C++动态规划

最新推荐文章于 2024-05-22 21:10:21 发布
最新推荐文章于 2024-05-22 21:10:21 发布
阅读量2.2k 收藏 12
点赞数 2
分类专栏： 算法入门 文章标签： 动态规划 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kicamon/article/details/123510253
版权

动态规划

文章目录

一、背包问题

1、01背包问题

01背包问题就是通过遍历选择是否选第i个物品，以达到总价值最大：

#include<iostream>
using namespace std;
const int N = 1010;

int n,m;//物品总数为n个，背包的总容量为m
int dp[N];
int v[N],w[N];//物品的体积和价值

int main()
{
    cin >> n >> m;
    
    for(int i = 0;i < n;i++)cin >> v[i] >> w[i];
    
    for(int i = 0;i < n;i++)
        for(int j = m;j >= v[i];j--)
            dp[j] = max(dp[j],dp[j - v[i]] + w[i]);//从不选和选中选中较大值
    
    cout << dp[m] << endl;
    
    return 0;
}

当遍历方向为从大到小时，每次更新时使用的是上一次的状态。更新的只与i-1时的状态有关，而逆序可以保证i-1的状态为上一次循环的状态，没有被更新。

2、完全背包问题

首先看结论，完全背包问题的代码就是将01背包中的从大到小遍历改成从小到大遍历

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

因为每个物品可以无限选择，所以选择的结果是多样的，此时：

dp[j] = max(dp[j],dp[j - v[i]] + w[i],dp[j - 2 * v[i]] + 2 * w[i]……)

同时，dp[j - v[i]] = max(dp[j - v[i]],dp[j - 2 * v[i]] + w[i]……)

所以，dp[j] = max(dp[j],dp[j - v[i]] + w[i])

由于这里的状态是需要及时更新的，所以这里的循环方式是正序。

3、多重背包

多重背包本质上还是利用01背包的思想处理的，每个物品可以选择多件，但是有数量限制，不同于完全背包的无限选择。

3.1、多重背包的朴素实现
for(int i = 0;i < n;i++)
{
    scnaf("%d%d%d",&v,&w,&s);//输入体积价值和数量
    for(int j = m;j >= v;j--)
        for(int p = 1;p <= s && j >= p * v;p++)
            f[j] = max(f[j],f[j - p * v] + p * w);
}
3.2、二进制优化多重背包

二进制优化多重背包是指利用2的次方将第i物品拆分为多个物品，并单独作为一个物品利用01背包计算结果。

比如，8拆分为1，2，4，1；10拆分为1，2，4，3。即20,21,22,23……2n,余数。

struct Good
{
    int v,w;
};
vector<Good>good;

void dp()
{
    for(int i = 0;i < n;i++)
    {
        int v,w,s;
        cin >> v >> w >> s;
        
        for(int j = 1;j <= s;s -= j,j *= 2)
            good.push_back({j * v,j * w});
        if(s)good.push_back({s * v,s * w});
    }
    
    for(auto g : good)
    {
        for(int i = m;i >= g.v;i--)
            f[i] = max(f[i],f[i - g.v] + g.w);
    }
}

4、分组背包

分组背包级有讲物品分为多组，每组有多个物品，但是每组物品最多只能选择一个。

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

二、线性DP

1、数字三角形

存在以下数字三角形，求和最大路径的值。

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

从最后一层开始dp即可，每次用较大的值加上上一个值，即可得到结果：

for(int i = n - 1;i > 0;i--)
{
    fo(int j = 1;j <= i;j++)
    {
        num[i][j] += max(num[i][j],num[i][j + 1]);
    }
}

最后的结果即为3num[1] [1]的值。

2、最长上升子序列

2.1、最长上升子序列的朴素实现

最长上升子序列的求法就是在每个点的位置存入以该点为结尾的最长子序列的长度，然后遍历是实现即可。

for(int i = 1;i <= n;i++)
    for(int j = 1;j < i;j++)
        f[i] = max(f[i],f[j] + 1);
2.2、优化

在储存子序列末尾数字的时候，取最小的存储，那么子序列末尾数字与子序列长度将呈正相关关系。

for(int i = 1;i <= n;i++)cin >> a[i];

int len = 0;
for(int i = 1;i <= n;i++)
{
    int l = 0,r = len;
    while(l < r)
    {
        int mid = l + r + 1 >> 1;
        if(q[mid] < a[i])l = mid;
        else r = mid - 1;
    }
    len = max(len ,r + 1);
    q[r + 1] = a[i];
}

3、最长公共子序列

最长公共子序列不一定要求连续。如果序列末尾不相等，则从状态[i,j-1]和[i-1,j]中取较大的值，如果末尾相等，则为状态[i-1,j-1]+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] = f[i-1][j-1] + 1;
    }

例如，序列：

acbd
abedc

状态表示：

j\i1234
11111
21122
31122
41123
51223

4、最短编辑距离

存在两不同的字符串a和字符串b，每一步操作对a进行删除、插入或修改一个字符，最终将a变成b，即为操作距离。操作的次数最少的方式即为最短编辑距离。这个问题的解决方法类似于完全背包问题。

它的思想是将a从1位开始处理变成b的每一位的次数，即用数组f[i] [i]来记录将a[1 ~ i]变成b[1 ~ j]的步骤。

首先是预处理所有0位变化，假设a有n位，b有m位。

for(int i = 0;i <= n;i++)f[i][0] = i;
for(int i = 0;i <= m;i++)f[0][i] = i;

然后是状态更新部分，类似于完全背包，是正序遍历：

for(int i = 1;i <= n;i++)
    for(int j = 1;j <= m;j++)
    {
        f[i][j] = min(f[i - 1][j],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);
    }

最后的答案即为f[n] [m]，输出即可。

三、区间DP

如题：282. 石子合并 - AcWing题库

首先利用前缀和预处理，方便求出每个区间的石子堆的重量和，输入的之后即可处理：

for(int i = 1;i <= n;i++)
{
    cin >> s[i];
    s[i] += s[i - 1];
}

然后利用三层循环来遍历每一个状态。第一层是区间长度，即需要合并的石子堆的数量。长度从2开始，因为长度为1时不需要合并；第二层是遍历区起点的下标；第三层是遍历区间里的每个点求出区间最小值。

const int null = 0x3f3f3f3f;

for(int l = 2;l <= n;l++)
{
    for(int i = 1;i + l - 1 <= n;i++)
    {
        int j = i + l - 1;
        f[i][j] = null;
        for(int p = i;p <= j;p++)
            f[i][j] = min(f[i][j],f[i][p] + f[p + 1][j] + s[j] - s[i - 1]);
    }
}

最后得到的f[1] [n]就是答案。

四、计数DP

计数dp本质上是完全背包的变种，将数字n拆分为不同的数的和，数字可以重复，但是不计顺序。

例如：

5可以拆分为

1 1 1 1 1

1 1 1 2

1 1 3

1 2 2

2 3

有两种代码实现方法，第一种是利用01背包，不过属性由最大值改为数量

f[i] [j] = f[i - 1] [j] + f[i - 1] [j - i] + … + f[i - 1] [j - s * i];

f[i] [j - i] = f[i - 1] [j - i] + f[i - 1] [j - 2 * i] + … + f[i - 1] [j - s * i];

综上，f[i] [j] = f[i - 1] [j] + f[i - 1] [j - i]，简化过后就是f[j] = f[j] + f[j - i]。

代码如下：

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

还有一种代码为：

f[0][0] = 1;

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

五、数位统计DP

数位统计DP用于计算一定范围内的数字出现的次数，比如[0,10]这个区间里，0这个数字出现过两次，即0和10的个位上。这个可以通过暴力来实现，但是暴力的时间复杂度很高，计算量庞大。

数位统计DP的原理如下：

求某七位数abcdefg范围内数字1出现的次数，在其每一位上进行一次计算。

情况1、计算最高位数字的时候，只需要计算后边的次数即可，这里为000000~bcdefg的数字量，即bcdefg+1。

情况2、在中间时，这里以第四位为例

2.1前边的数小于abc，前边有abc中情况，后边有1000中情况，综合为abc*1000种。

2.2前边的数等于abc，存在三种状况

2.2.1 d < 1时，这个数比abcdefg大，情况为0

2.2.2 d = 1时，后边的数可以取000~efg，则数量为efg+1

2.2.3 d > 1时，后边可以取000~999，则数量为1000

ps:当d为0的时候，前边不能取000，要从001开始，所以要将数字-1

综上可以得到代码：

int get(vector<int> num,int l,int r)//求0~x中的数字数量，即x
{
    int ans = 0;
    for(int i = l;i >= r;i--)ans = ans * 10 + num[i];
    return ans;
}

int pow10(int x)//求10的x次方
{
    int ans = 1;
    while(x--)ans *= 10;
    return ans;
}

int count(int n,int x)
{
    if(!n)return 0;
    vector<int> num;
    
    while(n)
    {
        num.push_back(n % 10);
        n /= 10;
    }
    n = num.size();
    
    int ans = 0;
    for(int i = n - 1 - !x;~i;i--)//x为0时，最高位不需要计算，
    {
        if(i < n - 1)//最高位不需要这个步骤
        {
            ans += get(num,n - 1,i + 1) * pow10(i);
            if(!x)ans -= pow10(i);//x为0时，减去一种情况
        }
        
        if(num[i] == x)ans += get(num,i - 1,0) + 1;//情况2，d < x时为0无需考虑
        else if(num[i] > x)ans += pow10(i);
    }
    
    return ans;
}

六、状态压缩DP

1、蒙德里安的梦想

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-auHvkmdz-1647344306704)(E:\笔记&诗歌散文\笔记\博客\图片\QQ图片20220312171852.png)]

这一题是大多数人学习状态压缩是所做的第一题，状态压缩的定义也可以在这里得到阐述。所谓状态压缩，就是将当前状态用二进制01串表示。

  • 在这里，我们通过先摆放横着的小方块，将所有的横着的小方块放完之后，剩下的部分只能有一种摆法供竖着的小方块摆，所以计算横摆小方块的情况即可。

  • 然后是判断这一列的摆放是否合法。判断方法是，空着的连续小方格为偶数，这样才能用竖着的小方块摆满。

我们假设一共是两行，那么一列的横摆方式有（1表示摆放，0表示空）00，01，10，11四种，即22种。简单计算可知，如果存在n行，那么共有2n种摆放方式（包括不合法的摆放方式）。这些摆放方式恰好可以用0~2n的二进制来表示，由此，我们可以得到代码：

for(int i = 0;i < 1 << n;i++)
{
    int cnt = 0;//用于储存连续空格的数量
    vis[i] =  1;//表示是否合法
    for(int i = 0;i < n;i++)//二进制位n位
    {
        if(i >> j & 1)
        {
            if(cnt & 1)
            {
                vis[i] = 0;
                break;
            }
            cnt = 0;
        }
        else cnt++;
    }
    if(cnt & 1)vis[i] = 0;
}

在将所有的合法序列都筛选出来之后，再进行下一步筛选并储存。这次的筛选是选择合适的序列组，如果第i-1列的某处伸入了第i列，那么在个位置第i列就只能是空，例如：001001和011001，再第三位上均为1，不储存。

for(int i = 0;i < 1 << n;i++)
{
    state[i].clear();//存储序列的容器，每次使用前清空。
    for(int j = 0;j < n;j++)
    {
        if((i & j) == 1 && vis[i | j])//i & j == 1说明它们没有重复覆盖位置，vis[i | j]说明它们留下的空位合法
            state[i].push_back(j);
    }
}

最后就是dp环节了：

memset(f,0,sizeof f);
for(int i = 1;i <= m;i++)
    for(int j = 0;j < 1 << n;j++)
        for(auto k : state[i])
            f[i][j] += f[i - 1][k];//三重循环遍历z

最后输出f[m] [0]即可，说明在m列上，伸出数量为0的方案数。

完整代码如下：

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
const int N = 12, M = 1 << N;
typedef long long LL;

int n, m;
LL f[N][M];
vector<int>state[M];
bool vis[M];

int main()
{
	while (cin >> n >> m,n || m)
	{
		int cnt = 0;
		for (int i = 0; i < 1 << n; i++)
		{
			vis[i] = 1;
			for (int j = 0; j < n; j++)
			{
				if (i >> j & 1)
				{
					if (cnt & 1)
					{
						vis[i] = 0;
						break;
					}
					cnt = 0;
				}
				else cnt++;
			}
			if (cnt & 1)vis[i] = 0;
		}

		for (int i = 0; i < 1 << n; i++)
		{
			state[i].clear();
			for (int j = 0; j < 1 << n; j++)
			{
				if ((i & j) == 0 && vis[i | j])
					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;
}

2、最短Hamilton路径

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KzVSwuGn-1647344306705)(E:\笔记&诗歌散文\笔记\博客\图片\最短Hamilton路径.png)]

这里我们需要维护两个量：一个是state，用来存储已经走过的点，另一个是j，即现在所处的点。

f[state] [j] = f[state_k] [k] + f[k] [j]，state_k表示state除去j之后、并且包含k的集合。

这里的state利用二进制来表示，哪一位上为1，则表示其已经走过。例如：00100表示走过第三个点。

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)//走过第j位，比较上一状态
            for(int k = 0;k < n;k++)
                if(i - (1 << j) >> k & 1)//没走过第j位但是走过第k位
                    f[i][j] = min(f[i][j],f[i - (1 << j)][k] + d[k][j]);//数组d储存边权

完整代码如下：

#include<iostream>
#include<cstring>
using namespace std;
const int N = 20, M = 1 << 20;

int n;
int f[M][N], d[N][N];

int main()
{
	cin >> n;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			cin >> d[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 - (1 << j) << k & 1)
						f[i][j] = min(f[i][j], f[i - (1 << j)][k] + d[k][j]);
	cout << f[(1 << n) - 1][n - 1] << endl;
 	return 0;
}

七、树形DP

先看看题：285. 没有上司的舞会 - AcWing题库

根据题目描述，没有职员愿意和直接上司一起参会，意味着子结点和父结点不能同时选入。那么，每个结点就要更新两种状态，选和不选：该节点是选入状态时，利用子结点的不选状态进行更新：该节点是不选的时候，利用子结点选入和不选中较大的进行更新。

我们创建一个二维数组f[N] [2]，两个下标分别表示位置和选择状态：

f[u] [1] += f[j] [0];

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

再利用dfs从父结点开始遍历每个结点就可以得到答案。

#include<iostream>
#include<cstring>
using namespace std;
const int N = 6010;

int e[N],ne[N],h[N],idx;
int f[N][2];//状态更新
int a[N];//存储读入数据
bool flag[N];//标记根节点

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

void dfs(int u)
{
    f[u][1] = a[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()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i++)cin >> a[i];
    
    for(int i = 1;i < n;i++)
    {
        int a,b;
        cin >> a >> b;
        flag[a] = 1;//将子结点标记为true
        add(b,a);
    }
    
    int root = 1;
    while(flag[root])root++;//遍历寻找根节点，由于作为子结点的结点都被标记了，所以没有被标记的就是根结点。
    
    dfs(root);
    
    cout << max(f[root][0],f[root][1]) << endl;
    return 0;
}

八、记忆化搜索

记忆化搜索再搜索过程中会将搜索过的状态都存下来，再次搜索到这个状态时就不必再次求解了。

如题：901. 滑雪 - AcWing题库

首先要做的是将每个点的高度读入：

for(int i = 1;i <= n;i++)
    for(int j = 1;j <= m;j++)
        cin >> g[i][j];

然后将用于状态更新的数组初始化：

memset(f,-1,sizeof -1);

最后遍历每个点，计算以该点为起始点的路径即可：

int res = 0;
for(int i = 1;i <= n;i++)
    for(int j = 1;j <= m;j++)
        res = max(res,dp(i,j));

dp函数如下：

int mx[4]{1,0,-1,0},my[4]{0,1,0,-1};

int dp(int x,int y)
{
    int& v = f[x][y];
    if(v != -1)return v;//v！=-1说明这个点被搜索过，可以直接返回
    
    v = 1;
    for(int i = 0;i < 4;i++)
    {
        int a = x + mx[i],b = y + my[i];
        if(a >= 1 && a <= n && b >= 1 && b <= m && g[a][b] < g[x][y])
            v = max(v,dp(a,b) + 1);
    }
    return v;
}

完整代码如下：

#include<iostream>
#include<cstring>
using namespace std;
const int N = 310;

int g[N][N],f[N][N];
int n,m;

int mx[4]{1,0,-1,0},my[4]{0,1,0,-1};

int dp(int x,int y)
{
    int& v = f[x][y];
    if(v != -1)return v;//v！=-1说明这个点被搜索过，可以直接返回
    
    v = 1;
    for(int i = 0;i < 4;i++)
    {
        int a = x + mx[i],b = y + my[i];
        if(a >= 1 && a <= n && b >= 1 && b <= m && g[a][b] < g[x][y])
            v = max(v,dp(a,b) + 1);
    }
    return v;
}

int main()
{
    cin >> n >> m;
    for(int i = 1;i <= n;i++)
    	for(int j = 1;j <= m;j++)
        cin >> g[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;
}
Kicamon
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【C++】动态规划
m0_63852285的博客
05-07 1739
动态规划（英语：Dynamic programming，简称 DP），是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。
C++-----动态规划
m0_63064861的博客
05-03 4764
动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。l每一个解都对应于一个值，我们希望找到具有最优值的解。基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。l适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。l我们。
C++动态规划详解
热门推荐
weixin_51951103的博客
09-11 1万+
动态规划思想 一、动态规划概念： 动态规划（dp）是研究多步决策过程最优化问题的一种数学方法。在动态规划中，为了寻找一个问题的最优解（即最优决策过程），将整个问题划分成若干个相应的阶段，并在每个阶段都根据先前所作出的决策作出当前阶段最优决策，进而得出整个问题的最优解。即记住已知问题的答案，在已知的答案的基础上解决未知的问题。 在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后
01背包问题c++动态规划 代码及讲解
最新发布
2203_75994275的博客
05-22 780
为了方便广大朋友们理解01背包问题，也方便我自己复习而先出的文章 如果有错误欢迎指出！！！我将感激不尽！！！
C++ 动态规划
meFranky的博客
07-04 4140
简要介绍动态规划解题的思路，并以数字金字塔、0-1背包问题为例，给出动态规划的代码实现
C++动态规划问题大合集
01-21
在IT领域，动态规划是一种强大的算法技术，常用于解决复杂问题。C++作为一种高效且功能丰富的编程...在深入学习C++动态规划的过程中，建议结合更多的实际问题和不同类型的动态规划问题进行练习，以巩固理解和提高技能。
C++动态规划源码.zip
11-14
在"C++动态规划源码.zip"这个压缩包中，我们可以找到一系列关于动态规划的C++源代码示例，这对于学习和理解动态规划的实现机制非常有帮助。 动态规划的基本概念是通过将大问题分解为相互关联的小问题来解决。每个小...
基于 C++动态规划求解最长公共子序列
05-10
【作品名称】：基于 C++动态规划求解最长公共子序列 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：基于 C++动态规划...
c++动态规划详解
Yoyo的博客
06-26 1119
动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。动态规划是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。简单来说动态规划其实就是，给定一个问题，我们把它拆成一个个子问题，直到子问题可以直接解决。然后呢，把子问题答案保存起来，以减少重复计算。再根据子问题答案反推，得出原问题解的一种方法。
C++动态规划超详细总结
我的博客
01-18 4277
详解 C/C++ 的动态规划问题。
C++之动态规划（动态规划入门）
m0_62755690的博客
11-05 7204
好
动态规划（DP）C++讲解，看着这一本就够了
JOSEPHCAMPBELL的博客
10-05 3415
动态规划（DP）C++讲解，看着这一本就够了
C++——动态规划
m0_48748418的博客
05-18 765
它通过将问题分解为更小的子问题，并利用子问题的解来构建原问题的解。在上述示例中，我们通过创建一个二维数组dp来保存子问题的解，其中dp[i][j]表示前i个物品放入容量为j的背包中所能达到的最大价值。动态规划的核心思想是存储并重复使用子问题的解，以避免重复计算。3、确定状态转移方程：找到子问题之间的关系，以及如何利用子问题的解来构建原问题的解。2、确定状态：找到描述子问题的状态变量，以便构建动态规划表。5、求解原问题：根据填充好的表格，求解原问题的解。1、定义子问题：将原问题拆解为较小的子问题。
动态规划（C++）
DCMyyds的博客
07-29 332
动态规划讲解
c++动态规划
06-02
C++中动态规划可以通过定义一个二维数组来实现。假设我们有一个问题，需要求解一个最优解，我们可以将这个问题分解成若干个子问题，然后将子问题的最优解保存在二维数组中。具体步骤如下： 1. 定义一个二维数组dp，dp[i][j]表示子问题的最优解。 2. 初始化dp数组，将所有dp[i][j]的值都设置为初始值。 3. 通过状态转移方程来求解dp数组：dp[i][j] = f(dp[i-1][j], dp[i][j-1], ...) 4. 最终的最优解就是dp数组中的某一个值，根据具体问题的要求来确定。 下面是一个示例代码： ```c++ #include <iostream> #include <algorithm> using namespace std; int main() { int n, m; cin >> n >> m; int a[n][m], dp[n][m]; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> a[i][j]; dp[i][j] = a[i][j]; } } for (int i = 1; i < n; i++) { for (int j = 1; j < m; j++) { dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + a[i][j]; } } cout << dp[n-1][m-1] << endl; return 0; } ``` 上面的代码实现了一个简单的动态规划问题：给定一个n行m列的矩阵，求从左上角到右下角的路径上的数字之和的最大值。我们将问题分解成了若干个子问题，通过状态转移方程dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + a[i][j]来求解dp数组，最终的最优解就是dp[n-1][m-1]。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值