456. 车站分级

一条单向的铁路线上，依次有编号为 1, 2, …, n 的 nn 个火车站。

每个火车站都有一个级别，最低为 1 级。

现有若干趟车次在这条线路上行驶，每一趟都满足如下要求：如果这趟车次停靠了火车站 x，则始发站、终点站之间所有级别大于等于火车站 x 的都必须停靠。（注意：起始站和终点站自然也算作事先已知需要停靠的站点）

例如，下表是 5 趟车次的运行情况。

其中，前 4 趟车次均满足要求，而第 5 趟车次由于停靠了 3 号火车站（2 级）却未停靠途经的 6 号火车站（亦为 2 级）而不满足要求。

现有 m 趟车次的运行情况（全部满足要求），试推算这 n 个火车站至少分为几个不同的级别。

输入格式

第一行包含 2 个正整数n,m，用一个空格隔开。

第 i+1 行（1≤i≤m）中，首先是一个正整数si（2≤si≤n），表示第 i 趟车次有 si 个停靠站；接下来有 si 个正整数，表示所有停靠站的编号，从小到大排列。

每两个数之间用一个空格隔开。输入保证所有的车次都满足要求。

输出格式

输出只有一行，包含一个正整数，即 n 个火车站最少划分的级别数。

数据范围

1≤n,m≤1000

输入样例：

9 3 
4 1 3 5 6 
3 3 5 6 
3 1 5 9 

输出样例：

3

思路：

/*
题目描述：如果这趟车次停靠了火车站x，则始发站、终点站之间所有级别大于等于火车站x的都必须停靠

翻译过来：停靠过的车站的等级一定严格大于为停靠过的车站的等级，因此车站的等级均有严格的大小关系，则不存在环，因此可以用拓扑排序每个车站在图中的大小关系，使用动态规划求出车站等级最大的最小值(方法和 Acwing 1192奖金 类似)

在建边的时候，最坏情况下是有1000趟火车，每趟有1000个点，每趟上限有500个点停站，则有(1000 - 500)个点不停站，不停站的点都向停站的点连有向边，则总共有500 * 500 * 1000 = 2.5 * 10^8,则会超内存，如果用邻接矩阵存储，需要遍历所有的边，遍历的次数也是2.5 * 10^8，因此会超时，所以在每趟火车所有不停站的点向所有停站的点连有向边时，中间添加一个ver辅助结点，如下图连接方式

dist[i]：表示i点在拓扑图中离起点的最远距离(可能存在多起点)，dist[起点] == 1,边的权值为1
*/

代码:

#include <bits/stdc++.h>
using namespace std;
const int N = 2010, M = 1000010; // N 边数+站点数  M 车辆数*每辆车最多边数

int n, m;
int h[N], e[M], ne[M], w[M], idx;
int q[N], d[N];
int dist[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
    d[b]++;
}

void topsort()
{
    int hh = 0, tt = -1;
    for (int i = 1; i <= n + m; i++)
        if (!d[i])
            q[++tt] = i;

    while (hh <= tt)
    {
        int t = q[hh++];
        for (int i = h[t]; ~i; i = ne[i])
        {
            int j = e[i];
            if (--d[j] == 0)
                q[++tt] = j;
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);

    for (int i = 1; i <= m; i++)
    {
        memset(st, 0, sizeof st);
        int cnt;
        scanf("%d", &cnt);
        int start = n, end = 1;
        while (cnt--)
        {
            int stop;
            scanf("%d", &stop);
            start = min(start, stop);
            end = max(end, stop);
            st[stop] = true;
        }

        int ver = n + i;
        for (int j = start; j <= end; j++) // 存储边的优化
            if (!st[j])
                add(j, ver, 0);
            else
                add(ver, j, 1);
    }

    topsort();
    for (int i = 1; i <= n; i++)
        dist[i] = 1;

    for (int i = 0; i < n + m; i++) // 求最长路径
    {
        int j = q[i];
        for (int k = h[j]; ~k; k = ne[k])
            dist[e[k]] = max(dist[e[k]], dist[j] + w[k]);
    }

    int res = 0;
    for (int i = 1; i <= n; i++)
        res = max(res, dist[i]);

    printf("%d\n", res);

    return 0;
}