【代码随想录day58】【C++复健】 117. 软件构建（拓扑排序）；47. 参加科学大会（dijkstra（朴素版）精讲）

117. 软件构建（拓扑排序）

继续边看解析边做题，思考时的问题做个如下的总结：

1. 存边用什么数据结构？

在题目中，我们需要存储节点之间的依赖关系（边信息）。选择适合的数据结构非常重要：

• 选择 unordered_map<int, vector<int>>：
  • 这个结构的作用是将节点 int 映射到一个 vector<int>，即以 O(1) 的复杂度找到所有依赖当前节点的节点集合。
  • 在代码中，rela[left].push_back(right) 表示从节点 left 指向节点 right 的边。

这种结构方便快捷，是处理稀疏图的常见选择。如果用二维数组存储，虽然逻辑上也可以，但会浪费内存并导致效率下降。

2 队列是否需要初始化代码？

自己思考的时候感觉队列需要一个初始化代码，但是却想不明白能不能合到主循环的代码里面去。看了卡哥的解析之后发现了，并不能，所以无须担心。

3 循环逻辑问题（GPT优化版）

我在写这道题时，曾经因为对循环逻辑的处理不当导致代码变成了死循环。具体问题是，我把初始化代码直接搬到了主循环里，导致一些节点被重复插入队列。比如，节点 1 在初始化时已经被插入队列了，但后面又因为错误的逻辑反复地被插入队列，这显然是不正确的。

当时我的想法是，在节点进入队列后，把它对应的 indegree 值设置成 -1，这样能避免重复插入。但是后来忘记实现这一点，结果还是出现了问题。虽然这种方式能够解决问题，但仔细想想，其实有更简单的方法：只要在 indegree[tominus[i]]--; 这一步之后，立即判断节点的入度是否减到 0，如果是 0，就将它加入队列。

这样处理有两个明显的优点：

1. 避免重复插入节点： 减少入度操作的节点必然是与其他节点存在依赖关系的（即入度不为 0 的节点），只有在入度变为 0 时才会被加入队列，从逻辑上保证了节点最多只会入队一次。
2. 减少不必要的遍历： 在减少入度时直接判断是否需要入队，避免了每次操作后全量扫描所有节点，显著提高了代码效率。

最终通过这样的调整，不仅解决了死循环问题，还让代码的逻辑更加清晰，执行效率也更高。这种在操作中即时判断的优化思路，给我很大的启发。

#include<iostream>
#include<vector>
#include<queue>
#include<unordered_map>
using namespace std;

int main(){
    int n,m;
    cin >> n >> m;
    vector<int> indegree(n);
    vector<int> result;
    unordered_map<int, vector<int>> rela;
    for(int i=0; i<m; i++){
        int left, right;
        cin >> left >> right;
        indegree[right]++;
        rela[left].push_back(right);
    }
    queue<int> zerodegree;
    for(int i=0; i<n; i++){
        if(indegree[i] == 0){
            zerodegree.push(i);
        }
    }
    while(!zerodegree.empty()){
        int top = zerodegree.front();
        zerodegree.pop();
        result.push_back(top);
        vector<int> tominus = rela[top];
        for(int i=0; i<tominus.size(); i++){
            indegree[tominus[i]]--;
            if (indegree[tominus[i]] == 0) {
                zerodegree.push(tominus[i]);
            }
        }
    }
    if(result.size() == n){
        for(int i=0; i<n; i++){
            cout << result[i];
            if(i<n-1){
                cout << " ";
            }
        }
        return 0;
    }
    cout << -1;
}

47. 参加科学大会（dijkstra（朴素版）精讲）

虽然的确是第一次写最短路算法，也是边看着解析边做的，但确实感觉这个题和prim算法非常的像，只要稍微改一下更新的公式就行，自信就来了。

然后自己上手一写，一塌糊涂。

来看GPT给我分析的问题：

1. 未初始化输入的边信息

在读取边信息时，你直接将 distance[left][right] = val，但没有先读取 left 和 right，会导致程序读取未定义的值。

修正方法： 在读取边之前，添加 cin >> left >> right >> val：

for (int i = 0; i < m; i++) {
    int left, right, val;
    cin >> left >> right >> val; // 读取边信息
    distance[left][right] = val;
    distance[right][left] = val;
}

并且这里其实还有一个更严肃的问题，那就是这是一个有向图而非无向图，所以我不能给左右赋同样的值（因为这个，做不对还想了半天），不然会导致算出来的结果不对，所以正确的应该是：

for (int i = 0; i < m; i++) {
    int left, right, val;
    cin >> left >> right >> val; // 读取边信息
    distance[left][right] = val;
}

---

2. 忘了在计算距离最小值的判断力加入对visited数组的判断

在第一个循环中，你将 visited[1] 设置为 true，但后续并没有在循环中检查哪些节点已经被访问过，可能会导致重复访问，或者访问逻辑错误。

修正方法： 在主循环和内层循环中，增加对 visited 的判断：

if (!visited[j] && mindist[j] < dis_min) {

---

3. 访问越界问题

当所有节点都访问过后，pos 可能仍然是 -1，表示当前没有未访问的节点。这会导致接下来的代码逻辑失效，导致访问出现越界问题。

修正方法： 在找到最小 pos 后立即判断：

if (pos == -1) {
    break; // 无法找到更短的路径，直接退出
}

顺带一提，卡哥的做法是直接给pos赋值成1，这样即使是没找到，也不会导致访问越界。但这样做的坏处在于，卡哥的这种写法会让循环继续执行，但假设我们循环一整圈都没有找到比INT_MAX更小的距离，此时其实说明已经没边了，所以循环没有必要继续执行了，直接break掉还能省点事情。

脑子里的杠精：如果刚好有一个距离就等于INT_MAX，你这个判断不就失效了吗？

emm... 那如果是这样距离总和都超过INT能表示的范围了，不如放他一马。

---

4. 在更新距离时也忘了对visited数组的判断

if (!visited[k] && distance[pos][k] != INT_MAX) {
    mindist[k] = min(mindist[pos] + distance[pos][k], mindist[k]);
}

以上就是本期的全部内容了，喜欢不要忘了点个一键三连哦（串台）

#include<iostream>
#include<vector>
#include <climits>
using namespace std;

int main(){
    int n,m;
    cin >> n >> m;
    vector<vector<int>> distance(n+1, vector<int>(n+1, INT_MAX));
    for(int i=0; i<m; i++){
        int left, right, val;
        cin >> left >> right >> val;
        distance[left][right] = val;
        //distance[right][left] = val; //不能加，加了你就完了
    }
    vector<int> mindist(n+1, INT_MAX);
    vector<bool> visited(n+1);
    mindist[1] = 0;
    for(int i=1; i<=n; i++){
        int dis_min = INT_MAX;
        int pos = -1;
        for(int j=1; j<=n; j++){
            if(!visited[j] && mindist[j] < dis_min){
                dis_min = mindist[j];
                pos = j;
            }
        }
        if (pos == -1) {
            break; // 无法找到更短的路径，直接退出
        }
        visited[pos] = true;
        for(int k=1; k<=n; k++){
            if(!visited[k] && distance[pos][k] != INT_MAX){
                mindist[k] = min(mindist[pos] + distance[pos][k], mindist[k]);
            }
        }
    }
    if(mindist[n] == INT_MAX){
        cout << -1;
        return 0;
    }
    cout << mindist[n];
}