leetcode刷题记录

岛屿类问题

问题1：岛屿数量

思路：用DFS的方法，遍历数组中的每一个点，遇到是岛屿的岛屿数量增加，从当前这个节点开始进行深度遍历，把这个节点变成非岛形式，继续再对周围四个点调用DFS。所以应该在DFS函数上加上判断当

if(posi<0 || posj<0 || posi>=row || posj>=col){
    return;
}

同时还应该考虑到如果当前遍历到的这个位置是非岛的时候，就不再进行搜索了，直接返回，因此

if(posi<0 || posj<0 || posi>=row || posj>=col || grid[posi][posj] == '0'){
    return;
}

最终代码如下

class Solution {
    public int numIslands(char[][] grid) {
        //dfs
        int cnt=0;
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(grid[i][j] == '1'){
                    cnt++;
                    dfs(grid,i,j);
                }
            }
        }
        return cnt;
    }
    private void dfs(char[][] grid, int r,int c){
        if(r>=grid.length || c>=grid[0].length || r<0 || c<0 || grid[r][c] == '0'){
            return ;
        }
        grid[r][c]='0';
        dfs(grid,r-1,c);
        dfs(grid,r+1,c);
        dfs(grid,r,c-1);
        dfs(grid,r,c+1);

    }
}

科大讯飞2022.08.20笔试题第三题

迷宫找礼物，求找到礼物的最短路径。
给定一个4x4的二维数组，0代表能走，1代表不能走，8代表宝藏的位置，入口是二维数组的边界位置的任一个不为0的位置，求从人口到宝藏位置的最短路径，并输出路径。

输入：[[0,1,1,1], [0,0,0,1], [1,0,8,1], [1,0,1,1]]

输出：(3,1),(2,1),(2,2)

思路：比较常规的DFS

public class Main {
    static String ans;
    static int anslen=Integer.MAX_VALUE;
    public static void main(String[] args) {
        //test();
        int[][] G=new int[][]{
                {0,1,1,1},
                {0,0,0,1},
                {1,0,8,1},
                {1,0,1,1}};
        test(G);

        System.out.println(ans);
    }

    public static void test(int[][] G){
        int[][] visited=new int[4][4];
       for(int i=0;i<4;i++){
           if(G[i][0]==0){
               dfs(G,i,0,new String(),visited);
           }
           if(G[i][3]==0){
               dfs(G,i,3,new String(),visited);
               System.out.println("yes !");
           }
           if(G[0][i]==0){
               dfs(G,0,i,new String(),visited);
               //System.out.println("yes111");
           }
           if(G[3][i]==0){
               dfs(G,3,i,new String(),visited);
               //System.out.println("yes222");
           }
       }
    }


    public static void dfs(int[][] G, int idxRow, int idxCol, String li, int[][] visited){
        if(visited[idxRow][idxCol]==0){
            visited[idxRow][idxCol]=1;
        }else{
            return;
        }
        //System.out.println(li);
        int[][] arr=new int[][]{{-1,0},{1,0},{0,-1},{0,1}};

        if(li.length()==0){
            li=li+"("+idxRow+","+idxCol+")";
        }else{
            li=li+",("+idxRow+","+idxCol+")";
        }

        for(int i=0;i<4;i++){
            int X=idxRow+arr[i][0];
            int Y=idxCol+arr[i][1];
            //System.out.println("x="+X+ " Y="+Y);
            if(X>=0  && X<4 && Y>=0 && Y<4){
                if(G[X][Y]==8){
                    //System.out.println(G[X][Y]);
                    li=li+",("+X+","+Y+")";
                    if(li.length()<anslen){
                        ans=li;
                        anslen=li.length();
                    }
                }else{
                    if(G[X][Y] == 0){
                        dfs(G,X,Y,li,visited);
                    }
                }
            }
        }
        visited[idxRow][idxCol]=0;
    }

}

重写比较器

问题1：179. 最大数

思路：对于数组中元素，首先转化为String类型，然后对String类型数组再排序，重写排序算法。排序的标准就是，两个字符串，a和b，判断是ab比较大还是ba比较大，哪个比较大那个就算大的。排序之后再拼接，最后对于形成的字符串答案，去除前导0。

class Solution {
    public String largestNumber(int[] nums) {
        int n=nums.length;

        String[] str=new String[n];
        for(int i=0;i<n;i++){
            str[i]=""+nums[i];
        }
        Arrays.sort(str,(a,b)->{
            String sa=a+b;
            String sb=b+a;
            return sb.compareTo(sa);
        });
        String ans=new String();
        for(String s:str){
            ans+=s;
        }
        int k=0;
        int len=ans.length();
        while(k<len-1 && ans.charAt(k)=='0'){
            k++;
        }
        return ans.substring(k,len);
    }
}