uva 12222(dp)

题意：有一条单行道，A、B两端都会有车要通过，现在给出n辆车，每个车出发地点、出发时间、通过这条道路的时间，问最后一辆车离开这条路的最小时间点。注意，相向而行的车不能同时在路上，而同向的车之间保证有10秒的差距，也就是路上的任意一点在10秒内只能经过一辆车。
题解：考虑到单行道两边都有车，那么可以从两端车的状态入手，f[i][j][k]表示A端前i辆车、B端前j辆车已离开后，此时再有车从k端进入的最小时间点。那么可以通过枚举从第i+1辆的A端的车连续通过(这样花费时间更短)更新所用最短时间，和从第j+1辆的B端的车连续通过更新所用最短时间,

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int N = 205;
const int INF = 0x3f3f3f3f;
struct Car {
    int t, d;
}A[N], B[N];
int n, f[N][N][2], cnt1, cnt2;
char str[5];

int main() {
    int cas;
    scanf("%d", &cas);
    while (cas--) {
        cnt1 = cnt2 = 1;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) {
            scanf("%s", str);
            if (str[0] == 'A') {
                scanf("%d%d", &A[cnt1].t, &A[cnt1].d);
                cnt1++;
            }
            else {
                scanf("%d%d", &B[cnt2].t, &B[cnt2].d);
                cnt2++;
            }
        }
        memset(f, INF, sizeof(f));
        f[0][0][0] = f[0][0][1] = 0;
        for (int i = 0; i < cnt1; i++) {
            for (int j = 0; j < cnt2; j++) {
                int s = f[i][j][0], e = 0;//A端有车进入
                for (int k = i + 1; k < cnt1; k++) {    
                    s = max(s, A[k].t);
                    e = max(e, s + A[k].d);
                    f[k][j][1] = min(f[k][j][1], e);//同时更新此时有车从B端进入的最小时间点
                    s += 10;//同一端连续进入有10秒间隔
                    e += 10;//开始和结束时间点同时右移
                }
                s = f[i][j][1], e = 0;//B端有车进入
                for (int k = j + 1; k < cnt2; k++) {
                    s = max(s, B[k].t);
                    e = max(e, s + B[k].d);
                    f[i][k][0] = min(f[i][k][0], e);
                    s += 10;
                    e += 10;
                }
            }
        }
        printf("%d\n", min(f[cnt1 - 1][cnt2 - 1][0], f[cnt1 - 1][cnt2 - 1][1]));
    }
    return 0;
}