[Johnson + 桶维护DIJ ] Codeforces #843D. Dynamic Shortest Path

这题用到了 $Johnson$ 算法的思想，就是先一趟最短路刷出 $dis(i)$ 然后把图改造。边 $(x,y)$ 的权改为 $w(x,y)+dis(x)-dis(y)$。
这样搞之后，边权都非负，再新图上做最短路的事情与原图是完全等价的，新图上从 $1$ 到 $v$ 的某条路径的长度就是原图的对应长度与 $dis(v)$ 的差值。$dis$ 的 $delta$ 在一些和权值大小有关的题上可能会有用。
这题的话，我们先把图改建，这时1到n的 $\Delta dis$ 都是 $0$， 当有 $k$ 条边的权值加 $1$ 之后，显然最短路长度最多增加 $min(k,n-1)$。
最短路长度有上界，我们就可以暴力用桶维护 $DIJ$，即用桶代替优先队列，每次取出的点的最短路值是不降的省去 $log$, 每次 $O(n+m)$，总复杂度 $O((n+m)Q)$。

#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long LL;
const int maxn=100005,maxe=100005,maxd=100005;
int n,m,Q;
LL dis[maxn],f[maxn],INF=1e16;
int fir[maxn],nxt[maxe],son[maxe],w[maxe],tot;
void add(int x,int y,int z){
    son[++tot]=y; w[tot]=z; nxt[tot]=fir[x]; fir[x]=tot;
}
struct data{
    int x; LL d;
    data(int t1=1,LL t2=1){x=t1;d=t2;}
    bool operator < (const data &b)const{ return d<b.d; }
};
priority_queue <data> Heap;
inline void DIJ(){
    for(int i=1;i<=n;i++) dis[i]=INF; dis[1]=0; 
    Heap.push(data(1,dis[1]));
    while(!Heap.empty()){
        int x=Heap.top().x; Heap.pop(); 
        for(int j=fir[x];j;j=nxt[j])
         if(dis[x]+w[j]<dis[son[j]]) dis[son[j]]=dis[x]+w[j], Heap.push(data(son[j],dis[son[j]]));
    }
}
queue<int> Bk[maxd];
int main(){
    freopen("cf843D.in","r",stdin);
    freopen("cf843D.out","w",stdout);
    scanf("%d%d%d",&n,&m,&Q);
    for(int i=1;i<=m;i++){
        int x,y,z; scanf("%d%d%d",&x,&y,&z);
        add(x,y,z); 
    }
    DIJ();
    while(Q--){
        int _type,k,x; scanf("%d%d",&_type,&k);
        if(_type==1) printf("%I64d\n",dis[k]<INF?dis[k]:-1); else{
            for(int i=1;i<=k;i++) scanf("%d",&x), w[x]++;
            for(int i=1;i<=n;i++) f[i]=INF; f[1]=0; Bk[0].push(1);
            for(int i=0,_max=0;i<=_max;i++)
             while(!Bk[i].empty()){
                int x=Bk[i].front(); Bk[i].pop();
                if(f[x]<i) continue;
                for(int j=fir[x];j;j=nxt[j]){
                    int t=f[x]+(w[j]+dis[x]-dis[son[j]]);
                    if(t<f[son[j]]){
                        f[son[j]]=t;
                        if(t<=min(k,n-1)) Bk[t].push(son[j]), _max=max(_max,t);
                    }
                }
             }
            for(int i=1;i<=n;i++) dis[i]=min(INF,dis[i]+f[i]);   
        }
    }
    return 0;
}