重塑矩阵 图解题解

把矩阵换个行列形状，要返回什么

给一个 m 行 n 列的矩阵 mat，再给目标行数 r、列数 c。要把 mat 里的数按原来的行遍历顺序，也就是一行读到底再换下一行，装进 r 行 c 列的新矩阵。题面给的 mat=[[1,2],[3,4]]、r=1、c=4，4 个数铺成一行，返回 [[1,2,3,4]]；换成 r=2、c=4，新矩阵要 8 个格子、原矩阵只有 4 个数，塞不下就原样还回 mat。

同一组行列坐标，两张矩阵指的不是同一个数

同样写着「第 1 行第 0 列」，在原矩阵和新矩阵里往往不是同一个数——原矩阵一行 n 个、新矩阵一行 c 个，行宽一变，同一组坐标就指向不同格子。照着新矩阵的格子去原矩阵对号入座会取错，得先有个跟形状无关的东西把两套坐标挂上钩。

先拉成一条直线，再按新宽度折回去

先不管形状，把原矩阵按行序拉成一条直线，(0,0)、(0,1)…一行接一行排成一串从 0 起编号的序列，这条线是两张矩阵共用的尺子。原矩阵一行 n 个数，直线上第 i 个数回原矩阵就在第 i 整除 n 行、第 i 取余 n 列；新矩阵一行 c 个数，同一个数落进新矩阵就在第 i 整除 c 行、第 i 取余 c 列。整除算走满了几整行，取余算这一行里的偏移，折行宽度不过是从 n 换成 c。

先对总数，再用一个编号把数搬完

步骤就两件事。头一件是校验总数：只有 m 乘 n 等于 r 乘 c、两张矩阵格子一样多才装得下，一旦不等就直接返回原矩阵 mat。第二件是搬运：开一个 r 行 c 列、先全填 0 的新矩阵 ans，让编号 i 从 0 跑到 m 乘 n 减 1，每步把原矩阵第 i 整除 n 行、第 i 取余 n 列的数写到 ans 第 i 整除 c 行、第 i 取余 c 列。读用原宽度 n、写用新宽度 c，一趟循环所有数各就各位。

拿 [[1,2],[3,4]] 重塑成 1 行 4 列过一趟

就用题面这张 mat=[[1,2],[3,4]]，目标 r=1、c=4。先对总数：原矩阵 2 乘 2、目标 1 乘 4 都是 4 个，相等。读用原宽度 n=2、写用新宽度 c=4，编号从 0 数到 3。编号 0：第 0 整除 2=0 行、0 取余 2=0 列取到 1，进新矩阵 (0,0)；编号 1：原矩阵 (0,1) 取到 2，进 (0,1)；编号 2：第 2 整除 2=1 行、2 取余 2=0 列取到 3，进 (0,2)；编号 3：原矩阵 (1,1) 取到 4，进 (0,3)。四步填完，新矩阵是 [[1,2,3,4]]，顺序跟原来一字不差。

为什么是 O(m·n)，两种极端形状会怎样

时间上每个数只读写一遍、不重不回头，共 m 乘 n 个，所以 O(m·n)；新矩阵要存下全部 m 乘 n 个数，空间同样 O(m·n)。两处写法一错结果全乱：省掉总数校验直接开搬，碰上 r 乘 c 跟原矩阵对不上时轻则漏数、重则越界，题目要的正是原样退回 mat；读原矩阵若也拿新宽度 c 定列会跳到别的格子，得用它自家宽度 n，写新矩阵才用 c。边界反而简单：r=1 摊成一整行、c=1 摊成一整列都合法，红线是 m 乘 n 得等于 r 乘 c。

Python

from __future__ import annotations
from typing import *
from collections import *
from functools import *
from itertools import *
from math import *
from heapq import *
from bisect import *
class Solution:
    def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
        m, n = len(mat), len(mat[0])
        if m * n != r * c:
            return mat
        ans = [[0] * c for _ in range(r)]
        for i in range(m * n):
            ans[i // c][i % c] = mat[i // n][i % n]
        return ans

C++

#include <algorithm>
#include <array>
#include <cctype>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        int m = mat.size(), n = mat[0].size();
        if (m * n != r * c) {
            return mat;
        }
        vector<vector<int>> ans(r, vector<int>(c));
        for (int i = 0; i < m * n; ++i) {
            ans[i / c][i % c] = mat[i / n][i % n];
        }
        return ans;
    }
};

Java

import java.util.*;
class Solution {
    public int[][] matrixReshape(int[][] mat, int r, int c) {
        int m = mat.length, n = mat[0].length;
        if (m * n != r * c) {
            return mat;
        }
        int[][] ans = new int[r][c];
        for (int i = 0; i < m * n; ++i) {
            ans[i / c][i % c] = mat[i / n][i % n];
        }
        return ans;
    }
}