luogu P1983 车站分级

题目描述

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

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

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

输入输出格式

输入格式：
输入文件为 level.in。

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

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

输出格式：
输出文件为 level.out。

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

输入输出样例

输入样例#1：
9 2
4 1 3 5 6
3 3 5 6
输出样例#1：
2
输入样例#2：
9 3
4 1 3 5 6
3 3 5 6
3 1 5 9
输出样例#2：
3
说明

对于 20%的数据，1 ≤ n, m ≤ 10；

对于 50%的数据，1 ≤ n, m ≤ 100；

对于 100%的数据，1 ≤ n, m ≤ 1000。

对拓扑排序有了新的理解：
拓扑用于解决什么问题？
可以说是用来解决“分配”（分级）的问题：给你一些信息，这些信息说明的是几个对象的大小或等级关系，按照等级关系建AOV网，拓扑序列就可以反映“分配关系”。
难点在于想到拓扑的模型及如何获取对象间的等级关系。

就本题来说，在一趟车中，停靠的车站必然要比不停靠的车站等级高（得到了等级关系），从停靠的车站引一条边纸箱不停靠的车站，拓扑排序就可以了，要求的是拓扑排序的层数或者说图中的最长边+1。
说起来容易做起来难。在构图的时候，如果枚举每个点，需要（n+m）^2次，复杂度会很高（TLE4个点）。可以只找出没有停靠的站，从停靠的站直接引边就好了，需要操作n*m次。

下面两种代码，除了一个用邻接矩阵，一个用邻接表之外，在topsort的实现方法上略有不同。

#include<cstdio>
#include<cstring>
using namespace std;

int n,m,top,num,total,ru[1001],a[1001][1001],zhan[1001];//a[x][i]:表示第x趟车停靠的第i个站；
bool matrix[1001][1001],b[1001];

void topsort()
{
    while (num<n)
    {
        total++;//while循环几次，就有几个等级 
        for (int i=1; i<=n; i++)
            if (ru[i]==0)
            {
                num++; zhan[++top]=i; ru[i]=0x7fffffff;
            }
        while (top>0)
        {
            int now=zhan[top--];
            for (int j=1; j<=n; j++)
                if (matrix[now][j]) ru[j]--;
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1; i<=m; i++)
    {
        int si;
        memset(b,false,sizeof(b));
        scanf("%d",&si);
        for (int j=1; j<=si; j++)
        {
            scanf("%d",&a[i][j]);
            b[a[i][j]]=1;
        }
        for (int j=a[i][1]; j<=a[i][si]; j++)
        {
            if (b[j]) continue;
            for (int k=1; k<=si; k++)
                if (!matrix[a[i][k]][j])
                { matrix[a[i][k]][j]=1; ru[j]++; }
        }

    }
    topsort();
    printf("%d",total);
    return 0;
}
/*
9 3 
4 1 3 5 6 
3 3 5 6 
3 1 5 9 

3

*/

another code

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int n,m,top,num,total,num_edge,maxlength,ru[1001],a[1001][1001],zhan[1001],head[1001],step[1001];//a[x][i]:表示第x趟车停靠的第i个站；
bool matrix[1001][1001],b[1001];
struct Edge{
    int next,to;
};
Edge edge[10000010];

void add_edge(int from,int to)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].to=to;
    head[from]=num_edge;
} 

void topsort()
{
    int tmp=1;
    for (int i=1; i<=n; i++)
        if (ru[i]==0) zhan[++top]=i;

    while (top<n)
    {
        int ss=0;
        for (int i=tmp; i<=top; i++)
        {
            int now=zhan[i];
            for (int j=head[now]; j!=0; j=edge[j].next)
            {
                ru[edge[j].to]--;
                if (ru[edge[j].to]==0)
                {
                    ss++;
                    zhan[top+ss]=edge[j].to;
                    step[edge[j].to]=step[now]+1;
                    maxlength=max(maxlength,step[edge[j].to]);
                }
            }
        }
        tmp=top+1;
        top+=ss;
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1; i<=m; i++)
    {
        int si;
        memset(b,false,sizeof(b));
        scanf("%d",&si);
        for (int j=1; j<=si; j++)
        {
            scanf("%d",&a[i][j]);
            b[a[i][j]]=1;
        }
        for (int j=a[i][1]; j<=a[i][si]; j++)
        {
            if (b[j]) continue;
            for (int k=1; k<=si; k++)
                if (!matrix[a[i][k]][j])
                { add_edge(a[i][k],j); matrix[a[i][k]][j]=1; ru[j]++; }
        }

    }
    topsort();
    printf("%d",maxlength+1);
    return 0;
}

我应该仔细比较两者之间的差异。