csu1106 记忆化搜索+最短路

/*
   中文题意就不说了，就是求最短路，从左上角到右下角的最短路的条数。
   思路：因为他是要对称走的话，我们可以这样考虑，将正方形对折。把他们
   的权值加起来。
   然后从右下角到对角线的就是从右下角到左上角按对称走的最短路径了。
   然后求出（n,n）点到其他点的最短路径，然后记忆化搜索，搞一下，就能过了

*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
using namespace std;
#define INF 999999999
#define MOD 1000000009
struct node
{
    int x,y;
};
int map[250][250];
int map1[250][250];
int dis[250][250];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
int dp[250][250];
int n;
int jude(int x,int y)
{
    if(x<1||x>n||y<1||y>n) return 0;
    return 1;
}
void SPFA()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            dis[i][j]=INF;
        }
    }
    dis[n][n]=map1[n][n];
    queue<node>q;
    node a={n,n};
    q.push(a);
    while(!q.empty())
    {
        a=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            int xx=dir[i][0]+a.x;
            int yy=dir[i][1]+a.y;
             if(!jude(xx,yy)) continue ;
            if(map1[xx][yy]==0) continue ;

            if(dis[a.x][a.y]!=INF&&dis[a.x][a.y]+map1[xx][yy]<dis[xx][yy])
            {
                dis[xx][yy]=dis[a.x][a.y]+map1[xx][yy];
                node b={xx,yy};
                q.push(b);
            }
        }
    }
}
int dfs(int x,int y)
{   //printf("%d %d\n",x,y);
    if(dp[x][y]!=-1) return dp[x][y];
    int c=0;
    for(int i=0;i<4;i++)
    {
        int xx=x+dir[i][0];
        int yy=y+dir[i][1];
        if(!jude(xx,yy)) continue ;
        if(dis[xx][yy]==INF) continue;
        if(dis[x][y]-map1[x][y]!=dis[xx][yy]) continue;
            //可以走的点必须是从那个点走过来的权值加上本身的权值等于最短路径的即可
            c=(c%MOD+dfs(xx,yy)%MOD)%MOD;
    }
    dp[x][y]=c;
    return dp[x][y];
}
int main()
{
    while(scanf("%d",&n)&&n)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                scanf("%d",&map[i][j]);
            }
        }
        memset(map1,0,sizeof(map1));
        for(int i=n;i>=1;i--)
        {
            for(int j=n-i+2;j<=n;j++)
            {
                map1[i][j]=map[i][j]+map[n-j+1][n-i+1];
               // printf("%d %d %d %d\n",i,j,n-j+1,n-i+1);//将正方形对折
            }
        }
        for(int i=n;i>=1;i--)
        {
              map1[i][n-i+1]=map[i][n-i+1];
        }
        SPFA();//求最短路
        memset(dp,-1,sizeof(dp));
        int min1=INF;
        dp[n][n]=1;
        for(int i=n;i>=1;i--)
        {

            if(min1>dis[i][n-i+1]) min1=dis[i][n-i+1];
            dfs(i,n-i+1);//记忆化搜索路径
        }
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            if(min1==dis[i][n-i+1])//当路径是最小的则累加他的路径条数
            {
                sum=(sum%MOD+dp[i][n-i+1]%MOD)%MOD;
            }
        }
        printf("%d\n",sum);
    }

}