杭电1142（dijkstra最短路+DFS记忆化搜索）

A Walk Through the Forest（难度：3）

Time Limit: 2000/1000 MS (Java/Others)
Memory Limit: 65536/32768 K (Java/Others)

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

思路：

题意：给出若干对顶点和路径长度，要求路径满足如下条件：A到终点的最短路大于B到终点的最短路，则A到B是连通的，求从1到2的满足上述条件的路径的有多少条。

方法：最短路径算法+记忆化搜索算法。

• 最短路径：n的最大取值为1000，所以不能使用时间复杂度为O(n³)的Floyd算法，要使用Dijkstra算法，可以套模板
  
  • 求出从2到其它所有顶点的最短路径值。
• 记忆化搜索算法使用深度优先搜索DFS算法
  
  • 递归扩展src，依次找出到2的距离比src到2距离更短的点，即path[src] += dfs[i]

AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 1010
#define INF 0xfffffff
int n,m;
int vis[maxn];//结点是否已经访问过 
int map[maxn][maxn];//两点间权值 
int dis[maxn];//到结点的最短距离 
int path[maxn];//到结点的最短路径数 

void dijkstra(int src)//src为起始结点 
{
    int min,k=src;
    //初始化所有节点都不在最短路径中 
    memset(vis,0,sizeof(vis));

    //初始化从起始结点到结点i的距离
    for(int i=0;i<=n;i++)
    {
        dis[i]=map[src][i];
    }

    //起始结点到起始结点距离为0,标记为已走 
    dis[src]=0;
    vis[src]=1;

    //依次标记n-1个结点 
    for(int i=1;i<=n;i++)
    {
        //初始化 
        min=INF;
        //找到i所直接连通的结点中具有最短距离的结点
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&min>dis[j])
            {
                //更新最短距离,保存达这个点 
                min=dis[j];
                k=j;
            }
        }
        dis[k]=min;
        //标记这个点 
        vis[k]=1;
        //判断是起始结点到j短,还是经过k连接j更短
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&dis[j]>dis[k]+map[k][j])
            {
                dis[j]=dis[k]+map[k][j];
            }
        }
    }
} 

int dfs(int src)//src为起始结点 
{
    //该点已经走过，返回过该点有多少条路 
    if(path[src]!=-1) return path[src];
    //找到终点，返回1（1条路） 
    if(src==2) return 1;
    //初始化 
    path[src]=0;
    //递归找路径 
    for(int i=1;i<=n;i++)
    {
        //结点i与起始结点直接相连且到2的距离更短 
        if(map[i][src]!=INF&&dis[i]<dis[src])
        {
            //扩展i结点找到所有最短路径 
            path[src]+=dfs(i);
        }
    }
    return path[src];//返回一共有多少条路 
}

int main()
{
    int a,b,d;
    while(cin>>n&&n!=0)
    {
        cin>>m;
        //初始化 
        for(int i=0;i<=n;i++)
        {
            for(int j=0;j<=n;j++)
            {
                if(i==j) map[i][j]=0;
                else map[i][j]=INF;
            }
        }
        //输入边点权值信息 
        for(int i=0;i<m;i++)
        {
            cin>>a>>b>>d;
            map[a][b]=map[b][a]=d;
        }
        //求目标结点为2的最短路径 
        dijkstra(2);
        memset(path,-1,sizeof(path));
        //从起始结点1开始记忆化搜索 
        cout<<dfs(1)<<endl;
    }
    return 0;
}