文章目录
分治算法
1.分治算法的基本思想
-
总体思想
-
将待求解的较大规模的问题分割为k个更小规模的子问题
-
对k个子问题分别求解
-
如果子问题的规模仍不够小，则再划分为k个子问题，如此递归下去，直到问题的规模足够小、可以求出其解为止
-
将求出的小规模的问题的解合并为一个更大规模的问题的解，自底向上求出原来的解
-
-
适用条件
- 该问题的规模缩小到一定的程度就可以容易地解决
- 该问题可以分解为若干个规模的相同问题，即该问题具有最优子结构性质
- 利用该问题分解出的子问题的解可以合并为该问题的解【如果具备了前两条特征，而不具备第三条特征，则可以考虑贪心算法或动态规划】
- 该问题所分解出的各子问题是相互独立的，即子问题之间不包含公共的子问题【重复地解公共的子问题用动态规划较好】
2.分治算法的时间复杂度
- 公式求解
-
分情况讨论
-
f(n)=c
T ( n ) = { O ( log b n ) a = 1 O ( n log b a ) a ! = 1 T(n)=\begin{cases} O(\log_bn)&a=1\\ O(n^{\log_ba})&a!=1\end{cases} T(n)={O(logbn)O(nlogba)a=1a!=1 -
f(n)=cn
T ( n ) = { O ( n ) a < b O ( n log b a ) a > b O ( n log b n ) a = b T(n)=\begin{cases} O(n)&a<b\\ O(n^{\log_ba})&a>b\\ O(n\log_bn)&a=b\end{cases} T(n)=⎩⎪⎨⎪⎧O(n)O(nlogba)O(nlogbn)a<ba>ba=b
-
3.分治算法的经典案例分析
3.1 二分查找
分析
-
给定已按升序排列的n个元素A[0:n-1]，现要在这n个元素中找出某一特定元素
-
二分查找要求代查列表中的元素是有序的
设[low~high]为当前查找区间，首先确定区间的重点位置mid=(low+high）/2， 然后将待查的key与A[mid]进行比较。
-
若key=A[mid]，则查找成功并返回其下标
-
若key<A[mid]，则查找左子表A[low~mid]
-
若key>A[mid]，则查找左子表A[mid~high]
重复上述查找过程。直到查找到关键key或者查找空间为空(high-low<=0)
-
问题
使用递归算法，实现二分搜索。
输入
多组数据输入，每组第一个数字为数组的长度n，然后输入n个整数，最后输入待查询的值。
输出
输出待查询值所在的位置，如果没有找到，则返回-1。
样例
-
样例输入
3 1 2 3 2
4 0 1 3 4 2 -
样例输出
2
-1
代码
#include<stdio.h>
int mid;
int a[10001];
int erfen(int b,int low,int heigh)
{
mid=(low+heigh)/2;
if(a[mid]==b)
return mid;
if(low>=heigh)
return -1;
if(b>a[mid])
return erfen(b,mid+1,heigh);
if(b<a[mid])
return erfen(b,low,mid-1);
}
int main()
{
int n,b;
while(scanf("%d",&n)!=EOF)
{
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
scanf("%d",&b);
printf("%d\n",erfen(b,1,n));
}
}
3.2 快速排序(随机化)
分析
快速排序是对冒泡排序的一种改进，提高排序的效率。
-
基本思想
数据分区：选中一个关键key，排序后使得关键key的左边的数字比它小，右边的数字比他大
递归排序：递归处理关键key的左边的数字和右边的数字
-
算法设计
数据分区算法设计思想，随机选取一个下标与第一个数字作为交换作为关键key，然后i设为当前数组第一个数字的下标，也就是关键key，j设为关键key的下个数字的下标，然后j++(j<=n)，每次增加前判断j下标对应的当前数字是否小于关键key，若小于关键key，则i++，然后下标i对应的数字与下标j对应的数字交换。j++到最后一个数字时结束，最后将下标i对应的数字与关键key交换。这样就可以将比关键key小的数字放在它的左边，比它大的数字放在它的右边。
问题
编程实现快速排序算法，深入理解快速排序算法的基本思想。
输入
多组输入，每组第一个数字为数组长度，然后输入一个一维整型数组。
输出
输出快速排序之后的一维整型数组（升序）
样例
-
样例输入
6 1 8 6 5 3 4
5 12 42 2 5 8 -
样例输出
1 3 4 5 6 8
2 5 8 12 42
代码
#include<stdio.h>
#include<stdlib.h>
int a[10005];
//交换函数
int swap(int a[],int i,int j)
{
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
//分区函数
int partition(int a[],int p,int q)
{
int x=a[p];
int i=p,j;
for(j=p+1;j<=q;j++)
{
if(a[j]<=x)
{
i++;
swap(a,i,j);
}
}
swap(a,p,i);
return i;
}
//随机化函数
int random(int p,int q)
{
return rand()%(q-p+1)+p;
}
//选取关键key交换至第一个，然后进行分区
int randomizedPartition(int a[],int p,int q)
{
int r=random(p,q);
swap(a,p,r);
int i=partition(a,p,q);
return i;
}
void randomizedQuickSort(int a[],int p,int q)
{
if(p<q)
{
int r=randomizedPartition(a,p,q);
randomizedQuickSort(a,p,r-1);
randomizedQuickSort(a,r+1,q);
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
randomizedQuickSort(a,0,n-1);
for(int i=0;i<n;i++)
{
printf("%d ",a[i]);
}
printf("\n");
}
return 0;
}
3.3 归并排序
分析
-
概述
- 将两个或两个以上的有序子序列归并为一个有序序列
- 在内部排序中，通常采用二路归并排序
-
基本思路
假设两个有序序列一个为a[n],一个为b[n]，i为a数组的下标，j为b数组的下标，然后a[i]与b[j]比较，较小的那个数放入新的数组里面去，假设是a[i]小，则i++后a[i]继续与b[j]比较，假设是b[j]小，则j++后b[j]继续与a[i]比较，重复上过程，直到下标i到达最后一个数或者下标j到达最后一个数，最后将a数组或者b数组剩余的数放在新数组的后面，这样就完成了一次二路归并排序。
归并排序就是基于分治的思想，一组无序的元素，先将其分成一个一个的元素，然后将其两两进行二路归并排序，最后生成一个新的有序数组，即排序完成。如图所示：
问题
编写一个程序，使用分治策略实现二路归并排序（升序）。
输入
多组输入，每组第一个数字为数组长度，然后输入一个一维整型数组。
输出
输出排序之后（升序）的一维整型数组，每组输出占一行。
样例
-
样例输入
6 1 8 6 5 3 4
5 12 42 2 5 8 -
样例输出
1 3 4 5 6 8
2 5 8 12 42
代码
#include<stdio.h>
int y[1000];
void copy(int a[1000],int y[1000],int n,int t)
{
for(int i=n;i<=t;i++)
a[i]=y[i];
}
void hebing(int a[1000],int y[1000],int n,int m,int t){
int i=n;
int j=m+1;
int k=n;
while(i<=m&&j<=t)
{
if(a[i]<=a[j])
y[k++]=a[i++];
else
y[k++]=a[j++];
}
while(i<=m)
{
y[k++]=a[i++];
}
while(j<=t)
{
y[k++]=a[j++];
}
}
void hebingsort(int a[1000],int p,int n)
{
int j=(p+n)/2;
if(p<n)
{
hebingsort(a,p,j);
hebingsort(a,j+1,n);
hebing(a,y,p,j,n);
copy(a,y,p,n);
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
int a[1000];
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
hebingsort(a,0,n-1);
for(int i=0;i<n;i++)
{
printf("%d ",a[i]);
}
printf("\n");
}
}
3.4 第k小元素
分析
给定线性序列中n个元素和一个整数k，1<=k<=n，要求找出这n个元素中第k小的元素
-
基本思想
利用快排分区思想，统计比关键key(基准元素)小的元素个数。如果个数大于等于k，则第k小元素在前半部分，否则在后半部分。
-
算法设计
对于无序序列a[s…t]，在其中查找第k小元素的过程:
- 若s=t，即其中只有一个元素，返回a[s]
- 若s!=t，表示该序列中有两个或两个以上元素，以基准为中心将其划分为a[s…i]和a[i+1…t],a[s…i]中所有元素均小于等于a[i]，a[i+1…t]中所有元素均大于a[i].
- j = i-s+1，统计小于等于a[i]的元素个数
- j>=k，第k小元素在a[s…i]中，递归在a[s…i]中寻找第k小元素
- j<k，第k小元素在a[i+1…t]中，递归在a[i+1…t]中寻找第k-j小元素
问题
输入一个整数数组，请求出该数组的第k小元素。要求时间复杂度为O(n)。
输入
每组输入包括两行，第一行为一个整数数组，两个数字之间用空格隔开；第二行为k值。数组中元素个数小于10^9。
输出
输出第k小元素的值。
样例
-
样例输入
2 5 6 1 8 7 9
2 -
样例输出
2
代码
#include<stdio.h> #include <stdlib.h> //交换函数 int swap(int a[],int i,int j) { int temp=a[i]; a[i]=a[j]; a[j]=temp; } int partition(int a[],int p,int q) { int x=a[p]; int i=p,j; for(j=p+1;j<=q;j++) { if(a[j]<=x) { i++; swap(a,i,j); } } swap(a,p,i); return i; } int random(int p,int q) { return rand()%(q-p+1)+p; } int randomizedPartition(int a[],int p,int q) { int r=random(p,q); swap(a,p,r); int i=partition(a,p,q); return i; } int randomizedSelect(int a[],int s,int t,int k) { if(s==t) return a[s]; int i=randomizedPartition(a,s,t), j=i-s+1; if(k<=j) return randomizedSelect(a,s,i,k); else{ return randomizedSelect(a,i+1,t,k-j); } } int main() { int a[10000],k,i=0; char c; while(scanf("%d%c",&a[++i],&c)!=EOF) { if(c=='\n') { scanf("%d",&k); printf("%d\n",randomizedSelect(a,1,i,k)); i=0; } } }
3.5 棋盘覆盖
分析
-
问题描述
- 在一个2k*2k个方格组成的棋盘中，恰有一个方格与其他方格方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。
- 在棋盘覆盖问题中，要用以下四种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格。且任何两个L型骨牌不得重复覆盖。
-
算法设计
当k>0时，**将2k2k棋盘分为4个2k-12k-1小棋盘,特殊方格必位于4个小棋盘之一中，其余3个小棋盘中无特殊方格，为了将这3个无特殊方格的小棋盘装换为特殊棋盘，可以用一个L型骨牌覆盖这3个小棋盘的汇合处，因此问题就变为
- 问题转化为4个较小规模的棋盘覆盖问题
- 递归的使用这种分割，直至棋盘简化为1*1棋盘
-
分割棋盘:将大棋盘分割为四个小棋盘
-
判断特殊方格的位置:判断特殊方格在哪个小棋盘中
-
判断方法:记录大棋盘左上角方格的行列坐标，结合棋盘边长再与特殊方格的坐标进行比较，可判断特殊方格的位置
- 如果特殊方格在某一小棋盘中，继续递归
- 如果不在某一小棋盘中，则根据分割的四个小棋盘的不同位置，把右下角、左下角、右上角或者左上角的方格标记为特殊方格，然后继续递归
-
变量s用于记录边的方格数(边长)，每次对棋盘进行分割时，边的方格数都会减半
问题
在一个n×n (n = 2k)个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。
在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。
输入
多组测试用例，每组测试用例包括两部分，
第一部分为方格的宽度n，
第二部分则为方格，特殊方格为-1，其他方格为0。
输出
输出覆盖后的方案
样例
-
样例输入
4
-1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0 -
样例输出
-1 2 4 4
2 2 1 4
3 1 1 5
3 3 5 5
代码
#include<stdio.h>
int y;
int a[100][100];
//size用于记录边的方格数(边长)，每次对棋盘进行分割时，边的方格数都会减半
//(tr,tc)为大棋盘左上角方格的行列坐标 (dr,dc)为特殊方格所在的行列坐标
void qipanfugai(int tr,int tc,int dr,int dc,int size)
{
if(size==1)
return;
int t=y++;
//将大棋盘分割为四个小棋盘
int s=size/2;
//左上角
//判断特殊方格在哪个小棋盘中
if(dr<tr+s&&dc<tc+s)
{
//如果特殊方格在某一小棋盘中，继续递归
qipanfugai(tr,tc,dr,dc,s);
}
else{
//如果不在左上角棋盘中，把左下角的方格标记为特殊方格，然后继续递归
a[tr+s-1][tc+s-1]=t;
qipanfugai(tr,tc,tr+s-1,tc+s-1,s);
}
//左下角
if(dr>=tr+s&&dc<tc+s)
{
qipanfugai(tr+s,tc,dr,dc,s);
}
else{
a[tr+s][tc+s-1]=t;
qipanfugai(tr+s,tc,tr+s,tc+s-1,s);
}
//右上角
if(dr<tr+s&&dc>=tc+s)
{
qipanfugai(tr,tc+s,dr,dc,s);
}
else{
a[tr+s-1][tc+s]=t;
qipanfugai(tr,tc+s,tr+s-1,tc+s,s);
}
//右下角
if(dr>=tr+s&&dc>=tc+s)
{
qipanfugai(tr+s,tc+s,dr,dc,s);
}
else{
a[tr+s][tc+s]=t;
qipanfugai(tr+s,tc+s,tr+s,tc+s,s);
}
}
int main()
{
int n,d,r;
while(scanf("%d",&n)!=EOF)
{
y=1;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
if(a[i][j]!=0)
{
d=i;
r=j;
}
}
}
qipanfugai(0,0,d,r,n);
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
printf("%d ",a[i][j]);
}
printf("\n");
}
}
}
3.6 大整数的乘法
分析
-
十进制整数：理想状态，X和Y的位数一样，且n=2m，m=1,2,3,……；
例如：1234*5678
-
算法改进：为了降低时间复杂度，必须减少乘法的次数，两个数相乘可用如下公式求解
X=AB(A代表前n/2位，B代表后n/2位) Y=CD(C代表前n/2位，D代表后n/2位)
X Y = A C ∗ 1 0 n + ( ( A − B ) ( D − C ) + A C + B D ) ∗ 1 0 n / 2 + B D XY=AC*10^n+((A-B)(D-C)+AC+BD)*10^{n/2}+BD XY=AC∗10n+((A−B)(D−C)+AC+BD)∗10n/2+BD
问题
使用分治算法实现两个大整数相乘。
输入
两个十进制大整数，满足每一个整数长度为2^n且两个大整数的长度相等。（多组数据）
输出
两个大整数的乘积。
样例
-
样例输入
1234 5678
-
样例输出
7006652
代码
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int t=0;
int fuhao(long v)
{
if(v<0)
{
return -1;
}
else
return 1;
}
int changdu(long a)
{
while(a!=0)
{
t++;
a=a/10;
}
return t;
}
long zhengshuchenfa(long a,long c,int n)
{
int s=fuhao(a)*fuhao(c);
a=abs(a);
c=abs(c);
if(a==0||c==0)
return 0;
else if(n==1)
return s*a*c;
else{
//将大整数拆成两个长度为n/2的整数
long A=(long)(a/pow(10,n/2));
long B=(long)(a%(long)(pow(10,n/2)+0.5));
long C=(long)(c/pow(10,n/2));
long D=(long)(c%(long)(pow(10,n/2)+0.5));
//位数仍然大于1则递归求解
long AC=zhengshuchenfa(A,C,n/2);
long BD=zhengshuchenfa(B,D,n/2);
long ABCD=zhengshuchenfa((A-B),(D-C),n/2)+AC+BD;
//最后返回所求出的值
return (long)(s*(AC*pow(10,n)+ABCD*pow(10,n/2)+BD));
}
}
int main()
{
int b;
long m,n;
while(scanf("%ld%ld",&m,&n)!=EOF)
{
t=0;
b=changdu(m);
printf("%ld\n",zhengshuchenfa(m,n,b));
}
}
小编能力有限，如有问题欢迎大家评论，感谢大家的访问！
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
