CCF 交通规划

男娘i 2021-09-14 03:02 297阅读 0赞

## **一、试题** ##

问题描述  
　　G国国王来中国参观后，被中国的高速铁路深深的震撼，决定为自己的国家也建设一个高速铁路系统。  
　　建设高速铁路投入非常大，为了节约建设成本，G国国王决定不新建铁路，而是将已有的铁路改造成高速铁路。现在，请你为G国国王提供一个方案，将现有的一部分铁路改造成高速铁路，使得任何两个城市间都可以通过高速铁路到达，而且从所有城市乘坐高速铁路到首都的最短路程和原来一样长。请你告诉G国国王在这些条件下最少要改造多长的铁路。  
输入格式  
　　输入的第一行包含两个整数n, m，分别表示G国城市的数量和城市间铁路的数量。所有的城市由1到n编号，首都为1号。  
　　接下来m行，每行三个整数a, b, c，表示城市a和城市b之间有一条长度为c的双向铁路。这条铁路不会经过a和b以外的城市。  
输出格式  
　　输出一行，表示在满足条件的情况下最少要改造的铁路长度。  
样例输入  
4 5  
1 2 4  
1 3 5  
2 3 2  
2 4 3  
3 4 2  
样例输出  
11  
评测用例规模与约定  
　　对于20%的评测用例，1 ≤ n ≤ 10，1 ≤ m ≤ 50；  
　　对于50%的评测用例，1 ≤ n ≤ 100，1 ≤ m ≤ 5000；  
　　对于80%的评测用例，1 ≤ n ≤ 1000，1 ≤ m ≤ 50000；  
　　对于100%的评测用例，1 ≤ n ≤ 10000，1 ≤ m ≤ 100000，1 ≤ a, b ≤ n，1 ≤ c ≤ 1000。输入保证每个城市都可以通过铁路达到首都。

## **二、代码** ##

首先弄清题意“从所有城市乘坐高速铁路到首都的最短路程和原来一样长”和“最少要改造多长的铁路”。前者是[最短路径算法][Link 1]，后者是[最小生成树算法][Link 2]。这两个要求有主次关系，理解为“在从所有城市乘坐高速铁路到首都的最短路程和原来一样长的情况下最少要改造多长的铁路”。如果关系相反算法也不一样了。现在我们优先考虑最短路径，其次考虑最小生成树。那么如何将两个算法融合？  
1、首先选取最短路径的Dijkstra和最小生成树的Prim算法，因为二者算法思想同源，算法类似，只是在处理时因目标不同而选取方向不同。  
2、其次我们要明白最小生成树算法生成的最小代价路径从起点到目的地的长度只可能比最短路径算法从起点到目的地的最小长度大或者相等。因为最短路径的目的就是从起点到目的地的长度最小，而最小生成树目的是追求总体代价最小，有可能从起点到目的地的长度偏大。因此在我们优先考虑最短路径情况下，只有一种可能情况导致我们需要考虑最小代价。那就是当在最短路径情况下有多条路径都能产生最短路径，那么这时候我们就要考虑最小代价的那条路径。  
以下图为例：  
![这里写图片描述][SouthEast]  
我们从1节点开始，根据Dijkstra算法，首先选择3号节点，然后采用松弛技术计算后续节点最短路径，这时候我们发现从1-3-2这条路径长度为6，而直接从1-2这条路径长度也为6。两个代价最短路径同时为6我们选取哪一个呢？这时候我们考虑由于1和3节点已经被我们确定了其最短路径，在这个时候，在其基础上，我们选择1-3-2路径到2号节点只需要在原有代价上新增3个长度，而选择1-2路径到2号节点需要在原有代价上新增6个长度，考虑要最小化代价，肯定选择1-3-2路径。

#include<iostream>
    #include<vector>
    #include<queue>
    
    using namespace std;
    
    #define NMAX 10001
    #define INTMAX 0x7fffffff
    
    // grid记录路径，grid数组下标表示起点，Edge的to表示终点。用grid数组下标表示起点方便取特定节点起点路径遍历
    struct Edge{
        int to;
        int w;
        Edge(int a, int b):to(a),w(b){}
    };
    
    
    struct Node{
        int dot;
        int dis;
        Node(int a, int b):dot(a), dis(b){}
        friend bool operator< (Node l, Node r){   // 为了使用Priority_queue队列的小堆，用dis最短路径进行比较。此处如果用数组作下表dot排序的话对于关系会变化，也就是dot与dis无法对应，因此需将dot写入结构体
            return l.dis > r.dis;
        }
    };
    
    
    int n,m;
    int s,e,c;
    // grid记录路径，grid数组下标表示起点，Edge的to表示终点。用grid数组下标表示起点方便取特定节点起点路径遍历
    vector<Edge> grid[NMAX];
    // 记录是否已经确定其最短路径
    bool visit[NMAX];
    // distances记录从起始点到某点的最短路径
    // weight记录把某个节点并入已确定集的代价。因为我们是逐条比较最短路径的，在最短路径相同情况下，如果采用当前路径把某个节点并入已确定集需要的代价比采用旧的路径把某个节点并入已确定集的代价高，那我们就选择新的路径代价。
    int distances[NMAX],weight[NMAX];
    
    void dijkstra(){
        // 初始化时把所有最短路径置位无穷大。
        for(int i=1; i<=n; i++){
            distances[i] = weight[i] = INTMAX;
            visit[i] = false;
        }
        distances[1] = weight[1] = 0;
    
    
        // 用pq来储存下一步可能要取的节点的节点号和最小路径长度（为了排序）。
        priority_queue<Node> pq;
        pq.push(Node(1,0));
    
        while(!pq.empty()){
            Node chose = pq.top();
            pq.pop();
            int dot = chose.dot;
            // 此处不加判断是否已加入确定集也可以，在pq许多以同一to为节点的Node中肯定是最短路径的先被处理，由于前面已经处理一遍，后面再处理其他以to为节点的Node的已经没有意义，不会出现更小的路径，不过加上减小内存，也更好理解。
    // if(visit[dot]){ 
    // continue;
    // }
            // 从pq取出最小路径节点加入已确定集
            visit[dot] = true;
            int length = grid[dot].size();
            for(int i=0; i<length; i++){
                // 遍历提取以dot为起点的路径，如果已确定过就跳过。
                int to = grid[dot][i].to;
                // 此处不加判断是否已加入确定集也可以，因为to如果加入确定集，那么说明其最小路径已经找到，如果接下来继续计算，也不可能出现73行的dist<distances[to]情况，不过加上减小内存，也更好理解。
    // if(visit[to]){ 
    // continue;
    // }
                int w = grid[dot][i].w;
    
                // Dijkstra算法松弛技术：计算从dot到to这条路径代价是否比已有路径代价更小，如果更小则更新代价
                int dist = distances[dot] + w;
                if(dist<distances[to]){
                    distances[to] = dist;
                    // 此处记录路径较短时增加的代价
                    weight[to] = w;
                    pq.push(Node(to, dist));
                }
    
                if(dist == distances[to]){
                    // Prim算法：此处记录取选择新的路径和选择旧的路径增加的代价较小的代价
                    weight[to] = min(weight[to], w);
                }
    
            }
        }
    }
    
    int main(){
        cin>>n>>m;
        for(int i=0; i<m; i++){
            cin>>s>>e>>c;
            // 分别以两个结点作为起点
            grid[s].push_back(Edge(e,c));
            grid[e].push_back(Edge(s,c));
        }
        dijkstra();
    
        int total =0;
        // weight记录的是该节点连接到前一个节点需要的代价，其实也就是生成图所有路径的代价。
        for(int i=2; i<=n; i++){
            total += weight[i];
        }
        cout<<total;
        return 0;
    }

[Link 1]: http://blog.csdn.net/qq_16234613/article/details/52388890
[Link 2]: http://blog.csdn.net/qq_16234613/article/details/52349052
[SouthEast]: /images/20210520/f6630ba4e2f2449987753d0eaff832fb.png