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 mroads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. 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 si (and vise versa), the length of this route is yi.
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.
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
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 a single integer representing the maximum number of the train routes which can be closed.
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
2
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
2
/*
题意：给你一般边和特殊无向边边，问你最多可以删除多少特殊边，使得删除后每个点的最短路
长度和原图一样
解法：对于连接到一个点的特殊边，只保留最短的一条，然后跑最短路，同时记录最短路条数
如果条数大于2，直接等于2就好了，对结果没有影响
最后如果特殊边长度大于最短距离，可以删除，等于就看最短路数是否大于1
spfa超时==，不科学。。。
还是优先队列优化的dij靠谱
弄了几个小时>_< 。果然太弱，hehe
*/
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<ctime>
#include<stack>
#define maxn 100010
#define LL long long
#define INF 10000000000000000LL
using namespace std ;
int head[maxn] , next1[maxn*8] ,to[maxn*8] ;
int n ,top ,num[maxn] ;
long long val[maxn*8] ,dis[maxn] ,d[maxn];
bool vi[maxn] ,vis[maxn] ,vv[maxn];
int q[maxn] ;
void Unit( int u ,int v ,LL c )
{
next1[top] = head[u] ;to[top] = v ;
val[top] = c ;head[u] = top++ ;
}
struct node
{
int x , y ;
node(){}
node( int xx ,int yy )
{
x = xx ;
y = yy ;
}
bool operator < (const node&s ) const
{
return y > s.y ;
}
};
void spfa(int s )
{
int i , j , k ;
for( i = 1 ; i <= n ;i++)
dis[i] = INF ;
memset(num,0,sizeof(num)) ;
memset(vi,0,sizeof(vi)) ;
dis[s] = 0 ;
priority_queue<node>q ;
q.push(node(s,0)) ;
while(!q.empty())
{
node k = q.top();q.pop();
if(vi[k.x]) continue ;
vi[k.x] = true ;
for( i = head[k.x] ; i != -1 ; i = next1[i])
{
j = to[i] ;
if(dis[j] > dis[k.x]+val[i])
{
vis[j] = true ;
dis[j] = dis[k.x]+val[i] ;
num[j] = 1 ;
q.push(node(j,dis[j])) ;
}
else if(dis[j] == dis[k.x]+val[i]) num[j] = 2 ;
}
}
}
void spfa1(int s )
{
int i , j , k ;
for( i = 1 ; i <= n ;i++)
dis[i] = INF ;
memset(vi,0,sizeof(vi)) ;
memset(num,0,sizeof(num)) ;
dis[s] = 0 ;
queue<int>q ;
vi[s] = true ;
q.push(s) ;
while(!q.empty())
{
k = q.front() ; q.pop() ;
for( i = head[k] ; i != -1 ; i = next1[i])
{
j = to[i] ;
// cout << j << " " << dis[j] <<" " << dis[k]+val[i] << endl;
if(dis[j] > dis[k]+val[i])
{
vis[j] = true ;
dis[j] = dis[k]+val[i] ;
num[j] = 1 ;
if(!vi[j])
{
vi[j] = true ;
q.push(j) ;
}
}
else if(dis[j] == dis[k]+val[i]) num[j] = 2 ;
}
vi[k] = false ;
}
}
int main()
{
int i , j , k , m ;
int u , v ,ans ;
LL c ;
while(scanf("%d%d%d",&n,&m,&k) != EOF )
{
memset(head,-1,sizeof(head)) ;
top = 0 ;
while(m--)
{
scanf("%d%d%I64d",&u,&v,&c) ;
Unit(v,u,c) ;
Unit(u,v,c) ;
}
ans = 0 ;
for( i = 1 ; i <= n ;i++)
d[i] = INF ;
memset(vv,0,sizeof(vv)) ;
for( i = 1 ; i <= k;i++)
{
scanf("%d%I64d",&v,&c) ;
vv[v] = true ;
if(d[v] == INF )
{
d[v] = c ;
continue ;
}
ans++ ;
if(d[v] > c) d[v] = c ;
}
for( int i = 2 ; i <= n ;i++ )if(vv[i])
{
Unit(1,i,d[i]) ;
Unit(i,1,d[i]) ;
}
spfa(1);
for( int i = 2 ; i <= n ;i++)if(vv[i])
{
if(d[i] > dis[i]) ans++ ;
else if(d[i] == dis[i]&&num[i] > 1) ans++;
}
cout << ans << endl;
}
return 0 ;
}