《入殓师》
 《星际迷航》
2分 （相当不错，仍可挖掘）
《霍顿与无名氏》（Disney）
《Lost》(Series)
《Prison Break》(Series)
《返老还童》
《Friends I》(Series)
《王牌对王牌》
《暗流》
《狙击电话亭》
《偷天换日》
《灵异第六感》
《达芬奇密码》
《鲁迪传奇》
《十一罗汉》
《破绽》
《朱诺》
《搏击俱乐部》
《捉迷藏》
 《南京！南京！》
 
1分 （表现突出，同时缺点很多很明显）
《潘神的迷宫》
《惊变28周》
《stay》
《非常嫌疑犯》
《The Hills Have Eyes 》 《隔山有眼》
《笨贼妙探》
《明星狗》
《蝙蝠侠前传2：暗夜骑士》
《贫民窟的百万富翁》
《牛津谋杀案》
《杀手没有假期》
《总统千金欧游记》
 《赛车风云》
《正当杀人》
《翻译风波》
《七磅》
《关键投票》
《无间道风云》
《洛城机密》
《人骨拼图》
《灵异拼图》
 
0分 （普普通通，没什么出彩的地方）
《恐怖异形入侵》
《海角七号》
《逃出改造岛》
《Two and half Man》(Series)
《硅谷传奇》
《冒牌天神》
《加勒比海盗II》
 
-1分 （纯粹浪费时间）
《投名状》
《机器人侵犯地球》
《灾难大电影》
《星河战队》(Series)
《阳光小美女》

-- 记ACM国际大学生程序设计竞赛

国防科大 欧阳君沛 alpc12 四城

ACM,梦中的太阳

   大家好，我是一名ACMer。

大家好，我真的很荣幸，能和你一起参加这场ACM盛会。

空旷的赛场上空，彩色的气球骄傲着飘起在凝静的空气中。看台上无数期待的双眼穿越长长的ACM横幅，一次再一次地贴近赛场上的ACM选手们。激动的红地毯将整个赛场淹没，印向主席台嘉宾们飞扬的微笑。我坐在那最中央，双手紧紧抓着键盘，那祈愿的目光，那痴痴的眼神，直要融化掉冰块般的雪白计算机屏幕。

那一刻，时间停止了。曾经的梦倾涌而来。一个小小的男孩，傻傻的坐在地平线上，等待着无垠的黑夜的第一道阳光，第一道温暖。太阳太阳，你快来吧，我们一起照亮这个世界，照亮无数热爱生命的人们。

ACM,难以述说的情怀

我是一名ACM竞赛的教练。

在看台上听着比赛开始的那一瞬间，我却突然觉得自己也是一名参赛选手。我的目光在我的队员们身上游走，一个一个，都那么亲切，回忆不断涌上心头。

小旭，你永远都是个孩子。当你提交的程序在期待许久后成功通过的时候，你嘴角那天真的笑容，像小朋友收集到了最后一张小浣熊卡片一样可爱。

豆豆，当我看着你强忍着泪水走出赛场，安慰自己说ACM is just a Game的时候，我多想拍拍你的肩膀，告诉你，其实ACM不只是个游戏，因为我们每个人都是赢家。

城城，只要一提起ACM，你总有无数要说的话题，一会儿激动不已，一会儿神采飞扬，眼睛里却永远闪烁着幸福的星光，我多想告诉你，我们在一起奋斗的时光我是多么的开心。

。。。。。。

突然眼前变得模糊，你知道吗，我也曾是一名ACM队员，叫我离开这个赛场我怎么舍得。

小A，好想亲亲你

亲爱的小A，我真的不敢相信，我怎么就喜欢上你了。

大家都说你是一个魅力无穷的女孩，就像艺术一般奇妙而美丽，和你在一起会那么开心那么幸福。

可是我一个小女生，我怎么也喜欢上你啦。

其实我知道，你是个大男孩，因为你身上有数不尽的谜团，你还会表演各种各样的魔术，你知道把，你已经把我深深地吸引住了。

  我这个爱玩却什么都不懂的女孩，却在ACM的世界里面，像一条鱼一样在晶蓝色的大海里畅游着。每天阳光透过水面折射进来，那么漂亮，那么令我沉醉。我才发现我再也离不开大海了，大海是我的家。

今晚我要抱着我的小熊睡觉。我给小熊取了个名字，用蓝色的彩笔写在它的掌心，“小A”。小熊，明天就要比赛了，不要害怕，不要担心，明天我要拿到我的那个AC，我的那个气球，送给你，好吗？

写在最后

2008，那么舍不得地离开。

祝福alpc大家庭越来越棒，越来越幸福！

感谢所有的ACMers为大家带来的感人故事！

1 清华大学 What's up? 7 金 
2 清华大学 IronGods  7 金 
3 复旦大学 HugeHydralisk 7 金 
4 天津大学 TJU_HanoiTower 6 金 
5 浙江大学 Sirius 6 金 
6 武汉大学 ChaeYeon 6 金 
7 浙江大学 Genesis 6 金 
8 中山大学 ZSU_Remiel 6 金 
9 北京交通大学 BJTU_ImBa 6 金 
10 复旦大学 Butcher 6 金 
11 复旦大学 HeavenHell 6 金 
12 华中科技大学 hustruggle 5 银 
13 武汉大学 Slash 5 银 
14 清华大学 Traveller 5 银 
15 同济大学 FamilyAllHandsRush 5 银 
16 吉林大学 supernova 5 银 
17 中山大学 ZSU_Rapheal 5 银 
18 北京大学 montage 5 银 
19 大连理工大学软件学院 VIPers 5 银 
20 北京大学 AcmTeam08 5 银 
21 北京大学 CrazyAC 5 银 
22 华中科技大学 salute 5 银 
23 中山大学 ZSU_Gabriel 4 银 
24 国防科技大学 Refugee 4 银 
25 福州大学 ACFighters 4 银 
26 哈尔滨工程大学 HRB-team0 4 银 
27 北京理工大学 Bit-bear 4 银 
28 北京交通大学 BJTU_Action 4 银 
29 北京邮电大学 Sapphire 4 银 
30 北京航空航天大学 DDR3 4 银 
31 哈尔滨工业大学 Aaron 4 银 
32 福州大学 Sakyamuni 4 银 
33 浙江大学 gdb 4 银 
34 北京邮电大学 EagleHustle 4 银 
35 西安电子科技大学 CET-6 4 铜 
36 国防科技大学 Nirvana 4 铜 
37 东北林业大学 tiger 4 铜 
38 西安交通大学 xjtuzlz 4 铜 
39 北京化工大学 Bucteam_NoRP 4 铜 
40 浙江理工大学 skyrocket 4 铜 
41 杭州电子科技大学 HDU_microant 4 铜 
42 中国地质大学 newHope 4 铜 
43 厦门大学 XMU_HCP 4 铜 
44 宁波大学 JustDoIt 3 铜 
45 电子科技大学 Knight 3 铜 
46 湖南大学 sword 3 铜 
47 北京师范大学 GREEDY 3 铜 
48 山东大学 Kakport 3 铜 
49 大连理工大学创新学院 Newbie 3 铜 
50 北京师范大学珠海分校 BNUEP_int_ijk 3 铜 
51 浙江大学城市学院 SuperZucc 3 铜 
52 浙江工业大学 Cheers 3 铜 
53 南开大学 Falco 3 铜 
54 哈尔滨工业大学 Martians 3 铜 
55 五邑大学 WYU_Fantasy 3 铜 
56 东北大学 zephyr 3 铜 
57 新加坡 KZ-NTU 3 铜 
58 广州大学 GoodGoodStudy 3 铜 
59 中国人民大学 Kingbase 3 铜 
60 吉林大学 supergiant 3 铜 
61 上海师范大学 Tinman1 3 铜 
62 东北师范大学软件学院 NENUSoftware_Golde 3 铜 
63 日本会津大学 WATCH.C 3 铜 
64 电子科技大学 Bishop 3 铜 
65 华东师范大学 Kop 3 铜 
66 杭州电子科技大学 HDU_Fantasy 3 铜 
67 浙江师范大学 KartRider 3 铜 
68 天津大学 TJU_Buddha 3 铜 
69 北华大学 Beihua_Sailing 3 铜 

用搜索做，超时，郁闷。

正解：动态规划。

DP状态：dp[mask][i], mask代表用了多少种方案了，i代表前6种方案的得分。

因为前6种方式得分和超过63有加分，因此这一维是必须的。

DP向后推比较好写。

核心代码：

By oyjpArt/alpc12

题意

n    有2个仓库，容量为(0 <= V <= 5000) 浮点数！

n    有100个物品，每个物品容量为(0 <= v[i] <= 100) 整数 价值为 m[i] (无范围浮点数！)

n    现在把这些物品放到2个仓库中，求最大的价值。

n    如果有放不进去的物品，可以切割出一部分放进去，但是一旦切割，没放进进去的一部分必须丢弃。

贪心？

n    这道题初看上去，很有让人贪心的冲动。

n    我和alpc42合计了一下。

n    根据A[i].m/A[i].v 作为优先级 给(A, A+n) 排序。

n    依次将A[0], A[1]…A[n-1]放入仓库，如果放不进去了，则切掉。

n    现在有两个仓库，当准备放一个物品进去的时候，应该放到哪个仓库呢？

第一次提交

n    我们俩想了想，觉得应该是放到空闲地方大的仓库，因为要尽可能把性价比高的物品放进去。

n    4144542008-08-01 13:42:41

n    WrongAnswer

n    C++

n    0.9K

第二次提交

n    随后我想出了一种会让程序出bug的情况。

n    就是当两个物品性价比相当的时候，应该要让大容量的在前面。因为有可能小容量的先放进去，导致大容量的没有地方放了，而需要切割。但实际上可以把小容量的放到小剩余容量的仓库里面去，而大容量的就可以放到大剩余容量的仓库.

n    改正提交之后还是Wrong Answer

问题在这

n     思考了一下我发现其实上面那个bug并没有解决。假设A[i].m/A[i].v > A[j].m/A[j].v，按理来说应该先放i，再放j。但是加入A[i].v < A[j].v,同样的有可能先放i再放j会让j被迫切割。

n     那么怎么办？

n     随后我们想到了一种动态规划的方法，但是因为复杂度太高，放弃了。这时候我们发现手头有很多题目可以做，就没有再做这个题目了。

赛后的思考

n      之所以会出现这样的问题。在于我们最开始的假设：要把性价比高的物品放到容量更大的仓库中。

n      那么，假如我们枚举一个物品放到A仓库还是B仓库的话，就可以解决这个问题了。

n      所谓枚举，其实是一个动态规划。

n      设dp[i][j] 代表前i个物品(排序后)都被完全放入了仓库，并且A仓库已经装了j的容量的物品。显然我们可以同时知道B仓库的容量是多少。

n      向后推的状态方程

n      dp[i+1][j+A[i+1].v] = Max(dp[i+1][j+A[i+1].v], dp[i][j] + A[i+1].m);

n      dp[i+1][j] = Max(dp[i+1][j], dp[i][j] + A[i+1].m);

n      如果一个仓库已经放不进去了，大家可以想想，应该是把下一个物品切割掉放入这个仓库中。（如果后面有物品可以放到另外一个仓库中，不用担心。后面的DP会覆盖这种情况）

n      一个仓库放满了之后，另外一个仓库堆放的情况其实就是贪心了。

Description

The cows are journeying north to in to gain cultural enrichment and enjoy a vacation on the sunny shores of Lake Superior. Bessie, ever the competent travel agent, has named the Bullmoose Hotel on famed Cumberland Street as their vacation residence. This immense hotel has N (1 ≤ N ≤ 50,000) rooms all located on the same side of an extremely long hallway (all the better to see the lake, of course).

The cows and other visitors arrive in groups of size D_i (1 ≤ D_i ≤ N) and approach the front desk to check in. Each group i requests a set of D_i contiguous rooms from Canmuu, the moose staffing the counter. He assigns them some set of consecutive room numbers r..r+D_i-1 if they are available or, if no contiguous set of rooms is available, politely suggests alternate lodging. Canmuu always chooses the value of r to be the smallest possible.

Visitors also depart the hotel from groups of contiguous rooms. Checkout i has the parameters X_i and D_i which specify the vacating of rooms X_i ..X_i +D_i-1 (1 ≤ X_i ≤ N-D_i+1). Some (or all) of those rooms might be empty before the checkout.

Your job is to assist Canmuu by processing M (1 ≤ M < 50,000) checkin/checkout requests. The hotel is initially unoccupied.

Input

* Line 1: Two space-separated integers: N and M
* Lines 2..M+1: Line i+1 contains request expressed as one of two possible formats: (a) Two space separated integers representing a check-in request: 1 and D_i (b) Three space-separated integers representing a check-out: 2, X_i, and D_i

Output

* Lines 1.....: For each check-in request, output a single line with a single integer r, the first room in the contiguous sequence of rooms to be occupied. If the request cannot be satisfied, output 0.

Sample Input

10 6

1 3

1 3

1 3

1 3

2 5 5

1 6

Sample Output

1

4

7

0

5

Source

USACO 2008 February Gold

这是一个线段树的题目：

1.     题意建模：

关键点：找出最靠左的一个长度至少为K的线段可以用线段树来做。

对任意一个线段树中的节点(x,y) 维护3个信息：

1.     (x, y) 中最长的线段的长度

2.     x点开始向右的线段长度

3.     y点开始向左的线段长度

题目要求我们对一个(0, 50000)长的区间做以下操作：

A.   对任意区间 (x, y) 使 F(x, y) = 0

B.   对任意区间 (x, y) 使 F(x, y) = 1

C.   查询任意一个区间 (x, y) 中最长的线段的长度，

D.   维护每个节点的3种信息

2.难点解析：

      1.实现A, B 操作：

要把某个节点覆盖为0，或者1，不需要向下扩展。只有在需要查询到儿子区间的状态的时候才需要扩展（参考spread函数）

2.实现D的维护：

每次改变了左右儿子区间的信息的时候，就需要更新当前节点的信息(参考update函数)

3.代码实现：

#include <stdio.h>

#define Max(a, b) ((a)>(b)?(a):(b))

const int N = 50010;

struct ST {int i,j,m,l,r,c,lc,rc;} st[2*N]; //区间宽度的2倍

int up, n;

void bd(int d, int x, int y) {

      st[d].i = x, st[d].j = y, st[d].m = (x+y)/2;

      st[d].c = st[d].lc = st[d].rc = y-x;

      if(x < y-1) {

           st[d].l = ++up; bd(up, x, st[d].m);

           st[d].r = ++up; bd(up, st[d].m, y);

      }

}

void spread(int d) {

      if(st[d].c == st[d].j-st[d].i) {

           int& l = st[d].l, &r = st[d].r;

           st[l].c = st[l].lc = st[l].rc = st[l].j-st[l].i;

           st[r].c = st[r].lc = st[r].rc = st[r].j-st[r].i;

      } else if(st[d].c == 0) {

           int& l = st[d].l, &r = st[d].r;

           st[l].c = st[l].lc = st[l].rc = 0;

           st[r].c = st[r].lc = st[r].rc = 0;

      }

}

void update(int d) {

      st[d].c = Max(Max(st[st[d].l].c, st[st[d].r].c), st[st[d].l].rc + st[st[d].r].lc);

      if(st[st[d].l].c == st[st[d].l].j-st[st[d].l].i) {

           st[d].lc = st[st[d].l].c + st[st[d].r].lc;

      } else st[d].lc = st[st[d].l].lc;

      if(st[st[d].r].rc == st[st[d].r].j-st[st[d].r].i) {

           st[d].rc = st[st[d].r].rc + st[st[d].l].rc;

      } else st[d].rc = st[st[d].r].rc;

}

void Empty(int d, int x, int y) {

      if(x <= st[d].i && y >= st[d].j) {

           st[d].c = st[d].lc = st[d].rc = 0;

           return;

      }

      spread(d);

      if(x < st[d].m) Empty(st[d].l, x, y);

      if(y > st[d].m) Empty(st[d].r, x, y);

      update(d);

}

void Fill(int d, int x, int y) {

      if(x <= st[d].i && y >= st[d].j) {

           st[d].c = st[d].lc = st[d].rc = st[d].j-st[d].i;

           return;

      }

      spread(d);

      if(x < st[d].m) Fill(st[d].l, x, y);

      if(y > st[d].m) Fill(st[d].r, x, y);

      update(d);

}

int Get(int d, int l) {

      spread(d);

      if(st[d].c < l) return -1;

      if(st[st[d].l].c >= l)

           return Get(st[d].l, l);

      else if(st[st[d].l].rc + st[st[d].r].lc >= l) {

           return st[st[d].l].j-st[st[d].l].rc;

      }

      return Get(st[d].r, l);

}

int main()

{

      int i, nq, cmd, x, l, y;

      up = 0;

      scanf("%d%d", &n, &nq);

      bd(0, 0, n);

      while(nq--) {

           scanf("%d", &cmd);

           if(cmd == 1) {

                 scanf("%d", &l);

                 x = Get(0, l);

                 if(x != -1)

                      Empty(0, x, x+l);

                 printf("%d\n", x+1);

           } else {

                 scanf("%d%d", &x, &l);

                 Fill(0, x-1, x+l-1);

           }

      }

      return 0;

}

Problem Statement

Definition

Constraints

Examples

{
"1 1 1",
"1 1 1"
}

Returns: 6

{
"1 -1",
"1 -1"
}

Returns: 2

{
"1 -1 -1 1",
"-1 -1 -1 -1",
"-1 -1 -1 -1",
"1 -1 -1 1"
}

Returns: 4

{
"20 13 -2 100",
"-12 0 4 -3",
"4 1 -36 21"
}

Returns: 131

{
"0"
}

Returns: 0

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

很多大牛fail了，我一个DFS+剪枝也超时了，一共32人pass sys test，1000pts无人ac，此套题难度还是很大的。

基本思路是状态压缩DP，横向(1<<12)*纵向(1<<12)*加和。

但是这样会超时。关键是没有利用到折叠的信息。

预先生成某个位置的状态（由那些位置叠加而来），就可以减少检查量，就可以ac了。

上次百度之星第三题竟然不会做，很是惭愧啊，脑袋生锈了。

The perfect hamilton path

Description

There are N(2 <= N <= 13) cities and M bidirectional roads among the cities. There exist at most one road between any pair of the cities. Along every road, there are G pretty girls and B pretty boys(1 <= G,B <= 1000).
You want to visit every city exactly once, and you can start from any city you want to. The degree of satisfaction is the ratio of the number of the pretty girls to the number of the pretty boys. You want to know the highest degree of satisfation.

Input

There are multiply test cases.
First line: two integers N, M;
The following M lines: every line with four integers i, j, G, B, response that there is a road between i and j with G and B.

Output

The highest degree of the satisfation, rounded to the third place after the decimal point.

Sample Input

3 3
1 2 5 3
2 3 7 4
3 1 13 11

Sample Output

1.714

HINT

Source

dupeng

Solution：

Problem Statement

Particles (which can be considered points in 3D-space for the purposes of the problem) can move in an electro-magnetic field. If a particle is charged, its trajectory can be described as spiral, and if it is uncharged, it is just a straight line. Given two particles (one charged and one uncharged) it should be determined whether they can possibly collide or not. Two particles can possibly collide if and only if their trajectories intersect.

Some steps have already been made by the physicist to simplify the problem, so the coordinates of the charged particle are represented as follows:

x1 = cos(PI * t)

y1 = sin(PI * t)

z1 = t

and for the uncharged particle:

x2 = vx * t + x0

y2 = vy * t + y0

z2 = vz * t + z0

Here t is a parameter which can be chosen arbitrarily and independently for both trajectories.

Your method will be given 6 integers - vx, vy, vz, x0, y0 and z0, describing the trajectory of the uncharged particle. It should determine whether the two given trajectories intersect or not. If they do, it should return a vector <double> containing exactly 3 elements x, y and z - the coordinates of the point where a collision can happen. If there is more than one such point, it should return a vector <double> containing exactly three zeroes. If collision of the two particles is impossible it should return an empty vector <double>.

Definition

Notes

Constraints

Examples

0

0

0

0

0

0

Returns: { }

2

4

1

-1

-1

0

Returns: {0.0, 1.0, 0.5 }

4

4

2

5

4

0

Returns: {0.0, 0.0, 0.0 }

0

0

1

1

0

0

Returns: {0.0, 0.0, 0.0 }

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

Description

Input

Output

Sample Input

1
5
1 2 11
1 4 13
3 4 5
4 5 10

Sample Output

26

Source