牛客题解 | 打家劫舍(二)

题目

题目链接

解题思路

这是打家劫舍问题的变种,房屋首尾相连形成环形。可以通过以下步骤解决:

  1. 由于首尾相连,我们可以将问题拆分为两种情况:
    • 偷第一家,不能偷最后一家(考虑 [ 0 , n − 2 ] [0, n-2] [0,n2] 的房屋)
    • 不偷第一家,可以偷最后一家(考虑 [ 1 , n − 1 ] [1, n-1] [1,n1] 的房屋)
  2. 对于每种情况,使用动态规划求解:
    • d p [ i ] dp[i] dp[i] 表示到第 i i i 个房屋时能偷到的最大金额
    • d p [ i ] = max ⁡ ( d p [ i − 1 ] , d p [ i − 2 ] + n u m s [ i ] ) dp[i] = \max(dp[i-1], dp[i-2] + nums[i]) dp[i]=max(dp[i1],dp[i2]+nums[i])
  3. 最后取两种情况的最大值

代码

#include <iostream>
#include <vector>
using namespace std;

int rob(vector<int>& nums, int start, int end) {
    if(start == end) return nums[start];
    
    vector<int> dp(end - start + 1);
    dp[0] = nums[start];
    dp[1] = max(nums[start], nums[start + 1]);
    
    for(int i = 2; i <= end - start; i++) {
        dp[i] = max(dp[i-1], dp[i-2] + nums[start + i]);
    }
    
    return dp[end - start];
}

int robCircle(vector<int>& nums) {
    int n = nums.size();
    if(n == 1) return nums[0];
    if(n == 2) return max(nums[0], nums[1]);
    
    // 考虑不偷最后一家
    int result1 = rob(nums, 0, n-2);
    // 考虑不偷第一家
    int result2 = rob(nums, 1, n-1);
    
    return max(result1, result2);
}

int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    for(int i = 0; i < n; i++) {
        cin >> nums[i];
    }
    cout << robCircle(nums) << endl;
    return 0;
}
import java.util.Scanner;

public class Main {
    public static int rob(int[] nums, int start, int end) {
        if(start == end) return nums[start];
        
        int[] dp = new int[end - start + 1];
        dp[0] = nums[start];
        dp[1] = Math.max(nums[start], nums[start + 1]);
        
        for(int i = 2; i <= end - start; i++) {
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[start + i]);
        }
        
        return dp[end - start];
    }
    
    public static int robCircle(int[] nums) {
        int n = nums.length;
        if(n == 1) return nums[0];
        if(n == 2) return Math.max(nums[0], nums[1]);
        
        // 考虑不偷最后一家
        int result1 = rob(nums, 0, n-2);
        // 考虑不偷第一家
        int result2 = rob(nums, 1, n-1);
        
        return Math.max(result1, result2);
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] nums = new int[n];
        for(int i = 0; i < n; i++) {
            nums[i] = sc.nextInt();
        }
        System.out.println(robCircle(nums));
        sc.close();
    }
}
def rob(nums, start, end):
    if start == end:
        return nums[start]
    
    dp = [0] * (end - start + 1)
    dp[0] = nums[start]
    dp[1] = max(nums[start], nums[start + 1])
    
    for i in range(2, end - start + 1):
        dp[i] = max(dp[i-1], dp[i-2] + nums[start + i])
    
    return dp[end - start]

def rob_circle(nums):
    n = len(nums)
    if n == 1:
        return nums[0]
    if n == 2:
        return max(nums[0], nums[1])
    
    # 考虑不偷最后一家
    result1 = rob(nums, 0, n-2)
    # 考虑不偷第一家
    result2 = rob(nums, 1, n-1)
    
    return max(result1, result2)

n = int(input())
nums = list(map(int, input().split()))
print(rob_circle(nums))

算法及复杂度

  • 算法:动态规划
  • 时间复杂度: O ( n ) \mathcal{O}(n) O(n),需要遍历两次数组
  • 空间复杂度: O ( n ) \mathcal{O}(n) O(n),需要一个 d p dp dp 数组
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值