算法難，難於上青天!!!!! 搞懂一個算法不容易，還是寫篇博客爲以後複習做好準備!!!!
動態規劃算法O(n^2)
- 設A[i]表示序列中第i個數，dp[i]表示從0到i這一段中以i結尾的最長上升子序列的長度,初始化dp[i]=1;(i=0,1,2…(len(A)-1).則有動態方程爲:
dp[i]=max{dp[i],dp[j]+1}(j=0,1,2,….i-1,且A[j] < A[i]);
爲什麼我是max{dp[i],dp[j]+1}呢,因 爲,我初始化中dp[i]=1,當我們去求dp[i],在A[1—i-1]中尋找比A[i]小的元素(下標幾記爲j),由於dp[j]已經求過,所以我們比較dp[j]+1和dp[i]的大小,將大的更新到dp[i]中. - 我們來想一種特殊的情況,假設有兩個元素A[x]和A[y],滿足
(1)x
#include<iostream>
#define N 1000
using namespace std;
int getLongCommonSub(int (&A)[6],int (&dp)[6],int n)
{
int length=0;
int i;
dp[0]=1;
for(i=1;i<n;i++){
dp[i]=1;
for(int j=0;j<i;j++){
if(A[i]>A[j] && dp[i]<dp[j]+1){ //求的是在1-(i-1)中滿足當前要求的元素比A[j]元素大的A[i]元素所對應dp[i]的最大值.
dp[i]=dp[j]+1;
}
}
}
return dp[i-1];
}
int main(int argc,char *argv[])
{
int A[6]={1,3,4,5,2,8};
int dp[6];
int ret=getLongCommonSub(A,dp,6);
cout << ret<<endl;
}用上面的序列走一遍這個程序[1,3,4,5,2,8];
- 1 3 4 5 2 8
- i從1開始到n,所以先把dp[0]=1;從1-(n-1)循環之前先會給dp[i]賦值爲1.
- j從0開始到(i-1),意思就是求1-i最長遞增子序列時,用A[i]和A[0-(i-1)]比較.
- i=1 j=0:A[1]=3;A[0]=1;A[i]>A[j]而且dp[i]=dp[1]=1;dp[j]+1=dp[0]+1=2;所以更新dp[1]=dp[j]+1=dp[1]+1=2;內循環j++不滿足j
動態規劃算法O(n^2)
- 設A[i]表示序列中第i個數，dp[i]表示從0到i這一段中以i結尾的最長上升子序列的長度,初始化dp[i]=1;(i=0,1,2…(len(A)-1).則有動態方程爲:
dp[i]=max{dp[i],dp[j]+1}(j=0,1,2,….i-1,且A[j] < A[i]);
爲什麼我是max{dp[i],dp[j]+1}呢,因 爲,我初始化中dp[i]=1,當我們去求dp[i],在A[1—i-1]中尋找比A[i]小的元素(下標幾記爲j),由於dp[j]已經求過,所以我們比較dp[j]+1和dp[i]的大小,將大的更新到dp[i]中. - 我們來想一種特殊的情況,假設有兩個元素A[x]和A[y],滿足
(1)x
#include<iostream>
#define N 1000
using namespace std;
int getLongCommonSub(int (&A)[6],int (&dp)[6],int n)
{
int length=0;
int i;
dp[0]=1;
for(i=1;i<n;i++){
dp[i]=1;
for(int j=0;j<i;j++){
if(A[i]>A[j] && dp[i]<dp[j]+1){ //求的是在1-(i-1)中滿足當前要求的元素比A[j]元素大的A[i]元素所對應dp[i]的最大值.
dp[i]=dp[j]+1;
}
}
}
return dp[i-1];
}
int main(int argc,char *argv[])
{
int A[6]={1,3,4,5,2,8};
int dp[6];
int ret=getLongCommonSub(A,dp,6);
cout << ret<<endl;
}用上面的序列走一遍這個程序[1,3,4,5,2,8];
- 1 3 4 5 2 8
- i從1開始到n,所以先把dp[0]=1;從1-(n-1)循環之前先會給dp[i]賦值爲1.
- j從0開始到(i-1),意思就是求1-i最長遞增子序列時,用A[i]和A[0-(i-1)]比較.
- i=1 j=0:A[1]=3;A[0]=1;A[i]>A[j]而且dp[i]=dp[1]=1;dp[j]+1=dp[0]+1=2;所以更新dp[1]=dp[j]+1=dp[1]+1=2;內循環j++,不滿足j< i,退出內循環.
- i=2 j=0: A[j]=4>A[j]=1&&dp[2]=1 < dp[0]+1=2;所以dp[2]更新爲2; j=1:A[i]=4>A[j]=1但是dp[2]=2 < dp[1]+1=3;所以dp[3]更新爲3;
- i=3 j=0:A[i]=5>A[j]=1&&dp[3]=1 < dp[0]+1=2,所以dp[3]更新爲2;
j=1:A[i]=5>A[j]=3&&dp[3]=2 < dp[1]+1=3;所以dp[3]更新爲3
j=2:A[i]=5 > A[j]=4&&dp[3]=3 < dp[2]+1=4 ,所以更新爲4;
j=3:不滿足j < i;退出內循環. - i=4 ; j=0:A[i]=2 >A[j]=1 && dp[4]=1 < dp[0]+1=2，所以更新dp[4]爲2;
j=1:A[i]=2 < A[j]=3; j++;
j=2:A[i]=2 < A[j]=4; j++;
j=3:A[i]=2 < A[j]=5;j++,j=4:不滿足j<4;退出內循環. - i=5;j=0:A[i]=8>A[j]=1 && dp[5]=1 < dp[0]+1=2，所以更新dp[5]爲2;
j=1;A[i]=8 > A[j]=3 && dp[5]=2 < dp[1]+1=3;所以更新dp[5]爲3;
j=2;A[i]=8 > A[j]=4 && dp[5]=3 < dp[2]+1=4;所以更新dp[5]爲4;
j=3;A[i]=8 > A[j]=5 && dp[5]=4 < dp[3]+1=5;所以更新dp[5]爲5;
j=4:A[i]=8 >A[j]=2 但是dp[5]=5 > dp[4]+1=3,所以直接j++,j=5,不滿足j
二分查找算法求最長遞增子序列
- 設當前已經求出的最長遞增子序列長度爲len，先判斷A[i]和dp[len] 若A[i]>dp[len],則直接將A[i]接在dp[len]後得到一個更長的遞增子序列,len++;dp[len]=A[i];
- 否則dp[1]到dp[len]中到最大的j,滿足dp[j] A[i],令k=j+1,則有dp[j] < A[i]<=dp[k].將A[i]接在D[j]後將得到一個更長的上升子序列，同時更新D[k] = A[i]。
- 最後，len即爲所要求的最長上升子序列的長度。
在上述算法中，若使用樸素的順序查找在D[1]..D[len]查找，由於共有O(n)個元素需要計算，
每次計算時的複雜度是O(n)，則整個算法的時間複雜度爲O(n^2)，與原來的算法相比沒有任何進步。
但是由於dp[]是上升的，我們在dp[]中查找時，可以使用二分查找高效地完成，則整個算法的時間複雜度
下降爲O(nlogn)，有了非常顯著的提高。需要注意的是，dp[]在算法結束後記錄的並不是一個符合題意的最長上升子序列.
代碼如下:
int BinarySearchgetLongCommonSub(int(&A)[10],int n)
{
int right,left,len=1,mid,i;
int dp[n+1];
dp[1]=A[1];
for(i=2;i<=n;i++){
if(A[i] > dp[len]){
dp[++len]=A[i];
}else{
left=1,right=len;
while(left <= right){ //二分查找找到第最小的比A[i]大的數.
mid=(left+right)/2;
if(dp[mid]<A[i]){
left=mid+1;
}else{
right=mid-1;
}
}
dp[left]=A[i];
}
}
return len;
}
int main(int argc,char *argv[])
{
int A1[10]={0,1,3,4,5,2,8,9,8,9}; //0號元素不用.
//int dp1[10];
int ret1=BinarySearchgetLongCommonSub(A1,9);
cout << ret1<<endl;
return 0;
}
