因为最近在搞图论,这部分内容比较杂,有些地方的思路有些相似,先临时总结一下,之后有空在仔细的修订吧
一.强连通分量
先上百科定义有向图强连通分量:在有向图G中,如果两个顶点vi,vj间(vi>vj)有一条从vi到vj的有向路径,同时还有一条从vj到vi的有向路径,则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通,称G是一个强连通图。有向图的极大强连通子图,称为强连通分量(strongly connected components)。那么把定义搞明白了,我们就要学习怎样求解强连通分量了
1.Kosaraju算法
思路大致就是酱紫的,至于问什么嘛,有空再补补算法导论,今天先整理一下
Kosaraju_Algorithm:
实现齐来也不是很困难,贴一个不错的模板吧
//Kosaraju
const int N =10010, M=50010;
struct node
{
int to, next;
}edge[M],edge2[M]; //edge是逆图,edge2是原图
int dfn[N], head[N], head2[N], belg[N], num[N];
//dfn时间戳
//belg记录每个点属于哪个连通分量,num记录强连通分量点的个数
bool vis[N];
int cnt,cnt1,scc,tot,tot1;
void dfs1(int u)
{
vis[u]=1;
for(int k=head2[u];k!=-1;k=edge2[k].next)
if(!vis[edge2[k].to]) dfs1(edge2[k].to);
dfn[++cnt1]=u;
}
void dfs2(int u)
{
vis[u]=1;
cnt++;
belg[u]=scc;
for(int k=head[u];k!=-1;k=edge[k].next)
if(!vis[edge[k].to]) dfs2(edge[k].to);
}
void Kosaraju(int n)
{
memset(dfn,0,sizeof(dfn));
memset(vis,0,sizeof(vis));
cnt1=scc=0;
for(int i=1;i<=n;i++)
if(!vis[i]) dfs1(i);
memset(vis,0,sizeof(vis));
for(int i=cnt1;i>0;i--)
if(!vis[dfn[i]])
{
cnt=0;
++scc;
dfs2(dfn[i]);
num[scc] = cnt;
}
}
void init()
{
tot=tot1=0;
memset(head,-1,sizeof(head));
memset(head2,-1,sizeof(head2));
memset(num,0,sizeof(num));
}
void addedge(int i,int j)
{
edge2[tot1].to=j; edge2[tot1].next=head2[i];head2[i]=tot1++;
edge[tot].to=i; edge[tot].next=head[j];head[j]=tot++;
}
2.tarjan算法
tarjan?太监?发现百科写的好像还不错先放到这里吧
//Tarjan
const int N =1010, M=100010;
struct node
{
int to, next;
}edge[M];
int head[N], low[N], dfn[N], sta[N], belg[N], num[N];
bool vis[N];
int scc,index,top, tot;
void tarbfs(int u)
{
int i,j,k,v;
low[u]=dfn[u]=++index;
sta[top++]=u;
vis[u]=1;
for(i=head[u];i!=-1;i=edge[i].next)
{
v=edge[i].to;
if(!dfn[v])
{
tarbfs(v);
if(low[u]>low[v]) low[u]=low[v];
}
else if(vis[v]&&low[u]>dfn[v]) low[u]=dfn[v];
}
if(dfn[u]==low[u])
{
scc++;
do
{
v=sta[--top];
vis[v]=0;
belg[v]=scc;
num[scc]++;
}
while(v!=u) ;
}
}
void Tarjan(int n)
{
memset(vis,0,sizeof(vis));
memset(dfn,0,sizeof(dfn));
memset(num,0,sizeof(num));
memset(low,0,sizeof(low));
index=scc=top=0;
for(int i=1;i<=n;i++)
if(!dfn[i]) tarbfs(i);
}
void init()
{
tot=0;
memset(head,-1,sizeof(head));
}
void addedge(int i,int j)
{
edge[tot].to=j; edge[tot].next=head[i];head[i]=tot++;
}
二.求图的割点
1.图的割点
2.寻找图的割点
3.数据
6 7
1 3
1 4
4 2
3 2
2 5
2 6
5 6
用邻接矩阵写的,写的略渣,有空用邻接表写一下
//
// main.cpp
// 图的割点
//
// Created by 张嘉韬 on 16/8/29.
// Copyright © 2016年 张嘉韬. All rights reserved.
//
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
const int maxn=1000;
int min(int a,int b)
{
if(a<b) return a;
else return b;
}
int map[maxn][maxn],n,m,x,y,root,flag[maxn],indx,num[maxn],low[maxn];
void dfs(int cur,int father)
{
int child=0;
indx++;
num[cur]=indx;
low[cur]=indx;
for(int i=1;i<=n;i++)
{
if(map[cur][i]==1)
{
if(!num[i])
{
dfs(i,cur);// 子节点就去dfs()
low[cur]=min(low[cur],low[i]);
if(cur!=root&&low[i]>=num[cur]) flag[cur]=1;
if(cur==root&&child==2) flag[cur]=1;//虽然未遍历完但是如果有两个两个子节点了那么一定就是割点。
}
else if(num[i]&&i!=father)
low[cur]=min(num[i],low[cur]);
}
}
}
int main(int argc, const char * argv[]) {
freopen("/Users/zhangjiatao/Documents/暑期训练/input.txt","r",stdin);
memset(map,0,sizeof(map));
memset(flag,0,sizeof(flag));
memset(num,0,sizeof(num));
memset(low,0,sizeof(low));
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&x,&y);
map[x][y]=1;
map[y][x]=1;
}
root=1;
indx=0;
dfs(1,root);
for(int i=1;i<=n;i++) cout<<num[i]<<" ";
cout<<endl;
for(int i=1;i<=n;i++) cout<<low[i]<<" ";
cout<<endl;
for(int i=1;i<=n;i++)
if(flag[i]) printf("%d\n",i);
return 0;
}
三.网络流之最大流问题
思路还是很简单的,每次找一条能够联通起点和终点的路径(增广路),然后在这条路径上减去这条路径的流量(当然就是这条路径的最小边的流量啦),然后这还没完,因为最大流其实是与增广路的顺序有关?(这一点其实还不是很懂,有时间补补再修订),所以当然不可以就这样直接减去了,我们把这些流量都添加到反向的边上,那么这一步的意思很明显,因为我们不确定最终的最大流中一定蕴含着这条边,所以我们让流过去的水流再流回来,那么其实相当于原图是没有发生改变的,那么就不会妨碍到我接着寻找真正在最大流中的增广路啦。
算法步骤:
1。寻找增广路并记录流量
2。在余量图中减去这条增广路的流量,在反向边中加上这个流量,在结果ans中加上这个流量。
3。重复步骤1,直到找不到增广路,那么就结束ans就是答案
试着用邻接表写过一次。。。最后写不下去了,添加反向边用邻接表写起来真的很麻烦
//
// main.cpp
// drainage ditches
//
// Created by 张嘉韬 on 16/8/19.
// Copyright © 2016年 张嘉韬. All rights reserved.
//
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
const int maxn=200+10;
const int inf=1<<30;
int n,m,map[maxn][maxn];
int Augment()
{
int flag=0;
int pre[maxn];
int vis[maxn];
for(int i=0;i<maxn;i++) vis[i]=pre[i]=0;
queue<int> q;
q.push(1);
vis[1]=1;
pre[1]=0;
while(!q.empty())
{
int temp=q.front();
q.pop();
for(int i=1;i<=n;i++)
{
if(!vis[i]&&map[temp][i]>0)
{
q.push(i);
vis[i]=1;
pre[i]=temp;
if(i==n)
{
flag=1;
while(!q.empty()) q.pop();
}
}
}
}
if(!flag) return 0;
int nMinFlow=inf;
int v=n;
while(pre[v])
{
nMinFlow=min(nMinFlow,map[pre[v]][v]);
v=pre[v];
}
v=n;
while(pre[v])
{
map[pre[v]][v]-=nMinFlow;
map[v][pre[v]]+=nMinFlow;
v=pre[v];
}
return nMinFlow;
}
int main(int argc, const char * argv[]) {
//freopen("/Users/zhangjiatao/Documents/暑期训练/input.txt","r",stdin);
while(scanf("%d%d",&m,&n)!=EOF)
{
for(int i=0;i<maxn;i++)
for(int j=0;j<maxn;j++)
map[i][j]=0;
for(int i=1;i<=m;i++)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
map[u][v]+=w;
}
int ans=0,nMinFlow;
while(nMinFlow=Augment()) ans+=nMinFlow;
printf("%d\n",ans);
}
return 0;
}
四.二分图最大匹配 匈牙利算法
1.二分图
首先啥叫二分图呢,有请度娘:
2.二分图最大匹配问题
3.匈牙利算法
有一个很好的讲解教程点击打开链接
我这里也贴一下我的关于一到模板题的匈牙利算法的见解
Problem Description
Input
1<=N 和M<=500.接下来的K行,每行有两个数,分别表示女生Ai愿意和男生Bj做partner。最后一个0结束输入。
Output
Sample Input
6 3 3 1 1 1 2 1 3 2 1 2 3 3 1 0
Sample Output
3
很典型的二分图最大匹配问题,匈牙利算法直接可以解决,这篇匈牙利算法讲解很生动:点击打开链接
其实一开始看上面这个教程的时候还是有一些地方不太明白,这里解释一下。
这里我特别想解释一下这个used状态到底起了什么作用,看了上面的教程,我们基本上清楚了每个妹子匹配男生的过程,让我们来模拟一下:
妹子a,找到了男生A
妹子b,找到了男生B
妹子c,找到了男生A,然后我们就要男生A对应的女生a去找新的男生,这个新的男生还不能是男生A,为了这个目的,我们需要让每次妹子找到一个可以匹配的男生的时候都要把他的used状态标记成1,这样需要这个男生的原配女生找其他男生的时候就不会找到男生A了(汗。。。)
// // main.cpp // HDU 2603 // // Created by 张嘉韬 on 16/8/19. // Copyright © 2016年 张嘉韬. All rights reserved. // #include <iostream> #include <cstring> #include <cstdio> #include <vector> using namespace std; const int maxn=500+10; int k,m,n,map[maxn][maxn],used[maxn],boy[maxn]; int find(int x) { for(int i=1;i<=n;i++)//遍历所有男生 { if(map[x][i]&&used[i]==0)//这里我想解释一下这个used到底起了什么作用
{ used[i]=1; //对所有已经访问过的男生做标记 if(boy[i]==0||find(boy[i])) { boy[i]=x; return 1; } } } return 0; } int main(int argc, const char * argv[]) { freopen("/Users/zhangjiatao/Documents/暑期训练/input.txt","r",stdin); while(scanf("%d%d%d",&k,&m,&n)) { if(k==0) break; for(int i=0;i<maxn;i++) for(int j=0;j<maxn;j++) map[i][j]=0; for(int i=1;i<=k;i++) { int a,b; scanf("%d%d",&a,&b); map[a][b]=1; } int r=0; for(int i=1;i<=n;i++) boy[i]=0; for(int i=1;i<=m;i++) { for(int j=0;j<maxn;j++) used[j]=0; if(find(i)) r++; } printf("%d\n",r); } return 0; }
4.最大流解法
思想很简单,就是用一个超级源点连接U,超级汇点连接V,每一条边的容量为1,然后求解最大流就可以了,因为我们的每一个增广路都对应着一个匹配
二分图最大匹配问题除了匈牙利算法,还有就是最大流增广路算法啊,思路是这样的,
随便找了一张二分图,我们只要给U加一个超级源节点,和一个超级汇点直接求这个图的最大流就可以,然而这样会超时,因为这个算法的时间复杂度是O(m*n) (n = |V|, m = |E|),但是匈牙利算法的复杂度二分图的左半边一共有n个点,最多找n条增广路径,如果图中有m条边,每一条增广路径把所有边遍历一遍,所以时间复杂度为O(n*m),要更快一些。
#include <iostream> #include <cstring> #include <cstdio> #include <stack> using namespace std; const int maxn=1010; int map[maxn][maxn],k,m,n; void init() { for(int i=0;i<maxn;i++) for(int j=0;j<maxn;j++) map[i][j]=0; } int dfs() { int vis[maxn],pre[maxn],flag=0; memset(vis,0,sizeof(vis)); memset(pre,-1,sizeof(pre)); stack <int> st; st.push(0); vis[0]=1; while(!st.empty()) { int temp=st.top(); st.pop(); for(int i=0;i<=m+n+1;i++) { if(map[temp][i]&&!vis[i]) { vis[i]=1; st.push(i); pre[i]=temp; if(i==m+n+1) { flag=1; break; } } } } if(flag) { int k=m+n+1; while(k!=0) { map[pre[k]][k]-=1; map[k][pre[k]]+=1; k=pre[k]; } return 1; } else return 0; } int main() { //freopen("input.txt","r",stdin); while(scanf("%d",&k)) { if(k==0) break; init(); scanf("%d%d",&m,&n); for(int i=1;i<=k;i++) { int u,v; scanf("%d%d",&u,&v); map[u][v+m]=1; } for(int i=1;i<=m;i++) map[0][i]=1; for(int i=1;i<=n;i++) map[m+i][m+n+1]=1; int ans=0,nMinFlow; while((nMinFlow=dfs())) ans+=nMinFlow; printf("%d\n",ans); } return 0; }
5.最大匹配的应用
网络流有许多性质,最大匹配还可以用来解决许多其他问题
二分图匹配中较为重要的三个公式:
二分图最小顶点覆盖 = 二分图最大匹配;
DAG图的最小路径覆盖 = 节点数(n)- 最大匹配数;
二分图最大独立集 = 节点数(n)- 最大匹配数;
五.拓扑排序