3 分治算法

3.1

设 $A$ 是 $n$ 个非 $0$ 实数构成的数组, 设计一个算法重新排列数组中的数, 使得负数都排在正数前面. 要求算法使用 $O(n)$ 的时间和 $O(1)$ 的空间.

算法设计：由于算法要求使用 $O(n)$ 的时间和 $O(1)$ 的空间，因此可以使用类似快速排序的方式将数组扫描一遍完成局部排序。而且已知$A$中只有正数和负数，因此如果以比较作为基本运算，比较的对象就是$0$，相当于对$A$进行一轮哨兵元素为$0$的快速排序。

数据输入：$A[\mathrm{1..}n]$

结果输出：排序好的$A[\mathrm{1..}n]$

伪码描述：

1. $p\leftarrow 1//从起始位置向后扫描的指针$
2. $q\leftarrow n//从末尾位置向前扫描的指针$
3. $whileA[p]<0andp<ndo//直到找到第一个正数$
4. ​ $p\leftarrow p+1$
5. $whileA[q]>0andp>1do//直到找到第一个负数$
6. ​ $q\leftarrow q-1$
7. $ifp<q//检查满足交换的条件$
8. $thenswap(A[p],A[q]);goto3//交换两个元素并开始新一轮扫描$
9. $elsereturnA//排序结束返回$

复杂度分析：该算法相当于对数组进行一轮哨兵元素为$0$的快速排序，易得算法的时间复杂度是
$$\begin{array}{r}W(n)=O(n)\end{array}$$
算法没有空间存储需求，全部操作都在原数组上完成，因此空间复杂度是
$$\begin{array}{r}S(n)=O(1)\end{array}$$

3.2

设 $S$ 是 $n$ 个不等的正整数集合, $n$ 为偶数, 给出一个算法将 $S$ 划分为子集 $S_1$ 和 $S_2$,使得 $|S_1|=|S_2|=n/2$, 且 $|{\sum }_{x\in S_1}x-{\sum }_{x\in S_2}x|$ 达到最大, 即使得两个子集元素之和的差达到最大.

算法设计：$n$个不等的正整数集合$S$的元素个数为偶数，因此$n/2$仍为整数，划分后 $|S_1|=|S_2|=n/2$，要想使得$|{\sum }_{x\in S_1}x-{\sum }_{x\in S_2}x|$ 达到最大，就需要找出这个集合中较大或者较小的$n/2$个数，一种简易的思路就是先对集合$S$进行排序，排好序后直接按索引将前$n/2$个数划分出来作为目标子集即可达到目的。

数据输入：$S[\mathrm{1..}n]$

结果输出：$S_1[\mathrm{1..}n/2],S_2[\mathrm{1..}n/2]$

伪码描述：

1. $L\leftarrow \mathrm{Sort}(S)//先对集合S使用排序算法进行排序得到数组L$
2. $S_1\leftarrow L[\mathrm{1..}n/2]//划分排序后的数组的到子集S_1$
3. $S_2\leftarrow L[n/2..n]//划分排序后的数组的到子集S_2$
4. $return{S}_1,S_2//返回划分好的两个子集$

复杂度分析：该算法的时间代价集中在第$1$行的排序算法的环节，排序的时间复杂度为 $O(n\log n)$，之后的数组划分部分时间复杂度为$O(1)$，因此该算法的总时间复杂度为
$$\begin{array}{r}W(n)=O(n\log n)+O(1)=O(n\log n)\end{array}$$

默认排序算法都在原数组上完成，因此算法只需要常数规模的存储空间，空间复杂度是
$$\begin{array}{r}S(n)=O(1)\end{array}$$

3.3

设 $A$ 和 $B$ 都是从小到大已经排好序的 $n$ 个不等的整数构成的数组, 如果把 $A$ 和 $B$ 合并后的数组记作 $C$, 设计一个算法找出 $C$ 的中位数并给出复杂度分析.

算法设计：第一时间想到的思路是直接对$A$和$B$进行顺序遍历同时比较大小，找到第$n$个数返回，这相当于将$C$进行了排序，但是题目只需要我们给出$C$的中位数即可，显然这样的算法并不是最优解。

因此不妨采用递归分治的思想，并采用类似二分查找的方式寻找中位数，具体操作即将$A$和$B$的中位数拿出比较，如果二者相等则就是$C$的中位数，如果不相等，则根据具体情况递归查询规模减半的$A$和$B$的一半子集。

数据输入：$A[\mathrm{1..}n],B[\mathrm{1..}n]$

结果输出：$C$的中位数$median$

伪码描述：

​ $findMedian(A,B,start1,end1,start2,end2):$

1. $mid1\leftarrow (start1+end1)/2//找到A的中间元素索引值$
2. $mid2\leftarrow (start2+end2)/2//找到B的中间元素索引值$
3. $ifA[mid1]=B[mid2]//判断是否为中位数$
4. $thenreturnA[mid1]//找到峰顶返回$
5. $ifA[mid1]<B[mid2]//峰顶在后半部分$
6. $thenfindMedian(A,B,mid1,end1,start2,mid2)//递归寻找$
7. $ifA[mid1]>B[mid2]//峰顶在前半部分$
8. $thenfindMedian(A,B,start1,mid1,mid2,end2)//递归寻找$

递推方程：
$$\{\begin{array}{l}W(n)=W\left(\frac{n}{2}\right)+1\\ W(1)=1\end{array}$$
复杂度分析：该算法使用递归分治的思想，由递推方程可知，每次递归问题的规模减半，因此易得算法的时间复杂度是
$$\begin{array}{r}W(n)=O(\log n)\end{array}$$
算法只需要常数规模的存储空间，因此空间复杂度是
$$\begin{array}{r}S(n)=O(1)\end{array}$$

3.4

输入三个正整数 $a,p,k$, 求 $a^{p}modk$ 的值. 提示: 由于数据的规模很大, 如果直接计算, 不仅需要采用高精度, 而且时间复杂度很大。例如 $10^{25}mod7=3$, 但 $10^{25}$ 超出了整型数的表示范围，不能直接计算. 请使用分治策略实现取余运算的算法并给出复杂度分析.

算法设计：根据取余运算的相关性质：
$$a^p{a}^{q}modk=(a^{p}modk)(a^{q}modk)$$
由此想到可以对指数运算的取余操作运用分治策略，具体操作可以用以下公式概括：
$$a^{p}modk=a^{p/2}{a}^{p/2}modk=(a^{p/2}modk)(a^{p/2}modk)$$
值得注意的是，在分治过程中$p/2$不一定是整数，因此需要额外考虑和处理$p$为奇数的情况。

数据输入：三个正整数 $a,p,k$

结果输出：取余运算结果$result$

伪码描述：

​ $Mod(a,p,k):$

1. $ifp=0//递归终止条件$
2. $thenreturn1$
3. $t\leftarrow Mod(a,p/2,k)//递归分治，规模减半$
4. $ifp\%2=1//判断p是否为奇数$
5. $thenreturn(t\ast t\ast b)\%k//处理p为奇数的情况$
6. $elsereturn(t\ast t)\%k//p为偶数，正常返回$

递推方程：
$$\{\begin{array}{l}W(n)=W\left(\frac{n}{2}\right)+1\\ W(1)=1\end{array}$$
复杂度分析：该算法使用递归分治的思想，每次递归问题的规模减半，因此易得算法的时间复杂度是
$$\begin{array}{r}W(n)=O(\log n)\end{array}$$
算法只需要常数规模的存储空间，因此空间复杂度是
$$\begin{array}{r}S(n)=O(1)\end{array}$$