CCF CSP——交通规划（201809-4） & 复习Dijkstra的两种实现

最新推荐文章于 2022-07-28 23:28:31 发布

哇吖吖

最新推荐文章于 2022-07-28 23:28:31 发布

阅读量409

点赞数

分类专栏： CCF CSP 文章标签：数据结构队列 dijkstra

本文链接：https://blog.csdn.net/qq_44408319/article/details/105935253

版权

CCF CSP 专栏收录该内容

57 篇文章 0 订阅

订阅专栏

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

样例输出

评测用例规模与约定
　　对于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。输入保证每个城市都可以通过铁路达到首都。

思路
增加一个cost[]数组
cost[i]用来记录最短路径情况下，把点 i 加入到集合S中的最短路径（最短的边长），也即从已处理的点到点 i 的最短距离。

Dijkstra算法中，集合S的含义
集合S：已经确定的顶点
集合T：尚未确定的顶点

我的代码：

#include <iostream>
#include <algorithm>//用于函数min
#include <vector> //用于图的邻接表存储
#include <queue> //用于优先队列
#include <climits>  //用于定义无穷大

using namespace std;

const int MAXN = 10000 + 10;//顶点数最多10000个（加上10个安全量）
const int INF = INT_MAX;  //定义无穷大为最大的整数

struct Edge{  //用于图邻接表存储的边的信息
    int to;  //该边的另外一端的顶点号
    int length; //该边的长度
    Edge(int t,int l):to(t),length(l){}//构造函数
};

struct Node{  //各节点的信息
    int number;//该节点的编号
    int distance;//源点到该节点的最短路径长度
    Node(){}
    Node(int n,int d):number(n),distance(d){}
    //由与点的信息要加入到优先队列中，故应设置各点大小关系
    bool operator<(const Node& point) const{//小于号重载
        return distance > point.distance;//距离大的优先级小
    }
};

vector<Edge> graph[MAXN];//图的邻接表存储
int cost[MAXN];//最短路径前提下，从已处理的点到该点的最短距离
int dist[MAXN];//从源点（首都1）到各点的最短路径
bool visit[MAXN];//标记各个点是否被访问过

void Dijkstra(int start,int n){//Dijkstra算法
    fill(dist,dist+n+1,INF);//将所有最短路径初始化为无穷大
    fill(visit,visit+n+1,false);//将所有点标记为未访问过
    fill(cost,cost+n+1,INF);//将所有点到已有集合的最短距离初始化为INF
    dist[start] = 0;//修改源点的信息
    cost[start] = 0;
    priority_queue<Node>que;
    que.push(Node(1,0));//将源点（首都1）加入到优先队列中
    Node front;
    while(!que.empty()){
        front = que.top();
        que.pop();
        int current = front.number;//current记录对头结点的编号
        if(!visit[current]){//若current没有被访问过
            visit[current] = true;//将其标记为已访问过
            //进行松弛操作，更新与该点相邻的所有点的信息
            for(int i=0;i<graph[current].size();i++){
                //获取current的邻接点now
                int now = graph[current][i].to;
                if(visit[now]){//若该点已被访问过，则处理下一个邻接点
                    continue;
                }
                //记录下current到now的距离
                int spend = graph[current][i].length;
                if(dist[now] > spend + dist[current]){
                    dist[now] = spend + dist[current];
                    cost[now] = spend;
                    //若该点的信息被更新，则加入到优先队列中
                    //一个点可能被添加多次，但通过visit数组
                    //可以保证其只被访问过一次（距离最短的那次）
                    que.push(Node(now,dist[now]));
                }else if(dist[now] == spend + dist[current]){
                    cost[now] = min(cost[now],spend);//若相等，取小
                }
            }
        }
    }
}

int main(){
    int n,m,a,b,c;
    cin>>n>>m;
    for(int i=0;i<m;i++){
        cin>>a>>b>>c;
        graph[a].push_back(Edge(b,c));//无向图
        graph[b].push_back(Edge(a,c));
    }
    Dijkstra(1,n);//传入首都的位置 城市的个数
    int answer = 0;
    for(int i=1;i<=n;i++){//cost[]中各值的和即为答案
        answer += cost[i];
    }
    cout<<answer;
    return 0;
}

知识点复习：
Dijkstra算法的两种实现方式（求点start到点terminal的最短距离）。
优先队列实现

#include <iostream>
#include <queue>
#include <climits>
#include <vector>
#include <algorithm>

using namespace std;

const int MAXN = 10000;
const int INF = INT_MAX;

struct Edge{
    int to;
    int length;
    Edge(int t,int l):to(t),length(l){}
};

struct Node{
    int number;
    int distance;
    Node(){}
    Node(int n,int d):number(n),distance(d){}
    bool operator<(const Node& point) const{
        return distance > point.distance;
    }
};

bool visit[MAXN];
int dist[MAXN];
vector<Edge> graph[MAXN];

void Dijkstra(int start,int n){
    fill(dist,dist+n,INF);
    dist[start] = 0;
    priority_queue<Node>que;
    que.push(Node(start,dist[start]));
    while(!que.empty()){
        int current = que.top().number;
        que.pop();
        for(int i=0;i<graph[current].size();i++){
            int target = graph[current][i].to;
            int distance = graph[current][i].length;
            if(dist[target] < dist[current] + distance){
                dist[target] = dist[current] + distance;
                que.push(Node(target,dist[target]));
            }
        }
    }
}

int main(){
    int n,m,from,to,length,start,terminal;
    cin>>n>>m;
    for(int i=0;i<m;i++){
        cin>>from>>to>>length;
        graph[from].push_back(Edge(to,length));
        graph[to].push_back(Edge(from,length));
    }
    cin>>start>>terminal;
    Dijkstra(start,n);
    if(dist[terminal]==INF){
        cout<<"-1";
    }else{
        cout<<dist[terminal];
    }
    return 0;
}

普通实现

#include <iostream>
#include <queue>
#include <climits>
#include <vector>
#include <algorithm>

using namespace std;

const int MAXN = 10000;
const int INF = INT_MAX;

struct Edge{
    int to;
    int length;
    Edge(int t,int l):to(t),length(l){}
};

bool visit[MAXN];
int dist[MAXN];
vector<Edge> graph[MAXN];

void Dijkstra(int start,int n){
    fill(dist,dist+n,INF);
    fill(visit,visit+n,false);
    dist[start] = 0;
    for(int i=0;i<n;i++){
        int target = -1;
        for(int i=0;i<n;i++){
            if(visit[target]){
                continue;
            }
            if(target==-1 || dist[i]<dist[target]){
                target = i;
            }
        }
        for(int j=0;i<graph[target].size();j++){
            int current = graph[target][j].to;
            int distance = graph[target][i].length;
            if(dist[target] > dist[current] + distance){
                dist[target] = dist[current] + distance;
            }
            visit[target] = true;
        }
    }

}

int main(){
    int n,m,from,to,length,start,terminal;
    cin>>n>>m;
    for(int i=0;i<m;i++){
        cin>>from>>to>>length;
        graph[from].push_back(Edge(to,length));
        graph[to].push_back(Edge(from,length));
    }
    cin>>start>>terminal;
    Dijkstra(start,n);
    if(dist[terminal]==INF){
        cout<<"-1";
    }else{
        cout<<dist[terminal];
    }
    return 0;
}

哇吖吖

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
CCF CSP——交通规划（201809-4） & 复习Dijkstra的两种实现

问题描述　　G国国王来中国参观后，被中国的高速铁路深深的震撼，决定为自己的国家也建设一个高速铁路系统。　　建设高速铁路投入非常大，为了节约建设成本，G国国王决定不新建铁路，而是将已有的铁路改造成高速铁路。现在，请你为G国国王提供一个方案，将现有的一部分铁路改造成高速铁路，使得任何两个城市间都可以通过高速铁路到达，而且从所有城市乘坐高速铁路到首都的最短路程和原来一样长。请你告诉G国国王在这些条件...
复制链接

扫一扫

专栏目录