HDU 1142 欢迎参加——每周六晚的BestCoder（有米！） A Walk Through the Forest

题目链接：HDU 1142

题目大意：寻找一共有多少条符合题意的路。能够从点A走到点B的要求是：点A到终点的最短路 > 点B到终点的最短路。 也就是说：从终点出发，求每一个点的最短路，然后那些最短路的值记录起来，作为能否通过的判断条件。最后用记忆化搜索来搜索出一共多少条符合要求的路。普通的dfs是超时的，bfs是超内存的。

最短路的话用dijstra或SPFA算法随便搞。用dijstra速度要略胜一筹，用SPFA的时候，姿势不够优美，直接粘贴的SPFA的模板，然后模板里的maxn=105，忘记改了，然后TLE(竟然不是RE)

最短路跑出来，就可以用记忆化搜索搞了。

dijstra+堆优化+记忆化搜索

#include<iostream>
#include<queue>
#include<vector>
#include<cstdio>
using namespace std;
const int maxn=1005,inf=1<<29;
struct edge{int to,cost;};
struct node
{
    int len,v;
    friend bool operator <(node x,node y)
    {
        return x.len>y.len;
    }
};
int d[maxn],dp[maxn];
int n,m,s;
vector<edge>G[maxn];
void Dijkstra()
{
    priority_queue<node>q;
    fill(d,d+maxn,inf);d[s]=0;
    node t;
    t.len=0;t.v=s;
    q.push(t);
    while(q.size())
    {
        t=q.top();q.pop();
        if(d[t.v]<t.len) continue;
        for(int i=0;i<G[t.v].size();i++)
        {
            edge e=G[t.v][i];
            if(d[e.to]>d[t.v]+e.cost)
            {
                d[e.to]=d[t.v]+e.cost;
                node temp={d[e.to],e.to};
                q.push(temp);
            }
        }
    }
}
int dfs(int now)
{
    if(dp[now]) return dp[now];
    if(now==2) return 1;
    for(int i=0;i<G[now].size();i++)
    {
        int next=G[now][i].to;
        if(d[now]>d[next]) dp[now]+=dfs(next);
    }
    return dp[now];
}
int main()
{
    //while(cin>>n>>m&&(n+m))
    while(~scanf("%d",&n),n)
    {
        scanf("%d",&m);
        for(int i=0;i<=n;i++) G[i].clear();
        for(int i=0;i<m;i++)
        {
            int a,b,w;
            edge t,rt;
            scanf("%d%d%d",&a,&b,&w);
            //cin>>a>>b>>w;
            t.to=b;t.cost=w;
            rt.to=a;rt.cost=w;
            G[a].push_back(t);
            G[b].push_back(rt);
        }
        s=2;
        Dijkstra();
        fill(dp,dp+maxn,0);
        cout<<dfs(1)<<endl;
    }
    return 0;
}

SPFA加记忆化搜索

#include<iostream>
#include<queue>
#include<vector>
#include<cstdio>
using namespace std;
const int maxn=1005,inf=1<<29;
struct edge{int to,cost;};
int d[maxn],vis[maxn];
int n,m,s;
int dp[maxn];
vector<edge>G[maxn];
void SFPA()
{
    fill(d,d+maxn,inf);d[s]=0;
    fill(vis,vis+maxn,0);
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=0;i<G[u].size();i++)
        {
            int v=G[u][i].to,len=G[u][i].cost;
            if(d[v]>d[u]+len)
            {
                d[v]=d[u]+len;
                if(vis[v]==0)
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}
int dfs(int u)
{
    if(dp[u]) return dp[u];
    if(u==2) return 1;
    for(int i=0;i<G[u].size();i++)
    {
            int v=G[u][i].to;
            if(d[v]<d[u]) dp[u]+=dfs(v);
    }
    return dp[u];
}
int main()
{
    //while(cin>>n>>m&&(n+m))
    while(~scanf("%d",&n),n)
    {
        scanf("%d",&m);
        for(int i=0;i<=n;i++) G[i].clear();
        for(int i=0;i<m;i++)
        {
            int a,b,w;
            edge t,rt;
            scanf("%d%d%d",&a,&b,&w);
            //cin>>a>>b>>w;
            t.to=b;t.cost=w;
            rt.to=a;rt.cost=w;
            G[a].push_back(t);
            G[b].push_back(rt);
        }
        s=2;
        fill(dp,dp+maxn,0);
        SFPA();
        printf("%d\n",dfs(1));
        //cout<<d[n]<<endl;
    }
    return 0;
}