lc 0224

目录

• ✅ 766. 托普利茨矩阵
• 描述
• 解答
  • cpp
  • py
• ✅ 566. 重塑矩阵
• 描述
• 解答
  • java
  • py
• ✅ 637. 二叉树的层平均值
• 描述
• 解答
  • cpp
  • py
  • java

0224 algo todo:

✅ 766. 托普利茨矩阵

https://leetcode-cn.com/problems/toeplitz-matrix

描述

如果一个矩阵的每一方向由左上到右下的对角线上具有相同元素，那么这个矩阵是托普利茨矩阵。

给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。

示例 1:

输入:
matrix = [
  [1,2,3,4],
  [5,1,2,3],
  [9,5,1,2]
]
输出: True
解释:
在上述矩阵中, 其对角线为:
"[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]"。
各条对角线上的所有元素均相同, 因此答案是True。
示例 2:

输入:
matrix = [
  [1,2],
  [2,2]
]
输出: False
解释:
对角线"[1, 2]"上的元素不同。
说明:

 matrix 是一个包含整数的二维数组。
matrix 的行数和列数均在 [1, 20]范围内。
matrix[i][j] 包含的整数在 [0, 99]范围内。
进阶:

如果矩阵存储在磁盘上，并且磁盘内存是有限的，因此一次最多只能将一行矩阵加载到内存中，该怎么办？
如果矩阵太大以至于只能一次将部分行加载到内存中，该怎么办？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/toeplitz-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

思路： 判断 a[i][j] == a[i+1][j+1] 即可

只需判断：前行中除最后一个元素外剩余的元素完全等于后行中除第一个元素外剩余的元素。

cpp

py

✅ 566. 重塑矩阵

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

描述

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

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

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

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

示例 1:

输入:
nums =
[[1,2],
 [3,4]]
r = 1, c = 4
输出:
[[1,2,3,4]]
解释:
行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。
示例 2:

输入:
nums =
[[1,2],
 [3,4]]
r = 2, c = 4
输出:
[[1,2],
 [3,4]]
解释:
没有办法将 2 * 2 矩阵转化为 2 * 4 矩阵。 所以输出原矩阵。
注意：

给定矩阵的宽和高范围在 [1, 100]。
给定的 r 和 c 都是正数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reshape-the-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

如果 rc > matrix 所有元素的个数， 那么 返回原来的数组。

否则： 想办法排列之： malloc rowcol 的空间，通过 for each（如果不是for each， 你会怎么办呢？因为要保持两个平面上的指针，一个是原数组平面的，一个是新的malloc平面的 ） 遍历原来的数组

java

class Solution {
    public int[][] matrixReshape(int[][] nums, int r, int c) {
        if (r*c > nums[0].length * nums.length) return nums;
        // else we can have suitable room for nums
        int[r][c] ret;
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                // how to traverse in nums? todo tt2
            }
        }
    }
}

one sol for tt2 is: use a common 平面指针 eg tmp：

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        int tmp=0;
        vector<vector<int>> res(r, vector<int> (c));
        if (r * c != nums[0].size() * nums.size())
        {
            return nums;
        }
        else
        {
            for (int y = 0; y < r; y++)
            {
                for (int x = 0; x < c; x++)
                {
                    tmp=y*c+x+1;
                    res[y][x]=nums[(tmp-0.1)/nums[0].size()][(tmp-1)%nums[0].size()];// tt2 here is the core.!!use tmp as the unified plane ptr
                }
            }
            return res;
        }
---or:
// much clear one:
class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        if (r * c != nums[0].size() * nums.size())
            return nums;
        vector<vector<int>> res(r, vector<int> (c));
        int h = nums.size(), w = nums.front().size();
        for (int i = 0; i < w * h; i++)
        {
            int cx=i%w,cy=i/w,tx=i%c,ty=i/c;
            res[ty][tx]=nums[cy][cx];
        }
        return res;
    }
};

py

class Solution:
    def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
        if len(nums) * len(nums[0]) != r * c: return nums
        tmp = []
        ret = []
        for i in range(len(nums)):
            tmp += nums[i]
        for i in range(0, len(tmp), c):# `c` means we have step length: c
            ret.append(tmp[i: i+c]) #
        return ret
'''执行用时 :
168 ms
, 在所有 Python3 提交中击败了
17.16%
的用户
内存消耗 :
14.4 MB
, 在所有 Python3 提交中击败了
34.89%
的用户'''

✅ 637. 二叉树的层平均值

https://leetcode-cn.com/problems/average-of-levels-in-binary-tree

描述

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.

示例 1:

输入:
    3
   / \
  9  20
    /  \
   15   7
输出: [3, 14.5, 11]
解释:
第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].
注意：

节点值的范围在32位有符号整数范围内。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/average-of-levels-in-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

层序遍历 框架：

q.enque(root);
while(!q.isEmpty()) {
    // we
    if watcher == 0: {
        watcher = len(q)
    }

    // 取出队首 的元素 node
    // 把 node 的 val 加入到 本行的 sum 中
        // 如何判断 本行 的node 已经全部加入 sum 中了呢 ？我们需要一个 watcher
        if --watcher == 0: # 本行的全部已经加入了
    // 如果 本行 的node 已经全部 加入到 sum 中，那么就 计算这个行的平均值。avg
        // 如何 计算 avg 呢？我们没有计数
       // 并把 avg 加入 到 ret 列表中。
    // 其他情况： 本行的node 还没有 全部 加入 sum 完全；那么继续sum += node.val
      //并且，把node.left node.right 都 入队。
}

cpp

py

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def averageOfLevels(self, root: TreeNode) -> List[float]:
        if root == None: return [0]
        ret = []
        que = []
        que.append(root)
        sum = 0
        watcher = len(que)
        counter = 0
        while(len(que) != 0) :
            sum = 0
            counter = 0
            watcher = len(que)
            while counter < watcher:
                node = que.pop(0)
                sum += node.val
                if node.left: que.append(node.left)
                if node.right: que.append(node.right)
                counter += 1
            ret.append(sum / counter)

        return ret
'''
执行用时 :
88 ms
, 在所有 Python3 提交中击败了
19.58%
的用户
内存消耗 :
15.8 MB
, 在所有 Python3 提交中击败了
44.35%
的用户
'''

上述py 实际上 参考下面的 java. 而且 多个语言 都是使用 双 while， 而非 一个while + if 拦截

关于 一个while + if 拦截 可以参考另一篇 针对： 637. 二叉树的层平均值 的博文

java

 public List<Double> averageOfLevels(TreeNode root) {
        List<Double> doubles = new ArrayList<>();
        if (root == null) return doubles;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            double ave = 0;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
                ave += node.val;
            }
            ave = ave * 1.0d / size;
            doubles.add(ave);
        }
        return doubles;
    }