POJ 1142 A Walk Through the Forest ( 最短路 +记忆化搜索）

此题，弄了几个小时，做完之后都说 那个题很水， 不过这个题 无关水与不水。 题意读错，开始 结合样例 ，认为是求有几条不同路径的最短路。 

但是，不是   ” 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. “

是从起点1 到终点2 的路径中的经过的每一个点的dis[]都是递减的才可以算作一个所求的路径。

先 spfa或 bellman 求出2到没点的距离，再DFS 求可行的递减路径, 别忘了记忆化搜索。

SPFA算法  31MS

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<vector>
using namespace std;
#define PI acos(-1.0)
#define max(a,b) (a)>(b)? (a):(b)
#define min(a,b) (a)>(b)? (b):(a)
#define INT_MIN -0x7FFFFFFF
#define INT_MAX 0x7FFFFFF
int n,m;
struct node
{
    int next,d;
    node(int x,int y)
    {
        next=x;
        d=y;
    }
};
int dui[1000005];
int inq[1005];
int vis[1005];
vector<node> edge[1005];
int map[1005][1005];
int dis[1005];
int mark[1005];
int sum;
void spfa()
{
    int i,j,k;
    int head,tail;
    for(i=0;i<=n;i++) dis[i]=INT_MAX;
    memset(inq,0,sizeof(inq));
    dis[2]=0;
    inq[2]=1;
    head=tail=0;//notice
    dui[tail++]=2;
    while(head<tail)
    {
        int now=dui[head++];
        inq[now]--;
        for(i=0;i<edge[now].size();i++)
        {
            int next=edge[now][i].next;
            int val=edge[now][i].d;
            if(dis[next]>dis[now]+val)
            {
                dis[next]=dis[now]+val;
                if(!inq[next])
                {
                    inq[next]++;
                    dui[tail++]=next;
                }
            }
        }
    }
}
int dfs(int x)
{
    int i,j,k;
    if(mark[x]) return mark[x];//记忆化搜索
    if(x==2) return 1;
    for(i=1;i<=n;i++)
    {
        if(map[x][i]<INT_MAX && dis[x]>dis[i])
        {
            mark[x]+=dfs(i);
        }
    }
    return mark[x];
}
int main()
{
    freopen("in.txt","r",stdin);
    int i,j,k;
    while(scanf("%d",&n),n)
    {
        for(i=0;i<=n;i++) edge[i].clear();
        scanf("%d",&m);
        int a,b,c;
        for(i=0;i<=n;i++)
            for(j=0;j<=n;j++)
            map[i][j]=INT_MAX;
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            map[a][b]=map[b][a]=c;
            edge[a].push_back(node(b,c));
            edge[b].push_back(node(a,c));
        }
        spfa();
        memset(vis,0,sizeof(vis));
        vis[1]=1;
        memset(mark,0,sizeof(mark));
        sum=dfs(1);
        //printf("d[2] : %d \n",dis[1]);
        printf("%d\n",sum);
    }
    return 0;
}

 Dijkstra算法    78MS

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define max(a,b) (a)>(b)? (a):(b)
#define min(a,b) (a)>(b)? (b):(a)
#define INT_MAX 0x7FFFFFF
int map[1005][1005];
int s[1005];
int dis[1005];
int n,m;
int sum;
int mark[1005];
void dijkstra(int v)
{
    int i,j,k;
    memset(s,0,sizeof(s));
    s[v]=1;
    for(i=0;i<=n;i++) dis[i]=map[v][i];
    dis[v]=0;
    for(i=0;i<n-1;i++)
    {
        int mi=INT_MAX;
        int ar;
        for(j=1;j<=n;j++)
        {
            if(!s[j] && mi>dis[j])
            {
                ar=j;
                mi=dis[j];
            }
        }
        s[ar]=1;
        for(k=1;k<=n;k++)
        {
            if(!s[k] && map[ar][k]<INT_MAX && dis[k]>dis[ar]+map[ar][k])
            {
                dis[k]=dis[ar]+map[ar][k];
            }
        }
    }
}
int dfs(int x)
{
    int i,j,k;
    if(mark[x]) return mark[x];
    if(x==2) return 1;
    for(i=1;i<=n;i++)
    {
        if(map[x][i]<INT_MAX && dis[x]>dis[i])
            mark[x]+=dfs(i);
    }
    return mark[x];
}

int main()
{
    //freopen("in.txt","r",stdin);
    int i,j,k;
    while(scanf("%d",&n),n)
    {
        scanf("%d",&m);
        for(i=0;i<=n;i++)
            for(j=0;j<=n;j++)
            map[i][j]=INT_MAX;
        int a,b,c;
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            map[a][b]=map[b][a]=c;
        }
        dijkstra(2);
        sum=0;

        memset(mark,0,sizeof(mark));
        sum=dfs(1);
        //printf("dis 1 %d\n",dis[1]);
        printf("%d\n",sum);
    }

    return 0;
}