hdu1428

每走一步需要保证 （走完之后所到区域）距离实验室的最短距离 < （当前区域）距离实验室的最短距离

问，从宿舍到实验室有多少条路可以走

单源最短路 + 记忆化搜索

#include <cstdio>
#include <cstring>
#include <climits>
#include <queue>

#define MAXN 50

struct QueueNode
{
    int x, y;
};

int n, G[MAXN+5][MAXN+5], dist[MAXN+5][MAXN+5];
long long dp[MAXN+5][MAXN+5];
int dir[4][4] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };
bool vis[MAXN+5][MAXN+5];
// for every moment , there are not two same elements in the queue is OK 
void spfa()
{
    std::queue<QueueNode> q;

    QueueNode head;
    dist[n][n] = G[n][n];
    head.x = head.y = n;
    q.push(head);

    while(q.empty()==false){

        QueueNode u = q.front();
        // if u is out the queue
        // vis[u] is false
        vis[u.x][u.y] = false;
        q.pop();

        QueueNode v;

        for(int i = 0; i < 4; ++i){
            v.x = u.x + dir[i][0];
            v.y = u.y + dir[i][1];
            if( v.x>=1 && v.x<=n && v.y>=1 && v.y<=n ){
                if(dist[v.x][v.y] > dist[u.x][u.y] + G[v.x][v.y]){

                    dist[v.x][v.y] = dist[u.x][u.y] + G[v.x][v.y];

                    if(vis[v.x][v.y] == false){
                        // if u is out of the queu
                        // vis[u] is true
                        vis[v.x][v.y] = true;
                        q.push(v);
                    }
                }
            }
        }

    }
}

long long dfs(int x, int y)
{
    if(dp[x][y] > 0)
        return dp[x][y];

    for(int i = 0; i < 4; ++i){
        int _x = x + dir[i][0];
        int _y = y + dir[i][1];
        if(_x>=1 && _x<=n && _y>=1 && _y<=n){
            if(dist[_x][_y] < dist[x][y]){
                dp[x][y] += dfs(_x, _y); 
            }
        }
    }
    return dp[x][y];
}

int main(int argc, char const *argv[])
{
    // freopen("_in", "r", stdin);
    while(~scanf("%d", &n)){
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                scanf("%d", &G[i][j]);
                dist[i][j] = INT_MAX;
                vis[i][j] = false;
            }
        }
        spfa();

        memset(dp, 0, sizeof(dp));
        dp[n][n] = 1;

        printf("%lld
", dfs(1, 1));        
    }
    return 0;
}