基础算法之动态规划

动态规划

在网上看到两个很棒的教程。

第一个和书上的讲解方式不同，却易于理解，通过黄金矿工模型引出，使人眼前一亮，很适合初学者。

http://www.cnblogs.com/sdjl/articles/1274312.html

第二个逐层深入，分初中高级，重点讲解什么是状态，怎样确定状态转移方程。

http://www.360doc.com/content/13/0601/00/8076359_289597587.shtml

切入点：

 由问题分解出两个子问题（最优子结构），子问题独立，两两不相互影响。

 子问题重叠——算法设计（每次调用传递的参数）

 边界处理，动态规划解决问题的关键

抽象出：状态 和 状态转移方程



初识问题：

http://songlee24.github.io/2014/11/27/dynamic-programming/

神奕的博客，分为这几个部分，逐层深入，介绍DP。

1. 最大字段和

2. 最长公共子序列 LCS

3. 最长递增子序列 LIS

4. 最大子矩阵

Hdu 1087 最大字段和

这里附上一个讲解链接，讲解透彻。

http://blog.csdn.net/niteip/article/details/7444973

#include <stdio.h>
#define MAX 1010
int a[MAX];
int sum[MAX];

int main()
{
int N,mark,i,j,Amax,ans;
while(scanf("%d",&N) && N!=0){
ans = 0;
for(i = 0; i<N; i++){
scanf("%d",&a[i]);
sum[i] = a[i];
for(j = 0; j<i; j++){
if(a[j]<a[i] && sum[i]<sum[j]+a[i])
sum[i] = sum[j]+a[i];
}//for j
}

for(i = 0; i<N; i++)
if(ans<sum[i])
ans = sum[i];
printf("%d\n",ans);
}//while
return 0;
}

LIS*1
LCS*1
复杂数塔
两道背包
状态DP
树形DP
数位

贪心

<
4000
/pre>

最长公共子序列LCS

动态规划方法

1、序列str1和序列str2

·长度分别为m和n；

·创建1个二维数组L[m.n]；

·初始化L数组内容为0

·m和n分别从0开始，m++，n++循环：

- 如果str1[m] == str2
，则L[m,n] = L[m - 1, n -1] + 1；

- 如果str1[m] != str2
，则L[m,n] = max{L[m,n - 1]，L[m - 1, n]}

·最后从L[m,n]中的数字一定是最大的，且这个数字就是最长公共子序列的长度

·从数组L中找出一个最长的公共子序列

2、从数组L中查找一个最长的公共子序列

http://blog.csdn.net/hackbuteer1/article/details/6686925

i和j分别从m，n开始，递减循环直到i = 0，j = 0。其中，m和n分别为两个串的长度。

·如果str1[i] == str2[j]，则将str[i]字符插入到子序列内，i–，j–；

·如果str1[i] != str[j]，则比较L[i,j-1]与L[i-1,j]，L[i,j-1]大，则j–，否则i–；（如果相等，则任选一个）


、

回溯打印出LCS(java实现)

 int count = 0;
for(int j = 0; j<y.length; j++)
for(int i = 0; i<x.length; i++){
if(d[i][j]==0 && L[i][j]==(count+1)){
c[count] = x[i];
count++;
break;
}
}
C =String.copyValueOf(c);
System.out.println(C);


HDU 1559 最大子矩阵
树形DP题目分类总结http://blog.csdn.net/liuqiyao_01/article/details/8477730

POJ  2343 树形DP(1)入门 Anniversary Party
https://vjudge.net/problem/POJ-2342

题意：某公司要举办一次晚会，但是为了使得晚会的气氛更加活跃，每个参加晚会的人都不希望在晚会中见到他的直接上司，现在已知每个人的活跃指数和上司关系（当然不可能存在环），求邀请哪些人（多少人）来能使得晚会的总活跃指数最大。

思路：

任何一个点的取舍可以看作一种决策，那么状态就是在某个点取的时候或者不取的时候，以他为根的子树能有的最大活跃总值。分别可以用f[i,1]和f[i,0]表示第i个人来和不来。

当i来的时候，dp[i][1] += dp[j][0];//j为i的下属

当i不来的时候，dp[i][0] +=max(dp[j][1],dp[j][0]);//j为i的下属

dp[i][0]/dp[i][1] 的取值表示i来或者不来，有他们的子树根节点的相应值决定。所以应该在dp函数中用回溯的方法。

#include <stdio.h>
#include <string.h>
#include <math.h>
#define max(a,b) ( ((a)>(b)) ? (a):(b) )
int dp[6005][2],father[6005],vis[6005],N;
void dp_tree(int root){
int i;
vis[root] = 1;
for(i = 1; i<=N ;i++){
if(vis[i]==0 && father[i] == root){
dp_tree(i);
dp[root][0] += max(dp[i][0],dp[i][1]);
dp[root][1] += dp[i][0];
} //if
}//for
}
int main(){
int i,root,l,k;
while(scanf("%d",&N)!=EOF){
memset(dp,0,sizeof(dp));
memset(vis,0,sizeof(vis));
memset(father,0,sizeof(father));
root = 0;
for(i = 1; i<=N; i++){
scanf("%d",&dp[i][1]);
}
while(scanf("%d%d",&l,&k)&& k+l>0){
father[l] = k;
}
dp_tree(root);
printf("%d\n",max(dp[root][0],dp[root][1]));
}
return 0;
}


AC代码。题目很水，网上一个题解，数组每一次都没有初始化，同样的数测试多遍结果都不一样，都可以过。。。想说的一点是tree_dp()的起点root的处理：初始化为零，而且到最后只有根结点的father值没有被改变过，巧妙地得出根节点的位置。

开始时候忘了加！=EOF，然后OLT

HDU 1011 树形DP(2)
对于每个房间，除去它本身所需要的士兵，其他的士兵就可以提供给它的子房间进行选择，子房间将其最优的选择提供给父节点，父节点通过子房间的解得到最优解。

树状DP，与其他不同的也就是添加进了树的元素，每个元素的选择有了限制，就变成了父元素与其子元素的最优解。

定义dp[i][j]默示根结点为i时，用掉j个士兵获得的最大possible。

dp[i][j] = max（dp[i][j]， dp[i][j-k] + dp[son[i]][k]）;

递归的求出dp[son[i]][k]的值。最后成果就是dp[1][m];

多个son的分组背包用一个静态链表存放，有一些难理解，过后参考一下别人的处理方式做一个优化。

#include <stdio.h>
#include <string.h>
#include <math.h>
#define max(a,b) ( ((a)>(b)) ? (a):(b) )
#define MAX_LEN 105

int N,M,j,k,p[MAX_LEN],son[MAX_LEN],bug[MAX_LEN],vis[MAX_LEN],dp[MAX_LEN][MAX_LEN];
struct lists{
int now;
int next;
}List[MAX_LEN];

void dp_tree(int root){
int cost[MAX_LEN],s,i;
vis[root] = 1;

for(i = List[son[root]].now; i>0; i = List[son[root]].next){
cost[i] = (bug[i]+19)/20;
k -= cost[i];
while(!vis[i])
{
printf("i = %d",i);
dp_tree(i);

dp[i][j] = max(dp[i][j],dp[son[i]][k]);
}
printf("1");
}
printf("dp[1]
= %d\t",dp[1]
);
}

int main(){
int i,c,f,spare;
while(scanf("%d%d",&N,&M)!=EOF && f+c>-2){
j = N;
memset(vis,0,sizeof(vis));
memset(son,0,sizeof(son));
//InitList
for(i=0; i<MAX_LEN - 1; i++)
{
List[i].next = i + 1;
List[i].now = 0;
}

List[MAX_LEN-1].next = 0;
List[MAX_LEN-1].now = 0;

for(i = 1; i<=N; i++)
{
scanf("%d%d",&bug[i],&p[i]);
printf("read\n");
}

spare = 0;
printf("M = %d",M);
if(M==1)
if( N>=(bug[1]+19)/20 )
printf("%d\n",p[1]);
else
printf("0\n");
else
{
for(i = 1; i<N; i++)
{
scanf("%d%d",&f,&c);
spare = List[0].next;
List[0].next = List[spare].next;
List[spare].now = c;
List[spare].next = son[f];
son[f] = spare;
}
dp_tree(1);
printf("%d\n",dp[1][M]);
}

}
return 0;
}


//未完待更，代码先存一下

hdu上25道动规 密码zafu

http://acm.hdu.edu.cn/webcontest/contest_show.php?cid=1264

解题报告：

http://wenku.baidu.com/link?url=1MJCBSc3Aw0vbdZI2aOx1wDEXOfdrGSr_I-nsR0DVpbjLZFwOG4LxTP839A66N8SFqKFRfmBuKMUcqSgqq9JyGCc_eY2v6htLcQVZIGOULm