uva12295 Optimal Symmetric Paths(bfs+记忆化搜索)

题目链接

题意：有个n*m的图，每个点都有权值，求从(1,1)走到(n,n)有最小权值的路径的方案数，要求路径必须沿次对角线对称

思路：由于题目要求路径必须沿次对角线对称，那么就可以把以次对角线对称的点的权值加过来，这样只用求(1,1)到对角线的最小权路径方案数即可，就不用考虑对称的问题

然后考虑如何限制路径，我们可以先求出(1,1)到每一点经过路径的最小权dp[i][j]，然后以找出对角线上的最小权值进行记忆化搜索，找它到(1,1)的方案数，加起来即为所求

注意记忆化搜索时路径是有限制的，只有dp[vx][vy]+e[x][y]==dp[x][y]时，才能继承v的状态

#include<bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
const int N=105;
const int INF=0x3f3f3f3f;
const int mod=1e9+9;
typedef long long ll;
ll n,e[N][N],dp[N][N],go[4][2]={1,0,0,1,-1,0,0,-1},step[N][N];
struct node
{
    node(){}
    node(ll xx,ll yy,ll ww)
    {
        x=xx,y=yy,w=ww;
    }
    ll x,y,w;
    bool operator < (const node&A)const
    {
        return w>A.w;
    }
};
void bfs(ll x,ll y)
{
    priority_queue<node>q;
    q.push(node(x,y,e[x][y]));
    while(!q.empty())
    {
        node u=q.top();
        q.pop();
        if(dp[u.x][u.y]<u.w)continue;
        for(ll i=0;i<4;i++)
        {
            ll tx=u.x+go[i][0];
            ll ty=u.y+go[i][1];
            if(tx>=1&&tx<=n&&ty>=1&&ty<=n-tx+1)
            {
                if(u.w+e[tx][ty]<dp[tx][ty])
                {
                    dp[tx][ty]=u.w+e[tx][ty];
                    q.push(node(tx,ty,dp[tx][ty]));
                }
            }
        }
    }
}
ll dfs(ll x,ll y)
{
    if(step[x][y])return step[x][y];
    ll sum=0;
    for(ll i=0;i<4;i++)
    {
        ll tx=x+go[i][0];
        ll ty=y+go[i][1];
        if(tx>=1&&tx<=n&&ty>=1&&ty<=n-tx+1&&dp[x][y]==dp[tx][ty]+e[x][y])
        {
            sum=(sum+dfs(tx,ty))%mod;
        }
    }
    return step[x][y]=sum;
}
int main()
{
    while(cin>>n)
    {
        if(!n)break;
        for(ll i=1;i<=n;i++)
            for(ll j=1;j<=n;j++)
            cin>>e[i][j];
        for(ll i=1;i<=n;i++)
        for(ll j=1;j<=n;j++)
        {
            if(i==n-j+1)continue;
            e[i][j]+=e[n-j+1][n-i+1];
        }
            mem(dp,INF);
            mem(step,0);
            dp[1][1]=e[1][1];
            bfs(1,1);//求出(1,1)到每一点的最小权
            step[1][1]=1;
         ll minn=INF,ans=0;
         for(ll i=1;i<=n;i++)
            minn=min(dp[i][n+1-i],minn);
         for(ll i=1;i<=n;i++)//找出对角线上最小的点进行记忆化搜索
         {
             if(dp[i][n-i+1]==minn)
                ans=(ans+dfs(i,n-i+1))%mod;
         }
         cout<<ans<<endl;
    }
    return 0;
}