La suma de dos números LeetCode 01

Suma de dos números

---

Enlace de tema:

https://leetcode-cn.com/problems/two-sum/

Descripción del Título

Dado un número de matriz de enteros y un objetivo de valor objetivo, busque los dos enteros cuya suma es el valor objetivo en la matriz y devuelva sus subíndices de matriz.

Puede asumir que cada entrada solo corresponderá a una respuesta. Sin embargo, no puede reutilizar los mismos elementos en esta matriz.

Ejemplo:

Dado nums = [2, 7, 11, 15], objetivo = 9

porque nums [0] + nums [1] = 2 + 7 = 9, devuelve [0, 1]

Tema detallado

Esta pregunta nos da una matriz, que está llena de números enteros, y luego nos da un objetivo numérico.Necesitamos averiguar qué dos números en la matriz son la suma del objetivo . Tenga en cuenta que no puede reutilizar el mismo elemento en esta matriz, lo que significa que el número en cada posición solo se puede usar una vez, como la matriz [1,1,3], puede usar el primero y el segundo 1, Pero no puedes usar el primero dos veces.

Plan de resolución de problemas

Idea 1: Complejidad temporal: O (N ^ 2) Complejidad espacial: O (1)

Este método es muy simple, es una solución violenta, el recorrido de doble bucle es suficiente. El bucle externo toma el elemento num [i] con el índice i de la matriz, y el bucle interno toma el elemento nums [j] después de la i y agrega el elemento con el índice i uno por uno para determinar si el resultado es el objetivo . Solo se requiere una pregunta, así que una vez que la encuentre, regrese directamente. La N en la complejidad de tiempo representa la longitud de la lista de números .

Veamos el siguiente código:

class Solution {
    
    
    public int[] twoSum(int[] nums, int target) {
    
    
        // 第一轮遍历
        for (int i = 0; i < nums.length; i++) {
    
    
            // 第二轮遍历不能重复计算了
            for (int j = i + 1; j < nums.length; j++) {
    
    
                if (nums[i] + nums[j] == target) {
    
    
                    // 注意 leetcode 中要求返回的是索引位置
                    return new int[]{
    
    i, j};
                }
            }
        }
        return null;
    }
}

Idea 2: Complejidad temporal: O (N) Complejidad espacial: O (N)

La idea anterior de 1 complejidad de tiempo es demasiado alta, es una forma típica de acelerar el tiempo, esto no es recomendable. De hecho, podemos sacrificar espacio a cambio de tiempo.

Esperamos que cuando recorramos secuencialmente para obtener un número num [1] , sabremos si el número objetivo-num1 que coincide con él está en nuestros números , y no hay solo uno. Por ejemplo, el objetivo es 4 y nums es [2,3]. Suponiendo que el num1 que obtuvimos en este momento es 2, entonces el 2 emparejado con él está en nums , pero el número 2 solo aparece una vez en nums , y no podemos obtener dos Veces, por lo que no funcionará.

Entonces tenemos los siguientes pasos :

1. Cree un HashMap , la clave almacena nums [i] y el valor almacena el índice i ;
2. Analizar HashMap si la presencia de target - cur , el valor actual de cur y un HashMap de valores clave y la suma de target ;
3. Si existe, devuelve el índice de target-cur y el índice del valor actual cur ;
4. Si no existe , guarde el número actual cur como clave y el índice del número actual como valor en el HashMap .

Veamos el siguiente código:

class Solution {
    
    
    public int[] twoSum(int[] nums, int target) {
    
    
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
    
    
            // 将原本为两个目标值切换为一个目标值，只需要每次从 map 中寻找目标值即可
            int num = target - nums[i];
            if (map.containsKey(num)) {
    
    
                return new int[]{
    
    map.get(num), i};
            }
            // 每次遍历过的值都存储到 map 中，这样之后就能从 map 中寻找需要的目标值
            map.put(nums[i], i);
        }
        return null;
    }
}