分治算法的深入理解

在利用分治算法求问题解时其基本思路可以分为以下几个步骤:
（1）分解，将要解决的问题划分成若干规模较小的同类问题
（2）求解，当子问题划分得足够小时，用较简单的方法解决
（3）合并，按原问题的要求，将子问题的解逐层合并构成原问题的解.
下面我们将通过具体的实例来对以上步骤做出详细的分析。

最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

问题分析：
我们要求最大子序列的和，就要先找到最大子序列的位置。那么最大子序列在哪呢？我们将数组二分，设置 mid=(low=high)/2 ，最大子序列要么在mid的左边[low,mid]，要么在mid的右边[mid+1，high]，要么跨立在分界点上。哪什么又叫做"跨立在分界点上"呢？只有包含子序列[mid,mid+1]的序列才叫做"跨立在分界点上"。通俗的将就是包含左边序列的最后一个元素mid和右边第一个元素mid+1的序列。在了解了"跨立"的含义后，我们又应该如何去解决求各个子序列的最大值呢？这其中又要利用到线性动态规划的思想(详解请见另一篇文章)。我们以左子序列为例,-2,1,-3,4,-1，连续的子序列可以分为以-2结尾的子序列，以1结尾的子序列，以-3结尾的子序列…我们假设以各数结尾的最大子序列的值为B[j]，那么与j紧邻的i(i>j)结尾的最大值为max{B[j]+date[i],date[i]},用状态转移方程式表示为B[i] max{B[j]+date[i],date[i]}.

/*
动态规划
时间复杂度O(N),空间复杂度O(1)
*/
public class Main{
    public static void main(String[] args){
       int[] date = new int[]{-2,1,-3,4,-1,2,1,-5,4};  //测试数据
       int[] B = new int[9];   //用来记录各个状态的最大值
       System.out.println(continueSubMax(date,B));
    }
    
    //求最大连续子数组的和
    public static int continueSubMax(int[] date,int[] B){
        B[0] = date[0];   //以第一个元素结尾的最大值即为其本身
        int max = B[0];
        for(int i=1;i<date.length;i++){
           B[i] = Math.max(B[i-1]+date[i],date[i]);
           if(B[i]>max){
               max = B[i];  //更新max的值
           }            
        }      
        return max;
    }
}

有如上的基础后，我们可以配合分治的思想来解决此问题。我们又该如何求"跨立"序列的最大值呢？由于跨立序列必然包含子序列[mid,mid+1],其中mid为左子序列的结尾，mid+1为右子序列的开头，所以问题转化为跨立序列的最大值 = 以mid结尾的左子序列的最大值+以mid+1开头的右子序列的最大值

/*
分治法
时间复杂度O(NlogN),空间复杂度O(logN)递归时栈使用的空间
*/
public class Main{
    public static void main(String[] args){
        int[] date = new int[] { -2, 1, -3, 4, -1, 2, 1, -5, 4 }; // 测试数据
        System.out.println(continueSubMax(0,8,date));
    }

    //求最大连续子数组的和
    public static int continueSubMax(int low,int high,int[] date){
        //递归出口，实际上在如上分析中我们可以得出,只要区间大于等于2都为跨立序列
        if(low == high){
            return date[low];
        }
        
        int mid = (low+high)/2;      //二分区间
        int LM = continueSubMax(low,mid,date);    //左子序列的最大值
        int RM = continueSubMax(mid+1,high,date); //右子序列的最大值

        //从mid开始依次往前找到以mid结尾的左子序列的最大值
        int leftMax = date[mid];
        int leftSum = 0;
        for(int i=mid;i>=low;i--){
            leftSum += date[i];
            leftMax = Math.max(leftSum,leftMax);
        }
   
        //从mid+1开始依次往后找到以mid+1加一开头的右子序列的最大值
        int rightMax = date[mid+1];
        int rightSum = 0;
        for(int i=mid+1;i<=high;i++){
            rightSum += date[i];
            rightMax = Math.max(rightSum,rightMax);
        }
 
        //跨立序列的最大值
        int CM = leftMax + rightMax;
        return Math.max(CM,Math.max(LM,RM));
    }
}

不修改数组找出重复的数字

给定一个长度为 n+1 的数组nums，数组中所有的数均在 1∼n 的范围内，其中 n≥1。请找出数组中任意一个重复的数，但不能修改输入的数组。

样例
给定 nums = [2, 3, 5, 4, 3, 2, 6, 7]。
返回 2 或 3。

问题分析：
首先，由题意我们可知数组的长度为n+1,也就是说数组装了n+1个数，又有每个数的范围是 [1,n],那么必然存在连个重复的数。为什么？这便是抽屉原理-------桌上有十个苹果，要把这十个苹果放到九个抽屉里，无论怎样放，我们会发现至少会有一个抽屉里面放不少于两个苹果。这一现象就是我们所说的“抽屉原理”。 抽屉原理的一般含义为：“如果每个抽屉代表一个集合，每一个苹果就可以代表一个元素，假如有n+1个元素放到n个集合中去，其中必定有一个集合里至少有两个元素。” 抽屉原理有时也被称为鸽巢原理。由此我们可以得出基本的解题思路，首先我们将范围区间二分为 [ 1, (1+n)/2 ] 和 [ (1+n)/2 + 1 , n],然后遍历数组，统计数组分别在区间 [ 1, (1+n)/2 ] 和区间 [ (1+n)/2 + 1 , n]的个数，如果数的个数大于区间的长度，说名重复得数一定再此区间，然后再将此区间重复上诉过程，直到找到答案，即每个区间的长度变为1.

代码

public class Main{
    public static void main(String[] args){
        int[] date  =new int[] {2, 3, 5, 4, 3, 2, 6, 7};
        System.out.println(findRepeatNumber(1,date.length-1,date));
    }
    
    //找出重复的元素
    public static int findRepeatNumber(int low,int high,int[] date){
         while(low<high){
            int mid = (low + high)/2;    //二分区间
            int count = 0;               //记录在此区间的值的个数
            for(int i=0;i<date.length-1;i++){
                if(date[i]<=mid && date[i]>=low){
                    count++;
                }
            }
                 
            if(count>mid-low+1){
                high = mid;
            } else {
                low = mid + 1;
            }
         }
         return low;  //或者return high;
    }
}