图论part11
Floyd 算法精讲
代码
三维DP数组
java
import java.util.Scanner;
public class Main {
// 定义最大距离值，避免使用Integer.MAX_VALUE防止加法溢出
public static final int INF = 100000000; // 10^8足够大且不会溢出
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
/*
* 1. 输入处理
* 第一行：N(景点数量), M(道路数量)
* 接下来M行：u, v, w (双向道路)
* 然后一行：Q(查询数量)
* 接下来Q行：start, end (查询起点和终点)
*/
int n = sc.nextInt(); // 景点数量 (1到n编号)
int m = sc.nextInt(); // 道路数量
/*
* 2. 初始化三维DP数组
* dp[k][i][j]表示从i到j，允许经过前k个节点(1..k)的最短路径
* 这里k的范围是0到n：
* - k=0表示不允许经过任何中间节点(直接边)
* - k=n表示允许经过所有节点
*/
int[][][] dp = new int[n+1][n+1][n+1];
// 初始化所有距离为INF，自己到自己的距离为0
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= n; k++) {
if (i == j) {
dp[k][i][j] = 0; // 自己到自己的距离为0
} else {
dp[k][i][j] = INF; // 初始化为最大值
}
}
}
}
// 3. 读取道路信息并填充初始距离(k=0的情况)
for (int i = 0; i < m; i++) {
int u = sc.nextInt();
int v = sc.nextInt();
int w = sc.nextInt();
// 双向道路，两个方向都要设置
dp[0][u][v] = w;
dp[0][v][u] = w;
}
/*
* 4. Floyd-Warshall算法核心部分(三维DP版本)
* 状态转移方程：
* dp[k][i][j] = min(dp[k-1][i][j], dp[k-1][i][k] + dp[k-1][k][j])
* 含义：
* - 从i到j允许经过前k个节点的最短路径 =
* min(不经过k的最短路径, 经过k的最短路径)
*/
for (int k = 1; k <= n; k++) { // 中间节点
for (int i = 1; i <= n; i++) { // 起点
for (int j = 1; j <= n; j++) { // 终点
// 比较两种情况：
// 1. 不经过节点k的最短路径(dp[k-1][i][j])
// 2. 经过节点k的最短路径(dp[k-1][i][k] + dp[k-1][k][j])
dp[k][i][j] = Math.min(dp[k-1][i][j], dp[k-1][i][k] + dp[k-1][k][j]);
}
}
}
// 5. 处理查询
int q = sc.nextInt(); // 查询数量
for (int i = 0; i < q; i++) {
int start = sc.nextInt();
int end = sc.nextInt();
// 使用允许经过所有节点(n个)的最短路径作为结果
// 如果不可达则输出-1
System.out.println(dp[n][start][end] == INF ? -1 : dp[n][start][end]);
}
}
}二维DP数组
java
import java.util.Scanner;
public class Main {
// 定义最大距离值，避免使用Integer.MAX_VALUE防止加法溢出
public static final int INF = 100000000; // 10^8足够大且不会溢出
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 1. 读取景点数量和道路数量
int n = sc.nextInt(); // 景点数量 (1到n编号)
int m = sc.nextInt(); // 道路数量
// 2. 初始化距离矩阵
int[][] dist = new int[n+1][n+1]; // 1-based索引
// 初始化所有距离为INF，自己到自己的距离为0
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) {
dist[i][j] = 0;
} else {
dist[i][j] = INF;
}
}
}
// 3. 读取道路信息并填充初始距离
for (int i = 0; i < m; i++) {
int u = sc.nextInt();
int v = sc.nextInt();
int w = sc.nextInt();
// 双向道路，两个方向都要设置
dist[u][v] = w;
dist[v][u] = w;
}
// 4. Floyd-Warshall算法核心部分
for (int k = 1; k <= n; k++) { // 中间节点
for (int i = 1; i <= n; i++) { // 起点
for (int j = 1; j <= n; j++) { // 终点
// 如果通过中间节点k可以缩短i到j的距离
if (dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
// 5. 处理查询
int q = sc.nextInt(); // 查询数量
for (int i = 0; i < q; i++) {
int start = sc.nextInt();
int end = sc.nextInt();
// 输出结果，如果不可达则输出-1
System.out.println(dist[start][end] == INF ? -1 : dist[start][end]);
}
}
}A * 算法精讲 （A star算法）
代码(超时，示例正确)
java
import java.util.*;
public class Main {
// 定义骑士的8种可能移动方式（马走日）
private static final int[][] MOVES = {
{1, 2}, {2, 1}, {2, -1}, {1, -2},
{-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}
};
// 节点类，表示棋盘上的一个位置
static class Node implements Comparable<Node> {
int x, y; // 当前位置坐标
int g; // 从起点到当前节点的实际代价
int h; // 到目标节点的启发式估计代价
Node parent; // 父节点（用于路径回溯）
public Node(int x, int y) {
this.x = x;
this.y = y;
this.g = 0;
this.h = 0;
}
// 计算总代价f = g + h
public int f() {
return g + h;
}
// 用于优先队列排序
@Override
public int compareTo(Node other) {
return Integer.compare(this.f(), other.f());
}
// 重写equals和hashCode用于比较节点
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Node node = (Node) obj;
return x == node.x && y == node.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
}
// A*算法实现
public static int aStarKnightPath(int startX, int startY, int targetX, int targetY) {
// 如果起点就是终点，直接返回0
if (startX == targetX && startY == targetY) {
return 0;
}
// 边界检查
if (!isValid(startX, startY) || !isValid(targetX, targetY)) {
return -1;
}
// 初始化开放列表和关闭列表
PriorityQueue<Node> openList = new PriorityQueue<>();
Set<Node> closedList = new HashSet<>();
// 创建起点节点
Node startNode = new Node(startX, startY);
startNode.g = 0;
startNode.h = heuristic(startX, startY, targetX, targetY);
openList.add(startNode);
while (!openList.isEmpty()) {
// 获取当前最优节点
Node currentNode = openList.poll();
// 如果到达目标节点，返回步数
if (currentNode.x == targetX && currentNode.y == targetY) {
return currentNode.g;
}
// 将当前节点加入关闭列表
closedList.add(currentNode);
// 遍历所有可能的移动
for (int[] move : MOVES) {
int newX = currentNode.x + move[0];
int newY = currentNode.y + move[1];
// 检查新位置是否有效
if (!isValid(newX, newY)) {
continue;
}
// 创建新节点
Node neighbor = new Node(newX, newY);
neighbor.g = currentNode.g + 1; // 每步代价为1
neighbor.h = heuristic(newX, newY, targetX, targetY);
neighbor.parent = currentNode;
// 如果已经在关闭列表中，跳过
if (closedList.contains(neighbor)) {
continue;
}
// 检查是否在开放列表中
boolean inOpenList = false;
for (Node node : openList) {
if (node.equals(neighbor)) {
inOpenList = true;
// 如果找到更优路径，更新节点
if (neighbor.g < node.g) {
node.g = neighbor.g;
node.parent = currentNode;
}
break;
}
}
// 如果不在开放列表中，加入
if (!inOpenList) {
openList.add(neighbor);
}
}
}
// 如果开放列表为空且未找到路径，返回-1
return -1;
}
// 启发式函数：曼哈顿距离除以3（骑士每步最多移动3格）
private static int heuristic(int x1, int y1, int x2, int y2) {
return (Math.abs(x1 - x2) + Math.abs(y1 - y2)) / 3;
}
// 检查坐标是否有效
private static boolean isValid(int x, int y) {
return x >= 1 && x <= 1000 && y >= 1 && y <= 1000;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int a1 = sc.nextInt();
int a2 = sc.nextInt();
int b1 = sc.nextInt();
int b2 = sc.nextInt();
int steps = aStarKnightPath(a1, a2, b1, b2);
System.out.println(steps);
}
}
}