机试题——服务逃生

题目描述

小明需要在多个业务节点之间选择最快的逃生节点集，并考虑每个节点的剩余业务容量。业务节点之间的关系可以看作一个图。小明有一个网络时延表，表示每个节点到其他节点的通信延迟；还有一个剩余业务容量表，表示每个节点的剩余业务容量。在一个节点故障时，需要选择一个或多个逃生节点，确保逃生路径的时延最小，并且逃生节点集各节点剩余容量的总和足够容纳故障节点的业务量。当故障节点与多个节点的最短距离相同时，优先选择编号较小的节点容灾；如果逃生节点集中多个节点的最短距离相同时，按编号从小到大的顺序排列。

输入描述

1. 第一行：一个整数n，表示业务节点数（2 <= n <= 10000），节点编号从0开始，依次递增。
2. 第二行到第1+n行：表示业务节点间的网络时延矩阵表delayMatrix，其中delayMatrix[i][j]表示节点i到节点j的通信时延。
   • 如果节点i和节点j之间没有直接相连的边，则delayMatrix[i][j]为-1。
   • 节点间有边时延范围为1 <= delayMatrix[i][j] <= 1000。
   • 输入保证delayMatrix[i][j] == delayMatrix[j][i]。
3. 第2+n行：表示各业务节点的剩余容量表remainingCapacity，其中remainingCapacity[i]表示节点i的剩余业务容量（1 <= remainingCapacity[i] <= 100）。
4. 第3+n行：表示故障业务节点编号faultyNode，表示发生故障的节点（0 <= faultyNode <= n-1）。
5. 第4+n行：表示受损业务节点需要迁移的业务量，受损业务量的范围为(0, 1000]。

输出描述

返回符合条件的逃生路径节点编号列表，用空格分隔。当所有节点都不够故障节点业务容灾时，输出所有容灾节点。

用例输入

4
-1 5 -1 8
5 -1 1 3
-1 1 -1 4
8 3 4 -1
10 20 15 25
2
12

1

• 故障节点为2，需要迁移的业务量为12。
• 节点1的剩余容量为20，可以容纳故障节点的业务量，且距离最短（1），因此选择节点1作为逃生节点。

解题思路

1. 问题建模：

   • 该问题可以看作是一个最短路径问题，结合容量约束。
   • 使用Dijkstra算法计算故障节点到其他所有节点的最短路径。
   • 选择满足容量约束的节点作为逃生节点。

2. Dijkstra算法：

   • 使用优先队列（小顶堆）实现Dijkstra算法，计算故障节点到其他所有节点的最短路径。
   • 优先队列存储当前节点的最短路径和节点编号。

3. 选择逃生节点：

   • 按最短路径从小到大排序，优先选择编号较小的节点。
   • 累加选择的节点的剩余容量，直到满足故障节点的业务量需求。

4. 特殊情况：

   • 如果所有节点的剩余容量总和仍不足以容纳故障节点的业务量，则输出所有节点。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<map>
#include<algorithm>
#include<string>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<queue>
#include<set>
#include<list>
#include<sstream>
#include<bitset>
#include<stack>
#include<climits>
#include<iomanip>
#include<cstdint>
using namespace std;

int delay[10005][10005];
int capacity[10005];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;

    // 输入网络时延矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> delay[i][j];
        }
    }

    // 输入剩余容量表
    for (int i = 0; i < n; i++) {
        cin >> capacity[i];
    }

    // 输入故障节点编号和需要迁移的业务量
    int fault, ne;
    cin >> fault >> ne;

    // 初始化最短路径数组
    vector<int> dis(n, INT_MAX);
    dis[fault] = 0;

    // 使用优先队列实现Dijkstra算法
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
    q.push({0, fault});

    while (!q.empty()) {
        int cur_dis = q.top().first;
        int cur_index = q.top().second;
        q.pop();

        for (int i = 0; i < n; i++) {
            if (delay[cur_index][i] == -1) continue;
            int next_dis = cur_dis + delay[cur_index][i];
            if (next_dis < dis[i]) {
                dis[i] = next_dis;
                q.push({next_dis, i});
            }
        }
    }

    // 按最短路径从小到大排序
    vector<pair<int, int>> temp;
    for (int i = 0; i < n; i++) {
        if (dis[i] != INT_MAX && dis[i] != 0) {
            temp.push_back({dis[i], i});
        }
    }
    sort(temp.begin(), temp.end());

    // 选择逃生节点
    vector<int> res;
    for (int i = 0; i < temp.size(); i++) {
        ne -= capacity[temp[i].second];
        res.push_back(temp[i].second);
        if (ne <= 0) break;
    }

    // 输出结果
    for (int i = 0; i < res.size() - 1; i++) {
        cout << res[i] << " ";
    }
    cout << res[res.size() - 1];
    return 0;
}