华为OD机试真题2024版 - 求幸存数之和

华为 OD 机试：快递员的烦恼
题目描述
快递公司每日早晨，给每位快递员推送需要送到客户手中的快递以及路线信息，快递员自己又查找了一些客户与客户之间的路线距离信息，请你依据这些信息，给快递员设计一条最短路径，告诉他最短路径的距离。

注意：

不限制快递包裹送到客户手中的顺序，但必须保证都送到客户手中；
用例保证一定存在投递站到每位客户之间的路线，但不保证客户与客户之间有路线，客户位置及投递站均允许多次经过；
所有快递送完后，快递员需回到投递站。
输入描述
首行输入两个正整数 n，m
接下来 n 行，输入快递公司发布的客户快递信息，格式为：客户 id 投递站到客户之间的距离 distance
再接下来的 m 行，是快递员自行查找的客户与客户之间的距离信息，格式为：客户 1 id 客户 2 id distance
在每行数据中，数据与数据之间均以单个空格分割

规格：
0 < n <= 10
0 <= m <= 10
0 < 客户 id <= 1000
0 < distance <= 10000

输出描述
最短路径距离，如无法找到，请输出-1

示例一
输入

2 1
1 1000
2 1200
1 2 300

2500

说明
路径 1：
快递员先把快递送到客户 1 手中，接下来直接走客户 1 到客户 2 之间的直通线路，最后走投递站和客户 2 之间的路，回到投递站，距离为 1000 + 300 + 1200 =2500
路径 2：
快递员先把快递送到客户 1 手中，接下来回到快递站，再出发把客户 2 的快递送过去，再回到投递站，距离为 1000 + 1000 + 1200 + 1200 = 4400
路径 3：
快递员先把快递送到客户 2 手中，接下来直接走客户 2 到客户 1 之间的直通线路，最后走投递站和客户 1 之间的路，回到投递站，距离为 1200 + 300 + 1000 =2500
其他路径……

所有路径中，最短路径距离为 2500

示例二
输入

5  1
5 1000
9 1200
17 300
132 700
500 2300
5 9 400
1
2
3
4
5
6
7

输出

9200
1

说明
在所有可行的路径中，最短路径长度为 1000 + 400 + 1200 + 300 + 300 + 700 + 700 + 2300 + 2300 = 9200OD 统一题解

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();

        Integer[][] distances = new Integer[n + 1][n + 1];
        Map<Integer, Integer> mapping = new HashMap<>();

        for (int i = 1; i <= n; i++) {
            int uid = scanner.nextInt();
            int d = scanner.nextInt();
            mapping.put(uid, i);
            distances[0][i] = distances[i][0] = d;
        }

        for (int i = 0; i < m; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            int d = scanner.nextInt();
            x = mapping.get(x);
            y = mapping.get(y);
            distances[x][y] = distances[y][x] = d;
        }

        Integer[][] f = new Integer[1 << n][n + 1];
        Queue<int[]> q = new LinkedList<>();
        q.add(new int[] {0, 0, 0});
        f[0][0] = 0;

        while (!q.isEmpty()) {
            int[] state = q.poll();
            int nowState = state[0];
            int now = state[1];
            int nowD = state[2];
            for (int nxt = 0; nxt <= n; nxt++) {
                if (nxt != now && distances[now][nxt] != null) {
                    int nextState;
                    if (nxt == 0) {
                        nextState = nowState;
                    } else {
                        nextState = nowState | (1 << (nxt - 1));
                    }
                    if (f[nextState][nxt] == null ||
                            f[nextState][nxt] > f[nowState][now] + distances[now][nxt]) {
                        f[nextState][nxt] = f[nowState][now] + distances[now][nxt];
                        q.add(new int[] {nextState, nxt, f[nextState][nxt]});
                    }
                }
            }
        }

        System.out.println(f[(1 << n) - 1][0]);
    }
}