题面
(http://codeforces.com/problemset/problem/843/D)
题目大意:
给定一张带权无向图,有q次操作
操作有两种
1 v 询问1到v的最短路
2 c 将边
l1,l2…lc
l
1
,
l
2
…
l
c
的权值增加1
分析
暴力的做法是每次重新建图,然后跑一次最短路
这样的时间复杂度是
O((n+m)qlog2n+Σc)
O
(
(
n
+
m
)
q
l
o
g
2
n
+
Σ
c
)
,会TLE,且常数较大
这是由于Dijkstra算法中进行了多余的计算
在Dijkstra算法的执行过程中,对于相邻的点x,y,若
dist[y]>dist[x]+w(x,y)
d
i
s
t
[
y
]
>
d
i
s
t
[
x
]
+
w
(
x
,
y
)
,就把
dist[y]设为dist[x]+w(x,y)
d
i
s
t
[
y
]
设
为
d
i
s
t
[
x
]
+
w
(
x
,
y
)
算法执行结束后,一定有
dist[y]≤dist[x]+w(x,y)
d
i
s
t
[
y
]
≤
d
i
s
t
[
x
]
+
w
(
x
,
y
)
即使边权从
w(x,y)
w
(
x
,
y
)
增加到
w′(x,y)=w(x,y)+Δw
w
′
(
x
,
y
)
=
w
(
x
,
y
)
+
Δ
w
,显然一定有
dist[y]≤dist[x]+w′(x,y)
d
i
s
t
[
y
]
≤
d
i
s
t
[
x
]
+
w
′
(
x
,
y
)
我们要多次用
w(x,y)+Δw
w
(
x
,
y
)
+
Δ
w
去更新dist,其中关于常量
w(x,y)
w
(
x
,
y
)
的计算是重复的
因此,我们先在原图上跑一遍最短路,然后将边的长度更新成
dist[x]+w(x,y)−dist[y]
d
i
s
t
[
x
]
+
w
(
x
,
y
)
−
d
i
s
t
[
y
]
这样在新图上跑最短路和原图上跑是完全等价的,只不过新图上维护的是新的dist与原来的dist的差值,即
Δdist
Δ
d
i
s
t
每次跑完最短路后更新
dist[i]=dist[i]+Δdist[i]
d
i
s
t
[
i
]
=
d
i
s
t
[
i
]
+
Δ
d
i
s
t
[
i
]
再像之前一样重设边权即可(代码中可以不用修改邻接表,直接在Dijkstra中算即可)
容易发现新图的边权很小,当有k条边的权值+1时,最短路的长度最多增加
min(k,n−1)
m
i
n
(
k
,
n
−
1
)
既然最短路长度的值域是确定的,我们就可以用值域个队列来模拟堆,设Q[i]存储dist=i的所有节点,我们只要维护dist最大值maxv,再逐一取出
Q[0],Q[1]…Q[maxv]
Q
[
0
]
,
Q
[
1
]
…
Q
[
m
a
x
v
]
中的全部元素即可
这样的Dijkstra算法的时间复杂度为
O(n+m)
O
(
n
+
m
)
总时间复杂度为 O((n+m)q+Σc) O ( ( n + m ) q + Σ c )
代码:
#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);
}
}
}