18.11.08 POJ 2762 Going from u to v or from v to u?（强连通+缩点+拓扑排序）

描述

In order to make their sons brave, Jiajia and Wind take them to a big cave. The cave has n rooms, and one-way corridors connecting some rooms. Each time, Wind choose two rooms x and y, and ask one of their little sons go from one to the other. The son can either go from x to y, or from y to x. Wind promised that her tasks are all possible, but she actually doesn't know how to decide if a task is possible. To make her life easier, Jiajia decided to choose a cave in which every pair of rooms is a possible task. Given a cave, can you tell Jiajia whether Wind can randomly choose two rooms without worrying about anything?

输入

The first line contains a single integer T, the number of test cases. And followed T cases.

The first line for each case contains two integers n, m(0 < n < 1001,m < 6000), the number of rooms and corridors in the cave. The next m lines each contains two integers u and v, indicating that there is a corridor connecting room u and room v directly.输出The output should contain T lines. Write 'Yes' if the cave has the property stated above, or 'No' otherwise.

样例输入

1
3 3
1 2
2 3
3 1

样例输出

Yes

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stack>
#include <string>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <fstream>
#include <set>

using namespace std;

const int maxn = 1005;
vector<vector<int>>G(maxn);
vector<set<int>>DAG(maxn);
int dfn[maxn], low[maxn],father[maxn],colorP[maxn];
bool route[maxn];
int to[maxn];
int ncount = 1, n, m, color;
stack<int>p;

void tarjan(int u,int father) {
    route[u] = true;
    p.push(u);
    low[u] = dfn[u] = ncount++;
    int l = G[u].size();
    for (int i = 0; i < l; i++) {
        int next = G[u][i];
        if (!dfn[next])
            tarjan(next, u);
        else if(route[next])
            low[u] = min(low[u], low[next]);
    }
    if (dfn[u] == low[u]) {
        int v = 0;
        ++color;
        while (v != u) {
            v = p.top();
            p.pop();
            colorP[v] = color;
        }
    }
    route[u] = false;
}

bool top() {
        int id, sum = 0;
        for (int i = 1; i <= color; i++) {
            if (to[i] == 0) {
                id = i;
                sum++;
            }
        }
        while (sum!=0)
        {
            if (sum > 1)
                return false;
            sum = 0;
            set<int>::iterator i1 = DAG[id].begin(), i2 = DAG[id].end();
            for (; i1 != i2; i1++)
            {
                to[*i1]--;
                if (to[*i1] == 0) {
                    id = *i1;
                    sum++;
                }
            }
        }
        return true;
}

void calculate() {
    for (int i = 1; i <= n; i++) {
        int size = G[i].size();
        for (int j = 0; j < size; j++) {
            int v = G[i][j];
            if (colorP[v] != colorP[i])
            {
                DAG[i].insert(colorP[v]);
                to[colorP[v]]++;
            }
        }
    }
    if (top())
        printf("Yes
");
    else
        printf("No
");
}

void init() {
    int kase;
    scanf("%d", &kase);
    while (kase--)
    {
        ncount = 1,n=0,m=0,color=0;
        memset(to, 0, sizeof(to));
        memset(dfn, 0, sizeof(to));
        memset(low, 0, sizeof(to));
        memset(father, 0, sizeof(to));
        memset(colorP, 0, sizeof(to));
        G = vector<vector<int>>(maxn);
        DAG = vector<set<int>>(maxn);
        scanf("%d%d", &n, &m);
        while (m--) {
            int from, to;
            scanf("%d%d", &from, &to);
            G[from].push_back(to);
            father[to] = from;
        }
        for (int i = 1; i <= n; i++) {
            if (!dfn[i])
                tarjan(i, father[i]);
        }
        calculate();
    }
}

int main()
{
    init();
    return 0;
}

这道题给的数据也相当水，比较迷的是我在openjudge上跑了1ms，在POJ永远TLE

属于玄学过的，之后再到POJ跑跑看（我说的之后再看看好像就没看过……唉……）

思路是拓扑排序，首先是确定对有向无环图来说符合两点两两相通的情况必须是只有一个点入度为0且只有一个点出度为0并且没有分叉点

不知道老师课上有没有讲过，网上的参考，贴一下

如果DAG中，有2个或2个以上的点的入度为0，那么这个DAG就是No，因为这说明有两个点是无法“进去”的，没有点能“进去”U，也没有点能“进去”V，那么这两个点肯定互相不能“进去”，即到达

如果DAG中，有2个或2个以上的点的出度为0，那么这个DAG就是No，因为说明这两个点是无法“出去的”。

反证法，点U和V，它们出度都是0，假设它们满足题目条件，从U能到V，或者从V能到U

1.因为点U出度为0，所以无法“出去”，它肯定无法到达V

2.因为点V出度为0，所以无法“出去”，它肯定无法到达U

3.综上，点U无法到达V，点V无法到达点U，与假设矛盾，所以与题目不成立

 

那么什么最后一个问题，如果这个DAG，入度为0的点的个数 <= 1 , 出度为0的点的个数 <= 1 ， 它就一定Yes吗？

这个就比较容易想了，首先，1个DAG中，不可能所有点都有入度，即入度为0的点个数为0，是不可能发生的。同样的，可能所有点都有出度，即出度为0的点个数为0，是不可能发生的

那剩下的情况就是，1个点入度为0为u，1个点出度为0为v。这个图，呈现一个“橄榄形”。如果从点u走到点v，能经过所有的点，那么就是Yes，否则是No。因为无法经过所有的点的话，说明图中出现了“分叉”，这种“分叉”必定导致两个点互相不可达。而从u到v，经过所有点，其实就是把这个DAG变成了一条链，就是判断这个DAG是否存在一条链贯穿所有点

 

怎么判断链呢？可以转化为拓扑排序，或者DP最长路

拓扑：拓扑排序可能有多种结果，但是如果是一个最长链，结果则是唯一的，结果要唯一，其实就是从初始化开始，到后面的任何一次删弧入队操作，都是保证了每次都只有一个元素入队，即永远只有一个元素的入度为0，如果中途有一次出现了有两个点入度为0，那么其实代表出现了一种“分叉”

而且拓扑排序可以综合掉前面的情况，不需要特判DAG有几个点入度为0，出度为0，直接拓扑，在拓扑过程就已经判断了

来自https://www.cnblogs.com/scau20110726/archive/2013/05/23/3094495.html