Q: Usted es un ladrón profesional para robar plan de la calle de la casa. Todas las habitaciones están en posesión de algo de dinero, las únicas limitaciones que afectan a robar la casa de su vecino está equipado con el sistema anti-robo de comunicarse entre sí, si dos casas adyacentes en la misma noche, los ladrones entraron en el sistema emitirá una alarma automática .
Dado un representante de cada array entero no negativo de cantidad de almacenamiento de Vivienda calculado en caso de que no toque el dispositivo de alarma, puede robar la cantidad máxima a.
Ejemplo 1:
Entrada: [1,2,3,1]
de salida: 4
Explicación: Vivienda robo No. 1 (cantidad = 1), entonces el robo Vivienda 3 (cantidad = 3).
La cantidad máxima de robo = 3 + 1 = 4.
Ejemplo 2:
Entrada: [2,7,9,3,1]
de salida: 12
Explicación: Vivienda robo No. 1 (cantidad = 2), 3 robo Vivienda (cantidad = 9), seguido por el robo de Vivienda 5 (1 = Cantidad ).
La cantidad máxima de robo = 2 + 9 + 1 = 12.
A: Un problema de programación dinámica típica.
La casa actual se divide en dos posibilidades, ya sea o no de agarre agarre.
Si la corriente robado, o bien no agarrar la última vez, ya sea en el último robado;
si la corriente no lo hizo agarrar, agarrar bien el último o la última vez que ocurre un robo,
por lo que, dp en la escritura buena:
dp [i] [0] = Math.max (dp [i - 1] [1], dp [i - 2] [1]); // grab ya sea la última o la penúltima grab es
dp [i] [1] = Math.max (dp [i - 1] [0] + nums [i], dp [i - 2] [1] + nums [i]); // última ya sea sin prisas ya sea en el último robado
código:
public static int rob(int[] nums) {
if (nums.length == 0)
return 0;
if(nums.length == 1)
return nums[0];
int[][] dp = new int[nums.length][2];
dp[0][0] = 0;
dp[0][1] = nums[0];
dp[1][0] = nums[0];
dp[1][1] = nums[1];
for (int i = 2; i < nums.length; i++) {
dp[i][0] = Math.max(dp[i - 1][1], dp[i - 2][1]);
dp[i][1] = Math.max(dp[i - 1][0] + nums[i], dp[i - 2][1] + nums[i]);
}
return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
}
O, llegado desde la base de la cola :( Presupuesto de "labuladong algoritmo Chuleta")
// 返回 nums[start..] 能抢到的最⼤值
private int dp(int[] nums, int start) {
if (start >= nums.length) {
return 0;
}
int res = Math.max(
// 不抢，去下家
dp(nums, start + 1),
// 抢，去下下家
nums[start] + dp(nums, start + 2)
);
return res;
}
Esta nota se puede añadir para evitar el doble conteo.
Esta es una de arriba hacia abajo, de abajo hacia arriba también puede reducir el computacional
int rob(int[] nums) {
int n = nums.length;
// dp[i] = x 表⽰：
// 从第 i 间房⼦开始抢劫，最多能抢到的钱为 x
// base case: dp[n] = 0
int[] dp = new int[n + 2];
for (int i = n - 1; i >= 0; i--) {
dp[i] = Math.max(dp[i + 1], nums[i] + dp[i + 2]);
}
return dp[0];
}
Dado que sólo y dp [i + 1], dp [i + 2] Relacionados, dos variables sólo puede grabarlo.
Q: Usted es un ladrón profesional para robar plan de la calle de la casa, cada habitación se encuentran en posesión de un poco de dinero. Este lugar Todas las casas están en un círculo , lo que significa que la primera y la última casa está al lado de la casa. Mientras tanto, las casas vecinas equipados con sistema anti-robo se comunican entre sí, si dos casas adyacentes en la misma noche, los ladrones entraron en el sistema emitirá una alarma automáticamente.
Dado un representante de cada array entero no negativo de cantidad de almacenamiento de Vivienda calculado en caso de que no toque el dispositivo de alarma, puede robar la cantidad máxima a.
Ejemplo 1:
Entrada: [2,3,2]
de salida: 3
Explicación: No puede robar primera No. 1 Vivienda (cantidad = 2), y luego robar la tercera casa (dinero = 2), debido a que son adyacentes.
Ejemplo 2:
Entrada: [1,2,3,1]
de salida: 4
Explicación: Puede primero robar Vivienda 1 (cantidad = 1), entonces el robo Vivienda 3 (cantidad = 3).
La cantidad máxima de robo = 3 + 1 = 4.
A:
por lo tanto, sobre todo en primer lugar, al final de la sala no puede, por tanto, especialmente robado, entonces no puede haber sólo tres situaciones diferentes: o bien no robaron, o los primeros submenús marco no hacer agarrar entre las habitaciones fue robado último cuadro, sala de submenús fue robado entre cualquiera de la última trama entre ⼀ se precipite.
Es simple, ah, estos tres casos, el tipo de resultado es más grande, es el canto respuesta final! Pero, de hecho, no necesitamos ⽐ de tres casos, y siempre que ⽐ que en el caso de un tres situaciones ⼆ en ⾏, ya que en ambos casos la sala de situación para la elección ⽐ submenús de ⼀ ampliada Sí, contar el dinero entra en la habitación útil submenús son ⾥ negativo, así que la opción zoom, ciertamente no es el resultado de la decisión óptima ⼩. Traído por encima de ella.
public static int rob(int[] nums) {
int n = nums.length;
if (n == 0)
return 0;
if (n == 1)
return nums[0];
return Math.max(maxRob(nums, 0, n - 2), maxRob(nums, 1, n - 1));
}
private static int maxRob(int[] nums, int start, int end) {
int dp_2 = 0;
int dp_1 = 0;
int dp = 0;
for (int i = end; i >= start; i--) {
dp = Math.max(dp_1, dp_2 + nums[i]);
dp_2 = dp_1;
dp_1 = dp;
}
return dp;
}
Q: Después de la finalización de la última vuelta después de robar una calle y la casa, descubrió que un ladrón puede robar nuevas áreas. La región tiene una sola entrada, lo que llamamos la "raíz". Además de la "raíz", y sólo las casas de una casa "padre" relacionados con ellos. Después de un poco de reconocimiento, astuto ladrón se dio cuenta de que "este lugar todas las casas están dispuestas similar a un árbol binario." Si ambas cámaras están directamente conectados robado la misma noche, la alarma de la casa.
Calculado sin tocar la alarma, un ladrón puede robar la cantidad máxima de la noche.
Ejemplo 1:
Entrada: [3,2,3, null, 3, null, 1]
3
/
2 3
\ \
3 1
de salida: 7
explica: un ladrón robar la cantidad noche máximo puede ser de 3 + 3 = 7 + 1 = .
Ejemplo 2:
Entrada: [3,4,5,1,3, null ,. 1]
. 3
/
4 5
/ \ \
1. 1. 3.
De salida: 9
Explicación: un ladrón robar la noche puede ser la cantidad máxima = 5 + 4 = 9 .
R:
Veo el árbol, de forma recursiva.
Map<TreeNode, Integer> map = new HashMap<>();
public int rob(TreeNode root) {
if (root == null)
return 0;
if (map.containsKey(root))
return map.get(root);
int do_it = root.val + (root.left == null ? 0 : rob(root.left.left) + rob(root.left.right)) + (root.right == null ? 0 : rob(root.right.left) + rob(root.right.right));
int not_do = rob(root.left) + rob(root.right);
int res = Math.max(do_it, not_do);
map.put(root, res);
return res;
}