Eres un ladrón profesional que planeas robar casas a lo largo de la calle. Hay una cierta cantidad de efectivo escondida en cada habitación. La única limitación que afecta al robo es que las casas adyacentes están equipadas con sistemas antirrobo interconectados. Si un ladrón entra en dos casas adyacentes en la misma noche, el sistema emitirá una alarma automáticamente . Dada una serie de números enteros no negativos que representan la cantidad de dinero almacenada en cada casa, calcule la cantidad máxima que se puede robar durante la noche sin tocar el dispositivo de alarma.
Ejemplo 1: Entrada: [1,2,3,1] Salida: 4
Explicación: Robar la casa 1 (cantidad = 1), luego robar la casa 3 (cantidad = 3).
La mayor cantidad robada = 1 + 3 = 4.Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/house-robberMétodo 1: programación dinámica
class Solution: def rob(self, nums: List[int]) -> int: n=len(nums) dp=[0 for i in range(n+2)] # n-1 是为了让i和nums对其 for i in range(n-1,-1,-1): # 两种状态比对，不抢：当前所获等于上一次的获得；抢：当前所获等于当前房屋（nums[i]）加上上次所获 dp[i]=max(dp[i+1],nums[i]+dp[i+2]) return dp[0]Método 2: recursividad
class Solution: def rob(self, nums: List[int]) -> int: global memo memo=[-1 for i in range(len(nums))] # 自顶向上 return self.dp(nums,0) def dp(self,nums: List[int],start: int)-> int: if start>=len(nums): return 0 if memo[start]!=-1: return memo[start] rst =max( # 不抢，去下家 self.dp(nums,start+1), # 抢，让后去下下家 nums[start]+ self.dp(nums,start+2) ) memo[start]=rst return rst
Eres un ladrón profesional, planeas robar casas a lo largo de la calle, hay una cierta cantidad de efectivo escondida en cada casa. Todas las casas en este lugar están en un círculo, lo que significa que la primera casa y la última casa están una al lado de la otra. Al mismo tiempo, las casas adyacentes están equipadas con sistemas antirrobo interconectados. Si un ladrón entra en dos casas adyacentes en la misma noche, el sistema emitirá una alarma automáticamente. Dada una matriz de números enteros no negativos que representan la cantidad de almacenamiento en cada casa, calcule la cantidad más alta que puede robar sin activar el dispositivo de alarma.
Ejemplo 1: Entrada: [2,3,2] Salida: 3
Explicación: No puede robar la casa 1 (cantidad = 2) primero y luego robar la casa 3 (cantidad = 2) porque son adyacentes.Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/house-robber-iiMétodo 1: programación dinámica
class Solution: def rob(self, nums: List[int]) -> int: n=len(nums) if n==0 : return 0 if n==1: return nums[0] return max(self.robPlan(nums,0,n-2),self.robPlan(nums,1,n-1)) def robPlan(self,nums:List[int],start:int,end:int)-> int: # 初始化 state_0,state_1=0,0 rst=0 for i in range(end,start-1,-1): # 不抢or抢，state_0:上次没抢后的金额，state_1：上次抢过后的金额 # rst:这次抢与不抢的比较的结果 rst=max(state_0,state_1+nums[i]) # 这次不抢，就作为下次抢的获利基数 state_1=state_0 # 这次抢的结果，就作为下次不抢的获利数 state_0=rst return rst
Después de robar una calle y un círculo de casas la última vez, el ladrón encontró una nueva área donde se podía realizar el robo. Solo hay una entrada a esta área, que llamamos la "raíz". Además de la "raíz", cada casa tiene una y sólo una casa "matriz" conectada a ella. Después de algún reconocimiento, el astuto ladrón se dio cuenta de que "todas las casas de este lugar están dispuestas como un árbol binario". Si dos casas conectadas directamente son robadas la misma noche, la casa llamará automáticamente a la policía. Calcule la cantidad máxima que un ladrón puede robar durante la noche sin activar la alarma.
Ejemplo 1: Entrada: [3,2,3, nulo, 3, nulo, 1]
3
/ \
2 3
\ \
3 1Resultado: 7
Explicación: La cantidad máxima que un ladrón puede robar en una noche = 3 + 3 + 1 = 7.Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/house-robber-iii
Método 1:# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def __init__(self): self.memo=collections.defaultdict(int) def rob(self, root: TreeNode) -> int: if root == None: return 0 if root in self.memo: return self.memo[root] # 抢，就查找当前值以及下下家（孙节点）的值，并求和 do_it=root.val \ +(0 if root.left==None else self.rob(root.left.left)+self.rob(root.left.right))\ +(0 if root.right==None else self.rob(root.right.left)+self.rob(root.right.right)) # 不抢，不抢当前值就抢下家（儿子节点）的值，并求和 not_do=self.rob(root.left)+self.rob(root.right) # 取最大值 rst=max(do_it,not_do) self.memo[root]=rst return rst