分治法-归并/快排（递归）-二分（非递归）

很多题目可以用暴力枚举法求解，比如 1~n的全排列，可重复数字的全排列，8皇后问题等但是需要注意，当时间复杂度超过 $10^9$一般就超时了，所以如果数量级为 $10^5$及以上，时间复杂度为 $O(n)$肯定就超时了，就考虑分治、贪心、动态规划等高级算法

分治法

分治法分成三个步骤，通常第三步是最难确定的：
　　　划分问题
　　　递归求解
　　　合并问题

同时注意定义递归的终止条件，例如对区间$[x,y)$划分的时候，以$y-x=1$或$y>x$为终止条件

1.最大连续和问题

暴力算法时间复杂度：$O(n^3)$

分治法

合并问题： 求出左边分区的最大子段和，右边分区的最大子段和，然后计算起点在左边终点在右边的最大子段和，三者最大的就是整个区间的最大子段和
递归终点： $y-x=1$。区间只有一个元素，直接返回该元素

int maxsum(int* a,int x,int y)//在左闭右开区间[x,y)
{
    if(y-x==1) return a[x];//递归终点
    
   //划分问题，左边[x,m),右边[m,y)
    int l_max,r_max,v;
    int m=x+(y-x)/2;       
    
    //递归求解，左边，右边的解
    int maxs=max(maxsum(a,x,m),maxsum(a,m,y));  
    
    //合并，求起点在左边重点在右边的最大和,和子问问题的解比较
    v=0;l_max=a[m-1];
    for(int i=m-1;i>=x;i--) l_max=max(l_max,v+=a[i]);
    
    v=0;r_max=a[m];
    for(int i=m;i<y;i++) r_max=max(r_max,v+=a[i]);
    
    return max(maxs,l_max+r_max);
}

时间复杂度：$T(n)=2T(n/2)+O(n),T(n)=O(nlogn)$

2.归并排序

合并问题 把两个有序表合并成一个
递归终点 $y-x<=1$,因为至少有两个元素才能进行划分，$y-x=1$的时候，区间内只有一个元素了，所以递归终点是区间长度为1的时候，return,而函数没有返回值，所以代码直接进行$y-x>1$的过程

void merge_sort(int*a,int x,int y,int* t)
{
    if(y-x>1)//递归的终点是y-x<=1,这里直接进入递归过程，因为终点的操作和非终点一样
    {
        int m=x+(y-x)/2;
        int p=x,q=m,i=x;//p.q分别指向左边.右边区间当前要合并和元素，i指向有序数组的位置
        merge_sort(a,x,m,t);
        merge_sort(a,m,y,t);

        while(p<m||q<y)//只要左边右边有一个没有合并完就继续
        {
            if(p>=m||q<y&&a[q]<=a[p])t[i++]=a[q++];//右边区间的数复制到临时数组，左边区间为空||左边区间不为空
            else t[i++]=a[p++];
        }
        for(int i=x;i<y;i++) a[i]=t[i];
    }
}
int main()
{
    merge_sort(a,0,数组长度,t);
    return 0;
}

时间复杂度 $O(nlogn)$

---

逆序对问题

递归求解 统计i和j均在左边或者均在右边的逆序对个数
合并问题 只需加上i在左边区间，j在右边区间的逆序对个数　（因为到合并这一步的时候，均在左边和均在右边的情况在递归求解的过程中已经将计算了，比如区间长度为4的时候，划分成2个长度为2的左右区间，如果左边是一个逆序对，那么这个区间长度为4的均在左边的逆序对，已经在区间长度为2的合并的时候计算了。即均在左边或者均在右边的情况，在递归求解的时候已经加上了）

递归终点 区间只有一个元素，和归并排序一样

怎么求i在左边，j在右边的逆序对？
$<=>$a[p]>a[q]$<=>$归并排序中把右边的元素赋值给临时数组
所以只需要改动一下归并排序中合并部分的代码

while(p<m||q<y)//只要左边右边有一个没有合并完就继续
        {
            if(p>=m||q<y&&a[q]<=a[p])cnt+=m-p;//改动之处
            //else t[i++]=a[p++];
        }

3.快速排序

划分问题 　把数组各个元素重排后分成两部分，使得左边的元素小于等于右边的元素
递归求解 　把左右两部分分别排序
合并问题 　不用合并，因为此时整个数组已经有序

这里给出的代码是对闭区间排序[x,y]
递归终点　x=y

快排的实现逻辑
1.选一个基准数，一般是第一个数
2.把比它大的放在右边，比它小的放在左边
3.直到每个区间只有一个数

有两种实现方法（前后交换、大小重放）

方法一（最常用）

int mypartion(int*a,int x,int y)//a[],区间[x,y]
{
        int low=x,high=y;
        int pivot=a[x];//选第一个元素作为枢纽元
        while(low<high)//这里low<high说明还没有找到pivot的位置
        {
        	//这里还需要low<high是因为防止high--;或者low++;的时候超过范围了
            while(low<high&&a[high]>=pivot)high--;  //从后面开始找到第一个小于等于pivot的元素，放到low位置
            a[low]=a[high];
                        
            while(low<high&&a[low]<=pivot)low++;//从前面开始找到第一个大于pivot的元素，放到high位置
            a[high]=a[low];
        }
        a[low]=pivot;//跳出了while说明，low=high
    }
    return low;
}

方法二：
int mypartion(int* a,int x,int y)
{
    int pivot=a[x];//选最后一个元素为基准
    int location=x-1;//location指向的是比pivot小的元素段的最后一个元素，如果后面还有比pivot小的元素就继续往这个区段后面放
    
    for(int i=x;i<y;i++)
    {
        if(a[i]<pivot)
            swap(a[i],a[++location]);
    }
    swap(a[y],a[++location]);
    return location;
}

快排的主函数
void quick_sort(int *a, int x, int y)
{
    if(x < y)//根据递归终点x=y
    {
        int middle = mypartition(a, x, y);
        quicksort(a, x, middle-1);
        quicksort(a, middle+1, y);
    }
}

时间复杂度
平均时间复杂度$O(nlogn)$
最坏情况下的时间复杂度：当原数组是降序排列的时候，每次调用quick_sort都要遍历一遍数组，$T(n)=n+(n-1)+(n-2)+...+1=O(n^2)$

4.二分查找（非递归）

还是左闭右开区间$[x,y)$
二分查找仍是使用分治的思路，但是一般采用非递归的形式

循环的终止条件是ｘ＜ｙ，因为当ｘ＝ｙ的时候说明当前x前面的数字都比v小，y-1（因为y是开区间）后面的数字都比v大，所以实际是数组中不存在v

int b_search(int* a,int x,int y,int v)
{
    int m;
    while(x<y)//[x,y)
    {
        m=x+(y-x)/2;
        if(a[m]==v) return m;
        else if(a[m]>v) y=m;
        else x=m+1;
    }
    return -1;
}

时间复杂度 每次折半，能折半几次时间复杂度就是多少$O(logn)$ 【平均和最坏时间复杂度都是】

如果数组中有多个v，二分查找返回的是最中间的那一个

---

upper/lower_bound实现

lower_bound：v存在时返回第一个位置，不存在则返回一个下标i，在此处插入v使得数组仍有序

思路：

1　当a[m]==v的时候，可能前面的区间[x,m)还有v，应该继续往前找
2　当a[m]>v的时候，根据二分查找的思想，应该在区间[x,m)继续查找看是否有v
3　当a[m]<v的时候，应该在区间[m,y)查找

可以将1.2两项合并

int b_search(int* a,int x,int y,int v)
{
    int m;
    while(x<y)//当x=y的时候，说明此时的x前面的数都比v小,y后面的都比v大，而且y是开区间，实际取不到，所以实际上就是没有这个数
    {
        m=x+(y-x)/2;
        if(a[m]>=v) y=m;
        else x=m+1;
    }
    return x;
}

upper_bound:如果数组中存在v，返回它出现的最后一个位置，如果不存在返回能插入v的位置，使得数组仍有序

int b_search(int* a,int x,int y,int v)
{
    int m;
    while(x<y)
    {
        m=x+(y-x)/2;
        if(a[m]<=v) x=m+1;//和lower_bound的不同
        else y=m;//修改
    }
    return x;
}