单向 DSP 【UVA - 116】【DP+输出路径】

题目链接

题目大意

有一个n*m的带权方格，第一行和最后一行是连通的，一个人想从第一列走到最后一列用最小的花费，他每次可以从第i列走到第i+1列，方向是向右或者向右上方或者右下方。输出最小的花费和路径，路径要求是字典序最小的。

解题思路

转移方程是很好写的，就是三个方向转移一下，不好搞的是那个路径，要自字典序最小，所以我们要从后往前，从最后一列开始转移，这样比较好控制，从第一列开始的话，我们记录的是你字典序最小的（wa到怀疑人生）

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int maxn=105,maxm=1005;
int e[maxn][maxm],dp[maxn][maxm],path[maxn][maxm];
int n,m;
struct node
{
    int a[105];
};
node aa[maxn*100];
int cmp(node x,node y)
{
    for(int i=0; i<m; i++)
        if(x.a[i]!=y.a[i])
            return x.a[i]<y.a[i];
}
int main()
{

    while(~scanf("%d %d",&n,&m))
    {
        memset(dp,0,sizeof(dp));
        memset(path,-1,sizeof(path));
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
                scanf("%d",&e[i][j]);
        for(int i=1; i<=n; i++)
            dp[m][i]=e[i][m];
        for(int i=m-1; i>=1; i--)
        {
            for(int j=1; j<=n; j++)
            {
                //dp[i][j]=e[j][i]+(min(min(dp[i-1][n],dp[i-1][j]),dp[i-1][j+1]));
                if(j==1)
                {
                    dp[i][j]=e[j][i]+dp[i+1][j];
                    path[i][j]=j;
                    if(j+1<n&&dp[i][j]>e[j][i]+dp[i+1][j+1])
                    {
                        path[i][j]=j+1;
                        dp[i][j]=e[j][i]+dp[i+1][j+1];
                    }
                    if(dp[i][j]>e[j][i]+dp[i+1][n])
                    {
                        dp[i][j]=e[j][i]+dp[i+1][n];
                        path[i][j]=n;
                    }
                }

                // dp[i][j]=e[j][i]+(min(min(dp[i-1][1],dp[i-1][j]),dp[i-1][j-1]));
                else if(j==n)
                {
                    dp[i][j]=e[j][i]+dp[i+1][1];
                    path[i][j]=1;
                    if(dp[i][j]>e[j][i]+dp[i+1][j-1]&&j-1>1)
                    {
                        dp[i][j]=e[j][i]+dp[i+1][j-1];
                        path[i][j]=j-1;
                    }
                    if(dp[i][j]>e[j][i]+dp[i+1][j])
                    {
                        dp[i][j]=e[j][i]+dp[i+1][j];
                        path[i][j]=j;
                    }
                }
                //dp[i][j]=e[j][i]+(min(min(dp[i-1][j],dp[i-1][j+1]),dp[i-1][j-1]));
                else
                {
                    dp[i][j]=e[j][i]+dp[i+1][j-1];
                    path[i][j]=j-1;
                    if(dp[i][j]>e[j][i]+dp[i+1][j])
                    {
                        dp[i][j]=e[j][i]+dp[i+1][j];
                        path[i][j]=j;
                    }
                    if(dp[i][j]>e[j][i]+dp[i+1][j+1]&&j+1<=n)
                    {
                        dp[i][j]=e[j][i]+dp[i+1][j+1];
                        path[i][j]=j+1;
                    }
                }
            }
        }
        int ans=0x3f3f3f3f,k;
        for(int i=1; i<=n; i++)
        {
            if(ans>dp[1][i])
            {
                ans=dp[1][i];
                k=i;
            }
        }
        printf("%d",k);
        for(int j=1; j<m; j++)
        {
            k=path[j][k];
            printf(" %d",k);
        }
        printf("\n%d\n",ans);
    }
    return 0;
}
/*
5 7
3 6 4 6 4 9 2
9 9 1 4 7 9 6
4 2 3 0 1 4 0
9 8 2 6 7 0 2
4 2 5 0 2 1 5
*/