¿Qué es un algoritmo eficiente para encontrar una isla de 1s conectados en una matriz de 0s y 1s?

DFS se puede aplicar para resolver este problema # 2 en O (mxn) tiempo y O (mxn) espacio.

Mientras modela la ‘matriz’ como un gráfico:
1. Una matriz de elementos [i] [j] con valor 1 se considera como un vértice.
2. Todos los elementos adyacentes de la matriz [i] [j] con valor 1 se consideran sus vértices vecinos. Un elemento puede tener un máximo de ocho vecinos como se muestra a continuación.

Con este modelo gráfico en su lugar, utilizamos el siguiente algoritmo para encontrar el número total de clústeres:
1. Inicialice el recuento a 0. Inicialice una matriz 2D de “booleanos” que tiene un tamaño igual a la matriz dada. Inicialice todos los elementos de la matriz ‘visitada’ en falso.
2. Para una matriz de elementos [i] [j], si la matriz [i] [j] es ‘1’ y la visita [i] [j] es ‘falsa’, entonces
2a. Incrementar el recuento en 1.
2b. Inicie la primera búsqueda en profundidad desde la matriz de elementos [i] [j]. Junto con la matriz de elementos [i] [j], esta primera búsqueda profunda marcaría todos los vértices que están conectados directa o indirectamente a la matriz de elementos [i] [j] como visitados. En resumen, todos los vértices en el grupo a partir de la matriz de vértices [i] [j] se visitan en esta primera búsqueda en profundidad.
3. Repita el paso 2 para todos los elementos de una matriz 2D dada.
4. Devuelve el ‘conteo’, que es básicamente el número total de grupos de 1s en una matriz 2D dada.

Detalles en el siguiente enlace con Código y Video:

Número de grupos de 1s O Número de islas

Esta pregunta se puede resolver mediante recursividad. Código C ++:

#include
usando el espacio de nombres estándar;
int arr [100] [100];
int visitado [100] [100];
int n;
int dfs (int x, int y) {

int an = 1;

if (x <1 || x> n || y <1 || y> n) devuelve 0;

if (visitado [x] [y] ||! arr [x] [y]) devuelve 0;
visitado [x] [y] = 1;
if (! visitó [x-1] [y-1] && arr [x-1] [y-1] == 1) {
an + = dfs (x-1, y-1);
}

if (! visitó [x-1] [y] ||! arr [x-1] [y]) {
an + = dfs (x-1, y);

}

if (! visitó [x-1] [y + 1] ||! arr [x-1] [y + 1]) {
an + = dfs (x-1, y + 1);
}

if (! visitó [x] [y-1] ||! arr [x] [y-1]) {
an + = dfs (x, y-1);
}

if (! visitó [x] [y + 1] ||! arr [x] [y + 1]) {
an + = dfs (x, y + 1);
}

if (! visitó [x + 1] [y-1] ||! arr [x + 1] [y-1]) {
an + = dfs (x + 1, y-1);
}

if (! visitó [x + 1] [y] ||! arr [x + 1] [y]) {
an + = dfs (x + 1, y);
}

if (! visitó [x + 1] [y + 1] ||! arr [x + 1] [y + 1]) {
an + = dfs (x + 1, y + 1);
}

devolver un;

}
int main () {
cin >> n;
para (int i = 1; i <= n; i ++) {
para (int j = 1; j <= n; j ++) {
cin >> arr [i] [j];
}
}
int fans = 0;
para (int i = 1; i <= n; i ++)
para (int j = 1; j <= n; j ++) {
if (! arr [i] [j] || visitado [i] [j])
continuar;
fans = max (ventiladores, dfs (i, j));
}

cout << fans << endl;
devuelve 0;
}

No necesita verificar todas las instrucciones. Solo E, ES, S, SW son suficientes ya que las otras direcciones ya están cubiertas en la fila o columna anterior si hay un “1” presente en otras direcciones en futuras iteraciones.
Comprueba este código:

import java.util.Scanner;

Solución de clase pública {

visita pública nula estática (int [] [] ar, boolean [] [] v, int i, int j) {
int size = ar.length;
if (ar [i] [j] == 1) {
v [i] [j] = verdadero;
if (j> 0 && i visita (ar, v, i + 1, j-1); // Sur oeste
}
si (i visita (ar, v, i + 1, j); // sur
si (j visita (ar, v, i + 1, j + 1); // Sureste
}
si (j visita (ar, v, i, j + 1); // este
}
}

public static void main (String [] args) {
int [] [] ar;
int cuenta = 0;
Scanner sc = nuevo escáner (System.in);
int n = sc.nextInt ();
ar = nuevo int [n] [n];
booleano [] [] v = nuevo booleano [n] [n];
para (int i = 0; i para (int j = 0; j ar [i] [j] = sc.nextInt ();
v [i] [j] = falso;
}
}

para (int i = 0; i para (int j = 0; j if (ar [i] [j] == 1 &&! v [i] [j]) {
recuento ++;
visita (ar, v, i, j);
}
}
}
System.out.println (cuenta);
}
}

Puede responder esta pregunta con el algoritmo O (n ^ 2) + O (2n). Siga los pasos a continuación.

1. Use la matriz dada como matriz 2D y cree un gráfico. 1 sugiere borde entre dos vértices y 0 es opuesto. Ignorar cuando el origen y el destino del borde es el mismo. Entonces su gráfico contendría 3 aristas. (2,3) (3,4) (2,4)
2. Ahora aplique DFS para encontrar ciclos en un gráfico dado. Si se encuentra el ciclo, aumente el recuento. El recuento final será tu respuesta. Sería igual al número de islas en matriz.

Espero que entiendas. Sigue codificando … 🙂

Parece que estás tratando de encontrar los componentes fuertemente conectados en el gráfico representado por una matriz de adyacencia dada. Ese es un problema bastante estándar, y cualquiera de los algoritmos en el artículo de Wikipedia sobre componentes fuertemente conectados lo resolverá por usted.

Esto requiere el algoritmo SCC de Tarjan. Aquí está la manera de hacer esto correctamente: se le ha dado una Matriz de adyacencia [matemáticas] A [/ matemáticas]. Suponiendo que este gráfico no esté dirigido, esta matriz es triangular superior, es decir, [matemática] A = A ^ {T} [/ matemática]. Por lo tanto, elimine el rastro (los elementos diagonales -> los bucles automáticos no tienen significado) y corte una mitad triangular de la matriz (elija). Construya una lista de adyacencia usando el orden lexicográfico (dada una ventaja entre [math] v_ {1} [/ math] y [math] v_ {2} [/ math], imponga la dirección como [math] (v_ {1} v_ { 2}) [/ matemáticas]). Esto significaría que su Gráfico ahora está dirigido (forzado). Ahora, ejecuta Tarjan’s Algo y colapsarás los SCC.

Las dos preguntas no son independientes: si el número de islas> 0, eso significa que existe una isla. Por lo tanto, solo necesita el algoritmo para contar el número de islas

a [i, j] es la matriz 0s y 1s
isla [i, j] si el número de isla de esa celda.
head [k] es la isla “padre” de la isla [k].

simplemente necesitamos recorrer la matriz (de arriba abajo, de izquierda a derecha) y verificar si nuestra celda actual está conectada a alguna isla anterior a la izquierda y arriba. Solo hay 3 casos:
– la celda a la izquierda es una celda 1 -> conecta esa celda a la isla de su izquierda
– la celda de arriba es una celda de 1 -> conecta esa celda a la isla de la celda de arriba
– ambas celdas son celdas 1 -> conecta las dos islas (haz que una isla sea hija de la otra, cambiando de cabeza) y marca la celda actual que pertenece a esa isla.

Al final, el número de islas es el número de elementos en el encabezado de la matriz.

Es una cuestión de DFS simple o BFS (cualquier recorrido de gráfico).

Encuentra el número de islas | Conjunto 1 (usando DFS) – GeeksforGeeks

se puede hacer por conjunto disjunto también

http://www.geeksforgeeks.org/fin …

Algoritmo de relleno de inundación

http://en.m.wikipedia.org/wiki/F …

Algoritmo de relleno de inundación

Inundación

Recientemente tuve un informe sobre este problema. No estoy seguro si a alguien le importa, pero aquí está el siguiente enlace.

Encontrar islas en una matriz binaria