Matrix(6)

519. Random Flip Matrix

class Solution {
    int i = 0, j = 0;
    int m = 0, n = 0;

    public Solution(int m, int n) {
        this.m = m;
        this.n = n;
    }
    
    public int[] flip() {
      j++;
      if(j == n) {
          j = 0;
          i ++;
      }  
      if(i == m) {
          i = 0;
          j = 0;
      }
      return new int[]{i, j};
    }
    
    public void reset() {
        
    }
}

74. Search a 2D Matrix

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if(matrix == null || matrix.length == 0) {
            return false;
        }
        int row = matrix.length;
        int col = matrix[0].length;
        int start = 0, end = row * col - 1; // 将2维数组转换成一个数组进行二分法
        while(start <= end) {
            int mid = start + (end - start) / 2;
            int ele = matrix[mid / col][mid % col];
            if(ele == target) {
                return true;
            } else if(ele < target) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        return false;
    }
}

73. Set Matrix Zeroes

class Solution {
    public void setZeroes(int[][] mat) {
      // 设置2个变量 避免第一行或者第一列的变化影响后面
      boolean firstcol = false, firstrow = false;
      int m = mat.length, n = mat[0].length;
        for(int i = 0; i < m; i++) {
          if(mat[i][0] == 0) {
              firstcol = true;
          }
        }
        for(int j = 0; j < n; j++) {
            if(mat[0][j] == 0) {
                firstrow = true;
            }
        }

        // 从第二行第二列开始，遇到0 则将首行首例标记为记为0
        for(int i = 1; i < m; i++) {
            for(int j = 1; j < n; j++) {
                if(mat[i][j] == 0) {
                    mat[0][j] = 0;
                    mat[i][0] = 0;
                }
            }
        }
        // 判断更新遍历到的元素
        for(int i = 1; i < m; i ++) {
            for(int j = 1; j < n; j++) {
                if(mat[i][0] == 0 || mat[0][j] == 0) {
                    mat[i][j] = 0;
                }
            }
        }

        if(firstrow) {
            for(int i = 0; i < n; i++) {
                mat[0][i] = 0;
            }
        }
        if(firstcol) {
            for(int i = 0; i < m; i++) {
                mat[i][0] = 0;
            }
        }
    }
}

542. 01 Matrix

class Solution {
    // 设置偏移量 组合表示左右上下移动
    private int[] dirX = new int[]{-1, 1, 0, 0};
    private int[] dirY = new int[]{0, 0, -1, 1};

    public int[][] updateMatrix(int[][] mat) {
       Queue<int[]> q = new LinkedList();
        int m = mat.length, n = mat[0].length;
        //将0入队列，1设置成-1 表示未被访问
       for(int i = 0; i < m; i++) {
           for(int j = 0; j < n; j++) {
               if(mat[i][j] == 0) {
                   q.offer(new int[]{i, j});
               } else{
                   mat[i][j] = -1;
               }
           }
       }
       while(!q.isEmpty()) {
           int[] point = q.poll();
           int x = point[0], y = point[1];
           //将0弹出队列，左右上下分别访问其邻居
           for(int i = 0; i < 4; i++) {
               int newX = x + dirX[i];
               int newY = y + dirY[i];
               // 确保新的坐标不越数组边界
               if(newX >= 0 && newX < m && newY >= 0 && newY < n && mat[newX][newY] == -1) {
                   // 如果遇到邻居为-1，表示这个1未被访问那么在0的基础上➕1
                   mat[newX][newY] = mat[x][y] + 1;
                   q.offer(new int[]{newX, newY});
               }
           }
       }
       return mat;
    }
}

885. Spiral Matrix III

class Solution {
    public int[][] spiralMatrixIII(int rows, int cols, int rStart, int cStart) {
        int[][] matrix = new int[rows*cols][2];
        int k = 0;
        
        int rEnd = rStart + 1;
        int cEnd = cStart + 1;

        while(true) {
            // right 
            for(int i = cStart; i <= cEnd; i++) {
                if(i < cols && i >= 0 && rStart >= 0) {
                    matrix[k][0] = rStart;
                    matrix[k][1] = i;
                    k++;
                }
            }
            cStart--;
            cEnd++;

            if(k == matrix.length) {
                break;
            }

            // down 
            for(int i = rStart + 1; i <= rEnd; i++) {
                if(i < rows && i >= 0 && cEnd - 1 < cols) {
                    matrix[k][0] = i;
                    matrix[k][1] = cEnd - 1;
                    k++;
                }
            }
            rStart--;
            rEnd++;

            if(k == matrix.length) {
                break;
            }

            // left
            for(int i = cEnd - 2; i >= cStart; i--) {
                if(i >= 0 && i < cols && rEnd - 1 < rows) {
                    matrix[k][0] = rEnd - 1;
                    matrix[k][1] = i;
                    k++;
                }
            }
        
            if(k == matrix.length) {
                break;
            }

            // up
            for(int i = rEnd - 2; i > rStart; i--) {
                if(i >= 0 && i < rows && cStart >= 0) {
                    matrix[k][0] = i;
                    matrix[k][1] = cStart;
                    k++;
                }
            }
        
            if(k == matrix.length) {
                break;
            }
        }
        return matrix;
    }
}

59. Spiral Matrix II

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];
        int left = 0, right = n - 1, up = 0, down = n - 1;
        int count = 1;
        int row, col;
        while(true) {
            for(col = left; col <= right; col++) {
                res[up][col] = count++;
            }
            if(++up > down) {
                break;
            }
            for(row = up; row <= down; row++) {
                res[row][right] = count++;
            }
            if(--right < left) {
                break;
            }
            for(col = right; col >= left; col--) {
                res[down][col] = count++;
            }
            if(--down < up) {
                break;
            } 
            for(row = down; row >= up; row--) {
                res[row][left] = count++;
            }
            if(++left > right) {
                break;
            }
        }
        return res;
    }
}

54. Spiral Matrix 

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList();
        int rowStart = 0, rowEnd = matrix.length - 1, colStart = 0, colEnd = matrix[0].length - 1;

        while (rowStart <= rowEnd && colStart <= colEnd) {
            // traverse from left to right
            for (int i = colStart; i <= colEnd; i++) {
                res.add(matrix[rowStart][i]);
            }
            rowStart++;
            // traverse frome up to down
            for (int i = rowStart; i <= rowEnd; i++) {
                res.add(matrix[i][colEnd]);
            }
            colEnd--;

            if (rowStart <= rowEnd) {
                // traverse from right to left
                for (int i = colEnd; i >= colStart; i--) {
                    res.add(matrix[rowEnd][i]);
                }
            }
            rowEnd--;
            if (colStart <= colEnd) {
                //traverse from down to up
                for (int i = rowEnd; i >= rowStart; i--) {
                    res.add(matrix[i][colStart]);
                }
            }
            colStart++;
        }
        return res;
    }
}