Question

我正在努力解决问题Diagonal Traverse - LeetCode

给出一个由M x N个元素组成的矩阵（M行，N列），按对角线顺序返回矩阵的所有元素，如下图所示。

示例：
Input:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]

Output:  [1,2,4,7,5,3,6,8,9]

Explanation:
注意：

给定矩阵的元素总数不会超过10,000。

该问题可以视为bfs从根（0，0）到目标（行，列）遍历

阅读所有提交的内容和讨论后，我找到了一个相对简洁的解决方案

class Solution:
    def findDiagonalOrder(self, matrix: 'List[List[int]]') -> 'List[int]':
        if len(matrix) == 0:
            return []
        r, c = 0, 0
        rows, cols = len(matrix), len(matrix[0])
        res = []
        for _ in range(rows * cols):
            res.append(matrix[r][c])
            if (r + c) % 2 == 0:
                if c == cols - 1: #column boundary 
                    r += 1
                elif r == 0: # 
                    c += 1
                else: #move up 
                    r -= 1
                    c += 1
            else:
                if r == rows - 1: #row boundary 
                    c += 1
                elif c == 0:
                    r += 1
                else:#move down 
                    r += 1
                    c -= 1
        return res

我觉得这样的解决方案还不够好，因为太多的工作无法使用多个条件检查。

这种问题模式可能有一个通用的解决方案，以后可以用最少的精力解决对角线穿越问题。

问题是从（0，0）到（4，4）

字符：
1.对角线上每个节点的总和等于步数
2.可能存在一个关系公式，可以根据root（0,0）和上一级生成下一级的所有节点。

我的解决方案：

import unittest
import logging

logging.basicConfig(level=logging.DEBUG, format="%(levelname)s %(message)s")

class Solution:
    def findDiagonalOrder(self, matrix: 'List[List[int]]') -> 'List[int]':
        from collections import deque 
        #root is (0, 0)
        #destination is (rows, cols)
        r, c = 0, 0
        root = (r, c)
        rows, cols = len(matrix), len(matrix[0])  
        step = 0
        queue = deque([root]) 
        res = []

        while queue and r < rows and c < cols:
            step += 1
            size = len(queue)

            for _ in range(size):
                r, c = queue.popleft()
                res.append(matrix[r][c])

            #collect the next nodes 
            if r == 0 and c == 0: 
                c = step #(0, 1) determin the direction of the first step 
                queue.append((r,c))
                logging.debug(f"queue: {queue}")
                logging.debug(f"step: {step}, r:{r}, c: {c}")

            if c == 0:
                level = [(step-i, i) for i in range(step)]
            elif r == 0:
                level = [(i, step-i) for i in range(step)]
            queue += level 
            logging.debug(f"queue: {queue}")
            #raise Exception

        return res 

class MyCase(unittest.TestCase):
    def setUp(self):
        self.solution = Solution()

    def test_a(self):
        matrix = [
                    [ 1, 2, 3 ],
                    [ 4, 5, 6 ],
                    [ 7, 8, 9 ]
                ]
        answer = [1,2,4,7,5,3,6,8,9]
        check = self.solution.findDiagonalOrder(matrix)
        self.assertEqual(answer, check)

unittest.main()

但是，它停在

DEBUG queue: deque([(0, 2), (1, 1)])
DEBUG queue: deque([(0, 2), (1, 1)])
DEBUG queue: deque([(0, 2), (1, 1)])
DEBUG queue: deque([(0, 2), (1, 1)])
^CDEBUG queue: deque([(0, 2), (1, 1)])
Traceback (most recent call last):

我未能写出良好的关系公式来生成下一级的节点。

请提供任何提示吗？

Answer 1

我不确定这是否能回答您的问题，但是我可以分享我的方法，只要它对您足够简洁明了。

代码是C ++，但是您可以理解。

class Solution {
public:
    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
        vector<int> result;

        int n = matrix.size();
        if(n == 0) return result;
        int m = matrix[0].size();
        if(m == 0) return result;

        result.resize(m * n);
        int row = 0, col = 0, d = 0;
        int dir[2][2] = {
               {-1, 1},
               {1, -1}
        };

        for (int i = 0; i < m * n; i++) {
            result[i] = matrix[row][col];
            row += dir[d][0];
            col += dir[d][1];

            if (row >= n) { row = n - 1; col += 2; d = 1 - d; }
            if (col >= m) { col = m - 1; row += 2; d = 1 - d; }

            if (row < 0)  { row = 0; d = 1 - d;}
            if (col < 0)  { col = 0; d = 1 - d;}
        }
        return result;
    }
};

Answer 2

遍历方阵的解决方案

$Path =  'HKLM:\Software\Microsoft\Windows\CurrentVersion\App Paths'

Get-ChildItem -Path $Path | 
ForEach-Object {
    Get-ItemProperty -Path $_.PSPath |
    Select-Object -ExpandProperty '(default)' -ErrorAction SilentlyContinue |
    ForEach-Object {
        Get-Item -Path $_ -ErrorAction SilentlyContinue |
        Select-Object FullName -ExpandProperty VersionInfo
    }
} |
    Format-Table -AutoSize

BFS解决方案，对角遍历二维数组

2 个答案: