botón de estancia --- 11/03/2020

1013. La matriz se divide en tres porciones iguales y

class Solution {
    public boolean canThreePartsEqualSum(int[] A) {
        int sum = 0,res = 0,cnt = 0;
        for(int a : A){
            sum += a;
        }
        if(sum % 3!=0) return false;
        sum = sum/3;
        for(int a : A){
            res += a;
            if(res == sum){
                cnt++;
                res=0;
            }
        }
        return cnt==3 || (cnt > 3 && sum == 0);
    }
}

class Solution {
    public boolean canThreePartsEqualSum(int[] A) {
        int sum = 0;
        for(int i : A){
            sum += i;
        }
        if(sum%3 != 0){
            // 总和不是3的倍数，直接返回false
            return false;
        }

        // 使用双指针,从数组两头开始一起找，节约时间
        int left = 0;
        int leftSum = A[left];
        int right = A.length - 1;
        int rightSum = A[right];

        // 使用left + 1 < right 的原因，防止只能将数组分成两个部分
        // 例如：[1,-1,1,-1]，使用left < right作为判断条件就会出错
        while(left + 1 < right){
            if(leftSum == sum/3 && rightSum == sum/3){
                // 左右两边都等于 sum/3 ，中间也一定等于
                return true;
            }
            if(leftSum != sum/3){
                // left = 0赋予了初值，应该先left++，在leftSum += A[left];
                leftSum += A[++left];
            }
            if(rightSum != sum/3){
                // right = A.length - 1 赋予了初值，应该先right--，在rightSum += A[right];
                rightSum += A[--right];
            }
        }
        return false;  
    }
}

1304. N único cero y número entero

class Solution {
    public int[] sumZero(int n) {
        int sum = 0;
        int[] res = new int[n];
        for(int i=0;i<n-1;i++){
            res[i] = i;
            sum += i;
        }
        res[n-1] = -sum;
        return res;
    }
}

class Solution {
    public int[] sumZero(int n) {
        int[] ans = new int[n];
        int index = 0;
        for (int i = 1; i <= n / 2; i++) {
            ans[index++] = -i;
            ans[index++] = i;
        }
        return ans;
    }
}

1305. Todos los elementos de dos árboles de búsqueda binaria

//遍历+优先队列
//PriorityQueue使用跟普通队列一样，唯一区别是PriorityQueue会根据排序规则决定谁在队头，谁在队尾。
class Solution {
   private PriorityQueue<Integer> priorityQueue;

    private void dfs(TreeNode root) {
        if (root == null) {
            return;
        }

        priorityQueue.offer(root.val);
        dfs(root.left);
        dfs(root.right);
    }

    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
        priorityQueue = new PriorityQueue<>();
        dfs(root1);
        dfs(root2);
        List<Integer> ansList = new ArrayList<>();
        while (!priorityQueue.isEmpty()) {
            ansList.add(priorityQueue.poll());
        }
        return ansList;
    }
}

class Solution {
    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
        List<Integer> list = new ArrayList<>();
        getAllElements(root1, list);
        getAllElements(root2, list);
        Collections.sort(list);
        return list;
    }

    public void getAllElements(TreeNode node, List<Integer> list) {
        if (node == null) {
            return;
        }
        getAllElements(node.left, list);
        list.add(node.val);
        getAllElements(node.right, list);
    }
}

Cuanto más se sabe, más usted no sabe.
Forma correcta sin necesidad de cirugía, los pacientes aún pueden buscar, no hay ninguna manera de la cirugía, poniendo fin a la cirugía.
Si usted tiene otras preguntas, mensaje de bienvenida, podemos discutir, aprender juntos y progresar juntos