WEBVTT

00:02.560 --> 00:05.970
Bem-vindo de volta à parte seis sobre o algoritmo da Páscoa.

00:05.980 --> 00:12.190
Agora, embora eu tenha dito que o conceito é realmente simples, o código continua e continua, mas estamos quase, quase

00:12.190 --> 00:12.880
acabando.

00:12.880 --> 00:15.220
Acho que poderia ter dito isso no último vídeo.

00:15.460 --> 00:18.010
De qualquer forma, o que você tem até agora, você deve ser capaz de correr.

00:18.010 --> 00:20.740
Portanto, espero que você tenha dado uma pequena olhada nisso.

00:21.390 --> 00:27.000
Mas se você não conseguia entender o que estava acontecendo, vamos fazer isso com você.

00:27.030 --> 00:31.670
Então vamos brincar com a imprensa e vamos gerar nossos dez por dez labirintos.

00:31.680 --> 00:32.640
Portanto, aqui está ele.

00:32.640 --> 00:33.270
Aqui.

00:33.330 --> 00:40.750
Agora, se pressionarmos a tecla P, teremos um sistema de nó inicial e final sentados lá dentro.

00:40.770 --> 00:49.200
Agora, quando você atingir C, vai gerar posições sobre, você sabe, para começar a explorar basicamente.

00:49.200 --> 00:58.050
Vamos ver se eu consigo dar a volta a isso para que possamos ver os valores nesses nós.

00:58.050 --> 00:58.590
Aí está.

00:58.590 --> 01:03.670
Portanto, temos os valores G, H e F ali dentro.

01:03.690 --> 01:08.670
Agora, se atingirmos C novamente, então começaremos a acrescentar mais.

01:08.670 --> 01:15.930
Agora, quando um nó é explorado e colocado fechado, ele se torna vermelho, o que significa que não o exploramos novamente.

01:16.500 --> 01:22.950
Então, continuamos e você verá que estamos procurando em ambas as direções até

01:22.950 --> 01:26.130
encontrarmos um caminho até o final.

01:26.130 --> 01:29.880
Nesse ponto, se você continuar batendo em C, nada vai acontecer.

01:29.880 --> 01:37.800
Então, na verdade, descobrimos aqui que nossa posição final desta forma não funcionou, nós corremos para fora.

01:37.950 --> 01:43.710
E o que temos que fazer agora é realmente conseguir o caminho.

01:43.920 --> 01:50.490
O caminho não é todo dos nós vermelhos, ok, porque eles estão aqui.

01:50.700 --> 01:53.730
Portanto, o caminho para chegar até aqui não envolve realmente estes nós.

01:53.730 --> 01:55.590
Acabamos de pesquisar através deles.

01:55.590 --> 02:03.510
O caminho pode ser encontrado pegando o último nó e realmente trabalhando em nosso caminho de volta ao local de

02:03.510 --> 02:04.820
onde começamos.

02:04.830 --> 02:11.760
Agora, neste ponto, você pode bater a tecla p e, devido à maneira como codificamos isto, você pode começar

02:11.760 --> 02:16.290
de novo e depois trabalhar com isso em seu próprio ritmo.

02:16.290 --> 02:22.350
Para obter uma melhor compreensão, você poderá ver como os valores G, H e F são atualizados e alterados

02:22.350 --> 02:23.230
aqui.

02:23.250 --> 02:27.110
Agora, se você quiser trabalhar com um labirinto maior, você pode fazer isso também.

02:27.120 --> 02:36.390
Portanto, se clicarmos em nosso labirinto e entrarmos no roteiro recursivo e mudarmos isso para dizer 30 por 30 e depois pressionarmos

02:36.390 --> 02:41.370
play, você verá como o algoritmo se comporta em um cenário maior.

02:41.370 --> 02:46.260
Agora, é claro, teríamos que ampliar para ver realmente tudo, o que significa que você

02:46.470 --> 02:51.720
pode perder muito dos detalhes dos valores F, mas pode não estar interessado nisso.

02:51.720 --> 02:57.420
Então, deixe-me clicar aqui e chegamos ao P, aí está nosso começo e fim e então você

02:57.930 --> 03:07.020
pode simplesmente chegar ao C até que continuemos e continuemos até chegarmos ao fim e encontrarmos um caminho que pode levar um

03:07.020 --> 03:08.490
pouco de tempo.

03:08.490 --> 03:13.980
Portanto, não vou sentar aqui e continuar fazendo isso, mas vocês verão novamente como temos muitos

03:13.980 --> 03:20.700
nós fechados na busca que está acontecendo aqui, o que provavelmente não vai fazer parte deste caminho real para chegar

03:20.700 --> 03:22.200
a este ponto.

03:22.200 --> 03:24.300
E nós queremos trabalhar ao contrário.

03:24.630 --> 03:25.140
Certo.

03:25.140 --> 03:31.110
Portanto, esse é o último pedaço que realmente temos que colocar em nosso código é conseguir o caminho.

03:31.710 --> 03:36.060
Cada vez que pressionamos C, vamos fazer uma busca com nossa última posição.

03:36.060 --> 03:43.140
Agora, se voltarmos à nossa busca, a última posição é definida no final, que é o marcador

03:43.140 --> 03:46.410
da lista aberta com o menor valor.

03:46.530 --> 03:53.010
E então, se olharmos para o topo e lembrarmos o que fizemos é que se passarmos por este nó e ele estiver

03:53.010 --> 04:00.240
realmente à altura do nó de objetivo, ele simplesmente retornará sem fazer nada e se colocará em pé de igualdade

04:00.240 --> 04:02.550
com a verdade.

04:02.550 --> 04:10.290
Isso significa que depois de termos terminado de encontrar o local da meta e o que eu vou fazer aqui para ter

04:10.290 --> 04:16.710
certeza de que não vamos continuar tentando correr o que está colocado e não feito.

04:17.910 --> 04:22.050
Basicamente, isso vai nos impedir de fazer qualquer coisa quando pressionamos.

04:22.050 --> 04:25.320
Veja, agora, o que temos a esta altura?

04:25.320 --> 04:34.110
Bem, se olharmos para um mapa de exemplo, o que você verá é um monte de nós fechados ali, todos os vermelhos.

04:34.110 --> 04:39.690
Este não é o caminho, como eu disse, estes são apenas todos os caminhos que exploramos e que possivelmente podem

04:39.690 --> 04:40.830
estar no caminho.

04:40.890 --> 04:50.190
Os que estão no caminho são os que estão ligados por esse valor de pais que somamos aqui mesmo.

04:50.460 --> 04:53.910
Portanto, aqui está nosso valor paternal em nosso marcador de caminho.

04:53.910 --> 05:02.910
Portanto, se conseguirmos nosso último nó, nosso nó de localização de objetivo e o seguirmos de trás para frente até seu pai, então

05:02.910 --> 05:07.680
pegue o pai daquele e o pai daquele até que você volte ao início.

05:07.680 --> 05:12.420
Na verdade, teremos nosso caminho estrelado.

05:13.290 --> 05:13.740
Certo.

05:13.740 --> 05:20.910
Portanto, considerando o tempo em que esta chave C já não funciona mais e está pronta.

05:21.050 --> 05:22.910
É igual a verdade.

05:22.940 --> 05:30.800
O valor da última posição vai ter a posição de objetivo nela.

05:31.310 --> 05:38.390
Levando isso em consideração, vamos usar isso para retroceder através da lista dos pais.

05:38.450 --> 05:50.120
Portanto, vamos colocar aqui outra IFF, coloque um ponto de entrada para baixar a chave e eu colocarei um ponto de código m para o mapa, neste

05:50.120 --> 05:50.720
caso.

05:51.470 --> 05:58.550
E então, se for esse o caso, vamos conseguir o caminho.

05:59.060 --> 06:02.840
É claro que ainda não escrevemos isso, portanto, isso vai estar acima da atualização.

06:03.810 --> 06:04.450
Vazio.

06:04.530 --> 06:05.760
Trace o caminho.

06:05.880 --> 06:15.180
E aqui, o que vou fazer é, antes de mais nada, remover todos os marcadores, o que significa que já limpamos todos aqueles pequenos blocos

06:15.180 --> 06:22.140
do mapa e podemos realmente colocar os marcadores exatamente onde está o caminho e vamos conseguir nossa

06:22.380 --> 06:24.150
posição inicial.

06:24.150 --> 06:26.670
Portanto, marcador de caminho.

06:27.720 --> 06:31.890
O início é igual à última pausa.

06:33.960 --> 06:34.830
Certo.

06:35.490 --> 06:40.110
Agora, você não achou que seria tão fácil ou que eu o deixaria sair tão facilmente?

06:40.350 --> 06:44.520
O que eu gostaria que você fizesse como um desafio é terminar este método.

06:44.520 --> 06:52.350
Portanto, você vai ter que começar com a última pausa e fazer um loop up de alguma forma através de todos os pais.

06:52.350 --> 06:58.800
Cada vez que você encontra o pai, você quer colocar um marcador no mapa naquele local.

06:58.800 --> 07:02.620
E isto vai acontecer quando você pressionar a tecla.

07:02.640 --> 07:09.270
Uma vez que você tenha passado por todos os C's e ficou sem marcadores reais e encontrou um caminho,

07:09.600 --> 07:14.130
ok, então faça uma pausa no vídeo agora e dê uma chance.

07:14.130 --> 07:17.040
E quando voltarmos, eu lhe mostrarei minha solução.

07:19.430 --> 07:20.090
Certo.

07:20.180 --> 07:22.500
Como você reagiu a isso?

07:22.520 --> 07:27.110
Um pouco de desafio, mas nada que tenho certeza de que você não consiga lidar.

07:27.470 --> 07:29.420
Vou usar um laço de parede para o meu.

07:29.420 --> 07:34.670
Portanto, embora não estejamos no nó inicial.

07:34.670 --> 07:35.240
Então comece.

07:35.240 --> 07:39.020
O ponto do nó é igual ao início.

07:39.230 --> 07:40.270
Então, vamos começar.

07:40.280 --> 07:46.070
Não é o mesmo que o nó inicial e o início não é igual a nulo.

07:47.240 --> 07:51.830
Portanto, esperamos ter um marcador de caminho a partir do qual possamos realmente começar.

07:51.860 --> 07:55.640
Embora isto seja verdade, vamos instanciar.

07:57.360 --> 08:11.010
Um caminho pe pré-fabricado na posição tão novo vetor três e será começar localização ponto x e não se esqueça de multiplicá-lo

08:11.010 --> 08:26.100
por nosso labirinto escala ponto zero e depois começar localização ponto z multiplicado por escala ponto labirinto e depois, é claro,

08:26.640 --> 08:29.460
um gatinho dentro.

08:30.960 --> 08:32.560
Identidade do ponto.

08:32.580 --> 08:35.040
Apenas para terminar a criação.

08:35.340 --> 08:41.240
Agora isso cria um bloco ou um marcador naquela última pausa.

08:41.250 --> 08:48.750
Queremos agora chegar ao pai da última pausa ou, neste caso, começar, porque já começamos no início.

08:48.930 --> 08:55.560
Portanto, o que vamos fazer é dizer que começar agora é igual a começar ponto pai.

08:57.300 --> 08:58.080
Assim.

08:59.400 --> 09:00.540
Muito bem, ótimo.

09:00.540 --> 09:08.010
Agora, uma vez feito isso, podemos também colocar ali o nó inicial, aquele de onde realmente partimos,

09:08.010 --> 09:11.850
caso não esteja em nenhuma dessas listas.

09:11.850 --> 09:17.010
E o nó inicial na verdade não tem pais nem nada, por isso pode ser deixado de fora.

09:17.010 --> 09:19.170
Portanto, vou apenas instanciar isso.

09:20.710 --> 09:40.870
Caminho ervilha novo vetor três ponto de localização do nó de partida ponto x multiplicado por nosso labirinto escala ponto zero e nossa partida.

09:41.740 --> 09:49.990
Localização do ponto do nó e multiplicado por nossa escala de pontos do labirinto.

09:51.550 --> 09:56.650
E depois uma reviravolta na identidade.

09:57.190 --> 10:04.450
Ok, agora, porque estamos fazendo looping enquanto não estamos à altura do início, o que significa que realmente

10:04.450 --> 10:10.780
temos que fazer isso aqui no final e não esquecer de colocar uma vírgula no final.

10:11.050 --> 10:16.810
Acabei de ter a idéia de que isto poderia ser um loop, que então incorporaria isso ali, e você

10:16.810 --> 10:18.850
mesmo pode ter feito isso.

10:18.850 --> 10:23.020
Portanto, se o fez, bem feito e é praticamente isso.

10:23.200 --> 10:25.780
Percebi que só tenho lá um Y em vez de um Z.

10:26.590 --> 10:32.590
Se você tiver encontrado algo diferente para este loop, por favor, compartilhe-o nos fóruns ou nas perguntas e respostas

10:32.590 --> 10:38.500
onde quer que você possa entrar em contato conosco, pois estamos sempre interessados em ver como outras pessoas resolveram

10:38.500 --> 10:39.820
os mesmos problemas.

10:39.820 --> 10:44.200
E como eu sempre digo, meu código não é o mais otimizado ou eficiente.

10:44.200 --> 10:46.780
É construído para que você possa realmente ler o que estou fazendo.

10:46.900 --> 10:48.750
Ok, então vamos guardar isso.

10:48.760 --> 10:55.240
Vamos voltar à unidade e vamos experimentar isto.

10:55.240 --> 10:58.750
Portanto, antes de mais nada, vamos ao labirinto e torná-lo menor novamente.

10:58.750 --> 11:02.340
Portanto, vamos fazer como 15 por 15.

11:02.350 --> 11:07.270
Pronto, então pressionamos o jogo, o que nos dará nosso labirinto.

11:07.360 --> 11:10.960
Vamos apenas colocar isso na tela para que você possa vê-lo.

11:10.960 --> 11:15.340
Agora atingimos P, o que nos dará nossas posições inicial e final.

11:15.400 --> 11:20.170
Em seguida, atingimos C até encontrarmos realmente um caminho.

11:20.170 --> 11:20.860
E este é o caso.

11:20.860 --> 11:21.970
É bastante fácil.

11:22.120 --> 11:28.330
Então, se chegarmos a M para pegar nosso caminho, você pode ver que ele passa e apaga tudo e apenas

11:28.330 --> 11:31.690
deixa você o que está nessa lista de caminhos.

11:32.170 --> 11:33.430
K Vamos fazer outra tentativa.

11:33.430 --> 11:35.860
Então vamos para P novamente.

11:35.860 --> 11:44.140
Eles estão um pouco mais longe desta vez e batemos em C até esgotarmos nossa busca ou chegarmos

11:44.140 --> 11:53.080
ao fim, que vamos para K e depois batemos na chave e isso nos dá nosso caminho de um para o outro ou

11:53.080 --> 11:56.880
este vai assim e por ali, ok.

11:56.890 --> 12:05.470
Portanto, este é um algoritmo de caminho estelar representado visualmente para que você possa realmente trabalhar através dele, trabalhar

12:05.470 --> 12:08.400
através dos valores e dos cálculos do G e F.

12:08.410 --> 12:12.910
Assim, você realmente se dá conta de como isso funciona.

12:12.910 --> 12:17.920
E acredite em mim, não há fim para os usos deste algoritmo em particular.

12:17.920 --> 12:25.150
Vemos isso o tempo todo na IA, então espero que você tenha gostado muito desta seção e que tenha conseguido muito com ela.
