Programando Number of Islands en Python

Curso de Algoritmos Avanzados: Grafos y Árboles

Introducción

¿Qué es un grafo?

¿Qué es un árbol?

¿Qué es recursión?

Aplicaciones reales de grafos y árboles

Formas de representar un grafo

DFS

Análisis de DFS: algoritmo de búsqueda en profundidad

Programando DFS de forma recursiva

Otras formas de programar DFS

Recorridos y profundidad de un Árbol

Sum Root to Leaf Numbers: análisis del problema

Solución de Sum Root to Leaf Numbers

Playground: Sum Root to Leaf Numbers

Programando Sum Root to Leaf Numbers en Golang

Number of Islands: análisis del problema

Solución de Number of Islands

Playground: Number of Islands

Programando Number of Islands en Python

Ejercicios recomendados de DFS

Ejercicios resueltos de DFS

BFS

Análisis de BFS: algoritmo de búsqueda en anchura

Programando BFS con Python

Minimum Knights Moves (movimientos de caballo en ajedrez): análisis del problema

Solución de Minimum Knights Moves

Playground: Minimum Knights Moves

Programando Minimum Knights Moves con Python

Rotting Oranges: análisis del problema

Solución de Rotting Oranges

Playground: Rotting Oranges

Rotting Oranges con Java

Shortest Bridge Between Islands: análisis del problema

Solución de Shortest Bridge Between Islands

Playground: Shortest Bridge Between Islands

Programando Shortest Bridge Between Islands con Python

Ejercicios recomendados de BFS

Ejercicios resueltos de BFS

Backtrack

Algoritmo de Backtrack

Letter Combinations of a Phone Number: análisis del problema

Solución de Letter Combinations of a Phone Number

Programando Letter Combinations of a Phone Number con C++

Playground: Letter Combinations of a Phone Number

Restore IP Addresses: análisis del problema

Programando Restore IP Addresses con C++

Playground: Restore IP Addresses

Word Search: análisis del problema

Solución de Word Search

Playgrund: Word Search

Programando Word Search JavaScript

Reto: N Queens Puzzle

Ejercicios recomendados de Backtrack

Ejercicios resueltos de Backtrack

Próximos pasos

¿Qué otros algoritmos y tipos de grafos puedes aprender?

¿Quieres más cursos avanzados de algoritmos?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Iniciar sesión

Recursos

Aportes 4

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

David Cervantes Arrioja

hace 5 meses

En Java

class Solution {
    static int islandNumbers;
    public int numIslands(char[][] grid) {
        islandNumbers = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length ; j++){
                if(grid[i][j] == '1'){
                    dfs(i,j, grid);
                    islandNumbers++;
                }
            }
        }
        return islandNumbers;
    }

    public void dfs(int i, int j, char[][] grid){
        if(i>=0 && i<grid.length && j>=0 && j<grid[0].length && grid[i][j] == '1'){
            grid[i][j] = '2';
            dfs(i, j+1, grid); 
            dfs(i, j-1, grid);
            dfs(i+1, j, grid);
            dfs(i-1, j, grid);

        }
    }
}

JergCode

hace 7 meses

Esta es mi solución en Kotlin:

fun main() {
    val map = listOf(
        mutableListOf(1, 1, 0, 0, 0, 0, 1, 0),
        mutableListOf(1, 0, 0, 1, 1, 0, 0, 0),
        mutableListOf(0, 0, 0, 1, 1, 0, 0, 1),
        mutableListOf(0, 0, 0, 0, 0, 1, 1, 1),
    )

    val count = countIslands(map);

    println("The number of Island in the map is: $count")
}

fun countIslands(map: List<MutableList<Int>>): Int {
    var count = 0
    for (i in map.indices) {
        for (j in map[i].indices) {
            if (map[i][j] == 1) {
                inspectIsland(map, i, j)
                count++
            }
        }
    }
    return count
}

Daniel Villacis

hace 3 horas

La solución pasada a C# `List<List<int>> inputData = new()` `{` ` new List<int>() { 1, 1, 1, 0, 0 },` ` new List<int>() { 1, 1, 0, 0, 0 },` ` new List<int>() { 0, 0, 0, 1, 1 },` ` new List<int>() { 1, 1, 0, 0, 0 },` ` new List<int>() { 1, 1, 0, 1, 1 }` `};` `void dfsInslands(int i, int j)` `{` ` if (0 <= i && i < inputData.Count && 0 <= j && j < inputData.Count && inputData[i][j] == 1)` ` {` ` inputData[i][j] = 2;` ` dfsInslands(i + 1, j);` ` dfsInslands(i - 1, j);` ` dfsInslands(i, j - 1);` ` dfsInslands(i, j + 1);` ` }` `}` `int CountIslands(List<List<int>> islands)` `{` ` int count = 0;` ` for (int i = 0; i < islands.Count; i++)` ` for (int j = 0; j < islands.Count; j++)` ` if (islands[i][j] == 1)` ` {` ` dfsInslands(i, j);` ` count++;` ` }` ` return count;` `}` `Console.WriteLine("TOTAL OF ISLANDS {0}",CountIslands(inputData));`

Fernando Sánchez Mejía

hace 6 meses

Jeje si leí el cuento de Hansel y Gretel.