10-21 Walk through the forest(最短路预处理+建树)

Walk Through the Forest

Jimmy experiences a lot of stress

at work these days, especially since

his accident made working difficult.

To relax after a hard day, he likes

to walk home. To make things even

nicer, his office is on one side of

a forest, and his house is on the

other. A nice walk through the forest,

seeing the birds and chipmunks

is quite enjoyable.

The forest is beautiful, and

Jimmy wants to take a different

route everyday. He also wants to

get home before dark, so he always

takes a path to make progress

towards his house. He considers

taking a path from A to B to be

progress if there exists a route from

B to his home that is shorter than any possible route from A. Calculate how many different routes

through the forest Jimmy might take.

Input

Input contains several test cases followed by a line containing ‘0’. Jimmy has numbered each intersection

or joining of paths starting with 1. His office is numbered 1, and his house is numbered 2. The first

line of each test case gives the number of intersections N, 1 < N ≤ 1000, and the number of paths M.

The following M lines each contain a pair of intersections a b and an integer distance 1 ≤ d ≤ 1000000

indicating a path of length d between intersection a and a different intersection b. Jimmy may walk a

path any direction he chooses. There is at most one path between any pair of intersections.

Output

For each test case, output a single integer indicating the number of different routes through the forest.

You may assume that this number does not exceed 2147483647.

Sample Input

5 6

1 3 2

1 4 2

3 4 3

1 5 12

4 2 34

5 2 24

7 8

1 3 1

1 4 1

3 7 1

7 4 1

7 5 1

6 7 1

5 2 1

6 2 1

0

Sample Output

2

4

理解，分析题意

#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxn = 1010;
typedef pair<int, int> pii;
vector<pii> vec[maxn];
int d[maxn];
const int INF = 0x3f3f3f3f;
bool app[maxn];
int mark[maxn];

void spfa(int s){
for(int i = 1; i <= n; i++) d[i] = INF;
memset(app, 0, sizeof(app));
d[s] = 0;
queue<int> que;
que.push(s), app[s] = true;
while(!que.empty()){
int u = que.front();
que.pop(); app[u]= false;
for(int i = 0; i < vec[u].size(); i++){
int v = vec[u][i].first;
int dist = vec[u][i].second;
if(d[v]>d[u]+dist){
d[v] = d[u]+dist;
if(!app[v]){
app[v] = true;
que.push(v);
}
}
}
}
}

int solve(){
memset(mark, 0, sizeof(mark));
memset(app, 0, sizeof(app));
mark[1] = 1;
app[1] = true;
queue<int> que;
que.push(1);
while(!que.empty()){
int u = que.front();
que.pop(); app[u] = false;
for(int i = 0; i < vec[u].size(); i++){
int v = vec[u][i].first;
if(d[v] < d[u]){
mark[v] += mark[u];
if(!app[v]){
app[v] = true;
que.push(v);
}
}
}
if(u != 2)  mark[u] = 0; //注意这里一个点可能被重复计数
}
return mark[2];
}

int main()
{
while(~scanf("%d", &n) && n){
scanf("%d", &m);
for(int i = 0; i <= n; i++) vec[i].clear();
for(int i = 0; i < m; i++){
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
vec[x].push_back(make_pair(y, z));
vec[y].push_back(make_pair(x, z));
}
spfa(2);
int ans = solve();
printf("%d\n", ans);
}
return 0;
}