POJ

 POJ - 3846 Mountain Road

题意：n个人要过桥，有的人从左边来，有的人从右边来，给你他们到达桥一端的时间和过桥所需要的时间，要求相向而行的只能有一人，对于每一个点，不能在10s内有同向而行的人经过。

思路：f[i][j][A/B] 表示 从左边走了i个，从右边走了j个，最后一个是左边还是右边的最小时间。问你最后一辆车的到达时间最小是多少。

　　对于每一个这样的状态，可以往后面一直推过了k辆反向的车所消耗的时间，只要把出发时间和到达时间的间距都压在10s以上就可以满足条件，不断的更新最优值就行了。

　　我之前写的时候对于每一个状态只知道推相邻的状态，这样导致转移的代码特别冗杂，最终答案也没有对，而且还超时了，所以这题来讲还是很遗憾没写出来，想到了状态，只是转移的时候犯了错误，没能过掉。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define LL long long
#define INF 0x3f3f3f3f
#define IN freopen("in.txt","r",stdin)
#define OUT freopen("out.txt", "w", stdout)
#define MAXN 100005
using namespace std;
#define A 0
#define B 1
struct Node{
    int x, y, pos;
};
int n;
int f[205][205][2];
Node a[205], b[205];
int a0, b0;
int main()
{
    //IN;
    //OUT;
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d
", &n);
        char ch;
        int x, y;
        a0 = 0;
        b0 = 0;
        //scanf("%c", &ch);
        for(int i = 1; i <= n; i++){
            scanf("%c", &ch);
            scanf("%d%d
", &x, &y);

            if(ch == 'A'){
                a0++;
                a[a0].x = x;
                a[a0].y = y;
                a[a0].pos = i;
            }
            else{
                b0++;
                b[b0].x = x;
                b[b0].y = y;
                b[b0].pos = i;
            }
        }
        int i = 0, j = 0;
        memset(f, INF, sizeof(f));
        f[0][0][A] = 0;
        f[0][0][B] = 0;
        int s, t;
        for(int i = 0; i <= a0; i++){
            for(int j = 0; j <= b0; j++){
                t = f[i][j][A] - 10;
                s = f[i][j][A] - 10;
                for(int k = j + 1; k <= b0; k++){
                    s = max(s + 10, b[k].x);
                    t = max(t + 10, s + b[k].y);
                    f[i][k][B] = min(f[i][k][B], t);
                }
                t = f[i][j][B] - 10;
                s = f[i][j][B] - 10;
                for(int k = i + 1; k <= a0; k++){
                    s = max(s + 10, a[k].x);
                    t = max(t + 10, s + a[k].y);
                    f[k][j][A] = min(f[k][j][A], t);
                }
            }
        }
        printf("%d
", min(f[a0][b0][A], f[a0][b0][B]));
    }
    return 0;
}