hdu_A Walk Through the Forest ——迪杰特斯拉+dfs

A Walk Through the Forest

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 3   Accepted Submission(s) : 1

Problem Description

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

 

Source

University of Waterloo Local Contest 2005.09.24

 

题意：Jimmy工作压力大，为了放松，他喜欢走路回家。而为了不太晚到家，他又得朝着家的方向走，也就是说必须离家越来越近。给定一个无向图，求有多少条路径回家。

 

分析：先用迪杰特斯拉算法求出各结点离源点（家）的最短距离，然后dfs求出路径总数。

 

时间超限代码（dfs需优化）

 #include <cstdio>
 #include <queue>
 #include <algorithm>
 #define INF 0x3f3f3f3f
 using namespace std;

 const int maxn=;
 vector<int> g[maxn];
 struct node
 {
     int num,dis;
 };
 int n,m;
 int cost[maxn][maxn],d[maxn];
 int ans;

 bool operator<(const node& n1,const node& n2)
 {
     return n1.dis<n2.dis;
 }

 void dij()
 {
     fill(d+,d+n+,INF);
     d[]=;
     priority_queue<node> que;
     que.push(node{,});
     while(!que.empty())
     {
         int x=que.top().num;
         que.pop();
         for(int i=;i<g[x].size();i++)
         {
             int u=x;
             int v=g[x][i];
             if(d[v]>d[u]+cost[u][v])
             {
                 d[v]=d[u]+cost[u][v];
                 que.push(node{v,d[v]});
             }
         }
     }
 }

 void dfs(int x)
 {
     if(x==)
     {
         ans++;
         return ;
     }
     for(int i=;i<g[x].size();i++)
     {
         int fx=g[x][i];
         if(d[fx]<d[x])
            dfs(fx);
     }
 }

 int main()
 {
     while(scanf("%d",&n),n)
     {
         scanf("%d",&m);
         ans=;
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
         {
             cost[i][j]=(i==j)?:INF;
         }
         for(int i=;i<m;i++)
         {
             int a,b,c;
             scanf("%d%d%d",&a,&b,&c);
             g[a].push_back(b);
             g[b].push_back(a);
             cost[a][b]=cost[b][a]=c;
         }
         dij();
         d[]=;
         dfs();
         printf("%d\n",ans);
         for(int i=;i<=n;i++)
             g[i].clear();
         ans=;
     }
     return ;
 }

优化分析：存在对某些结点进行了多次dfs，导致时间耗费过多。考虑采用记忆化搜索。我们用sum[i]表示从i出发有多少条到家的路径，对于已知sum[i]的结点i就不需要再次dfs，这样dfs的次数就只有n-1次（n为结点数）。

优化后代码：用时514ms

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <algorithm>
 #define INF 0x3f3f3f3f
 using namespace std;

 const int maxn=;
 vector<int> g[maxn];//图的邻接表表示
 struct node
 {
     int num,dis;
 };
 int n,m;
 int cost[maxn][maxn],d[maxn];
 int sum[maxn];

 bool operator<(const node& n1,const node& n2)//重载运算符
 {
     return n1.dis<n2.dis;
 }

 void dij()
 {
     fill(d+,d+n+,INF);//下标从1开始
     d[]=;
     priority_queue<node> que;
     que.push(node{,});
     while(!que.empty())
     {
         int x=que.top().num;
         que.pop();
         for(int i=;i<g[x].size();i++)
         {
             int u=x;
             int v=g[x][i];
             if(d[v]>d[u]+cost[u][v])
             {
                 d[v]=d[u]+cost[u][v];
                 que.push(node{v,d[v]});
             }
         }
     }
 }

 void dfs(int x)
 {
     for(int i=;i<g[x].size();i++)
     {
         int fx=g[x][i];
         if(d[fx]<d[x])
         {
             if(sum[fx]>)
             {
                 sum[x]+=sum[fx];
             }
             else
             {

             dfs(fx);
             sum[x]+=sum[fx];
             }
         }
     }
   //  return ;
 }

 int main()
 {
     while(scanf("%d",&n),n)
     {
         scanf("%d",&m);
         memset(sum,,sizeof(sum));
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
         {
             cost[i][j]=(i==j)?:INF;
         }
         for(int i=;i<m;i++)
         {
             int a,b,c;
             scanf("%d%d%d",&a,&b,&c);
             g[a].push_back(b);
             g[b].push_back(a);
             cost[a][b]=cost[b][a]=c;
         }
         dij();
         sum[]=;
         dfs();
         printf("%d\n",sum[]);
         for(int i=;i<=n;i++)
             g[i].clear();
     }
     return ;
 }

此题bug过的地方

（1）fill(d+1,d+1+n,INF),一开始没注意下标是从1开始，写成了fill(d,d+n,INF)。dij函数bug。

（2）每组用例输出后没有清空图，导致下一组用例的图多了许多不属于自己的边和顶点。