豆豆的图论板子

邻接表注意

1.无向图与有向图e, ne, w数组的数组大小

(1). 无向图

h[N], e[M * 2], ne[M * 2], w[M * 2], idx;

(2). 有向图

h[N], e[M], ne[M], w[M], idx;

---

但是实际做题的时候有些题的数据很怪, 所以所有数组的大小直接开成边数的两倍

最短路

单源

Dijkstra O(n2) 适合稠密图 不含负权边

const int N = 510, M = 100010; int g[N][N], dist[N]; bool visited[N]; int n, m; int dijkstra() { memset(dist, 0x3f, sizeof(dist)); dist[1] = 0; for(int i = 1; i <= n; i++) { int t = -1; for(int j = 1; j <= n; j++) { if(!visited[j] && (t == -1 || dist[j] < dist[t])) t = j; } visited[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)); for(int i = 1;i <= n;i++)g[i][i] = 0; while (m--) { int x, y, c; scanf("%d%d%d", &x, &y, &c); g[x][y] = min(g[x][y], c); } cout << dijkstra() << endl; return 0; }

堆优化版dijkstra O（mlogn）适合稀疏图 不含负权边

int n,m; int h[N],e[N],ne[N],w[N],idx; int dist[N]; bool st[N]; void add(int a,int b,int c){ w[idx] = c;e[idx] = b;ne[idx] = h[a];h[a] = idx++; } int dijkstra(){ memset(dist, 0x3f, sizeof dist); dist[1] = 0; priority_queue<PII,vector<PII>,greater<PII>> heap; heap.push({0,1}); while(heap.size()){ auto t = heap.top(); heap.pop(); int ver = t.second,distance = t.first; if(!st[ver]){ st[ver] = true; 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]; } void solve(){ memset(h, -1, sizeof(h)); cin >> n >> m; while(m--){ int x,y,z;cin >> x >> y >> z; add(x,y,z); } cout << dijkstra() << endl; }

Bellman_fold O（nm）可以含负权边 有边数k限制的最短路

const int N = 510,M=10010; struct Edge{ int a,b,c; }e[M]; int dist[N],back[N]; int n,m,k; bool f = 1;//判断是否存在满足路径 int bellman_ford(){ memset(dist,0x3f,sizeof dist); dist[1] = 0; for(int i = 1; i <= k; i++){//k次限制 memcpy(back,dist,sizeof dist); for(int j = 1; j <= m ; j++){ int a = e[j].a,b = e[j].b, c = e[j].c; dist[b] = min(dist[b],back[a] + c); } } if(dist[n] > 0x3f3f3f3f/2)f = 0;//前提：最长路径小于0x3f3f3f3f /2 return dist[n]; } void solve(){ cin >> n >> m >> k; for(int i = 1;i <= m; i++){ int x,y,z;cin >> x >> y >> z; e[i]={x,y,z}; } int res = bellman_ford(); if(f == 0)cout << "impossible" << endl; else cout << res << endl; }

SPFA O（m）——O（mn）可以含负权边 可求是否有负环

int n,m; int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储每个点到1号点的最短距离 bool st[N]; // 存储每个点是否在队列中 bool f = 1;// 求1号点到n号点的最短路距离，如果从1号点无法走到n号 f=0 void add(int a,int b,int c){ w[idx] = c,e[idx] = b,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()){ auto 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]){// 如果队列中已存在j，则不需要将j重复插入 q.push(j); st[j] = true; } } } } if(dist[n] == 0x3f3f3f3f)f = 0; return dist[n]; } void solve(){ memset(h,-1,sizeof h); cin >> n >> m; for(int i = 1;i <= m; i++){ int x,y,z;cin >> x >> y >> z; add(x,y,z); } int res = spfa(); if(f)cout << res << endl; else cout << "impossible" << endl; }

判断负环

int n,m; int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储每个点到1号点的最短距离 int cnt[N]; //cnt[x]存储1到x的最短路中经过的点数 bool st[N]; // 存储每个点是否在队列中 bool f = 1;// 求1号点到n号点的最短路距离，如果从1号点无法走到n号 f=0 void add(int a,int b,int c){ w[idx] = c,e[idx] = b,ne[idx] = h[a],h[a] = idx++; } bool spfa(){ //memset(dist,0x3f,sizeof dist); //dist[1] = 0; queue<int>q; for (int i = 1; i <= n; i ++ ){ q.push(i); st[i] = true; } while(q.size()){ auto 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]; cnt[j] = cnt[t] + 1; if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环 if(!st[j]){// 如果队列中已存在j，则不需要将j重复插入 q.push(j); st[j] = true; } } } } //if(dist[n] == 0x3f3f3f3f)f = 0; //return dist[n]; return false; } void solve(){ memset(h,-1,sizeof h); cin >> n >> m; for(int i = 1;i <= m; i++){ int x,y,z;cin >> x >> y >> z; add(x,y,z); } bool res = spfa(); if(res)cout << "Yes" << endl; else cout << "No" << endl; }

多源

floyd O(n3)

初始化： 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; // 算法结束后，d[a][b]表示a到b的最短距离 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]); }

最小生成树

朴素版prim O(n2+m) 稠密图 邻接矩阵

#include <iostream> #include <cstring> #include <algorithm> using namespace std; const int N = 510; int g[N][N];//存储图 int dt[N];//存储各个节点到生成树的距离 int st[N];//节点是否被加入到生成树中 int pre[N];//节点的前去节点 int n, m;//n 个节点，m 条边 void prim() { memset(dt,0x3f, sizeof(dt));//初始化距离数组为一个很大的数（10亿左右） int res= 0; dt[1] = 0;//从 1 号节点开始生成 for(int i = 0; i < n; i++)//每次循环选出一个点加入到生成树 { int t = -1; for(int j = 1; j <= n; j++)//每个节点一次判断 { if(!st[j] && (t == -1 || dt[j] < dt[t]))//如果没有在树中，且到树的距离最短，则选择该点 t = j; } //2022.6.1 发现测试用例加强后，需要判断孤立点了 //如果孤立点，直返输出不能，然后退出 if(dt[t] == 0x3f3f3f3f) { cout << "impossible"; return; } st[t] = 1;// 选择该点 res += dt[t]; for(int i = 1; i <= n; i++)//更新生成树外的点到生成树的距离 { if(dt[i] > g[t][i] && !st[i])//从 t 到节点 i 的距离小于原来距离，则更新。 { dt[i] = g[t][i];//更新距离 pre[i] = t;//从 t 到 i 的距离更短，i 的前驱变为 t. } } } cout << res; } void getPath()//输出各个边 { for(int i = n; i > 1; i--)//n 个节点，所以有 n-1 条边。 { cout << i <<" " << pre[i] << " "<< endl;// i 是节点编号，pre[i] 是 i 节点的前驱节点。他们构成一条边。 } } int main() { memset(g, 0x3f, sizeof(g));//各个点之间的距离初始化成很大的数 cin >> n >> m;//输入节点数和边数 while(m --) { int a, b, w; cin >> a >> b >> w;//输出边的两个顶点和权重 g[a][b] = g[b][a] = min(g[a][b],w);//存储权重 } prim();//求最下生成树 //getPath();//输出路径 return 0; }

Kruskal O(mlogm)稀疏图

int p[M]; int n,m; struct Edge { int a,b,w; bool operator< (const Edge &W)const { return w < W.w; } }edges[M]; int find(int x) { if(p[x]!=x) p[x]=find(p[x]); else return x; } int Kruskal() { int res=0,cnt=0;//res记录最小生成树的树边权重之和,cnt记录的是全部加入到树的集合中边的数量(可能有多个集合) for(int i=0;i<m;i++) { int a=edges[i].a,b=edges[i].b,w=edges[i].w; if(find(a)!=find(b)) /* 具体可以参考连通块中点的数量,如果a和b已经在一个集合当中了,说明这两个点已经被一种方式连接起来了, 如果加入a-b这条边,会导致集合中有环的生成,而树中不允许有环生成,所以一个连通块中的点的数量假设 为x,那么里面x个节点应该是被串联起来的,有x-1条边,所以只有当a,b所属的集合不同时,才能将a-b这条 边加入到总集合当中去 */ { p[find(a)]=p[find(b)];//将a,b所在的两个集合连接起来 cnt++;//因为加入的是a-b的这一条边,将a,b所在的两个集合连接之后,全部集合中的边数加1 res+=w;//加入到集合中的边的权重之和 } } if(cnt==n-1) return res;//可以生成最小生成树 else return 0x3f3f3f3f;//树中有n个节点便有n-1条边,如果cnt不等于n-1的话,说明无法生成有n个节点的树 } int main() { cin>>n>>m; for(int i=0;i<n;i++) p[i]=i;//初始化并查集 for(int i=0;i<m;i++) { int a,b,w; scanf("%d%d%d",&a,&b,&w); edges[i]={a,b,w}; } sort(edges,edges+m);//将边的权重按照大小一一排序 int t=Kruskal(); if(t==0x3f3f3f3f) printf("impossible\n"); else printf("%d\n",t); return 0; }

双端队列bfs求最短路径

//通讯线路 int n, m, k; int h[N], e[M], w[M], ne[M], idx; int dist[N]; deque<int> q; bool st[N]; void add(int a, int b, int c) { e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ; } bool check(int bound) { memset(dist, 0x3f, sizeof dist); memset(st, 0, sizeof st); q.push_back(1); dist[1] = 0; while (q.size()) { int t = q.front(); q.pop_front(); if (st[t]) continue; st[t] = true; for (int i = h[t]; ~i; i = ne[i]) { int j = e[i], x = w[i] > bound; if (dist[j] > dist[t] + x) { dist[j] = dist[t] + x; if (!x) q.push_front(j); else q.push_back(j); } } } return dist[n] <= k; } int main() { cin >> n >> m >> k; memset(h, -1, sizeof h); while (m -- ) { int a, b, c; cin >> a >> b >> c; add(a, b, c), add(b, a, c); } int l = 0, r = 1e6 + 1; while (l < r) { int mid = l + r >> 1; if (check(mid)) r = mid; else l = mid + 1; } if (r == 1e6 + 1) cout << -1 << endl; else cout << r << endl; return 0; }

缩点

int id[N];//用来存每个点属于哪个连通块 vector<int> block[N];//用来记录每个连通块都包括哪几个点 int bcnt; void dfs(int u, int bid) { id[u] = bid, block[bid].push_back(u); for (int i = h[u]; ~i; i = ne[i]) { int j = e[i]; if (!id[j]) dfs(j, bid); } } for (int i = 1; i <= n; i ++ ) if (!id[i]) { bcnt ++ ; dfs(i, bcnt); }

二分图

染色法判定二分图

染色法

将所有点分成两个集合，使得所有边只出现在集合之间，就是二分图

二分图：一定不含有奇数环，可能包含长度为偶数的环， 不一定是连通图

dfs版本

代码思路：

染色可以使用1和2区分不同颜色，用0表示未染色

遍历所有点，每次将未染色的点进行dfs, 默认染成1或者2

由于某个点染色成功不代表整个图就是二分图,因此只有某个点染色失败才能立刻break/return

染色失败相当于存在相邻的2个点染了相同的颜色

const int N = 1e5 + 10, M = 2e5 + 10; // 由于是无向图, 顶点数最大是N，那么边数M最大是顶点数的2倍 int e[M], ne[M], h[N], idx; int st[N]; void add(int a, int b){ e[idx] = b, ne[idx] = h[a], h[a] = idx ++; } bool dfs(int u, int color) { st[u] = color; for(int i = h[u]; i != -1; i = ne[i]){ int j = e[i]; if(!st[j]) { if(!dfs(j, 3 - color)) return false; }else if(st[j] == color) return false; } return true; } int main(){ int n, m; 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); // 无向图，a->b, b->a } bool flag = true; for(int i = 1; i <= n; i ++){ if(!st[i]){ if(!dfs(i, 1)){ flag = false; break; } } } if(flag) puts("Yes"); else puts("No"); return 0; }

bfs版本

代码思路

颜色 1 和 2 表示不同颜色, 0 表示 未染色

定义queue是存PII，表示 ,

同理，遍历所有点, 将未染色的点都进行bfs

队列初始化将第i个点入队, 默认颜色可以是1或2

while (队列不空)

每次获取队头t, 并遍历队头t的所有邻边

若邻边的点未染色则染上与队头t相反的颜色，并添加到队列

若邻边的点已经染色且与队头t的颜色相同, 则返回false

int e[M], ne[M], h[N], idx; int n, m; int st[N]; void add(int a, int b){ e[idx] = b, ne[idx] = h[a], h[a] = idx ++; } bool bfs(int u){ int hh = 0, tt = 0; PII q[N]; q[0] = {u, 1}; st[u] = 1; while(hh <= tt){ auto t = q[hh ++]; int ver = t.first, c = t.second; for (int i = h[ver]; i != -1; i = ne[i]){ int j = e[i]; if(!st[j]) { st[j] = 3 - c; q[++ tt] = {j, 3 - c}; } else if(st[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); } int flag = true; for(int i = 1; i <= n; i ++) { if (!st[i]){ if(!bfs(i)){ flag = false; break; } } } if (flag) puts("Yes"); else puts("No"); return 0; }

匈牙利算法 求二分图的最大匹配

//match[j]=a,表示女孩j的现有配对男友是a int match[N]; //st[]数组我称为临时预定数组，st[j]=a表示一轮模拟匹配中，女孩j被男孩a预定了。 int st[N]; //这个函数的作用是用来判断,如果加入x来参与模拟配对,会不会使匹配数增多 int find(int x) { //遍历自己喜欢的女孩 for(int i = h[x] ; i != -1 ;i = ne[i]) { int j = e[i]; if(!st[j])//如果在这一轮模拟匹配中,这个女孩尚未被预定 { st[j] = true;//那x就预定这个女孩了 //如果女孩j没有男朋友，或者她原来的男朋友能够预定其它喜欢的女孩。配对成功,更新match if(!match[j]||find(match[j])) { match[j] = x; return true; } } } //自己中意的全部都被预定了。配对失败。 return false; } //记录最大匹配 int res = 0; for(int i = 1; i <= n1 ;i ++) { //因为每次模拟匹配的预定情况都是不一样的所以每轮模拟都要初始化 memset(st,false,sizeof st); if(find(i)) res++; }