算法提高-图论- 有向图的强连通分量

AcWing 1174. 受欢迎的牛

#include 
#include 

const int N = 1e4 + 10, M = 5 * 1e4 + 10;

int dfn[N], low[N], timestamp;
bool is_instk[N];
int h[N], ne[M], e[M], idx;
int stk[N], top;
int scc_cnt, id[N], scc_size[N];
int dout[N];
int n, m;

using namespace std;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++ timestamp ;
    stk[++ top] = u;
    is_instk[u] = true;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);
        }
        else if (is_instk[j])//j遍历过了且j在栈里，保证j和u在同一连通量中，简单来说是判断当前边i是不是横叉边的
        {
            low[u] = min(low[u], dfn[j]);
        }
    }

    if (dfn[u] == low[u])
    {
        int y;
        scc_cnt ++;
        do{
            y = stk[top --];
            is_instk[y] = false;
            id[y] = scc_cnt;
            scc_size[scc_cnt] ++ ;
        }while(y != u);
    }

}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    while (m --)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }    
    for (int i = 1; i <= n; i ++ )
    {
        if (!dfn[i]) tarjan(i);
    }

    for (int i = 1; i <= n; i ++ )
    {
        for (int j = h[i]; ~j; j = ne[j])
        {
            int k = e[j];
            int a = id[i], b = id[k];
            if (a != b) dout[a] ++;
        }
    }

    int zeros = 0;
    int sum = 0;
    for (int i = 1; i <= scc_cnt; i ++)//遍历各个连通分量，如果一个连通分量出度为0，说明这个连通块内的牛不崇拜任何别的牛
    {                                   //并且这个图是连通的（否则的话无解），如果有两个连通块出度都是0，那么就没有任何一头牛是最受欢迎的
        if (dout[i] == 0) 
        {
            zeros++;
            sum = scc_size[i];
            if (zeros == 2)
            {
                sum = 0;
                break;
            }
        }
    }
    cout << sum;
    return 0;
}

AcWing 367. 学校网络

这题最难想的是求出来连通分量后怎么处理，为什么最少需要将一个新软件直接提供给多少个学校，才能使软件能够通过网络被传送到所有学校的答案是入度为0的连通分量数
为什么最少需要添加几条新的支援关系，使得将一个新软件提供给任何一个学校，其他所有学校就都可以通过网络获得该软件？的答案是统计该图中连通块出度入度的最大值

#include 
#include 

using namespace std;

const int N = 110, M = N * N;

int dfn[N], low[N], timestamp;
int scc_cnt;
int din[N], dout[N], id[N];
int h[N], ne[M], e[M], idx;
int stk[N], top;
bool in_stk[N];
int n;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++ timestamp;
    stk[++ top] = u;
    in_stk[u] = true;

    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);
        }
        else if(in_stk[j] == true) low[u] = min(low[u], dfn[j]);
    }

    if (dfn[u] == low[u])
    {
        int y;
        scc_cnt ++ ;
        do{
            y = stk[top --];
            in_stk[y] = false;
            id[y] = scc_cnt;
        }while(y != u);
      

    }
}
int main()
{
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i ++)
    {
        int j;
        while (cin >> j, j)
        {
            add(i, j);
        }
    }

    for (int i = 1; i <= n; i ++ ) if(!dfn[i]) tarjan(i);
    for (int i = 1; i <= n; i ++ )//遍历每个点
    {
        for (int j = h[i]; ~j; j = ne[j])//遍历i的邻边
        {
            int k = e[j];
            int a = id[i], b = id[k];
            if (a != b)
            {
                din[b] ++;
                dout[a] ++ ;
            }
        }
    }
    int p, q;
    for (int i = 1; i <= scc_cnt; i ++ )
    {
        if (din[i] == 0) p ++;
        if (dout[i] == 0) q ++;
    }

    cout << p << endl;
    if (scc_cnt == 1) puts("0");
    else cout << max(p, q);
    return 0;
}

AcWing 1175. 最大半连通子图

#include 
#include 
#include 
#include 
#include 

using namespace std;

typedef long long LL;

const int N = 100010, M = 2000010;

int n, m, mod;
int h[N], hs[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, scc_size[N];
int f[N], g[N];
// 有新图所以传h
void add(int h[],int a,int b)
{
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++timestamp;
    stk[++top] = u,in_stk[u] = true;
    for(int i =h[u];~i;i=ne[i])
    {
        int j = e[i];
        // 树枝边
        if(!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u],low[j]);
        }
        // 横向边
        else if(in_stk[j])low[u] = min(low[u],dfn[j]);
    }
    // 当前分量最高点 把当前点取出来作为一个强连通分量
    // ⭐
    // 解释一下为什么tarjan完是逆dfs序
    // 假设这里是最高的根节点fa
    // 上面几行中 fa的儿子节点j都已经在它们的递归中走完了下面9行代码
    // 其中就包括 ++scc_cnt 
    // 即递归回溯到高层节点的时候 子节点的scc都求完了
    // 节点越高 scc_id越大
    // 在我们后面想求链路dp的时候又得从更高层往下
    // 所以得for(int i=scc_cnt(根节点所在的scc);i;i--)开始
    if(dfn[u]==low[u])
    {
        ++scc_cnt;
        int y;
        do{//由于是dfs搜到一层stk.push 所以stk最先pop出来的是最深层的
            y=stk[top--];
            in_stk[y] = false;
            // id[y] = scc_cnt 属于第scc_cnt个强连通分量
            id[y] = scc_cnt;
            scc_size[scc_cnt]++;
        }while(y!=u);
    }
}

int main()
{
    memset(h,-1,sizeof h);
    memset(hs,-1,sizeof hs);
    cin >> n >> m >> mod;
    while(m--)
    {
        int a,b;
        cin >> a >> b;
        add(h,a,b);
    }
    // tarjan算强连通分量
    for(int i = 1;i<=n;i++)
    {
        if(!dfn[i])
        {
            tarjan(i);
        }
    }
    unordered_set<LL> S;// 边是(u,v) hash后 u*1000000+v
    for(int i=1;i<=n;i++)
    {
        for(int j = h[i];~j;j=ne[j])
        {
            int k = e[j];
            int a = id[i],b= id[k];
            // 边判重
            LL hash = a*1000000ll+b;
            // 如果a和b不在一个强连通分量 且 边(a,b)没被加过
            if(a!=b && !S.count(hash))
            {
                add(hs,a,b);
                S.insert(hash);
            }
        }
    }
    // 强连通分量算完后
    // 拓扑序一定是按照节点编号递减的顺序->不需要重新拓扑排序了
    // 在这个拓扑序上求最长路
    for(int i=scc_cnt;i;i--)
    {
        // !f[i] i没被更新过 i为一条链的起点
        if(!f[i])
        {
            f[i] = scc_size[i];
            g[i] = 1;
        }
        for(int j = hs[i];~j;j=ne[j])
        {
            int k = e[j];
            if(f[k]<f[i]+scc_size[k])
            {
                f[k] = f[i]+scc_size[k];
                g[k] = g[i];
            }
            else if(f[k]==f[i]+scc_size[k])
            {
                g[k] = (g[k]+g[i])%mod;
            }
        }
    }

    int maxf = 0,sum = 0;
    // 对比每一条路终点
    for(int i = 1;i<=scc_cnt;i++)
    {
        if(f[i]>maxf)
        {
            maxf = f[i];
            sum = g[i];
        }
        else if(f[i] == maxf)sum=(sum+g[i])%mod;
    }
    cout << maxf << endl;
    cout << sum;
    return 0;
}

AcWing 368. 银河

#include 
#include 
#include 
#include 

using namespace std;

typedef long long LL;

const int N = 100010, M = 600010;

int n, m;
int h[N], hs[N], e[M], ne[M], w[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, scc_size[N];
int dist[N];

void add(int h[],int a,int b,int c)
{
    e[idx] = b,ne[idx] = h[a],w[idx] = c,h[a] = idx++;
}

void tarjan(int u)
{
    dfn[u] = low[u] = timestamp++;
    stk[++top] = u,in_stk[u] = true;//stk[++top]要和stk[top--]配 而不是stk[top++] stk[0++] = u stk[1++] = t 

    for(int i = h[u];~i;i=ne[i])
    {
        int j = e[i];
        if(!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u],low[j]);
        }
        else if(in_stk[j]) low[u] = min(low[u],dfn[j]);
    }
    if(dfn[u]==low[u])
    {
        scc_cnt++;
        int y;
        do
        {
            y = stk[top--];//忘了强连通分量都是通过dfs后在一个栈里的
            in_stk[y] = false;//漏了
            id[y] = scc_cnt;
            scc_size[scc_cnt]++;
        }while(y!=u);//漏了
    }
}

int main()
{
    cin >> n >> m;
    memset(h,-1,sizeof h);
    memset(hs,-1,sizeof h);
    // 超级源点 和i有一个1的边
    for(int i = 1;i<=n;i++)add(h,0,i,1);
    while(m--)
    {
        int t,a,b;
        cin >> t >> a >> b;
        if(t==1)add(h,b,a,0),add(h,a,b,0);
        else if(t==2)add(h,a,b,1);
        else if(t==3)add(h,b,a,0);
        else if(t==4)add(h,b,a,1);
        else add(h,a,b,0);
    }
    tarjan(0);
    bool success = true;
    for(int i=0;i<=n;i++)
    {
        for(int j = h[i];~j;j=ne[j])
        {
            int k = e[j];
            int a = id[i],b = id[k];
            // 如果a和b在一个scc里,判断w[a][b]是否>0,
            if(a==b)
            {
                if(w[j]>0)//ab在同一个连通块内并且有一条边为正，那么就行成了一个正环，会一直走这条路更新
                {
                    success = false;
                    break;
                }
            }
            // 如果不在一个scc里 在新图里加一条边
            else add(hs,a,b,w[j]);
        }
        if(!success) break;
    }
    if(!success) cout << "-1";
    else
    {
        // 有解 求最长路
        for(int i = scc_cnt;i;i--)
        {
            for(int j = hs[i];~j;j=ne[j])
            {
                int k = e[j];
                dist[k] = max(dist[k],dist[i]+w[j]);
            }
        }
        LL res = 0;
        // 结果 = 新图里每个scc的距离 * scc里的点数 = dist[scc] * cnt[scc] 
        for(int i=1;i<=scc_cnt;i++) res+=(LL)dist[i]*scc_size[i];
        cout << res;
    }
    return 0;
}