动态规划

动态规划

动态规划分化为具有重复问题的子问题
分冶将问题划分为互不相交的子问题

最长上升子序列

第一种

#include <stdio.h>
#include <string.h>
int main(){
int n,i,j;
int num[1001];
int dp[1001];
int maxlen;
while(scanf("%d",&n)!=EOF){
   for(i=0;i<n;i++)
        scanf("%d",&num[i]);
    maxlen=1;
    memset(dp,0,sizeof(dp));
    for(i=0;i<n;i++){
            dp[i]=1;//
        for(j=0;j<i;j++)
        if(num[i]>num[j]&&dp[j]+1>dp[i]){
            dp[i]=dp[j]+1;
            maxlen=maxlen>dp[i]?maxlen:dp[i];
        }
    }
   printf("%d\n",maxlen);
}
}

时间复杂度为n*n

第二个循环找出i长度的最长上升子序列
每次循环，num[i]为新加入数据,比较更新。

第二种方法

#include <stdio.h>
#include <string.h>
int ans[100001];
int num[100001];
int getpos(int i,int l,int r){
    int mid;
    while(l<r){
        mid=(l+r)/2;
        if(num[i]>ans[mid]) l=mid+1;
        else r=mid;
    }
    return l;
}
int main(){
int n,i;
int l;
while(scanf("%d",&n)!=EOF){
   for(i=0;i<n;i++)
        scanf("%d",&num[i]);
        l=0;
   ans[l]=num[0];
   for(i=1;i<n;i++){
   if(ans[0]>=num[i]) ans[0]=num[i];
   if(ans[l]<num[i]) ans[++l]=num[i];
   else ans[getpos(i,0,l)]=num[i];
   }
   printf("%d\n",l+1);
}
return 0;
}

时间复杂度为nlogn
eg:
num: 2 1 5 3 4 2
dp:2
dp:1
dp:1 5
dp:1 3
dp:1 3 4
dp:1 2 4
（此处最长子序列为1 3 4）
这样操作使得
若最后一个2后面若还有一个3，最长上升子序列变为1 2 3 4

最大连续子序列

题目描述
给定 K 个整数的序列{ N1, N2, …, NK } ，其任意连续子序列可表示为{ Ni, Ni+1,…,Nj} ，其中1 <= i<= j <= K。最大连续子序列是所有连续子序列中元素和最大的一个，例如给定序列{ -2, 11, -4, 13, -5, -2 } ，其最大连续子序列为{ 11, -4, 13 } ，最大和为20。编写程序得到其中最大子序列的和并输出该子序列的第一个和最后一个元素的下标。
输入
测试输入包含若干测试用例，每个测试用例占2 行，第 1 行给出正整数 K( <100000) ，第 2 行给出 K 个整数，每个整数的范围-10000至10000 ，中间用空格分隔。
输出
对每个测试用例， 在 1 行里输出最大和、 最大连续子序列的第一个和最后一个元素的下标，中间用空格分隔。 如果最大连续子序列不唯一， 则输出序号 i 和 j 最小的那个（如输入样例的第 2、3组）。若所有 K 个元素都是负数，则定义其最大和为0，输出"0 0 0"。
样例输入

8
6 -2 11 -4 13 -5 -2 10
20
-10 1 2 3 4 -5 -23 3 7 -21 6 5 -8 3 2 5 0 1 10 3
8
-1 -5 -2 3 -1 0 -2 0
4
-1 -2 -4 -3

样例输出

27 0 7
27 10 19
3 3 3
0 0 0

#include <stdio.h>

int main(){
int n;
int i,flag=0;
int num[100000];
int dp[100000];
while(scanf("%d",&n)!=EOF){
flag=0;
for(i=0;i<n;i++){
scanf("%d",&num[i]);
if(num[i]>=0) flag=1;}
if(flag==0) {printf("0 0 0\n");continue;}
int Max,Max_i;
Max=dp[0]=num[0];
for(i=1;i<n;i++){
if(num[i]+dp[i-1]>num[i]) dp[i]=num[i]+dp[i-1];
else if(num[i]+dp[i-1]==num[i]) dp[i]=num[i];
else dp[i]=num[i];
if(dp[i]>Max){Max=dp[i];Max_i=i;}
}
int j=Max_i;
while(Max!=0){
Max-=num[j--];
}
printf("%d %d %d\n",dp[Max_i],j+1,Max_i);
}

}

数塔

自底向上

数字塔是第i行有i个数字组成，从上往下每个数字只能走到他正下方数字或者正右方数字，求数字塔从上到下所有路径中和最大的路径:

数塔：
9
12 15
10 6 8
2 18 9 5
19 7 10 4 16

解题，自下而上：
59
50 49
38 34 29
21 28 19 21
19 7 10 4 16

代码
省略

回文最小分割数

#include <stdio.h>
#include <string.h>
int arr[1005][1005],dp[1005];
char str[1005];
bool isTrue(int l,int r){
while(l<r){
    if(str[l-1]!=str[r-1]) return false;
    l++;r--;
}
return true;
}
int main(){
    int i,j,n;
while(scanf("%s",str)!=EOF){
        n=strlen(str);
    for(i=1;i<=n;i++){
        dp[i]=isTrue(1,i)?1:i;
    for(j=i;j>1;j--)
        if(isTrue(j,i))
        dp[i]=dp[i]<dp[j-1]+1?dp[i]:dp[j-1]+1;
}
 printf("%d\n",dp[n]);
}
return 0;
}