比赛那天感冒，第一题就弄晕了，现在题解出来了，补上吧~~

暂时只有第一题的：

Problem 6: Bobsledding [Brian Jacokes, 2009]

Bessie has entered a bobsled competition because she hopes her hefty
weight will give her an advantage over the L meter course (2 <= L
<= 1,000,000,000).

Bessie will push off the starting line at 1 meter per second, but
her speed can change while she rides along the course. Near the
middle of every meter Bessie travels, she can change her speed
either by using gravity to accelerate by one meter per second or
by braking to stay at the same speed or decrease her speed by one
meter per second.

Naturally, Bessie must negotiate N (1 <= N <= 100,000) turns on the
way down the hill. Turn i is located T_i meters from the course
start (1 <= T_i <= L-1), and she must be enter the corner meter at
a speed of at most S_i meters per second (1 <= S_i <= 1,000,000,000).
Bessie can cross the finish line at any speed she likes.

Help Bessie learn the fastest speed she can attain without exceeding
the speed limits on the turns.

Consider this course with the meter markers as integers and the
turn speed limits in brackets (e.g., '[3]'):

|   1   2   3   4   5   6   7[3]
|---+---+---+---+---+---+---+
|                            \
Start                         + 8    
                               \
                                + 9    
                                 \
                                  + 10       +++ 14 (finish)
                                   \         /
                              11[1] +---+---+
                                        12  13[8]

Below is a chart of Bessie's speeds at the beginning of each meter length
of the course:

Max:                              3               1       8
Mtrs: 0   1   2   3   4   5   6   7   8   9  10  11  12  13  14 
Spd:  1   2   3   4   5   5   4   3   4   3   2   1   2   3   4

Her maximum speed was 5 near the beginning of meter 4.

PROBLEM NAME: bobsled

INPUT FORMAT:

* Line 1: Two space-separated integers: L and N

* Lines 2..N+1: Line i+1 describes turn i with two space-separated
        integers: T_i and S_i

SAMPLE INPUT (file bobsled.in):

14 3
7 3
11 1
13 8

OUTPUT FORMAT:

* Line 1: A single integer, representing the maximum speed which
        Bessie can attain between the start and the finish line,
        inclusive.

SAMPLE OUTPUT (file bobsled.out):

5

题目看起来挺复杂，其实主要是求出各个turn处的最大速度，分析得到每个turn的最大速度需要满足三个条件， M_i = min (S_i , t_i – t_{i-1} + M_{i-1} , S_k + t_k – t_i [for all k > i ] )

因此处理每一个turn都要查询N个turn N*N的复杂度显然对于大数据要TLE的

逆向思考，如果我们反过来考虑，对于每一个之后的turn来说 如：i  如果他最大速度为 m_i

那么 在turn i-1处，他不能超过的最大速度 m_{i-1} = min(S_i,m_i+t_i – t_{i-1});这样成功的把后面两个限制转换为逆推的结果而不是向后查询

剩下的问题便是如果知道两个turn之间距离，以及turn的速度最大值，如何求出之间的最大值，画图显然可以得到一种算式 maxspeed = min(s1,s2) + (dist2-dist1+abs(s1-s2))/2;

或者 maxspeed = max(s1,s2) + (dist2 – dist1 – abs(s1-s2))/2;

注意在开头和结尾加入虚拟的turn就可以了

今天题解出来了~ 先看了大概思路 然后自己写出来了~

题目：

Farmer John's cows like to play coin games so FJ has invented with
a new two-player coin game called Xoinc for them.

Initially a stack of N (5 <= N <= 2,000) coins sits on the ground;
coin i from the top has integer value C_i (1 <= C_i <= 100,000).

The first player starts the game by taking the top one or two coins
(C_1 and maybe C_2) from the stack. If the first player takes just
the top coin, the second player may take the following one or two
coins in the next turn. If the first player takes two coins then
the second player may take the top one, two, three or four coins
from the stack. In each turn, the current player must take at least
one coin and at most two times the amount of coins last taken by
the opposing player. The game is over when there are no more coins
to take.

Afterwards, they can use the value of the coins they have taken
from the stack to buy treats from FJ, so naturally, their purpose
in the game is to maximize the total value of the coins they take.
Assuming the second player plays optimally to maximize his own
winnings, what is the highest total value that the first player can
have when the game is over?

MEMORY LIMIT: 20 MB

PROBLEM NAME: xoinc

INPUT FORMAT:

* Line 1: A single integer: N

* Lines 2..N+1: Line i+1 contains a single integer: C_i

SAMPLE INPUT (file xoinc.in):

5
1
3
1
7
2

简单来说就是两个人轮流取coins，每个人每次取得个数为1- 2*n;n为上一轮对方取得数目，

求两个人都是用最佳策略，先取得那个家伙最多能拿到多少硬币。貌似可以算是简单博弈论的思想

思路：

        coins[1···N] 从下到上 sum[1···N] 剩下 i个的和

        找到无后效性的子问题。考虑在还剩下p个钱币时候的情况，此时可以拿k个钱

由于条件，k的大小受上一轮拿的个数i的限制 ，所以我们要加上一个变量i。得到

dp[p][i]这个子问题。那么容易得到

dp[p][i]=max(1=<k<=i*2){SuM(p to p-k+1)+SuM(p-k to 1)-dp[p-k][k]}

            =max(1=<k<=i*2){sum[p]-dp[p-k][k]}

按照这个可以得到一个O（N^3）的算法

oidsolve(){
   for(inti=1;i<=N;i++)//剩下i个
        for(intj=1;j<=N;j++)//上一人拿了j 个
            for(intk=1;k<=j*2&&i-k>=0;k++){
                dp[i][j]=max(dp[i][j],sum[1]-sum[i+1]-dp[i-k][k]);
            }
    ret=dp[N][1];
}

 三重递归 ，最多可以过500的数据量  观察可以得出 dp[p][j] 和 dp[p][j+1] 的计算有很多的重叠
因为 上次拿了j+1 则可以比 dp[p][j] 多拿 2 个 

然后，由于考虑j的范围 应该为 N-i+1

这样得到了最终代码：

    scanf("%d",&N); 
    for(int i=1;i<=N;i++)    scanf("%d",coins+i);//{fin>>coins[i]; }
    sum[0]=0;
    for(int i=1;i<=N;i++)     sum[i]=sum[i-1]+coins[N-i+1];  
    for(int i=1;i<=N;i++)        //剩?下?i 个?
    for(int j=1;j<= N-i +1;j++){ // 上?次?拿?了?j 个?
    if(dp[i][j]<dp[i][j-1])dp[i][j]=dp[i][j-1];
    if(2*j-1<=i&&dp[i][j]<sum[i]-dp[i-2*j+1][2*j-1]) dp[i][j]=sum[i]-dp[i-2*j+1][2*j-1];
    if(2*j<=i&&dp[i][j]<sum[i]-dp[i-2*j][2*j]) dp[i][j]= sum[i]-dp[i-2*j][2*j];
    } 
    printf("%d\n",dp[N][1]);

很晚了 ，先写这么多 ，有空把bronze的写了