动态规划（dp）

动态规划可以用递归实现，用递归实现会比较简单，就是找递归出口比较难，能找到递归的规律，那用循环就肯定能做了，dp和贪心算法还是有区别的，用递归有可能会重复算一个数，斐波那契就是一个例子，循环会把它记录下来，所以复杂度会比较小。

一：理解dp

就是选最大的数是多少，但是同一时间不能选；

二：简单题理解

就是选出和最大的数是多少，但是相邻的不能选，dp是从后往前分析，找出规律，然后写递归出口，转换成数组，

递归代码：

#include<bits/stdc++.h>
using namespace std;
int rec_opt(int arr[],int len)
{
    if(len==0)
        return arr[0];
    else if(len==1)
        return max(arr[0],arr[1]);
    else
    {
        int a=rec_opt(arr,len-1);//注意传参数的时候和主函数一样，len是控制下标
        int b=rec_opt(arr,len-2)+arr[len];
        return max(a,b);
    }
}
int main()
{
    int arr[7]={1,2,4,1,7,8,3};
    cout<<rec_opt(arr,6)<<endl;//求的是下标为六前的和为最大值的数
    return 0;
}

数组实现：

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int arr[7]={1,2,4,1,7,8,3};
    for(int i=0;i<7;i++)
    {
        if(i==0)
            arr[i]=arr[i];
        if(i==1)
            arr[i]=max(arr[i],arr[i-1]);
        if(i>1)
        arr[i]=max(arr[i-2]+arr[i],arr[i-1]);
    }
    cout<<arr[6]<<endl;
    return 0;
}

三：题目实现：

递归实现：

#include<bits/stdc++.h>
using namespace std;
int rec_opt(int arr[],int len,int s)
{
    if(s==0)
        return true;
    else if(len==0)
        return arr[0]==s;
    else if(arr[len]>s)
        return rec_opt(arr,len-1,s);
    else
    {
        //int a=rec_opt(arr,len-1,s-arr[len])
        //int b=ec_opt(arr,len-1,s)
        return (rec_opt(arr,len-1,s-arr[len])||rec_opt(arr,len-1,s));
    }

}
int main()
{
    int arr[6]={3,34,4,12,5,2};
    cout<<rec_opt(arr,5,9)<<endl;
    cout<<rec_opt(arr,5,10)<<endl;
    cout<<rec_opt(arr,5,11)<<endl;
    cout<<rec_opt(arr,5,13)<<endl;
    return 0;
}

数组实现：

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int arr[6]={3,34,4,12,5,2};
    int dp[6][14];
    memset(dp,0,sizeof(dp));
    for(int i=0;i<6;i++)
    {
        for(int j=0;j<14;j++)
        {
            if(j==0)
                dp[i][j]=1;
            else if(i==0)
            {
                if(arr[i]==j)
                dp[i][j]=1;
                else
                    dp[i][j]=0;
            }
            else if(arr[i]>j)
                dp[i][j]=dp[i-1][j];
            else
            {
                int a=dp[i-1][j];
                int b=dp[i-1][j-arr[i]];
                dp[i][j]=(a||b);
            }
        }
    }
    cout<<dp[5][12]<<endl;
    return 0;
}

dp其实就是选与不选的问题.

四：最长上升子序列

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹.
怎么办呢?多搞几套系统呗!你说说倒蛮容易,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最少需要多少套拦截系统.

 

Input

输入若干组数据.每组数据包括:导弹总个数(正整数),导弹依此飞来的高度(雷达给出的高度数据是不大于30000的正整数,用空格分隔)

 

Output

对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统.

 

Sample Input

8 389 207 155 300 299 170 158 65

Sample Output

2

方法1：

/*
 .O(n*n)算法，dp[i]表示以ai为末尾的最长上升子序列的长度，而以ai结尾的最长上升子序列有两种：1.只包含ai的子序列;  2.在满足j<i且aj<ai的以aj为结尾的上升子序列末尾，追加上ai得到的子序列。
所以有如下递推关系：

dp[i]=max{1,dp[j]+1|j<i且aj<ai} 
*/
#include<bits/stdc++.h>
using namespace std;
int a[10010];
int dp[10010];
int main()
{
     int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            dp[i]=1;
        }
        int ans=0;
        for(int i=2;i<=n;i++)
        {
            for(int j=1;j<i;j++)
            {
                if(a[j]<a[i])
                {
                    dp[i]=max(dp[j]+1,dp[i]);
                }
            }
            ans=max(ans,dp[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

方法2：

/*
.O(nlogn)算法，dp[i]=长度为i+1的上升子序列中末尾元素的最小值（不存在的话就是INF）
这种算法中，运用STL中的lower_bound()函数很方便。
*/
#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
int a[10010];
int dp[10010];//dp[i]表示长度为i+1的子序列末尾元素最小值； 
int main()
{
    int n;
    while(scanf("%d",&n) == 1)
    {
        memset(dp,inf,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        for(int i=1;i<=n;i++)
        {
            *lower_bound(dp,dp+n,a[i])=a[i];
        }
        printf("%d\n",lower_bound(dp,dp+n,inf)-dp);
    }

    return 0;
}