DFS（深度优先搜索）
例题（排列数字）
一个题解
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int N = 10;
int path[N];
//用来存取方案
bool st[N];
//用来存取每个数字的状态，表明数字是否被用过
int n ;
void dfs(int u){
if(u == n){
//u = n时代表n个位置都已经被填满了 可以直接输出
for(int i = 0 ; i < n ; i++){
printf("%d ",path[i]);
}
puts("");
return ;
}
//如果u不等于n，就代表空位还没有被填满
for(int i = 1 ; i <= n ; i++){
if(!st[i]){
path[u] = i;
st[i] = true ;
//进入递归前 修改状态
dfs(u+1);
//递归结束后 及时恢复原状态
st[i] = false ;
}
}
}
int main(){
cin >> n;
dfs(0);
}
例题（n皇后问题）
一个题解
#include <iostream>
using namespace std;
const int N = 20;
// col列，dg斜线，udg反斜线
// g[N][N]用来存图
int n;
char g[N][N];
bool col[N], dg[N], udg[N];
void dfs(int u) {
if (u == n) {
for (int i = 0; i < n; i ++ ) puts(g[i]);
puts(""); // 换行
return;
}
for (int i = 0; i < n; i ++ )
if (!col[i] && !dg[u + i] && !udg[n + u - i]) {
g[u][i] = 'Q';
col[i] = dg[u + i] = udg[n + u - i] = true;
dfs(u + 1);
col[i] = dg[u + i] = udg[n + u - i] = false; // 恢复现场
g[u][i] = '.';
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i ++ )
for (int j = 0; j < n; j ++ )
g[i][j] = '.';
dfs(0);
return 0;
}
BFS（宽度优先搜索）
例题（走迷宫）
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 110;
int n, m;
// 用g来存储图，d来存储各个节点到起始节点的路径
int g[N][N], d[N][N];
int bfs()
{
// 定义一个队列q来存储最新到达的地点，队首出队的时候，也是走向下一个节点的时候
queue<PII> q;
// 将距离d首先初始化为-1
memset(d, -1, sizeof d);
// 初始化起始节点的距离d[0,0] = 0
d[0][0] = 0;
// 将起始节点加到队列中
q.push({0, 0});
// 定义四个方向
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
// 如果队列不为空
while (q.size())
{
// 将队首元素赋值给t
auto t = q.front();
// 队首出队
q.pop();
// 站在这个路口，向前后左右四个方向看（这个求向左走(x-1,y)、向右走(x+1,y)、向上走(x,y-1)、向下走(x,y+1)的写法可以背下来）
for (int i = 0; i < 4; i ++ )
{
// t为队首元素，即当前路口的x值，t.first为x轴的值，t.first + dx[i]为向左右走
// t为队首元素，即当前路口的y值，t.second为y轴的值，t.second + dy[i]为向上下走
int x = t.first + dx[i], y = t.second + dy[i];
// 如果如果坐标（x,y）合法（在给定图的范围内）且能走（g[x][y] == 0）且没有走过（d[x][y] == -1）
if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
{
// 将这个位置（x,y）到起始点（0,0）的距离（在上一步的距离+1（d[t.first][t.second] + 1））加到d[x][y]中
d[x][y] = d[t.first][t.second] + 1;
// 将这个新到达的位置加入队列
q.push({x, y});
}
}
}
// 输出右下角(n-1,m-1)到起始点的距离d[n - 1][m - 1]即可
// 因为bfs有最短性，所有直接输出就是左上角到右下角的最短的路径
return d[n - 1][m - 1];
}
int main()
{
cin >> n >> m;
for (int i = 0; i < n; i ++ )
for (int j = 0; j < m; j ++ )
cin >> g[i][j];
cout << bfs() << endl;
return 0;
}
树与图的存储
数是特殊的图（无环连痛图），图又分为有向图（边有方向）和无向图（边无方向），无向图是一种特殊的有向图。有向图一般存储方式有两大类：
邻接矩阵 g[a,b]（用的比较少，开个二维数组）: 时间复杂度为O(n2)，比较浪费空间，常用于存储稠密图。邻接矩阵不能存储重边，一般存储时只保留一条边。
邻接表（用的多）: 每个节点为头结点的单链表存储着从当前节点能走到的那些点。
数与图的遍历
例题（树的重心，深度优先）
一个题解
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = N * 2;
int n;
// h[N] 表示有N个槽
// e[M], ne[M], idx含义与单链表一致
int h[N], e[M], ne[M], idx;
int ans = N;
bool st[N]; // 表示哪些点已经遍历过了
// 插入一条a到b的边
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
// 深度优先搜索dfs
int dfs(int u)
{
st[u] = true; // 当前节点已经被搜索过了
int size = 0, sum = 0;
for (int i = h[u]; i != -1; i = ne[i]) // 遍历数的所有边
{
int j = e[i];
if (!st[j]){
int s = dfs(j);
size = max(size, s);
sum += s;
}
}
size = max(size, n - sum - 1);
ans = min(ans, size);
return sum + 1;
}
int main()
{
scanf("%d", &n);
memset(h, -1, sizeof h);
for (int i = 0; i < n - 1; i ++ )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
}
dfs(1);
printf("%d\n", ans);
return 0;
}
模板
int dfs(int u)
{
st[u] = true; // st[u] 表示点u已经被遍历过
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j]) dfs(j);
}
}例题（图中点的层次，广度优先）
一个题解
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N], ne[N], idx;
int d[N];// 保存1号点到各个点的距离
// -------------------------------A1开始------------------------------------
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
// -------------------------------A1结束------------------------------------
int bfs()
{
//---------------------------------------------A2开始-------------------------------
memset(d, -1, sizeof d);
queue<int> q;
d[1] = 0;
q.push(1);
while (q.size())
{
int t = q.front();
q.pop();
//---------------------------------------A2结束--------------------------------
// ---------------核心代码开始---------------------------------------
// 循环遍历所有与t相距为1的节点
for (int i = h[t]; i != -1; i = ne[i]) // ne[i]上的点都是与i节点距离为1的点
{
int j = e[i]; // 向外走一步
if (d[j] == -1) // 如果j没有被遍历过
{
d[j] = d[t] + 1; // 因为路径长度都是1，所以直接在上一步的基础上加上1即可
q.push(j); // 将j加到队列中
}
}
}
return d[n]; // 返回的d[n]即是节点1到节点n的距离
// ---------------核心代码结束---------------------------------------
}
// ---------------A3开始---------------------------------------
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for (int i = 0; i < m; i ++ )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
cout << bfs() << endl;
return 0;
}
// ---------------A3结束---------------------------------------
模板
queue<int> q;
st[1] = true; // 表示1号点已经被遍历过
q.push(1);
while (q.size())
{
int t = q.front();
q.pop();
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j])
{
st[j] = true; // 表示点j已经被遍历过
q.push(j);
}
}
}拓扑排序
例题（有向图的拓扑排序）
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010;
int n, m; // 输入需要的参数n,m
int h[N], e[N], ne[N], idx; // 构建图需要的参数
int d[N]; // d[i] 表示 节点i的入度是多少
int q[N]; // 用q[]来保存保存拓扑序列
// 构建图
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
// 拓扑排序
bool topsort()
{
// 用数组模拟队列
int hh = 0, tt = -1;
// 将入度为0的节点放入队列q中
for (int i = 1; i <= n; i ++ )
if (!d[i])
q[ ++ tt] = i;
// 如果队列不为空
while (hh <= tt)
{
// 队首出队，出队元素赋值为t
int t = q[hh ++ ];
// 遍历与出队元素相邻的所有边
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (-- d[j] == 0) // 如果减去一个入度后j节点的入度为0
q[ ++ tt] = j; // 那么将它加到队列中
}
}
// 判断是不是所有下标都入队了，如果tt == n - 1 ,那么队列中就有n个元素
// 那么说明它是一个有向无环图，否则说明它是一个存在环的图，即不存在拓扑序列
return tt == n - 1;
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
// 构建图
for (int i = 0; i < m; i ++ )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
d[b] ++ ; // 加入一条a指向b的边，b的入度加1，用d[b]++表示b的入度加1
}
// 如果没有拓扑序列输出-1
if (!topsort()) puts("-1");
// 否则输出这个序列
else
{
for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);
}
return 0;
}
模板
bool topsort()
{
int hh = 0, tt = -1;
// d[i] 存储点i的入度
for (int i = 1; i <= n; i ++ )
if (!d[i])
q[ ++ tt] = i;
while (hh <= tt)
{
int t = q[hh ++ ];
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (-- d[j] == 0)
q[ ++ tt] = j;
}
}
// 如果所有点都入队了，说明存在拓扑序列；否则不存在拓扑序列。
return tt == n - 1;
}最短路径
朴素Dijkstra
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510;
int n, m;
int g[N][N]; // 图g，存的是两条边之间的距离，如g[a][b]存的就是a到b的距离
int dist[N]; // 从1号点走到每个点的最短距离是多少
bool st[N]; // i号点的距离是否确定了
int dijkstra()
{
// 将所有的距离初始化为无穷
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 循环n-1次，因为有n个节点，要更新n-1次距离
for (int i = 0; i < n - 1; i ++ )
{
// 找最小值节点t，找所有没被确定的点的距离节点1距离最近的节点
int t = -1; // t = -1 表示还没有确定节点是哪个
for (int j = 1; j <= n; j ++ )
// 如果j的点的距离未定下来且 t == -1或 dist[t] > dist[j]（当前这个t不是最短的）
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
// 用t更新其他点的距离
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
// 用一个节点更新完与之相连的所有节点后，这个点的值就算作确定下来了
st[t] = true;
}
/* 如果第一个节点到第n个节点的长度为0x3f3f3f3f（无穷大）时，说明不存在这条路径，返回-1
if (dist[n] == 0x3f3f3f3f) return -1;
// 否则返回n的最短距离
return dist[n];*/
return d[n] == 0x3f3f3f3f? -1 : d[n];
}
int main()
{
scanf("%d%d", &n, &m);
// 图g的初始化
memset(g, 0x3f, sizeof g);
// 读入m条边
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
// 处理重边
g[a][b] = min(g[a][b], c);
}
printf("%d\n", dijkstra());
return 0;
}
模板
int g[N][N]; // 存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N]; // 存储每个点的最短路是否已经确定
// 求1号点到n号点的最短路，如果不存在则返回-1
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;
// 用t更新其他点的距离
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
st[t] = true;
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}堆优化Dijkstra
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII; // 堆中存储的元素
const int N = 1e6 + 10;
int n, m;
// W[]是边的权重
int h[N], w[N], e[N], ne[N], idx; // 稀疏图，用邻接表的形式来存
int dist[N];
bool st[N];
// 加边的模板
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, 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]) continue;
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[ver] + w[i])
{
dist[j] = dist[ver] + w[i];
heap.push({dist[j], j});
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
cout << dijkstra() << endl;
return 0;
}
模板
typedef pair<int, int> PII;
int n; // 点的数量
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储所有点到1号点的距离
bool st[N]; // 存储每个点的最短距离是否已确定
// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1}); // first存储距离，second存储节点编号
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;
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];
}Bellman-Ford
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, M = 10010;
// 定义一个结构体来存储所有边
struct Edge
{
int a, b, c;
}edges[M];
int n, m, k;
int dist[N];
int last[N];
void bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 循环k次
for (int i = 0; i < k; i ++ )
{
// 备份上一次迭代的结果last
/*
memcpy是内存拷贝函数
有三个参数：*destin, *source, n
void *memcpy(void *destin, void *source, unsigned n);
它从源source所指的内存地址的起始位置开始拷贝n个字节到目标destin所指的内存地址的起始位置中
然后返回一个指向目标存储区destin的指针
*/
memcpy(last, dist, sizeof dist);
// 每次循环遍历所有边，修改每个节点的最短路径
for (int j = 0; j < m; j ++ )
{
auto e = edges[j];
// dist[e.b]是节点1到b节点目前的距离
// last[e.a] + e.c是节点1到a节点，再从a节点到b节点的距离
dist[e.b] = min(dist[e.b], last[e.a] + e.c);
}
}
}
int main()
{
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i ++ )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edges[i] = {a, b, c}; // 表示存储一条a到b的边，边权为c
}
// 更新所有节点到1号节点的最短距离
bellman_ford();
// 可能有负数导致最后的结果不等于0x3f3f3f3f，但是也是无限接近于无穷大的，因此dist[n] > 0x3f3f3f3f / 2就可以认为是无穷大了
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
else printf("%d\n", dist[n]);
return 0;
}
模板
int n, m; // n表示点数，m表示边数
int dist[N]; // dist[x]存储1到x的最短路距离
struct Edge // 边，a表示出点，b表示入点，w表示边的权重
{
int a, b, w;
}edges[M];
// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
for (int i = 0; i < n; i ++ )
{
for (int j = 0; j < m; j ++ )
{
int a = edges[j].a, b = edges[j].b, w = edges[j].w;
if (dist[b] > dist[a] + w)
dist[b] = dist[a] + w;
}
}
if (dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}spfa求最短路
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N]; // st[]存的是当前这个点是不是在队列中，防止队列中存重复的点
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;
// 搜索一下t的所有临边
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;
}
}
}
}
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
int t = spfa();
if (t == 0x3f3f3f3f) puts("impossible");
else printf("%d\n", t);
return 0;
}
模板
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储每个点到1号点的最短距离
bool st[N]; // 存储每个点是否在队列中
// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
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) return -1;
return dist[n];
}spfa判断负环
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 2010, M = 10010;
int n, m;
int h[N], w[M], e[M], ne[M], idx; // idx是小于10010的，因此，e、w、ne数组都要初始为M
int dist[N], cnt[N];// cnt表示当前最短路边的数量
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 spfa()
{
queue<int> q;
// 将所有点都放到队列中，如果只放节点1的话，可能从1到不了该负环
for (int i = 1; i <= n; i ++ )
{
st[i] = true;
q.push(i);
}
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])
{
// 更新d数组的时候，将cnt数组在上一个节点的距离＋1
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1;
// 如果到某个点的边数 >=n 则说明一定至少有有n+1个节点，则证明一定存在两个相同的节点，则说明一定存在环
// 那么为什么是负环呢？
// 这是因为如果是正环的话，这个节点是不会被更新的（因为路径权重会增加），只有当它为负环时候，它才会走这条环，因此这个环一定是负环
if (cnt[j] >= n) return true;
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
if (spfa()) puts("Yes");
else puts("No");
return 0;
}
模板
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N], cnt[N]; // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N]; // 存储每个点是否在队列中
// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
// 不需要初始化dist数组
// 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。
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])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}floyd求最短路
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 210, INF = 1e9;// INF---无穷大
int n, m, Q;
int d[N][N];// 如d[i][j] ,表示从节点i走到节点j的距离
// 弗洛伊德算法
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, c;
scanf("%d%d%d", &a, &b, &c);
// 如果有多条边，保留最小边
d[a][b] = min(d[a][b], c);
}
floyd();
// 处理所有询问
while (Q -- )
{
int a, b;
scanf("%d%d", &a, &b);
int t = d[a][b];
if (t > INF / 2) puts("impossible");
else printf("%d\n", t);
}
return 0;
}
模板
初始化：
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求最小生成树
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int n, m;
int g[N][N];
int dist[N];
bool st[N];
int prim()
{
memset(dist, 0x3f, sizeof dist);
int res = 0; // res存的是最小生成树的树边权重之和
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;
// 如果找到的点到集合的最短距离是INF，则说明这是一个不连通的图，没有最小生成树
if (i && dist[t] == INF) return INF;
// 否则把这个点加到集合内
if (i) res += dist[t];
st[t] = true; // 表示该节点已经加到最小生成树了
// 用这个点更新一下其他节点到集合的距离
for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
}
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 = prim();
if (t == INF) puts("impossible");// 有点不连通的时候，不存在最小生成树
else printf("%d\n", t);
return 0;
}
模板
int n; // n表示点数
int g[N][N]; // 邻接矩阵，存储所有边
int dist[N]; // 存储其他点到当前最小生成树的距离
bool st[N]; // 存储每个点是否已经在生成树中
// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
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];
st[t] = true;
for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
}
return res;
}Kruskal算法求最小生成树
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = 200010, INF = 0x3f3f3f3f;
int n, m;
int p[N];
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]);
return p[x];
}
int kruskal()
{
// 将所有边排序
sort(edges, edges + m);
for (int i = 1; i <= n; i ++ ) p[i] = i; // 初始化并查集
int res = 0, cnt = 0;
for (int i = 0; i < m; i ++ )
{
int a = edges[i].a, b = edges[i].b, w = edges[i].w;
a = find(a), b = find(b);
if (a != b)
{
p[a] = b; // 合并两个集合
res += w;
cnt ++ ; // cnt存的是当前加了多少条边
}
}
if (cnt < n - 1) return INF;
return res;
}
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);
edges[i] = {a, b, w};
}
int t = kruskal();
if (t == INF) puts("impossible");
else printf("%d\n", t);
return 0;
}
模板
int n, m; // n是点数，m是边数
int p[N]; // 并查集的父节点数组
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]);
return p[x];
}
int kruskal()
{
sort(edges, edges + m);
for (int i = 1; i <= n; i ++ ) p[i] = i; // 初始化并查集
int res = 0, cnt = 0;
for (int i = 0; i < m; i ++ )
{
int a = edges[i].a, b = edges[i].b, w = edges[i].w;
a = find(a), b = find(b);
if (a != b) // 如果两个连通块不连通，则将这两个连通块合并
{
p[a] = b;
res += w;
cnt ++ ;
}
}
if (cnt < n - 1) return INF;
return res;
}二分图
染色法
例题
一个题解
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = 200010;// 无向图，两个节点间要存两条边
int n, m;
int h[N], e[M], ne[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; // 记录当前点的颜色为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; // 3-c表示：如果染过1号颜色（c = 1），则染2号颜色（3-c = 2）；如果染过2号颜色，则染1号颜色
}
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]) // 如果当前节点未染过色，用dfs去染色
{
if (!dfs(i, 1)) // 如果有矛盾发生（dfs为false） （1传入dfs，表示将第i个点染成1代表的颜色）
{
flag = false;
break;// 如果有矛盾，直接break，返回No即可
}
}
if (flag) puts("Yes");
else puts("No");
return 0;
}
模板
int n; // n表示点数
int h[N], e[M], ne[M], idx; // 邻接表存储图
int color[N]; // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色
// 参数：u表示当前节点，c表示当前点的颜色
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] == -1)
{
if (!dfs(j, !c)) return false;
}
else if (color[j] == c) return false;
}
return true;
}
bool check()
{
memset(color, -1, sizeof color);
bool flag = true;
for (int i = 1; i <= n; i ++ )
if (color[i] == -1)
if (!dfs(i, 0))
{
flag = false;
break;
}
return flag;
}匈牙利算法
例题
一个题解
#include <cstring>
#include <iostream>
#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]; // st数组判重，即不要重复搜一个点
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
// 找给出的节点x能否配对
bool find(int x){
for(int i = h[x];i != -1;i = ne[i]){
int j = e[i]; // j是n2集合的一个数
if(st[j] == 0){ // 如果j没考虑过，考虑它
st[j] = 1; // j考虑过了，不重复考虑
if(match[j] == 0 || find(match[j])){ // 如果j未配对，或者与j配对的值（在n1集合中）能再找一个值配对
match[j] = x; // 则这个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);
}
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
memset(st, false, sizeof st); // 每次都要将st数组置位0，表示没有考虑过所有的节点
if (find(i)) res ++ ; // 如果能成功配对，res加1表示成功配对的组数加1
}
printf("%d\n", res);
return 0;
}
模板
int n1, n2; // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx; // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
int match[N]; // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N]; // 表示第二个集合中的每个点是否已经被遍历过
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 res = 0;
for (int i = 1; i <= n1; i ++ )
{
memset(st, false, sizeof st);
if (find(i)) res ++ ;
}
扫一扫
401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
