51nod 1076 2条不相交的路径 tarjan算法

1076 2条不相交的路径

基准时间限制：1 秒 空间限制：131072 KB 分值: 40  难度：4级算法题

 收藏

 关注

给出一个无向图G的顶点V和边E。进行Q次查询，查询从G的某个顶点V[s]到另一个顶点V[t]，是否存在2条不相交的路径。（两条路径不经过相同的边）

（注，无向图中不存在重边，也就是说确定起点和终点，他们之间最多只有1条路）

Input

第1行：2个数M N，中间用空格分开，M是顶点的数量，N是边的数量。（2 <= M <= 25000, 1 <= N <= 50000)
第2 - N + 1行，每行2个数，中间用空格分隔，分别是N条边的起点和终点的编号。例如2 4表示起点为2，终点为4，由于是无向图，所以从4到2也是可行的路径。
第N + 2行，一个数Q，表示后面将进行Q次查询。(1 <= Q <= 50000)
第N + 3 - N + 2 + Q行，每行2个数s, t，中间用空格分隔，表示查询的起点和终点。

Output

共Q行，如果从s到t存在2条不相交的路径则输出Yes，否则输出No。

Input示例

4 4
1 2
2 3
1 3
1 4
5
1 2
2 3
3 1
2 4
1 4

Output示例

Yes
Yes
Yes
No
No

算法介绍

编辑

如果两个顶点可以相互通达，则称两个顶点 强连通(strongly connected)。如果 有向图G的每两个顶点都 强连通，称G是一个 强连通图。有向图的极大强连通子图，称为 强连通分量(strongly connected components)。

下图中，子图{1,2,3,4}为一个 强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量。

Tarjan算法是用来求有向图的强连通分量的。求有向图的强连通分量的Tarjan算法是以其发明者Robert Tarjan命名的。Robert Tarjan还发明了求 双连通分量的Tarjan算法。

Tarjan算法是基于对图 深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的 节点加入一个 堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。

定义 DFN(u)为节点u搜索的次序编号( 时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。

当DFN(u)=Low(u)时，以u为根的搜索子树上所有节点是一个 强连通分量。

接下来是对算法流程的演示。

从节点1开始DFS，把 遍历到的节点加入栈中。搜索到节点u=6时， DFN[6]=LOW[6]，找到了一个强连通分量。退栈到u=v为止，{6}为一个强连通分量。

返回节点5，发现DFN[5]=LOW[5]，退栈后{5}为一个 强连通分量。

返回节点3，继续搜索到节点4，把4加入 堆栈。发现节点4向节点1有后向边，节点1还在栈中，所以LOW[4]=1。节点6已经出栈，(4,6)是横叉边，返回3，(3,4)为树枝边，所以LOW[3]=LOW[4]=1。

继续回到节点1，最后访问节点2。访问边(2,4)，4还在栈中，所以LOW[2]=DFN[4]=5。返回1后，发现DFN[1]=LOW[1]，把栈中节点全部取出，组成一个 连通分量{1,3,4,2}。

至此，算法结束。经过该算法，求出了图中全部的三个 强连通分量{1,3,4,2},{5},{6}。

可以发现，运行Tarjan算法的过程中，每个顶点都被访问了一次，且只进出了一次 堆栈，每条边也只被访问了一次，所以该算法的 时间复杂度为O(N+M)。

以上摘自百度百科 ，个人觉得已经很详细了

主要用到的是tarjan算法tarjan算法是求连通量的两两到达的都属于一个联通分量。

这样的话，无向图内也通用。

之后在tarjan的连通分量里面 就能达到两两有两条不想交的路的效果了关于tarjan算法。

我卡在时间戳。之前认为是时间戳分类。之后自己敲了一个时间戳分类的代码。发现一些联通分量的时间戳在搜索过程中很难一致。

所以 ，我觉得精华部分是那个联通块的分类数组。把一个栈里面的连通分量用联通快的那个数组分开。用时间戳来把一个联通块从栈内分离出去。

#include <bits/stdc++.h>
using namespace std;
vector<int > d[50005];
stack<int > s;
int dfn[50005];
int low[50005];
int vtag[50005];
int b[50005];
int times;
void dfs(int t,int u)
{
    dfn[t]=low[t]=times++;
    s.push(t);
    vtag[t]=1;
    for(int i=0;i<d[t].size();i++)
    {
        if(!dfn[d[t][i]])
        {
            dfs(d[t][i],t);
            low[t]=min(low[t],low[d[t][i]]);
        }
        if(vtag[d[t][i]]&&d[t][i]!=u)
            low[t]=min(low[t],dfn[d[t][i]]);
    }
     if(low[t]==dfn[t])
     {
            while(s.top()!=t)
            {
                //cout<<s.top()<<' ';
                vtag[s.top()]=0;
                b[s.top()]=t;
                s.pop();
            }
            b[s.top()]=t;
            s.pop();
     }
}
int main()
{
    int n,m,q;
    while(cin>>n>>m)
    {
        memset(b,0,sizeof(b));
        memset(vtag,0,sizeof(vtag));
        while(!s.empty()) s.pop();
        times=1;
        int x,y;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&x,&y);
            d[x].push_back(y);
            d[y].push_back(x);
        }
        for(int i=1;i<=n;i++)
            if(!dfn[i])dfs(i,0);
        cin>>q;
        for(int i=0;i<q;i++)
        {
            scanf("%d%d",&x,&y);
            if(b[x]==b[y]) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }
    }
}