【Leetcode】1329. Sort the Matrix Diagonally

题目地址：

https://leetcode.com/problems/sort-the-matrix-diagonally/

给定一个$m$行$n$列的二维矩阵，要求将其每个左上到右下的对角线进行从小到大的排序。

可以用BFS。从右上到左下分层遍历，每次将下一层的数值加入一个列表进行排序，然后再填回去。代码如下：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {
    public int[][] diagonalSort(int[][] mat) {
        int m = mat.length, n = mat[0].length;
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{0, n - 1});
        while (!queue.isEmpty()) {
        	// 分层遍历需要记录size
            int size = queue.size();
            int diff = 0;
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                int[] cur = queue.poll();
                int x = cur[0], y = cur[1];
                // 下一层的所有坐标的x坐标减去y坐标都等于当前点的x - y + 1
                diff = x - y + 1;
                
                // 将左边的格子坐标加入队列
                if (y > 0) {
                    queue.offer(new int[]{x, y - 1});
                    list.add(mat[x][y - 1]);
                }
                
                // 如果到了最后一行了，则还要将下面那个格子坐标加入队列
                if (i == size - 1 && x + 1 < m) {
                    queue.offer(new int[]{x + 1, y});
                    list.add(mat[x + 1][y]);
                }
            }
            
            // 排完序填回去
            list.sort(null);
            for (int i = Math.max(0, diff); i < m && i - diff < n; i++) {
                mat[i][i - diff] = list.get(i - Math.max(0, diff));
            }
        }
        
        return mat;
    }
}

时间复杂度$O(mn)$，空间 O ( min ⁡ { m , n } ) O(\min\{m,n\}) O(min{m,n})。