leetcode——序列类DP

最新推荐文章于 2024-04-10 14:11:29 发布

Sophie1797

最新推荐文章于 2024-04-10 14:11:29 发布

阅读量497

点赞数

CC 4.0 BY-SA版权

分类专栏：基础算法

本文链接：https://blog.youkuaiyun.com/m0_37981481/article/details/98602996

基础算法专栏收录该内容

28 篇文章

订阅专栏

本文深入探讨了一系列经典的动态规划问题，包括打家劫舍、粉刷房子、解码方法、最长递增子序列等，提供了详细的算法思路和简洁的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

序列型dp问题关键在于，dp[i]表示前i个item的情况下的子问题，或者以i结尾的子问题

House robber

打家劫舍（一排房子）

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

【思路】分两种情况，偷和不偷，dp[i]表示第i个房子为结尾的情况下子问题的解

public int Rob(int[] nums) {
    if(nums.Length==0) return 0;
    var dp = new int[nums.Length];
    dp[0] = nums[0]; 
    if(nums.Length==1) return dp[0];
    dp[1] = Math.Max(nums[0],nums[1]);
    for(var i=2;i<nums.Length;i++){
        dp[i] = Math.Max(dp[i-1], dp[i-2]+nums[i]);
    }
    return dp[nums.Length-1];
}

【更简洁的方法】直接用两个变量来记录

public int Rob(int[] nums) {
    int prevMax = 0;
    int currMax = 0;
    foreach (int x in nums) {
        int temp = currMax;
        currMax = Math.Max(prevMax + x, currMax);
        prevMax = temp;
    }
    return currMax;
}

打家劫舍（一圈房子）

【思路】因为0号和最后一个房子最多只能抢一个，所以分两种情况，1.不算第0个房子，2.不算最后一个房子

public int Rob(int[] nums) {
    if(nums.Length==0) return 0;
    if(nums.Length==1) return nums[0];
    var n = nums.Length;
    var dp = new int[nums.Length];
    //没偷house0
    dp[0] = 0; dp[1] = nums[1];
    for(var i=2;i<nums.Length;i++){
        dp[i] = Math.Max(dp[i-1], dp[i-2]+nums[i]);
    }
    var notFirst = dp[nums.Length-1];
    //没偷house[n-1]
    dp[0] = 0; dp[1] = nums[0];
    for(var i=2;i<nums.Length;i++){
        dp[i] = Math.Max(dp[i-1], dp[i-2]+nums[i-1]);
    }
    var notLast = dp[nums.Length-1];
    return Math.Max(notFirst, notLast);
}

【更简洁的方法】

public int Rob(int[] nums) {
    int n=nums.Length;
    if(n<2)
        return n==0 ? 0 : nums[0];

    return (Math.Max(Robber(nums,0,n-2), Robber(nums,1,n-1)));
}
public int Robber(int[] nums, int l, int r)
{
    int pre=0;
    int cur=0;
    for(int i=l;i<=r;i++)
    {
        int temp=Math.Max(nums[i]+pre,cur);
        pre=cur;
        cur=temp;
    }
    return cur;
}

打家劫舍（二叉树型房子分布）

【突然冒出来二叉树】因为都是同一个系列的，顺便一块放这儿
【思路】分两种情况，偷了根节点和没偷根节点，dfs返回的是一个长度为2的数组，下标0表示偷了根节点，下标1表示没偷根节点，所以dfs的返回值要比较一下大小，看哪个下标的值大，那个值就是答案。注意同样的比较在更新res[1]的时候也要做。

 public int Rob(TreeNode root) {
    int[] num = dfs(root);
    return Math.Max(num[0], num[1]);
}
private int[] dfs(TreeNode x) {
    if (x == null) return new int[2];
    int[] left = dfs(x.left);
    int[] right = dfs(x.right);
    int[] res = new int[2];
    // res[0]: rob root
    // res[1]: not rob root
    res[0] = left[1] + right[1] + x.val;
    res[1] = Math.Max(left[0], left[1]) + Math.Max(right[0], right[1]);
    return res;
}

Paint house

粉刷房子（三种颜色）

假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。

当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3 的矩阵来表示的。

例如，costs[0][0] 表示第 0 号房子粉刷成红色的成本花费；costs[1][2] 表示第 1 号房子粉刷成绿色的花费，以此类推。请你计算出粉刷完所有房子最少的花费成本。

注意：

所有花费均为正整数。

示例：

输入: [[17,2,17],[16,16,5],[14,3,19]]
输出: 10
解释: 将 0 号房子粉刷成蓝色，1 号房子粉刷成绿色，2 号房子粉刷成蓝色。
最少花费: 2 + 5 + 3 = 10。

//感觉很像紫色算法书上劳动力分配问题
public int MinCost(int[][] costs) {
    var n = costs.Length;
    if(n==0) return 0;
    var dp = new int[n,3];
    dp[0,0] = costs[0][0];
    dp[0,1] = costs[0][1];
    dp[0,2] = costs[0][2];
    for(var i=1;i<costs.Length;i++){
        dp[i,0] = Math.Min(dp[i-1,1], dp[i-1,2]) + costs[i][0];
        dp[i,1] = Math.Min(dp[i-1,0], dp[i-1,2]) + costs[i][1];
        dp[i,2] = Math.Min(dp[i-1,0], dp[i-1,1]) + costs[i][2];
    }
    return Math.Min(Math.Min(dp[n-1,0], dp[n-1,1]), dp[n-1,2]);
}

粉刷房子（k种颜色）

假如有一排房子，共 n 个，每个房子可以被粉刷成 k 种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。

当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x k 的矩阵来表示的。

例如，costs[0][0] 表示第 0 号房子粉刷成 0 号颜色的成本花费；costs[1][2] 表示第 1 号房子粉刷成 2 号颜色的成本花费，以此类推。请你计算出粉刷完所有房子最少的花费成本。

注意：

所有花费均为正整数。

示例：

输入: [[1,5,3],[2,9,4]]
输出: 5
解释: 将 0 号房子粉刷成 0 号颜色，1 号房子粉刷成 2 号颜色。最少花费: 1 + 4 = 5;
或者将 0 号房子粉刷成 2 号颜色，1 号房子粉刷成 0 号颜色。最少花费: 3 + 2 = 5.
进阶：
您能否在 O(nk) 的时间复杂度下解决此问题？

下面的解法就是O(nk) ，关键在于找最大和找次大

public int MinCostII(int[][] costs) {
    var n = costs.Length;
    if(n==0) return 0;
    var mini = new int[costs[0].Length];
    GetMin(mini, costs[0]);
    for(var i=1;i<costs.Length;i++){
        for(var j=0;j<costs[i].Length;j++){
            costs[i][j] += mini[j];
        }
        GetMin(mini, costs[i]);
    }
    return costs[n-1].Min();
}

public void GetMin(int[] mini, int[] costs){
    var min = int.MaxValue;
    var minInd = -1;
    var sedMin = int.MaxValue;
    var sedMinInd = -1;
    for(var i=0;i<costs.Length;i++){
        if(costs[i]<min){
            min = costs[i];
            minInd = i;
        }
    }
    for(var i=0;i<costs.Length;i++){
        if(costs[i]<sedMin && i!=minInd){
            sedMin = costs[i];
            sedMinInd = i;
        }
    }
   // Console.Write("--"+min+" - "+sedMin+"\n");
    for(var i=0;i<mini.Length;i++){
        if(costs[i]!=min){
            mini[i] = min;
        }
        else{
            mini[i] = sedMin;
        }
    }
}

Decode way

解码方法（只有1-9）

一条包含字母 A-Z 的消息通过以下方式进行了编码：

‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26
给定一个只包含数字的非空字符串，请计算解码方法的总数。

示例 1:

输入: “12”
输出: 2
解释: 它可以解码为 “AB”（1 2）或者 “L”（12）。
示例 2:

输入: “226”
输出: 3
解释: 它可以解码为 “BZ” (2 26), “VF” (22 6), 或者 “BBF” (2 2 6) 。

public int NumDecodings(string s) {
    if(s == null || s.Length == 0) {
        return 0;
    }
    int n = s.Length;
    int[] dp = new int[n+1];//dp[i],前i个char的解码方法个数
    dp[0] = 1;//""=>""
    dp[1] = s[0] != '0' ? 1 : 0;
    for(int i = 2; i <= n; i++) {
        int first = int.Parse(s.Substring(i-1, 1));
        int second = int.Parse(s.Substring(i-2, 2));
        if(first >= 1 && first <= 9) {//这块if是防止出现0的情况
           dp[i] += dp[i-1];  
        }
        if(second >= 10 && second <= 26) {
            dp[i] += dp[i-2];
        }
    }
    return dp[n];
}

解码方法（还有通配符*号）

一条包含字母 A-Z 的消息通过以下的方式进行了编码：

‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26
除了上述的条件以外，现在加密字符串可以包含字符 '‘了，字符’'可以被当做1到9当中的任意一个数字。

给定一条包含数字和字符’*'的加密信息，请确定解码方法的总数。

同时，由于结果值可能会相当的大，所以你应当对109 + 7取模。（翻译者标注：此处取模主要是为了防止溢出）

示例 1 :

输入: “*”
输出: 9
解释: 加密的信息可以被解密为: “A”, “B”, “C”, “D”, “E”, “F”, “G”, “H”, “I”.
示例 2 :

输入: “1*”
输出: 9 + 9 = 18（翻译者标注：这里1可以分解为1, 或者当做1*来处理，所以结果是9+9=18）
说明 :

输入的字符串长度范围是 [1, 105]。
输入的字符串只会包含字符 ‘*’ 和数字’0’ - ‘9’。

int M = 1000000007;
public int NumDecodings(string s) {
    long first = 1, second = s[0] == '*' ? 9 : s[0] == '0' ? 0 : 1;
    for (int i = 1; i < s.Length; i++) {
        long temp = second;
        if (s[i] == '*') {
            second = 9 * second;
            if (s[i-1] == '1')
                second = (second + 9 * first) % M;
            else if (s[i-1] == '2')
                second = (second + 6 * first) % M;
            else if (s[i-1] == '*')
                second = (second + 15 * first) % M;
        } else {
            second = s[i] != '0' ? second : 0;
            if (s[i-1] == '1')
                second = (second + first) % M;
            else if (s[i-1] == '2' && s[i] <= '6')
                second = (second + first) % M;
            else if (s[i-1] == '*')
                second = (second + (s[i] <= '6' ? 2 : 1) * first) % M;
        }
        first = temp;
    }
    return (int) second;   
}

最长连续递增序列（连续）

public int FindLengthOfLCIS(int[] nums) {
    if(nums.Length==0) return 0;
    var dp = 1;
    var max = dp;//注意不能是int.MinValue,否则输入只有一个数的时候就返回错误的结果了
    for(var i = 1;i<nums.Length;i++){
        if(nums[i]>nums[i-1]){
            dp ++;
        }
        else{
            dp = 1;
        }
        max = Math.Max(max, dp);
    }
    return max;
}

LIS

最长上升子序列（可以不连续）

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。
进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

【注意】下面这种普通的DP解法并不是最快的解法，最快的解法是二分搜索

public int LengthOfLIS(int[] nums)
{
    var n = nums.Length;
    if (n == 0) return 0;
    var dp = new int[n];
    var max = int.MinValue;
    for (var i = 0; i < n; i++)
    {
        dp[i] = 1;
        for (var j = 0; j < i; j++)
        {
            if (nums[i] > nums[j])
            {
                dp[i] = Math.Max(dp[i], dp[j] + 1);
            }
        }
        max = Math.Max(max, dp[i]);
    }
    return max;
}

【更快的解法】
这种解法中，dp数组存的是nums中的序列，而且是升序存的，这里面正确性的证明，关键点在于dp中存的数蕴含着时间戳，如果nums[i]之前的数都比它小，它插入以后形成的序列肯定是最长的，更新len，如果它之前的数有大有小，它插入进去以后，只能跟比它小的组成序列，这时序列长度没有增加，但它插入进去以后会把刚好比它大的那个数给替换了，增加以后长度变长的概率。

public int LengthOfLIS(int[] nums) {
    if(nums==null||nums.Length==0){
        return 0;
    }
    int[] dp = new int[nums.Length];
    int len = 0;
    foreach (int num in nums) {
    	//这儿很像插入排序
        int i = Array.BinarySearch(dp, 0, len, num);
        if (i < 0) {
            i = -(i + 1);
        }
        //要么自己给自己在的位置赋值，要么替换掉上一个恰好比自己大数
        dp[i] = num;
        //如果插入位置下标等于len，说明长度变长了，要更新
        if (i == len) {
            len++;
        }
    }
    return len;
}

俄罗斯套娃信封问题（类LIS）

给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。

请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。

说明:
不允许旋转信封。

示例:

输入: envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出: 3
解释: 最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。

public int MaxEnvelopes(int[][] envelopes)
{
    if (envelopes == null
        || envelopes.Length == 0
        || envelopes[0] == null
        || envelopes[0].Length == 0)
    {
        return 0;
    }

    Array.Sort(envelopes, (e1, e2) => e1[0] - e2[0]);

    int n = envelopes.Length;
    int[] dp = new int[n];

    int ret = 0;
    for (int i = 0; i < n; i++)
    {
        dp[i] = 1;

        for (int j = 0; j < i; j++)
        {
            if (envelopes[i][0] > envelopes[j][0]
                && envelopes[i][1] > envelopes[j][1])
            {
                dp[i] = Math.Max(dp[i], 1 + dp[j]);
            }
        }

        ret = Math.Max(ret, dp[i]);
    }
    return ret;
}

比特位计数（bit+dp）

给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。

示例 1:

输入: 2
输出: [0,1,1]
示例 2:

输入: 5
输出: [0,1,1,2,1,2]

// 相当于从0开始构造，然后偶数的话继承上一个偶数，奇数继承前一个偶数加一
public int[] CountBits(int num)
{
    var res = new int[num + 1];
    for (var i = 0; i <= num / 2; i++)
    {
        res[i << 1] = res[i];
        if (i * 2 == num) break;
        res[(i << 1) + 1] = res[i] + 1;
    }
    return res;
}