LeetCode每日十题---哈希表（二）

题目描述1

笔者解答1.1

class Solution {
    public int[][] updateMatrix(int[][] matrix) {
       int m=matrix.length;
       int n=matrix[0].length;
       int[][] result=new int[m][n];
       int i,j;
       int min=0;
       int sum=m*n;
       for(i=0;i<m;i++){
           for(j=0;j<n;j++){
               if(matrix[i][j]==0){
                  result[i][j]=0;
                  sum--;
               }else{
                    result[i][j]=-1;
               }
           }
       }
       while(sum!=0){
           for(i=0;i<m;i++){
               for(j=0;j<n;j++){
                   if(result[i][j]==min){
                   if(i!=0){
                      if(result[i-1][j]==-1){
                        result[i-1][j]=min+1;
                        sum--;}
                   }
                   if(j!=0){
                      if(result[i][j-1]==-1){
                        result[i][j-1]=min+1;
                        sum--;}
                   }
                   if(i!=m-1){
                      if(result[i+1][j]==-1){
                        result[i+1][j]=min+1;
                        sum--;}
                   }
                   if(j!=n-1){
                      if(result[i][j+1]==-1){
                        result[i][j+1]=min+1;
                        sum--;}
                   }
                   }
               }
           }
           min++;
       }
       return result;
    }
}

笔者解答分析1.2

这次写的时候思路还是挺清晰的距离从小到大找点，直到找齐所有点，时间复杂度为O(n*n)，超越了百分之八十。总的来说还算可以，但毕竟这种思路太受限了，学学评论区那些比较系统的方法。

class Solution {
    public int[][] updateMatrix(int[][] matrix) {
        /**
        BFS思想, 把所有1都置为最大值, 把所有为0的位置加入队列中, 每次从队列中poll
        一个节点, 更新其四周的节点, 如果被更新的节点距离变小了就将其入队列准备更新其邻接点
        **/
        int m = matrix.length;
        if(m < 1) return matrix;
        int n = matrix[0].length;
        Deque<int[]> q = new ArrayDeque<>();
        
        for(int i = 0; i < m; ++i) {
            for(int j = 0; j < n; ++j) {
                if(matrix[i][j] == 1)
                    matrix[i][j] = Integer.MAX_VALUE;
                else 
                    q.offer(new int[]{i, j});
            }
        }
        
        int[][] dirs = {{-1,0}, {0,-1}, {1,0}, {0,1}};
        
        while(!q.isEmpty()) {
            int[] node = q.poll();
            for(int[] dir : dirs) {
                int x = node[0]+dir[0];
                int y = node[1]+dir[1];
                if(x < 0 || x >= m || y < 0 || y >= n || matrix[x][y] <= matrix[node[0]][node[1]]+1)
                    continue;
                matrix[x][y] = matrix[node[0]][node[1]]+1;
                q.offer(new int[]{x, y});
            }
        }        
        return matrix;
    }
}

题目描述2

笔者分析2.1

这题也是没想过可以用哈希表来解的，以为会是类似排列组合啥的。看了解答，刷新了我对哈希表的认知。减法！！！

class Solution {
    public int numSubarraysWithSum(int[] A, int S) {
       Map<Integer,Integer> map=new HashMap<>();
       map.put(0,1);
       int sum=0;
       int res=0;
       for(int i=0;i<A.length;i++){
           sum+=A[i];
           if(map.containsKey(sum-S)){
               res+=map.get(sum-S);//减法这步是真巧妙
           }
           map.put(sum,map.getOrDefault(sum,0)+1);
       }
       return res;
    }
}

题目描述3

笔者解答3.1

class Solution {
    public int leastBricks(List<List<Integer>> wall) {
      int n=wall.size();
      List<Map<Integer,Integer>> IList=new ArrayList<Map<Integer,Integer>>();
      int i;
      Set<Integer> set=new HashSet<Integer>();
      for(i=0;i<n;i++){
          Map<Integer,Integer> map=new HashMap<Integer,Integer>();
          int m=wall.get(i).size();
          int sum=0;
          for(int j=0;j<m-1;j++){
              sum+=wall.get(i).get(j);
              set.add(sum);
              map.put(sum,1);
          }
          IList.add(map);
      }
      List<Integer> orderlist=new ArrayList<Integer>();
      Iterator<Integer> itor=set.iterator();
      while(itor.hasNext()){
         Integer number=itor.next();
         orderlist.add(number);
      }
      int max=0;
      Collections.sort(orderlist);
      for(i=0;i<orderlist.size();i++){
          int temp=orderlist.get(i);
          int tempcount=0;
          for(int j=0;j<IList.size();j++){
              if(IList.get(j).get(temp)!=null){
                 tempcount++;
              }
          }
          if(tempcount>max){
              max=tempcount;
          }
      }
      return n-max;
    }
}

笔者分析3.2

虽然AC了，但能用这么多数据结构我都服我自己。时空复杂度均为百分之五，显然这题是不应该这样写的。看了下解答，思路都差不多，只是代码表述不同。

总结

题目普遍比较简单吧，没啥好说的。leecode每日打卡十九天，以下图为证