最小生成树 二分图

最小生成树

最小生成树 题目都是无向图 重边自环负权边都无所谓

Prim算法 应对无向稠密图

Prim很像Dij 区别在于维护距离为的是到已知集合(当前最小生成树)的距离 且Prim可以处理负边

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

const int N=510;
int g[N][N];
int d[N],ST[N];                             d代表到已知生成树的距离 ST代表是否在已知生成树中
int n,m;

int Prim(){
	memset(d,0x3f,sizeof(d));               初始化为最大值
	int res=0;
	
	for(int i=0;i<n;i++){					连续选n个点
		int t=-1;
		for(int j=1;j<=n;j++){
			if(!ST[j]&&(t==-1||d[j]<d[t])) t=j;   选距离生成树最近的其他点
		}
		
		ST[t]=1;							放入生成树
		if(i&&d[t]==0x3f3f3f3f) return 0x3f3f3f3f; 不是第一个且得到的是最大值 则不连通 无生成树
		if(i) res+=d[t];							不是第一个 则记下这条边的长度
		
		
		for(int j=1;j<=n;j++) d[j]=min(d[j],g[t][j]);  
	}
	
	return res;
}

int main(){
	cin>>n>>m;
	memset(g,0x3f,sizeof(g));
	while(m--){
		int u,v,w;
		cin>>u>>v>>w;
		g[u][v]=g[v][u]=min(g[u][v],w);
	}
	int t=Prim();                         
	if(t==0x3f3f3f3f) cout<<"impossible";
	else cout<<t;
}

克鲁斯卡尔算法 应对无向稀疏图

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

int n,m;
const int M=200010;
int p[N];

struct Edge{  					和Bellman-Ford一样结构体存边
	int a,b,w;
	bool operator<(Edge x)const{
		return w<x.w;
	}
}edge[M];

int find(int x){
	if(p[x]!=x) p[x]=find(p[x]);
	return p[x];
}

int kruskal(){
	int res=0,cnt=0;        cnt计数加入多少点 
	for(int i=1;i<=N;i++){  初始化并查集 
		p[i]=i;
	}
	sort(edge,edge+m);      
	for(int i=0;i<m;i++){   逐边检查是否两端点在一集合内
		int a=edge[i].a; int b=edge[i].b; int w=edge[i].w;
		a=find(a);  b=find(b);
		if(a!=b){
			p[a]=b;
			res+=w;
			cnt++; 
		}
	} 
	if(cnt<n-1) return -1;
	else return res;
}

int main(){
	cin>>n>>m;
	for(int i=0;i<m;i++){
		int a,b,w;
		cin>>a>>b>>w;
		edge[i]={a,b,w};
	}
	
	int t=kruskal();
	if(t==-1) cout<<"impossible";
	else cout<<t;
}

二分图

一个图为二分图等价其为不含奇圈的无向图

染色法 O(n+m) 无向图要存重边

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

const int N=100010, M=200010;

int h[N],e[M],ne[M],idx;
int color[N];
int n,m;

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

int DFS(int u,int c){
	color[u]=c;
	for(int i=h[u];i!=-1;i=ne[i]){
		int j=e[i];
		if(!color[j]){
			if(!DFS(j,3-c)) return 0;       DFS返回信息！！
		}
		else{
			if(color[j]==c) return 0;
		}
	}
	return 1;
}

int main(){
	memset(h,-1,sizeof(h));
	cin>>n>>m;
	for(int i=0;i<m;i++){
		int a,b;
		cin>>a>>b;
		add(a,b); add(b,a);    无向图！！！！ 
	}
	int flag=1;   是二分图
	for(int i=1;i<=n;i++){  DFS 且防止不连通 
		if(!color[i]){ 		 未dfs过 
			if(!DFS(i,1)){  默认颜色为1 
				flag=0;
				break;
			}  		
		} 
	}
	if(flag) cout<<"Yes";
	else cout<<"No";
}

匈牙利算法O(mn) 实际运行时间小 用于求二分图的最大匹配

匹配：二分图G，在G的一个子图M中，M的边集{E}中的任意两条边都不依附于同一个顶点，则称M是一个匹配。
思路：遍历男生，男生如果对应一个单身女生，则配对； 如果对应的女生已有男朋友A，则看A能不能换女朋友。

重点在于match数组存女生匹配的男生
st数组在每次选妃中判重 每次选妃前都要更新所有妹子available

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

const int N=510,M=100010;
int h[N],e[M],ne[M],idx;
int match[N],ST[N];  //match和ST数组都是对应女生的 
int n1,n2,m;

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

int find(int u){
	for(int i=h[u];i!=-1;i=ne[i]){
		int j=e[i];
		if(!ST[j]){
			ST[j]=1;
			if(!match[j]||find(match[j])){
				match[j]=u;
				return 1;
			}
		}
	}
	return 0;
}


int main(){
	int max_num=0;
	memset(h,-1,sizeof(h));
	cin>>n1>>n2>>m;
	while(m--){
		int a,b;
		cin>>a>>b;
		add(a,b);    只加从男到女即可 
	}
	for(int i=1;i<=n1;i++){
		memset(ST,0,sizeof(ST));    !! 每次选妃要更新ST[]数组 
		if(find(i)) max_num++;
	}
	cout<<max_num;
}