POJ 2762 Going from u to v or from v to u?（半连通图）

 

题目大意

 

给你一个 n(0<n<1001) 个节点 m(m<6000) 条边的有向图，对于图中的任意两个节点 u 和 v，问能否从 u 走到 v 或者从 v 走到 u

PS：这其实是《算法导论》中讲“强连通分量”的最后一道习题

 

做法分析

 

由于强连通分量重的点肯定能够满足题目的要求，所以可以先将图“化简”，变成 DAG(Directed Acyclic Graph)

 

首先：如果当前的 DAG 有不止一个入读为 0 的点，那么这些点之间肯定不能相互到达，还要明确的是，当前的 DAG 中至少有一个节点的入读为 0(如果没有节点的入读为 0，这些节点肯定能够形成环，和 DAG 中的 Acyclic 矛盾，前面的缩点工作做的就不彻底)

也就是说，现在我们要考虑的就是只有一个点的入读为 0 的情况，这个入读为 0 的点肯定能够到达图中所有的点！

然后我们将这个入读为 0 的点删掉，考虑剩下的 DAG，由于我们只需要考虑两个点之间是否可以从一个点到达另一个点，那么，当前我们要考虑的就是当前的 DAG 中，入读为 0 的点是否只有一个就行了！(还是一样的道理，如果有两个以上的点，这些点之间是不可到达的)

 

于是思路清晰了：

        向将原图缩点，形成 DAG(重新建图是必须的啦)

        对新建好的图拓扑排序：

                每次判断当前是否只有一个点的入读为 0，如果不止一个，跳出拓扑排序过程，输出 No

                将那个入读为 0 的点从新图中删掉，再进行下一轮判断

                如果当前的 DAG 中只剩一个节点，跳出拓扑排序过程，输出 Yes

缩点当然用 Tarjan 了

 

参考代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#include <stack>

using namespace std;

const int N=1006;

vector <int> arc[N], adj[N];
int n, m, t, T, ind;
int dfn[N], low[N], id[N], in[N];
bool vs[N];
stack <int> s;

void tarjan(int u)
{
    vs[u]=1, s.push(u);
    dfn[u]=low[u]=T++;
    int len=(int)arc[u].size();
    for(int i=0; i<len; i++)
    {
        int v=arc[u][i];
        if(dfn[v]==-1)
        {
            tarjan(v);
            if(low[u]>low[v]) low[u]=low[v];
        }
        else if(vs[v] && low[u]>dfn[v]) low[u]=dfn[v];
    }
    if(low[u]==dfn[u])
    {
        for(int v; 1; )
        {
            v=s.top();
            s.pop(), vs[v]=0;
            id[v]=ind;
            if(v==u) break;
        }
        ind++;
    }
}

int main()
{
    scanf("%d", &t);
    for(int ca=1; ca<=t; ca++)
    {
        scanf("%d%d", &n, &m);
        for(int i=0; i<=n; i++) dfn[i]=-1, vs[i]=0, arc[i].clear();
        while(!s.empty()) s.pop();
        for(int i=0, a, b; i<m; i++)
        {
            scanf("%d%d", &a, &b);
            arc[a].push_back(b);
        }
        ind=T=0;
        for(int i=1; i<=n; i++) if(dfn[i]==-1) tarjan(i);
        for(int i=0; i<ind; i++) adj[i].clear(), in[i]=0, vs[i]=0;
        for(int i=1; i<=n; i++)
        {
            int len=(int)arc[i].size(), u=id[i];
            for(int j=0; j<len; j++)
            {
                int v=id[arc[i][j]];
                if(u!=v) adj[u].push_back(v), in[v]++;
            }
        }
        int tot=ind, flag=1;
        while(flag && tot>1)
        {
            int p=-1, cnt=0;
            for(int i=0; i<ind; i++)
                if(!vs[i] && in[i]==0) p=i, cnt++;
            if(cnt!=1)
            {
                flag=0;
                break;
            }
            int len=(int)adj[p].size();
            for(int i=0; i<len; i++) in[adj[p][i]]--;
            tot--, vs[p]=1;
        }
        if(flag) printf("Yes\n"); else printf("No\n");
    }
    return 0;
}

AC通道

POJ 2762 Going from u to v or from v to u?