[LeetCode] 1128. Número de pares de dominó equivalentes (fácil) (JAVA) Una pregunta por día

【LeetCode】 1128. Número de pares de dominó equivalentes (fácil) (JAVA)

Dirección del título: https://leetcode.com/problems/number-of-equivalent-domino-pairs/

Descripción del Título:

Dada una lista de dominó, dominó [i] = [a, b] es equivalente a dominó [j] = [c, d] si y solo si (a == cyb == d), o (a = = d y b == c) - es decir, un dominó se puede rotar para que sea igual a otro dominó.

Devuelve el número de pares (i, j) para los cuales 0 <= i <j <dominoes.length, y dominó [i] es equivalente a dominó [j].

Ejemplo 1:

Input: dominoes = [[1,2],[2,1],[3,4],[5,6]]
Output: 1

Restricciones:

• 1 <= dominó.longitud <= 40000
• 1 <= dominó [i] [j] <= 9

Idea general

Darle una lista de dominós formada por algunas fichas de dominó.

Si una de las fichas de dominó se puede girar 0 grados o 180 grados para obtener otra ficha de dominó, consideramos que estas dos cartas son equivalentes.

Formalmente, dominó [i] = [a, b] y dominó [j] = [c, d] son ​​equivalentes bajo la premisa de que a == cyb == d, o a == d y b == c.

Bajo la premisa de 0 <= i <j <dominoes.length, averigüe el número de dominó [i] y dominó [j] equivalentes (i, j).

Método de resolución de problemas

Ciclo de violencia

1. Utilice directamente un doble bucle violento, la complejidad del tiempo es O (n ^ 2)
2. Tiempo de espera directo

class Solution {
    public int numEquivDominoPairs(int[][] dominoes) {
        int res = 0;
        for (int i = 0; i < dominoes.length; i++) {
            for (int j = i + 1; j < dominoes.length; j++) {
                if (dominoes[i][0] == dominoes[j][0] && dominoes[i][1] == dominoes[j][1]) {
                    res++;
                } else if (dominoes[i][0] == dominoes[j][1] && dominoes[i][1] == dominoes[j][0]) {
                    res++;
                }
            }
        }
        return res;
    }
}

Límite de tiempo excedido

Optimización uno

1. Ordene la matriz primero, la complejidad del tiempo es O (nlogn)
2. Encuentra el duplicado

class Solution {
    public int numEquivDominoPairs(int[][] dominoes) {
        for (int i = 0; i < dominoes.length; i++) {
            if (dominoes[i][0] <= dominoes[i][1]) continue;
            int temp = dominoes[i][0];
            dominoes[i][0] = dominoes[i][1];
            dominoes[i][1] = temp;
        }
        Arrays.sort(dominoes, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]));
        int res = 0;
        for (int i = 0; i < dominoes.length; i++) {
            int next = i + 1;
            while (next < dominoes.length && dominoes[i][0] == dominoes[next][0] && dominoes[i][1] == dominoes[next][1]) {
                next++;
            }
            int len = next - i;
            res += len * (len - 1) / 2;
            i = next - 1;
        }
        return res;
    }
}

Tiempo de ejecución: 15 ms, derrotando al 23,27% de los usuarios de Java
Consumo de memoria: 47,7 MB, derrotando al 35,18% de los usuarios de Java

Optimización dos

1. Dado que 1 <= dominó [i] [j] <= 9, puede usar a y = 10 * x + z para representar el valor total de dominó [i]
2. Solo use una matriz para almacenar, la complejidad del tiempo es O (n)
3. Nota: Debido a que aquí solo hay 100 números en total, es más rápido almacenar con matrices, Map consume mucho espacio y la velocidad de acceso es lenta; xyz pueden intercambiar posiciones, por lo que x representa un número más pequeño yz representa un número mayor

class Solution {
    public int numEquivDominoPairs(int[][] dominoes) {
        int[] num = new int[100];
        int ret = 0;
        for (int[] domino : dominoes) {
            int val = domino[0] < domino[1] ? domino[0] * 10 + domino[1] : domino[1] * 10 + domino[0];
            ret += num[val];
            num[val]++;
        }
        return ret;
    }
}

Tiempo de ejecución: 3 ms, derrotando al 85,51% de los usuarios de Java
Consumo de memoria: 47,6 MB, derrotando al 51,03% de los usuarios de Java

Bienvenido a prestar atención a mi cuenta oficial, LeetCode actualiza una pregunta todos los días