状态压缩dp入门[HDU1074][HDU1065][POJ3254][POJ1185][HDU4359][POJ3311][POJ2411]

最新推荐文章于 2021-02-19 17:40:19 发布
最新推荐文章于 2021-02-19 17:40:19 发布
阅读量506 收藏 1
点赞数
分类专栏： ACM_DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24833289/article/details/47663639
版权

我理解的状态压缩dp问题是这样的：

给出你n个物品，你要在这n个物品中选出一些物品（或一个都不选），那么对于每个物品你都有两种选择（选或者不选），这样，一共有2^n种情况。而n<=20通常（2^n<=10^6+x），然后我们就枚举 1 - 2^n，每个数分别对应一个二进制数，这个二进制数又可表示我们取物品的一种状态。

如：总共有5个物品，则最多有32种取物品的情况，13 对应5位的二进制数01101，就表示取物品2，3，5。对于每个5位的二进制数我们都用5次位运算判断它的各个位是1还是0。本来每个状态要用5个空间存，现在可以用一个数字来表示。

简而言之就是，通过枚举数字来枚举选择的情况。

涉及到的一些位运算

i & (1 << j)  表示 i 这种状态时，取了第 j 个物品

i | (1 << j)  得到在 i 这种状态下，再取第 j 个物品后的状态

i & ~(1 << j)  得到在 i 这种状态下，去掉第 j 个物品的状态

( i & (i << 1))  || ( i & (i >> 1)) 表示 i 状态下，取了两个相邻的元素

i & j 表示相邻的两行分别取 i 状态和 j 状态时，在某一列取了两个元素

j != (i & j)  j 状态中包含 i 状态时不取的元素


下面是一些状态压缩dp入门题


题目：HDU1074 http://acm.hdu.edu.cn/showproblem.php?pid=1074

题意：小明做功课，给出每项功课的名字，最后期限和完成所花时间，小明开始做一个功课之后他就会把它做完，如果完成功课的时间比最后期限晚就会扣分，扣的分数=完成该功课的时间 - 该功课的最后期限。求小明扣分最少时完成功课的顺序，多种方案时输出字典序小的。

思路：小明已经完成的功课的集合是我们要压缩的状态，已完成功课的集合为done，dp[done]记录完成它们最少扣的分数，然后在done中加入一个未完成的功课 i ，比较更新dp[done + i]

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
int d[20], c[20], dp[1 << 15], add[1 << 15];
char sub[20][105];

void showpath(int x)
{
    if(x == 0) return;
    showpath(x & ~(1 << add[x]));
    printf("%s\n", sub[add[x]]);
}

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int t, n;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(int i = 0; i < n; i++)
        {
            scanf(" %s %d%d", sub[i], &d[i], &c[i]);
        }
        for(int i = 0; i <= (1 << n); i++)
        {
            dp[i] = INF;
        }
        dp[0] = 0;
        for(int done = 0; done <= (1 << n) - 1; done++)
        { //枚举已经完成的作业的集合
            int time = 0; //当前完成功课总用时
            for(int i = 0; i < n; i++)
            {
                if(done & (1 << i)) time += c[i]; 
            }
            //printf("done=%d time=%d\n", done, time);
            for(int i = 0; i < n; i++)
            {
                if(!(done & (1 << i)) && dp[done] != INF)
                {
                    int cur = 0;
                    if(time + c[i] > d[i]) cur = time + c[i] - d[i]; //算出当前状态下完成第 i 个作业要扣的分数
                    //printf("i=%d cur=%d\n", i, cur);
                    if(dp[done] + cur < dp[done | (1 << i)]) //比较更新
                    {
                        dp[done | (1 << i)] = dp[done] + cur;
                        add[done | (1 << i)] = i; //记录完成作业集合为done + i时，最后完成的作业是i
                        //printf("%d-%d\n", done | (1 << i), dp[done | (1 << i)]);
                    }
                }
            }
        }
        printf("%d\n", dp[(1 << n) - 1]);
        showpath((1 << n) - 1);
    }

    return 0;
}

题目：HDU 1065  http://acm.hdu.edu.cn/showproblem.php?pid=1565

题意：在一个n*n的棋盘里，每格有一个非负数，取出若干个数，满足每两个个数所在格子没有公共边，求所取的数和的最大值。

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
int check[1 << 20], grid[25][25], pre[1 << 20], cur[1 << 20], can[1 << 20];
int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif


    //printf("cnt=%d\n", cnt);
    int n;
    while(scanf("%d", &n) != EOF)
    {
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
            {
                scanf("%d", &grid[i][j]);
            }
        }
        memset(check, 0, sizeof(check));
        int cnt = 0;
        for(int i = 0; i <= (1 << n) - 1; i++)
        { //先得到只考虑一行时，符合条件的状态，装入can[]，减少枚举状态数
            int flag = 1;
            for(int j = 1; j < n; j++)
            {
                if((i & (1 << (j - 1))) && ( i & (1 << j)))
                { //同一行中第j格与第j- 1格都取了，不符合
                    flag = 0; break;
                }
            }
            if(flag)
            {
                //printf("add i=%d\n", i);
                check[i] = 1;
                can[cnt++] = i;
            }
        }
        memset(pre, 0, sizeof(pre));
        memset(cur, 0, sizeof(cur));
        for(int lay = 0; lay < n; lay++)
        {
            for(int i = 0; i < cnt; i++)
            { //枚举第lay行的状态，计算这样取这行取了多少格
                //if(lay && pre[i] == 0) continue;
                int add = 0;
                for(int k = 0; k < n; k++)
                {
                    if(can[i] & (1 << k))
                    {
                        add += grid[lay][k];
                    }
                }
                for(int j = 0; j < cnt; j++)
                { //枚举lay-1行的状态
                    if(!(can[i] & can[j])) //没有取上下相邻的格
                    {
                        cur[can[i]] = max(cur[can[i]], pre[can[j]] + add);
                    }
                }

            }
            for(int i = 0; i < cnt; i++)
            {
                pre[can[i]] = cur[can[i]];
                cur[can[i]] = 0;
            }
        }
        int ans = 0;
        for(int i = 0; i < cnt; i++)
        {
            if(ans < pre[can[i]]) ans = pre[can[i]];
        }
        printf("%d\n", ans);
    }


    return 0;
}


题目：POJ 3254 http://poj.org/problem?id=3254

题意：m * n地，在上面种草，标记为1的格子才能种，任意两个种草的格子没有公共边，问有多少种种草的方案（可以一棵草也不种）。

思路：dp[ f ][ i ] 表示只考虑了前 f 行，在第 f 行种草状态为 i 的方案数

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000000
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
int a[15], dp[15][1 << 13];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, m, aa;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        memset(a, 0, sizeof(a));
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                scanf("%d", &aa);
                if(aa) a[i] |= (1 << j);
            }
        }
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < (1 << m); i++)
        {
            if(i != (i & a[0])) continue;
            if((i & (i << 1)) || (i & (i >> 1))) continue;
            dp[0][i] = 1;
        }
        for(int f = 1; f < n; f++)
        {
            for(int i = 0; i < (1 << m); i++)
            {
                if(i != (i & a[f])) continue; //i状态在不该种草的地方种草了
                if((i & (i << 1)) || (i & (i >> 1))) continue; //左右相邻的格子种草了
                for(int j = 0; j < (1 << m); j++)
                {
                    if(j != (j & a[f - 1])) continue;
                    if(i & j) continue; //上下相邻的格子种草了
                    dp[f][i] += dp[f - 1][j];
                    dp[f][i] %= MOD;
                }
            }
        }
        int ans = 0;
        for(int i = 0; i < (1 << m); i++)
        {
            ans += dp[n - 1][i];
            ans %= MOD;
        }
        printf("%d\n", ans);
    }


    return 0;
}



题目：POJ 1185  http://poj.org/problem?id=1185

题意：n*m的地方，标记为P的地方可以安排炮兵，炮兵攻击的范围为“十字”，向上下左右各攻击两格（看图），安排炮兵是每两个炮兵不能彼此攻击到，问最多能安排多少个炮兵。

思路：一开始我没用三维数组，枚举f，f-1，f-2行的状态，转移的时候实际上只考虑了 f 和 f - 1 不冲突，f 和 f - 2 不冲突， f - 1 和 f - 2 不冲突，但不能保证 f - 1 和 f - 2 - 1 不冲突，所以是错的。枚举没一行的状态时都要考虑上一行的状态和上上一行的状态，上一行的状态又是和上上一行的上一行有关的，所以dp数组需要增加一个维度，dp[ f ][ i ][ j ] 表示第 f 行取 i 状态同时 f - 1 行取 j 状态时能得到的最大值。

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
int dp[105][100][100], add[100], can[100], a[105], cnt;

void init(int m)
{ //先找出只有一行时可以取的状态，减少枚举量，同时算出各种取法取了多少个位置
    memset(can, 0, sizeof(can));
    memset(add, 0, sizeof(add));
    cnt = 0;
    for(int i = 0; i < (1 << m); i++)
    {
        if((i & (i << 1)) || (i & (i << 2)) ||
           (i & (i >> 1)) || (i & (i >> 2))) continue;
        can[cnt] = i;
        for(int j = 0; j < m; j++)
            if(i & (1 << j)) add[cnt]++;
        cnt++;
    }
    memset(dp, 0, sizeof(dp));
}


int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, m;
    char aa;

    while(scanf("%d%d", &n, &m) != EOF)
    {
        memset(a, 0, sizeof(a));
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                scanf(" %c", &aa);
                if(aa == 'P') a[i] |= (1 << j);
            }
        }
        init(m);
        //printf("cnt=%d\n", cnt);
        int ans = 0;
        for(int i = 0; i < cnt; i++)
        {
            if(can[i] != (can[i] & a[0])) continue;
            dp[0][i][0] = add[i];
            ans = max(add[i], ans);
        }
        for(int f = 1; f < n; f++)
        { //枚举层
            for(int i = 0; i < cnt; i++)
            { //枚举当前层的状态
                if(can[i] != (can[i] & a[f])) continue; //当前状态取了不该取的位置
                for(int j = 0; j < cnt; j++)
                {
                    if(can[j] != (can[j] & a[f - 1])) continue;
                    if(can[j] & can[i]) continue; //当前层与上一次层冲突
                    if(f == 1)
                    {
                        dp[1][i][j] = max(dp[1][i][j], dp[0][j][0] + add[i]);
                        ans = max(dp[1][i][j], ans);
                        continue;
                    }
                    for(int k = 0; k < cnt; k++)
                    {
                        if(can[k] != (can[k] & a[f - 2])) continue;
                        if(can[k] & can[j]) continue;
                        if(can[k] & can[i]) continue;
                        dp[f][i][j] = max(dp[f][i][j], dp[f - 1][j][k] + add[i]);
                        //printf("dp[%d][%d][%d]=%d\n", f, i, j, dp[f][i][j]);
                        ans = max(dp[f][i][j], ans);
                    }
                }
            }
        }
        printf("%d\n", ans);
    }

    return 0;
}

题目：HDU 4539   http://acm.hdu.edu.cn/showproblem.php?pid=4539

题意：和上一题差不多，也要三维数组，攻击范围不同

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
int dp[105][200][200], can[200], add[200], cnt, a[105];

void init(int m)
{
    memset(can, 0, sizeof(can));
    memset(add, 0, sizeof(add));
    cnt = 0;
    for(int i = 0; i < (1 << m); i++)
    {
        if((i & (i << 2)) || (i & (i >> 2))) continue;
        can[cnt] = i;
        for(int j = 0; j < m; j++)
        {
            if(i & (1 << j)) add[cnt]++;
        }
        cnt++;
    }
    memset(dp, 0, sizeof(dp));
}


int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, m, aa;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        memset(a, 0, sizeof(a));
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                scanf("%d", &aa);
                if(aa) a[i] |= (1 << j);
            }
        }
        init(m);
        int ans = 0;
        for(int i = 0; i < cnt; i++)
        {
            if(can[i] != (can[i] & a[0])) continue;
            dp[0][i][0] = add[i];
            ans = max(add[i], ans);
        }
        for(int f = 1; f < n; f++)
        {
            for(int i = 0; i < cnt; i++)
            {
                if(can[i] != (can[i] & a[f])) continue;
                for(int j = 0; j < cnt; j++)
                {
                    if(can[j] != (can[j] & a[f - 1])) continue;
                    if(can[i] & (can[j] >> 1)) continue;
                    if(can[i] & (can[j] << 1)) continue;
                    if(f == 1)
                    {
                        dp[1][i][j] = max(dp[1][i][j], dp[0][j][0] + add[i]);
                        ans = max(dp[1][i][j], ans);
                        continue;
                    }
                    for(int k = 0; k < cnt; k++)
                    {
                        if(can[k] != (can[k] & a[f - 2])) continue;
                        if(can[k] & (can[j] >> 1)) continue;
                        if(can[k] & (can[j] << 1)) continue;
                        if(can[k] & can[i]) continue;
                        dp[f][i][j] = max(dp[f][i][j], dp[f - 1][j][k] + add[i]);
                        ans = max(dp[f][i][j], ans);
                    }
                }
            }
        }
        printf("%d\n", ans);
    }

    return 0;
}



题目：POJ 3311  http://poj.org/problem?id=3311
题意：给出0-n个点间两两到达的距离，求从0出发，1-n中每个点至少经过一次，然后回到0点的所需走的最短路径

思路：读完题目容易想到旅行商问题（TSP），同样将已经到达过的点的集合作为状态，但要注意的是，点是可以重复到达的。dp[s][v]记录的是走过点集合s最后停在v的最短路径长度。最主要是要想好循环的次序。我的程序第一层循环是枚举集合s，第二层循环枚举走过集合s后再走到的最后一个点u（可以在集合s中也可以不在集合s中），第三层循环枚举在集合s中，连接最后一个u的点v。建议结合样例，把dp数组更新的过程打出来感受一下。

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
int d[15][15], dp[1 << 12][15];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n;
    while(scanf("%d", &n) != EOF)
    {
        if(!n) break;
        memset(d, 0, sizeof(d));
        for(int i = 0; i <= n; i++)
        {
            for(int j = 0; j <= n; j++)
            {
                scanf("%d", &d[i][j]);
            }
        }
        n++;
        for(int s = 0; s < (1 << n); s++)
        {
            for(int v = 0; v < n; v++)
            {
                dp[s][v] = INF;
            }
        }
        dp[0][0] = 0;
        for(int s = 0; s < (1 << n); s++)
        { //枚举已经走过的点的集合
            //printf("s=%d\n", s);
            for(int u = 0; u < n; u++)
            { //从集合s中的某点v走到u
                for(int v = 0; v < n; v++)
                {
                    if(dp[s][v] != INF)
                    {
                        {
                            dp[s | (1 << u)][u] = min(dp[s | (1 << u)][u], dp[s][v] + d[v][u]);
                            //printf("dp %d %d %d\n", s | (1 << u), u, dp[s | (1 << u)][u]);
                        }
                    }
                }
            }
        }
        int ans = INF;
        for(int i = 0; i < n; i++)
        {
            ans = min(ans, dp[(1 << n) - 1][i] + d[i][0]);
        }
        printf("%d\n", ans);
    }

    return 0;
}

题目：POJ 2411  http://poj.org/problem?id=2411

题意：给出一个h*w的长方形，你用许多个1*2的小长方形铺满它，小长方形不能重叠，问有多少钟铺法。

思路：这题枚举两行的状态后判断可不可行的方法我没想到，是看了网上题解才明白的。我们一行行地枚举铺砖的状态，每铺新的一行，上一行都要铺满。

首先，第一行如果有空缺，那么它在还没铺满前必定是由小长方形横向铺成的，容易想到要先找出这些状态。

然后，枚举铺新一行的状态，再枚举上一行铺成的状态，如果上一行的状态有空缺，那么空缺的位置肯定是由一个竖着放的小长方形铺的，则新一行的这个位置一定不能为空，所以两行中每一列至少有一格被铺了。

我们可以通过上一行的状态确定新行状态的什么位置铺了竖着的小长方形（即上一行状态的空缺位置），则当前状态剩下的被覆盖位置一定是被横着的小长方形铺的，这又用回了第一行找出来的状态。

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
ll dp[15][1 << 12];
int check[1 << 12];

void init(int m)
{ //只由小长方形横着铺成的一行的状态
    memset(check, 0, sizeof(check));
    memset(dp, 0, sizeof(dp));
    for(int i = 0; i < (1 << m); i++)
    {
        int x = i, cur = 0;
        while(x)
        {
            if(cur)
            {
                if(x & 1) cur = 0;
                else break;
            }
            else if(x & 1) cur = 1;
            x >>= 1;
        }
        if(!cur)
        {
            check[i] = 1; dp[0][i] = 1;
        }
    }
}

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, m;
    while(scanf("%d%d", &n, &m) != EOF && (n + m))
    {
        init(m);
        for(int f = 1; f < n; f++)
        {
            for(int i = 0; i < (1 << m); i++)
            {
                for(int j = 0; j < (1 << m); j++)
                {
                    if((i | j) != (1 << m) - 1) continue; //有一列一格也没，则铺完f行，f-1行的空缺还会在，后面也不可能铺满
                    if(!check[i & j]) continue; // i & j 排除了被竖着小长方形铺的格子
                    dp[f][i] += dp[f - 1][j];
                }
            }
        }
        printf("%I64d\n", dp[n - 1][(1 << m) - 1]);
    }

    return 0;
}


cookiesMonster
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Poj - 3254 Corn Fields （状态压缩dp入门第一题（详解
今天天气不错
04-08 9746
题目大意：农夫有一块地，被划分为m行n列大小相等的格子，其中一些格子是可以放牧的（用1标记），农夫可以在这些格子里放牛，其他格子则不能放牛（用0标记），并且要求不可以使相邻格子都有牛。现在输入数据给出这块地的大小及可否放牧的情况，求该农夫有多少种放牧方案可以选择（注意：任何格子都不放也是一种选择，不要忘记考虑！
hdu oj poj 题目代码与详解
09-08
【题目代码与详解】是针对在线编程竞赛平台HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿大学在线判题系统）中的经典题目所编写的解决方案和解析的集合。这些平台是程序员和计算机科学学生提升算法技能、熟悉...
HDU1018 POJ1423 UVALive2697 UVA1185 ZOJ1526 Big Number【阶乘位数】
海岛Blog
11-15 766
Big Number Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 28524   Accepted: 9075 Description In many applications very large integers numbers are required.
HDU 1520 & POJ 2342 Anniversary party(树形DP入门题)
09-03 819
HDU 1520 & POJ 2342 Anniversary party(树形DP入门题)
状态压缩(棋盘问题+hdu3254+poj1185+hud2553)
ly59782的博客
08-02 2617
在n*n(n≤20)的方格棋盘上放置 n 个车(可以攻击所在行、列)，求使它们不能互相攻击的方案总数。 状态压缩递推： 在n*n(n≤20)的方格棋盘上放置 n 个车，某些格子不能放，求使它们不能互相攻击的方案总数。 给出一个 n*m 的棋盘(n 、m≤ 80,n*m ≤ 80)，要在棋盘上放 k(k ≤ 20)个棋子， 使得任意两个棋子不相邻。问有多少种方案。 hdu - 3254 corn fields poj1185炮兵阵地 hdu 2553 n皇后问题 nyoj-492 king poj2411-
HDU2716 POJ2141 Message Decowding【密码】
海岛Blog
02-19 196
Message Decowding Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1934 Accepted Submission(s): 834 Problem Description The cows are thrilled because they’ve just learned about encrypting messages.
DP.rar_DP_hdu_动态规划_动态规划 C++
最新发布
09-20
描述中提到的“动态规划DP题解”和“POJ HDU部分动态规划DP题解”，说明这个压缩包包含了针对HDU和POJ（Problemset Online Judge）平台上一些动态规划题目的解答。POJ是一个著名的在线编程竞赛平台，其中包含了大量...
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
leetcode下载-algorithm-1:力扣、HDU、ZOJ、POJ
06-29
Interview，ZOJ，POJ 等平台。 欢迎Coders对代码加以指正和提议！ 常见问题总结 两整数求平均值 average = min + (max - min) / 2 防止两整数的和越界 整数乘积对比 1.0 * m * m == num 类似乘积对比， 需转为double...
【包教包会】用树的定义去判断树！(HDU1272)(HDU1325)(POJ1308)
01-20
在计算机科学中，树是一种非常基础且重要的数据...通过编程实现这些条件的检查，可以解决如HDU1272、HDU1325和POJ1308这类题目。掌握这些基本概念和技巧，不仅有助于解决这类问题，也是深入学习图论和数据结构的基础。
POJ 2063 Investment （完全背包）
cookiesMonster
02-05 631
题意：我有很多钱，要用来买债券，已知每种债券的价格和每一期可获得的利润（注意债券的价格只能为1000的倍数），而且我可以每一期把原来的债券卖掉，然后用原来的钱加上利润选择新的购买方案。已知我要一开始有多少钱和我将购买多少期债券，求出我最后有多少钱。 思路：完全背包。一开始看到债券价格为1000的倍数，我就用了 for(int j = value[i]; j …… str += a
树形dp入门[POJ1655][HDU1520][HDU1561][HDU1011][POJ1155][ZOJ3626]
cookiesMonster
08-15 568
[POJ1655][HDU1520][HDU1561][HDU1011][POJ1155][ZOJ3626]树形dp中，我们可以很容易利用题目给出的数据构建出一棵树，然后我们会用dp[i]记录，选择以 i 为根的子树中的点能得到的最优答案。而dp[i]的值可以根据，i节点的子节点u1,u2...un对应的dp[u1],dp[u2]...dp[un]，递推得到。树形dp通常用搜索的形式实现，由于是树的结构，所以不包含重复的搜索，复杂度为O（n）。
经典动态规划问题 背包问题 [POJ3211][POJ2063][HDU1114][POJ1276][POJ1014][POJ1742][ZOJ3631]
cookiesMonster
08-14 515
[POJ3211][POJ2063][HDU1114][POJ1276][POJ1014][POJ1742][ZOJ3631] 最长上升自序列问题（LIS） 给出n个整数a1,a2...an组成序列，求最长的上升子序列（若i 时间复杂度为O(n^2)的做法： dp[i]表示以ai为末尾的最长上升子序列长度，则有 当a[j] 时间复杂度O(nlogn)的做法： dp[i]表示长度为i的上升子序列末尾元素的最小值，则对于每个元素ai，二分查找数组dp，找到第一个dp[]值不小于ai的位置，将其值变为ai 例题
单调队列优化dp [HDU2191][HDU3401][POJ1821]
cookiesMonster
10-05 448
用单调队列优化形如 dp[i][j] = max(dp[i - 1][k] + (j - k) * a[i]) 的状态转移 上式可化为dp[i][j] = max(dp[i - 1][k] - k * a[i]) + j * a[i]， 在不用单调队列优化前，对于dp[i][j] 和dp[i][j + 1]枚举 k 时发现，有重复的部分，而且都是取dp[i - 1][...k...]...的最
ZOJ 3626 Treasure Hunt I （树形dp）
cookiesMonster
08-16 417
题目：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3626 题意：有一个危险的村庄，这里有时会有怪兽出现，已知怪兽多久会出现一次，怪兽出现之后发现谁不在家，就会把谁杀掉。一个勇士要得到了一张藏宝图并要去找宝藏，他知道村庄之间的距离和每个村庄里有多少宝藏，问他不被怪兽杀掉的话，最多能拿到多少宝藏。给出的n个村庄和n-1条
codeforce #331D Wilbur and Trees （记忆化搜索DP）
cookiesMonster
11-24 417
题目：http://codeforces.com/contest/596/problem/D 题意：有n课树并排排列，没课树高h，砍树。每次，从剩余的树中选最左边的或最右边的（概率相等，0.5），砍掉一棵树，树倒向左边的概率为p，倒向右边的概率为1-p。如果树和相邻树的距离小于h，树倒时会把相邻的树撞倒。问，砍完所有树，树干覆盖的草地长度的期望值。 思路： dp[ l ][ r ] 表示看完
区间dp入门[POJ2955][HDU2476][POJ3186][POJ1651][HDU4632][HDU4283][HDU4570][POJ3280]
cookiesMonster
08-15 397
[POJ2955][HDU2476][POJ3186][POJ1651][HDU4632][HDU4283][HDU4570][POJ3280]区间dp问题，通常给出一个序列，用dp[ i ][ j ] 表示序列为ai,a(i + 1)...aj时的答案，而较长的序列的答案由较短的序列的答案递推得到，让人想到矩阵连乘顺序问题。 所以解题的时候会用到3个循环： 第一层枚举序列长度 jj;第二层枚举序列开头的位置 i ;第三层枚举序列 [i, i + jj ] 中间点 k，其中第三层有时是不需要的.
概率dp入门[HDU5001][POJ2151][POJ3071][HDU3853][POJ2096]
cookiesMonster
09-14 389
[HDU5001][POJ2151][POJ3071][HDU3853][POJ2096] 概率分为求概率和求期望两种： 求概率从起点开始求解，因为起点发生的概率通常可以确定，为1； 求期望从终点开始求解，因为通常记录从某个点到终点的期望，即先确定了终点到终点的期望。 例题 HDU 5001 概率 http://acm.hdu.edu.cn/showproblem.php?pid=5001 题意：有一个图，n个点，m条边，（起点随机）我在某个点随便找一条相邻边消耗1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值