【算法设计与分析】分治-练习题

逆序对

在⼀个数组 A[0…n-1] 中，逆序对（inversion）i 和 j 是⼀对索引 ，满足 i<j 且A[i]>A[j]。⼀个包含n个元素的数组中的逆序对数量介于0（如果数组已排序）和 （如果数组完全逆序）n(n-1) 之间。

相关例题：P1908 逆序对

分析：

直接暴力枚举：二维循环，枚举每一个 i<j的数对，如果A[i] > A[j]则记录该逆序对。

时间复杂度：$O(n^2)$
空间复杂度：$O(1)$

归并排序：利用归并排序合并的时候，需要比较元素大小的步骤，来直接计算其产生的逆序对数目。
归并排序过程中，前面的分治过程不会产生逆序对的计算。在递归树到达底层之后，进行合并，就会计算逆序对的数量的计算。
例如：

• 5 与 4 合并。此时i=0，j=1，mid=1，但A[i]>A[j]，此时可能不止产生一个逆序对，需要判断 i 和 j 的差距，即$mid-i$
• 4,5 与 2 合并。此时i=0, j=2，mid=1，但A[i]>A[j]，此时产生了两个逆序对：$mid-i$。且前两个值交换位置也没有对该值的逆序对产生影响，因为前面的值与该值相对的位置没有改变，因此逆序对总数不变。
  

时间复杂度：$O(nlogn)$
空间复杂度：借助了辅助数组用于归并，$O(n)$

代码：

#include<bits/stdc++.h>
using namespace std;

long long ans;
int nums[500010],me[500010];

void merge_sort(int low, int high){
    if(low==high) return;
    int mid = (low+high)/2,i=low,j=mid+1, index = low;
    merge_sort(low,mid);
    merge_sort(mid+1,high);
    while(i<=mid&&j<=high){
        if(nums[i]<=nums[j]){
            me[index++]=nums[i++];
        }else{
            me[index++]=nums[j++];
            ans+=(mid-i+1);
        }
    }
    while(i<=mid){
        me[index++]=nums[i++];
    }
    while(j<=high){
        me[index++]=nums[j++];
    }

    for(int i=low;i<=high;i++){
        nums[i]=me[i];
    }
}

long long count_inversion(int n){
    ans=0;
    merge_sort(0, n);
    return ans;
}

int main(){
    int tmp,n;
    cin>>n;
    for(int i=0;i<n;i++){
        scanf("%d",&nums[i]);
    }
    cout<<count_inversion(n-1)<<endl;
    return 0;
}

支配点

给定⼆维平面上两个不同的点 p 和 q ，如果p.x<=q.x且p.y<=q.y，称q支配p。给定⼀个点集P，设计⼀个⾼效的算法，计算每⼀个点支配的点的数量。

分析：
对于该题，没有想到比较好的思路，因此只使用了二重循环枚举的方法：

时间复杂度：$O(n^2)$
空间复杂度：要存储所有的点的支配的点的数量，$O(n)$

代码：

#include<bits/stdc++.h>
using namespace std;

vector<int> Disposable_points(vector<vector<int>>& points){
    int n=points.size();
    vector<int> ans(n,0);
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(i==j) continue;
            if(points[i][0]>=points[j][0]&&points[i][1]>=points[j][1]) ans[i]++;
        }
    }
    return ans;
}

int main(){
    vector<vector<int>> points={{1,1}, {2,2}, {3,3}, {4,4}};
    for(auto& p : Disposable_points(points)){
        cout<<p<<endl;
    }
    return 0;
}

寻找最小的盒子

你正在参加⼀档游戏节目。你会看到⼀排盒子，每个盒子里都包含⼀个任意且唯⼀的数字。你的目标是在尽可能少地打开盒子的情况下找到⼀个盒子，其数字大于其左边和右边的盒子中的数字。当然，除非它是第⼀个或最后⼀个盒子，在这种情况下，它只需要大于其相邻的那个盒子的数字即可。
假设⼀共有n个盒子，设计的算法的时间复杂度应该优于 $O(n)$。

分析：
寻找某个盒子，其数字大于旁边盒子里的数字。
该题目的核心就是寻找某个区域内的极大值（不需要找到最大值，当然最大值也是极大值）。

注意：每个盒子中的数字是任意且唯一的，那就说明任意选择一段Array[i…j]，该段满足条件：i==0 || Array[i]>Array[i-1] 且 j==n-1 || Array[j]>Array[j+1]，此时该段中一定存在极大值。

因此，我们可以采取二分的做法：
对于满足要求的盒子i，盒子中的值会比左右的值都大，因此该值为极大值（并非最大值）。
当 $Array[mid]<Array[mid-1]$ 时，mid左边的数组⼀定存在⼀个极大值，因此往low~mid-1进行二分搜索⼀定能得到⼀个满足要求的盒子。
当 $Array[mid]<Array[mid+1]$时，mid右边的数组也⼀定会有⼀个极大值，因此对右边数组进行⼆分搜索也能找到⼀个满足要求的盒⼦。
当 $Array[mid]>Array[mid-1]$ 且 $Array[mid]>Array[mid+1]$ ，此时mid即为满足要求的盒子。

时间复杂度：每一次都会去掉当前的一般的元素，因此时间复杂度：
$$\begin{gathered} T(n)=T(n/2)+O(1) \\ T(n)=O(logn) \end{gathered}$$

代码：

#include<bits/stdc++.h>
using namespace std;

int find_box(vector<int>& boxes,int i, int j){
    int mid=(i+j)/2;
    if((mid==0&&boxes[mid]>boxes[mid+1])||(mid==boxes.size()-1&&boxes[mid]>boxes[mid-1])||(boxes[mid]>boxes[mid+1]&&boxes[mid]>boxes[mid-1])) return mid;
    if(boxes[mid]<boxes[mid+1]) return find_box(boxes, mid+1, j);
    return find_box(boxes, i, mid-1);
}

int main(){
    vector<int> boxes={1,2,4,7,6,5,7,8,9};
    cout<<find_box(boxes, 0, boxes.size()-1)<<endl;
    return 0;
}

最近点对

具体内容见 分治第一部分。