基础算法之动态规划

动态规划

在网上看到两个很棒的教程。
第一个和书上的讲解方式不同，却易于理解，通过黄金矿工模型引出，使人眼前一亮，很适合初学者。
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
数位

贪心

最长公共子序列LCS

动态规划方法

1、序列str1和序列str2

·长度分别为m和n；
·创建1个二维数组L[m.n]；
·初始化L数组内容为0
·m和n分别从0开始，m++，n++循环：
- 如果str1[m] == str2[n]，则L[m,n] = L[m - 1, n -1] + 1；
- 如果str1[m] != str2[n]，则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][N] = %d\t",dp[1][N]);
}



 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