火车进站

题意：

你有一个小站，车站最多能同时接纳三辆火车。先进的火车必须先出。允许同时有多辆火车进出站。

给定n<=100个火车的进出站时刻，不必一一接纳，求最多能接纳多少火车。

解：

由于是个DP，我一开始想的是把时间离散化之后按照时间来。

f[i][j][k][l]表示前i辆火车，三条轨道的最后时刻分别是jkl时的最大接纳量。

然后发现数组开不下...然后发现哪来三个轨道啊，只有一个......

然后发现网上居然有题解。

设f[i][j][k]表示车站内的顺序是k->j->i，i最先来。

然后枚举由j->i->p的情况转移过来。

记得判断当前状态是否合法。

#include <cstdio>
#include <algorithm>

const int N = 110;

int f[N][N][N];
std::pair<int, int> a[N];

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) {
        scanf("%d%d", &a[i].first, &a[i].second);
    }
    std::sort(a + 1, a + n + 1);
    int ans = 1;
    if(m == 1) {
        for(int i = 1; i <= n; i++) {
            f[i][0][0] = 1;
            for(int j = 1; j < i; j++) {
                if(a[j].second <= a[i].first) {
                    f[i][0][0] = std::max(f[i][0][0], f[j][0][0] + 1);
                }
            }
            ans = std::max(ans, f[i][0][0]);
        }
        printf("%d", ans);
        return 0;
    }
    if(m == 2) {
        for(int i = 1; i <= n; i++) {
            for(int j = i + 1; j <= n; j++) {
                if(a[i].second > a[j].second) {
                    continue;
                }
                f[i][j][0] = 2;
                for(int k = 1; k < i; k++) { /// j - i - k
                    if(a[k].second <= a[j].first) {
                        f[i][j][0] = std::max(f[i][j][0], f[k][i][0] + 1);
                    }
                }
                ans = std::max(ans, f[i][j][0]);
            }
        }
        printf("%d", ans);
        return 0;
    }
    for(int i = 1; i <= n; i++) {
        for(int j = i + 1; j <= n; j++) {
            if(a[i].second > a[j].second) {
                continue;
            }
            for(int k = j + 1; k <= n; k++) {
                if(a[j].second > a[k].second) {
                    continue;
                }
                f[i][j][k] = 3;
                for(int p = 1; p < i; p++) { // k - j - i - p
                    if(a[p].second <= a[k].first) {
                        f[i][j][k] = std::max(f[i][j][k], f[p][i][j] + 1);
                    }
                }
                ans = std::max(ans, f[i][j][k]);
            }
        }
    }
    printf("%d", ans);
    return 0;
}