[学习报告]《LeetCode九日集训》Day8 二级指针

第一题：翻转图像

给定一个 n x n 的二进制矩阵 image ，先 水平 翻转图像，然后 反转 图像并返回 结果 。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。

例如，水平翻转 [1,1,0] 的结果是 [0,1,1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。

例如，反转 [0,1,1] 的结果是 [1,0,0]。

class Solution {
    public int[][] flipAndInvertImage(int[][] A) {
        int x=A.length,y=A[0].length;
        int[][] B = new int[x][y];
        for (int i=0;i<x;i++){
            for (int j=0;j<y;j++){
                B[i][y-j-1]=1-A[i][j];   //从后往前赋值，同时取反
            }
        }
        return B;
    }
}

第二题：转置矩阵

给你一个二维整数数组 matrix， 返回 matrix的 转置矩阵 。

矩阵的 转置 是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。

class Solution {
    public int[][] transpose(int[][] matrix) {
    int m = matrix.length;
    int n = matrix[0].length;
    int[][] res = new int[n][m];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            res[j][i] = matrix[i][j];
        }
    }
    return res;
}
}

第三题：重塑矩阵

在 MATLAB 中，有一个非常有用的函数 reshape ，它可以将一个 m x n 矩阵重塑为另一个大小不同（r x c）的新矩阵，但保留其原始数据。

给你一个由二维数组 mat 表示的 m x n 矩阵，以及两个正整数 r 和 c ，分别表示想要的重构的矩阵的行数和列数。

重构后的矩阵需要将原始矩阵的所有元素以相同的 行遍历顺序 填充。

如果具有给定参数的 reshape 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

class Solution {
    public int[][] matrixReshape(int[][] nums, int r, int c) {
        int m = nums.length;
        int n = nums[0].length;
        if (m * n != r * c) {
            return nums;
        }

        int[][] ans = new int[r][c];
        for (int x = 0; x < m * n; ++x) {
            ans[x / c][x % c] = nums[x / n][x % n];
        }
        return ans;
    }
}

第四题：将一维数组转变成二维数组

给你一个下标从 0 开始的一维整数数组 original 和两个整数 m 和 n 。你需要使用 original 中 所有 元素创建一个 m 行 n 列的二维数组。

original 中下标从 0 到 n - 1 （都 包含 ）的元素构成二维数组的第一行，下标从 n 到 2 * n - 1 （都 包含 ）的元素构成二维数组的第二行，依此类推。

请你根据上述过程返回一个 m x n 的二维数组。如果无法构成这样的二维数组，请你返回一个空的二维数组。

class Solution {
    public int[][] construct2DArray(int[] original, int m, int n) {
        if(original.length != m * n) return new int[][]{};
        int[][] ans = new int[m][n];
        int idx = 0;
        for(int i = 0 ; i < m ; i++){
            for(int j = 0 ; j < n ; j++){
                ans[i][j] = original[idx++];
            }
        }
        return ans;
    }
}

第五题、1260. 二维网格迁移

难度简单52

给你一个 m 行 n 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。

每次「迁移」操作将会引发下述活动：

位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。
位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0]。
位于 grid[m - 1][n - 1] 的元素将会移动到 grid[0][0]。
请你返回 k 次迁移操作后最终得到的 二维网格。

class Solution {
    public List<List<Integer>> shiftGrid(int[][] grid, int k) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        int len =grid.length , len2 = grid[0].length;
        for(int i=0;i<k;i++){
           grid = shitftSignlGrid(grid);
        }
        for(int i=0;i<len;i++){
             List<Integer>  list = new ArrayList<>();
            for(int j=0;j<len2;j++){
                list.add(grid[i][j]);
            }
            result.add(list);
        }
        return result;
    }
    public int[][] shitftSignlGrid(int[][] grid){
        int len =grid.length , len2 = grid[0].length;
        int[][] newgrid = new int[len][len2];
        for(int i=0;i<len2;i++){
            for(int j=0;j<len;j++){
                if(i!=len2-1){
                     newgrid[j][i+1] = grid[j][i];
                }else if(i==len2-1 && j!=len-1){
                    newgrid[j+1][0] = grid[j][i];
                }else {
                    newgrid[0][0] = grid[j][i];
                }
              
            }
        }
        return newgrid;
    }
}