【NOIp复习】图论算法模板合集
最小生成树
Kruskal
//Kruskal
struct edge{
int from,to,val;
}e[maxn];
bool operator < (const edge&a,const edge&b){
return a.val<b.val;//边按边权排序
}
int find(int a){
return fa[a]==a ? fa[a] : fa[a]=find(fa[a]);
}
void Kruskal(){
int cnt=0;
sort(e+1,e+m+1);
for(int i=1,j=0;i<=m,j<n-1;i++){
int a=e[i].from,b=e[i].to;
if(find(a)!=find(b)){
//你想干嘛干嘛吧
fa[find(a)]=find(b);
j++;//加入n-1条边就可以跳出循环啦
}
}
}最小完全图
//最小树的最小完全图：
//在Kruskal算法中，当前添加的边是连接两边所在集合的边权最小的边
//所以将边从小到大考察，该边左右端点所在并查集连的边数为f[u]*f[v]-1（因为本来已经有这条边了嘛）
//然后因为这条边是最小的，所以其他的边最小也应该是e[i].val+1
//合并两边并查集，搞腚
//在并查集中，用f[]数组记录以i为根节点的并查集大小，
//union操作实现如下：
void Union(int a,int b){
int x=find(a),y=find(b);
//以将a合并到b为例
f[y]+=f[x];
fa[x]=y;
}Prim&前向星
typedef pair<int,int> pii;//<dist,idx>，用于堆排序
int cnt=0,head[maxn],dis[maxn];
bool vis[maxn];
struct edge{
int to,next,val;
}e[maxn*3];
bool cmp(pii a,pii b){
return a.first>b.first;//小根堆
}
void add(int u,int v,int val){
for(int i=head[u];~i;i=e[i].next){
if(e[i].to==v){
if(e[i].val>val) e[i].val=val;
return;
}
}
e[++cnt].to=v;
e[cnt].val=val;
e[cnt].next=head[u];
head[u]=cnt;
}
void Prim(int s){
int ans=0;
memset(dis,-1,sizeof(dis));
memset(vis,0,sizeof(vis));
priority_queue<pii,vector<pii>,cmp> q;
for(int i=head[s];~i;i=e[i].next){
dis[e[i].to]=e[i].val;//初始化与源点相连的所有节点
q.push(make_pair(dis[e[i].to],e[i].to))//入队待扩展
}
dis[s]=0; vis[s]=1;//初始化源点
while(!q.empty()){
pii u=q.top(); q.pop();
if(vis[u.second]) continue;//跳过已访问节点
vis[u.second]=1;
ans+=u.first;//用于统计最小生成树边权和
for(int i=head[u.second];~i;i=e[i].next){//将与新加入节点相连的所有节点加入堆
int j=e[i].to;
if(!vis[j]&&(dis[j]>e[i].val||dis[j]==-1)){//如果目标节点未被访问且（访问边是当前最小的边或目标节点尚未被访问过）
dis[j]=e[i].val; //就将dis更新为当前边权，入堆
q.push(make_pair(dis[j],j));
}
}
}
printf("%d\n",ans);//输出最小生成树边权和
}最短路
SPFA
int dis[maxn];
bool vis[maxn];
bool SPFA(int s){//传入源点，传出是否有负环
int stat[maxn];//统计节点的入队次数，大于节点数n说明有负环
bool flag=0;
memset(stat,0,sizeof(stat));
memset(dis,0x3f,sizeof(dis));//到源点的距离
memset(vis,0,sizeof(vis)); //是否在队列内
queue<int> q;
q.push(s); vis[s]=1;
while(!q.empty()){
if(flag) break;
int tmp=q.front(); q.pop(); vis[tmp]=0;
for(int i=head[tmp];~i;i=e[i].next){
int cur=e[i].to;
if(dis[cur]>dis[tmp]+e[i].val){
dis[cur]=dis[tmp]+e[i].val;
vis[cur]=1; stat[cur]++;
if(stat[cur]>n){
flag=1; break;
}
q.push(cur);
}
}
}
return flag;
}Dijkstra
void Dijkstra(int s){
//堆优化乱搞
priority_queue<pii> q;
bool cmp(pii a,pii b){
return a.first>b.first;
}
//init
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
q.push(make_pair(dis[s]=0,s));//初始化源点
for(int i=head[s];~i;i=e[i].next){
int cur=e[i].to;
dis[cur]=e[i].val;
q.push(make_pair(dis[cur],cur));
}
while(!q.empty()){
int tmp=q.top(); q.pop();
if(vis[tmp]) continue;
for(int i=head[tmp];~i;i=e[i].next){
int cur=e[i].to;
if(!vis[cur]&&dis[cur]>dis[tmp]+e[i].val){
dis[cur]=dis[tmp]+e[i].val;
vis[cur]=1; q.push(make_pair(dis[cur],cur));
}
}
}
}Floyd
普通版
//普通版Floyd
void Floyd(){
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(dis[i][j]>dis[i][k]+dis[k][j]) dis[i][j]=dis[i][k]+dis[k][j];
//在读入边的时候边权作为dis即可
}求最小环
//算最小环
//一个环可以拆成一条链加一条边，
//算floyd的时候保证中间点k的编号比i大比j小，就可以保证首尾不经过k点
void Floyd_minimum_cycle(){
for(int k=1;k<=n;k++){
for(int i=1;i<k;i++)
for(int j=k+1;j<=n;j++)
ans=min(ans,dis[i][j]+map[i][k]+map[k][j]);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}
}
//有向图求最小环，直接用floyd就可以，以s为起点的环长度为d[s][k]+d[k][s]
//也可以跑Dijkstra先算从s到所有点的最短距离，再算所有点到s的最短距离
//求以s为终点的单（终点）最短路，把图上所有边反过来就好最近公共祖先（LCA）
Tarjan
bool flag[maxn],answered[maxn];
vector<pii> qes;//用来存询问
void csh(){//初始化...
memset(flag,0.sizeof(flag));//用来标记是否已经算过LCA了
for(int i=1;i<=n;i++) fa[i]=i;
memset(head,0,sizeof(head));
memset(answered,0,sizeof(answered));//用来标记是否已经回答过询问了
}
void Union(int x,int y){
fa[find(y)]=find(x); return;//将y集合加入x中
}
void LCA(int p,int f){//p为当前节点，f为当前节点的父亲（防止倒流...）
for(int i=head[p];~i;i=e[i].next){
if(e[i].to!=f&&!flag[to]){
LCA(e[i].to,p);
Union(p,e[i].to);
flag[to]=1;
}
}
//处理询问
}
使用方法：LCA(根节点，0);RMQ+DFS（倍增）
void dfs(int rt){
for(int i=head[rt];~i;i=e[i].next){
if(!dep[e[i].to]){
dep[e[i].to]=dep[rt]+1;
p[e[i].to][0]=rt;//p[i][0]为i的直接父节点
dfs(e[i].to);
}
} return;
}
void init_bz(){
//p[i][j]为i节点的第2^j祖先
for(int j=1;(1<<j)<=n;j++)
for(int i=1;i<=n;i++)
if(p[i][j-1]!=-1)
p[i][j]=p[p[i][j-1]][j-1];
return;
}
int LCA(int a,int b){
int i,j;
if(dep[a]<dep[b]) swap(a,b);//保证a是b的儿子节点
for(i=0;(1<<i)<=dep[a];i++); i--;
for(j=i;j>=0;j--)
if(dep[a]-(1<<j)>=dep[b]) a=p[a][j];
if(a==b) return a;
for(j=i;j>=0;j--)
if(p[a][j]!=-1&&p[a][j]!=p[b][j]){
a=p[a][j]; b=p[b][j];
}
return p[a][0];
}
使用方法：
dfs(1);//1为根节点
dep[1]=0;
p[1][0]=1;
//如果dfs时还要记与根节点距离的话，传入一个参数pa表示dfs节点的父节点即可 二分图
二分图染色
int col[maxn]; bool flag=1;
void ran(int p,int rt,int c){
if(col[rt]!=-1&&col[rt]!=c){
flag=0; return;
} else {
for(int i=head[rt];i!=0;i=e[i].next){
int cur=e[i].to;
ran(rt,cur,(c+1)%2);
}
return;
}
}二分图最大匹配（匈牙利算法）
读入优化
inline int read(){
int x=0,f=1; char ch=getchar();
while(ch<'0'||ch>'9'){
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
x=x*10+ch-'0'; ch=getchar();
}
return x*f;
}//读入优化来一波~~ NTR算法主体
int nx,ny,match[maxn];
bool vis[maxn],w[maxn][maxn];
bool find(int x){
for(int i=1;i<=ny;i++){
if(!w[x][i]||vis[i]) continue;//用vis来标记这个人有没有被霸占
vis[i]=1;//霸占该人
if(match[i]==-1||find(match[i])){//如果该人没有匹配，或者匹配更改可行（可NTR）
match[i]=x;//更改这个人的匹配到需要找对象的x身上
return 1;//NTR成功！
}
}
return 0;//返回：歌颂爱情的伟大！
}
int suan(){
int ans=0;
memset(match,-1,sizeof(match));//每个人初始化为没有对象
for(int i=1;i<=nx;i++){//对左边的每一个点尝试寻找对象
memset(vis,0,sizeof(vis));//千万记住初始化...最开始每个人都没有被霸占的
if(find(i)) ans++;//可匹配人数++
}
return ans;
}
int m,a,b;//m是边的条数，a/b为临时变量
int main(){
nx=read(); ny=read();
for(int i=1;i<=m;i++){
a=read(); b=read();
w[a][b]=1; //这里默认左右两边的编号都是从1开始好了
//如果题目不一样的话，只需要简单修改下就可以了
}
int out=suan();
if(out) printf("%d\n",out);
else puts("No.");
return 0;
}二分图最小完备匹配（KM算法）
不会网络流怎么破！！！！！！！！！！！！！
int nx,ny,linky[maxn];
double lack,w[maxn][maxn],lx[maxn],ly[maxn];
bool visx[maxn],visy[maxn];
bool find(int x){
visx[x]=1;
for(int i=1;i<=ny;i++){
if(visy[i]) continue;
int t=lx[x]+ly[i]-w[x][i];
if(t<0){
visy[i]=1;
if(linky[i]==-1||find(linky[i])){
linky[i]=x;
return 1;
}
} else if(t<lack) lack=t;
}
return 0;
}
double KM(){
memset(linky,-1,sizeof(linky));
for(int i=1;i<=ny;i++) ly[i]=0;
for(int i=1;i<=nx;i++){
lx[i]=INF;
for(int j=1;j<=ny;j++)
if(w[i][j]>lx[i]) lx[i]=w[i][j];
}
for(int x=1;x<=nx;x++){
while(1){
memset(visx,0,sizeof(visx));
memset(visy,0,sizeof(visy));
lack=INF;
if(find(x)) break;
for(int i=1;i<=ny;i++){
if(visx[i]) lx[i]-=lack;
if(visy[i]) ly[i]+=lack;
}
}
}
int ans=0;
for(int i=1;i<=ny;i++) ans-=w[linky[i]][i];
return ans;
} 拓扑排序
Kahn算法
priority_queue<int,vector<int>,greater<int> > s;//入度为0的集合，小根堆保证字典序最小
int in[maxn];//存放每个点的入度
vector<int> ans;
void Kahn(){
for(int i=1;i<=n;i++) if(in[i]==0) s.push(i);
while(!s.empty()){
int cur=s.top(); s.pop(); ans.push_back(cur);
for(int i=head[cur];i!=0;i=e[i].next){
int tmp=e[i].to;
in[tmp]--;
if(in[tmp]==0) s.push(tmp);
}
}
return;
}强连通分量
%Tarjan
stack<int> s;
bool vis[maxn];
int dfn[maxn],low[maxn],cnt=0,num=0;//时间戳，能回到的最远祖先，计数器（标记节点），计数器（标记强连通分量）
int qlt[maxn];//点i属于哪一个强连通分量
vector<int> ans[maxn];
void Tarjan(int u){
dfn[u]=low[u]=++cnt;
vis[u]=1;
s.push(u);
for(int i=head[u];i!=0;i=e[i].next){
int cur=e[i].to;
if(!vis[cur]){
Tarjan(cur);
low[u]=min(low[u],low[cur]);
} else if(!qlt[cur]) {
low[u]=min(low[u],low[cur]);
}
}
if(dfn[u]==low[u]){
num++;
while(1){
int tmp=s.top(); s.pop();
qlt[tmp]=num;
if(tmp==u) break;
}
}
}