leetcode分治——169/53

一、169 多数元素

1.题目

https://leetcode-cn.com/problems/majority-element/
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

2.思想

1.哈希表解法
2.分治
分治介绍：https://blog.csdn.net/weixin_43872728/article/details/101082875
(1).设计思想：
将一个难以直接解决的大问题，分割成一些规模小的相同问题，以便各个击破，分而治之。
(2).策略
对于一个规模为n的问题，若将问题分割为m个的子问题可以直接解决，这些子问题相互独立且与原文问题形式相同，递归地解决这些问题，然后将各子问题的解答合并后得到原问题的解。

3.代码

1.哈希表

class Solution {
    public int majorityElement(int[] nums) {
        //hash表解法
        //base case
        if (nums.length <1) return nums[0];
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        int n = nums.length;
        for (int i=0; i<n;i++){
            if(!map.containsKey(nums[i])){
                map.put(nums[i],1);
            }else{
                map.put(nums[i],map.get(nums[i])+1);
                if (map.get(nums[i]) >n/2){
                    return nums[i];
                }
                }
            }
        return nums[0];    
            
        }
       
    }

2.分治解法

class Solution {
    public int majorityElement(int[] nums) {
        return majorityApply(nums, 0, nums.length-1);
    }

    public int majorityApply(int[] nums, int left, int right){
        //base case数组中只有一个元素时候，返回这个值
        //left right分别为所求区间的左右端点，闭合
        if (left == right){
            return nums[left];
        }

        //向下分割区间
        int mid = (left+right)/2;
        int leftNum = majorityApply(nums,left, mid);
        int rightNum = majorityApply(nums, mid+1, right);
        //如果左右众数相同，则返回
        if (leftNum == rightNum) return leftNum;

        //否则分别计算区间内众数的个数，并比较大小
        //注当前区间是递归的left和right
        int leftCount = numCount(nums, leftNum, left,right);
        int rightCount = numCount(nums, rightNum, left, right);

        

        return leftCount>rightCount?leftNum:rightNum;


    }

    public int numCount(int[]nums, int num, int left, int right){
        //if (nums.length == 0) return 0;
        int count=0;
        for(int i = left; i<=right;i++){
            if(nums[i] == num){
                count++;
            }
        }
        return count;
    }
}

二、53最大子数组和

1.题目

https://leetcode-cn.com/problems/maximum-subarray/
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。

2.思想

1.动态规划——找到当前值和之前值得关系，比较得到最大的
2.分治
https://leetcode-cn.com/problems/maximum-subarray/solution/zui-da-zi-xu-he-by-leetcode-solution/

3.代码

1.动态规划

class Solution {
    public int maxSubArray(int[] nums) {
        //动态规划
        /* 
        1.如果当前子数组加上后面的数，和变小，那就不应该加，此时把当前最大和保存下来
        2.遍历数组，比较当前值和新加入值的大小
        
        */
        int pre = 0;
        int maxNum =nums[0];
        for (int num:nums){
            pre = Math.max(pre+num,num);
            maxNum = Math.max(maxNum,pre);
        }
        return maxNum;
    }
}

2.分治

class Solution {
    public class Status{
        int lSum;//左子区间的最大值
        int rSum;//右子区间的最大值
        int mSum;//返回值
        int iSum;//区间和
        //初始化变量
        public Status(int lSum, int rSum, int mSum, int iSum){
        this.lSum = lSum;
        this.rSum = rSum;
        this.mSum = mSum;
        this.iSum = iSum;
    }
        
    }
    
    

    public int maxSubArray(int[] nums) {
        //分治思想
        //分割成相同的小区间，合并时存在多种情况
        /**
        1.左子区间或右子区间的和有一个为最大值；
        2.左子区间和右子区间的左子区间的和为最大值；
        3.右子区间和左子区间的右子区间的和为最大值；
        4.左子区间的右区间和右子区间的左区间的和为最大值        
        
         */
        return sumSubArray(nums,0, nums.length-1 ).mSum;
    }
    public Status sumSubArray(int[] nums, int left, int right ){
        //base case
        if (left == right ) return new Status(nums[left], nums[left], nums[left], nums[left]);
        int mid = (left+right)/2;
        Status leftStatus = sumSubArray(nums,left, mid);
        Status rightStatus = sumSubArray(nums, mid+1, right);
        return pushUp(leftStatus,rightStatus);

    }

    //左右区间最大值求解
    public Status pushUp(Status l, Status r){
        int iSum = l.iSum + r.iSum;
        int lSum = Math.max(l.lSum,l.iSum+r.lSum);
        int rSum = Math.max(r.rSum, l.rSum+r.iSum);
        int mSum = Math.max(Math.max(l.mSum,r.mSum), l.rSum+r.lSum);
        return new Status(lSum, rSum, mSum, iSum);
    }


}

三、合并K个升序链表

1.题目

https://leetcode-cn.com/problems/merge-k-sorted-lists/
给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

2.思路

1. 可以用分治思想，先拆分成单力度的，然后再两两合并，直到最后合并完
   时间复杂度
2. 也可以用最小堆/优先队列，队列的头是最小元素
   因为LIstNode列表中存储的是各个LIstNode的头结点，所以，先将k个头结点放到优先队列中，然后逐个将对头放到结果链表中

3.代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        //分治
        //分治的思想是先拆分成最小单元粒度的，然后两两合并，自底向上合并
        if (lists.length == 0){
            return null;
        }
        return mergeMain(lists, 0, lists.length-1);
    }

    public ListNode mergeMain(ListNode[] lists, int left, int right){
        if (left == right){
            return lists[left];
        }
        if (left > right) return null;
        int mid = (left+right)/2;
        return mergeTwo(mergeMain(lists,left,mid),mergeMain(lists,mid+1, right));

    }

    public ListNode mergeTwo(ListNode a , ListNode b){
        if(a == null || b == null){
            return a!=null ? a:b;
        }
        ListNode head = new ListNode(0);
        ListNode aPre=a;
        ListNode bPre=b;
        ListNode tail = head;
        while(aPre!=null && bPre!=null){
            if(aPre.val > bPre.val){
                tail.next = bPre;
                bPre = bPre.next;
            }else{
                tail.next = aPre;
                aPre = aPre.next;
            }
            tail = tail.next;
        }
        tail.next=(aPre!=null ? aPre:bPre);
        return head.next;

    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        //base case 
        if (lists == null || lists.length == 0) return null;
        //构造优先队列，优先队列的队首为最小值
        PriorityQueue<ListNode> que = new PriorityQueue<>(lists.length, new Comparator<ListNode>(){
            public int compare(ListNode n1, ListNode n2){
                if (n1.val < n2.val) return -1;
                else if (n2.val == n1.val) return 0;
                else return 1;
            }
        });

        for(ListNode node: lists){
           if (node !=null) que.add(node);
        }
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;

        while(!que.isEmpty()){
            cur.next =que.poll();
            cur = cur.next;
            if (cur.next != null) que.add(cur.next);
        }
        return dummy.next;

    }
}