图

1、邻接表的存储

#include<stdio.h>
#include<stdlib.h>
#include<string.h> 
#define MAXN 10000
struct {
	int value; //用来存边的权值
	int to;   //用来存边的末端
	int next;// 用来储存下一条边的编号
}edges[MAXN];
int cnt = 0; //第一边的编号为零
int head[MAXN]; //储存以 i 为 始点的边的编号
void init(){
	memset(head,-1,sizeof(head)); //初始化每个点均没在边中
}
void add(int u,int v,int value){
	edges[cnt].to = v; //编号为 cnt的边的末端
	edges[cnt].value = value; //边的权值
	edges[cnt].next = head[u]; //下一条以u为始点的编号
	head[u] = cnt ++;//以当前点为始点的编号为 cnt
	edges[cnt].to = u; //因为我存的是无向图 所以 要再以v为始点存一遍
	edges[cnt].value = value;
	edges[cnt].next = head[v];
	head[v] = cnt ++;
}
 
void Print(int n){
	int i,j;
	for (i=1;i<=n;i++)
	{
		for (j=head[i];j!=-1;j=edges[j].next) 一开始j为 以i为始点的边的编号 当j！=-1 时说明以i为始点的边还有，他在 edges[j].next 中存着
		{
			printf("%d->%d = %d\n",i,edges[j].to,edges[j].value);
		}
	}
}
int main (){
	int n,m,i,u,v,value;
	scanf("%d%d",&n,&m);
	init();
	for (i=0;i<m;i++)
	{
		scanf("%d%d%d",&u,&v,&value);
		add(u,v,value);
	}
	Print(n);
} 

2、拓扑排序

    queue<int>q;
    vector<int>edge[n];
    for(int i=0;i<n;i++)  //n  节点的总数
        if(in[i]==0) q.push(i);  //将入度为0的点入队列
    vector<int>ans;   //ans 为拓扑序列
    while(!q.empty())
    {
        int p=q.front(); q.pop(); // 选一个入度为0的点，出队列
        ans.push_back(p);
        for(int i=0;i<edge[p].size();i++)
        {
            int y=edge[p][i];
            in[y]--;
            if(in[y]==0)
                q.push(y);  
        }
    }
    if(ans.size()==n)   
    {
        for(int i=0;i<ans.size();i++)
            printf( "%d ",ans[i] );
        printf("\n");
    }
    else printf("No Answer!\n");   //  ans 中的长度与n不相等，就说明无拓扑序列

3、dijsktra的堆优化

 1 #include <cstdio>
 2 #include <queue>
 3 #include <iostream>
 4 #include <algorithm>
 5 using namespace std;
 6 int n,m,s;
 7 int head[100001],dis[100001],cnt;
 8 bool vis[100001];
 9 struct qwq{
10     int from,to,next;
11     long long len;
12 }edge[200001];
13 void add(int u,int v,int w)
14 {
15     cnt++;
16     edge[cnt].from=u;
17     edge[cnt].to=v;
18     edge[cnt].len=w;
19     edge[cnt].next=head[u];
20     head[u]=cnt;
21     return;
22 }
23 struct node{
24     int index,dist;
25     bool operator < (const node &x)const
26     {
27         return dist>x.dist;
28     }
29 };
30 priority_queue<node> q; 
31 int main()
32 {
33     scanf("%d%d%d",&n,&m,&s);
34     for(int i=1;i<=m;i++)
35     {
36         int u,v,w;
37         scanf("%d%d%d",&u,&v,&w);
38         add(u,v,w);
39     }
40     for(int i=1;i<=n;i++)
41     dis[i]=2147483647;
42     dis[s]=0;
43     q.push(node{s,0});
44     while(!q.empty())
45     {
46         node x=q.top();
47         q.pop();
48         int u=x.index;
49         if(vis[u]) continue;
50         vis[u]=1;
51         for(int i=head[u];i;i=edge[i].next)
52         {
53             if(dis[edge[i].to]>dis[u]+edge[i].len)
54             {
55                 dis[edge[i].to]=dis[u]+edge[i].len;
56                 q.push(node{edge[i].to,dis[edge[i].to]});
57             }
58         }
59     }
60     for(int i=1;i<=n;i++)
61     printf("%d ",dis[i]);
62     return 0;
63 }

4、欧拉回路

dfs例题
fleury解释
fleury算法：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <climits>
#include <vector>
#include <queue>
#include <cstdlib>
#include <string>
#include <set>
#include <stack>
#define LL long long
#define pii pair<int,int>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1000;
bool e[maxn][maxn];
int n,m;
stack<int>stk;
void dfs(int u){
    stk.push(u);
    for(int i = 1; i <= n; i++){
        if(e[u][i]){
            e[u][i] = false;
            e[i][u] = false;
            dfs(i);
            break;
        }
    }
}
void Fleury(int x){
    while(!stk.empty()) stk.pop();
    stk.push(x);
    int i;
    while(!stk.empty()){
        int u = stk.top();
        stk.pop();
        for(i = 1; i <= n; i++)
            if(e[u][i]) break;
       if(i <= n) dfs(u); else printf("%d ",u);
    }
    puts("");
}
int main() {
    int u,v,cnt,degree,st;
    while(~scanf("%d %d",&n,&m)){
        memset(e,false,sizeof(e));
        for(int i = 0; i < m; i++){
            scanf("%d %d",&u,&v);
            e[u][v] = e[v][u] = true;
        }
        cnt = 0;
        st = 1;
        for(int i = 1; i <= n; i++){
            for(int j = 1,degree = 0; j <= n; j++)
                if(e[i][j]) degree++;
            if(degree&1){
                st = i;
                cnt++;
            }
        }
        if(cnt == 2 || !cnt) Fleury(st);
        else puts("No Euler path");
    }
    return 0;
}

5、tarjan求强联通分量

强连通分量+割点+桥

#include<iostream>
#include<algorithm>
#include<cstring>
#include<stack> 
using namespace std;
 
struct ss{
	int v;
	int next;
	/*  
	v指节点v 
	next永远指u点->上一个点的边序（1，2，3···）
	边序 即u到其他点（上一个点）是第几条边（num） 
	上一条边没有就是-1 
	*/ 
}s[1000]; 
 
int head[1000];//边序 
int dfn[1000];
int low[1000];
int vis[1000];//相当于栈 
int color[1000];//染色 
int n,m;
int cnt;
int num;
stack<int >st;
 
void init()
{
	memset(head,-1,sizeof(head));
	memset(vis,0,sizeof(vis));
	memset(dfn,0,sizeof(dfn));
	memset(low,0,sizeof(low));
	//memset(color,0,sizeof(color));	
	num=0;
	cnt=0;
}
void add(int u,int v)
{
	s[num].v = v;
	s[num].next = head[u];
	head[u] = num++;
	/*
	将v存进去
	将u->上一个点的边序挂上next
	num一直在++(总边数不会错)
	head[u]更新当前u的边序 			
	如果双向再存u挂v边序 
	eg[num].v = u;
	eg[num].next = head[v];
	head[v] = num++;
	*/ 	
}
void Tarjan(int u)
{
	st.push(u);
	dfn[u] = low[u] = ++cnt;//搜索次序号 
	vis[u]=1;//节点x在栈中
	for(int i = head[u]; i != -1; i = s[i].next)
	{
		//通过对u点上一个边序的挂钩
		//构造对连接u点的所有边数遍历查找对应v点 
		int v = s[i].v;
		if(!dfn[v])//不曾访问过 
		{
			Tarjan(v);//找v点 
			low[u] = min(low[u],low[v]);
			/* 
			根节点的dfn值是区分不同环的值
                        low是为了让这个环都等dfn[根]
                        low[根]可能不等dfn[根]
                        根的low继承根的根的dfn 
			1.如果v是根节点
			  不论只有v一个点还是有一个环 
			  low[v]确实永远比low[u]大(u比v先入)
			  v的环low值=dfn[v]都比low[u]的大 
			  v不对u产生影响
			2. 
			  如果v点与u点成环
			  那么顺着v点或v连着的点找下去
			  总有一个能连到根节点
			  low值回溯的时候继承根的dfn值
                          根的dfn是这个环里面最小的
			  low[v]等于dfn[根]
			  v对u产生影响->low[u]=low[v] 
			*/ 
		}
		else if(vis[v])//访问过但还在栈中 
			/*
			因为根u点还没有将边都找完
			出栈的点都是根节点边已经找完的点或者环 
			已经没有与剩下的点有任何关系才能出 
			*/ 
			low[u] = min(low[u],dfn[v]);
			/*
			这相当于根节点有两个分叉口a,b 
			并且a找到已经在栈中的b
				  
			那么这一步其实也可以写成 
			low[u] = min(low[u],low[v]);
                        反正连到一个环了
		
                        目的是为了让缩点与割点的代码一致 
                        区分相连的环的根有不同的dfn
                        无向图找割点用的
                        但是缩点是将一起出栈的点缩成一个点（染成一个色）
	                对于缩点结果都无影响	
			*/
	}	
 
	if(dfn[u]==low[u])//找一遍再是强连通分量 
	{
		int now;
		do{	//取出包括u的环 
			now=st.top();
			color[now]=u; //染色 
			vis[now]=0;
			st.pop();
		}while(now!=u);
	}
	return;	
} 
void out()
{
	for(int i=1;i<=n;i++)
		printf("%d ",i);
	printf("\n");
	for(int i=1;i<=n;i++)
		printf("%d ",color[i]);
	printf("\n");
}
 
int main()
{
	while(~scanf("%d%d",&n,&m) && (m+n))
	{
		init();
		int u,v;
		while(m--)
		{
			scanf("%d%d",&u,&v);	
			add(u,v);
		}	
		//为了防止一个图里有不相连的两个或多个树 
		for(int i=1;i<=n;i++) 
			if(!dfn[i]) 
				Tarjan(i);
		out();
	} 
	return 0; 
} 

匈牙利算法和km算法

白话描述匈牙利算法
KM算法+模板