hdu 1428 漫步校园 优先队列BFS +记忆化搜索

参考：http://blog.sina.com.cn/s/blog_7fec44cf0100ypaq.html

题意：从（１，１）点开始走，终点是（n , n），每走一步都要保证距离终点最近，如果和A区域相邻的四个区域离（n，n）点，比A点离（n，n）点更近，那么就可以走，求到终点的方案数。

思路：如何判断一个点是否离终点更近？用优先队列的BFS求终点到其它各个点的最短距离，并保存在数组中。(n,n)到(n,n)的方案数是1，从（1，1）点开始搜，如果一个点到终点的方案数已经求出，那么就不用再搜了，直接加就行。

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
struct point {
    int x , y;
    int step;    
    bool friend operator < (const point a , const point b) {
        if(a.step > b.step) return 1;
        return 0;    
    }
};
int n , cnt;
int dir[4][2] = {{-1,0},{1,0},{0,1},{0,-1}};
bool vis[60][60];
int map[60][60];
void bfs() {
    priority_queue<point> Q;
    point start , node;
    start.x = n;
    start.y = n;
    start.step = map[n][n];
    vis[n][n] = 1;
    Q.push(start);
    while(!Q.empty()) {
        start = Q.top();
        Q.pop();
        for(int k = 0 ; k < 4 ; k ++) {
            int xx = start.x + dir[k][0];
            int yy = start.y + dir[k][1];
            if(xx >= 1 && xx <= n && yy >= 1 && yy <= n && !vis[xx][yy]) {
                vis[xx][yy] = 1;
                node.x = xx;
                node.y = yy;
                node.step = start.step + map[xx][yy];
                map[xx][yy] += map[start.x][start.y];   //优先队列求出其它点到(n,n)的最短距离 
                Q.push(node);    
            }    
        }    
    }               
}
__int64 ans[60][60];
__int64 dfs(int i , int j) {            //记忆化搜索ans数组保存到终点的方案数 
    //printf("i = %d , j = %d\n",i,j);
    if(ans[i][j] > 0) return ans[i][j];
    for(int k = 0 ; k < 4 ; k ++) {
        int xx = i + dir[k][0];
        int yy = j + dir[k][1];
        if(xx >= 1 && xx <= n && yy >= 1 && yy <= n) {
            if(map[xx][yy] < map[i][j])
            ans[i][j] += dfs(xx , yy);
        }    
    }
    return ans[i][j];                
}
int main() {
    int i , j;
    while(scanf("%d",&n)!=EOF) {
        for(i = 1 ; i <= n ; i ++)
            for(j = 1 ; j <= n ; j ++) 
            scanf("%d",&map[i][j]);
            memset(vis,0,sizeof(vis));
            bfs();
            memset(ans,0,sizeof(ans));
            ans[n][n] = 1;
            dfs(1 , 1);
            printf("%I64d\n",ans[1][1]);        
    }    
}