hdu 1142 最短路+记忆化搜索

先求一遍最短路，然后判断哪条路可以走再记忆化搜索统计方法数。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int INF = 99999999;
const int N = 1001;
const int M = N * N;
int head[N];
int dist[N];
int dp[N];
bool visit[N];
int n, m, e;

struct Edge
{
    int v, next, w;
} edge[M];

void addEdge( int u, int v, int w )
{
    edge[e].v = v;
    edge[e].w = w;
    edge[e].next = head[u];
    head[u] = e++;
}

void dij( int s )
{
    memset( visit, false, sizeof(visit) );
    for ( int i = 0; i <= n; i++ )
    {
        dist[i] = INF;
    }
    dist[s] = 0;
    for ( int i = 1; i <= n; i++ )
    {
        int u = 0;
        for ( int j = 1; j <= n; j++ )
        {
            if ( !visit[j] && dist[j] < dist[u] )
            {
                u = j;
            }
        }
        visit[u] = true;
        for ( int j = head[u]; j != -1; j = edge[j].next )
        {
            int v = edge[j].v, w = edge[j].w;
            if ( !visit[v] && dist[u] + w < dist[v] )
            {
                dist[v] = dist[u] + w;
            }
        }
    }
}

int dfs( int u )
{
    if ( dp[u] ) return dp[u];
    int sum = 0;
    for ( int i = head[u]; i != -1; i = edge[i].next )
    {
        int v = edge[i].v;
        if ( dist[u] > dist[v] )
        {
            sum += dfs(v);
        }
    }
    return dp[u] = sum;
}

int main ()
{
    while ( scanf("%d", &n), n )
    {
        e = 0;
        memset( head, -1, sizeof(head) );
        scanf("%d", &m);
        while ( m-- )
        {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            addEdge( u, v, w );
            addEdge( v, u, w );
        }
        dij(2);
        memset( dp, 0, sizeof(dp) );
        dp[2] = 1;
        int ans = dfs(1);
        printf("%d\n", ans);
    }
    return 0;
}