• 题意：每条单程巴士线路从某个巴士站出发，依次途经若干个巴士站，最终到达终点巴士站。一名旅客最近到 $H$ 城旅游，他很想去 $S$ 公园游玩，但如果从他所在的饭店没有一路巴士可以直接到达 $S$ 公园，则他可能要先乘某一路巴士坐几站，再下来换乘同一站台的另一路巴士，这样换乘几次后到达 $S$ 公园。现在用整数 $1,2,\dots N$ 给 $H$ 城的所有的巴士站编号，约定这名旅客所在饭店的巴士站编号为 $1$，$S$ 公园巴士站的编号为 $N$。写一个程序，帮助这名旅客寻找一个最优乘车方案，使他在从饭店乘车到 $S$ 公园的过程中换乘的次数最少。

• 输入格式：第一行有两个数字 $M$ 和 $N$，表示开通了 $M$ 条单程巴士线路，总共有 $N$ 个车站。从第二行到第 $M+1$ 行依次给出了第 $1$ 条到第 $M$ 条巴士线路的信息，其中第 $i+1$ 行给出的是第 $i$ 条巴士线路的信息，从左至右按运行顺序依次给出了该线路上的所有站号，相邻两个站号之间用一个空格隔开。

• 目前发现（大雪菜也说过），当边权都为1的时候，通常就是用 bfs 来写，而不是用 spfa，dijkstra 这种方法。

• 其实，这和迷宫的那个模型差不太多，而且还简单一些。

• 这道题保留的意义其实是掌握以下 stringstream 和 getline(cin, line) 的用法。

#include<sstream>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
const int maxn = 510, INF = 1e9;
int g[maxn][maxn], N, M, d[maxn];
void bfs() {
	fill(d, d + maxn, INF);
	queue<int> que;
	que.push(1);
	d[1] = 0;
	while (que.size()) {
		int u = que.front(); que.pop();
		for (int j = 1; j <= N; j++) {
			if (g[u][j] && d[j] > d[u] + 1) {
				d[j] = d[u] + 1;
				que.push(j);
			}
		}
	}
}
int main() {
	cin >> M >> N;
	string line;
	getline(cin, line);
	for (int i = 0; i < M; i++) {
		getline(cin, line);
		stringstream ss(line);
		vector<int> v;
		int u;
		while (ss >> u) v.push_back(u);
		for (int i = 0; i < v.size(); i++) {
			for (int j = 0; j < i; j++) g[v[j]][v[i]] = 1;
		}
	}
	bfs();
	int ans = d[N];
	if (ans == INF) printf("NO\n");
	else printf("%d\n", ans - 1);
	return 0;
}

• 题意：$n\ast m$ 的园子，雨后起了积水。八连通的积水被认为是连在一起的。问总共有多少水洼。

• dfs可能会爆栈，因此这里展示bfs的做法。

• 连通块分为四连通和八连通。

• 注意，这个题是可以把 queue 当作全局变量的。因为在 bfs 中，只有 queue 为空是才能跳出循环。

int N, M;
char g[maxn][maxn];
bool vis[maxn][maxn];
typedef pair<int, int> P;
queue<P> que;
void bfs(int x, int y) {
	que.push({ x, y });
	vis[x][y] = true;
	while (que.size()) {
		auto p = que.front(); que.pop();
		int x = p.first, y = p.second;
		for (int dx = -1; dx <= 1; dx++) {
			for (int dy = -1; dy <= 1; dy++) {
				int nx = x + dx, ny = y + dy;
				if (nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
				if (vis[nx][ny] || g[nx][ny] == '.') continue;
				vis[nx][ny] = true;
				que.push({ nx, ny });
			}
		}
	}
}
void solve() {
	int ans = 0;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			if (g[i][j] == 'W' && !vis[i][j]) {
				bfs(i, j);
				ans++;
			}
		}
	}
	printf("%d\n", ans);
}

• 给定一个N行M列的01矩阵A，$A[i][j]$ 与 $A[k][l]$ 之间的曼哈顿距离定义为：

$$dist(A[i][j],A[k][l])=|i-k|+|j-l|$$

• 输出一个N行M列的整数矩阵B，其中：

$$B[i][j]=mi{n}_{1\le x\le N,1\le y\le M,A[x][y]=1}dist(A[i][j],A[x][y])$$

• 多源 BFS 问题.
• 虚拟源点，无需解释，直接上代码。

queue<P> que;
void bfs() {
	memset(d, -1, sizeof d);
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			if (g[i][j] == '1') {
				d[i][j] = 0;
				que.push(P(i, j));
			}
		}
	}
	while (que.size()) {
		auto p = que.front(); que.pop();
		int x = p.first, y = p.second;
		for (int i = 0; i < 4; i++) {
			int nx = x + dx[i], ny = y + dy[i];
			if (nx < 0 || nx >= N || ny < 0 || ny >= M || d[nx][ny] != -1) continue;
			d[nx][ny] = d[x][y] + 1;
			que.push(P(nx, ny));
		}
	}
}

• 这道题并不是所有节点都可以访问到的。只能访问到下标值和为偶数的节点。当中点下标之和为奇数的时候就访问不到。
• 注意这个偏移量数组的灵活运用 (dx, ix, ok).
• 这迷宫的终点是(N, M)，一定注意！而且下标是从0开始的。而且注意要取出队头pop_front()。
• 这道题判断重复访问的位置只能放到从 deque 取出的地方，不可以往后放。因为这个节点访问顺序不好保证。
• 双端队列广搜有一个和bfs不一样的地方，即第一次从双端队列弹出的是最短距离，但是第一次更新的时候并不是！因此，判断节点是否被访问过，以及更新距离的方式，都要改变。而bfs第一次更新的时候就已经是最短距离了。

bool vis[maxn][maxn];
char g[maxn][maxn];
int dx[] = { 1, 1, -1, -1 }, dy[] = { 1, -1, 1, -1 };
int ix[] = { 0, 0, -1, -1 }, iy[] = { 0, -1, 0, -1 };
const char* ok = "\\//\\";
int bfs() {
	for (int i = 0; i <= N; i++) {
		for (int j = 0; j <= M; j++) {
			d[i][j] = INF;
		}
	}
	memset(vis, false, sizeof vis);
	deque<P> dq;
	d[0][0] = 0;
	dq.push_back(P(0, 0));

	while (dq.size()) {
		auto p = dq.front(); dq.pop_front();
		int x = p.first, y = p.second;
		if (x == N && y == M) return d[x][y];
		
		if (vis[x][y]) continue;
		vis[x][y] = true;
		for (int i = 0; i < 4; i++) {
			int nx = x + dx[i], ny = y + dy[i];
			if (nx < 0 || nx > N || ny < 0 || ny > M) continue;
			int w = (g[x + ix[i]][y + iy[i]] != ok[i]);
			if (d[nx][ny] >= d[x][y] + w) {
				d[nx][ny] = d[x][y] + w;
				if (w) dq.push_back(P(nx, ny));
				else dq.push_front(P(nx, ny));
			}
		}
	}
}

#include<iostream>
#include<string>
#include<unordered_map>
#include<queue>
using namespace std;
string a[10], b[10], A, B;
int N;
int extend(queue<string>& que, unordered_map<string, int>& da, unordered_map<string, int>& db, string a[], string b[]) {
	string st = que.front(); que.pop();
	string ed;
	for (int i = 0; i < st.size(); i++) {
		for (int j = 0; j < N; j++) {
			if (st.substr(i, a[j].size()) == a[j]) {
				ed = st.substr(0, i) + b[j] + st.substr(i + a[j].size());
				if (db.count(ed)) return da[st] + 1 + db[ed];
				if (da.count(ed)) continue;
				da[ed] = da[st] + 1;
				que.push(ed);
			}
		}
	}
	return 11;
}
int bfs() {
	queue<string> qa, qb;
	unordered_map<string, int> da, db;
	qa.push(A), qb.push(B), da[A] = 0, db[B] = 0;
	//因为只要又一个队列为空，那么必然从起点无法转移到终点了。
	while (qa.size() && qb.size()) {
		int t;
		if (qa.size() < qb.size()) t = extend(qa, da, db, a, b);
		else t = extend(qb, db, da, b, a);
		if (t <= 10) return t;
	}
	return 11;
}
int main() {
	cin >> A >> B;
	while (cin >> a[N] >> b[N]) N++;
	int ans = bfs();
	if (ans > 10) cout << "NO ANSWER!\n";
	else cout << ans << endl;
	return 0;
}

• 整个搜索空间非常庞大。
• 由于百科中说估计值与真实值越接近，最终搜索速度越快。所以这里选择到终点的最短路作为估计值（可以建反图来求得）。
• 第几次出队就是第几短,于是终点出了k次就是第k短路了。
• 这道题容易漏掉两种无解的情况：起点与终点重合，起点与终点不连通。

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P3;
const int maxn = 1010, maxm = 100010, INF = 0x3f3f3f3f;
int h[maxn], hr[maxn], ne[maxm], e[maxm], w[maxm], idx;
int N, M, S, T, K, d[maxn];
bool vis[maxn];
void add(int h[], int a, int b, int c) {
	e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void dijkstra() {
	priority_queue<P, vector<P>, greater<P>> que;
	fill(d, d + maxn, INF);
	d[T] = 0; que.push(P(0, T));
	while (que.size()) {
		auto p = que.top(); que.pop();
		int u = p.second;
		if (vis[u]) continue;
		vis[u] = true;
		for (int i = hr[u]; i != -1; i = ne[i]) 
        {
			int v = e[i];
			if (d[v] > d[u] + w[i]) 
            {
				d[v] = d[u] + w[i];
				que.push(P(d[v], v));
			}
		}
	}
}
int astar() {
	//若起点与终点不连通，也是无解吖。。。
	if (d[S] == INF) return -1;
	priority_queue<P3, vector<P3>, greater<P3>> que;
	que.push(P3(d[S], P(0, S)));
	int cnt = 0;
	while (que.size()) {
		auto p = que.top(); que.pop();
		int u = p.second.second, dis = p.second.first;
		if (u == T) cnt++;
		if (cnt == K) return dis;
		for (int i = h[u]; i != -1; i = ne[i]) {
			int v = e[i];
			//如何判断所有路径？就是不经判断，把所有经过的路径全部加进来。
			que.push(P3(dis + w[i] + d[v], P(dis + w[i], v)));
		}
	}
	return -1;
}
int main() {
	memset(h, -1, sizeof h);
	memset(hr, -1, sizeof hr);
	scanf("%d%d", &N, &M);
	for (int i = 0; i < M; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(h, a, b, c);
		add(hr, b, a, c);
	}
	scanf("%d%d%d", &S, &T, &K);
	//因为题中说路径至少包含一条边，因此，对于起点和终点重合的情况，若想让路径至少包含一条边，要这样处理：
	if (S == T) K++;
	dijkstra();
	printf("%d\n", astar());
}

• 给定一颗树。请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。
• 这道题一直WA的原因是双向边，但是边的数组最开始开小了。双向边的话，数组一定要开到两倍！

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 100005, maxm = maxn * 2;
int h[maxn], e[maxm], ne[maxm], idx, N, ans;
bool vis[maxn];  //该节点是否访问过。
void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int dfs(int u) {
	vis[u] = true;
	//res储存各个连通块中点数的最大值，sum储存从节点u出发的子树的大小。
	int res = 0, sum = 1;
	for (int i = h[u]; i != -1; i = ne[i]) {
		int v = e[i];
		if (!vis[v]) {
			int s = dfs(v);
			res = max(res, s);
			sum += s;
		}
	}
	//N - sum是上面的那个连通块的大小
	res = max(res, N - sum);
	ans = min(res, ans);
	return sum;
}
int main() {
	for (int i = 0; i < maxn; i++) h[i] = -1;
	int a, b;
	scanf("%d", &N);
	ans = N;
	for (int i = 0; i < N - 1; i++) {
		scanf("%d%d", &a, &b);
		add(a, b), add(b, a);
	}
	dfs(1);
	printf("%d\n", ans);
	return 0;
}

树是一种很常见的数据结构。我们把 $N$ 个点，$N-1$ 条边的连通无向图称为树。若将某个点作为根，从根开始遍历，则其它的点都有一个前驱，这个树就成为有根树。对于两个树 $T_1$ 和 $T_2$，如果能够把树 $T_1$ 的所有点重新标号，使得树 $T_1$ 和树 $T_2$ 完全相同，那么这两个树是同构的。也就是说，它们具有相同的形态。

现在，给你 $M$ 个无根树，请你把它们按同构关系分成若干个等价类.

注意这个题的输入，树的编号是 $1\sim N$，结点父结点编号为 $0$ 说明该点没有父结点.

(wsy) 最难卡掉的树哈希方法：$rd$ 数组是一个随机数生成的数组：h[i] = rnd() % M，其中 $M$ 是一个大质数.

叶节点的哈希值定义为1.
$$Hash(T_R)=\prod _{i\in son(R)}(rd(size(T_R)+Hash(T_i))\mathrm{mod}M$$
对于无根树，可以先求树的重心作为根，如果重心有两个就建立虚拟节点连接两个重心，把虚拟节点当作根节点.

判断无根树同构，也可以跑两遍树形DP，求出每个点为根时的Hash值，排序后比较即可。不过应该需要用到 $f_x=1+{\sum }_{y\in so{n}_x}{f}_y\times prime(siz{e}_y)$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const int N = 60, M = 110;

int h[N], e[M], ne[M], idx, sz[N], weight[N];
ll Hash[N], Hash_tree[N];
int centroid[2];
inline void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
mt19937 rnd(0);
int n, m;

//求树的重心
int getCentroid(int u, int fa)
{
    sz[u] = 1, weight[u] = 0;
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];

        if(v == fa) continue;

        sz[u] += getCentroid(v, u);
        //找到size最大的子树.
        weight[u] = max(weight[u], sz[v]);
    }
   	//子树还有来自父结点的那棵子树.
    weight[u] = max(weight[u], n - sz[u]);
    if(weight[u] <= n / 2)
    {
        centroid[centroid[0] != 0] = u;
    }
    return sz[u];
}

void getHash(int u, int fa)
{
    Hash_tree[u] = sz[u] = 1;

    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(v == fa) continue;
        getHash(v, u);
        sz[u] += sz[v];
    }
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(v == fa) continue;
        Hash_tree[u] = Hash_tree[u] * (Hash[sz[u]] + Hash_tree[v]) % mod;
    }
}

int main()
{
    for(int i = 1; i < N; i++)
    {
        Hash[i] = rnd() % mod;
    }
    unordered_map<ll, int> Map;
    scanf("%d", &m);
    for(int id = 1; id <= m; id++)
    {
        memset(h, -1, sizeof h);
        idx = 0;
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
        {
            int p;
            scanf("%d", &p);
            if(!p) continue;
            add(p, i);
            add(i, p);
        }
        centroid[0] = centroid[1] = 0;
        getCentroid(1, -1);

        int rt0 = centroid[0], rt1 = centroid[1];
        ll res = 1;
        if(!rt1)
        {
            getHash(rt0, -1);
            res = (Hash[sz[rt0]] + Hash_tree[rt0]) % mod;
        }
        else
        {
            getHash(rt0, rt1);
            res = (Hash[n] + Hash_tree[rt0]) % mod;
            getHash(rt1, rt0);
            res = res * (Hash[n] + Hash_tree[rt1]) % mod;
        }
        if(!Map.count(res)) Map[res] = id;
        printf("%d\n", Map[res]);
    }
}

• 给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环。所有边的长度都是 1，点的编号为 $1$∼$n$。请你求出 1 号点到 $n$ 号点的最短距离，如果从 1 号点无法走到 $n$ 号点，输出 −1。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100010, maxm = 100010, INF = 0x3f3f3f3f;
int h[maxn], e[maxm], ne[maxm], idx;
int N, M, d[maxn];
void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int bfs() {
	queue<int> que;
	memset(d, 0x3f, sizeof d);
	que.push(1);
	d[1] = 0;
	while (que.size()) {
		int u = que.front(); que.pop();
		for (int i = h[u]; i != -1; i = ne[i]) {
			int v = e[i];
			if (d[v] != INF) continue;
			d[v] = d[u] + 1;
			que.push(v);
		}
	}
	if(d[N] == INF) return -1;
	return d[N];
}
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);
	}
	bfs();
	printf("%d\n", bfs());
	return 0;
}

• 适用范围：单源最短路，存在负权边（平均情况下O(m)，最坏情况下O(nm)）。
• 这个函数返回值依然是判断是否等于INF，因为这个是用队列维护的，没有更新到的点不会加入队列，自然也不会去更新d[t]的值。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100010, INF = 0x3f3f3f3f;
int h[maxn], e[maxn], ne[maxn], w[maxn], idx;
int N, M, d[maxn];
bool vis[maxn];
void add(int a, int b, int c) {
	e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void spfa() {
	queue<int> que;
	que.push(1);
	memset(d, 0x3f, sizeof d);
	d[1] = 0;
	vis[1] = true;
	while (que.size()) {
		int u = que.front(); que.pop();
		vis[u] = false;
		for (int i = h[u]; i != -1; i = ne[i]) {
			int v = e[i];
			if (d[v] > d[u] + w[i]) {
				d[v] = d[u] + w[i];
				if (!vis[v]) {
					que.push(v);
					vis[v] = true;
				}
			}
		}
	}
}
int main() {
	scanf("%d%d", &N, &M);
	memset(h, -1, sizeof h);
	for (int i = 0; i < M; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	spfa();
	if (d[N] == INF) printf("impossible\n");
	else printf("%d\n", d[N]);
	return 0;
}

• 注意，从头到尾变化还是不少的
• 原理：统计当前某个点的最短路所包含的边数。若边数大于等于N，则说明有负环。
• 经验表明，spfa求负环的时候，复杂度通常会高达$O(nm)$，那么，经验表明，当所有点入队次数超过2n次的时候，很可能存在负环。虽然不能保证一定正确，但是用spfa超时的时候，这个方法效果还不错。
• d不初始化也无所谓，d的初值并不影响答案。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 2010, maxm = 10010;
int h[maxn], e[maxm], ne[maxm], w[maxm], idx;
int N, M, d[maxn], cnt[maxn];
bool vis[maxn];
void add(int a, int b, int c) {
	e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
//有负环的话返回true.
bool spfa() {
	queue<int> que;
	for (int i = 1; i <= N; i++) {
		//防止图不连通。其实等效加了一个虚拟超级源点。
		que.push(i);
		vis[i] = true;
	}
	while (que.size()) {
		int u = que.front(); que.pop();
		vis[u] = false;
		for (int i = h[u]; i != -1; i = ne[i]) {
			int v = e[i];
			if (d[v] > d[u] + w[i]) {
				d[v] = d[u] + w[i];
				cnt[v] = cnt[u] + 1;
				if (cnt[v] >= N) return true;
				if (!vis[v]) {
					que.push(v);
					vis[v] = true;
				}
			}
		}
	}
    return false;
}
int main() {
	scanf("%d%d", &N, &M);
	memset(h, -1, sizeof h);
	for (int i = 0; i < M; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	if (spfa()) printf("Yes\n");
	else printf("No\n");
	return 0;
}

1. 给定一张无向图，求图中一个至少包含3个点的环，环上的节点不重复，并且环上的边的长度之和最小。该问题称为无向图的最小环问题。你需要输出最小环的方案，若最小环不唯一，输出任意一个均可。
2. 按照环的编号最大的节点 $k$ 的编号分类。那么环一定可以写成边 $ik$ 、边 $kj$，加上一个路径 $i$ 到 $j$。这样，我们可以确定 $k$ 时，循环所有 $(i,j)$ 对。
3. $d[i,j]=d[i,k]+d[k,j]$，这个 $k$ 就本身具备了记录路径的功能，每当跟新的时候，我们可以把它记录下来，即 $pos[i,j]=k$.
4. 凡是涉及到三个相加的，$INF$ 一定不要写成 $0x3f3f3f3f$，因为又溢出的风险。

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 110, INF = 1e7;
int N, M;
int d[maxn][maxn], g[maxn][maxn], cnt, pos[maxn][maxn], ans[maxn];
void get_path(int i, int j) {
	if (pos[i][j] == 0) return;
	int k = pos[i][j];
	get_path(i, k);
	ans[cnt++] = k;
	get_path(k, j);
}
int main() {
	scanf("%d%d", &N, &M);
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) g[i][j] = INF;
	}
	for (int i = 1; i <= N; i++) g[i][i] = 0;
	for (int i = 0; i < M; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		g[a][b] = g[b][a] = min(c, g[a][b]);
	}
	memcpy(d, g, sizeof d);
	int res = INF;
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i < k; i++) {
			for (int j = i + 1; j < k; j++) {
				if (d[i][j] + g[i][k] + g[k][j] < res) {
					res = d[i][j] + g[j][k] + g[k][i];
					cnt = 0;
					ans[cnt++] = k;
					ans[cnt++] = i;
					get_path(i, j);
					ans[cnt++] = j;
				}
			}
		}
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N; j++) {
				if (d[i][j] > d[i][k] + d[k][j]) {
					d[i][j] = d[i][k] + d[k][j];
					pos[i][j] = k;
				}
			}
		}
	}
	if (res == INF) printf("No solution.\n");
	else {
		for (int i = 0; i < cnt; i++) printf("%d ", ans[i]);
	}
	return 0;
}

• 给定一张由 $T$ 条边构成的无向图，点的编号为 $1\sim 1000$ 之间的整数。求从起点 $S$ 到终点 $E$ 恰好经过 $N$ 条边（可以重复经过）的最短路。

• $floyd$ 算法是 $d[k,i,j]$ 表示从i到j，只经过 $1\sim k$ 的距离最小值。倍增算法略作改动，$d[k,i,j]$ 表示从 $i$ 到 $j$，只经过 $k$ 条边的最短路径。

• 那么，设从 $i$ 到 $k$ 经过 $a$ 条边，从 $k$ 到 $j$ 经过 $b$ 条边，那么 $d[a+b,i,j]=\min (d[a,i,k]+d[b,k,j])$。

• 注意，sizeof参数必须是一个真正的数组，不可以是函数传进来的指针

• 复杂度是$O(n^3\log n)$。运用了快速幂的思想。快速幂可以成立的一个重要原因是结合律是成立的。包括矩阵的快速幂也是因为矩阵之间乘法的结合律是成立的。具体的解释可以看看代码注释：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
const int maxn = 110, INF = 0x3f3f3f3f;
int g[maxn][maxn], res[maxn][maxn];
int N, M, K, st, ed;
map<int, int> id;

void mul(int c[][maxn], int a[][maxn], int b[][maxn]) {
	//因为c与a或b可能是同一数组，防止访问冲突，再开一个数组。
	static int tmp[maxn][maxn];
	for (int i = 0; i < maxn; i++) fill(tmp[i], tmp[i] + maxn, INF);
	for (int k = 0; k < N; k++) {
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				tmp[i][j] = min(tmp[i][j], a[i][k] + b[k][j]);
			}
		}
	}
	//这一步其实相当于重新建图，把经过边数为1的路径去掉，把边数为2的路径作为新的边连起来。
	memcpy(c, tmp, sizeof tmp);
}
void qmi() {
	for (int i = 0; i < maxn; i++) {
		fill(res[i], res[i] + maxn, INF);
		//这个地方必须要把res[i][i]初始化为0.因为这个存的是答案，不只是路径的问题。
		res[i][i] = 0;
	}
	//就像快速幂一样。
	while (K) {
		//mul(res, res, g) 和 mul(res, g, res) 都可以 AC
		if (K & 1) mul(res, res, g);
		mul(g, g, g);
		K >>= 1;
	}
}
int main() {
	scanf("%d%d%d%d", &K, &M, &st, &ed);
	if (!id.count(st)) id[st] = N++;
	st = id[st];
	if (!id.count(ed)) id[ed] = N++;
	ed = id[ed];
	for (int i = 0; i < maxn; i++) {
		fill(g[i], g[i] + maxn, INF);
	}
	//注意，这里不可以把g[i][i]初始化为0.因为从i走到i表示一个自环呀，算经过1个节点。
	for (int i = 0; i < M; i++) {
		int a, b, c;
		scanf("%d%d%d", &c, &a, &b);
		if (!id.count(a)) id[a] = N++;
		if (!id.count(b)) id[b] = N++;
		a = id[a], b = id[b];
		g[a][b] = g[b][a] = min(g[a][b], c);
		
	}
	qmi();
	printf("%d\n", res[st][ed]);
	return 0;
}

• 其实还可以这样写倍增算法：

void qmi() {
	memset(res, 0x3f, sizeof res);
	for (int i = 1; i <= N; i++) res[i][i] = 0;
	while (K) {
	//差别在这里，把结果存在res里面，这样更像快速幂。
	//而且此时写成mul(g, res, res)不影响结果。感觉这样子好像更合理一些。
		if (K & 1) mul(res, g, res);
		mul(g, g, g);
		K >>= 1;
	}
}

• 可以分块。块儿内部都是非负权边，可以用dijkstra来算。团外部又负权边但是无环，可以按照拓扑图来做。块儿的内部是不可能有航线的。因为若A和B节点之间有航线，就不可能有道路，否则无法满足“不能从B到A”这一条件。
• 另外，我在想，最开始的时候，如果一个连通块入度为0，是不是等价于S在这个连通块儿内部。不然，这个连通块儿是不可能从S走的到的呀。
• 当然要入度减到0的时候入队啊，不然其他的点根本就没办法用dijkstra计算啊。
• 最后还是要提醒，又负权边的话，只要不是 spfa，最后判断距离都要 > INF / 2。

1. 先输入所有双向道路,然后 DFS 出所有连通块，计算两个数组: id[] 存储每个点属于哪个连通块; vector< int > block[] 存储每个连通块里有哪些点;
2. 输入所有航线，同时统计出每个连通块的入度。
3. 按照拓扑序依次处理每个连通块。先将所有入度为0的连通块的编号加入队列中。
4. 每次从队头取出一个连通块的编号bid.
5. 将该block[bid]中的所有点加入堆中，然后对堆中所有点跑dijkstra算法。注：这相当于建立了超级源点（即起点），然后将该块中的所有点都加入队列中.
6. 每次取出堆中距离最小的点ver.
7. 然后遍历ver的所有邻点。如果 $id[ver]==id[j]$，那么如果 $j$ 能被更新，则将其插入堆中；如果 $id[ver]\ne id[j]$ ，则将 $id[j]$ 这个连通块的入度减 $1$，如果减成 $0$了，则将其插入拓扑排序的队列中。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn = 25010, maxm = 150010, INF = 0x3f3f3f3f;
int h[maxn], e[maxm], ne[maxm], w[maxm], idx;
int N, M1, M2, S, d[maxn];
bool vis[maxn];
int id[maxn], in[maxn], bcnt;
vector<int> blocks[maxn];
void add(int a, int b, int c){
	e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
queue<int> que;
void dfs(int u) {
	blocks[bcnt].push_back(u);
	id[u] = bcnt;
	for (int i = h[u]; i != -1; i = ne[i]) {
		int v = e[i];
		if (!id[v]) dfs(v);
	}
}
typedef pair<int, int> P;
void dijkstra(int x) {
	priority_queue<P, vector<P>, greater<P> > pq;
	for (auto u : blocks[x]) pq.push(P(d[u], u));
	while (pq.size()) {
		auto p = pq.top(); pq.pop();
		int u = p.second, dis = p.first;
		if (vis[u]) continue;
		vis[u] = true;
		for (int i = h[u]; i != -1; i = ne[i]) {
			int v = e[i];
			if (d[v] > d[u] + w[i]) {
				d[v] = d[u] + w[i];
				if (id[u] == id[v]) pq.push(P(d[v], v));
			}
			if (id[u] != id[v] && --in[id[v]] == 0) que.push(id[v]);
		}
	}
}
void toposort() {
	fill(d, d + maxn, INF);
	for (int i = 1; i <= bcnt; i++) {
		if (in[i] == 0) que.push(i);
	}
	d[S] = 0;
	while (que.size()) {
		int x = que.front(); que.pop();
		dijkstra(x);
	}
}
int main() {
	memset(h, -1, sizeof h);
	scanf("%d%d%d%d", &N, &M1, &M2, &S);
	for (int i = 0; i < M1; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
		add(b, a, c);
	}
	for (int i = 1; i <= N; i++) {
		if (!id[i]) {
			bcnt++;
			dfs(i);
		}
	}
	for (int i = 0; i < M2; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
		in[id[b]]++;
	}
	toposort();
	for (int i = 1; i <= N; i++) {
		if (d[i] > INF / 2) printf("NO PATH\n");
		else printf("%d\n", d[i]);
	}
	return 0;
}

• 题意：$n$ 个点 $m$ 条边，任意两个点之间至多一条道路，有单向边也有双向边，每个点都有一个点权，要求找到两个结点 $u$ 和 $v$，使得 $u$ 的点权 减去$v$ 的点权的结果最大，并且可以从1号点走到 $u$，从 $u$ 走到 $v$，再从 $v$ 走到 $n$ 号点.
• 这个可以从 $dp$ 的角度思考问题。以 $k$ 为分界点，买在 $1\sim k$ 中（在这之间寻找买入最小值 $dmin[k]$ ），卖在 $k\sim N$ 中（在这之间寻找卖出最大值 $dmax[k]$），不过这里的 $k$ 也可以作为买入点或卖出点。
• 记 $F[x]$ 为点权，$D[x]$ 存储从起点到 $x$ 的访问到的点权的最大值或最小值。建图以及建反图，可以用 SPFA 或者 Dijkstra 算法，把 $d[x]+w(x,y)$ 换成 d [ x ] = min ⁡ { d [ x ] , p r i c e [ y ] } d[x] = \min\{d[x],price[y]\} d[x]=min{d[x],price[y]} 来更新。正反分别跑一遍最短路；最后枚举每个节点 $x$，用 $F[x]-D[x]$ 更新答案。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 100010, maxm = 2000010, INF = 0x3f3f3f3f;
int hs[maxn], ht[maxn], e[maxm], ne[maxm], w[maxn], idx;
int dmin[maxn], dmax[maxn], N, M;
bool vis[maxn];
void add(int a, int b, int type) 
{
	if (type) e[idx] = b, ne[idx] = ht[a], ht[a] = idx++;
	else e[idx] = b, ne[idx] = hs[a], hs[a] = idx++;
}
void spfa(int h[], int d[], int type) 
{
	queue<int> que;
	//spfa是不用将vis初始化的。因为队列为空的时候才会跳出while循环嘛。
	if (!type) {
		fill(d, d + maxn, INF);
		d[1] = w[1], vis[1] = true;
		que.push(1);
	}
	else {
	//这一步将d初始化为0或-INF都是对的。因为点权的最小值是1。
	//一开始我还以为是边权变成负数然后求最大值，然后发现不是这样。
	//因为这个不是在跑最短路，只是用了spfa的板子而已。
		fill(d, d + maxn, -INF);
		d[N] = w[N], vis[N] = true;
		que.push(N);
	}
	while (que.size()) {
		int u = que.front(); que.pop();
		vis[u] = false;
		for (int i = h[u]; i != -1; i = ne[i]) {
			int v = e[i];
			if (!type && d[v] > min(d[u], w[v]) || type && d[v] < max(d[u], w[v])) {
				if (!type) d[v] = min(d[u], w[v]);
				else d[v] = max(d[u], w[v]);
				if (!vis[v]) {
					vis[v] = true;
					que.push(v);
				}
			}
		}
	}
}
int main() {
	memset(hs, -1, sizeof hs);
	memset(ht, -1, sizeof ht);
	scanf("%d%d", &N, &M);
	for (int i = 1; i <= N; i++) scanf("%d", &w[i]);
	for (int i = 0; i < M; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, 0), add(b, a, 1);
		if (c == 2) add(b, a, 0), add(a, b, 1);
	}
	spfa(hs, dmin, 0);
	spfa(ht, dmax, 1);
	int ans = 0;
	for (int i = 1; i <= N; i++) ans = max(dmax[i] - dmin[i], ans);
	printf("%d\n", ans);
	return 0;
}

• 题意：整个迷宫被划分为 $n\ast m$ 个单元。南北或东西方向相邻的 $2$ 个单元之间可能互通，也可能有一扇锁着的门，或者是一堵不可逾越的墙。迷宫中有一些单元存放着钥匙，同一个单元可能存放多把钥匙，并且所有的门被分成 $P$ 类，打开同一类的门的钥匙相同，不同类门的钥匙不同。求从 $(1,1)$出发 到 $(n,m)$ 的最少移动距离。

• $1\le n,m,p\le 10$，墙和门的总数最多150个.

• 从 $dp$ 角度思考，设 $d(x,y,state)$ 就是在 $(x,y)$ 这个点，拥有钥匙状态时 $state$ (因为只有10把钥匙🔑，所以用二进制表示很方便)，这个值储存的是最短步数。可以变成两种情况：

1. 捡钥匙： d ( x , y , s t a t e ) = min ⁡ { d ( x , y , s t a t e ) , d ( x , y , s t a t e ∣ k e y ) } d(x, y, state) = \min\{d(x, y, state), d(x, y, state | key)\} d(x,y,state)=min{d(x,y,state),d(x,y,state∣key)}；
2. 移动（没有门或墙，有门且有匹配的钥匙）： d ( a , b , s t a t e ) = max ⁡ { d ( x , y , s t a t e ) + 1 , d ( a , b , s t a t e ) } d(a, b, state) = \max\{d(x, y, state) + 1, d(a, b, state)\} d(a,b,state)=max{d(x,y,state)+1,d(a,b,state)}。

• 所以状态的转移可以是走 $1$ 步，也可以是走 $0$ 步。就可以变成双端队列广搜了。于是处理步骤如下：

1. 建图：先把墙和门的信息保存在 $set$ 里面，然后用邻接表建图。用 $w[i]$ 表示边的信息，$0$ 为没有门也没有墙，$>0$ 时为需要哪个钥匙，这里多说一句，输入0时表示有墙，但是有墙的时候是不建立边的。
2. 先捡钥匙，此过程就是走权重为 $0$ 的边。第二步向四个方向移动，就是走权重为 $1$ 的边。然后答案就出来了。

• 小心左移右移别搞混。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<deque>
#include<set>
using namespace std;
const int maxn = 110, maxm = 410, maxp = 1 << 10, INF = 0x3f3f3f3f;
int h[maxn], e[maxm], ne[maxm], w[maxm], idx;
bool vis[maxn][maxp];
typedef pair<int, int> P;
set<P> s;
int g[15][15], N, M, T, K, S, key[maxn], d[maxn][maxp];
void add(int a, int b, int c) {
	e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
deque<P> dq;
int dx[] = { 1, -1, 0, 0 }, dy[] = { 0, 0, 1, -1 };
void build() {
	for (int x = 1; x <= N; x++) {
		for (int y = 1; y <= M; y++) {
			for (int i = 0; i < 4; i++) {
				int nx = x + dx[i], ny = y + dy[i];
				if (nx < 1 || nx > N || ny < 1 || ny > M) continue;
				int a = g[x][y], b = g[nx][ny];
				//没有墙或门，则记边权为0。
				if (!s.count(P(a, b))) add(a, b, 0);
			}
		}
	}
}
int bfs() {
	for (int i = 1; i <= N * M; i++) {
		fill(d[i], d[i] + maxp, INF);
	}
	d[1][0] = 0;
	dq.push_back(P(1, 0));
	while (dq.size()) {
		auto p = dq.front(); dq.pop_front();
		int u = p.first, state = p.second;
		if (vis[u][state]) continue;
		vis[u][state] = true;
		if (u == N * M) return d[u][state];
		if (key[u]) {
			int new_state = state | key[u];
			if (d[u][new_state] > d[u][state]) {
				d[u][new_state] = d[u][state];
				dq.push_front(P(u, new_state));
			}
		}
		for (int i = h[u]; i != -1; i = ne[i]) {
			int v = e[i];
			if (d[v][state] > d[u][state] + 1) {
				if (w[i] && !((state >> w[i] - 1) & 1)) continue;
				d[v][state] = d[u][state] + 1;
				dq.push_back(P(v, state));
			}
		} 
	}
	return -1;
}
int main() {
	memset(h, -1, sizeof h);
	int id = 1;
	scanf("%d%d%d%d", &N, &M, &T, &K);
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= M; j++) g[i][j] = id++;
	}
	
	for (int i = 0; i < K; i++) {
		int x1, y1, x2, y2, c;
		scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &c);
		int a = g[x1][y1], b = g[x2][y2];
		s.insert(P(a, b)), s.insert(P(b, a));
		if (c) add(a, b, c), add(b, a, c);
	}
	scanf("%d", &S);
	for (int i = 0; i < S; i++) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		int u = g[a][b];
		key[u] |= 1 << c - 1;
	}
	build();
	printf("%d\n", bfs());
	return 0;
}