Graph Theory collection template _ (b)

SPFA

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;

const int N=100010;
int h[N],e[N],ne[N],idx,w[N];
int dist[N];
bool st[N];
int n,m;

void add(int a,int b,int c){
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
int spfa()
{
	memset(dist , 0x3f , sizeof(dist));
	dist[1] = 0;
	
	queue<int> q ;
	q.push(1);
	st[1] = true;
	
	while(q.size())
	{
		int t = q.front();
		q.pop();
		
		st[t] = false;   // 点不在队列里面 
		
		for(int i = h[t] ; i != -1 ; i =ne[i])
		{
			int j = e[i];
			if(dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if(!st[j])
				{
					q.push(j);
					st[j] = true;
				} 
			}
		}
	}	
	
}

int main(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    cout<<spfa()<<endl;
    return 0;
}

Floyed

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 210 , INF = 1e9 ;

int n , m , Q;
int d[N][N];

void floyd()
{
	for(int k = 1 ; k <= n ; k++)
	{
		for(int i = 1 ; i <= n ; i++)
		{
			for(int j = 1 ; j <= n ; j++)
			{
				d[i][j] = min(d[i][j] , d[i][k] + d[k][j]);
			}
		}
	}
}

int main()
{
	scanf("%d%d%d" , &n , &m , &Q);
	
	for(int i = 1 ; i <= n ; i++)
	for(int j = 1 ; j <= n ; j++)
	    if(i == j) d[i][j] = 0;
	    else d[i][j] = INF;
	    
	while(m--)
	{
		int a , b , w;
		scanf("%d%d%d" , &a , &b , &w );
		
		d[a][b] = min(d[a][b] , w);
	}
	
	floyd();
	
	while(Q--)
	{
		int a , b;
		scanf("%d%d" , &a , &b);
		
		if(d[a][b] > INF / 2) puts("impossible");
		else printf("%d\n" , d[a][b]); 
	} 
	return 0;
}

Prime

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510 , INF = 1e9;

int n , m;
int g[N][N];
int dist[N];     //这个点到集合的距离 
bool st[N];

int prime()
{
	memset(dist , 0x3f , sizeof(dist));
	
	int res = 0;
	for(int i = 0 ; i < n ; i++)
	{
		int t = -1;
		for(int j = 1 ; j <= n ; j++)
		    if(!st[j] && ( t == - 1  || dist[t] > dist[j]))    
		        t = j;
		        
		if(i && dist[t] == INF)  return INF;      //如果不是第一个点，且当前点无穷，当前图的不连通 
		if(i) res += dist[t];                     // 要累加，否则可能把自环加进来 
		
		for(int j = 1 ; j <= n ; j++)   dist[j] = min(dist[j] , g[t][j]);
			
		st[t]  = true;
	}
	
	return res;
}

int main()
{
	scanf("%d%d" , &n , &m);
	
	memset(g , 0x3f , sizeof(g));
	
	while(m--)
	{
		int a , b ,c;
		scanf("%d%d%d" , &a , &b , &c);
		g[a][b] = g[b][a] = min(g[a][b] , c);
	}
	
	int t = prime();
	
	if(t == INF) puts("imposible");
}

Kruskal

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 100010;

int n , m;
int p[N];

struct Edge{
	int a, b ,w;
	
	bool operator < (const Edge &W)const
	{
		return w < W.w;
	} 
}e[N];

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

int main()
{
	scanf("%d%d" , &n , &m);
	
	for(int i = 0 ; i < m ; i++)
	{
		int a, b ,w;
		scanf("%d%d%d" , &a , &b , &w);
		e[i] = { a , b ,w };
	}
	
	 
	sort(e , e + m);
	
	for(int i = 1 ; i <= n ; i++) p[i] = i;
	
	int res = 0  , cnt = 0;   //res里存放中最小权重边之和   cnt 是当前加了多少条边 
	for(int i = 0 ; i <= m ; i++ )
	{
		int a = e[i].a , b = e[i].b , w = e[i].w;
		
		a = find(a) , b = find(b);
		if(a != b)
		{
		    p[a]  = b; 
			res += w;
			cnt++; 
		} 
	}
	
	if(cnt < n - 1) puts("impossible");
	else printf("%d\n" , res);
	return 0;
}

FIG staining _ bipartite

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N  = 100010 , M  =2000010;

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

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

bool 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 false;
		}
		else if(color[j] == c)  return false;
	} 
	
	return true;
}

int main()
{
	scanf("%d%d" , &n , &m);
	
	memset(h , -1 , sizeof(h));
	
	while(m--)
	{
		int a , b ;
		scanf("%d%d" , &a , &b);
		add(a , b) , add(b , a);
	}
	
	bool flag = true;
	for(int i= 1 ; i <= n ; i++)
	{
		if(!color[i])
		{
			if(!dfs(i , 1))
			{
				flag = false;
				break;
			}
		}
	}
	
	if(flag) puts("Yes");
	else puts("No");
	
	return 0;
}



//4 4
//1 3
//1 4
//2 3
//2 4

Hungarian algorithm

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 510 , M = 100010;

int n1 , n2 , m;
int h[N] , e[M] , ne[M] , idx;
int match[N];
bool st[N];

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

bool find(int x)
{
	for(int i = h[x] ; i!= -1 ; i =ne[i])
	{
		int j= e[i];
		if(!st[j])
		{
			st[j] = true;
			if(match[j] == 0 || find(match[j]))
			{
				match[j] = x;
				return true;
			}
		}
	}
	return false;
}

int main()
{
	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) , add(b ,a);
	}
	
	int res = 0 ;
	for(int i = 1 ; i<= n1 ; i++)
	{
		memset(st , false , sizeof(st));
		if(find(i)) res++;
	}
	
	printf("%d" , res); 
	return 0;
}