LeetCode 566 - Reshape the Matrix

https://leetcode.com/problems/reshape-the-matrix

In MATLAB, there is a very useful function called 'reshape', which can reshape a matrix into a new one with different size but keep its original data.

You're given a matrix represented by a two-dimensional array, and two positive integers r and c representing the row number and columnnumber of the wanted reshaped matrix, respectively.

The reshaped matrix need to be filled with all the elements of the original matrix in the same row-traversing order as they were.

If the 'reshape' operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.

Example 1:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
Output: 
[[1,2,3,4]]
Explanation:
The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.

Example 2:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 2, c = 4
Output: 
[[1,2],
 [3,4]]
Explanation:
There is no way to reshape a 2 * 2 matrix to a 2 * 4 matrix. So output the original matrix.

Note:

1. The height and width of the given matrix is in range [1, 100].
2. The given r and c are all positive.

X.
https://leetcode.com/articles/reshape-the-matrix/
Do you know how a 2-D array is stored in the main memory(which is 1-D in nature)? It is internally represented as a 1-D array only. The element $nums[i][j]$ of $nums$ array is represented in the form of a one dimensional array by using the index in the form: $nums[n*i + j]$, where $m$ is the number of columns in the given matrix. Looking at the same in the reverse order, while putting the elements in the elements in the resultant matrix, we can make use of a $count$ variable which gets incremented for every element traversed as if we are putting the elements in a 1-D resultant array. But, to convert the $count$ back into 2-D matrix indices with a column count of $c$, we can obtain the indices as $res[count/c][count\%c]$ where $count/c$ is the row number and $count\%c$ is the coloumn number. Thus, we can save the extra checking required at each step.
https://discuss.leetcode.com/topic/87851/java-concise-o-nm-time

public int[][] matrixReshape(int[][] nums, int r, int c) {
    int n = nums.length, m = nums[0].length, k = 0;
    if (r*c != n*m) return nums;
    int[][] res = new int[r][c];
    for (int i=0;i<r;i++) 
        for (int j=0;j<c;j++,k++) 
            res[i][j] = nums[k/m][k%m];
    return res;
}

http://www.cnblogs.com/grandyang/p/6804753.html
对于这种二维数组大小重新非配的问题的关键就是对应位置的坐标转换，最直接的办法就是先把原数组拉直，变成一条直线，然后再组成新的数组。所以这道题我们先判断给定数组是否能重塑成给定的大小，就是看两者的元素总数是否相同，直接行数乘以列数即可，然后我们新建一个目标大小的数组，并开始遍历，对于每个位置，我们先转为拉直后的一维坐标，然后在算出在原数组中的对应位置赋值过来即可

    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        int m = nums.size(), n = nums[0].size();
        if (m * n != r * c) return nums;
        vector<vector<int>> res(r, vector<int>(c));
        for (int i = 0; i < r; ++i) {
            for (int j = 0; j < c; ++j) {
                int k = i * c + j;
                res[i][j] = nums[k / n][k % n];
            }
        }
        return res;
    }

下面这种方法整体思路和上面没啥区别，但是只使用了一个循环，直接就是遍历拉直后的一维数组的坐标，然后分别转换为两个二维数组的坐标进行赋值
https://discuss.leetcode.com/topic/87901/one-loop

We can use matrix[index / width][index % width] for both the input and the output matrix.

public int[][] matrixReshape(int[][] nums, int r, int c) {
    int m = nums.length, n = nums[0].length;
    if (r * c != m * n)
        return nums;
    int[][] reshaped = new int[r][c];
    for (int i = 0; i < r * c; i++)
        reshaped[i/c][i%c] = nums[i/n][i%n];
    return reshaped;
}

http://blog.csdn.net/u014688145/article/details/71023781
public int[][] matrixReshape(int[][] nums, int r, int c) { int row = nums.length; if (row == 0) return nums; int col = nums[0].length; if (col == 0) return nums; if (row * col != r * c) return nums; int[][] res = new int[r][c]; for (int i = 0; i < row; i++){ for (int j =0; j < col; j++){ int x = i * col + j; int nr = x / c; int nc = x % c; res[nr][nc] = nums[i][j]; } } return res; }

X.
While putting the numbers in the resultant array, we fix a particular row and keep on incrementing the column numbers only till we reach the end of the required columns indicated by $c$. At this moment, we update the row index by incrementing it and reset the column index to start from 0 again
https://discuss.leetcode.com/topic/87853/easy-java-solution

    public int[][] matrixReshape(int[][] nums, int r, int c) {
        int m = nums.length, n = nums[0].length;
        if (m * n != r * c) return nums;
        
        int[][] result = new int[r][c];
        int row = 0, col = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                result[row][col] = nums[i][j];
                col++;
                if (col == c) {
                    col = 0;
                    row++;
                }
            }
        }
        
        return result;
    }

X.
https://leetcode.com/articles/reshape-the-matrix/

    public int[][] matrixReshape(int[][] nums, int r, int c) {
        int[][] res = new int[r][c];
        if (nums.length == 0 || r * c != nums.length * nums[0].length)
            return nums;
        int count = 0;
        Queue < Integer > queue = new LinkedList < > ();
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[0].length; j++) {
                queue.add(nums[i][j]);
            }
        }
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                res[i][j] = queue.remove();
            }
        }
        return res;
    }