Libro de registro de pincel LeetCode
Suma de dos números
Dificultad : simple
Descripción : Dada una matriz de números enteros y un objetivo de valor objetivo, encuentre los dos enteros cuya suma es el valor objetivo en la matriz y devuelva su índice de matriz.
Puede suponer que cada entrada solo corresponderá a una respuesta. Sin embargo, el mismo elemento en la matriz no se puede usar dos veces.
Ejemplos
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
Ideas para resolver problemas
Puede ver que el requisito previo para la pregunta es que cada entrada solo corresponderá a una respuesta, pero el mismo elemento en la matriz no se puede usar en ambos lados, por lo que podemos recorrer la matriz y luego usar el valor del elemento de la matriz como la clave y las coordenadas como el valor. En el mapa.
Durante el recorrido del bucle, reste el valor del elemento actual con el objetivo para obtener la diferencia. Luego vaya al mapa para obtener la interpolación. Si se puede obtener, almacene las dos coordenadas en la matriz devuelta y regrese.
Código de implementación
class Solution {
public int[] twoSum(int[] nums, int target) {
int[] returnIntArray = new int[2];
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int num = nums[i];
int result = target - num;
if (map.containsKey(result)) {
returnIntArray[1] = i;
returnIntArray[0] = map.get(result);
} else {
map.put(num, i);
}
}
return returnIntArray;
}
}
Agrega dos números
Dificultad : moderada
Descripción : Dé dos listas enlazadas no vacías para representar dos enteros no negativos. Entre ellos, sus respectivos dígitos se almacenan en orden inverso, y cada uno de sus nodos solo puede almacenar un dígito.
Si sumamos estos dos números, se devolverá una nueva lista vinculada para representar su suma.
Puede suponer que, excepto por el número 0, ninguno de estos números comenzará con 0.
Ejemplos
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
Ideas para resolver problemas
Déjame hablar sobre mis primeros pensamientos.
Intento atravesar dos listas de elementos individuales, convertirlo en int, luego agregar las dos entradas (referidas como suma), y finalmente convertir esta suma en una cadena, luego atravesar esta cadena y almacenar cada valor en un ListNode , Y luego ensamblado en una sola lista de elementos Sin embargo, en la prueba de ejecución real, cuando se envía el leetCode, si se pasa una larga lista de elementos individuales como parámetro, la longitud del int puede desbordarse directamente, lo que da como resultado un resultado incorrecto. Debido a que el requisito de longitud del listnode no se puede especificar, se puede eliminar incluso si se cambia a largo, por lo que este esquema no es confiable
Nuevo plan
0, defina una cabeza de nodo, luego defina un final, puntos finales a la cabeza, defina una cantidad de acarreo
1. Juzgue las dos listas de un solo elemento (en lo sucesivo denominadas l1, l2), si ambas están vacías, incluso si se completa el recorrido, pero mientras uno no esté vacío, continúe atravesando, pero el valor de los dos nodos siempre es 0 Demasiado
2. Obtenga el valor de l1 + l2
3. Debido a que el resultado del último cálculo puede ser mayor que diez, es para llevar, por lo que la lógica de los resultados del cálculo final de estos dos debe ser: l1 + l2 + carry
4. El nuevo carry es (l1 + l2 + carry) / 10, y el resultado de la suma actual es (l1 + l2 + carry)% 10
5. Apunte end.next al nodo recién creado y configure el valor del nodo en sum
6. Apunte el puntero final al nodo recién creado (end = end.next)
7. Determine si l1 y l2 están vacías, de lo contrario, apúntelos a su próximo nodo.
8. Cuando se completa el recorrido, el resultado del último bit puede ser mayor que 10, por lo que debe determinar si el arrastre final es mayor que 0. Si es mayor que 0, debe finalizar el siguiente nodo, apuntando a un nuevo nodo, el valor del nodo Es llevar
9. Dado que el valor de la cabeza que acabamos de crear es 0, pero no necesitamos el nodo 0 en el resultado real, por lo que devolvemos el resultado como head.next
Código de implementación
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode head = new ListNode(0);
ListNode end = head;
int carry = 0;
while (l1 != null || l2 != null) {
int x = l1 == null ? 0 : l1.val;
int y = l2 == null ? 0 : l2.val;
int sum = x + y + carry;
// 判断和的结果是否大于10
carry = sum / 10;
// 获取无论结果是否大于10，最终的这一位的数字是多少
sum = sum % 10;
// 组装列表
end.next = new ListNode(sum);
end = end.next;
// 判断是否还需要继续next
if (l1 != null) {
l1 = l1.next;
}
if (l2 != null) {
l2 = l2.next;
}
}
// 判断最终位计算是否超过了10
if (carry > 0) {
end.next = new ListNode(carry);
}
return head.next;
}
}
La subcadena más larga sin caracteres repetidos
Dificultad : moderada
Descripción : Dada una cadena, te enteras de que no contiene un carácter repetido más larga subcadena de longitud.
Ejemplos
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3
Ideas para resolver problemas
- Defina un mapa para almacenar el carácter y la posición de longitud, el valor del valor es la posición del carácter +1, +1 significa que no se repite después de la posición del carácter
- Defina la posición de inicio de la subcadena no repetida start y end as end
- A medida que el final avanza hacia atrás, encontrará los mismos caracteres que los intervalos de inicio y finalización. En este momento, use el carácter como clave, obtenga su valor y actualice el inicio. En este momento, no hay caracteres duplicados en los intervalos de inicio y finalización.
- Independientemente de si el inicio se actualiza, actualizará su estructura de datos de mapas y ans
- Complejidad de tiempo O (n)
Código de implementación
public int lengthOfLongestSubstring(String s) {
int ans = 0;
Map<Character, Integer> map = new HashMap<>();
for (int start = 0, end = 0; end < s.length(); end++) {
Character c = s.charAt(end);
if (map.containsKey(c)) {
start = Math.max(start, map.get(c));
}
ans = Math.max(ans, end - start + 1);
map.put(c, end + 1);
}
return ans;
}