Leetcode数据结构day4

566. 重塑矩阵

给你一个由二维数组 mat 表示的 m * n 矩阵，以及两个正整数 r 和 c ，分别表示想要的重构的矩阵的行数和列数。
重构后的矩阵需要将原始矩阵的所有元素以相同的 行遍历顺序 填充。
如果具有给定参数的 reshape 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

思路解析

方法一 二维数组的一维表示

对于一个行数为 m，列数为 n，行列下标都从 0 开始编号的二维数组，我们可以通过下面的方式，将其中的每个元素 (i,j) 映射到整数域内，并且它们按照行优先的顺序一一对应着 [0,mn) 中的每一个整数。
这样的映射为（i,j）-> i*n + j；同样地，我们可以将整数 x 映射回其在矩阵中的下标，即 i = x /n，j = x % n，其中 / 表示整数除法，% 表示取模运算。

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        int m = nums.size();
        int n = nums[0].size();
        if (m * n != r * c) {
            return nums;
        }

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

复杂度分析
时间复杂度：O(rc)。这里的时间复杂度是在重塑矩阵成功的前提下的时间复杂度，否则当 mn = rc 时，C++ 语言中返回的是原数组的一份拷贝，本质上需要的时间复杂度为 O(mn)，而其余语言可以直接返回原数组的对象，需要的时间复杂度仅为 O(1)。
空间复杂度：O(1)。

方法二 暴力遍历

遍历数组，先判断要求组成的矩阵的元素个数与原来矩阵的元素个数是否相等，不相等就返回原来矩阵，相等进入遍历，利用两个容器分别存储行矩阵和整个矩阵。

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        int n = mat.size();
        int m = mat[0].size();
        if(r*c != n*m) return mat;
        vector<vector<int>> res;
        vector<int> alls;
        for(int i = 0; i < mat.size(); i++){
            for(int j = 0; j < mat[i].size(); j++){
                alls.push_back(mat[i][j]);
                if(alls.size() == c){
                    res.push_back(alls);
                    alls.clear();
                }
            }
        }
        return res;
    }
};

复杂度分析
时间复杂度：O(mn)。
空间复杂度：O(rc)。

118. 杨辉三角

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。

思路解析

方法一 数学组合递推公式

每个数字等于上一行的左右两个数字之和，可用此性质写出整个杨辉三角。即第 n 行的第 i 个数等于第 n−1 行的第 i−1 个数和第 i 个数之和。这也是组合数的性质之一。

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ret(numRows);
        for (int i = 0; i < numRows; ++i) {
            ret[i].resize(i + 1);
            ret[i][0] = ret[i][i] = 1;
            for (int j = 1; j < i; ++j) {
                ret[i][j] = ret[i - 1][j] + ret[i - 1][j - 1];
            }
        }
        return ret;
    }
};

复杂度分析
时间复杂度：O(numRows^2)。
空间复杂度：O(1)。

方法二 动态规划

逐行进行递推。

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector< vector<int> > result;
        for(int i = 0; i< numRows; i++)
        {
            vector<int> temp(i+1, 1);
            for(int j = 1; j < i; j++)
            {
                temp[j] = result[i-1][j-1] + result[i-1][j];
            }
            result.push_back(temp);
        }
        return result;

    }
};

复杂度分析
时间复杂度：O(numRows^2)。
空间复杂度：O(1)。