Pregunta diaria de Leetcode: 1267. Estadísticas de servidores que participan en la comunicación

Titulo original

Aquí hay un mapa de distribución del servidor. La ubicación del servidor está marcada en  m * n la cuadrícula de matriz de números enteros  grid . 1 significa que hay un servidor en la celda y 0 significa que no hay ningún servidor.

Si dos servidores están en la misma fila o columna, asumimos que pueden comunicarse entre sí.

Cuente y devuelva la cantidad de servidores que pueden comunicarse con al menos otro servidor.

Ejemplo 1:

Entrada: grid = [[1,0],[0,1]]
 Salida: 0
 Explicación: Ningún servidor puede comunicarse con otros servidores.

Ejemplo 2:

Entrada: grid = [[1,0],[1,1]]
 Salida: 3
 Explicación: Todos estos servidores pueden comunicarse con al menos otro servidor.

Ejemplo 3:

Entrada: grid = [[1,1,0,0],[0,0,1,0],[0,0,1,0],[0,0,0,1]]
 Salida: 4
 Explicación: Los dos servidores de la primera fila se comunican entre sí, los dos servidores de la tercera columna se comunican entre sí, pero el servidor de la esquina inferior derecha no puede comunicarse con los otros servidores.

pista:

• m == grid.length
• n == grid[i].length
• 1 <= m <= 250
• 1 <= n <= 250
• grid[i][j] == 0 or 1

Fuente: sitio web oficial de LeetCode: la plataforma de crecimiento tecnológico amada por los geeks de todo el mundo

Ideas para resolver problemas

Una vez que comprendamos la pregunta, descubriremos que la pregunta requiere que cuentemos el número de unos en cada fila y columna que son mayores o iguales a 2 en las filas y columnas. Una forma sencilla de resolver el problema es contar el número de unos en cada fila y columna, y luego recorrer cada punto con un valor de 1 para ver si el número de unos en la fila y columna es mayor o igual a 2. Entonces obtenemos la implementación de la solución oficial:

class Solution {
public:
    int countServers(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        unordered_map<int, int> rows, cols;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1) {
                    ++rows[i];
                    ++cols[j];
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1 && (rows[i] > 1 || cols[j] > 1)) {
                    ++ans;
                }
            }
        }
        return ans;
    }
};

作者：力扣官方题解
链接：https://leetcode.cn/problems/count-servers-that-communicate/solutions/101819/tong-ji-can-yu-tong-xin-de-fu-wu-qi-by-leetcode-so/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Solución del problema de optimización.

La solución oficial requiere atravesar todos los puntos dos veces ¿Hay algún margen de optimización? De hecho, cuando recorremos cada fila, si el número de unos en la fila es mayor o igual a 2, entonces todos son puntos que coinciden con el resultado. Si es exactamente igual a 1, entonces es necesario determinar posteriormente si el número de puntos 1 en esta columna es mayor o igual a 2. Por lo tanto, podemos recopilarlos primero y juzgarlos finalmente, de modo que la complejidad temporal de nuestra segunda ronda pueda reducirse a O (n). Basado en esta idea, nuestra versión optimizada:

class Solution {
public:
    int countServers(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        unordered_map<int, int> cols;
        int ans = 0,col = 0, rows=0;
        vector<int> srows;
        for(int i = 0; i < m;i++){
            rows=0;
            for(int j =0;j< n;j++){
                if(grid[i][j] == 1){
                    ++rows;
                    ++cols[j];
                    col = j;
                }
            }
            if(rows >= 2){
                ans+=rows;
            }else if(rows == 1){
                srows.emplace_back(col);
            }
        }
        for(int &j:srows){
            if(cols[j]>=2){
                ++ans;
            }
        }
        return ans;
    }
};