题目描述
快递公司每日早晨，给每位快递员推送需要送到客户手中的快递以及路线信息，快递员自己又查找了一些客户与客户之间的路线距离信息，请你依据这些信息，给快递员设计一条最短路径，告诉他最短路径的距离。
注意：
- 不限制快递包裹送到客户手中的顺序，但必须保证都送到客户手中
- 用例保证一定存在投递站到每位客户之间的路线，但不保证客户与客户之间有路线，客户位置及投递站均允许多次经过
- 所有快递送完后，快递员需回到投递站
输入描述
首行输入两个正整数n、m
接下来 n 行，输入快递公司发布的客户快递信息，格式为：
客户id 投递站到客户之间的距离distance
再接下俩的 m 行，是快递员自行查找的客户与客户之间的距离信息，格式为
客户id1 客户id2 distance
在每行数据中，数据与数据之间均以单个空格分隔
规格：
- 0 < n ≤ 10
- 0 ≤ m ≤ 10
- 0 < 客户id ≤ 1000
- 0 < distance ≤ 10000
输出描述
最短路径距离，如无法找到，请输出-1
用例
| 输入 | 2 11 10002 12001 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 15 10009 120017 300132 700500 23005 9 400 |
| 输出 | 9200 |
| 说明 | 在所有可行的路径中，最短路径长度为 1000 + 400 + 1200 + 300 + 300 + 700 + 700 + 2300 + 2300 = 9200 |
#include <iostream>
#include <vector>
#include <map>
#include <climits>
#include <algorithm>
using namespace std;
const int INF = INT_MAX / 2; // 避免溢出
void solve() {
int n, m;
cin >> n >> m;
map<int, int> station_to_customer;
vector<int> customer_ids;
for (int i = 0; i < n; ++i) {
int customer_id, distance;
cin >> customer_id >> distance;
station_to_customer[customer_id] = distance;
customer_ids.push_back(customer_id);
}
// 所有节点：快递站（假设id为0）和客户
vector<int> nodes = {0};
for (int id : customer_ids) {
nodes.push_back(id);
}
map<int, int> node_index;
for (int i = 0; i < nodes.size(); ++i) {
node_index[nodes[i]] = i;
}
int size = nodes.size();
vector<vector<int>> dist(size, vector<int>(size, INF));
for (int i = 0; i < size; ++i) {
dist[i][i] = 0;
}
// 快递站到客户的直接距离
for (auto& [customer_id, d] : station_to_customer) {
int u = 0;
int v = node_index[customer_id];
dist[u][v] = d;
dist[v][u] = d; // 假设可以双向
}
// 客户之间的距离
for (int i = 0; i < m; ++i) {
int id1, id2, d;
cin >> id1 >> id2 >> d;
int u = node_index[id1];
int v = node_index[id2];
dist[u][v] = min(dist[u][v], d);
dist[v][u] = min(dist[v][u], d);
}
// Floyd-Warshall 计算所有节点对的最短路径
for (int k = 0; k < size; ++k) {
for (int i = 0; i < size; ++i) {
for (int j = 0; j < size; ++j) {
if (dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
// 检查所有客户之间是否可达
vector<int> customer_indices;
for (int id : customer_ids) {
customer_indices.push_back(node_index[id]);
}
for (int i : customer_indices) {
for (int j : customer_indices) {
if (dist[i][j] == INF) {
cout << -1 << endl;
return;
}
}
}
// TSP动态规划
int k = customer_indices.size();
vector<vector<int>> dp(1 << k, vector<int>(k, INF));
// 初始状态：从快递站直接到客户u
for (int u = 0; u < k; ++u) {
int original_u = customer_indices[u];
dp[1 << u][u] = dist[0][original_u];
}
// 遍历所有mask
for (int mask = 0; mask < (1 << k); ++mask) {
for (int u = 0; u < k; ++u) {
if (!(mask & (1 << u))) {
continue;
}
if (dp[mask][u] == INF) {
continue;
}
// 尝试访问未访问的v
for (int v = 0; v < k; ++v) {
if (mask & (1 << v)) {
continue;
}
int original_u = customer_indices[u];
int original_v = customer_indices[v];
int new_mask = mask | (1 << v);
if (dp[new_mask][v] > dp[mask][u] + dist[original_u][original_v]) {
dp[new_mask][v] = dp[mask][u] + dist[original_u][original_v];
}
}
}
}
// 最后需要从任意一个客户返回快递站
int full_mask = (1 << k) - 1;
int min_total = INF;
for (int u = 0; u < k; ++u) {
int original_u = customer_indices[u];
int total = dp[full_mask][u] + dist[original_u][0];
if (total < min_total) {
min_total = total;
}
}
cout << (min_total != INF ? min_total : -1) << endl;
}
int main() {
solve();
return 0;
}
