LeetCode120-Traingle & Hdu2084數塔問題(簡單dp)

• 遞迴
• 二維dp
• 一維dp
• Hdu2084數塔問題

題目連結

題目

遞迴

遞迴的思路是從上到下：

• 遞迴函式有兩個主要的引數，記錄行和列，表示當前行的位置是matrix[r][c]，要向下去求最小路徑；
• 如果行 r == n，說明不需要向下求，則直接返回matrix[r][c]；
• 否則先給我遞迴求出從matrix[r+1][c]求出的最大路徑，和從matrix[r+1][c+1]的最大路徑，我取最大的，和自己相加即可；
• 然後用二維陣列map記憶化即可；

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        if(triangle == null || triangle.size() == 0 || triangle.get(0).size() == 0)
            return 0;
        int[][] map = new int[triangle.size()][triangle.get(triangle.size()-1).size
 
()];
        return process(triangle,0,0,triangle.size()-1,map);
    }

    // 遞迴
    private int process(List<List<Integer>>triangle,int r,int c,int level,int[][] map){
        if(r == level)
            return triangle.get(r).get(c);
        if(map[r][c] != 0)
            return map[r][c];
        int
 
 ele = triangle.get(r).get(c);
        map[r][c] = Math.min(
              ele + process(triangle,r+1,c,level,map),
              ele + process(triangle,r+1,c+1,level,map)
        );
        return map[r][c];
    }
}

二維dp

dp就是記憶化的反方向，從下到上求解:

• 初始化最後一行的就是本來的值，代表的就是從這一行往下不需要求了；
• 然後就是往上遞推即可，搭積木。。；

class Solution {
     public int minimumTotal(List<List<Integer>> triangle) {
        if(triangle == null || triangle.size() == 0 || triangle.get(0).size() == 0)
            return 0;

        int r = triangle.size();
        int c = triangle.get(triangle.size()-1).size();

        int[][] dp = new int[r][c];

        for(int j = 0; j < c; j++)
            dp[r-1][j] = triangle.get(r-1).get(j);

        for(int i = r-2; i >= 0; i--){
            for(int j = 0;j <= i; j++){// 或 for(int j = i;j >= 0; j--){
                dp[i][j] = triangle.get(i).get(j)+Math.min(dp[i+1][j],dp[i+1][j+1]);
            }
        }
        return dp[0][0];
    }
}

一維dp

滾動優化也需要注意滾動的方向：

• 因為dp[i][j]依賴 dp[i+1][j] 和dp[i+1][j+1]，所以不能先更新dp[i+1][j+1]；
• 所以滾動的方向是從j = i 到j = 0；

class Solution {
     public int minimumTotal(List<List<Integer>> triangle) {
        if(triangle == null || triangle.size() == 0 || triangle.get(0).size() == 0)
            return 0;

        int r = triangle.size();
        int c = triangle.get(triangle.size()-1).size();

        int[] dp = new int[c];

        for(int j = 0; j < c; j++)
            dp[j] = triangle.get(r-1).get(j);

        for(int i = r-2; i >= 0; i--){
            for(int j = 0;j <= i ; j++){ //不能寫出 j = i ; j >= 0 ; j--
                dp[j] = triangle.get(i).get(j)+Math.min(dp[j],dp[j+1]);
            }
        }
        return dp[0];
    }
}

Hdu2084數塔問題

題目連結

就是從求最小路徑和變成求最大路徑和，思想沒變。

import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * 數塔問題
 * 題目連結 : http://acm.hdu.edu.cn/showproblem.php?pid=2084
 */
public class Main {

    // 方法一: 記憶化遞迴
    public static int maxPath(int[][] matrix,int n){
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0)
            return 0;
        int[][] map = new int[n][n]; //注意這裡
        return process(matrix,0,0,n-1,map);
    }
    public static int process(int[][] matrix,int r,int c,int n,int[][] map){
        if(r == n)
            return matrix[r][c];

        if(map[r][c] != 0)
            return map[r][c];

        map[r][c] = matrix[r][c] + Math.max(process(matrix,r+1,c,n,map),
                process(matrix,r+1,c+1,n,map)
        );

        return map[r][c];
    }


    // 二維dp
    public static int maxPath2(int[][] matrix,int n){
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0)
            return 0;
        int[][] dp = new int[n][n];

        for(int j = 0; j < n; j++)
            dp[n-1][j] = matrix[n-1][j];

        for(int i = n-2; i >= 0; i--){
            for(int j = 0; j <= i; j++){
                dp[i][j] = matrix[i][j] + Math.max(dp[i+1][j],dp[i+1][j+1]);
            }
        }
        return dp[0][0];
    }

    //一維dp
    public static int maxPath3(int[][] matrix,int n){
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0)
            return 0;
        int[] dp = new int[n];

        for(int j = 0; j < n; j++)
            dp[j] = matrix[n-1][j];

        for(int i = n-2; i >= 0; i--){
            for(int j = 0; j <= i; j++){// 不能寫出for(int j = i ; j >= 0; j--)
                dp[j] = matrix[i][j] + Math.max(dp[j],dp[j+1]);
            }
        }
        return dp[0];
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        int C = cin.nextInt();
        while(C-- > 0){
            int n = cin.nextInt();
            int[][] matrix = new int[n][n];
            for(int i = 0; i < n; i++){
                for(int j = 0; j <= i; j++){
                    int x = cin.nextInt();
                    matrix[i][j] = x;
                }
            }
//            System.out.println(maxPath(matrix,  n));
//            System.out.println(maxPath2(matrix, n));
            System.out.println(maxPath3(matrix, n));
        }
    }
}