Dijkstra算法进阶

Dijkstra算法

题目中可能有两条或者以上可以达到最短距离的路径，题目中会给一个第二标尺（第一标尺是距离），要求在所有最短路径中寻找第二标尺最优的路径。常见的第二标尺：
（1）给每条边在增加一个边权（比如说花费），然后要求在最短路径有多条时，要求路径的花费之和最小（如果边权是其他含义，那么也可以是最大）
（2）给每个顶点增加一个点权（例如每个曾是能收集到的物资），然后在最短路径有多条时，要求路径上结点的权值之和最大（最小）
（3）直接问有多少条最短路径

1、新增边权

cost[u][v]表示u->v的花费（由题目输入），并增加一个数组c[]，令起点s到顶点u的最小花费是c[u]，初始化时c[s] = 0，其余的c[i] = INF
（和dist[]、G[][]数组的含义类似）

for(int v = 0; v < n; v++){
	if (!visited[v] && G[u][v] != INF){
		if (dist[u] + G[u][v] < dist[v]){
			dist[v] = dist[u] + G[u][v];
			c[v] = c[u] + cost[u][v];
		}else if (dist[u] + G[u][v] == dist[v] && c[u] + cost[u][v] < c[v]){
		//虽然经过u和不经过u的最短距离是一样的，但经过u的路径花费更小
			c[v] = c[u] + cost[u][v];
		}
	}
}

2、新增点权

weight[]数组来存储各个顶点之间的点权，weight[i]表示第i个顶点的点权，w[]用来存储从起点s出发到达顶点u的路径上结点的权值之和（初始化时w[s] = weight[s]，其余的w[i]均为0）

for (int v = 0; v < n; v++){
	if (!visited[v] && G[u][v] != INF){
		if (dist[u] + G[u][v] < dist[v]){
			dist[v] = dist[u] + G[u][v];
			w[v] = w[u] + weight[v];
		}else if (dist[u] + G[u][v] == dist[v] && w[u] + weight[v] > w[v]){
			w[v] = w[u] + weight[v];
		}
	}
}

3、最短路径数

nums[]用来存储到结点i的最短路径的条数，初始化时nums[s] = 1（起点到自身的距离是1）,其他的nums[i] = 0

for (int v = 0; v < n; v++){
    if (!visited[v] && G[u][v] != INF){
        if (dist[u] + G[u][v] < dist[v]){
            dist[v] = dist[u] + G[u][v];
            nums[v] = nums[v];
        }else if (dist[u] + G[u][v] == dist[v]){
            nums[v] += nums[u]; 
        }
    }
}

1003 Emergency (25 分)

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510, INF = 0x3f3f3f3f;
int n, m, s, t;
int G[N][N], dist[N], weight[N], w[N], nums[N];
bool visited[N] = {false};
//G[u][v]存储u->v之间的边权，dist[i]表示s->i的最短距离，weight[i]表示顶点i的权值；
//w[i]表示起点s到i的最短路径上结点的权值之和，nums[i]表示起点s->i的最短路径的条数，visited[i]用来标记顶点i是否被访问过

void Dijkstra(int s){
    memset(dist, 0x3f, sizeof dist);//对应的数组进行初始化
    memset(nums, 0, sizeof nums);
    memset(w, 0, sizeof w);
    dist[s] = 0, nums[s] = 1, w[s] = weight[s];//起点到自身的距离是0、路径数是1、路径上的结点权值是weight[s]
    for (int i = 0; i < n; i++){
        int u = -1, MIN = INF;
        for (int j = 0; j < n; j++){
            if (!visited[j] && dist[j] < MIN){
                u = j;
                MIN = dist[j];
            }
        }
        if (u == -1)    return ;
        visited[u] = true;
        for (int v = 0; v < n; v++){
            if (!visited[v] && G[u][v] != INF){//v是u相邻的顶点并且v还未被放问过
                if (dist[u] + G[u][v] < dist[v]){//第一标尺：路径
                    dist[v] = dist[u] + G[u][v];
                    nums[v] = nums[u];
                    w[v] = w[u] + weight[v];
                }else if (dist[u] + G[u][v] == dist[v]){//经过u到达v的路径相等时
                    nums[v] += nums[u]; //最短路径数nums[v] += nums[u]
                    if (w[u] + weight[v] > w[v])//经过u到达v路径上结点的权值更大
                        w[v] = w[u] + weight[v];
                }
            }
        }
    }
}

int main(){
    cin>>n>>m>>s>>t;
    memset(G, 0x3f, sizeof G);//记得将G初始化
    for (int i = 0; i < n; i++) cin>>weight[i];
    for (int i = 0; i < m; i++){
        int x, y, z;
        cin>>x>>y>>z;
        G[x][y] = G[y][x] = z;
    }
    Dijkstra(s);
    cout<<nums[t]<<" "<<w[t]<<endl;
    return 0;
}

1030 Travel Plan (30 分)

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int N = 510, INF = 0x3f3f3f3f;
int n, m, s, t;
int G[N][N], dist[N], cost[N][N], c[N], last[N];
bool visited[N] = {false};
//G[u][v]存储u->v之间的边权，dist[i]表示s->i的最短距离，cost[u][v]表示顶点u到顶点v的花费；
//c[i]表示起点s到i的最短路径上结点的花费，last[i]表示最短路径上i的上一个结点，visited[i]用来标记顶点i是否被访问过

void Dijkstra(int s){
    memset(dist, 0x3f, sizeof dist);//对应的数组进行初始化
    memset(c, 0x3f, sizeof c);
    memset(last, -1, sizeof last);
    dist[s] = 0, c[s] = 0;//起点到自身的距离是0、花费是0
    for (int i = 0; i < n; i++){
        int u = -1, MIN = INF;
        for (int j = 0; j < n; j++){
            if (!visited[j] && dist[j] < MIN){
                u = j;
                MIN = dist[j];
            }
        }
        if (u == -1)    return ;
        visited[u] = true;
        for (int v = 0; v < n; v++){
            if (!visited[v] && G[u][v] != INF){//v是u相邻的顶点并且v还未被放问过
                if (dist[u] + G[u][v] < dist[v]){//第一标尺：路径
                    dist[v] = dist[u] + G[u][v];
                    c[v] = c[u] + cost[u][v];
                    last[v] = u;    //v的上一个结点是u
                }else if (dist[u] + G[u][v] == dist[v]){//经过u到达v的路径相等时
                    if (c[u] + cost[u][v] < c[v]){//经过u到达v路径上结点的权值更大
                        c[v] = c[u] + cost[u][v];
                        last[v] = u;
                    }
                }
            }
        }
    }
}

int main(){
    cin>>n>>m>>s>>t;
    int temp = t;
    memset(G, 0x3f, sizeof G);//记得将G初始化
    memset(cost, 0x3f, sizeof cost);
    for (int i = 0; i < m; i++){
        int x, y, z, b;
        cin>>x>>y>>z>>b;
        G[x][y] = G[y][x] = z;
        cost[x][y] = cost[y][x] = b;
    }
    Dijkstra(s);
    vector<int> path;
    while(t != -1){
        path.push_back(t);
        t = last[t];
    }
    t = temp;
    for (int i = path.size()-1; i >= 0; i--)    cout<<path[i]<<" ";
    cout<<dist[t]<<" "<<c[t]<<endl;
    return 0;
}