1. Título
Hay un cuadrado con m filas yn columnas en el suelo, desde las coordenadas [0,0] hasta las coordenadas [m-1, n-1]. Un robot comienza a moverse desde la cuadrícula de coordenadas [0, 0]. Puede moverse una cuadrícula hacia la izquierda, derecha, arriba y abajo a la vez (no puede moverse fuera de la cuadrícula) y no puede ingresar la suma de coordenadas de fila y coordenadas de columna mayores que k rejilla. Por ejemplo, cuando k es 18, el robot puede ingresar el cuadrado [35, 37] porque 3 + 5 + 3 + 7 = 18. Pero no puede entrar en el cuadrado [35, 38] porque 3 + 5 + 3 + 8 = 19. ¿Cuántas rejillas puede alcanzar el robot?
En segundo lugar, solución del problema 1: realización recursiva
Buscar en cuatro direcciones
class Solution {
public int dig_num(int target){
int sum = 0;
while(target>0){
sum+=target%10;
target/=10;
}
return sum;
}
public int dfsSolver(int startL,int startR,int m,int n,int k,int[][] visited){
if(startL<0||startR<0||startL>=m||startR>=n||dig_num(startL)+dig_num(startR)>k||visited[startL][startR]==1){
return 0;
}
visited[startL][startR]=1;
return 1+dfsSolver(startL-1,startR,m,n,k,visited)+dfsSolver(startL+1,startR,m,n,k,visited)+dfsSolver(startL,startR-1,m,n,k,visited)+dfsSolver(startL,startR+1,m,n,k,visited);
}
public int movingCount(int m, int n, int k) {
int[][] visited = new int[m][n];
return dfsSolver(0,0,m,n,k,visited);
}
}
Instrucciones de solución de problemas
Consideramos la cuadrícula con coordenadas de fila y coordenadas de columna mayores que k como obstáculos, entonces esta pregunta es una pregunta de búsqueda muy tradicional, podemos usar la búsqueda primero en amplitud o la búsqueda en profundidad para resolverlo, este artículo elige usar primero la amplitud El método de búsqueda se explica.
Entonces, ¿cómo calcular la suma de los dígitos de un número? Solo necesitamos tomar el resto del número x a 10 cada vez, podemos saber cuál es el dígito unitario del número x, y luego dividir x entre 10. Esta operación es equivalente a cambiar el número decimal de x en un lugar a la derecha y borrando El número de dígitos (similar al >> operador de desplazamiento a la derecha en binario), se repite hasta que el final de x es 0.
Al mismo tiempo, hay una optimización oculta para este problema: podemos reducir la dirección de búsqueda hacia la derecha y hacia abajo durante el proceso de búsqueda, en lugar de buscar hacia arriba y hacia la izquierda. Como se muestra en la siguiente figura, mostramos el mapa 16 * 16 con la ampliación de la condición de restricción k, la tendencia de cambio de los cuadrados factibles. El valor en cada cuadrado es la suma de las coordenadas de fila y columna. El cuadrado azul representa sin obstáculos Cuadrado, es decir, su valor es menor o igual que la condición de restricción actual k. Podemos encontrar que a medida que aumenta la condición de restricción k, los cuadrados sin obstáculos recién agregados en el área del cuadrado azul donde se encuentra (0, 0) se pueden obtener moviendo el cuadrado superior o izquierdo un paso. Las otras áreas de la cuadrícula azul desconectadas se conectarán a medida que k aumente, y cuando estén conectadas, también se obtendrán moviendo la cuadrícula superior o izquierda un paso, por lo que podemos reducir nuestra dirección de búsqueda hacia la derecha o hacia abajo.
3. Solución del problema Primera búsqueda de 2 amplitudes
class Solution {
public int dig_num(int target){
int sum = 0;
while(target>0){
sum+=target%10;
target/=10;
}
return sum;
}
public int movingCount(int m, int n, int k) {
if(k==0){
return 1;
}
int[] dx = {
1,0};
int[] dy = {
0,1};
int[][] visited = new int[m][n];
visited[0][0] = 1;
Queue<int[]> queue = new LinkedList<int[]>();
queue.add(new int[]{
0,0});
int res=1;
while(!queue.isEmpty()){
int[] cell = queue.poll();
int x = cell[0];
int y = cell[1];
for(int i=0;i<2;i++){
int tx = x+dx[i];
int ty = y+dy[i];
if(tx<0||tx>=m||ty<0||ty>=n||dig_num(tx)+dig_num(ty)>k||visited[tx][ty]==1){
continue;
}
queue.offer(new int[]{
tx,ty});
visited[tx][ty] = 1;
res++;
}
}
return res;
}
}
Cuatro, recursividad
class Solution {
public int dig_num(int target){
int sum = 0;
while(target>0){
sum+=target%10;
target/=10;
}
return sum;
}
public int movingCount(int m, int n, int k) {
if(k==0){
return 1;
}
int[][] visited = new int[m][n];
visited[0][0] = 1;
int res=1;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(i==0&&j==0||dig_num(i)+dig_num(j)>k){
continue;
}
if(i-1>=0){
visited[i][j]|=visited[i-1][j];
}
if(j-1>=0){
visited[i][j]|=visited[i][j-1];
}
res+=visited[i][j]==1? 1:0;
}
}
return res;
}
}