A soma de dois números LeetCode 01

Soma de dois números

---

Link do tópico:

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

Descrição do título

Dados uma matriz de números inteiros e um alvo de valor de destino, por favor, encontre os dois inteiros cuja soma é o valor de destino na matriz e retorne seus subscritos de matriz.

Você pode presumir que cada entrada corresponderá apenas a uma resposta. No entanto, você não pode reutilizar os mesmos elementos nesta matriz.

Exemplo:

Dados nums = [2, 7, 11, 15], alvo = 9

porque nums [0] + nums [1] = 2 + 7 = 9, então retorne [0, 1]

Tópico detalhado

Essa pergunta nos dá uma matriz, que está cheia de inteiros, e então nos dá um alvo numérico . Precisamos descobrir quais dois números na matriz são a soma da meta . Observe que você não pode reutilizar o mesmo elemento nesta matriz, o que significa que o número em cada posição pode ser usado apenas uma vez, como a matriz [1,1,3], você pode usar o primeiro e o segundo 1, Mas você não pode usar o primeiro 1 duas vezes.

Plano de resolução de problemas

Ideia 1: Complexidade de tempo: O (N ^ 2) Complexidade de espaço: O (1)

Este método é muito simples, é uma solução violenta, a travessia de loop duplo é suficiente. O loop externo pega o elemento num [i] com o índice i da matriz, e o loop interno pega o elemento nums [j] após o i e adiciona o elemento com o índice i um por um para determinar se o resultado é o destino . Apenas uma pergunta é necessária, então, uma vez encontrada, retorne diretamente. O N na complexidade do tempo representa o comprimento da lista de números .

Vejamos o código abaixo:

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;
    }
}

Ideia 2: Complexidade de tempo: O (N) Complexidade do espaço: O (N)

A ideia acima 1 complexidade de tempo é muito alta, é uma maneira típica de acelerar o tempo, isso não é aconselhável. Na verdade, podemos sacrificar espaço em troca de tempo.

Esperamos que, quando percorrermos sequencialmente para obter um número num [1] , saibamos se o número target-num1 correspondente está em nossos nums e não há apenas um. Por exemplo, o alvo é 4 e nums é [2,3]. Supondo que o num1 que obtivemos neste momento seja 2, o 2 emparelhado com ele está de fato em nums , mas o número 2 só aparece uma vez em nums , e não podemos obter dois Vezes, então não vai funcionar.

Portanto, temos as seguintes etapas :

1. Crie um HashMap , armazena chave nums [i] e armazena valor índice i ;
2. Analisar HashMap se a presença de target - cur , o valor atual de cur e um HashMap de valores- chave e a soma de target ;
3. Se existir, retorna o índice do cur-alvo e o índice do valor atual cur ;
4. Se ele não existir , salvar o atual número cur como a chave eo atual número de índice como o valor no HashMap .

Vejamos o código abaixo:

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;
    }
}