LintCode1884拿走瓶子-区间型动态规划

RedJACK~

已于 2022-12-21 08:44:50 修改

阅读量413

点赞数 1

分类专栏： LeetCode 文章标签：动态规划算法 leetcode

于 2022-12-21 08:40:15 首次发布

本文链接：https://blog.csdn.net/qq_22328011/article/details/128392324

版权

LeetCode 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

lintcode 1884
n = arr.length
dp[i][j] 代表拿走 $\sim j$ 瓶子所需要的最少次数.
初始化条件

$\ i = 0:n-1 \quad for \ j = i:n-1 :$ dp[i][j] = n
$\ i = 0:n-1 :$ dp[i][i] = 1
$\ i = 1:n-1 :$ dp[i-1][i] = 1 $\ arr[i-1]=arr[i]$ , dp[i-1][i] = 2 $\ arr[i-1]\neq arr[i]$
状态转移
$\ l = 2:n-1 \quad for \ i = 0:n-1, j=i+l:$ dp[i][j] = dp[i+1][j-1] $\ arr[i] = arr[j]$
$\ k = i:j-1:$ dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]))

Java

public class Solution {
    public int takeAwayTheBottle(int[] arr) {
        int n = arr.length;
        int[][] dp = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                if (i == j) dp[i][j] = 1;
                else if (i == j-1) {
                    if (arr[i] == arr[j]) dp[i][j] = 1;
                    else dp[i][j] = 2; 
                } else dp[i][j] = n;
            }
        }
        for (int l = 2; l < n; l++) {
            for (int i = 0; i < n && i+l < n; i++) {
                int j = i+l;
                if (arr[i] == arr[j]) dp[i][j] = dp[i+1][j-1];
                for (int k = i; k < j; k++) {
                    dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k+1][j]);
                }
            }
        }
        return dp[0][n-1];
    }
}

func takeAwayTheBottle (arr []int) int {
    //base cace
    n := len(arr)
    dp := make([][]int,n)
    for i,_ := range dp {
        dp[i] = make([]int,n)
    }
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            if i == j {
                dp[i][j] = 1
            } else {
                dp[i][j] = n
            }
        }
    }
    for i := 0; i+1 < n; i++ {
        if arr[i] == arr[i+1] {
            dp[i][i+1] = 1
        } else {
            dp[i][i+1] = 2
        }
    }
    //dp
    for l := 2; l < n; l++{
        for i := 0; i+l < n; i++ {
            r := i+l
            if arr[i] == arr[r] {
                dp[i][r] = dp[i+1][r-1] 
            }
            for k := i; k < r; k++ {
                dp[i][r] = min(dp[i][r],dp[i][k]+dp[k+1][r])
            }
        }
    }
    return dp[0][n-1]
}

func min(x,y int) int {
    if x < y {return x}
    return y
}