ICPC（路）（迪杰斯特拉 + 路径存取）

问题 F: 路

时间限制: 1 Sec  内存限制: 128 MB
提交: 236  解决: 59
[提交] [状态] [命题人:admin]

题目描述

Farmer John 热衷于散步，每天早上他都要从 1 号仓库走到 n 号仓库。 Farmer John 家的 n 个仓库被 m 条双向道路连通起来，每条道路有一个长度 w。而Farmer John 又不喜欢走路，所以他走的是从 1 号仓库到 n 号仓库的最短路。
但是 Farmer 的奶牛们总想搞点事情，他们计划着把 m 条道路的其中一条变成原来长度的 2 倍，使得 Farmer John 可能会多走一点路。
他们想知道，最多能让 Farmer John 多走多少路呢？

 

输入

第一行一个正整数 n,m，表示仓库个数和道路条数。
接下来 m 行，每行三个正整数，表示每条双向道路的连接的仓库和该双向道路的长度。

 

输出

输出只有一行，表示最多能让 Farmer John 每天早上多走多少路。

 

样例输入

5 7
2 1 5
1 3 1
3 2 8
3 5 7
3 4 3
2 4 7
4 5 2

样例输出

2

 

提示

一开始的最短路为1→3→4→5，长度为1+3+2=6。
将连接3和4的边变为原来的两倍，3×2=6。
改造后的图，最短路为1→3→5，长度为1+7=8。
多走了8−6=2的路程，可以证明这是最大的答案。
对于50%的数据，1≤n≤50。
对于100%的数据，1≤n≤250，1≤m≤25000，1≤w≤106。
保证没有重边。

个人理解

先用迪杰斯特拉找到最短路，然后枚举最短路中的每一条路进行*2，并持续进行迪杰斯特拉算最短路，找到差距最大的。

由于点的数量比较少，导致最短路径中边的数量也比较少，因此可以枚举。

#include <iostream>
#include <cstring>
#include <stack>
using namespace std;
#define MAX 300
#define INF 0x3f3f3f3f
int dist[MAX], path[MAX];
int pp[MAX],temp;
struct MGraph
{
    int edges[MAX][MAX];//邻接矩阵，记录的是两点之间的距离，也就是权值 
    int n,e;//顶点数和边数
}G;
void init() {
    memset(G.edges, INF, sizeof(G.edges));
}
void insert(int u, int v, int w) {
    G.edges[u][v]=G.edges[v][u]= w;
}
void printfPath(int path[], int a){
    stack<int> s;
    int f=0,ll,_MAX=-1,ss,tt;
    while(path[a] != -1){
        s.push(a);
        a = path[a];
    } 
    s.push(a);
    while(!s.empty())
    {
    	pp[temp++]=s.top();
        s.pop();
    }
} 
void Dijkstra(MGraph g, int v, int dist[], int path[]){ //顶点默认从0到n 
    int set[MAX], min, i, j, u;
    //对各个数组进行初始化
    for(i = 1; i <= g.n; i++){
        dist[i] = g.edges[v][i];
        set[i] = 0;
        if(g.edges[v][i] < INF){
            path[i] = v;
        }else{
            path[i] = -1;
        }
    } 
    set[v] = 1; 
    path[v] = -1;
    //初始化结束，关键操作开始
    for(i = 1; i <= g.n - 1; i++)
    {
        min = INF;//找到的点   目前最小 
        //这个循环每次从剩余顶点中选出一个顶点，通往这个顶点的路径在通往所有剩余顶点的路径中是长度最短的
        for(j = 1; j <= g.n; j++){
            if(set[j] == 0 && dist[j] < min){
                u = j;
                min = dist[j];
            }
        } 
        set[u] = 1;//将选出的顶点并入最短路径中
        //这个循环以刚并入的顶点作为中间点，对所有通往剩余顶点的路径进行检测
        for(j = 1; j <= g.n; j++) {
            //这个if判断顶点u的加入是否会出现通往顶点j的更短的路径，如果出现，则改变原来路径及其长度，否则什么都不做
            if(set[j] == 0 && dist[u] + g.edges[u][j] < dist[j]){
                dist[j] = dist[u] + g.edges[u][j];//更新路径长度 
                path[j] = u;//更新路径顶点 
            } 
        } 
    } 
}
int main() {
    init();
    int n, m;//n个点，m条边
    int a, x, y, w;
    cin >> n >> m;
    G.e = m;
    G.n = n;
 
    for(int i = 0; i < m; i++){
        cin >> x >> y >> w;
        insert(x, y, w);
    }
    Dijkstra(G, 1, dist, path);
    int ll=dist[n],Max=-1;
    printfPath(path, n);
    for(int i=1;i<temp;i++)
    {
    	G.edges[pp[i-1]][pp[i]]=G.edges[pp[i-1]][pp[i]]*=2;
    	Dijkstra(G,1,dist,path);
    	Max=max(Max,dist[n]-ll);
    	G.edges[pp[i-1]][pp[i]]=G.edges[pp[i-1]][pp[i]]/=2;
	}
    cout<<Max<<endl;
    return 0;
}