Zoo

Description

現在你是動物園的一名員工，負責整個園區人行道的佈局，目前所有人行道都是單向道路。

這些路徑將動物園分成了若干個區域，每個區域內存在11個或多個景點

在同一個區域內的任意兩個景點之間可以互相到達，但是當你從一個區域走到另一個區域時

你就再也不能回到之前走過的區域，並且存在一條路徑可以走遍所有的區域。

這樣的設計可以控制動物園的遊客流量。(輸入的數據保證滿足這些條件)

現在你可以儘可能的多添加邊，要求不能有重邊和自環

並且需要滿足如果在之前uu不可到達vv，那麼添加邊之後uu還是不可以到達vv

求最多能添加的邊數。

Input

輸入第一行爲正整數nn,表示景點數目(1≤n≤2500)(1≤n≤2500)

接下來輸入nn行，每行nn個整數Map_{ij}Mapij (Map_{ij}=0\ or\ Map_{ij}=1)(Mapij=0 or Mapij=1)

Map_{ij}Mapij爲11，表示ii和jj之間存在單向邊<i,j><i,j>，爲00則表示不存在。

Output

輸出一個整數表示最多能添加的邊

Sample Input 1

7
0 1 0 0 0 0 0
0 0 1 0 1 0 0
1 0 0 1 0 0 0
1 0 0 0 0 0 0
0 0 0 0 0 1 0
0 0 0 0 0 0 1
0 0 0 0 1 0 0

Sample Output 1

Sample Input 2

Sample Output 2

Sample Input 3

2
0 1
1 0

Sample Output 3

Hint

輸入數據量較大，建議使用高效的輸入輸出方式

#include<bits/stdc++.h>
using namespace std;
int a[2510][2510];
vector<int> g[2510];
const int maxn=2510;
int low[maxn],pre[maxn],col[maxn];int vis[maxn],ru[maxn];
stack<int>q;int topo[maxn];//注意棧 
int deep,ccnt,n;
void dfs(int u){
	pre[u]=low[u]=++deep;
//	vis[u]=1;
	q.push(u);
	int sz=g[u].size();
	for(int i=0;i<sz;i++){
		int v=g[u][i];
		if(!pre[v]){
			dfs(v);
			low[u]=min(low[u],low[v]);
		}
		else if(!col[v]){
			low[u]=min(low[u],pre[v]);
		}
	}

	if(low[u]==pre[u]){
		ccnt++;
		for(;;){
			int x=q.top();
			q.pop();
			col[x]=ccnt;
		//	col[x]=cnt;
			vis[ccnt]++;
			if(x==u) break;
		}
	}
}
void find_scc(){
	deep=ccnt=0;
	memset(pre,0,sizeof(pre));
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=n;i++){
		if(!pre[i]) dfs(i);
	}
}
vector<int>gg[maxn];
int main(){
//	int n;
	cin>>n;int tot=0;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			cin>>a[i][j];
			if(a[i][j]){
				g[i].push_back(j);tot++;
			}
		}
	}
	//cout<<tot<<endl;
	find_scc();
	for(int i=1;i<=n;i++){
		for(int j=0;j<g[i].size();j++){
			int v=g[i][j];//
			if(col[i]!=col[v]){
				gg[col[i]].push_back(col[v]);//
				ru[col[v]]++;
			}
		}
	}
	queue<int>qq;
	for(int i=1;i<=ccnt;i++){
		if(!ru[i]) qq.push(i);
	}
	int cnt=0;
	while(!qq.empty()){
		int y=qq.front();qq.pop();
		topo[++cnt]=y;
		for(int i=0;i<gg[y].size();i++){
			int v=gg[y][i];
			if(--ru[v]==0) qq.push(v);
		}	
	}
	int ans=0;
	for(int i=1;i<=ccnt;i++){
		ans+=vis[i]*(vis[i]-1);
	//	cout<<ans<<endl;
		for(int j=i+1;i<=cnt&&j<=cnt;j++){
			ans+=vis[topo[i]]*vis[topo[j]];
		}
	}
	cout<<ans-tot<<endl; 
	return 0;
	
}

終於做完了這道縮點和拓撲排序的題了。

然後看了這篇博客挺好的：https://www.cnblogs.com/stxy-ferryman/p/7779347.html

Styx-ferryman

務必要卡常，寫個好程序，你會很快樂，寫個壞程序，你會成爲哲♂學家。

隨筆 - 179 文章 - 0 評論 - 32

tarjan求強連通分量+縮點+割點/割橋（點雙/邊雙）以及一些證明

“tarjan陪伴強聯通分量

生成樹完成後思路才閃光

歐拉跑過的七橋古塘

讓你心馳神往”----《膜你抄》

自從聽完這首歌，我就對tarjan開始心馳神往了，不過由於之前水平不足，一直沒有時間學習。這兩天好不容易學會了，寫篇博客，也算記錄一下。

一、tarjan求強連通分量

1、什麼是強連通分量？

引用來自度孃的一句話：

“有向圖強連通分量：在有向圖G中，如果兩個頂點vi,vj間（vi>vj）有一條從vi到vj的有向路徑，同時還有一條從vj到vi的有向路徑，則稱兩個頂點強連通(strongly connected)。如果有向圖G的每兩個頂點都強連通，稱G是一個強連通圖。有向圖的極大強連通子圖，稱爲強連通分量(strongly connected components)。”

一臉懵逼......不過倒也不難理解。

反正就是在圖中找到一個最大的圖，使這個圖中每個兩點都能夠互相到達。這個最大的圖稱爲強連通分量，同時一個點也屬於強連通分量。

如圖中強連通分量有三個：1-2-3,4,5

2、強連通分量怎麼找？

噫......當然，通過肉眼可以很直觀地看出1-2-3是一組強連通分量，但很遺憾，機器並沒有眼睛，所以該怎麼判斷強連通分量呢？

如果仍是上面那張圖，我們對它進行dfs遍歷。

可以注意到紅邊非常特別，因爲如果按照遍歷時間來分類的話，其他邊都指向在自己之後被遍歷到的點，而紅邊指向的則是比自己先被遍歷到的點。

如果存在這麼一條邊，那麼我們可以yy一下，emmmm.......

從一個點出發，一直向下遍歷，然後忽得找到一個點，那個點竟然有條指回這一個點的邊！

那麼想必這個點能夠從自身出發再回到自身

想必這個點和其他向下遍歷的該路徑上的所有點構成了一個環，

想必這個環上的所有點都是強聯通的。

但只是強聯通啊，我們需要求的可是強連通分量啊......

那怎麼辦呢？

我們還是yy出那棵dfs樹

不妨想一下，什麼時候一個點和他的所有子孫節點中的一部分構成強連通分量？

他的子孫再也沒有指向他的祖先的邊，卻有指向他自己的邊

因爲只要他的子孫節點有指向祖先的邊，顯然可以構成一個更大的強聯通圖。

比如說圖中紅色爲強連通分量，而藍色只是強聯通圖

那麼我們只需要知道這個點u下面的所有子節點有沒有連着這個點的祖先就行了。

但似乎還有一個問題啊......

我們怎麼知道這個點u它下面的所有子節點一定是都與他強聯通的呢？

這似乎是不對的，這個點u之下的所有點不一定都強聯通

那麼怎麼在退回到這個點的時候，知道所有和這個點u構成強連通分量的點呢？

開個棧記錄就行了

什麼？！這麼簡單？

沒錯~就是這麼簡單~

如果在這個點之後被遍歷到的點已經能與其下面的一部分點（也可能就只有他一個點）已經構成強連通分量，即它已經是最大的。

那麼把它們一起從棧裏彈出來就行了。

所以最後處理到點u時如果u的子孫沒有指向其祖先的邊，那麼它之後的點肯定都已經處理好了，一個常見的思想，可以理解一下。

所以就可以保證棧裏留下來u後的點都是能與它構成強連通分量的。

似乎做法已經明瞭了，用程序應該怎麼實現呢？

所以爲了實現上面的操作，我們需要一些輔助數組

(1)、dfn[ ]，表示這個點在dfs時是第幾個被搜到的。

(2)、low[ ]，表示這個點以及其子孫節點連的所有點中dfn最小的值

(3)、stack[ ]，表示當前所有可能能構成是強連通分量的點。

(4)、vis[ ]，表示一個點是否在stack[ ]數組中。

那麼按照之上的思路，我們來考慮這幾個數組的用處以及tarjan的過程。

假設現在開始遍歷點u：

(1)、首先初始化dfn[u]=low[u]=第幾個被dfs到

dfn可以理解，但爲什麼low也要這麼做呢？

因爲low的定義如上，也就是說如果沒有子孫與u的祖先相連的話，dfn[u]一定是它和它的所有子孫中dfn最小的（因爲它的所有子孫一定比他後搜到）。

(2)、將u存入stack[ ]中，並將vis[u]設爲true

stack[ ]有什麼用？

如果u在stack中，u之後的所有點在u被回溯到時u和棧中所有在它之後的點都構成強連通分量。

(3)、遍歷u的每一個能到的點，如果這個點dfn[ ]爲0，即仍未訪問過，那麼就對點v進行dfs，然後low[u]=min{low[u],low[v]}

low[ ]有什麼用？

應該能看出來吧，就是記錄一個點它最大能連通到哪個祖先節點（當然包括自己）

如果遍歷到的這個點已經被遍歷到了，那麼看它當前有沒有在stack[ ]裏,如果有那麼low[u]=min{low[u],low[v]}

如果已經被彈掉了，說明無論如何這個點也不能與u構成強連通分量，因爲它不能到達u

如果還在棧裏，說明這個點肯定能到達u，同樣u能到達他，他倆強聯通。

(4)、假設我們已經dfs完了u的所有的子樹那麼之後無論我們再怎麼dfs，u點的low值已經不會再變了。

那麼如果dfn[u]=low[u]這說明了什麼呢？

再結合一下dfn和low的定義來看看吧

dfn表示u點被dfs到的時間，low表示u和u所有的子樹所能到達的點中dfn最小的。

這說明了u點及u點之下的所有子節點沒有邊是指向u的祖先的了，即我們之前說的u點與它的子孫節點構成了一個最大的強連通圖即強連通分量

此時我們得到了一個強連通分量，把所有的u點以後壓入棧中的點和u點一併彈出，將它們的vis[ ]置爲false，如有需要也可以給它們打上相同標記（同一個數字）

tarjan到此結束

至於手模？tan90°！網上有不少大佬已經手摸了不少樣例了，想必不需要本蒟蒻再補充了。

結合上面四步代碼已經可以寫出了：

對了，tarjan一遍不能搜完所有的點，因爲存在孤立點或者其他

所以我們要對一趟跑下來還沒有被訪問到的點繼續跑tarjan

怎麼知道這個點有沒有被訪問呢？

看看它的dfn是否爲0！

這看起來似乎是o(n^2)的複雜度，但其實均攤下來每個點只會被遍歷一遍

所以tarjan的複雜度爲o(n)。

來一道例題吧，這是模板題，應該做到提交框AC

[USACO06JAN]牛的舞會The Cow Prom

給你n個點，m條邊，求圖中所有大小大於1的強連通分量的個數

輸入樣例#1：

輸出樣例#1：

顯然是tarjan水題，數出強連通分量的個數，給每個強連通分量的點染色，統計出每個強連通分量中點的個數，如果大於一，則答案加一。

代碼：

#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f

vector<int> g[10010];
int color[10010],dfn[20020],low[20020],stack[20020],vis[10010],cnt[10010];
int deep,top,n,m,sum,ans;

void tarjan(int u)
{
    dfn[u]=++deep;
    low[u]=deep;
    vis[u]=1;
    stack[++top]=u;
    int sz=g[u].size();
    for(int i=0;i<sz;i++)
    {
        int v=g[u][i];
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else
        {
            if(vis[v])
            {
                low[u]=min(low[u],low[v]);
            }
        }
    }
    if(dfn[u]==low[u])
    {
        color[u]=++sum;
        vis[u]=0;
        while(stack[top]!=u)
        {
            color[stack[top]]=sum;
            vis[stack[top--]]=0;
        }
        top--;
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int from,to;
        scanf("%d%d",&from,&to);
        g[from].push_back(to);
    }
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i])
        {
            tarjan(i);
        }
    }
    for(int i=1;i<=n;i++)
    {
        cnt[color[i]]++;
    }
    for(int i=1;i<=sum;i++)
    {
        if(cnt[i]>1)
        {
            ans++;
        }
    }
    printf("%d\n",ans);
}

二、tarjan縮點

其實這也是利用了tarjan求強連通分量的方法，對於一些貢獻具有傳導性，比如友情啊、路徑上的權值啊等等。

思想就是因爲強連通分量中的每兩個點都是強連通的，可以將一個強連通分量當做一個超級點，而點權按題意來定。

來看一道題吧。

poj2186 Popular Cows

告訴你有n頭牛，m個崇拜關係，並且崇拜具有傳遞性，如果a崇拜b，b崇拜c，則a崇拜c，求最後有幾頭牛被所有牛崇拜。

Sample Input
3 3
1 2
2 1
2 3
Sample Output
1

顯然一個強聯通分量內的所有點都是滿足條件的，我們可以對整張圖進行縮點，然後就簡單了。

剩下的所有點都不是強連通的，現在整張圖就是一個DAG（有向無環圖）

那麼就變成一道水題了，因爲這是一個有向無環圖，不存在所有點的出度都不爲零的情況。

所以必然有1個及以上的點出度爲零，如果有兩個點出度爲零，那麼這兩個點肯定是不相連的，即這兩圈牛不是互相崇拜的，於是此時答案爲零，如果有1個點出度爲0，那麼這個點就是被全體牛崇拜的，

這個點可能是一個強聯通分量縮成的超級點，所以應該輸出整個強聯通分量中點的個數。

代碼：

#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

int dfn[10010],low[10010],vis[10010],stack[10010],color[10010],du[10010],cnt[10010];
int n,m,top,sum,deep,tmp,ans;
vector<int> g[10010];

void tarjan(int u)
{
    dfn[u]=low[u]=++deep;
    vis[u]=1;
    stack[++top]=u;
    int sz=g[u].size();
    for(int i=0; i<sz; i++)
    {
        int v=g[u][i];
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else
        {
            if(vis[v])
            {
                low[u]=min(low[u],low[v]);
            }
        }
    }
    if(dfn[u]==low[u])
    {
        color[u]=++sum;
        vis[u]=0;
        while(stack[top]!=u)
        {
            color[stack[top]]=sum;
            vis[stack[top--]]=0;
        }
        top--;
    }
}


int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(vis,0,sizeof(du));
        memset(vis,0,sizeof(low));
        memset(dfn,0,sizeof(dfn));
        memset(vis,0,sizeof(vis));
        memset(vis,0,sizeof(cnt));
        memset(vis,0,sizeof(color));
        memset(vis,0,sizeof(stack));
        for(int i=1; i<=n; i++)
        {
            g[i].clear();
        }
        for(int i=1; i<=m; i++)
        {
            int from,to;
            scanf("%d%d",&from,&to);
            g[from].push_back(to);
        }
        for(int i=1; i<=n; i++)
        {
            if(!dfn[i])
            {
                tarjan(i);
            }
        }
        for(int i=1; i<=n; i++)
        {
            int sz=g[i].size();
            for(int j=0; j<sz; j++)
            {
                int v=g[i][j];
                if(color[v]!=color[i])
                {
                    du[color[i]]++;
                }
            }
            cnt[color[i]]++;
        }
        for(int i=1; i<=sum; i++)
        {
            if(du[i]==0)
            {
                tmp++;
                ans=cnt[i];
            }
        }
        if(tmp==0)
        {
            printf("0\n");

        }
        else
        {
            if(tmp>1)
            {
                printf("0\n");
            }
            else
            {
                printf("%d\n",ans);
            }
        }
    }
}

三、tarjan求割點、橋

1、什麼是割點、橋

再來引用一遍度娘：

在一個無向圖中，如果有一個頂點集合，刪除這個頂點集合以及這個集合中所有頂點相關聯的邊以後，圖的連通分量增多，就稱這個點集爲割點集合。

又是一臉懵逼。。。。

總而言之，就是這個點維持着雙聯通的繼續，去掉這個點，這個連通分量就無法在維持下去，分成好幾個連通分量。

比如說上圖紅色的即爲一個割點。

橋：

如果一個無向連通圖的邊連通度大於1，則稱該圖是邊雙連通的 (edge biconnected)，簡稱雙連通或重連通。一個圖有橋，當且僅當這個圖的邊連通度爲 1，則割邊集合的唯一元素被稱爲橋(bridge)，又叫關節邊(articulationedge)。一個圖可能有多個橋。（該資料同樣來自百度）

對於連通圖有兩種雙聯通，邊雙和點雙，橋之於邊雙如同割點之於點雙

如圖則是一個橋。

2、割點和橋怎麼求？

與之前強連通分量中的tarjan差不多。但要加一個特判，根節點如果有兩個及以上的兒子，那麼他也是割點。

模板題：洛谷3388

求割點的個數和數量

代碼：

#include<cstdio> 
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#define hi printf("hi!");
using namespace std;

vector<int> g[10010];
int dfn[10010],low[10010],iscut[10010],son[10010];
int deep,root,n,m,ans;

int tarjan(int u,int fa)
{
    int child=0,lowu;
    lowu=dfn[u]=++deep;
    int sz=g[u].size();
    for(int i=0;i<sz;i++)
    {
        int v=g[u][i];
        if(!dfn[v])
        {
            child++;
            int lowv=tarjan(v,u);
            lowu=min(lowu,lowv);
            if(lowv>dfn[u])
            {
                iscut[u]=1;
            }
        }
        else
        {
            if(v!=fa&&dfn[v]<dfn[u])
            {
                lowu=min(lowu,dfn[v]);
            }
        } 
    }
    if(fa<0&&child==1)
    {
        iscut[u]=false;
    }
    low[u]=lowu;
    return lowu;
} 

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int from,to;
        scanf("%d%d",&from,&to);
        g[from].push_back(to);
        g[to].push_back(from);
    }
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i])
        {
            root=i;
            tarjan(i,-1);
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(iscut[i])
        {
            ans++;
        }
    }
    printf("%d\n",ans);
    for(int i=1;i<=n;i++)
    {
        if(iscut[i])
        {
            printf("%d ",i);
        }
    }
}

橋的求法也差不多

並沒有找到模板題目，所以只好把沒檢驗過的代碼放着了......如有錯誤還請留言指正

#include<cstdio> 
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#define hi printf("hi!");
using namespace std;

vector<pair<int,int> >bridge;
vector<int> g[10010];
int dfn[10010],low[10010];
int deep,root,n,m,ans;

int tarjan(int u,int fa)
{
    int lowu;
    lowu=dfn[u]=++deep;
    int sz=g[u].size();
    for(int i=0;i<sz;i++)
    {
        int v=g[u][i];
        if(!dfn[v])
        {
            int lowv=tarjan(v,u);
            lowu=min(lowu,lowv);
            if(lowv>dfn[u])
            {
                int from,to;
                from=u;
                to=v;
                if(from>to)
                {
                    swap(from,to);
                }
                bridge.push_back(make_pair(from,to));
            }
        }
        else
        {
            if(v!=fa&&dfn[v]<dfn[u])
            {
                lowu=min(lowu,dfn[v]);
            }
        } 
    }
    low[u]=lowu;
    return lowu;
} 

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int from,to;
        scanf("%d%d",&from,&to);
        g[from].push_back(to);
        g[to].push_back(from);
    }
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i])
        {
            root=i;
            tarjan(i,-1);
        }
    }
    for(int i=0;i<bridge.size();i++)
    {
        printf("%d %d\n",bridge[i].first,bridge[i].second);
    }
}

標籤: tarjan, 算法小講堂

好文要頂關注我收藏該文