渣渣的Leetcode之旅（Python3）_动态规划练习（198,213,518,279,118）

198. 打家劫舍

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

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

示例 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 。

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 400

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/house-robber
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def rob(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return nums[0]
        list_01 = [0]*len(nums)
        list_01[0] = nums[0]
        if nums[1] > nums[0]:
            list_01[1] = nums[1]
        else:
            list_01[1] = nums[0]
        for i in range(2,len(nums)):
            if nums[i] + list_01[i-2] > list_01[i-1]:
                list_01[i] = nums[i] + list_01[i-2]
            else:
                list_01[i] = list_01[i-1]
        return list_01[-1]

213. 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈
，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警
。

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

示例 1：

输入：nums = [2,3,2] 输出：3 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）,
因为他们是相邻的。

示例 2：

输入：nums = [1,2,3,1] 输出：4 解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：

输入：nums = [0] 输出：0

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 1000

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/house-robber-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def rob(self, nums: List[int]) -> int:
        if len(nums)==1:
            return nums[0]
        if len(nums) ==2:
            if nums[0] > nums[1]:
                return nums[0]
            else:
                return nums[1]
                
        fin_count = 0

        list_01 = [0]*(len(nums)-1)
        list_01[0] = nums[0]
        if nums[1] > nums[0]:
            list_01[1] = nums[1]
        else:
            list_01[1] = nums[0]     
        for i in range(2,len(nums)-1):
            if nums[i] + list_01[i-2] >= list_01[i-1]:
                list_01[i] = nums[i] + list_01[i-2]
            else:
                list_01[i] = list_01[i-1]
        fin_count = list_01[-1]

        list_01 = [0]*(len(nums)-1)
        list_01[0] = nums[1]
        if nums[2] > nums[1]:
            list_01[1] = nums[2]
        else:
            list_01[1] = nums[1]
        for i in range(3,len(nums)):
            if nums[i] + list_01[i-3] >= list_01[i-2]:
                list_01[i-1] = nums[i] + list_01[i-3]
            else:
                list_01[i-1] = list_01[i-2]
        if fin_count < list_01[-1]:
            fin_count = list_01[-1]
        return fin_count

518. 零钱兑换 II

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

示例 1:

输入: amount = 5, coins = [1, 2, 5] 输出: 4 解释: 有四种方式可以凑成总金额: 5=5 5=2+2+1
5=2+1+1+1 5=1+1+1+1+1

示例 2:

输入: amount = 3, coins = [2] 输出: 0 解释: 只用面额2的硬币不能凑成总金额3。

示例 3:

输入: amount = 10, coins = [10] 输出: 1

注意:

你可以假设：

0 <= amount (总金额) <= 5000
1 <= coin (硬币面额) <= 5000
硬币种类不超过 500 种
结果符合 32 位符号整数

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/coin-change-2
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        coins.sort()
        list_01 = [0]*(amount+1)
        list_01[0] = 1
        for i in coins:
            for j in range(1,amount+1):
                if j-i >= 0:
                    list_01[j] += list_01[j-i]
        return list_01[-1]

279. 完全平方数

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于
n。你需要让组成和的完全平方数的个数最少。

给你一个整数 n ，返回和为 n 的完全平方数的 最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和
11 不是。

示例 1：

输入：n = 12 输出：3 解释：12 = 4 + 4 + 4

示例 2：

输入：n = 13 输出：2 解释：13 = 4 + 9

提示：

1 <= n <= 104

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/perfect-squares
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 ```

class Solution:
    def numSquares(self, n: int) -> int:
        dict_01 = {}
        for i in range(1,101):
            dict_01[i**2] = 1
        if n in dict_01:
            return 1
        list_01 = [0]*(n+1)
        list_01[1] = 1
        for i in range(2,n+1):
            if i in dict_01:
                list_01[i] = 1
                continue
            middle = i
            for j in range(1,i//2+1):
                temp = list_01[j] + list_01[i-j]
                if middle>temp:
                    middle = temp
            list_01[i] = middle
        return list_01[n]

118. 杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5 输出: [
[1],
[1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ]

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/pascals-triangle
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        list_01 = []
        for i in range(0,numRows):
            if i == 0:
                list_01.append([1])
                continue
            if i == 1:
                list_01.append([1,1])
                continue
            else:
                list_02 = []
                list_02.append(1)
                for j in range(1,i):
                    a = list_01[i-1][j-1]+list_01[i-1][j]
                    list_02.append(a)
                list_02.append(1)
                list_01.append(list_02)
        return list_01