分治算法

1.多数元素

此题思路非常多，主要介绍分治思想的应用和常见其他解法。

1.1 分治法

求原数组的众数可以转化成求各子数组的众数，最后将子数组的结果合并为原数组结果。这就涉及两个问题：

a）递归头。当子数组只有一个元素时，众数即为该元素。

b）合并规则。

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

    }

    // 计算左（或右）区间的众数各自在整个数组中出现了多少次
    private int countInRange(int[] arr, int target, int L, int R){
    
        int count = 0;
        for (int i = L;i <= R;i++){
    
            if (arr[i] == target) count++;
        }
        return count;
    }
    private int getMajority(int[] nums, int L, int R){
    
        // 递归头
        if (L == R) return nums[L];

        // 分治核心算法
        int mid = L + (R - L) / 2;
        int left = getMajority(nums, L, mid);
        int right = getMajority(nums, mid + 1, R);

        // 递归结果判定，左边的结果在整个数组中出现次数多就返回left，否则返回right
        if (left == right) return left;
        if (countInRange(nums, left, L, R) >= countInRange(nums, right, L, R)){
    
            return left;
        }else{
    
            return right;
        }
    }
}

1.2 哈希表

第一步先将数组中所有元素写到哈希表中，以元素为key，出现次数为value。第二步类似冒泡排序第一步，“打擂”的方式找出值最大的entry。返回其键即可。

class Solution {
    
    public int majorityElement(int[] nums) {
    
        Map<Integer, Integer> counts = new HashMap<>();
        for (int num: nums){
    
            if (counts.containsKey(num)){
    
                counts.put(num, counts.get(num) + 1);
            }else{
    
                counts.put(num, 1);
            }
        }

        Map.Entry<Integer, Integer> modeEntry = null;
        for (Map.Entry<Integer, Integer> entry: counts.entrySet()){
    
            if (modeEntry == null || modeEntry.getValue() < entry.getValue()){
    
                modeEntry = entry;
            }
        }
        return modeEntry.getKey();
    }
}

1.3 排序

将原数组排序后，处于n/2位置的元素必然是“众数”。

class Solution {
    
    public int majorityElement(int[] nums) {
    
        Arrays.sort(nums);
        return nums[nums.length / 2];
    }
}

2.最大子序和

2.1 分治法

a）递归头：只有一个元素的子数组的最大子序和就是该元素。

b）合并准则：总的最大子序和必然是是由各子问题（只有一个元素）的最大子序和相加而成。

class Solution {
    
    public int maxSubArray(int[] nums) {
    
        if (nums.length == 1) return nums[0];

        int left = maxSubArray(Arrays.copyOfRange(nums, 0, nums.length / 2));
        int right = maxSubArray(Arrays.copyOfRange(nums, nums.length / 2, nums.length));

        // max_L和max_R的设计是为检验左数组的最大子序和和右数组的最大子序和能否连在一起，不能的话就取左、右较大的那个。
        int max_L = nums[nums.length / 2 - 1];
        int tmp = 0;
        for (int i = nums.length / 2 - 1;i >= 0;i--){
    
            tmp += nums[i];
            max_L = Math.max(tmp, max_L);
        }

        int max_R = nums[nums.length / 2];
        int temp = 0;
        for (int j = nums.length / 2;j < nums.length;j++){
    
            temp += nums[j];
            max_R = Math.max(temp, max_R);
        }
        
        int max_LR = Math.max(left, right);
        return max_LR > (max_L + max_R)? max_LR: (max_L + max_R);
    }
}

2.2 动态规划

本质和分治类似，每一步的状态取决于前一步的状态（截止当前元素时的最大子序和），那任务也是找到：

a）递归头：即dp中的边界条件，dp[0] = nums[0]

b）合并规则：如果当前元素大于0，dp[i] = dp[i-1] + nums[i]；否则dp[i-1]