LuoGu 1983 浅谈如何【车站分级】即数据架构调整加强线段树优化时空复杂度转换

世界真的很大
这道题本来的原题基本上是一道做烂了的拓扑序水题
但是数据如果加到1e5呢？
虽说可以优化空间从nm到2*n，但是建边的时间nm是省不了的
详细讲讲线段树对于区间赋值问题的利用

看题先：

description：

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

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

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

input：

输入文件为 level.in。

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

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

output：

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

给出加强版的数据范围：

详细讲讲怎么从10分一步一步爬到100分吧

---

10分做法：

对于一趟车次，其选中的车的优先级我们很难比较，只知道他么应该有一个最小的，其余都比他大或者等于，这样模糊的条件
当题目发现一个思路进行下去所能得出的结论都很模糊的时候，且无法更加清晰，肯定要想到转化思路
不如从清晰的部分入手。
既然无法得知这一区间内被选中的所有车站的分级，但是有一点我们可以确认，那就是，没有没选中的车站的优先级一定没有被选中的等级高
这是显然的。那么就把这一段区间所有没有被选中的点和所有被选中的点连边。只要题目没有矛盾，那必然是一张DAG。
那么我们需要的就是这张DAG里的最长路，即拓扑序最大值就行了

看似十分优秀的做法其实不够优秀
这样的话建边的时间复杂度就是nm，空间复杂度也是nm。
对于5000的数据范围，建边很有可能达到25000000~
可惜啊~
从未见过10分的题解这么长

---

40分做法

就是10分做法的优化了
时间复杂度nm，因为拓扑序是O（m）的，就忽略了
在这个数据范围下还可以接受，但是空间就不得行了
需要优化的是空间
考虑对于每一趟车次，我们虚建一个额外的点，所有没被选上的点对虚点连边，虚点对所有被选上的点连边，然后再拓扑序的时候不考虑虚点。
这样结果是一样的但是建边的空间复杂度却能够被缩减到O（n）
非常之优秀

40分代码：

#include<stdio.h>
#include<queue>
#include<cstring>
using namespace std;

const int INF=0x3f3f3f3f;

struct edge
{
    int u,v,last;
}ed[4000010];

queue <int> state;

int n,m,ans=0,num=0,tot=0;
int src[200010],dis[200010],head[200010],in[200010];

void add(int u,int v)
{
    num++,in[v]++;
    ed[num].v=v;
    ed[num].last=head[u];
    head[u]=num;
}

void TOP()
{
    for(int i=1;i<=n+m;i++)
        if(!in[i])
        {
            state.push(i);
            if(i<=n) dis[i]=1;
            else dis[i]=0;
        } 
    while(!state.empty())
    {
        int u=state.front();
        state.pop();
        for(int i=head[u];i;i=ed[i].last)
        {
            int v=ed[i].v;//printf("%d %d\n",u,v);
            in[v]--;
            if(!in[v])
            {
                if(v<=n) dis[v]=max(dis[u]+1,dis[v]);
                else dis[v]=max(dis[v],dis[u]);
                state.push(v);
            }
        }
    }
}

int main()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int t,u,st=INF,ed=0;
        tot++;
        scanf("%d",&t);
        for(int k=1;k<=t;k++)
        {   
        //  printf("%d %d\n",i,j);
            scanf("%d",&u);
            st=min(st,u),ed=max(ed,u);
            add(n+i,u),src[u]=tot;
        }
    //  if(i==25) printf("%d %d %d\n",st,ed,t);
        for(int k=st;k<=ed;k++)
            if(src[k]!=tot) add(k,n+i);
    }
    TOP();
    for(int i=1;i<=n;i++)
        ans=max(ans,dis[i]);
//  for(int i=1;i<=n;i++)
//      if(dis[i]==17) printf("%d\n",i);
    printf("%d\n",ans);
    return 0;
}
/*
100 100
20 28 39 42 47 48 49 50 54 55 56 57 58 59 61 64 68 69 72 73 75
*/

---

100分做法

空间复杂度已经足够优秀了，不够优秀的是建边的时候的时间复杂度
讲道理怎么会有一道题的时间复杂度集中在预处理上的。。。
考虑我们建边的时候，是对一段连续的区间向一个点连边，挨个挨个连是我们这个算法的不够优秀的地方
但是如果想要直接连，或者说，一个区间一起连，能够想到的就是先把这个区间的所有点连向一个虚点，再由虚点连向这个虚点
这么安排这个预处理的预处理的虚点呢？

一段区间一起做什么事应该想到线段树
用线段树的每一个节点把其所有区间统一起来，连的时候就用log的时间直接连接一段区间就好
但是这样在线段树自己上面就会多连一些边，空间复杂度会变大，但也在可以接受的范围内
正所谓“空间换时间”
完整AC代码：

#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;

struct edge
{
    int v,last;
}ed[8000010];

queue <int> state ;

struct node
{
    int id;
    node *ls, *rs;
}pool[8000010],*tail=pool,*root;

int n,m,num=0,tot=0,ans=0;
int head[400010],tmp[400010],mrk[400010],rev[400010],dis[400010],in[400010];

void add(int u,int v)
{
    num++,in[v]++;
    ed[num].v=v;
    ed[num].last=head[u];
    head[u]=num;
}

node *build(int lf,int rg)
{
    node* nd=++tail;
    nd->id=++tot;
    if(lf==rg)
    {
        rev[lf]=nd->id,mrk[nd->id]=1;
        nd->ls=nd->rs=0;
        return nd;
    }
    int mid=(lf+rg)>>1;
    nd->ls=build(lf,mid);
    nd->rs=build(mid+1,rg);
    add(nd->ls->id,nd->id);
    add(nd->rs->id,nd->id);
    return nd;
}

void modify(node *nd,int lf,int rg,int L,int R,int tar)
{
    if(L<=lf && rg<=R)
    {
        add(nd->id,tar);
        return ;
    }
    int mid=(lf+rg)>>1;
    if(L<=mid) modify(nd->ls,lf,mid,L,R,tar);
    if(R>mid) modify(nd->rs,mid+1,rg,L,R,tar);
}

void TOP()
{
    for(int i=1;i<=tot+m;i++)
        if(!in[i])
        {
            state.push(i);
            if(mrk[i]) dis[i]=1;
            else dis[i]=0;
        }
    while(!state.empty())
    {
        int u=state.front();
        state.pop();
        for(int i=head[u];i;i=ed[i].last)
        {
            int v=ed[i].v;
            in[v]--;
            if(!in[v])
            {
                if(mrk[v]) dis[v]=max(dis[v],dis[u]+1);
                else dis[v]=max(dis[v],dis[u]);
                state.push(v);
            }
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    root=build(1,n);
    for(int i=1;i<=m;i++)
    {
        int t;
        scanf("%d",&t);
        for(int k=1;k<=t;k++)
            scanf("%d",&tmp[k]),add(tot+i,rev[tmp[k]]);
        for(int k=2;k<=t;k++)
        {
            int R=tmp[k]-1,L=tmp[k-1]+1;
            if(L<=R) modify(root,1,n,L,R,tot+i);
        }
    }
    TOP();
    for(int i=1;i<=n;i++)
        ans=max(ans,dis[i]);
    printf("%d\n",ans);
    return 0;
}
/*
9 2 
4 1 3 5 6 
3 3 5 6 
*/

嗯，就是这样