多阶段决策问题(UVa 116)

在回溯法中，每个决策对应于给一个节点产生新的子树，而解的生成过程对应一颗解答树，节点的层数就是下一个待填充位置$cur$。

在多阶段决策的最优化问题，大多可以用dp解决，状态转移则类似于回溯法中的解答树。

UVa 116

$d(i,j)$表示从第此处出发到达最后一列的最小和，要求字典序最小，就同时要记录行号的最小值。

代码：

//
//  main.cpp
//  UVa 116
//
//  Created by Yanbin GONG on 12/3/2018.
//  Copyright © 2018 Yanbin GONG. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <cmath>

using namespace std;

int m,n;
int cell[15][105];
int d[15][105];
int path[15][105]; //记录从该处应该走到的下一个点
int tmp;
int ans;
int startNode;
//int updown[3] = {-1,0,1}; 写在dp中，方便改变状态，满足在上下边时候的移动


int main(){
    while(cin>>n>>m){
        memset(d,0x3f,sizeof(d));
        ans = 0x3f3f3f3f;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                cin>>cell[i][j];
            }
            d[i][m] = cell[i][m];//初始化边界
        }
        //dp
        for(int j=m;j>1;j--){
            
            for(int i=1;i<=n;i++){
                int updown[3] = {i-1,i,i+1}; //表示接下来处在的行
                if(i==1) updown[0] = n;
                if(i==n) updown[2] = 1;
                //排序找到最小字典序的核心代码！因为这个WA了
                sort(updown,updown+3); //排序找到最小字典序的核心代码！因为这个WA了
                //排序找到最小字典序的核心代码！因为这个WA了
                for(int k=0;k<3;k++){
                    tmp = d[i][j] + cell[updown[k]][j-1]; //到[][j-1]的总成本
                    if(tmp<d[updown[k]][j-1]){
                        d[updown[k]][j-1] = tmp;
                        path[updown[k]][j-1] = i;//反向记录从[][j-1]走到[i][j]
                    }
                }
            }
        }
        //找到最优解的开始
        for(int i=1;i<=n;i++){
            if(ans>d[i][1]){
                ans = d[i][1];
                startNode = i;
            }
        }
        //print
        printf("%d",startNode);
        int nextNode = path[startNode][1];
        for(int j=1;j<=m;j++){
            printf(" %d",nextNode);
            nextNode = path[nextNode][j];
        }
        printf("\n%d\n",ans);
    }
    return 0;
}

这题要注意将$updown$更新后重新排序一遍，这样才能确定找到的字典序是最小的