PAT（甲级）1030 Travel Plan (30point(s))

题目

题目链接

思路

题目大意: 在保证距离最短的情况下使其花费尽可能小；
可以用Dijktras + DFS做，也可以直接用Dijktras算法做，前者根据第一标尺距离最短把每个节点的前驱全部存储下来，然后用DFS选一条花费最小的；后者只存储每个元素的一个前驱，所以在第一标尺距离相等的情况下，需要判断第二标尺花费是不是会进行优化，进而修改前驱节点；

代码

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
using namespace std;
const int maxn = 510;
const int inf = 1e9;
//G存储距离，cost存储花费， d[]存储到初始节点的距离，minCost全局最小的花费
int G[maxn][maxn], cost[maxn][maxn];
int n, m, st, ed, d[maxn], minCost = inf;
bool vis[maxn] = {false};
//pre数组存储最短路径上每个节点的前驱
vector<vector<int>> pre(maxn);
vector<int> tempPath, path;

void Dijktras(int s){
     fill(d, d + maxn, inf);
     d[s] = 0;
     for(int  i = 0; i < n; i ++){
          int u = -1, minn = inf;
          for(int j = 0; j < n; j ++ ){
               if(d[j] < minn && vis[j] == false){
                    u = j;
                    minn = d[j];
               }
          }
          if(u == -1) return;
          vis[u] = true;
          for(int v = 0; v < n; v ++){
               if(G[u][v] != inf && vis[v] == false){
                    //如果出现了更短的距离，这个节点的前驱数组需要清空在压入
                    if(d[u] + G[u][v] < d[v]){
                         d[v] = d[u] + G[u][v];
                         pre[v].clear();
                         pre[v].push_back(u);
                    }
               //否则直接压入即可，说明存在多个前驱节点
                    else if(d[u] + G[u][v] == d[v]){
                         pre[v].push_back(u);
                    }
               }
          }
     }
}
//进行DFS，找出所有的最短路径
void DFS(int e){
     //如果是起始点，说明已经找到一条最短路径，判断花费是不是最小
     if(e == st){
          //将起始点压入
          tempPath.push_back(st);
          int temp = 0;
          for(int i = tempPath.size() - 1; i > 0; i--){
               temp += cost[tempPath[i]][tempPath[i - 1]];
          }
          if(temp < minCost){
                minCost = temp;
                path = tempPath;
          }
          //将起始点弹出
          tempPath.pop_back();
          return;
     }
     //如果不是起始点，将这个点压入
     tempPath.push_back(e);
     for(int i = 0; i < pre[e].size(); i ++){
          DFS(pre[e][i]);
     }
     //将这个点弹出
     tempPath.pop_back();
}
int main(){
     scanf("%d%d%d%d", &n, &m, &st, &ed);
     fill(G[0], G[0] + maxn * maxn, inf);
     fill(cost[0], cost[0] + maxn * maxn, inf);
     int s, e, dis, c;
     for(int i = 0; i < m; i ++){
          scanf("%d%d%d%d", &s, &e, &dis, &c);
          G[s][e] = G[e][s] = dis;
          cost[s][e] = cost[e][s] = c;
     }
     Dijktras(st);
     DFS(ed);
     //逆序打印最优路径上的节点
     for(int i = path.size() - 1; i >= 0; i --){
          printf("%d ", path[i]);
     }
     printf("%d %d\n", d[ed], minCost);
     //system("pause");
     return 0;
}