CF449B Jzzhu and Cities （最短路）

CF449B CF450D

http://codeforces.com/contest/450/problem/D

http://codeforces.com/contest/449/problem/B

Codeforces Round #257 (Div. 2) D

Codeforces Round #257 (Div. 1) B

D. Jzzhu and Cities

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city u_i to v_i (and vise versa) using the i-th road, the length of this road is x_i. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city s_i (and vise versa), the length of this route is y_i.

Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.

Input

The first line contains three integers n, m, k (2 ≤ n ≤ 10⁵; 1 ≤ m ≤ 3·10⁵; 1 ≤ k ≤ 10⁵).

Each of the next m lines contains three integers u_i, v_i, x_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i; 1 ≤ x_i ≤ 10⁹).

Each of the next k lines contains two integers s_i and y_i (2 ≤ s_i ≤ n; 1 ≤ y_i ≤ 10⁹).

It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.

Output

Output a single integer representing the maximum number of the train routes which can be closed.

Sample test(s)

Input

5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5

Output

2

Input

2 2 3
1 2 2
2 1 3
2 1
2 2
2 3

Output

2

题意：有n个城市，1是首都。给出m条有权无向边（公路），k条由1连接到某个城市的有权无向边（铁路），求在保持首都到各个城市的最短路长度不变的情况下，最多能炸掉多少条铁路。

题解：首都到达同一个城市的铁路只保留最短的，然后进行最短路并统计某个顶点最短路的更新次数，最后只保留长度等于最短路且更新次数为1（只有这一种最短路）的铁路。

设一个c[i]记录i点的更新次数，初始c[首都]为1，其他为0。更新的时候dij和spfa不是小于才更新嘛，小于的时候就c[新点]=c[当前点]，等于的时候就c[新点]+=c[当前点]，这样c[i]就是最短路的更新次数（最短路的方案数）。

注意CF可是大家都能出数据的，有人出了个卡SPFA的数据，我都吓尿了。可以给SPFA加SLF优化过。有人用优先队列过的，因为还好没人出卡优先队列SPFA的数据…

代码：

 //#pragma comment(linker, "/STACK:102400000,102400000")
 #include<cstdio>
 #include<cmath>
 #include<iostream>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<map>
 #include<set>
 #include<stack>
 #include<queue>
 using namespace std;
 #define ll long long
 #define usll unsigned ll
 #define mz(array) memset(array, 0, sizeof(array))
 #define minf(array) memset(array, 0x3f, sizeof(array))
 #define REP(i,n) for(i=0;i<(n);i++)
 #define FOR(i,x,n) for(i=(x);i<=(n);i++)
 #define RD(x) scanf("%d",&x)
 #define RD2(x,y) scanf("%d%d",&x,&y)
 #define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
 #define WN(x) prllf("%d\n",x);
 #define RE  freopen("D.in","r",stdin)
 #define WE  freopen("1biao.out","w",stdout)
 #define mp make_pair
 #define pb push_back
 
 const ll INF=1LL<<;
 
 const int maxn=;
 const int maxm=;
 struct edge {
     int v,next;
     ll w;
 } e[maxm];///边表
 int head[maxn],en;
 
 void add(int x,int y,ll z) {
     e[en].w=z;
     e[en].v=y;
     e[en].next=head[x];
     head[x]=en++;
 }
 
 int n,m,k;
 ll g[maxn];
 bool f[maxn];///入队标志
 int b[maxn], c[maxn];
 ll d[maxn];///b为循环队列，d为起点到各点的最短路长度
 void spfa() { ///0~n-1，共n个点，起点为st
     int i,k;
     int st=, l=, r=;
     memset(f,,sizeof(f));
     memset(b,,sizeof(b));
     for(i=; i<n; i++)
         d[i]=INF;
     b[]=st;
     f[st]=;
     d[st]=;
     c[st]=;
     while(l!=r) {
         k=b[l++];
         l%=n;
         for(i=head[k]; i!=-; i=e[i].next)
             if (d[k]+e[i].w < d[e[i].v]) {
                 d[e[i].v]=d[k] + e[i].w;
                 c[e[i].v]=c[k];
                 if (!f[e[i].v]) {
                     if(d[e[i].v]>d[b[l]]) {///SLF优化，这题卡没优化的SPFA……
                         b[r++]=e[i].v;
                         r%=n;
                     } else {
                         l--;
                         if(l==-)l=n-;
                         b[l]=e[i].v;
                     }
                     f[e[i].v]=;
                 }
             } else if(d[k]+e[i].w == d[e[i].v])
                 c[e[i].v]+=c[k];
         f[k]=;
     }
 }
 
 void init() {
     memset(head,-,sizeof(head));
     en=;
 }
 
 int main() {
     int i,x,y;
     ll z;
     while(scanf("%d%d%d",&n,&m,&k)!=EOF) {
         init();
         REP(i,m) {
             scanf("%d%d%I64d",&x,&y,&z);
             x--;
             y--;
             add(x,y,z);
             add(y,x,z);
         }
 
         REP(i,n) g[i]=INF;
 
         REP(i,k) {
             scanf("%d%I64d",&x,&z);
             x--;
             if(z<g[x]) g[x]=z;
         }
 
         REP(i,n)
             if(g[i]!=INF) {
                 add(,i,g[i]);
                 add(i,,g[i]);
             }
 
         memset(c,,sizeof(c));
         spfa();
 
         int remain=;
         REP(i,n)
             if(g[i]!=INF && c[i]== && d[i]==g[i])
                 remain++;
         printf("%d\n",k-remain);
     }
     return ;
 }