0003算法笔记——【分治法】分治法与二分搜索，棋盘覆盖问题
2013-10-30 17:47
316 查看
1、分治法
分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同。递归的解这些子问题，然后将各子问题的解合并得到原问题的解。
分治法所能解决的问题一般具有以下几个特征：
1) 该问题的规模缩小到一定的程度就可以容易地解决
2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3) 利用该问题分解出的子问题的解可以合并为该问题的解；
4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。
分治法的基本步骤：
分治法在每一层递归上都有三个步骤：
分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题；
合并：将各个子问题的解合并为原问题的解。
它的一般的算法设计模式如下：
[cpp]
view plaincopyprint?
Divide-and-Conquer(P)
1. if |P|≤n0
2. then return(ADHOC(P))
3. 将P分解为较小的子问题 P1 ,P2 ,...,Pk
4. for i←1 to k
5. do yi ← Divide-and-Conquer(Pi) △ 递归解决Pi
6. T ← MERGE(y1,y2,...,yk) △ 合并子问题
7. return(T)
其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必
再继续分解。ADHOC(P)是该分治法中的基本子算法，用于直接解小规模的问题P。因此，当P的规模不超过n0
时直接用算法ADHOC(P)求解。算法MERGE(y1,y2,...,yk)是该分治法中的合并子算法，用于将P的子问题P1
,P2 ,...,Pk的相应的解y1,y2,...,yk合并为P的解。
子问题的划分：人们从大量实践中发现，在用分治法设计算法时，最好使子问题的规模大致相同。换句话说，将一个问题分成大小相等的k个子问题的处理方法是行之有效的。许多问题可以取
k = 2。这种使子问题规模大致相等的做法是出自一种平衡(balancing)子问题的思想，它几乎总是比子问题规模不等的做法要好。
2、二分搜索
大部分程序员应该都知道二分搜索的大致原理，这里不再赘述。需要说明的是二分搜索是所有以比较为基础的搜索算法时间复杂度最低的算法。用二叉树描速二分查找算法，最坏情况下与二叉树的最高阶相同。比较二叉树线性查找也可用二叉树表示，最坏情况下比较次数为数组元素数量。任何一种以比较为基础的搜索算法，其最坏情况所用时间不可能低于O(logn)。
二分搜索程序清单如下：
[cpp]
view plaincopyprint?
//2d3 二分搜索技术
#include "stdafx.h"
#include <iostream>
using namespace std;
template<class Type>
int BinarySearch(Type a[],const Type& x,int n);
int main()
{
int x = 6;
int a[10];
for(int i=0; i<10; i++)
{
a[i] = i + 1;
}
cout<<BinarySearch(a,x,10)<<endl;
return 0;
}
template<class Type>
int BinarySearch(Type a[],const Type& x,int n)
{
int left = 0;
int right = n-1;
while(left<=right)
{
int mid = (left + right)/2;
if(x == a[mid])
{
return mid;
}
if(x>a[mid])
{
left = mid + 1;
}
else
{
right = mid - 1;
}
}
return -1;
}
3、棋盘覆盖问题
在一个2^k * 2^k个方格组成的棋盘中，有一个方格与其它的不同，若使用以下四种L型骨牌覆盖除这个特殊方格的其它方格，如何覆盖。四个L型骨牌如下图：
棋盘中的特殊方格如图：
实现的基本原理是将2^k * 2^k的棋盘分成四块2^(k - 1) * 2^(k - 1)的子棋盘，特殊方格一定在其中的一个子棋盘中，如果特殊方格在某一个子棋盘中，继续递归处理这个子棋盘，直到这个子棋盘中只有一个方格为止如果特殊方格不在某一个子棋盘中，将这个子棋盘中的相应的位置设为骨牌号，将这个无特殊方格的了棋盘转换为有特殊方格的子棋盘，然后再递归处理这个子棋盘。以上原理如图所示：
棋盘覆盖程序如下：
[cpp]
view plaincopyprint?
//2d6 棋盘覆盖问题
#include "stdafx.h"
#include <iostream>
using namespace std;
int tile = 1;//全局变量 骨牌编号
int Board[4][4];//棋盘
void ChessBoard(int tr,int tc,int dr,int dc,int size);
int main()
{
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
Board[i][j] = 0;
}
}
ChessBoard(0,0,2,3,4);
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
cout<<Board[i][j]<<" ";
}
cout<<endl;
}
}
/**
* tr : 棋盘左上角的行号，tc棋盘左上角的列号
* dr : 特殊方格左上角的行号，dc特殊方格左上角的列号
* size ：size = 2^k 棋盘规格为2^k*2^k
*/
void ChessBoard(int tr,int tc,int dr,int dc,int size)
{
if(size == 1)
{
return;
}
int t = tile++;//L型骨牌编号
int s = size/2;//分割棋盘
//覆盖左上角子棋盘
if(dr<tr+s && dc<tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr,tc,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖右下角
Board[tr+s-1][tc+s-1] = t;
//覆盖其余方格
ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
}
//覆盖右上角子棋盘
if(dr<tr+s && dc>=tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr,tc+s,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖左下角
Board[tr+s-1][tc+s] = t;
//覆盖其余方格
ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
}
//覆盖左下角子棋盘
if(dr>=tr+s && dc<tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr+s,tc,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖右上角
Board[tr+s][tc+s-1] = t;
//覆盖其余方格
ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
}
//覆盖右下角子棋盘
if(dr>=tr+s && dc>=tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr+s,tc+s,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖左上角
Board[tr+s][tc+s] = t;
//覆盖其余方格
ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
}
}
程序运行结果如下：
分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同。递归的解这些子问题，然后将各子问题的解合并得到原问题的解。
分治法所能解决的问题一般具有以下几个特征：
1) 该问题的规模缩小到一定的程度就可以容易地解决
2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3) 利用该问题分解出的子问题的解可以合并为该问题的解；
4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。
分治法的基本步骤：
分治法在每一层递归上都有三个步骤：
分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题；
合并：将各个子问题的解合并为原问题的解。
它的一般的算法设计模式如下：
[cpp]
view plaincopyprint?
Divide-and-Conquer(P)
1. if |P|≤n0
2. then return(ADHOC(P))
3. 将P分解为较小的子问题 P1 ,P2 ,...,Pk
4. for i←1 to k
5. do yi ← Divide-and-Conquer(Pi) △ 递归解决Pi
6. T ← MERGE(y1,y2,...,yk) △ 合并子问题
7. return(T)
Divide-and-Conquer(P) 1. if |P|≤n0 2. then return(ADHOC(P)) 3. 将P分解为较小的子问题 P1 ,P2 ,...,Pk 4. for i←1 to k 5. do yi ← Divide-and-Conquer(Pi) △ 递归解决Pi 6. T ← MERGE(y1,y2,...,yk) △ 合并子问题 7. return(T)
其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必
再继续分解。ADHOC(P)是该分治法中的基本子算法，用于直接解小规模的问题P。因此，当P的规模不超过n0
时直接用算法ADHOC(P)求解。算法MERGE(y1,y2,...,yk)是该分治法中的合并子算法，用于将P的子问题P1
,P2 ,...,Pk的相应的解y1,y2,...,yk合并为P的解。
子问题的划分：人们从大量实践中发现，在用分治法设计算法时，最好使子问题的规模大致相同。换句话说，将一个问题分成大小相等的k个子问题的处理方法是行之有效的。许多问题可以取
k = 2。这种使子问题规模大致相等的做法是出自一种平衡(balancing)子问题的思想，它几乎总是比子问题规模不等的做法要好。
2、二分搜索
大部分程序员应该都知道二分搜索的大致原理，这里不再赘述。需要说明的是二分搜索是所有以比较为基础的搜索算法时间复杂度最低的算法。用二叉树描速二分查找算法，最坏情况下与二叉树的最高阶相同。比较二叉树线性查找也可用二叉树表示，最坏情况下比较次数为数组元素数量。任何一种以比较为基础的搜索算法，其最坏情况所用时间不可能低于O(logn)。
二分搜索程序清单如下：
[cpp]
view plaincopyprint?
//2d3 二分搜索技术
#include "stdafx.h"
#include <iostream>
using namespace std;
template<class Type>
int BinarySearch(Type a[],const Type& x,int n);
int main()
{
int x = 6;
int a[10];
for(int i=0; i<10; i++)
{
a[i] = i + 1;
}
cout<<BinarySearch(a,x,10)<<endl;
return 0;
}
template<class Type>
int BinarySearch(Type a[],const Type& x,int n)
{
int left = 0;
int right = n-1;
while(left<=right)
{
int mid = (left + right)/2;
if(x == a[mid])
{
return mid;
}
if(x>a[mid])
{
left = mid + 1;
}
else
{
right = mid - 1;
}
}
return -1;
}
//2d3 二分搜索技术
#include "stdafx.h"
#include <iostream>
using namespace std;
template<class Type>
int BinarySearch(Type a[],const Type& x,int n);
int main()
{
int x = 6;
int a[10];
for(int i=0; i<10; i++)
{
a[i] = i + 1;
}
cout<<BinarySearch(a,x,10)<<endl;
return 0;
}
template<class Type>
int BinarySearch(Type a[],const Type& x,int n)
{
int left = 0;
int right = n-1;
while(left<=right)
{
int mid = (left + right)/2;
if(x == a[mid])
{
return mid;
}
if(x>a[mid])
{
left = mid + 1;
}
else
{
right = mid - 1;
}
}
return -1;
}3、棋盘覆盖问题
在一个2^k * 2^k个方格组成的棋盘中，有一个方格与其它的不同，若使用以下四种L型骨牌覆盖除这个特殊方格的其它方格，如何覆盖。四个L型骨牌如下图：
棋盘中的特殊方格如图：
实现的基本原理是将2^k * 2^k的棋盘分成四块2^(k - 1) * 2^(k - 1)的子棋盘，特殊方格一定在其中的一个子棋盘中，如果特殊方格在某一个子棋盘中，继续递归处理这个子棋盘，直到这个子棋盘中只有一个方格为止如果特殊方格不在某一个子棋盘中，将这个子棋盘中的相应的位置设为骨牌号，将这个无特殊方格的了棋盘转换为有特殊方格的子棋盘，然后再递归处理这个子棋盘。以上原理如图所示：
棋盘覆盖程序如下：
[cpp]
view plaincopyprint?
//2d6 棋盘覆盖问题
#include "stdafx.h"
#include <iostream>
using namespace std;
int tile = 1;//全局变量 骨牌编号
int Board[4][4];//棋盘
void ChessBoard(int tr,int tc,int dr,int dc,int size);
int main()
{
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
Board[i][j] = 0;
}
}
ChessBoard(0,0,2,3,4);
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
cout<<Board[i][j]<<" ";
}
cout<<endl;
}
}
/**
* tr : 棋盘左上角的行号，tc棋盘左上角的列号
* dr : 特殊方格左上角的行号，dc特殊方格左上角的列号
* size ：size = 2^k 棋盘规格为2^k*2^k
*/
void ChessBoard(int tr,int tc,int dr,int dc,int size)
{
if(size == 1)
{
return;
}
int t = tile++;//L型骨牌编号
int s = size/2;//分割棋盘
//覆盖左上角子棋盘
if(dr<tr+s && dc<tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr,tc,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖右下角
Board[tr+s-1][tc+s-1] = t;
//覆盖其余方格
ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
}
//覆盖右上角子棋盘
if(dr<tr+s && dc>=tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr,tc+s,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖左下角
Board[tr+s-1][tc+s] = t;
//覆盖其余方格
ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
}
//覆盖左下角子棋盘
if(dr>=tr+s && dc<tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr+s,tc,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖右上角
Board[tr+s][tc+s-1] = t;
//覆盖其余方格
ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
}
//覆盖右下角子棋盘
if(dr>=tr+s && dc>=tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr+s,tc+s,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖左上角
Board[tr+s][tc+s] = t;
//覆盖其余方格
ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
}
}
//2d6 棋盘覆盖问题
#include "stdafx.h"
#include <iostream>
using namespace std;
int tile = 1;//全局变量 骨牌编号
int Board[4][4];//棋盘
void ChessBoard(int tr,int tc,int dr,int dc,int size);
int main()
{
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
Board[i][j] = 0;
}
}
ChessBoard(0,0,2,3,4);
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
cout<<Board[i][j]<<" ";
}
cout<<endl;
}
}
/**
* tr : 棋盘左上角的行号，tc棋盘左上角的列号
* dr : 特殊方格左上角的行号，dc特殊方格左上角的列号
* size ：size = 2^k 棋盘规格为2^k*2^k
*/
void ChessBoard(int tr,int tc,int dr,int dc,int size)
{
if(size == 1)
{
return;
}
int t = tile++;//L型骨牌编号
int s = size/2;//分割棋盘
//覆盖左上角子棋盘
if(dr<tr+s && dc<tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr,tc,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖右下角
Board[tr+s-1][tc+s-1] = t;
//覆盖其余方格
ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
}
//覆盖右上角子棋盘
if(dr<tr+s && dc>=tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr,tc+s,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖左下角
Board[tr+s-1][tc+s] = t;
//覆盖其余方格
ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
}
//覆盖左下角子棋盘
if(dr>=tr+s && dc<tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr+s,tc,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖右上角
Board[tr+s][tc+s-1] = t;
//覆盖其余方格
ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
}
//覆盖右下角子棋盘
if(dr>=tr+s && dc>=tc+s)//特殊方格在此棋盘中
{
ChessBoard(tr+s,tc+s,dr,dc,s);
}
else//特殊方格不在此棋盘中
{
//用编号为t的骨牌覆盖左上角
Board[tr+s][tc+s] = t;
//覆盖其余方格
ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
}
}程序运行结果如下：
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 0003算法笔记——【分治法】分治法与二分搜索，棋盘覆盖问题
- 0003算法笔记——【分治法】分治法与二分搜索，棋盘覆盖问题
- 03算法笔记——【分治法】分治法与二分搜索，棋盘覆盖问题
- 【分治法】分治法与二分搜索，棋盘覆盖问题
- 分治法---棋盘覆盖问题
- 棋盘覆盖问题 分治法
- 【Java学习笔记】40：棋盘覆盖问题的可视化(基于JFrame)
- 棋盘覆盖问题 (分治法)
- 算法java实现--分治法--棋盘覆盖问题
- 分治法——棋盘覆盖问题
- 棋盘覆盖问题 - 分治法（c++）
- 计算机算法设计与分析作业01：分治法求解大数乘法+L型骨牌的棋盘覆盖问题
- 分治法——棋盘覆盖问题
- 经典算法之棋盘覆盖问题 --分治法
- 算法笔记——【分治法】棋盘覆盖
- 分治---二分搜索，棋盘覆盖
- bzoj1052: [HAOI2007]覆盖问题（二分+搜索）
- [BZOJ 1052] 覆盖问题 二分+搜索(DFS)+贪心
- 005-二分搜索-分治法-《算法设计技巧与分析》M.H.A学习笔记
- 算法笔记——【分治法】分治法与二分搜索