HDU1619（动态规划记录路径）

 思路：利用动态规划的思想将输入矩阵的dp矩阵记录下来，用结构体来存储dp矩阵，并且将每个元素的前驱结点记录下来。

将所有最小权值路径记录下来，从尾节点到头结点进行回溯，用stk数组记录路径下标，倒序输出。

#include
#include
#include
#include
#include
using namespace std;
const int maxn=12;
const int maxm=102;
struct node
{
    int path;
    int pre;
} dp[maxn][maxm];
struct stak
{
    int fat[maxm];//存放下标
} stk[maxn];
int mapp[maxn][maxm];
int n,m;
int dir[3],p,maxp,q;
int record[maxn];
bool cmp(stak a,stak b)
{
    for(int i=0; i=n)
                    dir[k]%=n;
            }//解决下标越界的问题
            p=dir[0];
            maxp=dp[p][j-1].path;//最小值而不是最大值
            for(int k=0; k<3; k++)
            {
                q=dir[k];
                if(maxp>dp[q][j-1].path)
                {
                    maxp=dp[q][j-1].path;
                    p=q;
                }
                else if(maxp==dp[q][j-1].path&&qdp[i][m-1].path)
        {
            p=i;
            maxp=dp[i][m-1].path;
        }

    }//p是最小值的第一个下标
    for(int i=0; i=0; i--)
        {
            printf("%d",stk[0].fat[i]+1);
            if(i)
                printf(" ");
        }
        printf("\n%d\n",maxp);
    }
    return 0;
}

推荐学习其他大佬的博客：https://blog.csdn.net/V5ZSQ/article/details/48877963

总结：1.大佬的博客的优势在于倒着计算dp矩阵，这样在更新二维数组的同时可以解决字典序的问题。

2.程序中用于解决下标越界的语句段可以用更好的形式表达：

            for(int k=0; k<3; k++)
            {
               dir[k]=(dir[k]+n)%n;
            }//解决下标越界的问题

3.大佬的博客也给了其他的借鉴：一个位置的前驱结点使用二维数组存储也很方便。如：path[maxn][maxm]