Reto: N Queens Puzzle

Curso de Algoritmos Avanzados: Grafos y Árboles

Introducción

Estructuras de Datos: Grafos y Árboles en Profundidad

Estructuras de Árbol: Nodos, Raíces y Jerarquías

Recursión y secuencia de Fibonacci en programación

Aplicaciones Prácticas de Grafos en Tecnología

Representación de Grafos: Matriz y Lista de Adyacencia

DFS

Recorrido en Profundidad (DFS) en Árboles y Grafos

Algoritmo DFS en JavaScript: Búsqueda en Árboles

Búsqueda en Profundidad (DFS) en Grafos: Iterativa y Recursiva

Recorridos en Árboles: Inorder, Preorder y Postorder

Suma de Números en Caminos Raíz-Hoja en Árboles Binarios

Suma de Caminos en Árbol con DFS en Python

Playground: Sum Root to Leaf Numbers

Implementación de Árboles Binarios en Golang

Algoritmo DFS para Contar Islas en Matrices Binarias

Conteo de Islas en Matrices con DFS

Playground: Number of Islands

Programación Recursiva: Resolver Problemas con DFS en Python

Rellenar Sección de Imagen con Algoritmo DFS

Búsqueda en Profundidad para Procesamiento de Imágenes

BFS

Algoritmo BFS: Exploración en Anchura de Grafos y Árboles

Implementación de BFS en Árboles con Python

Algoritmo BFS para mover el caballo de ajedrez

Saltos mínimos con caballo en ajedrez infinito: Resuelve BFS.

Playground: Minimum Knights Moves

Suma de matrices en Python: Paso a Paso

Propagación de Plagas en Matrices: Cálculo de Días Totales

Propagación de plagas con BFS en matrices cuadradas

Playground: Rotting Oranges

Matrices y Algoritmos: Implementación en Java

Puente más Corto entre Islas en Matrices Binarias

Construcción de Puentes Cortos entre Islas en Matrices Numéricas

Playground: Shortest Bridge Between Islands

Resuelve problemas con el algoritmo Breadth-First Search en Python

Búsqueda Breadth-First (BFS) en Grafos: Conceptos y Ejercicios

Búsqueda en Anchura para Problemas de Grafos

Backtrack

Solución de Problemas con Algoritmo Backtracking en Laberintos

Combinaciones de Letras en Números Telefónicos

Combinaciones de Letras en Números Telefónicos con Backtracking

C++: Generación de combinaciones en un teclado numérico

Playground: Letter Combinations of a Phone Number

Formación de direcciones IP válidas a partir de cadenas numéricas

Algoritmo para Crear Direcciones IP Válidas en C++

Playground: Restore IP Addresses

Resolución del Problema Word Search en Tableros MxN

Búsqueda de palabras en matrices usando backtracking y DFS

Playgrund: Word Search

Búsqueda de Palabras en Matrices con JavaScript

Algoritmos para resolver N-Reinas en Python

Programación backtracking para resolver Sudoku

Combinaciones Únicas de Sumas de Enteros

Próximos pasos

Árboles AVL: Balanceo Automático en Estructuras de Datos

Algoritmos de Búsqueda Eficientes y Su Aplicación Práctica

N-Queens

El rompecabezas de n reinas es el problema de colocar n reinas en un tablero de ajedrez de n x n de manera que ninguna de ellas se ataque mutuamente.
Dado un número entero n, devuelva todas las soluciones distintas del rompecabezas de n reinas. Puede devolver la respuesta en cualquier orden. Cada solución contiene una configuración del tablero distinta de la colocación de n reinas, donde “Q” y “.” indican una reina y un espacio vacío, respectivamente.

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 1

Preguntas 0

Ordenar por:

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

Carlos Hernandez

hace 2 meses

Mi solución: ```js def check_valid_board(board, queens, n): DIRECTIONS = [(1, 1), (1, -1), (-1, 1), (-1, -1)] for queen in queens: for direction in DIRECTIONS: i, j = queen offset_i, offset_j = direction while True: i += offset_i j += offset_j if i < 0 or i >= n or j < 0 or j >= n: break if board[i][j] == 'Q': return False return True def append_queen_to_board(i, combinations, taken_columns, queens, n, current_board): if len(queens) == n: splitted_board = current_board.split("|") if check_valid_board(splitted_board, queens, n): combinations.append(splitted_board) return current_board += '|' for index in range(n): if index not in taken_columns: current_combination = '.' * index + 'Q' + '.' * (n - index - 1) append_queen_to_board(i + 1, combinations, taken_columns + [index], queens + [(i + 1, index)], n, current_board + current_combination) def n_queens(n): combinations = [] taken_columns = [] queens = [] for i in range(n): current_board = '.' * i + 'Q' + '.' * (n - i - 1) append_queen_to_board(0, combinations, taken_columns + [i], queens + [(0, i)], n, current_board) return combinations ```