Codeforces 843D (Dijkstra算法的优化，动态最短路)

(http://codeforces.com/problemset/problem/843/D)
题目大意：
给定一张带权无向图，有q次操作
操作有两种
1 v 询问1到v的最短路
2 c 将边l1,l2…lc 的权值增加1

分析

暴力的做法是每次重新建图，然后跑一次最短路
这样的时间复杂度是)，会TLE，且常数较大

这是由于Dijkstra算法中进行了多余的计算
在Dijkstra算法的执行过程中，对于相邻的点x,y，若)
算法执行结束后，一定有)
即使边权从)
我们要多次用)的计算是重复的
因此，我们先在原图上跑一遍最短路，然后将边的长度更新成]
这样在新图上跑最短路和原图上跑是完全等价的，只不过新图上维护的是新的dist与原来的dist的差值，即Δdist
每次跑完最短路后更新]
再像之前一样重设边权即可（代码中可以不用修改邻接表，直接在Dijkstra中算即可）

容易发现新图的边权很小，当有k条边的权值+1时，最短路的长度最多增加)
既然最短路长度的值域是确定的，我们就可以用值域个队列来模拟堆，设Q[i]存储dist=i的所有节点，我们只要维护dist最大值maxv，再逐一取出]中的全部元素即可
这样的Dijkstra算法的时间复杂度为)

总时间复杂度为)

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define INF 10000000000000000ll
#define maxn 100005
using namespace std;
int n,m,q;
long long dis[maxn];
long long delta[maxn];
struct edge {
    int from;
    int to;
    int next;
    int len;
} E[maxn<<1];
int head[maxn];
int size=0;
void add_edge(int u,int v,int w) {
    size++;
    E[size].from=u;
    E[size].to=v;
    E[size].len=w;
    E[size].next=head[u];
    head[u]=size;
}

struct node {
    int x;
    long long d;
    node() {

    }
    node(int u,long long v) {
        x=u;
        d=v;
    }
    friend bool operator <(node u,node v) {
        return u.d>v.d;
    }
};
void dijkstra() {
    priority_queue<node>heap;
    for(int i=1; i<=n; i++) dis[i]=INF;
    dis[1]=0;
    heap.push(node(1,0));
    while(!heap.empty()) {
        int x=heap.top().x;
        heap.pop();
        for(int i=head[x]; i; i=E[i].next) {
            int y=E[i].to;
            if(dis[x]+E[i].len<dis[y]) {
                dis[y]=dis[x]+E[i].len;
                heap.push(node(y,dis[y]));
            }
        }
    }
}

queue<int>Q[maxn];
void new_dijkstra(int k) {
    int maxv=0;
    for(int i=1; i<=n; i++) {
        delta[i]=INF;
    }
    delta[1]=0;
    Q[0].push(1);
    for(int i=0; i<=maxv; i++) {
        while(!Q[i].empty()) {
            int x=Q[i].front();
            Q[i].pop();
            if(delta[x]<i) continue;
            for(int j=head[x]; j; j=E[j].next) {
                int t=delta[x]+(dis[x]-dis[E[j].to]+E[j].len);
                if(t<delta[E[j].to]) {
                    delta[E[j].to]=t;
                    if(t<=min(k,n-1)) {
                        Q[t].push(E[j].to);
                        maxv=max(maxv,t);
                    }
                }
            }
        }
    }

    for(int i=1; i<=n; i++) dis[i]=min(INF,dis[i]+delta[i]);
}

int main() {
    int u,v,w;
    scanf("%d %d %d",&n,&m,&q);
    for(int i=1; i<=m; i++) {
        scanf("%d %d %d",&u,&v,&w);
        add_edge(u,v,w);
    }
    dijkstra();
    int cmd,k,x;
    for(int i=1; i<=q; i++) {
        scanf("%d",&cmd);
        if(cmd==1) {
            scanf("%d",&x);
            if(dis[x]<INF) printf("%I64d\n",dis[x]);
            else printf("-1\n");
        } else {
            scanf("%d",&k);
            for(int i=1; i<=k; i++) {
                scanf("%d",&x);
                E[x].len++;
            }
            new_dijkstra(k);
        }
    }
}