参考链接:
a.http://www.programfan.com/blog/article.asp?id=13086
b.http://blog.csdn.net/hhygcy/article/details/3950158
1.对(http://hao3100590.iteye.com/blog/1548135)中问题6:最长递增子序列的改进,减少时间复杂度
算法的思想:
它不是使用的动态规划法,而是普通的算法思想,就是在数组中直接存储最长递增子序列,在循环的过程中不断的查找插入位置,直到最终找到。下面列出实现的过程:
从上面的过程可以看出该算法的实现过程,在查找sub合适插入位置的时候,使用了二分查找,提高了查找速度,这个算法本身也比前面利用动态规划法简单,但是该算法复杂之处不在算法
而在算法正确性的证明!,算法证明见:http://www.programfan.com/blog/article.asp?id=13086
代码:
#include <iostream>
#include <cstring>
using namespace std;
const int MIN = -32768;
/**
*a :原始数组
*sub :最终获取的最大递增子序列(注意,sub[0]是哨兵,结果从1开始)
*length :数组长度
**/
int longestSub(int* a, int* sub, int length){
if(length<=0) return 0;
sub[0]=MIN; //为了初始化的比较,相当于哨兵的作用
sub[1]=a[0]; //初始序列就是a[0]
int len = 1; //最大递增子序列长度
int mid, left, right; //二分查找时的index
for(int i=0; i<length; i++){
//在sub数组中二分查找合适的插入位置
left = 0;
right = len;
//获取的最终插入位置就如a[i]=6,{1,3,5,7}位置就是5后面index=3,会替代7
while(left<=right){
mid = (left+right)/2;
if(sub[mid]<a[i]) left=mid+1;
else right=mid-1;
}
//策略是使用替代,不断的寻找合适的值,插入sub,最后sub中剩余的值就是要寻找的最长递增子序列
sub[left]=a[i];
if(left>len) len++;
}
return len;
}
int main(){
int a[] = { 1, 9, 3, 8, 11, 4, 5, 6, 4, 19, 7, 1, 7 };
int* sub = new int[13];
memset(sub,0,sizeof(int));
int length = longestSub(a,sub,13);
cout<<"length:"<<length<<endl;
for(int i=1; i<=length; i++) cout<<sub[i]<<" ";
delete[] sub;
sub=NULL;
return 0;
}
这个算法的时间复杂度只有O(nlogn),效率明显提高了而且也更简单了
不过其结果和改进之前的有些不同,前面是{1,3,4,5,6,19},改进之后是{1,3,4,5,6,7}结果都是正确的!
2.实际应用的两个例子
a.造桥问题
问题描述:
要在一条河的南北两边的各个城市之间造若干座桥.桥两边的城市分别是a(1)...a(n)和b(1)...b(n).这里的要求a(i)只可以和b(i)之间造桥,同时两座桥之间不能交叉.希望可以得到一个尽量多座桥的方案.
问题分析:
首先,这是一个动态规划的问题,即解答有许多中,寻找一个最优的解决方案。
其次,问题抽象,就是怎样将这个问题抽象成一个数学模型进行解决
第一步:就是搞清楚问题是什么?-------就是对号入座A对应于B的序号,这样的解决方案有许多如1,5,4和2,5,4以及1,3
第二步:抽象-------抽象成两个数组S1(1,2,5,4,3), S2(2,1,3,5,4),然后找S1和S2中相同的数字,且序号必须在数组下标递增,找出最多的对数
(即S1中的1对应了S2中的1,S1中的2对应了S2中的2,虽然S1中的下标是1,2 但是在S2中的下标是2,1没有递增,故而是不行的---更简单的说就是上面图不能交叉)
第三步:找规律--------这是最难的,如何才能从中找到突破口,我们在寻找的过程中发现,联系S1和S2的桥梁是什么?就是组成对的两个数在各自数组中的下标
那我们把这些下标都写出来,只是写一方就可以了从S1到S2的,就设为S3(2,1,4,5,3)---就表示S3[0]=2表示S1数组第一个值对应与S2中的第二个值(这个2就是在S2中的下标),
从而依次就把S3写出来了,这样找对数最多,而S3表示的是连线时对方的下标,那么是不是只要下标递增就不会交叉了?事实就是这样!!
就是找S3中的最长递增数组,这里就是{2,4,5}或者{1,4,5}
第四步:写代码-------既然突破口找到了,代码就不是问题了
代码
/**
*建桥问题
**/
#include <iostream>
#include <cstring>
using namespace std;
/**
*建立建桥索引数组
*a : 原始数组a
*b : 原始数组b
*c :建立的索引数组
*length :数组长度
*/
void build(const int* a, const int* b, int* c, int length){
for(int i=0; i<length; i++){
for(int j=0; j<length; j++){
if(a[i]==b[j]){
c[i]=j+1;//我们建立数组时以1为开始
break;
}
}
}
}
/**
*s2 :原始数组S2
*rt : 求出的最大递增子序列
*length:数组长度
*/
void printResult(int* s2, int* rt, int length){
int j = 0;
for(int i=0; i<length; i++)
{
if(rt[i]==0) break;
j = s2[rt[i]-1];
cout<<"B"<<j<<"--A"<<j<<" ";
}
cout<<endl;
}
/**
*a : 原始数组
*length :数组长度
*sub :求出的最大递增子序列
*/
void longestIncreaseSub(int* a, int length, int* sub){
int n = length;
int *t = new int[n];
int *p = new int[n];
memset(p,0,sizeof(int));
t[0]=1;
for(int i=1; i<n; i++){
t[i]=1;
for(int j=0; j<i; j++){
if(a[j]<a[i] && t[j]>t[i]-1){
t[i]=t[j]+1;
p[i]=j;
}
}
}
int m=0,k=0;
for (int i=1;i<=n;i++)
{
if (m<t[i])
{
m = t[i];
k = i;
}
}
while(m>=0){
sub[m-1] = a[k];
m--;
k = p[k];
}
delete[] t;
delete[] p;
p = NULL;
t = NULL;
}
int main(){
int a[] = {1,2,5,4,3};
int b[] = {2,1,3,5,4};
int length = sizeof(a)/sizeof(int);
//索引数组
int* c = new int[length];
//存储最终结果
int* sub = new int[length];
memset(sub,0,sizeof(int));//初始化sub
memset(sub,0,sizeof(int));//初始化sub
build(a,b,c,length);
longestIncreaseSub(c,length, sub);
printResult(b,sub, length);
delete[] c;
delete[] sub;
c = NULL;
sub = NULL;
return 0;
}
b.叠箱子问题
问题描述:
1.一排有许多不同的箱子,长宽高不一样
2.你需要把他叠放的尽量的高.但是箱子的摆放必须满足大的在下面,小的在上面的原则
3.箱子可以任意旋转(这就意味着你要用一个箱子的时候,旋转到合适位置)
问题分析:
具体分析见图:
注1:盒子要比上面的大--准确的说,是Wi>Wj && Di>Dj,单独使用Si>Sj不准确,因为可能很长但很窄,不和题目要求
为了满足要求,我们人为规定,W<=D(输入时确定或者后来处理),这样就不用担心这个问题了,使用Si>Sj就满足要求。
注2:记住盒子可以旋转,意味着每个盒子可以有三个面可以使用,旋转数量不限。
注3:本体关键是建立模型,列出动态规划的方程
代码:
/**
*
*叠箱子问题
*/
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
//定义一个箱子结构体
struct Box{
int h;//高
int w;//宽
int d;//长
};
//排序比较器
bool boxCompare(const Box& a, const Box&b){
return a.d*a.w > b.d*b.w;//降序排序
}
//最高的堆叠高度算法
int highestBox(const vector<Box>& b){
//初始判断
if(b.size()<=0) return 0;
//初始化一个vector,长度是原来的三倍,因为每个箱子都有三种翻转方式,每种当成一个新的箱子
vector<Box> boxs(b.size()*3);
//箱子的处理,使所有的箱子都是w<=d,每个箱子都翻转两次
for(int i=0; i<b.size(); i++){
//下面是一个箱子的三种翻转情况
boxs[i*3+0].h = b[i].h;
boxs[i*3+0].w = b[i].w < b[i].d ? b[i].w : b[i].d;
boxs[i*3+0].d = b[i].w < b[i].d ? b[i].d : b[i].w;
boxs[i*3+1].h = b[i].h;
boxs[i*3+1].w = b[i].h < b[i].d ? b[i].h : b[i].d;
boxs[i*3+1].d = b[i].h < b[i].d ? b[i].d : b[i].h;
boxs[i*3+2].h = b[i].h;
boxs[i*3+2].w = b[i].w < b[i].h ? b[i].w : b[i].h;
boxs[i*3+2].d = b[i].w < b[i].h ? b[i].h : b[i].w;
}
//排序(不是boxCompare())
sort(boxs.begin(), boxs.end(), boxCompare);
//最长递增子序列问题
vector <int> m(b.size()*3);
m[0] = boxs[0].h;
for(int i=0; i<boxs.size(); i++){
for(int j=0; j<i; j++){
if ( (boxs[i].w <= boxs[j].w) && (boxs[i].d <= boxs[j].d) && (m[i] < m[j]+boxs[i].h) )
m[i] = m[j]+boxs[i].h;
}
}
int mm = *max_element(m.begin(),m.end());
return mm;
}
int main(){
vector<Box> box(3);
box[0].h = 2;
box[0].w = 3;
box[0].d = 4;
box[1].h = 2;
box[1].w = 3;
box[1].d = 1;
box[2].h = 5;
box[2].w = 3;
box[2].d = 4;
cout<<highestBox(box)<<endl;
return 0;
}