Para entender o problema de 15puzzle, aprendi sobre a primeira pesquisa e a primeira pesquisa. Vamos primeiro discutir a pesquisa de profundidade (DFS). O objetivo da profundidade é priorizar a busca por caminhos mais distantes do vértice inicial, enquanto a primeira pesquisa é procurar primeiro os caminhos mais próximos do vértice inicial. Gostaria de saber qual é a diferença entre a primeira pesquisa e o retorno? No Baidu, diz -se que o retorno é uma espécie de pesquisa profunda, mas a diferença é que o retorno não mantém a árvore de pesquisa. Então, e a Pesquisa em Faridade (BFS)? Quais são seus aplicativos? Resposta: O caminho mais curto, problema da divisão de vinhos, oito problemas digitais, etc. Vamos voltar ao ponto, aqui simplesmente implementei pesquisas amplas e pesquisas profundas usando o Java. Entre eles, a pesquisa profunda é implementada usando o gráfico + pilha e a pesquisa ampla é implementada usando o gráfico + fila. O código é o seguinte:
1. Crie um novo Nodirection -Graph representando "Gráfico não direcionado"
pacote com.wly.algorithmbase.datastructure;/** * Gráfico não direcionado * @author wly * */public class NodirectionGraph {private int mmaxSize; // o número máximo de verteias contido no gráfico privado graphvertex [] vertexlist; vértices privados int nvertex; // O número de vértices atualmente salvados nodirectiongraph (int maxSize) {mmaxsize = maxSize; vertexList = new Graphvertex [mmaxSize]; Indicatomat = new int [mmaxize] [mmaxSize]; nvertex = 0; j=0;j<mMaxSize;j++) {for (int k=0;k<mMaxSize;k++) {indicatorMat[j][k] = 0;}}}public void addVertex(GraphVertex v) {if(nVertex < mMaxSize) {vertexList[nVertex++] = v;} else {System.out.println ("--- A inserção falhou, o número de vértices atingiu o limite superior!");}}/*** Modifique a matriz de adjacência e adicione uma nova borda* @param start* @param end*/public void (int, int end) {indicatat [end] [end] [end]; INDIM INDIMENTO; Matriz de adjacência*/public void printIndicatorMat () {for (int [] linha: indicatormat) {for (int i: line) {System.out.print (i + "");} system.out.println ();}}/** ** Deepation do traitoming* @param vertexInMexr, reproduza, o ponto de partida do ponto de partida* @Println (); Matriz de adjacência do gráfico */public void dfs (int vertexindex) {ArrayStack Stack = new ArrayStack (); // 1. Adicione o elemento de pesquisa ao vertexlist da pilha [vertexindex] .setVisited (true); pilha.push (vertexindex); int nextVertexindex = getNextVertexindex (vertexindex); while (! Stack.isempty ()) {// Pressione continuamente a pilha e saia da pilha até que a pilha esteja vazia (o elemento de pesquisa não coloca a pilha) se (nextVertexindex! {Stack.pop ();} // Recupera se o elemento superior atual contém outros nós intimidados se (! Stack.isEmpty ()) {nextVertexindex = getNextVertexindex (Stack.Peek ());}}}/** * getNextVerTexIndex (int colun) {for (int i = 0; i <indicatomat [colun] .Length; i ++) {if (indicatomat [colun] [i] == 1 &&! vertexlist [i] .isvisited ()) {return i;}} retorn -1; Ponto de partida a atravessar, isto é, o número de linhas na matriz de adjacência do gráfico*/public void Bfs (int vertexindex) {ChainQueue fileue = new ChainQueue (); vertexlist [vertexindex] .Setvisited (trueee.eue.insert (new queuenode (vertex]. getNextVertexIndex (VertexIndex); while (! Queue.isEmpty ()) {if (nextVertexindex! = -1) {vertexlist [nextVertexindex] .SetVisited (true); Queue.insert (new Queuenode (nextVertexindex));} elseieeeTeET (); getNextVertexindex (Queue.peek (). Data); Queue.printelems ();}}}}2. Depois, há um pacote de matriz que é simulado com uma matriz
pacote com.wly.algorithmbase.datastructure;/***Use matrizes para implementar a estrutura da pilha*@Author Wly**/public class ArrayStack {private int [] Tarray; private int TopIndex = -1; // indica a posição do índice do elemento superior atual da parte superior da pilha private intacto_Step = 12; Array genérico ***/Tarray = new Int [CAPACIDADE_STEP];}/***Método para aparecer no elemento superior*@return*/public int pop () {if (isEmpty ()) {System.out.println ("Erro, o elemento na pilha está vazio, não pode pop"); return -1;} else {int i = Tarray [topIndex]; Tarray [topIndex--] = -1; // EASE o elemento pop Return i;}}/*** Insira um elemento no pilha* @param t*/public void push (int) {// verifique se o pilha é full if (topIndex === " new int [Tarray.Length + Capacate_Step]; para (int i = 0; i <Tarray.Length; i ++) {temparray [i] = Tarray [i];} Tarray = temparray; temparray = null;} else {topIndex ++; Tarray [topIndex] = t; {if (isEmpty ()) {System.out.println ("Erro, o elemento na pilha está vazio, não pode espiar"); retornar -1;} else {return Tarray [topIndex];}}/** *** printElems () {for (int i = 0; i <= topIndex; i ++) {System.out.print (Tarray [i]+"");} System.out.println ();}}3. Chainqueue em uma fila simulada com listas vinculadas
pacote com.wly.algorithmbase.datastructure;/** * Use a lista vinculada para implementar a fila * * @Author wly * */public class Cadeiaeue {private Queuenode Head; // apontar para a cabeça da fila * {//1/1/1 //) apontar para a cabeça {//1 //) apontar para a cauda da cauda (//) {//1 //) apontar para a cauda da cauda (//) para a cauda da cauda da fila = 0; novo nó na cauda da fila*/public void Insert (nó queuenode) {// É claro, você também pode escrever isso, adicione cauda.prev = node se (cabeça == null) {head = node; cauda = cabeça;} else {node.next = cauda; cauda. node;} size ++;}/*** Remova o nó da cabeça da fila*/public queuenode remove () {if (! isEmpty ()) {queuenode temp = head; head = head.Prev; size-; vazio * * @return */public boolean isEmpty () {if (size> 0) {return false;} else {return true;}}/** * retorna o primeiro nó da fila, mas não remove */public queuenode.OnOt.OnOt.Estin.Estin.Estin.Estin.Estin.Estin.Estint, (não, é (não, éPeeTy (não -), que é o quee -sety (não é, o que é o systeml (não -setyn) e não, que é o que é o que é o systeml. A fila atual está vazia! "); retornar nulo;}}/*** retornar o tamanho da fila** @return*/public int size () {return size;}/*** Imprima elementos na fila*/public void PrintElems () {queuenode tempnode = Head; while (TempNode! "); tempnode = tempnode.prev;} system.out.println ();}}/** * class class * * @author wly * */class queuenode {queuenode prev; queuenode a seguir; setData (int data) {this.data = data;}@substituir public string tostring () {// TODO Method Auto-Gerated Stub Super.toString (); retorna dados + "";}}4. Test Test_bfs_dfs
pacote com.wly.algorithmbase.search; importar com.wly.algorithmbase.datastructure.graphvertex; importar com.wly.algorithmbase.datastructure.nodirectionGraph;/** ** baseada em graph-first * @author wly * * * * */ {// Inicialize dados de teste NodirectionGraph Graph = new NodirectionGraph (7); Graph.addvertex (new GraphVertex ("A")); Graph.addvertex (new Graphvertex ("B"); Graphvertex (New Graphvertex ("C"); GraphVertex ("E")); Graph.addvertex (new Graphvertex ("F")); Graph.addvertex (new Graphvertex ("g")); graph.addedge (0, 1); graphded.addedge (0, 2); graph.addedge (1, 3); graphdedge (1, 4); 5); System.out.println ("-Matriz adjacente do gráfico-"); graf.printIndicatorMat (); // Teste o System.out.out.println ("-Prioridade profunda-"); graf.dfs (0); graph = new NodirectionGraph (7); graf.adDvertex (graphvertex; GraphVertex("B"));graph.addVertex(new GraphVertex("C"));graph.addVertex(new GraphVertex("D"));graph.addVertex(new GraphVertex("E"));graph.addVertex(new GraphVertex("F"));graph.addVertex(new GraphVertex ("g")); Graph.AddEdge (0, 1); Graph.AddEdDe (0, 2); Graph.AddEdge (1, 3); Graph.AddEdge (1, 4); Graph.AddEdge (3, 6); Graph.AddEdDe (2, 5); System.out.println ("-Passenity-" Wearch);A estrutura do gráfico testada aqui é a seguinte:
Os resultados da operação são os seguintes:
--Adjacent matrix of graph-- 0 1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Aqui precisamos explicar os resultados em execução de pesquisa profunda e ampla pesquisa acima, onde 0, 1, 2, 3 ... corresponde a A, B, C, D, respectivamente ... é um pouco confuso, por favor me perdoe ~~
Oh ~~~
Resumir
O exposto acima é todo o conteúdo deste artigo sobre a implementação de programação Java da profundidade baseada em gráficos e a primeira pesquisa e o primeiro código completo de pesquisa. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!