重構 2 行二進制矩陣

給你一個 2 行 n 列的二進制數組：

矩陣是一個二進制矩陣，這意味着矩陣中的每個元素不是 0 就是 1。
第 0 行的元素之和爲 upper。
第 1 行的元素之和爲 lower。
第 i 列（從 0 開始編號）的元素之和爲 colsum[i]，colsum 是一個長度爲 n 的整數數組。
你需要利用 upper，lower 和 colsum 來重構這個矩陣，並以二維整數數組的形式返回它。

如果有多個不同的答案，那麼任意一個都可以通過本題。

如果不存在符合要求的答案，就請返回一個空的二維數組。

示例 1：

輸入：upper = 2, lower = 1, colsum = [1,1,1]
輸出：[[1,1,0],[0,0,1]]
解釋：[[1,0,1],[0,1,0]] 和 [[0,1,1],[1,0,0]] 也是正確答案。

示例 2：

輸入：upper = 2, lower = 3, colsum = [2,2,1,1] 輸出：[]

示例 3：

輸入：upper = 5, lower = 5, colsum = [2,1,2,0,1,0,1,2,0,1]
輸出：[[1,1,1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,1,0,1]]

提示：

• 1 <= colsum.length <= 10^5
• 0 <= upper, lower <= colsum.length
• 0 <= colsum[i] <= 2

題目分析

• 本題使用 DFS 求解，有 TLE 的可能
• 本題應使用貪心算法，大致思路爲：
  • 若 colsum[i]=2，則 一定上下均爲 1
  • 若 colsum[i]=0，則 一定上下均爲 0
  • 若 colsum[i]=1，則 上下一個 1 一個 0
• 唯一需要討論的只有 colsum[i]=1的情形，我們可以規定：默認先分配上爲 1，再分配下爲 1,當upper < lower時，則先分配下爲1，再分配上爲1
  無解的情形與解決方案：
  • 行元素之和（upper+lower）與列元素之和（∑colsum）不相等
  • 解決方案：一次循環，求出 ∑colsum，與 upper+lower 比較行元素之和
  • 解決方案 1：排除所有 00 的項與 22 的項，觀察此時 upper 與 lower 是否爲負值
  • 解決方案 2：直接分配，分配完成後，觀察此時 upper 與 lower 是否爲負值

class Solution {
    List<List<Integer>> list = new ArrayList<>();

    public List<List<Integer>> reconstructMatrix(int upper, int lower, int[] colsum) {
        int sum = 0;
        for (int col : colsum) {
            sum += col;
        }
        if (upper + lower != sum) {
            return list;
        }
        recursion(upper, lower, colsum, new Integer[2][colsum.length], 0);
        return list;

    }

    public void recursion(int upper, int lower, int[] colunm, Integer[][] res, int n) {
        if (n == colunm.length) {
            if (upper == 0 && lower == 0) {
                List list1 = new ArrayList(n);
                List list2 = new ArrayList(n);
                Collections.addAll(list1, res[0]);
                Collections.addAll(list2, res[1]);
                list.add(list1);
                list.add(list2);
            }
            return;
        }
        if (colunm[n] == 0) {
            res[0][n] = 0;
            res[1][n] = 0;
            recursion(upper, lower, colunm, res, n + 1);
            if (list.size() > 0) {
                return;
            }
        } else if (colunm[n] == 2) {
            if (upper < 1 || lower < 1) {
                return;
            }
            res[0][n] = 1;
            res[1][n] = 1;
            recursion(upper - 1, lower - 1, colunm, res, n + 1);
            if (list.size() > 0) {
                return;
            }
        } else {
            if (upper > lower) {
                if (upper > 0) {
                    res[0][n] = 1;
                    res[1][n] = 0;
                    recursion(upper - 1, lower, colunm, res, n + 1);
                    if (list.size() > 0) {
                        return;
                    }
                } else if (lower > 0) {
                    res[0][n] = 0;
                    res[1][n] = 1;
                    recursion(upper, lower - 1, colunm, res, n + 1);
                    if (list.size() > 0) {
                        return;
                    }
                }
            } else {
                if (lower > 0) {
                    res[0][n] = 0;
                    res[1][n] = 1;
                    recursion(upper, lower - 1, colunm, res, n + 1);
                    if (list.size() > 0) {
                        return;
                    }
                } else if (upper > 0) {
                    res[0][n] = 1;
                    res[1][n] = 0;
                    recursion(upper - 1, lower, colunm, res, n + 1);
                    if (list.size() > 0) {
                        return;
                    }
                }
            }
        }
    }
}