2022-3-9 剑指offer day27

题1：

JZ12 矩阵中的路径

描述

请设计一个函数，用来判断在一个n乘m的矩阵中是否存在一条包含某长度为len的字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 \begin{bmatrix} a & b & c &e \\ s & f & c & s \\ a & d & e& e\\ \end{bmatrix}\quad⎣⎡​asa​bfd​cce​ese​⎦⎤​ 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

数据范围：0 \le n,m \le 20\0≤n,m≤20 ,1\le len \le 25\1≤len≤25 

 

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param matrix char字符型二维数组 
     * @param word string字符串 
     * @return bool布尔型
     */
    boolean ans=false;
    String comp;
    int[][] dir={{-1,0},{1,0},{0,1},{0,-1}};
    public boolean hasPath (char[][] matrix, String word) {
        // write code here
        int len=word.length(),m=matrix.length,n=matrix[0].length;
        comp=word;
        StringBuilder sb=new StringBuilder();
        boolean[][] visited=new boolean[m][n];
        for (int i=0;i<m;i++){
            for (int j=0;j<n;j++) {
                if (ans) return ans;
                //剪枝 开头字母相同再搜索
                if (matrix[i][j]==word.charAt(0)){
                    visited[i][j]=true;
                    sb.append(matrix[i][j]);
                    dfs(i,j,matrix,len,sb,visited);
                    visited[i][j]=false;
                    sb.deleteCharAt(sb.length()-1);
                }

            }
        }
        return ans;
    }
    
    
    public void dfs(int x,int y,char[][] arr,int len,StringBuilder sb,boolean[][] visited){
        if (sb.length()==len) {
            if (sb.toString().equals(comp)) ans=true;
            return;
        }
        if (ans) return;
        int m=arr.length,n=arr[0].length;
        for (int[] t:dir){
            int dx=x+t[0];
            int dy=y+t[1];
            // 剪枝 当前坐标合法且相同再dfs
            if (dx>=0&&dy>=0&&dx<m&&dy<n&&!visited[dx][dy]&&arr[dx][dy]==comp.charAt(sb.length())){
                sb.append(arr[dx][dy]);
                visited[dx][dy]=true;
                dfs(dx,dy,arr,len,sb,visited);
                sb.deleteCharAt(sb.length()-1);
                visited[dx][dy]=false;
            }
        }
        
    }
}

思路：深度优先搜索。要剪枝  不然时间会超时。

 

题2：

JZ13 机器人的运动范围

 

描述

地上有一个 rows 行和 cols 列的方格。坐标从 [0,0] 到 [rows-1,cols-1] 。一个机器人从坐标 [0,0] 的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 threshold 的格子。 例如，当 threshold 为 18 时，机器人能够进入方格   [35,37] ，因为 3+5+3+7 = 18。但是，它不能进入方格 [35,38] ，因为 3+5+3+8 = 19 。请问该机器人能够达到多少个格子？

 

数据范围： 0 \le threshold \le 15 \0≤threshold≤15  ，1 \le rows,cols \le 100 \1≤rows,cols≤100 

 

进阶：空间复杂度 O(nm) \O(nm)  ，时间复杂度 O(nm) \O(nm) 

import java.util.*;
public class Solution {
    public int movingCount(int threshold, int rows, int cols) {
        boolean[][] visited=new boolean[rows][cols];
        visited[0][0]=true;
        int ans=1;
        int[][] dir={{1,0},{-1,0},{0,1},{0,-1}};
        Queue<int[]> queue=new LinkedList<>();
        queue.add(new int[]{0,0});
        while (!queue.isEmpty()){
            int[] t=queue.poll();
            for (int[] p:dir){
                int dx=p[0]+t[0];
                int dy=p[1]+t[1];
                if (dx>=0&&dy>=0&&dx<rows&&dy<cols&&!visited[dx][dy]&&check(dx,dy,threshold)){
                    queue.offer(new int[]{dx,dy});
                    ans++;
                    visited[dx][dy]=true;
                }
            }
        }
        
        return ans;
    }
    
    public boolean check(int x,int y, int sum){
       int s=0;
       while (x>0) {
           s+=x%10;
           x/=10;
       }
          while (y>0) {
           s+=y%10;
           y/=10;
       }
        if (s<=sum) return true;
        return false;
    }
}

思路：  dfs跟bfs都能写，写了一个BFS版本的。