UVa 10913 - Walking on a Grid（dp递推变形）

u010660276

于 2015-08-02 20:59:33 发布

阅读量399

点赞数 1

分类专栏：动态规划

本文链接：https://blog.csdn.net/u010660276/article/details/47211049

版权

动态规划专栏收录该内容

121 篇文章 1 订阅

订阅专栏

Walking on a Grid
题意：从（1,1）走到（N,N），只能向右向左向下走，每个格子只能走一遍，并且负数格子的个数有限制，问最大能得到的值是多少
思路：因为走过的不能走，所以可以对于每一行处理一个L，R数组，分别表示该行从左往右，和从右往左到达当前格子的最大值是多少，那么对于这一行的取值肯定就是从这两个值中选个大的

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=80;
const int INF=0x3f3f3f3f;
int a[maxn][maxn];
int dp[maxn][maxn][10];
int N,K;
int L[maxn][10],R[maxn][10];
int main()
{
    int cas=1;
    while(scanf("%d%d",&N,&K)!=EOF,N+K)
    {
        for(int i=1;i<=N;i++)
            for(int j=1;j<=N;j++)scanf("%d",&a[i][j]);

        for(int i=0;i<=N;i++)
            for(int j=0;j<=N;j++)
                for(int k=0;k<=K;k++)dp[i][j][k]=-INF;

        if(a[1][1]>=0)dp[1][1][0]=a[1][1];
        else dp[1][1][1]=a[1][1];
        for(int i=2;i<=N;i++)
        {
            int flag=a[1][i]<0?1:0;
            for(int k=0;k<=K;k++)
                if(dp[1][i-1][k]!=-INF)
                    dp[1][i][k+flag]=dp[1][i-1][k]+a[1][i];
        }
        for(int i=2;i<=N;i++)
        {
            for(int j=0;j<=N;j++)
                for(int k=0;k<=K;k++)L[j][k]=R[j][k]=-INF;
            for(int j=1;j<=N;j++)
            {
                int flag=a[i][j]<0?1:0;
                for(int k=0;k<=K;k++)
                    if(j==1)
                    {
                        if(dp[i-1][j][k]!=-INF)
                            L[j][k+flag]=dp[i-1][j][k]+a[i][j];
                    }    
                    else
                    {
                        if(L[j-1][k]>-INF)
                            L[j][k+flag]=max(L[j][k+flag],L[j-1][k]+a[i][j]);
                        if(dp[i-1][j][k]>-INF)
                            L[j][k+flag]=max(L[j][k+flag],dp[i-1][j][k]+a[i][j]);
                    }

            }
            for(int j=N;j>=1;j--)
            {
                int flag=a[i][j]<0?1:0;
                for(int k=0;k<=K;k++)

                    if(j==N)
                    {
                        if(dp[i-1][j][k]!=-INF)
                            R[j][k+flag]=dp[i-1][j][k]+a[i][j];
                    }
                    else
                    {
                        if(R[j+1][k]>-INF)
                            R[j][k+flag]=max(R[j][k+flag],R[j+1][k]+a[i][j]);
                        if(dp[i-1][j][k]>-INF)
                            R[j][k+flag]=max(R[j][k+flag],dp[i-1][j][k]+a[i][j]);
                    }
            }
            for(int j=1;j<=N;j++)
                for(int k=0;k<=K;k++)
                    dp[i][j][k]=max(L[j][k],R[j][k]);
        }
        int ans=-INF;
        for(int i=0;i<=K;i++)
            ans=max(ans,dp[N][N][i]);
        printf("Case %d: ",cas++);
        if(ans==-INF)printf("impossible\n");
        else printf("%d\n",ans);
    }
    return 0;
}