24-3-25拓扑+二分图+tarjan

确定比赛名次问题（图的拓扑排序+单调队列） 

原文链接：https://blog.csdn.net/Mitchell_Donovan/article/details/116654722

问题描述：

有N个比赛队伍(1<=N<=500)，编号依次为1,2,3,⋯⋯, N，进行比赛。比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即如果P1赢P2, 用P1 P2表示，排名时P1在P2之前。现在请你编程序确定排名。

输入：输入有若干组，每组中的第一行为二个数N和M其中，N表示队伍的个数，且1<=N<=500,M表示接着有M行的输入数据。接下来的M行数据中，每行包含两个整数P1和P2, 表示P1队赢了P2队。

输出：给出一个符合要求的排名，无法确定名次的队伍输出时编号小的队伍在前。    

思路：Q放深度为0的点，mark记从Q中已弹出过的元素，matrix[u][v]记u与v有无路，depth记元素深度

#include<iostream>
#include<stdio.h>
#include<vector>
#include<queue>
using namespace std;
void topsort(int numvextex,vector<vector<int>>& matrix,vector<int>& depth){
	vector<int>mark(numvextex+1,0);
	priority_queue<int,vector<int>,greater<int>>Q;//存储的元素类型是 int，greater<int>从小到大的顺序
	for(int i=1;i<=numvextex;i++){//初始化Q,成环的那一部分没有元素深度为0
		if(depth[i]==0)Q.push(i);
	}
	while(!Q.empty()){
		int v=Q.top();//依次遍历
		Q.pop();
		cout<<v<<" ";
		mark[v]=1;
		for(int i=1;i<=numvextex;i++){//查找路径
			if(matrix[v][i]){
				depth[i]--;//更新子节点深度
				if(depth[i]==0){
					Q.push(i);
				}
			}
		}
	}
	for(int i=1;i<=numvextex;i++){//检查是否成环
		if(mark[i]==0){
			printf("mark[%d]:%d\n",i,mark[i]);
			cout<<"circle"<<endl;
			break;
		}
	}	
}
int main(void){
	int n,m;cin>>n>>m;
	vector<vector<int>>matrix(n+1,vector<int>(n+1,0));
	vector<int>depth(n+1,0);
	for(int i=0;i<m;i++){
		int u,v;cin>>u>>v;
		matrix[u][v]=1;
		depth[v]++;
	}
	topsort(n,matrix,depth);
}

二分图的最大匹配

[AcWing]861. 二分图的最大匹配（C++实现）匈牙利算法匹配二分图模板题_匈牙利算法 c++实现-CSDN博客

给定一个二分图,其中左半部包含n1个点(编号1~n1),右半部包含n2个点(编号1~n2),二分图共包
含m条边。

数据保证任意一条边的两个端点都不可能在同一部分中。

请你求出二分图的最大匹配数。

二分图的匹配:给定一个二分图G,在G的一个子图M中,M的边集{E}中的任意两条边都不依附于同
一个顶点,则称M是一个匹配。

二分图的最大匹配:所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配,其边数即为最大匹配数。

输入格式
第一行包含三个整数n1、n2和m。

接下来m行,每行包含两个整数u和v,表示左半部点集中的点u和右半部点集中的点v之间存在一条边。

输出格式
输出一个整数,表示二分图的最大匹配数。

思路：e[idx]=b;ne[idx]=h[a];h[a]=idx++;为关键连接元素代码，find依路径寻找各点有无能连通的路，从头找到尾，st记录该方案下已找寻过的点

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, M = 100010;
int n1,n2,m;
int match[N];
bool st[N];
int h[N],e[N],ne[N],idx;//ne所连点的下一点，h该条边所连点1 2 3
void add(int a,int b){
	e[idx]=b;ne[idx]=h[a];h[a]=idx++;
	//e中第idx号元素为b，记b元素
	//ne第idx号元素为节点a的头结点，记a号码
	//h节点a的头结点指向 e 数组中第idx+1号元素，更新a号码
}
bool find(int x){
	for(int i=h[x];i!=-1;i=ne[i]){
		int j=e[i];
		printf("st[%d]:%d\n",j,st[j]);
		if(st[j]==0){
			st[j]=1;
			if(match[j]==0||find(match[j])){//若1头节点为2，若2仍有头节点，即使2已经匹配也可以更新
				match[j]=x;
				printf("match[%d]:%d\n",j,match[j]);
				return true;
			}
		}
	}
	return false;
}
int main(void){
	scanf("%d%d%d", &n1, &n2, &m);
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);
    }
    int res=0;
    for(int i=1;i<=n1;i++){
    	memset(st,false,sizeof(st));
    	if(find(i))res++;
	}
	printf("%d",res);
}

强连通Tarjan算法

思路：每个节点的访问顺序（dfn），它所能够追溯到的最早的祖先节点（low），id强连通编号，stk防止强连通量记重，g[u][i]为u号连的第i个号码

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

const int maxn = 100005;
vector<int> g[maxn];
int dfn[maxn], low[maxn], id[maxn];
int res=0,timestamp=0;
bool in_stk[maxn],vis[maxn];
stack<int> stk;

void tarjan(int u){
    vis[u] = true;
    stk.push(u);
    in_stk[u] = true;
    dfn[u] = low[u] = ++timestamp;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(!vis[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(in_stk[v]){
            low[u]=min(low[u],dfn[v]);
//节点 v 能够追溯到的最早祖先节点就是节点 v 自身，所以应该考虑节点 v 的 dfn 值
        }
    }
    if(dfn[u]==low[u]){
        do{
            int y=stk.top();
            stk.pop();
            in_stk[y]=false;
            id[y]=res;
        }while(y!=u);//第一个元素是u也顺利弹出
        res++;
    }
}

int main(void){
    int n, m;
    cin >> n >> m;
    for(int i=0;i<m;i++){
        int u,v; cin>>u>>v;
        g[u].push_back(v);
    }
    for(int i=1;i<=n;i++){
        if(!vis[i]){
            tarjan(i);
        }
    }
    cout << res;
    return 0;
}