Buscando una matriz para una cadena de sumas -- java campo con algorithm campo con matrix campo con multidimensional-array campo con depth-first-search camp Relacionados El problema

Searching a matrix for a chain of sums


0
vote

problema

Español

Todavía estoy tratando de mejorar en mis habilidades de codificación, y esta pregunta me ha gustando un poco en mis pistas, por lo que cualquier ayuda es muy apreciada. Sé cómo crear la matriz aleatoria muy fácilmente, no hay problema con eso. Sin embargo, la lógica de encontrar la cadena está demostrando ser muy difícil para mí. Creo que el enfoque adecuado es una especie de algoritmo en primer lugar de la profundidad, pero no estoy totalmente seguro de cómo implementar eso en este escenario, o si eso es incluso correcto.

Mi pregunta básica es, ¿debería estar usando la primera búsqueda de profundidad, y si es así, si lo estoy haciendo recursivamente? ¡Cualquier consejo o sugerencias en la implementación también son bienvenidos!

Hacer un programa que crea una cuadrícula de 3x3 de un azar números positivos donde 0 & lt; = n & lt; = 9. El programa debe Encuentra todas las combinaciones posibles de números que se suman al área de La cuadrícula, o 9, utilizando estas reglas (similar a Boggle):

a. Los números deben estar "encadenados" en células secuencialmente adyacentes, donde Las células "adyacentes" son aquellas horizontalmente, verticales y diagonalmente vecino

b. La cadena no tiene que estar en una línea. Por ejemplo, podría ir. horizontalmente una vez, luego verticalmente una vez, y finalmente diagonalmente una vez

c. Al menos las células "Anchura de la cuadrícula - 1" deben usarse en la cadena (a La cuadrícula 3x3 significa que se deben usar al menos dos células)

d. Una cadena no puede repetir una célula de cuadrícula que ya ha usado

e. Cadenas que usan las mismas celdas exactas que una cadena anterior son considerado repeticiones y no debe contarse

Sé que para cada elemento, cuando está buscando a través de cada elemento adyacente, debe verificar y realizar un seguimiento de si se ha visitado antes, para que no repita los números.

  public class GridSolver { int[][] workingGrid;  public GridSolver(int[][] workingGrid){     this.workingGrid = workingGrid; }  public String solve(){     int length = this.workingGrid.length;     boolean[][] visited = new boolean[length][length];      for(int rows=0; rows<length; rows++){         for(int columns=0; columns<length; columns++){             if(visited[rows][columns] == false){                 dfs(workingGrid[rows][columns]);             }         }     }     return null; }      public HashSet<ArrayList<Integer>> dfs(int element){     HashSet<ArrayList<Integer>> chains = new HashSet<>();      checkLeft();     checkTopLeft();     checkTopMiddle();     checkTopRight();     checkRight();     checkBottomRight();     checkBottomMiddle();     checkBottomLeft();      return null; }}   

Esto es lo que tengo hasta ahora y me doy cuenta de que es bastante descuidado y no el mejor esquema de pensamiento, pero por eso estoy aquí, supongo: P.

También solo para explicar algunos de mi pensamiento en el Código, el método dfs()1 tiene un tipo de devolución de hashset porque sé que no puede tener cadenas duplicadas, y es un conjunto de una Lista de las cadenas. Además, los métodos de "cheque" no se implementan, acabo de escribirlos porque sé que deberá procesar cada uno de estos bloques adyacentes para cada número.

Una vez más, cualquier ayuda es muy apreciada, y gracias por ayudarme como un principiante aquí!

Original en ingles

I'm still trying to improve on my coding skills, and this question has got me spinning in my tracks a little bit, so any help is greatly appreciated. I know how to create the random array very easily, no problem with that. However, the logic of finding the chain is proving very difficult for me. I believe the proper approach is some sort of depth first searching algorithm, but I'm not entirely sure of how to implement that in this scenario, or whether that is even correct.

My basic question is, should I be using depth first search, and if so, should I be doing it recursively? Any tips or hints on implementation are also welcome!

Make a program that creates a 3x3 grid of random positive numbers where 0 <= n <= 9. The program should find all possible combinations of numbers that add up to the area of the grid, or 9, using these rules (similar to Boggle):

a. The numbers must be "chained" in sequentially adjacent cells, where "adjacent" cells are those horizontally, vertically, and diagonally neighboring

b. The chain does not have to be in a line. For example, it could go horizontally once, then vertically once, and finally diagonally once

c. At least the xe2x80x9cgrid width - 1xe2x80x9d cells must be used in the chain (a 3x3 grid means that at least two cells must be used)

d. A chain cannot repeat a grid cell that it has already used

e. Chains that use the exact same cells as a previous chain are considered repeats and should not be counted

I know that for each element, when you are searching through each adjacent element, you must check and keep track of whether it's been visited before, so you don't repeat numbers.

public class GridSolver { int[][] workingGrid;  public GridSolver(int[][] workingGrid){     this.workingGrid = workingGrid; }  public String solve(){     int length = this.workingGrid.length;     boolean[][] visited = new boolean[length][length];      for(int rows=0; rows<length; rows++){         for(int columns=0; columns<length; columns++){             if(visited[rows][columns] == false){                 dfs(workingGrid[rows][columns]);             }         }     }     return null; }      public HashSet<ArrayList<Integer>> dfs(int element){     HashSet<ArrayList<Integer>> chains = new HashSet<>();      checkLeft();     checkTopLeft();     checkTopMiddle();     checkTopRight();     checkRight();     checkBottomRight();     checkBottomMiddle();     checkBottomLeft();      return null; }} 

This is what I have so far and I realize that it is pretty sloppy and not the best thought out scheme, but that's why I'm here I guess :P.

Also just to explain some of my thinking in the code, the dfs()method has a return type of HashSet because I know that you can't have duplicate chains, and it is a set of a list of the chains. Also the "check" methods are not implemented, I just wrote them down because I know that you will need to process each of these adjacent blocks for each number.

Once again, any help is greatly appreciated, and thank you for humoring me as a beginner here!

              
   
   

Lista de respuestas


Relacionados problema

0  Profundidad primera búsqueda recursivamente desde el primer vértice a la última java  ( Depth first search recursively from first vertex to last java ) 
Tengo una tarea en la que tenemos una matriz de vértices, cada vértice tiene una lista de matriz con vértices adyacentes. El objetivo es usar encontrar un cam...

2  Ordenar números en orden lexicográfico de sus factores primordiales  ( Sort numbers in lexicographical order of their prime factors ) 
Estoy tratando de resolver un problema algorítmico que me obliga a ordenar una lista de números de tamaño N (N & LT; = 1E6) basado en el orden lexicográfico d...

1  Encontrar un camino más largo en un árbol no dirigido  ( Finding longest path in an undirected tree ) 
Estaba tratando de encontrar el camino más largo en un árbol no dirigido ( http: //www.spoj. COM / PROBLEMAS / PT07Z / ) e hizo el siguiente código. #inclu...

0  Grabación de predecesores en una búsqueda DFS en un gráfico no dirigido  ( Recording predecessors in a dfs search in an undirected graph ) 
Estaba tratando de usar el código de este hilo: BOOST DFS back_edge , para registrar los ciclos en un gráfico no dirigido. Para hacer esto, necesito almacena...

0  Modificaciones de BFS / DFS para verificar caminos simples  ( Modifications of bfs dfs to check simple paths ) 
Tengo que diseñar un algoritmo a partir de BFS o DFS para hacer lo siguiente, dado g = (v, e) un gráfico dirigido: Compruebe si hay como máximo una ruta sim...

0  Generación de gráficos DFS en Python  ( Dfs graph generation in python ) 
Así que estoy tratando de ser un poco más competente con Python, y decidí que hacer un laberinto sería una cosa divertida para saber cómo hacerlo. Encontré e...

2  Unión: encontrar algoritmo y determinar si un borde pertenece a un ciclo en un gráfico  ( Union find algorithm and determining whether an edge belongs to a cycle in a gra ) 
Estoy leyendo un libro sobre algoritmos ("estructuras de datos y algoritmos en C ++") y se han encontrado con el siguiente ejercicio: ex. 20. Modificar cy...

4  Método rápido de ajuste de azulejos / arreglos  ( Fast method of tile fitting arranging ) 
Por ejemplo, digamos que tenemos una cuadrícula 2D limitada que queremos cubrir con baldosas cuadradas de igual tamaño. Tenemos un número ilimitado de azulejo...

0  ¿Algoritmo DFS para el problema de 8 rompecabezas no devuelve nada?  ( Dfs algorithm for 8 puzzle problem doesnt return anything ) 
Así que he estado tratando de resolver el problema de 8 Puzzle utilizando la búsqueda de profundidad, donde el objetivo es obtener el número mínimo de pasos (...

1  ¿Cuál es la cantidad total de secuencias de Travesals de DFS y BFS para un gráfico?  ( What is the total number of dfs and bfs travesals sequences possible for a graph ) 
¿Hay una fórmula generalizada? ¿Cuál será la forma más eficiente de contar las secuencias de DFS / BFS total para un gráfico? ...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos