HDU 1142 A Walk Through the Forest （dijkstra算法）

地址：http://acm.hdu.edu.cn/showproblem.php?pid=1142

思路1：

题目大意是给你一个图。起点为1，终点为2

然后点a到点b是合法的判断（Notice 1:)是当b存在一个到终点的距离小于a到终点的最小距离，求从起点到终点的路径数。

Notice 1:不合法并非是断路，合法指回家的时候只按dis[b] < dis[a]的路线走、

dis[]表示到终点2的最短路径， 满足dis[b] < dis[a]， 表示这样a->b的是可选择的。 就是说每次回家时选择从距起点（最短距离)近的点 向 距起点（最短距离）远的点走， 求这样的路线条数。

dp[i] = sum{ dp[j] |  i->j邻接 && dp[j] > dp[i]}；

//即邻接的两点（i,j）且 i->j 的路线是可行的，到 j 的路径数是其所以前驱点路径数之和

 for (j = 1; j <= n; j++)

{

if （i->j 邻接 且 dis[j] > dis[i]）

{

then i->j的路线是可选择的；

dp[i] += dp[j];

}

}

借鉴代码1如下：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
#define INF 0x7fffffff  //这个是把inf赋值为一个极大值。你可以这样认为0x7fffffff是十六进制的-1，那么把它减1就相当于正的最大值
#define MAXN 1010
int map[MAXN][MAXN];
int dis[MAXN];
int dp[MAXN];
bool hash[MAXN];
struct Dij
{
    int id;
    int dis;
    bool friend operator < (const Dij a, const Dij b)
    {
        return a.dis > b.dis;
    }
};
Dij now, next;
void Init(int n)
{
    for (int i = 0; i <= n; i++)
    {
        map[i][i] = 0;
        for (int j = i + 1; j <= n; j++)
        {
            map[i][j] = map[j][i] = INF;
        }
    }
}
void Bfs(int st, int n)
{
    memset(hash, false, sizeof(hash));
    for (int i = 1; i <= n; i++)
    {
        dis[i] = INF;
    }
    priority_queue<Dij> Q;
    now.id = st;
    now.dis = 0;
    dis[st] = 0;
    Q.push(now);
    
    while (!Q.empty())
    {
        now = Q.top();
        Q.pop();
        if (hash[now.id])
        {
            continue;
        }
        hash[now.id] = true;
        
        for (int j = 1; j <= n; j++)
        {
            if (!hash[j] && map[now.id][j] != INF && 
            dis[j] > dis[now.id] + map[now.id][j])
            {
                dis[j] = dis[now.id] + map[now.id][j];
                next.id = j;
                next.dis = dis[j];
                Q.push(next);
            }
        }
    }
}
int dp_num(int ed, int n)
{
    if (dp[ed] != 0)
    {//不为0，说明已求得，直接返回。
        return dp[ed];
    }
    for (int j = 1; j <= n; j++)
    {
        if (j != ed && map[j][ed] != INF)
        {
            if (dis[j] < dis[ed])
            {
                dp[ed] += dp_num(j, n);
                //dis表示到终点2的最短路径，即按题意求dis[b] < dis[a]的路径数目。
            }
        }
    }
    return dp[ed];
}
int main()
{
    int n, m, i, j;
    int a, b, c;
    while (scanf("%d", &n) != EOF)
    {
        if (n == 0)
            break;
        Init(n);
        scanf("%d", &m);
        for (i = 0; i < m; i++)
        {
            scanf("%d %d %d", &a, &b, &c);
            if (c < map[a][b])
            {
                map[a][b] = map[b][a] = c;
            }
        }
        Bfs(2, n);
        memset(dp, 0, sizeof(dp));
        dp[2] = 1;//只要dis表示到终点2的最短路即可，dfs可以从起点->终点，也可以从终点->起点
        dp_num(1, n);//dfs求路径数
        printf("%d/n", dp[1]);
    }
    return 0;
}

借鉴代码2如下：

#include<stdio.h>
int n,map[1001][1001];
int dist[1001],s[1001],dp[1001];
int dfs(int v)//深搜
{
    int i,temp,sum=0;
    if(dp[v]!=-1)
        return dp[v];
    if(v==2)
        return 1;
    for(i=1;i<=n;i++)
    {
        if(map[v][i]!=2000000&&dist[v]>dist[i])//
        {
            temp=dfs(i);
            sum+=temp;
        }
    }
    dp[v]=sum;
    return sum;
}
void dijkstra(int v)//dijkstra求最短路
{
    int i,j,u,min;
    for(i=1;i<=n;i++)
        dist[i]=map[v][i];
    dist[v]=0;
    s[v]=1;
    for(i=1;i<n;i++)
    {
        min=2000000;
        for(j=1;j<=n;j++)
        {
            if(!s[j]&&dist[j]<min)
            {
                min=dist[j];
                u=j;
            }
        }
        s[u]=1;
        for(j=1;j<=n;j++)
        {
            if(!s[j]&&dist[j]>dist[u]+map[u][j])
            {
                dist[j]=dist[u]+map[u][j];
            }
        }
    }
}
int main()
{
    int i,j,x,m;
    while(scanf("%d",&n),n)
    {
        for(i=1;i<=n;i++)
        {
            s[i]=0;
            dp[i]=-1;
            for(j=1;j<=n;j++)
                map[i][j]=2000000;
        }
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d%d%d",&i,&j,&x);
            map[i][j]=map[j][i]=x;
        }
        dijkstra(2);
        dfs(1);
        printf("%d/n",dp[1]);
    }
    return 0;
}

 

思路2：

本题的思想就是dfs+dijkstra。本题的意思是，如果在点B出存在一条路使得从B点出发可以比从A点出发跟快的到达home，所以B到home的最短距离要比A到home得最短距离小，所以本题首先要求出各点到home得距离，然后再用记忆搜索法搜索即可

借鉴代码如下：

#include<stdio.h>
 #include<string.h>
 #include<queue>
  using namespace std;
  int dist[1005],dp[1005];
 typedef struct t
 {
     int end,len;
     struct t *next;
 }T;
 struct node
 {
     int data;
     int len;
     bool operator <(const node &a)const
     {
         return a.len<len;
     }
     T *next;
 }s[1005];
 void dijkstra(int v0)
 {
     s[v0].len=0;node cur;
     int visit[1005],mark=0;
     memset(visit,0,sizeof(visit));
     memset(dist,-1,sizeof(dist));
     priority_queue<node> qu;
     qu.push(s[v0]);
     dist[v0]=0;
     while(!qu.empty ())
     {
         cur=qu.top();
         while(visit[cur.data])
         {
             qu.pop();
             if(qu.empty ())
             {
                 mark=1;
                 break;
             }
             cur=qu.top();
         }
         if(mark)
             break;
         qu.pop();
         visit[cur.data]=1;
         T *p=cur.next;
         while(p)
         {
             if(!visit[p->end])
             {
                 if(dist[p->end]==-1||dist[cur.data]+p->len<dist[p->end] )
                     s[p->end].len=dist[p->end]=p->len+dist[cur.data];
                 qu.push (s[p->end]);
             }
             p=p->next;
         }
     }
 }
 int dfs(int v0)
 {
     int temp=0;
     if(v0==2)
         return 1;
     if(dp[v0]!=-1)
         return dp[v0];
     t *p=s[v0].next;
     while(p)
     {
         if(dist[v0]>dist[p->end])
         {
             dp[p->end]=dfs(p->end);
             temp+=dp[p->end];
         }
         p=p->next;
     }
     return temp;
 }
 int main()
 {
     int n,i,m,a,b,len;
     while(scanf("%d",&n)!=EOF)
     {
         if(n==0)
             break;
         scanf("%d",&m);
         T *p,*q;
         for(i=1;i<=n;i++)
         {
             s[i].next=NULL;
             s[i].data=i;
         }
         memset(dp,-1,sizeof(dp));
         for(i=1;i<=m;i++)
         {
             scanf("%d%d%d",&a,&b,&len);
             p=(T*)malloc(sizeof(T));
             p->end=b;
             p->len=len;
             p->next=s[a].next;
             s[a].next=p;
             q=(T*)malloc(sizeof(T));
             q->end=a;
             q->len=len;
             q->next=s[b].next;
             s[b].next=q;
         }
         dijkstra(2);
         printf("%d\n",dfs(1));
     }
     return 0;
 }

 

思路3：

题目大意是给一个图。起点为1，终点为2

然后点a到点b是合法的判断是当b存在一个到终点的距离小于a到终点的最小距离。。。。。求从起点到终点的路径数。。

我的做法是dijk + sort + dp。

先dijk出任何点到2的最小距离。然后按照距离对他们sort 。

dp就是很普通的路径dp：ans[终点] += ans[起点];

借鉴代码如下：

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define MAXN 1100
#define INF 1000000000

struct way
{
    int s;
    int d;//distance
    bool operator <(const way k)const
    {
        return d < k.d;
    }
};

struct point//restore id and d(distance) of each point
{
    int d,id;
    bool operator<(const point &a) const//used for sort
    {
        if(d==a.d)
            return a.id>id;//从小到大排id
        return a.d<d;//从大到小排distance
    }
}p[MAXN];

int n,ans[MAXN];
int map[MAXN][MAXN];
bool flag[MAXN];

void dijk()//dijk find minimal distance between each point to point 2
{
    priority_queue<way>Q;

    way temp,now;
    now.s=2;
    now.d=0;
    Q.push(now);
    p[2].d=0;

    while(!Q.empty())
    {
        now=Q.top();
        Q.pop();//use priority queue to ensure pop the point with minimal distance every time
        if(flag[now.s])
            continue;
        flag[now.s]=1;//flag[i]==1 means it is in the end point set
        for(int i=1;i<=n;i++)//从终点往回推
        {
            if(!flag[i]&&map[now.s][i]!=INF&&p[i].d>p[now.s].d+map[now.s][i])
            {
                temp.s=i;
                temp.d=p[now.s].d+map[now.s][i];
                p[i].d=temp.d;
                Q.push(temp);
            }
        }
    }
}

void init(int m)//初始化
{
    int i,j;
    int a,b,c;
    for(i=1;i<=n;i++)
    {
        p[i].id=i;
        flag[i]=0;
        p[i].d=INF;
        ans[i]=0;
        for(j=1;j<=n;j++)
            map[i][j]=INF;
    }
    while(m--)
    {
        scanf("%d%d%d",&a,&b,&c);
        map[a][b] = c;
        map[b][a] = c;
    }
}

void dp()//ans[end point]+=ans[start point]
{
    int i,j;
    for(i=1;i<=n;i++)//find start point 1
        if(p[i].id==1)
            break;
    ans[1]=1;
    for(i;i<n;i++)
    {
        for(j=i+1;j<=n;j++)//p[j].d must be <= p[i].d after sorting
        {
            if(map[p[j].id][p[i].id]!=INF&&p[j].d<p[i].d)
                ans[p[j].id]+=ans[p[i].id];
        }
    }
}

int main()
{
    int m;
    while(scanf("%d",&n)!=EOF&&n!=0)
    {
        scanf("%d",&m);
        init(m);
        dijk();//find minimal distance between each point to point 2
        sort(p+1,p+n+1);//sort the distance
        dp();
        printf("%d/n",ans[2]);
    }
    return 0;
}