1. 卡码网 97. 小明逛公园

题目链接：https://kamacoder.com/problempage.php?pid=1155
文章链接：https://www.programmercarl.com/kamacoder/0097.小明逛公园.html

思路：
使用Floyd 算法，目的是解决多源最短路问题，即 求多个起点到多个终点的多条最短路径。
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
用 grid数组来存图，那就把dp数组命名为 grid。
grid[i][j][k] = m，表示 节点i 到 节点j 以[1…k] 集合为中间节点的最短距离为m。
注意：[1…k] ，表示节点1 到 节点k 一共k个节点的集合。
2、确定递推公式
分两种情况：
1.节点i 到 节点j 的最短路径经过节点k
对于该情况，grid[i][j][k] = grid[i][k][k - 1] + grid[k][j][k - 1]
节点i 到 节点k 的最短距离 是不经过节点k，中间节点集合为[1…k-1]，所以 表示为grid[i][k][k - 1]
节点k 到 节点j 的最短距离 也是不经过节点k，中间节点集合为[1…k-1]，所以表示为 grid[k][j][k - 1]
2.节点i 到 节点j 的最短路径不经过节点k
对于该情况，grid[i][j][k] = grid[i][j][k - 1]
如果节点i 到 节点j的最短距离 不经过节点k，那么 中间节点集合[1…k-1]，表示为 grid[i][j][k - 1]
因为我们是求最短路，对于这两种情况自然是取最小值。
即： grid[i][j][k] = min(grid[i][k][k - 1] + grid[k][j][k - 1]， grid[i][j][k - 1])
3.dp数组如何初始化

vector<vector<vector<int>>> grid(n + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, 10005)));  // C++定义了一个三位数组，10005是因为边的最大距离是10^4for(int i = 0; i < m; i++){cin >> p1 >> p2 >> val;grid[p1][p2][0] = val;grid[p2][p1][0] = val; // 注意这里是双向图
} 

注意：输入数据没有涉及到的节点的情况都应该初始为一个最大数，此处设值为10005。
4.确定遍历顺序
初始化时，我们是把 k =0 的 i 和j 对应的数值都初始化了，这样才能去计算 k = 1 的时候 i 和 j 对应的数值。
因此，遍历k 的for循环一定是在最外面，遍历 i 和 j 的话，for 循环的先后顺序无所谓。

for (int k = 1; k <= n; k++) {for (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {grid[i][j][k] = min(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1]);}}
}

import java.util.*;public class Main{public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt(); // 景点的数量int m = sc.nextInt(); // 道路的数量// 1. 定义dp数组和下标// dp[i][j][k] 表示节点i 到 节点j 以[1...k] 集合为中间节点的最短距离。int[][][] dp = new int[n+1][n+1][n+1];// 2. 递推公式// dp[i][j][k] = Math.min(dp[i][j][k-1],dp[i][k][k-1]+dp[k][j][k-1]);// 3. 初始化for (int i=0;i<=n;i++) {for (int j=0;j<=n;j++) {Arrays.fill(dp[i][j],10005);}}for (int i=0;i<m;i++) {int u = sc.nextInt();int v = sc.nextInt();int w = sc.nextInt();dp[u][v][0] = w;dp[v][u][0] = w;}//4. 遍历顺序for (int k=1;k<=n;k++) {for (int i=1;i<=n;i++) {for (int j=1;j<=n;j++) {dp[i][j][k] = Math.min(dp[i][j][k-1],dp[i][k][k-1]+dp[k][j][k-1]);}}}int q = sc.nextInt();for (int i=0;i<q;i++) {int start = sc.nextInt();int end = sc.nextInt();if (dp[start][end][n] == 10005) {System.out.println(-1);} else {System.out.println(dp[start][end][n]);}}}
}

2. 卡码网 127. 骑士的攻击

题目链接：https://kamacoder.com/problempage.php?pid=1203
文章链接：https://www.programmercarl.com/kamacoder/0126.骑士的攻击astar.html

思路：
使用Astar算法， 关键在于 启发式函数， 也就是 影响 广搜或者 dijkstra 从 容器（队列）里取元素的优先顺序。

启发式函数 要影响的就是队列里元素的排序！
对队列里节点进行排序，就需要给每一个节点权值，如何计算权值呢？
每个节点的权值为F，给出公式为：F = G + H
1.G：起点达到目前遍历节点的距离
2.H：目前遍历的节点到达终点的距离
当前遍历节点的权值F：起点达到目前遍历节点的距离 + 目前遍历的节点到达终点的距离，就是起点到达终点的距离。
本题，采用欧拉距离才能最大程度体现 点与点之间的距离。
计算出来 F 之后，按照 F 的 大小，来选出队列中F最小的节点。

import java.util.*;public class Main {static int[][] moves = new int[1001][1001];static int[][] dir = {{-2, -1}, {-2, 1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}};static int b1, b2;static class Knight {int x, y;int g, h, f;public Knight(int x, int y, int g, int h, int f) {this.x = x;this.y = y;this.g = g;this.h = h;this.f = f;}}static class KnightComparator implements Comparator<Knight> {public int compare(Knight k1, Knight k2) {return k1.f - k2.f; // Java的优先队列默认是最小堆，所以这里用k1.f - k2.f来使得f值小的排在前面}}static PriorityQueue<Knight> que = new PriorityQueue<>(new KnightComparator());static int Heuristic(Knight k) { // 欧拉距离return (k.x - b1) * (k.x - b1) + (k.y - b2) * (k.y - b2);}static void astar(Knight k) {Knight cur, next;que.add(k);while (!que.isEmpty()) {cur = que.poll(); // 选出队列中F最小的节点if (cur.x == b1 && cur.y == b2) {break;}for (int i = 0; i < 8; i++) {next = new Knight(cur.x + dir[i][0], cur.y + dir[i][1], cur.g, 0, 0);if (next.x < 1 || next.x > 1000 || next.y < 1 || next.y > 1000) {continue;}if (moves[next.x][next.y] == 0) {moves[next.x][next.y] = moves[cur.x][cur.y] + 1;next.g = cur.g + 5;next.h = Heuristic(next);next.f = next.g + next.h;que.add(next);}}}}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();while (n-- > 0) {int a1 = scanner.nextInt();int a2 = scanner.nextInt();b1 = scanner.nextInt();b2 = scanner.nextInt();for (int[] row : moves) {Arrays.fill(row, 0);}Knight start = new Knight(a1, a2, 0, Heuristic(new Knight(a1, a2, 0, 0, 0)), 0);start.f = start.g + start.h;astar(start);System.out.println(moves[b1][b2]);que.clear(); // 清空队列}scanner.close();}
}