UVA

题意：

给你一个n，然后给你一个n*n的正方形w[i][j]，你需要找到一个从(1,1)点走到(n,n)点的最短路径数量。而且这个路径必须按照y=x对称

题解：

我们把左上角的点当作(0,0)点，右下角的点当作(n,n)点

因为路径必须按照y=x堆成，那么我们可以按照y=x这一条线对折，然后正方形就变成了三角形，我们把对折成三角形后两点在同一位置的值相加，比如(1,1)和（n，n）对折后在一个位置，那么我们就让w[1][1]+=w[n][n]（这里我们保留左上部分）。

然后你按照左上部分从(0,0)点只要走到对称线y=x的点上，这就是一个从左上角到右下角的一条路径（可以想一想）

那么我们就可以对这个上半部分的三角形就行bfs式的最短路遍历

代码：

fill函数的作用是：将一个区间的元素都赋予val值。函数参数：fill(vec.begin(), vec.end(), val); val为将要替换的值。

#include <cstdio>
#include <cstring>
#include <cctype>
#include<queue>
#include<vector>
#include <algorithm>
using namespace std;
const int maxn=105;
const int INF=1e9+10;
const int mod=1e9+9;
typedef long long LL;
int n,dp[maxn][maxn],w[maxn][maxn],counts[maxn][maxn];
//dp[x][y]求的是从（0，0）点到（x，y）点的最短路径值（也就是最短路）
//counts[x][y]求的是从（0，0）点到（x，y）点的最短路径数量
int p[4][2]=
{
    {1,0},
    {0,1},
    {-1,0},
    {0,-1}
};
struct shudui
{
    int x,y,lx,ly,dis;
    shudui() {}
    shudui(int x,int y,int lx,int ly,int dis)
    {
        this->x=x;
        this->y=y;
        this->lx=lx;
        this->ly=ly;
        this->dis=dis;
    }
    bool operator < (const shudui a)const
    {
        return a.dis<dis;
    }
} str1;
priority_queue<shudui>r;
void JK()
{
    for(int i=0; i<maxn; ++i)
        fill(dp[i],dp[i]+maxn,mod);
    counts[0][0]=1;
    r.push(shudui(0,0,0,0,w[0][0]));
    while(!r.empty())
    {
        str1=r.top();
        r.pop();
        int x=str1.x;
        int y=str1.y;
        int lx=str1.lx;
        int ly=str1.ly;
        int dis=str1.dis;
        if(dp[x][y]>dis)
        {
            dp[x][y]=dis;
            counts[x][y]=counts[lx][ly];
        }
        else if(dp[x][y]==dis)
        {
            counts[x][y]=(counts[x][y]+counts[lx][ly])%mod;
            continue;
        }
        else continue;

        if(x+y>=n-1) continue;
        for(int i=0; i<4; ++i)
        {
            int xx=x+p[i][0];
            int yy=y+p[i][1];
            if(xx<n && yy<n && xx>=0 && yy>=0)
            {
                r.push(shudui(xx,yy,x,y,dis+w[xx][yy]));
            }
        }
    }
}
int main()
{
    while(~scanf("%d",&n) && n)
    {
        for(int i=0; i<n; ++i)
        {
            for(int j=0; j<n; ++j)
            {
                scanf("%d",&w[i][j]);
            }
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n-i-1; j++)
            {
                w[i][j] += w[n-j-1][n-i-1];
            }
        }
        JK();
        int minn=mod;
        for(int i=0; i<n; ++i)
        {
            minn=min(minn,dp[i][n-i-1]);
        }
        int ans=0;
        for(int i=0; i<n; ++i)
        {
            if(dp[i][n-i-1]==minn)
            {
                ans=(ans+counts[i][n-i-1])%mod;
            }
        }
        printf("%d
",ans);
    }
    return 0;
}