算法零基础学习关于数组的一些练习题| leetcode 202218861260的题解

Posted 2023-02-19 妙七先生

2022. 将一维数组转变成二维数组

问题描述：

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

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

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

提示：

    1 <= original.length <= 5 * 104
    1 <= original[i] <= 105
    1 <= m, n <= 4 * 104

思路分析

简单来讲，这道题就是将一个一维数组转换为一个m * n的二维数组。如下：

因此，解决这个问题关键在于如何将一维数组的索引正确地转换为二维数组的索引。

代码：

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

1886. 判断矩阵经轮转后是否一致

问题描述：

给你两个大小为 n x n 的二进制矩阵 mat 和 target 。现 以 90 度顺时针轮转 矩阵 mat 中的元素 若干次 ，如果能够使 mat 与 target 一致，返回 true ；否则，返回 false 。

提示：

n == mat.length == target.length
n == mat[i].length == target[i].length
1 <= n <= 10
mat[i][j] 和 target[i][j] 不是 0 就是 1

思路分析

最简单的方法就是『将mat矩阵一次次的旋转，看一下是否能与target一致』。

看下面这个例子：
这里对 Mat 进行若干次旋转，并判断 Mat 和 target 是否一致。
在经过两次旋转之后，Mat 将和 target 一致。
由于mat矩阵每次都是旋转90°，所以，在最多旋转两次。（第三次旋转将和原矩阵一样）

代码：

    class Solution 
        public boolean findRotation(int[][] mat, int[][] target) 
            int i = 0;
            while(i < 4)
                if(equal(mat,target,mat.length))
                    return true;
                mat = rotate(mat);
                i++;
            
            return false;
        
     
        // 轮转矩阵
        int[][] rotate(int[][] mat)
            int length = mat.length;
            for(int i = 0; i < length / 2; i++)
                for(int j = 0; j < length; j++)
                    int s = mat[i][j];
                    mat[i][j] = mat[length - 1 - i][j];
                    mat[length - 1 -i][j] = s;
                
            
            for(int i = 0; i < length; i++)
                for(int j = i; j < length; j++)
                    int s = mat[i][j];
                    mat[i][j] = mat[j][i];
                    mat[j][i] = s;
                
            
            return mat;
        
     
        // 比较相等
        boolean equal(int[][] mat, int[][] target, int length)
            for(int i = 0; i < length; i++)
                for(int j = 0; j < length; j++)
                    if(mat[i][j] != target[i][j])
                        return false;
                
            
     
            return true;
        
    

1260. 二维网格迁移

问题描述：

给你一个 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 次迁移操作后最终得到的 二维网格。

提示：

m == grid.length
n == grid[i].length
1 <= m <= 50
1 <= n <= 50
-1000 <= grid[i][j] <= 1000
0 <= k <= 100

思路分析：

我们来看一下「迁移」：

1. 位于grid[i][j]的元素移动到grid[i][j + 1]；
   
2. 位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0];
   
3. 位于 grid[m - 1][n - 1] 的元素将会移动到 grid[0][0]。
   

如果我们将它视为一个「一维循环数组」，那么，这里每「迁移一次」，数组的元素就会「后移」一次 。

代码：

    class Solution 
        public List<List<Integer>> shiftGrid(int[][] grid, int k) 
            int row_num = grid.length;
            int col_num = grid[0].length;
            int num = row_num * col_num;
            int[][] res = new int[row_num][col_num];
     
            for(int i = 0; i < row_num; i++)
                for(int j = 0; j < col_num; j++)
                    int location = (j + i * col_num + k) % num;
                    res[location / col_num][location % col_num] = grid[i][j];
                
            
     
            List<List<Integer>> result = new ArrayList<>();
            for (int[] row : res) 
                List<Integer> listRow = new ArrayList<>();
                result.add(listRow);
                for (int v : row) listRow.add(v);
            
     
            return result;