uva 1416 - Warfare And Logistics（dijkstra）

The army of United Nations launched a new wave of air strikes on terrorist forces. The objective of the mission is to reduce enemy's logistical mobility. Each air strike will destroy a path and therefore increase the shipping cost of the shortest path between two enemy locations. The maximal damage is always desirable.

Let's assume that there are n enemy locations connected bym bidirectional paths, each with specific shipping cost. Enemy's total shipping cost is given asc = path(i,j) . Here path(i, j) is the shortest path between locationsi and j . In casei and j are not connected,path(i, j) = L . Each air strike can only destroy one path. The total shipping cost after the strike is noted asc' . In order to maximized the damage to the enemy, UN's air force try to find the maximalc' - c .

Input

The first line ofeach input case consists ofthree integers: n , m , and L . 1 < n100 ,1m1000 , 1L108 . Each ofthe following m lines contains three integers:a , b , s , indicating length of the path between a andb .

Output

For each case, output the total shipping cost before the air strike and the maximal total shipping cost after the strike. Output them in one line separated by a space.

Sample Input

4  6  1000
1  3  2
1  4  4
2  1  3
2  3  3
3  4  1
4  2  2

Sample Output

28  38

这题过的真艰辛！从昨晚搞到现在，最后写个数据生成程序+别人ac的代码，生成了点数据才发现错在哪儿了
本题关键就是记录下每条边是属于哪些棵生成树，然后删边后重新计算相应的变化。
但是，如果开始时就没有一颗最短路的生成树（即图不连通），那我们就需要特别注意了（我就是wa在这个地方被搞死了啊）
开始时还犯了个sb错误，把边的最大数目搞错了（导致数组开小，无限re）
因为是无向图，所以用模版加边时每条边加了两次，所以最后总边数是乘以2了的
还有如果数据给出了一条类似a->a的边，输入应该直接跳过

关于这道题还有一个拓展：
假如这道题改为如果之后输入m条边，要求计算添加了某条边的最小值。
当然还是可以用本题的方法去做，但实际上面对这个问题还有一个更好的方法。
如果你深入理解了floyed这个动态规划的算法，在面对这个题其实也是可以应用的。
也是抓住影响的只有与改变的那条边相关的最短路。
首先Floyd求出任意两点间的最短距离，之后关键是每更新一条边该如何维护这些最短距离。
假设用floyd求出来后的答案存在矩阵map[n][n]里，对于每次更新(a[i][j]=k)，如果a[i][j]>=map[i][j]，则不用更新；
否则，对于map[x][y]，需要更新的只有两种情况，一种是从x->i->j->y，另一种是x->j->i->y，选出这两种的最小的与当前的map[x][y]比较即可。
因此只需要枚举x，y，然后更新map[x][y]，总复杂度为O(n^3+m*n^2)，比用dijkstra要好一些

floyed不能用在本题的原因是，原来的边被删掉，而导致边长变大，这样是无法处理的。

代码如下：

 

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
typedef long long LL;
const int maxn = 100 + 5;
const int INF = 1000000000;

struct Edge{
    int from,to;
    LL dist;
    int tag;//XiuGai
};

struct Heapnode{//优先队列的结点
    int d,u;
    bool operator < (const Heapnode& rhs) const{
        return d > rhs.d;
    }
};

struct Dijkstra{
    int n,m;//点数和边数
    vector<Edge> edges;//边列表
    vector<int> G[maxn];//每个节点出发的边编号（从0开始）
    bool done[maxn];//是否已永久编号
    int d[maxn];//s到各个点的距离
    int p[maxn];//最短路中的上一条边
    vector<int> mark[2005];
    LL l;

    void init(int n,LL l){
        this->n = n;
        for(int i = 0;i < n;i++) G[i].clear();//清空邻接表
        edges.clear();//清空边表

        for(int i = 0;i < 1005;i++) mark[i].clear();
        for(int i = 0;i < maxn;i++) p[i] = -1;
        this->l = l;
    }

    void AddEdge(int from,int to,LL dist,int tag){
        //如果是无向图，每条无向边需调用两次AddEdge
        edges.push_back((Edge){from,to,dist,tag});
        m = edges.size();
        G[from].push_back(m-1);//(m-1)因为边从0开始编号
    }

    LL dijkstra(int s){//求s到所有点的距离
        priority_queue<Heapnode> Q;
        for(int i = 0;i < n;i++)    d[i] = INF;
        d[s] = 0;
        memset(done,0,sizeof(done));
        Q.push((Heapnode){0,s});
        while(!Q.empty()){
            Heapnode x = Q.top();Q.pop();
            int u = x.u;
            if(done[u]) continue;
            done[u] = true;
            for(int i = 0;i < G[u].size();i++){
                Edge& e = edges[G[u][i]];
                if(e.tag == 0) continue;//XiuGai
                if(d[e.to] > d[u] + e.dist){
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = G[u][i];//记录下到节点的那条边，方便回溯
                    Q.push((Heapnode){d[e.to],e.to});
                }
            }
        }

        LL ret = 0;
        for(int i = 0;i < n;i++){
            if(i == s)  continue;
            if(d[i] == INF) ret += l;
            else ret += d[i];
        }
        return ret;
    }

    void track(int s){
        for(int i = 0;i < n;i++){
            if(i == s)  continue;
            if(p[i] == -1)  continue;
            mark[p[i]].push_back(s);
        }
    }

    void fuckedge(int n){
        edges[n].tag = 0;
        if(edges[n].from == edges[n+1].to && edges[n].dist == edges[n+1].dist && edges[n].to == edges[n+1].from)
            edges[n+1].tag = 0;
        else
            edges[n-1].tag = 0;
    }

    void recover(int n){
        edges[n].tag = 1;
        if(edges[n].from == edges[n+1].to && edges[n].dist == edges[n+1].dist && edges[n].to == edges[n+1].from)
            edges[n+1].tag = 1;
        else
            edges[n-1].tag = 1;
    }
};

Dijkstra solver;
LL ans[maxn];
LL c,c2;

int main(){
    //freopen("a","r",stdin);
    //freopen("A1","w",stdout);
    int n,m,l;
    int a,b,s;

    while(scanf("%d%d%d",&n,&m,&l) != EOF){
        solver.init(n,l);
        c = 0;
        while(m--){
            scanf("%d%d%d",&a,&b,&s);a--;b--;
            if(a == b)  continue;
            solver.AddEdge(a,b,s,1);solver.AddEdge(b,a,s,1);
        }
        for(int i = 0;i < n;i++){
            c += ans[i] = solver.dijkstra(i);
            solver.track(i);
        }
        c2 = c;LL tem;
        for(int i = 0;i < solver.edges.size();i++){
            solver.fuckedge(i);
            if(i%2==0) tem = c;
            for(int j = 0;j < solver.mark[i].size();j++){
                tem -= ans[solver.mark[i][j]];
                tem += solver.dijkstra(solver.mark[i][j]);
            }
            solver.recover(i);
            c2 = max(c2,tem);
        }
        printf("%lld %lld\n",c,c2);
    }
    return 0;
}

生成数据

#include <cstdio>
#include <cstdlib>
#include <time.h>

int main(){
    srand((int)time(NULL));
    freopen("a","w",stdout);
    for(int i = 0;i < 5;i++){
        int n,m;
        printf("%d %d %d\n",n = rand()%5+2,m = rand()%10+1,rand()%1000000);
        while(m--){
            printf("%d %d %d\n",rand()%n+1,rand()%n+1,rand()%10000);
        }
        printf("\n\n");
    }
    return 0;
}