分治与递归（算法分析与设计）
1.分治法基本模板
divide-and-comquer(P)
{
if(|P|<=n0)
adhoc(P);
divide P into smaller subinstances P1,P2,...,Pk;
for(i=1;i<=k;i++)
yi=divide-and-comquer(Pi);
return merge(y1,...,yk);
}a.一般是递归出口
b.将原问题分割成若干子问题，子问题与原问题相同，规模略小
c.合并子问题的解（不是所有分治都有这个）
2.递归与非递归的转换记录
a.尾递归转非递归（一般先写好递归版，再用栈模拟）（本质：还是自顶而下）
尾递归在原问题转换成若干子问题之后，不再合并子问题的解，递归是最后的语句，递归之后不再有操作返回值或局部变量的表达式。
1.循环外压栈初始变量
2.循环以栈空为条件
3.循环内先出栈，恢复局部变量值
4.递归出口处，仍然编写递归出口处代码，由continue代替return来打断余下操作
5.用恢复的局部变量值操作
6.遇到递归处，改成压栈当前局部变量
7.出循环
b.线性（一般）递归转非递归
若用栈模拟递归，保存当前局部变量用以代替递归，但是递归之后，又需要用这些改变后的局部变量（或递归返回值）做子问题的合并，这个对我来说比较难做。所以换个方向，思考记录如下：
1.尾递归转非递归的本质还是自顶而下的处理问题，所以可以用栈轻易模拟
2.非尾递归可以自底而上，来转化递归
尾递归转非递归： 3.棋盘覆盖，4.快速排序
非尾递归转非递归：5.strassen矩阵乘法，6.合并排序
3.棋盘覆盖
a.递归版
#include
#include
using namespace std;
vector< vector > a;
static int tile=1;
void chessBoard(int startx,int starty,int msize,int x,int y)
{
if(msize==1)
{
return;
}
else
{
int g=tile++;//只能用局部变量来赋值，直接用静态变量，递归返回后，余下伪特殊方块的赋值就出问题了。
int tempx=(x-startx)/(msize/2);
int tempy=(y-starty)/(msize/2);
if(tempx==0&&tempy==0)
{
chessBoard(startx,starty,msize/2,x,y);
}
else
{
a[startx+msize/2-1][starty+msize/2-1]=g;
chessBoard(startx,starty,msize/2,startx+msize/2-1,starty+msize/2-1);
}
if(tempx==0&&tempy==1)
{
chessBoard(startx,starty+msize/2,msize/2,x,y);
}
else
{
a[startx+msize/2-1][starty+msize/2]=g;
chessBoard(startx,starty+msize/2,msize/2,startx+msize/2-1,starty+msize/2);
}
if(tempx==1&&tempy==0)
{
chessBoard(startx+msize/2,starty,msize/2,x,y);
}
else
{
a[startx+msize/2][starty+msize/2-1]=g;
chessBoard(startx+msize/2,starty,msize/2,startx+msize/2,starty+msize/2-1);
}
if(tempx==1&&tempy==1)
{
chessBoard(startx+msize/2,starty+msize/2,msize/2,x,y);
}
else
{
a[startx+msize/2][starty+msize/2]=g;
chessBoard(startx+msize/2,starty+msize/2,msize/2,startx+msize/2,starty+msize/2);
}
}
}
int main()
{
//初始化棋盘a，特殊元素赋值0，其余元素赋值-1
int n;
cout<<"please input n!"<>n;
vector temp;
for(int j=0;j>x>>y;
a[x][y]=0;
//特殊元素赋值0，伪特殊元素均大于0，未被标记的均为-1
chessBoard(0,0,n,x,y);
for(int i=0;i b.非递归版
#include
#include
#include
using namespace std;
typedef struct Node
{
public:
int startx;
int starty;
int msize;
int x;
int y;
};
vector< vector > a;//存放棋盘
stack s;//存放临时变量
void chessBoard(int startx,int starty,int msize,int x,int y)
{
Node temp;//临时变量
int g=1;
temp.startx=startx;
temp.starty=starty;
temp.msize=msize;
temp.x=x;
temp.y=y;
s.push(temp);//初始状态压栈
while(!s.empty())//栈空为循环终止判断条件
{
Node temp2=s.top();//出栈，恢复局部变量
s.pop();
if(temp2.msize==1)//递归出口处，return用continue代替，打断余下操作
{
continue;
}
if((temp2.x-temp2.startx)temp2.msize/2)
{
temp.startx=temp2.startx;
temp.starty=temp2.starty+temp2.msize/2;
temp.msize=temp2.msize/2;
temp.x=temp2.x;
temp.y=temp2.y;
s.push(temp);
}
else
{
temp.startx=temp2.startx;
temp.starty=temp2.starty+temp2.msize/2;
temp.msize=temp2.msize/2;
temp.x=temp2.startx+temp2.msize/2-1;
temp.y=temp2.starty+temp2.msize/2;
s.push(temp);
if(a[temp2.startx+temp2.msize/2-1][temp2.starty+temp2.msize/2]==-1)
a[temp2.startx+temp2.msize/2-1][temp2.starty+temp2.msize/2]=g;
}
if((temp2.x-temp2.startx)>temp2.msize/2&&(temp2.y-temp2.starty)temp2.msize/2&&(temp2.y-temp2.starty)>temp2.msize/2)
{
temp.startx=temp2.startx+temp2.msize/2;
temp.starty=temp2.starty+temp2.msize/2;
temp.msize=temp2.msize/2;
temp.x=temp2.x;
temp.y=temp2.y;
s.push(temp);
}
else
{
temp.startx=temp2.startx+temp2.msize/2;
temp.starty=temp2.starty+temp2.msize/2;
temp.msize=temp2.msize/2;
temp.x=temp2.startx+temp2.msize/2;
temp.y=temp2.starty+temp2.msize/2;
s.push(temp);
if(a[temp2.startx+temp2.msize/2][temp2.starty+temp2.msize/2]==-1)
a[temp2.startx+temp2.msize/2][temp2.starty+temp2.msize/2]=g;
}
g++;
}
return;
}
int main()
{
int n;
cout<<"please input n!"<>n;
vector temp;
for(int j=0;j>x>>y;
a[x][y]=0;
chessBoard(0,0,n,x,y);
for(int i=0;i 4.快速排序（随机快速排序：随机在left~right之间选择一个主元，再将主元与最左（右）元素互换位置，其他一切照旧）（按各主元对称的序列，快排效果最好）
a.递归版
#include
#include
using namespace std;
int qSortOne(vector &p,int left,int right)
{
int a=p[left];
while(leftp[left])
{
left++;
}
p[right]=p[left];
p[left]=a;
}
return left;
}
void qSort(vector &w,int left,int right)
{
if(left a;
int temp;
while(cin>>temp)
{
a.push_back(temp);
}
qSort(a,0,a.size()-1);
for(int i=0;i b.非递归版
#include
#include
#include
using namespace std;
typedef struct Node
{
int left;
int right;
};
stack s;
int qSortOne(vector &p,int left,int right)
{
int a=p[left];
while(leftp[left])
{
left++;
}
p[right]=p[left];
p[left]=a;
}
return left;
}
void qSort(vector &w,int left,int right)
{
Node temp;
temp.left=left;
temp.right=right;
s.push(temp);
while(!s.empty())
{
Node temp1=s.top();
s.pop();
if(temp1.left a;
int temp;
while(cin>>temp)
{
a.push_back(temp);
}
qSort(a,0,a.size()-1);
for(int i=0;i 5.strassen矩阵乘法
a.非递归版
#include
#include
using namespace std;
int main()
{
int n;
cout<<"please input n!"<>n;
vector< vector > A;//A作为乘数矩阵A，和存储结果矩阵C
vector< vector > B;
cout<<"please input matrix A!"< temp2;
for(int j=0;j>temp1;
temp2.push_back(temp1);
}
A.push_back(temp2);
}
cout<<"please input matrix B!"< temp2;
for(int j=0;j>temp1;
temp2.push_back(temp1);
}
B.push_back(temp2);
}
cout<<"count matrix C!"< M;
for(int j=0;j 6.合并排序
a.递归版
#include
#include
#include
using namespace std;
int random(int s,int e)
{
return s+rand()%(e-s+1);
}
void mergeD(vector &a,vector &b,int l,int mid,int r)
{
int i=l;
int j=mid+1;
while(i<=mid&&j<=r)
{
if(a[i] &a,vector &b,int l,int r)
{
for(int i=l;i<=r;i++)
{
a[i]=b[i-l];
}
}
void mergeSort(vector &d,int l,int r)
{
if(l b;
mergeD(d,b,l,i,r);
copyD(d,b,l,r);
}
}
int main()
{
vector data;
int temp;
cin>>temp;
for(int i=0;i #include
#include
#include
#include
using namespace std;
int random(int s,int e)
{
return s+rand()%(e-s+1);
}
void mergeD(vector &a,vector &b,int l,int mid,int r)
{
int i=l;
int j=mid+1;
while(i<=mid&&j<=r)
{
if(a[i] &a,vector &b,int l,int r)
{
for(int i=l;i<=r;i++)
{
a[i]=b[i-l];
}
}
//尾递归转非递归用栈模拟（本质上还是自顶而下）
//线性递归转非递归用栈模拟比较困难，那么就换种思路，自底而上
void mergeSort(vector &d)
{
int size=2;//排序小组大小
int n=d.size();
int left;
int right;
while(size<=n)
{
for(left=0;left+size-1<=n-1;left=left+size)
{
right=left+size-1;
vector b;
mergeD(d,b,left,(right+left)/2,right);
copyD(d,b,left,right);
}
if(right b;
mergeD(d,b,left,left+size/2-1,right);
copyD(d,b,left,right);
}
size=size*2;
}
size=size/2;
if(size!=n)
{
left=0;
right=n-1;
vector b;
mergeD(d,b,left,left+size-1,right);
copyD(d,b,left,right);
}
}
int main()
{
vector data;
int temp;
cin>>temp;
for(int i=0;i 7.线性时间选择（在序列中找出第k小的数（中位数等等））
a.寻找第k小元素（随机划分线性时间选择）
#include
#include
#include
using namespace std;
int random(int start,int end)//产生一个（start，end）之间的随机整数
{
return start+rand()%(end-start+1);//rand()产生一个随机整数
}
int qSortOne(vector &p,int left,int right)//随机划分一次（一次快排划分）
{
int i=(int)(random(left,right));
int a=p[left];
p[left]=p[i];
p[i]=a;
a=p[left];
while(leftp[left])
{
left++;
}
p[right]=p[left];
p[left]=a;
}
return left;
}
void findK(vector &w,int left,int right,int k)
{
if(left<=right)
{
int start=qSortOne(w,left,right);
if(start>k)//只递归一边
{
findK(w,left,start-1,k);
}
else if(start a;
int temp;
int k;
cout<<"please input k!"<>k;
cout<<"please input array a[],end by ctrl+z!"<>temp)
{
a.push_back(temp);
}
findK(a,0,a.size()-1,k);
for(int i=0;i b.寻找第k小元素（选择划分基准线性时间选择）
#include
#include
#include
#include
using namespace std;
int random(int start,int end)
{
return start+rand()%(end-start+1);
}
//比较元素已然确定，就不需要再在函数内部选了
int Partition(vector &d,int left,int right,int k)
{
int i = left-1,j = right + 1;
while(true)
{
while(d[++i]k);
if(i>=j)
{
break;
}
swap(d[i],d[j]);
}
return j;
}
//冒泡排序，用于对小组内元素排序
void Bubble(vector &d,int left,int right)
{
bool exchange;
for(int i=0;i<=right-left;i++)
{
exchange=false;
for(int j=left;jd[j+1])
{
swap(d[j],d[j+1]);
exchange=true;
}
}
if(!exchange)
{
return;
}
}
}
int Select(vector &d,int left,int right,int k)
{
if(left-right<75)//如果排序个数小于75个，就直接排序，返回第k大小的元素值
{
Bubble(d,left,right);
return d[left+k-1];
}
int i;
//如果排序个数大于75个，再用找中位数的中位数的方法来减少运算次数
for(i=0;i<=(right-left-4)/5;i++)
{
Bubble(d,left+i*5,left+i*5+4);//各小组内部排序
swap(d[left+i*5+2],d[left+i]);//将各小组的中位数都移到数组最左端
}
i--;
if((left+i*5+4) data;
int n;
cout<<"please input the size of array data[]!"<>n;
for(int i=0;i>k;
cout<<"the number is: "< a.O(n^2)暴力法
#include
#include
#include
#include
#include
using namespace std;
typedef struct Node
{
int x;
int y;
};
vector d;
int random(int s,int e)
{
return s+rand()%(e-s+1);
}
double dis(int a,int b)
{
return sqrt(pow(d[b].x-d[a].x+0.0,2)+pow(d[b].y-d[a].y+0.0,2));
}
bool cmpxy(Node a,Node b)
{
if(a.x!=b.x)
{
return a.x temt;
if(left+1==right)//只有两个元素，直接返回
{
return dis(right,left);
}
else if(left+2==right)//只有三个元素，按中位数分后，有一边只有一个元素，所以也是直接计算，返回结果
{
double d1=dis(right,left);
double d2=dis(right,left+1);
double d3=dis(right-1,left);
return min(min(d1,d2),d3);
}
double d1=Count(left,(left+right)/2);//以x坐标排序中位线划分左区
double d2=Count((left+right)/2+1,right);//以x坐标排序中位线划分右区
double dx=min(d1,d2);
for(int i=left;i<=right;i++)//没有按《算法设计与分析》中描写一样，这里是直接用暴力，将整个[-dx,dx]区间的数给囊括了
{
if(fabs(d[(left+right)/2].x-d[i].x)d3) //所以这个算法的复杂度是O(n^2)，而不是算法设计与分析》中的n*logn
{
dx=d3;
}
}
}
return dx;
}
int main()
{
int num;
cin>>num;
Node temp;
for(int i=0;i