leetcode 2

weixin_42673583

已于 2022-02-18 15:12:29 修改

阅读量205

点赞数

分类专栏： leetcode 文章标签： leetcode 算法职场和发展

于 2022-02-17 20:44:22 首次发布

本文链接：https://blog.csdn.net/weixin_42673583/article/details/122989200

版权

leetcode 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

在这里插入图片描述

public class MakeNo {
    public static int[] makeNo(int size){
        if(size == 1){
            return new int[] {1};
        }
        /**
         * size
         * 一半
         * [4个奇数，3个偶数]
         * 如果奇数满足，2*奇数-1也满足 偶数也是，交叉也是，数学证明
         */
        int halfSize = (size + 1)/2;
        int[] base = makeNo(halfSize);
        int[] ans = new int[size];
        int index = 0;
        for(;index < halfSize;index++){
            ans[index] = base[index]*2+1;
        }
        for (int i = 0; index < size; i++,index++) {
            ans[index] = base[i]*2;
        }
        return ans;
    }
}

在这里插入图片描述

public class MaxSumInTree {
    public static class Node{
        public int value;
        public Node left;
        public Node right;
        public Node(int val){
            value = val;
        }
    }

    //从头节点出发，返回最大路径和
    public static int maxSum = Integer.MIN_VALUE;

    public static int maxPath(Node head){
        p(head,0);
        return maxSum;
    }

    public static void p(Node x,int pre){
        if(x.left == null && x.right==null){
            maxSum= Math.min(maxSum,pre+x.value);
        }
        if(x.left != null){
            p(x.left,x.value+pre);
        }
        if(x.right != null){
            p(x.right,x.value+pre);
        }
    }

    //从x开始遍历
    public static int process2(Node x){
        if (x.left == null && x.right == null) {
            return x.value;
        }
        int next = Integer.MIN_VALUE;
        if(x.left!=null){
            next = process2(x.left);
        }
        if(x.right!=null){
            next = Math.max(next,process2(x.right));
        }
        return x.value + next;
    }

    //从任意节点出发，只能往下走 最大路径
    //这个和从头结点出发有什么区别呢，这个可以不经过头结点，就是答案可以不经过头结点
    //假设从X出发，分为和X有关的情况，分为和X无关的情况


    public static class Info{
        public int allTreeMaxSum;
        public int fromHeadMaxSum;

        public Info(int all,int from){
            allTreeMaxSum = all;//该树的最大值 不一定从头出发
            fromHeadMaxSum  = from;//从头出发的最大值
        }
    }

    /**
     * 和x无关 左树最大和，右树最大和
     * 和x相关 x自己，往x左走，往x右走
     * @param x
     * @return
     */
    public static Info process22(Node x){
           if(x == null){
               return null;
           }
           Info leftInfo = process22(x.left);
           Info rightInfo = process22(x.right);

           int p1 = Integer.MIN_VALUE;
           if(leftInfo != null){
               p1 = leftInfo.allTreeMaxSum;
           }

        int p2 = Integer.MIN_VALUE;
        if(rightInfo != null){
            p2 = rightInfo.allTreeMaxSum;
        }

        //p3 p4 p5以x为头结点的最长路径
        int p3 = x.value;

        int p4 = Integer.MIN_VALUE;
        if(leftInfo != null){
            p4 = x.value + leftInfo.fromHeadMaxSum;
        }


        int p5 = Integer.MIN_VALUE;
        if(rightInfo != null){
            p5 = x.value + rightInfo.fromHeadMaxSum;
        }

        int allTreeMaxSum = Math.max(Math.max(Math.max(p1,p2),p3),Math.max(p4,p5));
        int fromHeadMaxSum = Math.max(Math.max(p3,p4),p5);
        return new Info(allTreeMaxSum,fromHeadMaxSum);
    }

    public static int maxSum2(Node head){
        if(head == null){
            return 0;
        }
        return process22(head).allTreeMaxSum;
    }


    //可以往左走 也可以往右走，每个路径只能走一次，不一定到根节点
    /**
     * 和x无关 左树最大和，右树最大和
     * 和x相关 x自己，往x左走，往x右走 继往左又往右走
     * @param x
     * @return
     */
    public static Info process33(Node x){
        if(x == null){
            return null;
        }
        Info leftInfo = process33(x.left);
        Info rightInfo = process33(x.right);

        int p1 = Integer.MIN_VALUE;
        if(leftInfo != null){
            p1 = leftInfo.allTreeMaxSum;
        }

        int p2 = Integer.MIN_VALUE;
        if(rightInfo != null){
            p2 = rightInfo.allTreeMaxSum;
        }

        //p3 p4 p5以x为头结点的最长路径
        int p3 = x.value;

        int p4 = Integer.MIN_VALUE;
        if(leftInfo != null){
            p4 = x.value + leftInfo.fromHeadMaxSum;
        }


        int p5 = Integer.MIN_VALUE;
        if(rightInfo != null){
            p5 = x.value + rightInfo.fromHeadMaxSum;
        }

        //既往左走 右边走
        int p6 = Integer.MIN_VALUE;
        if(leftInfo != null && rightInfo != null){
            p6 = x.value + leftInfo.fromHeadMaxSum + rightInfo.fromHeadMaxSum;
        }
        int allTreeMaxSum = Math.max(Math.max(Math.max(p1,p2),p3),Math.max(p4,Math.max(p5,p6)));
        int fromHeadMaxSum = Math.max(Math.max(p3,p4),p5);
        return new Info(allTreeMaxSum,fromHeadMaxSum);
    }

    public static int maxSum3(Node head){
        if(head == null){
            return 0;
        }
        return process33(head).allTreeMaxSum;
    }

    public static int max = Integer.MIN_VALUE;

    //从任意节点出发，，只能往下走，到叶节点为止最大路径和 防止溢出 用long
    public static int bigShuai(Node head){
        if(head.left == null && head.right == null){
            max = Math.max(max,head.value);
            return head.value;
        }
        int nextMax = 0;
        if(head.left != null){
            nextMax = bigShuai(head.left);
        }
        if(head.right != null){
            nextMax = Math.max(nextMax,bigShuai(head.right));
        }
        int ans = head.value + nextMax;
        max = Math.max(max,ans);
        return ans;
    }

}

在这里插入图片描述

public class PackingMachine {
    public static int minOps(int[] arr){
        if(arr == null || arr.length == 0){
            return 0;
        }
        int size = arr.length;
        int sum = 0;
        for (int i = 0; i < size; i++) {
            sum+=arr[i];
        }
        if(sum % size != 0){
            return -1;
        }
        int avg = sum / size;
        int leftSum = 0;
        int ans = 0;
        for (int i = 0; i < arr.length; i++) {
            int leftRest = leftSum - i * avg;
            int rightRest = (sum-  leftRest - arr[i])-(size-i-1)*avg;
            if(leftRest < 0 && rightRest < 0 ){
                ans = Math.max(ans,Math.abs(leftRest)+Math.abs(rightRest));
            }else{
                ans = Math.max(ans,Math.max(Math.abs(leftRest),Math.abs(rightRest)));
            }
            leftRest+=arr[i];
        }
        return ans;
    }

}

![在这里插入图片描述](https://img-blog.csdnimg.cn/06b91e7b294c4bf6bace6375676c0f67.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAd2VpeGluXzQyNjczNTgz,size_20,color_FFFFFF,t_70,g_se,x_16)
思路：首先找到最大值，假设最大值划分为左边，那么最右边的数一定是最大值的最小值，，同理 如果最大值划分为右边，也类似，所以最大值减去两边的值