小白学习（传递闭包）

传递闭包的定义

对于有向图G(V,E)的传递闭包即是G(V,E),其中E{i，j:图中包含一条由i到j的路径}

Floyd warshall 传递闭包算法

算法实现原理：
由于我们只需要确定节点对(i,j)之间存在 i->j 的路径，所以对于松弛操作可以有两种优化方式
（1）将所有节点之间存在的直接连通的便权重设为1，不连通为INF(无穷大）。然后运行该算法，如果 mp[i][j]<n,则两者之间在路径。
（2）可以将松弛册率改为，mp[i][j]==1||(mp[i][k]==1&&mp[k][j]==1)也即是要么，i可以通过{1，2，3，…k-1}中的部分节点到达j，要么i可以通过{1，2，3，…k-1}中的部分节点到达j，可以参考对Floy warshall 算法分析 链接
（1）Floyd warshall 传递闭包算法

void floyd_warshall()
{
    int tmp;
    for(int k = 1; k <= n; ++k)
    {
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 1; j <= n; ++j)
            {
                //松弛操作； 
                { 
                    tmp = mp[i][k] + mp[k][j];
                    if(tmp < mp[i][j])
                    {
                        mp[i][j] = tmp;
                    }
                }
            }
        }
    }
}

（2）Floyd warshall 传递闭包算法的实现

void floyd_warshall()
{
    for(int k = 1; k <= n; ++k)
    {
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 1; j <= n; ++j)
            {
                if(mp[i][j] == 1 || mp[i][k] == 1 && mp[k][j] == 1)
                {
                    mp[i][j] = 1;
                }
            }
        }
    }
}

时间复杂度
容易知道时间复杂度为O(V^3)

DFS 传递闭包算法

算法分析
DFS时间复杂度为O(V+E)
使用对每一个节点进行DFS，每次可以得出一个节点可以到达的节点，可以求出有向图的传递闭包，使劲按复杂度为VO(V+E),即O（V(V+E))
如果图的边数较少时，第二张算法更有效，可以根据题目数据进行约束
代码实现：

int vis[N][N];//vis[i][j]表示i->j可达 
void dfs(int s)//普通的dfs算法
{
    int num = n;
    stack<int> st;
    st.push(s);
    vis[s][s] = 1;
    while(!st.empty())
    {
        int now = st.top();
        st.pop();
        int len = ed[now].size();
        for(int i = 0;i < len; ++i)
        {
            if(vis[s][ed[now][i]] == 0)
            {
                st.push(ed[now][i]);
                vis[s][ed[now][i]] = 1;
            }
        }
    }   
}