动态规划（背包问题，状态压缩DP，树形DP，区间DP，线性DP，计数类DP，记忆化搜索等）介绍及应用

已于 2023-07-19 17:53:28 修改
阅读量802 收藏 8
点赞数 2
分类专栏： 算法总结 文章标签： 动态规划 算法 c++
于 2023-02-10 20:01:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61551023/article/details/128976404
版权
本文详细介绍了动态规划在解决各种问题中的应用，包括01背包、完全背包、多重背包、分组背包问题的解法，以及线性DP、区间DP、计数类DP中的数位统计类问题和状态压缩技巧。此外，还讨论了树形DP在解决特定问题中的应用，如没有上司的舞会问题，以及记忆化搜索在滑雪问题中的运用。
摘要由CSDN通过智能技术生成

动态规划

文章目录

背包问题

01背包

每件物品只能用一次，找到在容量 V 内的最大价值

  • 01背包问题

    用DP分析法分析之后可以得到如下的结果，我们定义了f[i][j]，表示从前i个物品中选取容量为j的最佳选择情况，所以我们进行状态计算的时候可以分为选不选第i个物品，从而得到如下的计算公式
    f [ i ] [ j ] = m a x ( f [ i − 1 ] [ j ] , f [ i − 1 ] [ j − v [ i ] ] + w [ i ] ) f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]) f[i][j]=max(f[i−1][j],f[i−1][j−v[i]]+w[i])
    这样我们可以得到二维朴素版的01背包求解

for (int i = 1; i <= n; i++)
	for (int j = 0; j <= m; j++)
	{
		f[i][j] = f[i - 1][j];
		if (j > v[i])
		f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
	}

  然后我们可以发现每次进行状态转移的时候我们只用到了i-1没有用到i-2等，同时j也只用到了j和j-v[i]因此我们可以考虑使用滚动数组来优化代码到一维，每次i代表了循环到第i轮拿去0-m的最优选择，因此每次遇到更优解的时候都会进行覆盖。但是因为我们每次都会用到上一轮的状态所以我们循环重量的时候应该从大大小，不然会污染结果

加入我们需要更新f[7]用到了f[6]但是当我们从小到大开始遍历的时候f[6]一定已经被计算过一次，也就是此时f[6]是第i轮更新的结果，而不是第i-1轮

for (int i = 1; i <= n; i++)
	for (int j = m; j >= v[i]; j--)
		f[j] = max(f[j], [j - v[i]] + w[i]);

完全背包

每件物品能用无数次，找到在容量 V 内的最大价值

  • 完全背包问题

    完全背包进行状态划分的时候我们可以按照取得数量进行划分，然后出来了一个三维的朴素做法

当我们枚举的带有数量的时候，我们每次需要和自身取一个最大值，因为不能确定哪一次的f[i][j]是最大值

for (int i = 1; i <= n; i++)
	for (int j = 0; j <= m; j++)
		for (int k = 0; k * v[i] <= j; k++)
			f[i][j] = max(f[i][j], f[i-1][j-k*v[i]]+k*w[i]);

 由下面的式子我们可以对三维做法进行一个优化
f [ i ] [ j ] = m a x ( f [ i − 1 ] [ j ] , f [ i − 1 ] [ j − v [ i ] ] + w [ i ] , f [ i − 1 ] [ j − 2 ∗ v [ i ] ] + 2 ∗ w [ i ] ) . . . f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i],f[i-1][j-2*v[i]]+2*w[i])... f[i][j]=max(f[i−1][j],f[i−1][j−v[i]]+w[i],f[i−1][j−2∗v[i]]+2∗w[i])...

f [ i ] [ j − v [ i ] ] = m a x ( f [ i − 1 ] , [ j − v [ i ] ] , f [ i − 1 ] [ j − 2 ∗ v [ i ] ] + w [ i ] ) + . . . f[i][j-v[i]]=max(f[i-1],[j-v[i]],f[i-1][j-2*v[i]]+w[i])+... f[i][j−v[i]]=max(f[i−1],[j−v[i]],f[i−1][j−2∗v[i]]+w[i])+...

所以我们得到： f [ i ] [ j ] = m a x ( f [ i ] [ j − v ] + w , f [ i − 1 ] [ j ] ) 所以我们得到：f[i][j]=max(f[i][j-v]+w,f[i-1][j]) 所以我们得到：f[i][j]=max(f[i][j−v]+w,f[i−1][j])

 二维做法

for (int i = 1; i <= n; i++)
	for (int j = 0; j <= m; j++)
	{
		f[i][j] = f[i - 1][j];
		if (j > v[i])
			f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
	}

  这个时候我们可以发现和01背包类似，我们可以继续优化到一维，但是这里需要使用从小到大枚举，因为我们用到的是第i轮的数值

 for(int i = 1 ; i<=n ;i++)
    for(int j = v[i] ; j<=m ;j++)
    {
            f[j] = max(f[j],f[j-v[i]]+w[i]);
    }

多重背包

每一种物品都有各自的数量，找到在容量 V 内的最大价值

多重背包每次枚举数量即可

for(int i = 1;i <= n;i++)
        for(int j = 0;j <=m;j++)
            for(int k= 0;k <= s[i] && j >= v[i] * k;k++)
                f[i][j] = max(f[i][j],f[i-1][j-v[i] * k] + w[i] * k);

  当数据量过大的时候，我们使用三重循环就会超过时间的限制，因此我们可以将s拆分为二进制数，然后利用二进制的组成来达到组成小于等于s的任意值，比如10可以分为1 2 4 3，我们在使用01背包的时候可以考虑是否选取，这样的话就可以构成了 0-10 之间的任意数，也就是相当于去了 s 的任意情况

int main(void)
{
	cin >> n >> m;
	int cnt = 0;
	for (int i = 1; i <= n; i++)
	{
		int a, b, s;
		cin >> a >> b >> s;
		int k = 1;
		while (k <= s)
		{
			cnt++;
			v[cnt] = b * k;
			w[cnt] = a * k;
			s -= k;
			k = k * 2;
		}
		if (s > 0)
		{
			cnt++;
			v[cnt] = b * s;
			w[cnt] = a * s;
		}
	}
	n = cnt;
	for (int i = 1; i <= n; i++)
		for (int j = m; j >= v[i]; j--)
			f[j] = max(f[j], f[j - v[i]] + w[i]);
	cout << f[m] << endl;
	return 0;
}

分组背包

有许多不同类别的物品，每一种类别中只能选择一个物品

  分组背包问题，我们需要枚举每一个组别中的物品，然后别的就和01背包类似，只需要分为选或不选两种情况即可

 for(int i=1;i<=n;i++)
        for(int j=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j];  //不选
            for(int k=0;k<s[i];k++)
                if(j>=v[i][k])
                    f[i][j]=max(f[i][j],f[i-1][j-v[i][k]]+w[i][k]);  
        }

线性DP

  • Exp

    • 线性DP处理的一般就是题目中存在线性关系或者近似线性关系的问题

    • 一般DP问题都是在最后进行操作

  • 数字三角形

f[i][j]代表从起点走到i,j点的距离的最大值

状态计算的时候比较左上和右上下来的点即可

#include <iostream>
#include <algorithm>
using namespace std;
const int N= 550,INF = 1e9;
int a[N][N],f[N][N];
int n,m;
int main(void)
{
    cin >> n;
    for(int i = 1;i <= n ; i ++)
        for(int j = 1 ; j <= i ; j ++)
            cin >> a[i][j];
    for (int i = 0; i <= n; i ++ )
        for (int j = 0; j <= i + 1; j ++ )
            f[i][j] = -INF;
    f[1][1]= a[1][1];
    for(int i = 2 ; i <= n ; i ++)
        for(int j = 1 ; j <= i ; j ++ )
            f[i][j] = max(f[i-1][j-1] + a[i][j],f[i-1][j] + a[i][j]);
    int res = -INF;
    for(int i = 1 ; i <= n ; i ++)
        res = max(res,f[n][i]);
        cout << res << endl;
    return 0;
}

f[i]代表前f[i]中严格单调递增的数列的值

每次只需要比较遍历新加入的 i 即可

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
typedef long long LL;
const int N = 1e5 + 10;
int n;
int a[N], f[N];
int main(void)
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    for (int i = 1; i <= n; i++)
    {
        f[i] = 1;
        for (int j = 1; j < i; j++)
        {
            if (a[i] > a[j])
                f[i] = max(f[i], f[j] + 1);
        }
    }
    int res = 0;
    for (int i = 0; i <= n; i++)
        res = max(res, f[i]);
    cout << res << endl;
    return 0;
}

  我们可以发现 每个f[i]都记录了一个最大值，但是有些值我们用不到，因此我们可以设置一个数组记录了满足递增子序列的长度不同的结尾最小的值，然后我们可以发现该数组一定是一个单调递增的数组，所以我们可以通过二分找到每个i应该插入的位置，进而求到了最长上升子序列的长度

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
typedef long long LL;
const int N = 1e5 + 10;
int n;
int a[N], q[N];
int main(void)
{
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    int len = 0;
    q[0] = -2e9;
    for (int i = 0; i < n; i++)
    {
        int l = 0, r = len;
        while (l < r)
        {
            int mid = l + r + 1 >> 1;
            if (a[i] > q[mid])
                l = mid;
            else
                r = mid - 1;
        }
        len = max(len, r + 1);
        q[r + 1] = a[i];
    }
    cout << len << endl;
    return 0;
}

f[i][j]代表了在A的前i个字符和B的前j个字符中的最长公共子序列

我们只需要考虑 第i个和第j个字母是否选取，并且当都选取的时候处理相等或者不相等的情况

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
typedef long long LL;
const int N = 1010;
int n, m;
int f[N][N];
char a[N], b[N];
int main(void)
{
    cin >> n >> m;
    cin >> a + 1 >> b + 1;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            f[i][j] = max(f[i - 1][j], f[i][j - 1]);
            if (a[i] == b[j])
                f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
        }
    cout << f[n][m] << endl;
    return 0;
}

f[i][j]表示从a[1-i]变成b[1-j]的最小次数

我们只需要考虑最后一位的操作即可，增加、删除或者是替换，然后去一个最小值即可

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
typedef long long LL;
const int N = 1010;
int n, m;
char a[N],b[N];
int f[N][N];
int main(void)
{
    cin >> n >> a + 1 >> m >> b + 1;
    for(int i = 1; i <= m ; i++) f[0][i] = i;
    for(int i = 1; i <= n ; i++) f[i][0] = i;
    for(int i = 1 ; i <= n ; i ++)
        for(int j = 1; j <= m ; j ++)
        {
            f[i][j] = min(f[i-1][j] + 1,f[i][j-1] + 1);
            if(a[i] == b[j]) f[i][j] = min(f[i][j],f[i-1][j-1]);
            else f[i][j] = min(f[i][j],f[i-1][j-1] + 1);
        }
    cout << f[n][m] << endl;    
    return 0;
}

解题思路就是利用上一题，然后暴力遍历即可

#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 1e1 + 5, M = 1e3 + 10;

int n, m;
char str[M][N];
int dp[N][N];

int edit_distance(char a[], char b[])
{
    int la = strlen(a + 1), lb = strlen(b + 1);
    for (int i = 0; i <= lb; i++) {
        dp[0][i] = i;
    }
    for (int i = 0; i <= la; i++) {
        dp[i][0] = i;
    }
    for (int i = 1; i <= la; i++) {
        for (int j = 1; j <= lb; j++) {
            dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
            dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + (a[i] != b[j]));
        }
    }
    return dp[la][lb];
}
int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> (str[i] + 1);
    }

    while (m--) {
        int res = 0;
        char s[N];
        int limit;
        cin >> (s + 1) >> limit;
        for (int i = 0; i < n; i++) {
            if (edit_distance(str[i], s) <= limit) {
                res++;
            }
        }
        cout << res << endl;
    }
    return 0;
}

区间DP

区间DP一般就是指区间的划分问题，枚举的一般是区间长度

f[i][j]代表了从i和j中选取的最小代价

在选定的区间内进行状态的计算，最小代价就是合并区间的代价的最小取和加上整体的区间和

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
typedef long long LL;
const int N = 330;
int a[N], s[N];
int f[N][N];
int n;
int main(void)
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    // 前缀和数组
    for (int i = 1; i <= n; i++)
        s[i] = s[i - 1] + a[i];
    for (int len = 2; len <= n; len++)
    {
        for (int i = 1; i + len - 1 <= n; i++)
        {
            int j = i + len - 1;
            f[i][j] = 1e8;
            for (int k = i; k < j; k++)
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);
        }
    }
    cout << f[1][n] << endl;
    return 0;
}

计数类DP

我们可以当作完全背包问题，并且数字的可选数量为无穷

表示总和为i，总个数为j的方案数：我们也可以根据区间的最小值进行划分，一种是含有1的情况f[i-1][j-1]，当不含有1的时候我们可以得到f[i-j][j-1]

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, mod = 1e9 + 7;

int n;
int f[N];

int main()
{
    cin >> n;

    f[0] = 1;
    for (int i = 1; i <= n; i ++ )
        for (int j = i; j <= n; j ++ )
            f[j] = (f[j] + f[j - i]) % mod;

    cout << f[n] << endl;

    return 0;
}
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, mod = 1e9 + 7;

int n;
int f[N][N];

int main()
{
    cin >> n;

    f[1][1] = 1;
    for (int i = 2; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ )
            f[i][j] = (f[i - 1][j - 1] + f[i - j][j]) % mod;

    int res = 0;
    for (int i = 1; i <= n; i ++ ) res = (res + f[n][i]) % mod;

    cout << res << endl;

    return 0;
}

数位统计类DP

状态压缩DP

  状态压缩类DP，一般是指将状态用二进制表示，不然的话可能需要很大的数组来表示所有的状态，用了二进制表示后就可以很简便的记录下所有的状态，一般就是记录满足正确状态的情况。

f[i][j]表示从i-1列中伸出方块的数量，我们只枚举横着放置方块的情况，而且我们需要保证放置的状态和前一列的状态不能重新重复、中间的间隙必须书偶数不能为奇数，因为我们剩下的都必须是竖直放置

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
typedef pair<int, int> PII;
typedef long long LL;
const int N = 12, M = 1 << 12;
int n, m;
long long f[N][M];
bool st[M];
vector<int> state[M];
int main(void)
{
    while (cin >> n >> m, n || m)
    {
        // 预处理所有状态 i 代表了从 0~2^n 之间所有的二进制数
        for (int i = 0; i < 1 << n; i++)
        {
            int cnt = 0;
            st[i] = true;
            for (int j = 0; j < n; j++)
            {
                if (i >> j & 1)
                {
                    if (cnt & 1)
                        st[i] = false;
                    cnt = 0; // break
                }
                else
                    cnt++;
            }
            if (cnt & 1)
                st[i] = false;
        }
        for (int i = 0; i < 1 << n; i++)
        {
            state[i].clear();
            for (int j = 0; j < 1 << n; j++)
                if ((j & i) == 0 && st[j | i])
                    state[i].push_back(j);
        }
        // 状态转移
        memset(f, 0, sizeof f);
        f[0][0] = 1;
        for (int i = 1; i <= m; i++)
            for (int j = 0; j < 1 << n; j++)
                for (auto k : state[j])
                    f[i][j] += f[i - 1][k];
        cout << f[m][0] << endl;
    }
    return 0;
}

f[i][j]表示用过了前i个点，并且当前是在j这个点的路径最小值

由题意我们发现我们只需要考虑哪些点被用过，以及终点是哪里，所以我们可以用二进制表示每个点的使用情况，然后遍历所有的情况，我们需要保证当前状态包含i，且前一个k状态不含i

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;
const int N = 20, M = 1 << N;
int n;
int f[M][N];
int w[N][N];
int main(void)
{
    cin >> n;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cin >> w[i][j];
    memset(f, 0x3f, sizeof f);
    f[1][0] = 0;
    for (int i = 0; i < 1 << n; i++)
        for (int j = 0; j < n; j++)
            if (i >> j & 1)
                for (int k = 0; k < n; k++)
                    if (i >> k & 1)
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
    cout << f[(1 << n) - 1][n - 1] << endl;
    return 0;
}

树形DP

树形DP我们用f[u][0]代表该节点是否参与，0不参与1参与，接着考虑参与的时候和不参与的时候子树的值

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 6010;

int n;
int h[N], e[N], ne[N], idx;
int happy[N];
int f[N][2];
bool has_fa[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u)
{
    f[u][1] = happy[u];

    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        dfs(j);

        f[u][1] += f[j][0];
        f[u][0] += max(f[j][0], f[j][1]);
    }
}

int main()
{
    scanf("%d", &n);

    for (int i = 1; i <= n; i ++ ) scanf("%d", &happy[i]);

    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(b, a);
        has_fa[a] = true;
    }

    int root = 1;
    while (has_fa[root]) root ++ ;

    dfs(root);

    printf("%d\n", max(f[root][0], f[root][1]));

    return 0;
}

记忆化搜索

  记忆化搜索时一种实现DP的方式，属于优化后的DFS，因为DFS会重复搜索很多地方，而DP会保留一次的结果
  记忆化搜索相当于多次剪枝儿的DFS
  动态规划相当于用数组记录下较多的状态，避免了重复的遍历访问，把计算过的子问题保存下来

  记忆化搜索，本质还是 动态规划，只是实现方式采用了 深度优先搜索 的形式，但是它不像 深度优先搜索那样 重复 枚举所有情况，而是把已经计算的子问题保存下来，这样就和动态规划的思想不谋而合了

  记忆化搜索只是dp的一种实现方式，记忆化搜索可以实现然而普通递推不能实现的问题（或实现起来非常麻烦的问题）就用记忆化搜索， 比如这题；我们假设f[i][j]表示滑到坐标(i,j)所能滑到的最长长度。那么对于状态f[i][j]而言，它可以由f[i-1][j],f[i][j-1],f[i+1][j],f[i][j+1]四个状态推得，然而我们使用普通的递推（两个for）只能得到上、左两个方向的状态，右、下两个方向的状态却无从得知，因此使用递推就不能满足我们的要求，如果再补上两个for覆盖右、下状态，那么时间复杂度就变为了N^4，很明显会TLE，其中f[i][j]记录的是从[i,j]出发路径的最大值

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 330;
int h[N][N];
int f[N][N];
int n,m;
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};
int dp(int x,int y)
{
    int &v = f[x][y];
    if(v != -1) return v;
    v = 1;
    for(int i = 0;i<4;i++)
    {
        int a = x+dx[i],b = y+dy[i];
        if(x >= 1&&x<=n&&y>=1&&y<=m&&h[x][y] < h[a][b])
            v = max(v,dp(a,b)+1);
    }
    return v;
}
int main(void)
{
    cin >> n >> m;
    for(int i = 1;i<=n;i++)
        for(int j = 1;j<=m;j++)
            cin >> h[i][j];
    memset(f,-1,sizeof(f));
    int res = 0;
    for(int i = 1;i<=n;i++)
        for(int j = 1;j<=m;j++)
            res = max(res,dp(i,j));
    cout << res << endl;
    return 0;
}

动态规划本质和DFS一样，相当于优化的DFS，利用数组记录下了已经操作过的子问题的状态

赵英英俊
关注
专栏目录
线性DP / 区间DP / 记忆化搜索
Sti1lWater的博客
03-28 152
DP DFS
记忆化搜索+背包问题
jiangkun0331的博客
07-26 299
入侵和反击 A国部署的反导系统遇到了一个致命BUG，那就是每一次发射的拦截导弹的飞行高度都将只能小于等于上一枚导弹的飞行高度，第一次发射的拦截导弹的飞行高度可以看作是足够大。对于A国，这是一件很严重的问题，这意味着A国的防空系统面临空前危机。 通过对A国的军事部门计算机的入侵，A国还不知道敌对国B国刚才已经发现了这项BUG。更不知道，在这项BUG的报告书上交到B国空军司令部那一刻，三分钟后B国的全...
区间DP&树形DP
weixin_43870697的博客
08-05 557
目录 区间DP 树形DP 例题 A:POJ-2955 Brackets B:UVA-10003 Cutting Sticks C:POJ-1651 Multiplication Puzzle D:HDU-3506 Monkey Party E:POJ-2342 Anniversary party F:HDU-1054 Strategic Game G:ZOJ-3201 T...
关于01背包的记忆化搜索
m0_73959263的博客
11-03 432
记忆化搜索01背包问题
01背包问题--记忆化搜索and动态规划
丫丫的博客
06-10 1159
继上一篇代码的优化：分析：暴力搜索的代码可知，反复调用时有些同一参数调用了几次白白浪费了计算时间。我们可以利用记忆化数组，把已经计算过的参数的结果记录下来，下次需要用时可以直接返回结果。参数的组合为nw种，而函数内只调用2次递归，所以时间复杂度为O(nm)，比起O（2^n)效率大幅度提高。代码：#include&lt;iostream&gt; #include&lt;string.h&gt; us...
【AcWing】线性DP、区间DP、计数类DP
m0_70948728的博客
07-25 474
线性DP、区间DP、计数类DP
【专题讲解】计数类dp，区间dp与树形DP
遍地跑小鸡的博客
06-26 680
引言 动态规划部分的第三章节，前面已经讲了背包问题和线性dp问题。 计数类dp是求得方案的个数 区间dp是设计dp[i][j]表示从 i 开始到 j 的属性值。 计数DP 例题，整数拆分 思路一，背包问题 一个容量为N的背包，物品的体积是1-N，问恰好装满背包的方案数。完全背包。 dp = [0]*(V+1) dp[0] = 0 mod = 10**9+7 for i in range(N): for j in range(v, V+1): dp[j] = (dp[j]+dp[j-v])%mod
c语言dp状态转移方程,[总结-动态规划]经典DP状态设定和转移方程
weixin_42511201的博客
05-25 1097
马上区域赛，发现DP太弱，赶紧复习补上。#普通DPCodeForces-546D Soldier and Number Game 筛法+动态规划待补UVALive-8078 Bracket Sequence问以每个字符为左端点的最长括号序列是多长。(包括尖、花、中小括号)状态：设dp[i]为从i开始的括号序列最长长度。转移：以i+1为起点的最长串后边的字符若与左括号匹配，答案是加上这个字符后边的最...
动态规划之计数类DP
小羊的博客
04-02 1799
之前讲过背包问题，线性DP，区间DP，不知道大家忘了吗，这次是计数类DP 看完本篇文章觉得不错的话记得点赞👍，收藏⭐，还有问题也可以评论留言💬
树形dp+树形结构总结
热门推荐
dcx2001的博客
10-18 3万+
总结       最近写了好多树形dp+树形结构的题目，这些题目变化多样能与多种算法结合，但还是有好多规律可以找的。 树形dp一般都是用子树更新父亲（即从下向上更新），那么首先应该考虑的是一个一个子树的更新父亲还是把所有子树都算完了在更新父亲？这就要因题而异了，一般来说有两种情况：1.需要把所有子树的信息都掌握之后再更新子树的就需要把所有子树都算完了在更新父亲。2.而像树上背包这样的问题就需要
记忆化搜索解决背包问题
qq_43813373的博客
05-17 528
为什么要用二维数组进行纪录？ 记忆化最麻烦的还是记忆值的准确性 #include<iostream> #include<algorithm> using namespace std; struct node{ long long w,v; }d[10000]; long long n,m; long long dp[1000][1000]; /* 一开始我直接使用的dp[1000000],以为将每个m对应的最优解存下就行了，但是不行，每个i对应的m都有意义。 并且对于dp[m]一
01背包问题——记忆化搜索的妙用
m0_46530392的博客
02-14 523
目录最基本的想法思想引申解决方案 这是一道很经典的01背包问题，是有限背包。 我们可以看到利用记忆化搜索的方法时间是 最基本的想法 #include<iostream> using namespace std; int n,W; const int MAX_SIZE=100; int w[MAX_SIZE+1],v[MAX_SIZE+1]; void solve(); int rec(int,int); int main(){ cin >> n >> W
算法基础复盘笔记Day11【动态规划】—— 区间DP、计数类DP、树形DP、记忆化搜索
最新发布
Java技术一点通
04-15 2038
考虑一颗以u为根节点的子树，这颗子树的快乐指数应该是u的函数，并且分两种情况：选u和不选u。状态表示： f[u][1]表示以u 为根节点的子树并且包括u的总快乐指数，f[u][0] 表示以u为根节点的子树并且不包括u的总快乐指数。 状态计算：记点u的子节点是s - 选 $u$，f[u][1] += $\sum\limits_{}^{}$f[s][0]; - 不选 $u$，f[u][0] += $\sum\limits_{}
完全背包问题 dp及记忆化搜索
m0_60777643的博客
12-29 716
669 · 换硬币 给出不同面额的硬币以及一个总金额. 写一个方法来计算给出的总金额可以换取的最少的硬币数量. 如果已有硬币的任意组合均无法与总金额面额相等, 那么返回 -1. 你可以假设每种硬币均有无数个 总金额不会超过10000 硬币的种类数不会超过500, 每种硬币的面额不会超过100 样例1 输入： [1, 2, 5] 11 输出： 3 解释： 11 = 5 + 5 + 1 样例2 输入： [2] 3 输出： -1 分析： 确定子问题：主问题，n的总金额用value[ ]面值的
背包问题的5种求解方法——记忆化搜索或者动态规划
随意凯的博客
04-24 2589
这篇博客简单讲一下动态规划经典问题——背包问题的解法，总共有5种解法，很全面！！！！
0/1背包问题（递归+记忆化搜索+dp三种方法）
-知是故人来-
03-31 629
–链接–
01背包 记忆化搜索解法
m0_60777643的博客
01-04 1402
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N行，每行两个整数vi,wi，用空格隔开，分别表示第 i件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi≤1000 输入样例 4 5
详解背包问题--以及对它进行状态压缩--分割等和子集
CppYyds的博客
05-26 283
文章目录题目背包详解代码 题目 背包详解 如何判断是背包问题呢？只要一个问题可以看作为将物体装入背包的过程，那么它就是背包问题。 比如本题，只要求出sum/2之后，接下来要求出数组中的元素是否有和正好为该数的， 而这个过程sum/2就相当于背包的容量，而数组中的元素就是装入其中的物体，确定为背包问题后， 我们还需要清楚是哪一类背包问题–到底是物体使用次数受限还是不受限。 此题物体使用次数只有一次，所以是01背包问题，接下来就是定义dp和推导dp关系的过程了。 定义dp[i][j]为判断前i个元素能
背包和区间DP
qq_43632898的博客
04-10 185
背包问题也分很多比如最经典的01背包问题，分组背包，完全背包。 所有的学习的背包问题都是从01背包问题上发展而来的，比如01背包的经典问题就是有限的空间中获得最大的利润，那么分组背包就是所有的有N件物品，告诉你这N件物品的重量以及价值，将这些物品划分为K组，每组中的物品互相冲突，最多选一件，求解将哪些物品装入背包可使这些物品的费用综合不超过背包的容量，完全背包就是有N 件物品和一个容量为的背包。每...
信息技术经典dp算法详解与实例汇总
动态规划（Dynamic Programming，简称DP）是一种通过将大问题分解为相互重叠的小问题来求解最优化问题的算法方法，它通常用于求解具有最优子结构和重叠子问题性质的问题。 首先，资源问题部分包括了： 1. **机器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赵英英俊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值