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

 

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

 

题意：有n个山洞m条路，问任意两点x,y能否存在从x到y或者从y到x。

思路：

1、注意是或而不是和，所以“缩点”后，由于“缩点”内的点相互可达，所以不需要管“缩点”内的点。注意，不是判断强连通的数量为1，而是判断是否是弱连通。

2、如果两点不可达那么在拓扑排序时，该两点谁也不是谁的前驱和后继，所以在拓扑排序时只要同时出现至少两个入度为０的点，那么这些点一定互不可达，所以只要判断拓扑的方式是否唯一即可。

第一种方法：只要用拓扑判断入度为0的点是否为1个，如果有多个，就出现在分叉，不可能从x到y。

第二种方法：从入度为0的点DFS搜索最长能到达的路径如果路径长度等于点数，说明可以从源点访问完所有点。

 

知识充电： 

强连通图：在有向图中, 若对于每一对顶点v1和v2, 都存在一条从v1到v2和从v2到v1的路径,则称此图是强连通图.

弱连通图：将有向图的所有的有向边替换为无向边，所得到的图称为原图的基图。如果一个有向图的基图是连通图，则有向图是弱连通图。

单向连通图：如果有向图中，对于任意节点v1和v2，至少存在从v1到v2和从v2到v1的路径中的一条，则原图为单向连通图。

 

三者之间的关系是，强连通图必然是单向连通的，单向连通图必然是弱连通图。

CODE：

 

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

#define MAXN 50010
#define MAXM 100010

struct Edge
{
    int v, next;
}edge[MAXM], edge2[MAXM];

int first[MAXN], first2[MAXN],stack[MAXN], ins[MAXN], dfn[MAXN], low[MAXN];
int belong[MAXM];
int ind[MAXN], outd[MAXN], topo[MAXN];

int n, m;
int cnt, cnt2;
int scnt, top, tot;

void init()
{
    cnt = 0, cnt2 = 0;
    scnt = top = tot = 0;
    memset(dfn, 0, sizeof(dfn));
    memset(first, -1, sizeof(first));
    memset(first2, -1, sizeof(first2));
    memset(ins, 0, sizeof(ins));
    memset(ind, 0, sizeof(ind));
    //memset(outd, 0, sizeof(outd));
    //memset(topo, 0, sizeof(topo));
}

void read_graph(int u, int v)
{
    edge[cnt].v = v;
    edge[cnt].next = first[u];
    first[u] = cnt++;
}

void read_graph2(int u, int v) //重构图 
{
    edge2[cnt2].v = v;
    edge2[cnt2].next = first2[u], first2[u] = cnt2++;
}

void dfs(int u)
{
    int v;
    dfn[u] = low[u] = ++tot;
    ins[u] = 1;
    stack[top++] = u;
    for(int e = first[u]; e != -1; e = edge[e].next)
    {
        v = edge[e].v;
        if(!dfn[v])
        {
            dfs(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if(dfn[u] == low[u])
    {
        scnt++;
        do
        {
            v = stack[--top];
            belong[v] = scnt;
            ins[v] = 0;
        }while(v != u);
    }
}

void Tarjan()
{
    for(int v = 1; v <= n; v++) if(!dfn[v])
        dfs(v);
} //Tarjan 

int toposort()
{
    queue<int> q;
    int tot2 = 0;
    for(int i = 1; i <= scnt; i++) if(!ind[i]) q.push(i);
    if(q.size() > 1) return 0;
    while(!q.empty())
    {
        int x = q.front(); q.pop();
        topo[++tot2] = x;
        for(int e = first2[x]; e != -1; e = edge2[e].next)
        {
            int v = edge2[e].v;
            if(--ind[v] == 0)
            {
                q.push(v);
            }
        }
        if(q.size() > 1) return 0;
    }
    if(tot2 != scnt) return 0;
    else return 1;
} //toposort 

void solve()
{
    Tarjan();
    for(int u = 1; u <= n; u++) //重构图 
    {
        for(int e = first[u]; e != -1; e = edge[e].next)
        {
            int v = edge[e].v;
            if(belong[u] != belong[v])
            {
                ind[belong[v]]++;
                read_graph2(belong[u], belong[v]);
            }
        }
    }
    if(toposort()) printf("Yes\n");
    else printf("No\n");
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        init();
        scanf("%d%d", &n, &m);
        while(m--)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            read_graph(u, v);
        }
        solve();
    }
    return 0;
}