Template _ a collection of graph theory (a)

FIG tree depth first traversal

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

using namespace std;

const int N = 100010 , M = N * 2;

int n;
int h[N] , e[M] , ne[N] , idx;
bool vis[N];
int ans = N ;
  
void add(int a , int b)
{
	e[idx] = b , ne[idx] = h[a] , h[a] = idx++;   //h[]开的一个单链表 
}

int dfs(int u)
{
	vis[u] = true;
	
	int sum = 1 , res = 0;      //sum记录根子树的个数  res每一个连通块的最大值 
	for(int i = h[u] ; i!= -1 ; i = ne[i])
	{
		int j = e[i];
		if(!vis[j])
		{
			int s = dfs(j);    //当前子树的大小 
			res = max(res , s);
			sum += s;
		}
	} 
	
	res = max(res , n - sum);     //父亲连通块和子联通比较 
	ans = min(ans , res);
	return sum;
}

int main()
{
	cin >> n;
	memset(h , -1 , sizeof(h));
	
	for(int i = 0 ; i < n ; i++)
	{
		int a , b;
		cin >> a >> b;
		add(a , b) , add(b , a);
	}
	
	dfs(1);
	
	cout << ans << endl;
	return 0;
}

Fig Tree and breadth-first traversal

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

using namespace std;

const int N = 100010;

int n , m ;
int h[N] , e[N] , ne[N] , idx;
int d[N] ;
//int q[N];

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

int bfs()
{
//	int hh = 0 , tt = 0;
//	q[0] = 1;
	memset(d , -1 , sizeof(d));
	queue<int> q;
    d[1] = 0;                  //最开始第一个点遍历过 
    q.push(1);
	
	while(!q.empty())
	{
		int t = q.front();
		q.pop();
		
		for(int i = h[t] ; i != -1 ; i = ne[i])
		{
			int j = e[i];
			if(d[j] == -1)     //如果j没有被扩展过 
			{
				d[j] = d[t] + 1;
				q.push(j);    //把j加到队列里面 
			}
		} 
	}
//	while(hh <= tt)
//	{
//		int t = q[ hh++ ];
//		
//		for(int i = h[t] ; i != -1 ; i = ne[i])
//		{
//			int j = e[i];
//			if(d[i] == -1)
//			{
//				d[j] = d[t] + 1;
//				q[ ++ tt ] = j;
//			}
//		}  
//	}
	
	return d[n];
}

int main()
{
	cin >> n >> m;
	
	memset(h  , -1 , sizeof(h));
	
	for(int i = 0 ; i < m ; i++)
	{
		int a , b;
		cin >> a >> b;
		add(a , b);
	}
	
	cout << bfs() << endl;
} 

Topological sorting

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

using namespace std;

const int N = 100010;

int n , m ;
int h[N] , e[N] , ne[N] , idx;
int d[N];  //代表每个元素的入度
int top[N] , cnt = 1; //top是拓扑序列的序列 

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

bool topsort()
{
	queue<int> q;
	
	for(int i = 1 ; i <= n ; ++i) 
	{
		if(!d[i])    //将入度为0的点加入队列 
		q.push(i);
	}
	
	while(q.size())
	{
		int t = q.front();
		top[cnt] = t;    //将队首元素加入到序列中； 
		cnt++;
		q.pop();
		 
		for(int i = h[t] ; i != -1 ; i = ne[i])
		{
			int j = e[i];
			d[j]--;     //j的入度-- 
			if(d[j] == 0)  
			q.push(j);
		}
	}
	if(cnt < n)  return 0; 
	else return 1; 
}
int main()
{
	cin >> n >> m;
	
	memset(h , -1 , sizeof(h));
	
	for(int i = 0 ; i < m ;i++)
	{
		int a , b;
		cin >> a >> b;
		add(a , b);
		d[b] ++ ;   //b的入度加一 
	}
	
	if(!topsort()) cout << "-1";
	else
	{
		for(int i = 1 ; i <= n ; ++i)
		{
			cout << top[i] << " ";
		}
	} 
	return 0;
}

Simple Dij

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

using namespace std;

const int  N = 510;

int n , m;
int g[N][N];
int dist[N];
bool st[N];

int dijkstra()
{
	memset(dist , 0x3f , sizeof(dist));
	dist[1] = 0;
	
	for(int i = 0 ; i< n - 1 ; i++) 
	{
		int t = -1;
		for(int j = 1 ; j<= n ; j++)
		    if(!st[j] && (t == -1 || dist[t] > dist[j]))
		        t = j;
		        
		st[t] = true;
		
		for(int j = 1 ; j <=n ; j++)
		    dist[j] = min(dist[j] , dist[t] + g[t][j]); 
	}
	
	if(dist[n] == 0x3f3f3f3f)  return -1;
	return dist[n];
} 

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] = min(g[a][b] , c);
	}
	
	int t = dijkstra();
	
	printf("%d\n" , t);
	return 0;
}

Optimized heap Dij

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

using namespace std;
typedef pair<int,int> PII;

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 dijktra(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    priority_queue< PII , vector<PII> , greater<PII> >heap;
    heap.push({0,1});    //距离是0 编号是1 
    while(heap.size()){
        pair<int ,int> t=heap.top();
        heap.pop();
        int ver=t.second,distance=t.first;
        if(st[ver])continue;
        for(int i=h[ver];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>distance+w[i])
             {
                 dist[j]=distance+w[i];
                 heap.push({dist[j],j});
             }
        }
    }
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];
}

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<<dijktra()<<endl;
    return 0;
}

Bellman

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

using namespace std;

const int N =510 , M = 10010;

int n , m , k;
int dist[N] , backup[N];

struct Edge{
	int a , b ,w;
}e[M];

int bellman_ford()
{
	memset(dist , 0x3f , sizeof(dist));
	dist[1] = 0;
	
	for(int i = 0 ; i < k ; i++)
	{
		memcpy(backup , dist , sizeof(dist));
		for(int j = 0 ; j < m ; j++)
		{
			int a = e[j].a , b = e[j].b , w = e[j].w;
			dist[b] = min(dist[b] , backup[a] + w);
		}
	} 
	
	if(dist[n] > 0x3f3f3f3f / 2) return -1;
	else dist[N];
}

int main()
{
	scanf("%d%d%d" , &n , &m , &k);
	
	for(int i = 0 ; i < m ; i++)
	{
		int a , b ,w;
		scanf("%d%d%d" , &a , &b , &w);
		e[i] = {a , b , w};
	}
	
	int t = bellman_ford();
	
	if(t == -1) puts("impossible");
	else printf("%d\n" , t);
	return 0;
}