GroupBlog

算法难，难于上青天!!!!! 搞懂一个算法不容易，还是写篇博客为以后复习做好准备!!!!

动态规划算法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;
}