leetcode-120-Triangle 动态规划

问题

题目：[leetcode-120]

思路

搜索是可以实现的，但是显然复杂度在指数级别。是否能用DP，考虑如下两个条件是否满足。

• 最优子结构
• 重叠子问题

这个题目首先有明显的重叠子问题现象。所以可以考虑用DP解题。DP最关键的另外一个因素是，是否具有最优子结构。可以进行如下的分析，不妨在某个状态设出最优解。

$$设运行到节点a(i,j)的最短路径长度为dp[i][j]$$
那么显然当 j != 0 && j != i时，
$$dp[i][j] = min( dp[i-1][j-1] , dp[i-1][j] ) +a[i][j]$$
那么，现在就只需判断两个子问题的解是否为最优解，可以模仿算法导论流水线的例题，用反证法。

反证法证明如下：
假设dp[i][j]来自于dp[i-1][j-1]，并且dp[i-1][j-1]并不是运行到节点a(i-1,j-1)的最短路径。那么只需用运行到节点dp[i-1][j-1]的最短路径替换当前的路径，那么便可以得到到达dp[i][j]的一条更短的路径。这与dp[i][j]是运行到节点a[i][j]的最短路径相互矛盾。所以，原假设不成立，即dp[i-1][j-1]是到达节点a[i-1][j-1]的最短路径。同理，可证如果dp[i][j]来自于dp[i-1][j]那么，dp[i-1][j]是运行到节点a[i-1][j]的最短路径。从而，也满足最优子条件的限制。

下面，可以确定用DP的方法实现。四步走，其中，a[i][j]代表节点(i,j)的值：
1. 状态定义

$$dp[i][j]表示运行到节点a[i][j]的最短路径$$
2. 转移函数
$$dp[i][j]=\left\{ \begin{aligned} dp[i-1][j] + a[i][j], &&j = 0 \\ dp[i-1][j-1] + a[i][j], &&j = i \\ \min( dp[i-1][j-1], dp[i-1][j]) + a[i][j], && j > 1 \\ \end{aligned} \right. \tag{1}$$
3. 初始化
$$dp[0][0] = a[0][0]\tag{2}$$
4. 打表

代码(c++实现)

//c++ version
class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {

        int row = triangle.size();
        if( !row )
            return -1;

        int** dp = new int*[row]; // minimum path to a(i,j)
        if( !dp )
            return -1;
        for( int i = 0; i < row; ++i )
        {
            dp[i] = new int[i+1];
            if( !dp[i] )
                return -1;
        }

        dp[0][0] = triangle[0][0];
        for( int i = 1; i < row; ++i )
        {
            for( int j = 0; j <= i; ++j )
            {
                if( !j )
                    dp[i][j] = dp[i-1][j] + triangle[i][j];
                else if( j == i )
                    dp[i][j] = dp[i-1][j-1] + triangle[i][j];
                else
                    dp[i][j] = std::min( dp[i-1][j-1] , dp[i-1][j] ) + triangle[i][j];
            }
        }

        int min = dp[row-1][0];
        for( int j = 1; j < row; ++j )
        {
            if( dp[row-1][j] < min )
                min = dp[row-1][j];
        }

        for( int i = 0; i < row; ++i )
        {
            delete [] dp[i];
        }
        delete [] dp;

        return min;
    }
};

c实现的时候，每次要把参数分析好。*triangleColSizes数组给出的是每个一维数组的大小。

代码1(c实现)

//c version
int minimumTotal(int** triangle, int triangleRowSize, int *triangleColSizes){

    int** dp = (int**)malloc( sizeof(int*) * triangleRowSize );
    if( !dp )
        return -1;

    for( int i = 0; i < triangleRowSize; ++i )
    {
        dp[ i ] = (int*)malloc( sizeof(int) * triangleColSizes[i] );
        if( !dp[i] )
            return -1;
    }

    dp[0][0] = triangle[0][0];
    for( int i = 1; i < triangleRowSize; ++i )
    {
        for( int j = 0; j < triangleColSizes[i]; ++j )
        {
            if( !j )
                dp[i][j] = dp[i-1][j] + triangle[i][j];
            else if( j == triangleColSizes[i] - 1 )
                dp[i][j] = dp[i-1][j-1] + triangle[i][j];
            else
                dp[i][j] = ( dp[i-1][j-1] < dp[i-1][j] )?( dp[i-1][j-1] + triangle[i][j] ):( dp[i-1][j] + triangle[i][j] );
        }
    }

    int min = dp[triangleRowSize-1][0];
    for( int j = 1; j < triangleColSizes[triangleRowSize-1]; ++j )
    {
        if( dp[triangleRowSize-1][j] < min )
            min = dp[triangleRowSize-1][j];
    }


    for( int i = 0; i < triangleRowSize; ++i )
    {
            free(dp[i]);
    }

    free(dp);

    return min;
}

---

下面补充一道一样的题目，只不过这次我给出了从暴力搜索到记忆化搜索再到动态规划的全部过程。
题目链接：[poj-1163]

代码1（暴力搜索）

思路简单，dfs即可。

int dfs( int i, int j, int row_num )
{
    if( i == row_num - 1 )
        return arr[i][j];
    else
    {
        return arr[i][j] + std::max( dfs( i+1, j, row_num ), dfs( i+1, j+1, row_num ) );
    }
}

代码2（记忆化搜索-备忘录）

做备忘录的时候，是在递归的基础上修改。在边界条件的时候，没有记忆的必要，所以此时不记忆。

int dfs_memo( int i, int j, int row_num )
{
    if( i == row_num - 1 )// 边界不记忆
        return arr[i][j];
    else
    {
        if( dp[i][j] > 0 )
            return dp[i][j];
        else
        {
            dp[i][j] = arr[i][j] + std::max( dfs_memo( i + 1, j, row_num ), dfs_memo( i + 1, j + 1, row_num ) );
            return dp[i][j];
        }
    }
}

代码3（记忆化搜过-备忘录）

这个代码我是参考了白书的代码，刘汝佳的思路是所有位置都记忆。所以上来先判断是否有效，如果有效直接返回。然后无效状态，计算的时候再分边界条件和地规模式去计算。注意，递归计算的也一定是有效状态，边界条件只不过是边界的有效状态，但是它也是有效状态。

int dfs_memo1( int i, int j, int row_num )
{
    if( dp[i][j] > 0 )// 记忆
        return dp[i][j];
    else// 无记忆
        return dp[i][j] = arr[i][j] + ( (i == row_num - 1)?0:std::max( dfs_memo1( i + 1, j, row_num ), dfs_memo1( i + 1, j + 1, row_num) ) );
}

代码4（动态规划）

状态定义不同导致了计算方向的不同，但是本质都是自底向上。

int solve( int row_num )
{
    /* 1.状态定义: dp[i][j]表示从(0,0)到(i,j)的最长路径
     * 2.转移函数: dp[i][j] = arr[i][j] + max( dp[i-1][j-1], dp[i-1][j] )
     *
     * */


    // 3.初始化
    dp[0][0] = arr[0][0];
    for( int i = 1; i < row_num; ++i )
    {
        dp[i][0] = dp[i-1][0] + arr[i][0];
        dp[i][i] = dp[i-1][i-1] + arr[i][i];    
    }

    // 4.打表
    for( int i = 2; i < row_num; ++i )
    {
        for( int j = 1; j < i; ++j )
        {
            dp[i][j] = arr[i][j] + std::max( dp[i-1][j-1], dp[i-1][j] );
        }
    }


    int max = dp[row_num-1][0];
    for( int i = 1; i < row_num; ++i )
    {
        if( dp[row_num - 1][i] > max )
            max = dp[row_num - 1][i];
    }


    return max;
}

代码5（动态规划）

int solve1( int row_num )
{
    /* 1.状态定义: dp[i][j]表示从(i,j)到最地段的最长路径
     * 2.转移函数: dp[i][j] = arr[i][j] + max( dp[i-1][j-1], dp[i-1][j] )
     *
     * */

    // 初始化
    for( int i = 0; i < row_num - 1; ++i )
    {
        dp[row_num - 1][i] = arr[ row_num - 1 ][i];
    }
    // 打表
    for( int i = row_num - 2; i >= 0; --i )
    {
        for( int j = 0 ; j <= i; ++j )
        {
            dp[i][j] = arr[i][j] + std::max( dp[i+1][j], dp[i+1][j+1] );
        }
    }

    return dp[0][0];
}

思路1

DP的思路不变，只是在空间上可以考虑滚动数组的优化。
因为，每个状态值依赖于右侧和当前的状态，所以从左侧开始更新即可。

代码6

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle){
        int n = triangle.size();
        std::vector<int> dp(n);
        for(int j = 0; j < n; ++j){
            dp[j] = triangle[n-1][j];
        }
        for(int i = n-2; i >= 0; --i){
            for(int j = 0; j < n; ++j){
                dp[j] = triangle[i][j] + std::min(dp[j], dp[j+1]);
            }
        }
        return dp[0];
    }
};