[SMOJ1830]小岛

题目描述

有 $N$ 个城市，编号 1 至 $N$，农夫 FJ 为这 $N$ 个城市共设计了 $M$ 条单向飞机航班。
如果存在两个不同的城市 $a$ 和 $b$，使得城市 $a$无论如何也无法到达城市 $b$（即使转机也不能到达$b$），而且城市 $b$ 无论如何也无法到达城市 $a$（即使转机也不能到达$a$），
那么我们认为 FJ 设计的这 $M$ 条飞机航班是不合理的，输出”No”，否则输出“Yes”。

输入格式 1830.in

多组测试数据。
第一行，一个整数 $R$ ，表示有 $R$ 组测试数据。
每组测试数据格式：
第一行，两个整数，$N$ 和 $M$。 $1\leq N\leq50000$， $1 \leq M \leq 60000$。
接下来有 $M$ 行，每行两个整数: $a$ 和 $b$，表示城市 $a$ 有一条单向航班飞向城市 $b$。

输出格式 1830.out

共 $R$ 行，每行输出Yes或者No。

输入样例 1830.in

1
3 3
1 2
2 3
3 1

输出样例 1830.out

Yes

---

题意：有 $n$ 个结点和 $m$ 条有向边，判断是否存在两个点 $u$ 和 $v$，满足 $u$ 无法到达 $v$ 且 $v$ 无法到达 $u$。事实上，就是判断图是否弱连通。

如果题目条件是“$u$ 无法到达 $v$ 或者 $v$ 无法到达 $u$”，那么显然只要判断整个图是否为一个强连通分量即可。但是这样做是错的，很容易举出反例。
但是，显然缩点这一步并不是没有用的。缩点后同一强连通分量内的点肯定互相可达，因此只需要判断强连通分量之间是否可达就可以了。

我们不妨这样来思考：把缩点后得到的 DAG 中结点编号为 1~$n$，按编号从小到大顺次排成一行，容易发现：每条边一定是从编号小的往编号大的方向连，绝对不可能倒着。请重视这个性质，这是解决本题的关键。

那么，我们考虑第 $n-1$ 个点和第 $n$ 个点。如果它们之间不连通，则整个图就是根本不合法的。想要使他们连通，只有一种可能，就是存在一条从 $n - 1$ 连到 $n$ 的有向边。不可能往前连再连回来，这不符合我们上面得出的性质。
同理，对于第 $n-2$ 个点和第 $n-1$ 个点，要使它们连通，必须存在一条从 $n - 2$ 连到 $n - 1$ 的有向边…………对于第 1 个点和第 2 个点，必须存在从 1 到 2 的边。

可能会问，这样一来，仅仅是满足了相邻结点之间连通的要求而已。但其他的呢？事实上，只要能够满足相邻结点之间连通，任意两个结点之间就一定连通。
归纳起来，也就是说，要求缩点后得到的是一条链！但是，除了相邻结点中的边之外，可能存在其他多余的边。那无所谓，只要成一条链，已经足够满足要求。

具体的实现：缩点可以在 $O(n+m)$ 内跑一遍 tarjan，之后可以用 topo 做，每次删去入度为 0 的点。如果一次同时删去多于 1 个点，则不合法。否则删到最后，就成一条链，一定合法。至于为什么能够这样做，最好还是手画一下进行分析。

lgj 也在评讲的时候告诉我们：赛场上思考问题往往不一定能够立即得到正解，因此要多举例，画图（或列式？）分析，找到一些共通点，从而突破。

参考代码：

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
#include <queue>

using namespace std;

const int maxn = 1e5 + 100;
const int maxm = 1e5 + 100;

struct Edge { int to, next; } edge[maxm];
int a[maxm], b[maxm];

int n, m;
int head[maxn], belong[maxn];
int cntEdge, cntScc;

void addEdge(int u, int v) {
    edge[++cntEdge].to = v;
    edge[cntEdge].next = head[u];
    head[u] = cntEdge;
}

int dfn[maxn], low[maxn], timeStamp;
bool instack[maxn];
stack <int> st;
int inDegree[maxn];

void tarjan(int root) {
    dfn[root] = low[root] = ++timeStamp;
    instack[root] = true;
    st.push(root);
    for (int i = head[root]; i; i = edge[i].next)
        if (!dfn[edge[i].to]) {
            tarjan(edge[i].to);
            low[root] = min(low[root], low[edge[i].to]);
        } else if (instack[edge[i].to]) low[root] = min(low[root], dfn[edge[i].to]);
    if (dfn[root] == low[root]) {
        cntScc++;
        int cur;
        do {
            cur = st.top(); st.pop();
            instack[cur] = false;
            belong[cur] = cntScc; //每个结点属于缩点后的哪个强连通分量
        }
        while (cur != root);
    }
}

bool topo() {
    queue <int> q;
    while (!q.empty()) q.pop();
    for (int i = 1; i <= cntScc; i++)
        if (!inDegree[i]) q.push(i); //将入度为 0 的点入队
    if (q.size() > 1) return false; //如果一次有多个点同时入队，则它们之间就互不可达，整个图不合法
    while (!q.empty()) {
        int cur = q.front(); q.pop();
        for (int i = head[cur]; i; i = edge[i].next)
            if (!(--inDegree[edge[i].to])) q.push(edge[i].to);
        if (q.size() > 1) return false; //同上
    }
    return true;
}

int main(void) {
    freopen("1830.in", "r", stdin);
    freopen("1830.out", "w", stdout);
    int r;
    scanf("%d", &r);
    while (r--) {
        scanf("%d%d", &n, &m);
        memset(head, 0, sizeof head);
        cntEdge = 0;
        for (int i = 0; i < m; i++) {
            scanf("%d%d", &a[i], &b[i]);
            addEdge(a[i], b[i]);
        }

        memset(dfn, 0, sizeof dfn);
        timeStamp = 0;
        memset(instack, false, sizeof instack);
        cntScc = 0;
        for (int i = 1; i <= n; i++) if (!dfn[i]) tarjan(i);

        memset(head, 0, sizeof head);
        cntEdge = 0;
        memset(inDegree, 0, sizeof inDegree);
        for (int i = 0; i < m; i++)
            if (belong[a[i]] != belong[b[i]]) {
                addEdge(belong[a[i]], belong[b[i]]);
                ++inDegree[belong[b[i]]];
            }
        puts(topo() ? "Yes" : "No");
    }
    return 0;
}