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

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

Targan，拓扑排序

传送门：POJ

传送门：HustOJ

---

题意

题意是给出一些点，和他们之间的有向边，如果图中任意两点 x，y 之间满足 x 可以到达 y 或者 y 可以到达 x ，就输出“Yes”，否则输出“No”。注意，这里是 x 到达 y ，或者 y 到达 x ，是 或者 不是 而且 。

---

思路

如果是“而且”的话，很明显的是判断整个图是否为一个强连通分量，那么就简单的多了，但是这个题不行。
处理方法：先用强连通缩点来化简图，然后在DAG上做拓扑排序，如果排序过程中，出现1个以上的点入度同时为0时，那么就不满足条件。换句话说，缩点后应该是一个链，跑spfa最长路长度是点数也行。

---

代码

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>

#define _ ios_base::sync_with_stdio(0),cin.tie(0)
#define M(a,b) memset(a,b,sizeof(a))
using namespace std;

const int MAXN=1005;
const int oo=0x3f3f3f3f;
typedef long long LL;
const LL loo=4223372036854775807ll;
typedef long double LB;
const LL mod=1e9+7;

struct Targan
{
    //sccno[i]为i所在的dfs块编号
    vector<int> G[MAXN];
    int pre[MAXN], lowlink[MAXN], sccno[MAXN], dfs_clock, scc_cnt;
    stack<int> S;
    void init()
    {
        for(int i=0;i<MAXN;i++) G[i].clear();
        while(!S.empty()) S.pop();
    }
    void addedge(int a, int b)
    {
        G[a].push_back(b);
    }
    void dfs(int u)
    {
        pre[u]=lowlink[u]=++dfs_clock;
        S.push(u);
        for(int i=0;i<G[u].size();i++)
        {
            int v=G[u][i];
            if(!pre[v])
            {
                dfs(v);
                lowlink[u]=min(lowlink[u], lowlink[v]);
            }
            else if(!sccno[v])
            {
                lowlink[u]=min(lowlink[u], pre[v]);
            }
        }
        if(lowlink[u]==pre[u])
        {
            scc_cnt++;
            while(true)
            {
                int x=S.top();S.pop();
                sccno[x]=scc_cnt;
                if(x==u) break;
            }
        }
    }
    void find_scc(int n)
    {
        dfs_clock=scc_cnt=0;
        M(sccno, 0);M(pre, 0);
        for(int i=1;i<=n;i++)//注意修改取值范围
        {
            if(!pre[i]) dfs(i);
        }
    }
}targan;
vector<int> G_new[MAXN];
int indegree[MAXN];
int main()
{
    _;
    int T;cin>>T;
    while(T--)
    {
        int n, m;cin>>n>>m;
        targan.init();M(indegree, 0);
        for(int i=0;i<MAXN;i++) G_new[i].clear();
        while(m--)
        {
            int a, b;cin>>a>>b;
            targan.addedge(a, b);
        }
        targan.find_scc(n);
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<targan.G[i].size();j++)
            {
                if(targan.sccno[targan.G[i][j]]!=targan.sccno[i])
                {
                    G_new[targan.sccno[i]].push_back(targan.sccno[targan.G[i][j]]);
                    indegree[targan.sccno[targan.G[i][j]]]++;
                }
            }
        }
        int scc=targan.scc_cnt;
        int count=0, now=0;
        for(int i=1;i<=scc;i++)
        {
            if(indegree[i]==0)
            {
                count++;
                now=i;
            }
        }
        bool ff=0;
        if(count>1) cout<<"No"<<endl;
        else
        {
            while(n--)
            {
                int ttt=0;
                count=0;
                for(int i=0;i<G_new[now].size();i++)
                {
                    int to=G_new[now][i];
                    indegree[to]--;
                    if(indegree[to]==0)
                    {
                        count++;
                        ttt=to;
                    }
                }
                if(count>1) { cout<<"No"<<endl;ff=1;break; }
                now=ttt;
            }
            if(ff==0) cout<<"Yes"<<endl;
        }

    }
    return 0;
}