直入主题
由于手残，将帖子一次次的删除所以就不想搞那些花里胡哨的了
引子：
本周我们学习了，动态规划。由于本人太菜就想来写篇帖子，加强巩固一下。
就是太菜了
第一部分概念：
主要分为：
- 状态和状态变量
- 阶段和阶段变量
- 策略和最优策略
- 状态转移方程
戳我
还有不懂请参见信息奥赛一本通
其实DP就是一个类似递推的算法。
看完了概念我们就开始上代码：
第一题：最长上升子序列（时间复杂度O）
题
题目描述：
给定一个序列，从中选取若干个数，使得这一组数组成的序列a满足 i < j 且 a[i] < a[j]，求这个序列的最长长度。
#include <cstdio>
const int MAXN = 5005;
int a[MAXN], dp[MAXN];
int main() {
int n;
scanf ("%d", &n);
int ans = 0, s = 0;
for(int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[i] = 1; //初始化
for(int j = 1; j < i; j++) {
if(a[i] > a[j] && dp[j] + 1 > dp[i]) {
dp[i] = dp[j] + 1;
}
}
if(dp[i] > ans) {
ans = dp[i];
s = i;//转移答案
}
}
printf("%d\n", ans);
return 0;
}
那么就开始解释一下了。首先，我们定义一个DP数组，而dp[i]表示以i结尾的最长上升子序列的长度，这就是所谓的状态。之后可以用两重循环，接着循环扫了一遍之后，来找出当前以i结尾最长上升子序列，判断一下，之后就将已经找到的最长上升子序列的长度赋值。依次循环得到最优解 循环结束——本题结束。
那么你如果想知道（n*logn）的解法。
就自己想想吧，实在不行我也没办法，总之，等下次就会登场了。
那么问题来了：什么时候会用到动态规划呢？
经GM权威讲解：我们知道了当一个问题的状态转移方程具有最优子结构与重叠子问题，则其可用动态规划求解。
这就与贪心形成了鲜明的对比！！
那么我们开始下一道题！
最长上升子序列の输出序列
题目大门
题目描述：
给定一个整数序列A1A2A3….An。求它的一个递增子序列，使子序列的元素个数尽量多，元素不一定要求连续。
(特别注意这里：
输出格式
第1行：1个整数k，表示最长上升子序列的长度。
第2行：k个用单个空格分开的整数，表示找到了最长上升子序列。如果有多个长度等于k的子序列，则输出最靠前的1个。
)
那么上代码！(WA代码)
#include <cstdio>
int prev[1005];
const int MAXN = 100005;
int a[MAXN], dp[MAXN];
using namespace std;
void print(int i){
if(prev[i]==i){
printf("%d",a[i]);
return;
}
print(prev[i]);
printf(" %d",a[i]);
}
int main() {
int n;
scanf ("%d", &n);
int ans = 0, s = 0;
for(int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[i] = 1;
for(int j = 0; j < i; j++) {
if(a[i] > a[j] && dp[j] + 1 > dp[i]) {
dp[i] = dp[j] +1;
prev[i]=j;
}
}
if(dp[i] > ans) {
ans = dp[i];
s = i;
}
}
printf("%d\n", ans);
print(s);
return 0;
}
这里为什么会错呢，错在哪里呢你们可以去编译一下。我来讲讲为什么会错，在这里我们引入了一个叫prve 的函数prev[i]指的就是前驱的意思。他的好处数不胜数，这里你们去查一查。但是为什么会错呢，是因为在循环的时候必须prev[i]每次都要=0，但是当时我没有加，而且一厢情愿的以为prev[i]==i就是初始化，看来我那时还没有搞懂初始化是什么意思呢，所以才会导致每一个测试点我都会加一个0，因为他要返回到0啊！！！！看来我是真的菜啊
赢来了一阵嘲笑之后，迎来了我的AC代码如下：
#include <cstdio>
int prev[1005];
const int MAXN = 100005;
int a[MAXN], dp[MAXN];
using namespace std;
void print(int i){
if(prev[i]==i){
printf("%d",a[i]);
return;
}
print(prev[i]);
printf(" %d",a[i]);
}
int main() {
int n;
scanf ("%d", &n);
int ans = 0, s = 0;
for(int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[i] = 1;
prev[i]=i;
for(int j = 0; j < i; j++) {
if(a[i] > a[j] && dp[j] + 1 > dp[i]) {
dp[i] = dp[j] +1;
prev[i]=j;
}
}
if(dp[i] > ans) {
ans = dp[i];
s = i;
}
}
printf("%d\n", ans);
print(s);
return 0;
}
那么再讲一道非常经典的例题吧
第三题：数字三角形
那么这道题呢有几种不同的做法：
- 搜索
- 记忆化搜索
- DP(顺推)
- DP(逆推)
题目
因为时间关系，我主要来讲一下第四种方案
来看一下吧：
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int a[105][105] = {
0};
int dp[105][105] = {
0};
int main(){
int n;
cin>>n;
for( int i = 1; i <= n; i++ )
for( int j = 1; j <= i; j++ )
cin>>a[i][j];
for( int i = 1; i <= n; i++ )
for( int j = 1; j <= i; j++ )
dp[i][j] = max(dp[i-1][j-1],dp[i-1][j]) + a[i][j];
int ans = 0;
for( int j = 1; j <= n; j++ )
ans = max(ans,dp[n][j]);
cout<<ans<<endl;
return 0;
}
那么来分析一下吧。之所以不能用贪心的原因就是他存在一个缺点就是目光短浅贪心能做，但是对不了，因为我们可以看到贪心是13–11–12–14–13这样走的和为63，但是他存在这么一条路他和为86。这就是为什么不用贪心的原因。那我们就来看一下用DP求解的方法吧：
首先是划分阶段：按三角形的行划分阶段，若有n行，则有n-1个阶段
1. 从根结点13出发，选取他的两个方向中的一条支路，当到了倒数第二层时，每个节点其后继仅有的两个节点，可以直接比较，选择最大值为前进方向，从而求得从根节点开始到底端的最大路径。
2. 自底向上：（给出递推式和终止条件）
-从底层开始,本身即为最大数
-从倒数第二层开始取决于底层数据
······
由此推下去
最最重要的还是状态和状态转移方程了，虽然这个方案体现不怎么出来，但是有必要说一下。
状态：Ans=max{F[N][1],F[N][2],····,F[N][N]}
状态转移方程：F[y][y]=max{F[x-1][y-1],F[x-1][y]}+A[x,y]
边界条件:F[1][1]=A[1][1]
有时对状态转移方程的”-1”，比较模糊，但是却有感觉还是比较透明的。
那么我继续来讲一下数字三角形的其他方法
那么就开始第二种解法——搜索 只是单纯的搜索
#include<iostream>
#include<cstdio>
using namespace std;
const int MAXN=1005;
int a[MAXN][MAXN],f[MAXN][MAXN],n,ans;
void dfs(int x,int y,int Curr){
if(x==n){
if(Curr>ans)ans=Curr;
return;
}
dfs(x+1,y,Curr+a[x+1][y+1]);
dfs(x+1,y+1,Curr+a[x+1][y+1]);
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++)
scanf("%d",&a[i][j]);
ans=0;
dfs(1,1,a[1][1]);
printf("%d",ans);
return 0;
}
这道题如果是用这个方法的话，这能得到一个Time Limit Exceeded 和一个惨淡的30分。
我们不用编译都知道，这个代码一定会超时，那为什么会超时呢？因为他是把所有的数组全部都走了一遍，由于每一条路径都是n-1组成，每一步有左和右两种选择，因此总数为*2n-1*，所以时间复杂度就是O(2n-1)，毫无疑问超时。
那么第三种解法记忆化搜索
方法二之所以会超时，是因为搜索了全部情况，所以就要用到记忆化搜索。
注意！今天问了GM，其实动态规划其实可以理解为记忆化搜索，这样就要好理解一些了。
好吧，上代码：
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN=505;
int a[MAXN][MAXN],f[MAXN][MAXN],n;
int dfs(int x,int y){
if (f[x][y]==-1){
if(x==n)f[x][y]=a[x][y];
else f[x][y]=a[x][y]+max(dfs(x+1,y),dfs(x+1,y+1));
}
return f[x][y];
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++){
scanf("%d",a[i][j]);
}
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++)
f[i][j]=-1;
dfs(1,1);
printf("%d",f[1][1]);
return 0;
}