NOIP 普及组 车站分级 [拓扑排序][线段树优化连边][虚点优化]

3294 车站分级

 

2013年NOIP全国联赛普及组

 时间限制: 1 s

 空间限制: 128000 KB

 题目等级 : 黄金 Gold

题解

题目描述 Description

一条单向的铁路线上，依次有编号为1, 2, …, n的n个火车站。每个火车站都有一个级别，最低为1级。现有若干趟车次在这条线路上行驶，每一趟都满足如下要求：如果这趟车次停靠了火车站x，则始发站、终点站之间所有级别大于等于火车站x的都必须停靠。（注意：起始站和终点站自然也算作事先已知需要停靠的站点）
例如，下表是5趟车次的运行情况。其中，前4趟车次均满足要求，而第5趟车次由于停靠了3号火车站（2级）却未停靠途经的6号火车站（亦为2级）而不满足要求。

 

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

输入描述 Input Description

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

输出描述 Output Description

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

样例输入 Sample Input

[Sample 1]
9 2
4 1 3 5 6
3 3 5 6
[Sample 2]
9 3
4 1 3 5 6
3 3 5 6
3 1 5 9

样例输出 Sample Output

[Sample 1]
2
[Sample 2]
3

数据范围及提示 Data Size & Hint

对于20%的数据，1 ≤ n, m ≤ 10；
对于50%的数据，1 ≤ n, m ≤ 100；
对于100%的数据，1 ≤ n, m ≤ 1000。

一道普及组的题做成这样我也是很无奈

考试考到了1e5的数据 看了想打人

首先 原先我们把每一个给定区间里未覆盖的点向覆盖的点两两连边

现在改为建立虚点x  未覆盖的点向x连边  x向覆盖的点连边

然后观察到覆盖点将区间割成了许多小段

想到线段树优化连边

建一棵线段树

叶子结点代表每一个车站

非叶子结点代表一个区间的车站

左右节点向父节点连边

每次连边查询区间 将代表该区间的节点与覆盖点连边

边数降到mlogn

目前洛谷上跑得最快  感觉还有优化的空间  懒得写了~

上代码

#include <bits/stdc++.h>
using namespace std;

const int N = 1500;

int head[N << 3], top, n, m, tp, stp[N], in[N << 3], arc[N];
bool nd[N << 3];

struct Node
{
    int y, nxt;
    Node() {    }
    Node( int y, int nxt ) : y(y), nxt(nxt) {    }
} e[N * 700];

void Adde( int x, int y )
{
//    printf( "x %d  y %d\n", x, y );
    in[y]++;
    e[++top] = Node(y, head[x]), head[x] = top;
}

#define ls (bt << 1)
#define rs (bt << 1 | 1)
void Build( int bt, int lf, int rg )
{
    tp = max(tp, bt);
    if(lf == rg)
    {
        arc[lf] = bt;
        nd[bt] = 1;
        return;
    }
    int mid = (lf + rg) >> 1;
    Adde(ls, bt);
    Build(ls, lf, mid);
    Adde(rs, bt);
    Build(rs, mid + 1, rg);
}

void Query( int bt, int lf, int rg, int L, int R, int tmp )
{
    if(L > R) return;
    if(L <= lf && rg <= R)
    {
        Adde(bt, tmp);
        return;
    }
    int mid = (lf + rg) >> 1;
    if(L <= mid) Query(ls, lf, mid, L, R, tmp);
    if(R > mid) Query(rs, mid + 1, rg, L, R, tmp);
}

int que[N << 5], h, t, dep[N << 3];

void Bfs()
{
    for(int i = 1; i <= tp; ++i)
        if(!in[i]) que[++t] = i, dep[i] = nd[i];
    while(h < t)
    {
        int u = que[++h];
        for(int i = head[u]; i; i = e[i].nxt)
        {
            int v = e[i].y;
            in[v]--;
            dep[v] = max(dep[u] + nd[v], dep[v]);
            if(in[v] == 0) que[++t] = v;
        }
    }
}

int main()
{
    cin >> n >> m;
    Build(1, 1, n);
    for(int i = 1, cnt; i <= m; ++i)
    {
        scanf( "%d", &cnt );
        ++tp;
        for(int j = 1; j <= cnt; ++j)
            scanf( "%d", &stp[j] );
        for(int j = 1; j < cnt; ++j)
        {
            Adde(tp, arc[stp[j]]);
            Query(1, 1, n, stp[j] + 1, stp[j + 1] - 1, tp);
        }
        Adde(tp, arc[stp[cnt]]);
    }
    Bfs();
    int ans = 0;
    for(int i = 1; i <= n; ++i)
        ans = max(ans, dep[arc[i]]);
    cout << ans << endl;
    return 0;
}