车站分级

拓扑排序 dp 全连接图虚拟节点优化 T4 P1983 [NOIP2013 普及组] 车站分级 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

一条单向的铁路线上，依次有编号为 $1,2,\dots ,n$的 $n$个火车站。每个火车站都有一个级别，最低为 $1$ 级。现有若干趟车次在这条线路上行驶，每一趟都满足如下要求：如果这趟车次停靠了火车站 $x$，则始发站、终点站之间所有级别大于等于火车站$x$ 的都必须停靠。（注意：起始站和终点站自然也算作事先已知需要停靠的站点）

例如，下表是$5$趟车次的运行情况。其中，前$4$ 趟车次均满足要求，而第 $5$ 趟车次由于停靠了 $3$ 号火车站（$2$ 级）却未停靠途经的 $6$ 号火车站（亦为 $2$ 级）而不满足要求。

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

输入格式

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

第 $i+1$ 行$(1\le i\le m)$中，首先是一个正整数 $s_i(2\le s_i\le n)$，表示第$i$ 趟车次有 $s_i$ 个停靠站；接下来有$s_i$个正整数，表示所有停靠站的编号，从小到大排列。每两个数之间用一个空格隔开。输入保证所有的车次都满足要求。

输出格式

一个正整数，即 $n$ 个火车站最少划分的级别数。

样例 #1

样例输入 #1

9 2 
4 1 3 5 6 
3 3 5 6

样例输出 #1

2

样例 #2

样例输入 #2

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

样例输出 #2

3

提示

对于$20\%$的数据，$1\le n,m\le 10$；

对于 $50\%$的数据，$1\le n,m\le 100$；

对于 $100\%$的数据，$1\le n,m\le 1000$。

思路

样例1 显然最低的级别数是2, 除非没有停靠站。停靠站的级别需要大于当前路径上其他无需停靠的站点 对于 1 3 5 6 这个车次, 每个停靠站的级别最小值 一定严格 大于 2 4 两个车站, 故可以像差分约数一样, a > b, 就从 b 连一条向 a 的边, 这里就这么连： 接近一个全连通图了, 遇到这种情况时就得考虑下会不会爆内存。 1000个车次, 假如都是从1到500车站, 那么就要要连 $1000\ast 1000\ast 500=5e8$ 条边, 如果是邻接表会超内存, 要是用邻接矩阵, 在枚举的时候也会爆时间。

对于这种全连接类的, 有一种优化技巧： 在两边中间设立一个虚拟点, 将本来要分别连过去的边连到该点上 这样就压缩了信息, 既可以保证从2点出发到达1356点的路径跟之前一样, 也降低了边数, 总共最多会有 $1000\ast (1000+500)$ 条边, 少了很多。

建完图之后就拓扑排序, DP求最长路即可。 总复杂度为 $O(N)$

代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <vector>
using namespace std;
const int N = 4100, M = 1e6;
int h[N], e[M], ne[M], idx, w[M];
int q[N];
int n, m;
int din[N], dist[N], res;
bool st[N];
 
void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
    din[b]++;
}
 
void topsort()
{
    int hh = 0, tt = -1;
    for (int i = 1; i <= n + m; i++)
        if (!din[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 (--din[j] == 0)
                q[++tt] = j;
        }
    }
}
 
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    memset(dist, 0, sizeof dist);
    for (int i = 1; i <= m; i++)
    {
        memset(st, 0, sizeof st);
        int cnt;
        cin >> cnt;
        int start = n, end = 1;
        while (cnt--)
        {
            int t;
            cin >> t;
            st[t] = true;
            start = min(t, start);
            end = max(t, end);
        }
 
        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]);
    }
 
    for (int i = 1; i <= n; i++)
        res = max(res, dist[i]);
    cout << res << endl;
    return 0;
}