动态规划详解

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

来更新一下，既然想写一篇动态规划，那么怎么能少了01背包。
主要是我 01背包顺推逆推每次都要重新理解一次

先奉上题目：
https://www.acwing.com/problem/content/2/
我们设 f i , j f_{i,j} fi,j​为前 i i i个物品容量为 j j j能收获的最大贡献。那么 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) fi,j​=max(fi−1,j​,fi,−1,j−vi​​+wi​)
这个式子表示对于第 i i i 件物品，选择它或不选它能产生的最大价值。
它的状态完全由前 i − 1 i-1 i−1 个物品的状态转移而来。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int dp[maxn][maxn],w[maxn],v[maxn];
signed main(){
    int n,m;
    cin>>n>>m;
    for(int i = 1;i <= n;i++){
        cin>>v[i]>>w[i];
    }
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            if(j>=v[i]){
                dp[i][j] = max(dp[i - 1][j],dp[i - 1][j - v[i]] + w[i]);
            }
            else dp[i][j] = dp[i - 1][j];
        }
    }
    cout<< dp[n][m] <<endl;
   return 0;
}

这里的时间无法再优化，但空间复杂度还可以再优化，我们注意到，当前的状态（假设为 i i i）只与 i − 1 i-1 i−1的状态有关。那么我们另设一个数组存 i − 1 i - 1 i−1的状态，那么就可以将空间复杂度由 O ( n m ) O(nm) O(nm)降至 O ( 2 m ) O(2m) O(2m)。 f [ j ] = max ⁡ ( s t a [ j ] , s t a [ j − v [ i ] ] + w [ i ] ) f[j]=\max(sta[j],sta[j-v[i]]+w[i]) f[j]=max(sta[j],sta[j−v[i]]+w[i])

#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e3 + 10;
int dp[maxn], w[maxn], v[maxn], sta[maxn];

signed main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (j >= v[i]) {
                dp[j] = max(sta[j], sta[j - v[i]] + w[i]);
            } else dp[j] = sta[j];
        }
        for (int j = 1; j <= m; j++)
            sta[j] = dp[j];
    }
    cout << dp[m] << endl;
    return 0;
}

很多初学者不明白01背包顺着推和逆着推的到底是什么逻辑。
现在我们再来优化一下上面的代码，来看看滚动数组是怎么逆推实现的。
上面我们要用 s t a sta sta 数组来记录前一个状态，现在，来试试不用 s t a sta sta 来记录状态。
我们只用 D P [ V ] DP[V] DP[V]来更新答案。
想想为什么我们要用 s t a sta sta 来记录前一个状态，因为对于现在的 d p [ j ] dp[j] dp[j]，我们是对第 i i i 件物品选择或不选，如果顺推那就是： d p [ j ] = max ⁡ ( d p [ j ] , d p [ j − v [ i ] ] + w [ i ] ) dp[j]=\max(dp[j],dp[j-v[i]]+w[i]) dp[j]=max(dp[j],dp[j−v[i]]+w[i])这个式子里， j j j 之前的状态已经讨论过 i i i 是否选取，也就是说，很有可能我当前选了 i i i,但是之前的 d p [ j − v [ i ] ] dp[j-v[i]] dp[j−v[i]]也选过 i i i，造成了重复计数。
面对这种情况，就有了我们的逆推，逆着推，后面的先考虑是否选 i i i ,那么前面的 d p [ j ] dp[j] dp[j] 就没有被污染了。

#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e3 + 10;
int dp[maxn], w[maxn], v[maxn], sta[maxn];

signed main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= 1; j--) {
            if (j >= v[i]) {
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
            }
        }
    }
    cout << dp[m] << endl;
    return 0;
}

闲着无聊 写一篇二进制优化dp玩玩：
题目链接

有 N 种物品和一个容量是 V
的背包。
第 i种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。接下来有 N行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i种物品的体积、价值和数量。
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

二进制优化背包的前提是你要学会01背包和多重背包。

01背包很简单吧，第i件物品，我选或是不选，当前最多能拿到多少钱（价值）。
然后我们再进行第i件物品的选择。

对于多重背包来说 ，我门对前i种物品进行选择，对于第i种物品来说，我会尝试不选，看看现在我的钱（价值）有没有增多。
选择一个，看看现在我的钱（价值）有没有增多。
再看看选两个有没有增多，再看看选三个有没有增多，直到我的包太小装不下了，就完了。

然后我们再进行i+1种物品的选择。

有没有发现有点相似？

如果我们把多重背包拆开了，一种物品有n个，我们就拆成n个独立的物品。
卧槽，这不就是01背包吗。

然后我又开始搜寻宝藏了。
然后我发现，由于我把多重背包拆开了，有时候就会遇到，有1023个相同的物品。但我只能一次一次的进行选择，yes or no，进行1023次。
Oh my god ！！ 明明它们都是相同的，我就不能简化吗，为什么要这样折磨我。

我不知道从哪里得到了一个结论：
任何数都可以用多个不同的2的指数进行表示。
比如 7=1+2+4
11=8+1+2

然后我就突然得到了上帝的智慧，于是我把这1023个相同物品分成了1个，2个，4个，8个，16个，32个，64个，128个，256个，512个。总共10堆，刚好分完。哇，少了好多。

如果我现在背包可以装54个这样的物品，很显然我装满就是价值最大的时候了。
咦，这上面并没有54呢，但是我一个一个装是可以装到54的呢。
别急，
还记得我们的结论吗，54=32+16+4+2；
我选了54个物品就相当于是我选了32，16，4，2，这是可以组合的，那么对于dp来说它并不会管你如何组合，只会问你能不能组合。

我们对这一数进行dp时，其实我们已经讨论了1-1023所有的数。

哈哈哈，写的可能不是很好，但已经尽力了，这是我所能理解的二进制优化，当然还有点漏洞，比如我故意取了一个特殊值，1023，它恰好被分完了，如果是1024能？ 我就不细说了，欢迎大家讨论。

后面是题解：

首先就是拆分多重背包，变成01背包，相同的物品进行二进制优化拆分，会拆成很少几个部分。
所有拆分当然是先要预处理啊：

    int len=1;
    for (int i = 1; i <= n; i++) {
        int z = 1;
        for (int j = 0; s[i] >(z<<j); s[i] -= (z<<j),j++ ) {

           q[len]=(z<<j)*v[i];
           p[len++]=(z<<j)*w[i];
        }
        q[len]=s[i]*v[i];
        p[len++]=s[i]*w[i];
    }

预处理是我随意写的，可能写的不是很好看。

完整代码：

#include<bits/stdc++.h>

using namespace std;
#define  int long long
#define rep(i, x, y) for(auto i=(x);i<=(y);++i)
#define dep(i, x, y) for(auto i=(x);i>=(y);--i)
#define gcd(a, b) __gcd(a,b)
const long long mod = 1e9 + 7;
const int maxn = 2e4 + 10;

int lowbit(int x) { return x & -x; }

bool ispow(int n) { return (n & (n - 1)) == 0; }//O(1) 判断是否是 2^k（2的k次方）
int read() {
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9') {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}

int w[maxn];
int v[maxn];
int s[maxn];
int dp[10005];
int q[maxn],p[maxn];
signed main() {
    int t;
    int n, c;
    cin >> n >> c;
    rep(i, 1, n) {
        cin >> v[i] >> w[i] >> s[i];
    }
    int len=1;
    for (int i = 1; i <= n; i++) {
        int z = 1;
        for (int j = 0; s[i] >(z<<j); s[i] -= (z<<j),j++ ) {

           q[len]=(z<<j)*v[i];
           p[len++]=(z<<j)*w[i];
        }
        q[len]=s[i]*v[i];
        p[len++]=s[i]*w[i];
    }
    for (int i = 1; i < len; i++) {
        for (int j = c; j >= q[i]; j--) {
            dp[j]=max(dp[j],dp[j-q[i]]+p[i]);
        }
    }
    cout << dp[c] << endl;
    return 0;
}

/***********************************************************************/

换个写法，效果一样：

#include<bits/stdc++.h>

using namespace std;
#define  int long long
#define rep(i, x, y) for(auto i=(x);i<=(y);++i)
#define dep(i, x, y) for(auto i=(x);i>=(y);--i)
#define gcd(a, b) __gcd(a,b)
const long long mod = 1e9 + 7;
const int maxn = 1e3 + 10;

int lowbit(int x) { return x & -x; }

bool ispow(int n) { return (n & (n - 1)) == 0; }//O(1) 判断是否是 2^k（2的k次方）
int read() {
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9') {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}

int w[maxn];
int v[maxn];
vector<int> a[100000];
int s[maxn];
int dp[100005];

signed main() {
    int t;
    int n, c;
    cin >> n >> c;
    rep(i, 1, n) {
        cin >> v[i] >> w[i] >> s[i];
    }
    for (int i = 1; i <= n; i++) {
        int z = 1;
        for (int j = 0; s[i] >= (z<<j); s[i] -=(z<<j) ,j++) {

           a[i].push_back((z<<j));

        }
        a[i].push_back(s[i]);
    }
    for (int i = 1; i <= n; i++) {
            int len = a[i].size();
            for (int k = 0; k < len; k++) {
                for (int j = c; j >= v[i]; j--)
                if (j - a[i][k] * v[i] >= 0)
                    dp[j] = max(dp[j], dp[j - a[i][k] * v[i]] + a[i][k] * w[i]);
            }
    }
    cout << dp[c] << endl;
    return 0;
}

如果遍历顺序不同，会产生另一种dp：
一种物品有n种取法，n种取法种只能取一次，产生的最大价值。

#include<bits/stdc++.h>

using namespace std;
#define  int long long
#define rep(i, x, y) for(auto i=(x);i<=(y);++i)
#define dep(i, x, y) for(auto i=(x);i>=(y);--i)
#define gcd(a, b) __gcd(a,b)
const long long mod = 1e9 + 7;
const int maxn = 1e3 + 10;

int lowbit(int x) { return x & -x; }

bool ispow(int n) { return (n & (n - 1)) == 0; }//O(1) 判断是否是 2^k（2的k次方）
int read() {
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9') {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}

int w[maxn];
int v[maxn];
vector<int> a[100000];
int s[maxn];
int dp[100005];

signed main() {
    int t;
    int n, c;
    cin >> n >> c;
    rep(i, 1, n) {
        cin >> v[i] >> w[i] >> s[i];
    }
    for (int i = 1; i <= n; i++) {
        int z = 1;
        for (int j = 0; s[i] >= (z<<j); s[i] -=(z<<j) ,j++) {

           a[i].push_back((z<<j));

        }
        a[i].push_back(s[i]);
    }
    for (int i = 1; i <= n; i++) {
            int len = a[i].size();
        for (int j = c; j >= v[i]; j--)
            for (int k = 0; k < len; k++) {

                if (j - a[i][k] * v[i] >= 0)
                    dp[j] = max(dp[j], dp[j - a[i][k] * v[i]] + a[i][k] * w[i]);
            }
    }
    cout << dp[c] << endl;
    return 0;
}

                ————————我是邪恶的分界线——————————————

题目链接

这一篇解释的可能更好——

背包九讲详解————真耐心的大佬
题意：一个数轴有n个村庄，有m个邮局建在村庄上，问如何建可使得每个村庄到最近的邮局距离之和最小。

思路：
设 d p [ i ] [ j ] dp[i][j] dp[i][j]表示前 i i i个村庄选 j j j个邮局的距离和最小值。（日常套路设法）
首先注意，我们选前i个村庄并不考虑后面村庄的影响。
推下状态方程，发现并不好推。

首先它肯定要从前 j − 1 j-1 j−1个推出。
前i个村庄选j-1个邮局选法有很多，需要全部遍历。
但我们还是发现并不好推这个东西，因为在添加新邮局时需要更新距离和最小，前面已经推出的 d p dp dp 状态转移到当前，值是不一样的，需要更新它。而这显然不合理的。
我们需要前面的状态转移到当前，前面的 d p dp dp 不需要经过加工，可以直接用。
那么我当前新加节点时， 在从前k个村庄j-1个邮局转移而来时，dp[k][j-1]不能进行变化，那么从k+1到i，我新加一个邮局，需要在这个段取得和值最小。怎么做？
中间加。证明很简单，自己去画一下就行了。
那么状态转移方程就是 d p [ i ] [ j ] = m i n ( d p [ i ] [ j ] , d p [ k ] [ j − 1 ] + X ) dp[i][j]=min(dp[i][j],dp[k][j-1]+X) dp[i][j]=min(dp[i][j],dp[k][j−1]+X)
其中 X X X就很有意思了，就是之前说的，在k+1☞i这个区间加一个邮局，得到的最小值和，那么怎么加？前面说过，加中间就行。
所以我们可以预处理出来。 d [ i ] [ j ] d[i][j] d[i][j] 表示从i到j加一个邮局距离和最小值。

    rep(i,1,n-1){
        rep(j,i+1,n){
            int z=(j+i)/2;
            for(int k=i;k<=j;k++){
                d[i][j]+=abs(a[k]-a[z]);
            }
        }
    }

初始状态为无穷大，dp[0][0] 为0。

  memset(dp,0x3f,sizeof(dp));
   dp[0][0]=0;

完整代码：

#include <bits/stdc++.h>

using namespace std;
#define  int long long
#define rep(i, x, y) for(int i=(x);i<=(y);++i)
#define dep(i, x, y) for(int i=(x);i>=(y);--i)
#define gcd(a, b) __gcd(a,b)
const int mod = 1e9 + 7;
const int maxn = 3e2 + 10;

int lowbit(int x) { return x & -x; }

bool ispow(int n) { return (n & (n - 1)) == 0; }//O(1) 判断是否是 2^k（2的k次方）
int read() {
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9') {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}
int dp[maxn][maxn];
int v[maxn],w[maxn];
vector<int>p[maxn];
int d[maxn][maxn];
int n, m;
int a[maxn];
signed main() {
    cin>>n>>m;
//    int root=0;
//    rep(i,1,n){
//        int s;cin>>s;
//        if(s==-1)root=i;
//        else
//        p[s].emplace_back(i);
//    }
    rep(i,1,n){
         cin>>a[i];
    }
    rep(i,1,n-1){
        rep(j,i+1,n){
            int z=(j+i)/2;
            for(int k=i;k<=j;k++){
                d[i][j]+=abs(a[k]-a[z]);
            }
        }
    }
    memset(dp,0x3f,sizeof(dp));
   dp[0][0]=0;

    for(int i=1;i<=n;i++){
        for(int j=1;j<=m&&j<=i;j++){
            for(int k=j-1;k<i;k++){
                dp[i][j]=min(dp[i][j],dp[k][j-1]+d[k+1][i]);
                 //cout<<dp[i][1]<<endl;
            }
        }
    }
    cout<<dp[n][m]<<endl;
    return 0;
}

分组背包问题：金明的预算
https://www.luogu.com.cn/problem/P1064
在这里插入图片描述
思路：简单分组背包，主件所带的附件不超过3个，那么组合方案数最多7个，60个物品，最多的组合数其实只有 60 × 7 4 \dfrac{60\times7}{4} 460×7​。组件和附件作为同一组，分组背包时间复杂度大约为 O ( n ∗ m ) O(n*m) O(n∗m)。

#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e5 + 10;
int dp[100][maxn];
struct  node{
    int v,w;
};
vector<node>s[maxn];
signed main() {
   // freopen("P1064_1.in","r",stdin);
    int n, m;
    cin >> n >> m;
    unordered_map<int,int >mp;
    int cnt = 1;
    for(int i = 1;i <= m; i++){
        int x,y,z ;
        cin>>x>>y>>z;
        if(z == 0){
            mp[i] = cnt;
            s[cnt++].emplace_back(node{x,y});
        }
        else {
            s[mp[z]].emplace_back(node{x,y});
        }
    }
    for(int i = 1;i < cnt;i++){
        int len = s[i].size();
        vector<node>S;
        S.clear();
        S.emplace_back(node{s[i][0].v,s[i][0].v*s[i][0].w});
        for(int j = 1;j < len;j++){
            S.emplace_back(node{s[i][j].v+s[i][0].v, s[i][j].v*s[i][j].w+s[i][0].w* s[i][0].v});
            for(int k = j + 1;k <len ;k++){
                S.emplace_back(node{s[i][j].v + s[i][0].v + s[i][k].v, s[i][j].v*s[i][j].w + s[i][0].v*s[i][0].w+ s[i][k].w*
                                                                                                                  s[i][k].v});
                for(int l = k + 1;l <len ;l ++){
                    S.emplace_back(node{s[i][j].v + s[i][0].v + s[i][k].v + s[i][l].v,
                                        s[i][j].v*s[i][j].w + s[i][0].v*s[i][0].w + s[i][k].v*s[i][k].w+ s[i][l].v*s[i][l].w});
                }
            }
        }
        s[i] = S;
    }
    for(int i = 1;i< cnt ;i++){
        for(int j = 1;j<= n ;j++){
            int len = s[i].size();
            for(int k = 0;k < len;k++){
                if(j >= s[i][k].v) {
                    dp[i][j] = max(dp[i][j], max(dp[i - 1][j], dp[i - 1][j - s[i][k].v] + s[i][k].w));
                 //   cout << dp[i][j] << endl;
                }
                else dp[i][j] = max(dp[i - 1][j],dp[i][j]);
            }
        }
    }
    cout<<dp[cnt - 1][n]<<endl;
    return 0;
}

上面的代码实在太冗长了，接下来就开始玩代码了，反正今天状态不佳，估计学不了什么了。
来试试重载运算符 + + +：
好样的，在我一番调试下，终于找到了正确的重载方式。
首先，物品价格可以直接重载，木有问题。
但是！，物品性价比如果直接相乘相加，那么两个物品相加木有问题，三个物品相加就会重复计数： s 1 + s 2 = v 1 ∗ w 1 + v 2 ∗ w 2 s_1+s_2=v_1*w_1+v_2*w_2 s1​+s2​=v1​∗w1​+v2​∗w2​
正确
s 1 + s 2 + s 3 = ( v 1 ∗ w 1 + v 2 ∗ w 2 ) × ( v 1 + v 2 ) + v 3 × w 3 s_1 +s_2+s_3=(v_1*w_1+v_2*w_2)\times(v_1+v_2)+v_3\times w_3 s1​+s2​+s3​=(v1​∗w1​+v2​∗w2​)×(v1​+v2​)+v3​×w3​
那么怎么重载呢？
就本身的性价比不变，再加上新来的就行了：
s 1 + s 2 + s 3 = v 1 ∗ w 1 + v 2 ∗ w 2 + v 3 × w 3 s_1 +s_2+s_3=v_1*w_1+v_2*w_2+v_3\times w_3 s1​+s2​+s3​=v1​∗w1​+v2​∗w2​+v3​×w3​
这样的话第一件物品就必须加的是性价比。
代码：

#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e5 + 10;
int dp[100][maxn];
struct  node{
    int v,w;
    node operator +(const node &p)const{
        return node{p.v + v,p.w* p.v + w };
    }
};
vector<node>s[maxn];
signed main() {
    int n, m;
    cin >> n >> m;
    unordered_map<int,int >mp;
    int cnt = 1;
    for(int i = 1;i <= m; i++){
        int x,y,z ;
        cin>>x>>y>>z;
        if(z == 0){
            mp[i] = cnt;
            s[cnt++].emplace_back(node{x,y * x});
        }
        else {
            s[mp[z]].emplace_back(node{x,y});
        }
    }
    for(int i = 1;i < cnt;i++){
        int len = s[i].size();
        vector<node>S;
        S.clear();
        S.emplace_back(node{s[i][0].v,s[i][0].w});
        for(int j = 1;j < len;j++){
            S.emplace_back(s[i][0] + s[i][j]);
            for(int k = j + 1;k <len ;k++){
                S.emplace_back(s[i][0]+ s[i][j]  + s[i][k]);
                for(int l = k + 1;l <len ;l ++){
                    S.emplace_back(s[i][0] + s[i][j] + s[i][l] + s[i][k]);
                }
            }
        }
        s[i] = S;
    }
    for(int i = 1;i< cnt ;i++){
        for(int j = 1;j<= n ;j++){
            int len = s[i].size();
            for(int k = 0;k < len;k++){
                if(j >= s[i][k].v) {
                    dp[i][j] = max(dp[i][j], max(dp[i - 1][j], dp[i - 1][j - s[i][k].v] + s[i][k].w));
                }
                else dp[i][j] = max(dp[i - 1][j],dp[i][j]);
            }
        }
    }
    cout<<dp[cnt - 1][n]<<endl;
    return 0;
}
Phantom_matter
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++动态规划详解
weixin_51951103的博客
09-11 1万+
动态规划思想 一、动态规划概念： 动态规划（dp）是研究多步决策过程最优化问题的一种数学方法。在动态规划中，为了寻找一个问题的最优解（即最优决策过程），将整个问题划分成若干个相应的阶段，并在每个阶段都根据先前所作出的决策作出当前阶段最优决策，进而得出整个问题的最优解。即记住已知问题的答案，在已知的答案的基础上解决未知的问题。 在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后
动态规划详解Python
qq_34184505的博客
06-28 5029
它通常用于优化问题，其中问题可以被分解成一系列重叠子问题，通过存储并重复使用已经解决过的子问题的解，可以避免重复计算，从而提高算法的效率。问题：有一个数组，求其中两个数x,y，满足x的索引小于y的索引，使得 x-y 最大。例如 arr = [3,7,2,6,4,1,9,8,5]， 最大回撤是6，对应的x=7,y=1。例如：arr = [1,5,-10,2,5,-3,2,6,-3,1]. 输出为：12。动态规划算法通常具有较高的时间复杂度，但通过存储已解决的子问题的解，可以大大减少重复计算，提高算法效率。
区间动态规划详解
u012679087的专栏
11-15 4915
前段时间遇到石子合并问题，看着题解A了，以为学会了区间DP，再次遇到能量项链这个问题的时候大脑还是一片空白，只能重新认识一下区间动态规划了。 翻过很多博客，基本上都是题解，真正对区间动态规划本身的讲解几乎没有，可能是我没找到吧。   区间动态规划，顾名思义，就是动态规划过程中求一个区间的最优解。通过将一个大的区间分为很多个小的区间，求其小区间的解，然后一个一个的组合成一个大的区间而得出最终解...
01背包问题——动态规划详解
qq_57205114的博客
02-17 2271
有N件物品和⼀个最多能被重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i]。每件物品只能⽤⼀次，求解将哪些物品装入背包⾥物品价值总和最⼤。 在题目中我们假设有三件物品 重量 价值 物品1 1 15 物品2 3 20 物品3 ...
python动态规划详解_动态规划详解（leetcode例题+解析）python
weixin_42131013的博客
01-29 552
动态规划详解(leetcode例题+解析)python一级目录例题+解析class Solution:def fib(self, N: int) -> int:for i in range(N+1):if i == 0:res = 0pre2 = 0elif i == 1:res = 1pre1 = 1else:res = pre1+pre2pre1, pre2 = res, pre1ret...
【算法分析】动态规划详解+范例+习题解答
weixin_50927106的博客
06-19 1379
递归算法求解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。这种性质称为子问题的重叠性质动态规划每次总是“自底向上”地求解问题，是否可能存在“多余求解”的情形？是给定n个矩阵｛A1A_1A1​,A2A_2A2​,…,AnA_nAn​｝，其中AiA_iAi​与Ai+1A_i+1Ai​+1是可乘的，i=1,2 ,…,n-1。如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。矩阵连乘计算次序问题的最优解包含着其子问题的最优解。这种性质称为最优子结构性质。 具体：计算
动态规划详解:清晰易懂
ROJS的博客
04-19 98
看一遍就理解：动态规划详解 - 云+社区 - 腾讯云 (tencent.com)
动态规划算法详解
热门推荐
m0_54615144的博客
07-27 2万+
动态规划算法通常用于求解具有最优性质的问题 基本概念 动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划(DP)。 基本思想与策略 基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。...
【动态规划】从入门到实践---动态规划详解
m0_57248981的博客
04-30 1283
1.动态规划概念 动态规划就是利用历史记录，来避免我们进行重复计算，而这些历史记录，我们需要用一些变量来保存，一般使用一维数组或者二维数组，下面我们来说动态规划最重要的三个步骤： 一.定义数组元素的含义 因为我们需要用一个数组来保存历史数据，那么最重要的来了，需要保存的历史数据是什么？ 也就是数组内存放的元素含义是什么？ 二.找到数组元素之间的关系表达式 也就是说，我们可以利用数组中保存的历史数据推理计算出来新的元素值，所以我们要找到数组之间元素的关系表达式，例如dp[n] = dp[n-1] + d
最大子矩阵动态规划详解.zip
02-24
最大子矩阵
算法导论之动态规划详解
11-26
动态规划学习笔记 // /经典问题/状态表示/状态转移方程 https://blog.csdn.net/weixin_37863080/article/details/103261838 和上文配套使用更佳
Java 7大排序
m0_74270127的博客
05-10 812
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
【算法】NOIP2003神经网络
littlegengjie的博客
05-13 591
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，Ui是阈值，可视为神经元的一个内在参数。然后根据拓扑排序一次遍历该图的所有点（例如便利到点1，会遍历所有以点1位直接前驱的点），遍历点1之后，3、4、5的状态均为1，遍历点2之后3、4、5均为2，将所有输出点的状态减去阈值，就为最终状态。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。
1080：余数相同问题
如果没有特别说明，c++都是基于GCC-4.9.2运行的
05-11 377
【代码】：1080：余数相同问题
找第二大的数（分治法）
2201_75525567的博客
05-11 301
这段代码通过递归的方式，将数组分为两半，并分别找出左半部分和右半部分的两个最大数，然后比较这四个数的大小，得到第二大的数。这段代码是用来找出数组中第二大的数的。
力扣阶段练习(1).消失的数字
2301_79475128的博客
05-11 840
恰好。这便是使用异或寻找缺失数的思路。
第33次CSP认证Q1：词频统计
XingziYY的博客
05-10 263
在学习了文本处理后，小 P 对英语书中的 𝑛n 篇文章进行了初步整理。具体来说，小 P 将所有的英文单词都转化为了整数编号。假设这 𝑛n 篇文章中共出现了 𝑚m 个不同的单词，则把它们从 11 到 𝑚m 进行编号。这样，每篇文章就简化为了一个整数序列，其中每个数都在 11 到 𝑚m 范围内。
零钱兑换动态规划详解
最新发布
05-16
零钱兑换问题是指给定一定数量的不同面额的硬币，以及一个需要兑换的金额，求出最少需要多少枚硬币才能凑成该金额。这是一道经典的动态规划问题，可以使用动态规划算法来解决。 具体来说，我们可以定义一个数组dp，其中dp[i]表示凑成金额i所需的最少硬币数。对于每个面额为coin的硬币，我们可以考虑将其加入凑成金额i的方案中，此时需要加入一枚硬币，所以此时需要的硬币数为dp[i-coin]+1。我们枚举所有可能的硬币面额，并选取其中最小的dp[i-coin]+1作为dp[i]的值。 最终，我们得到的dp[amount]即为凑成金额amount所需的最少硬币数。如果dp[amount]的值没有被更新过，则说明无法凑成该金额。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值