背包型动态规划

已于 2024-03-01 11:51:36 修改
阅读量104 收藏
点赞数
文章标签： 动态规划 算法
于 2023-02-21 13:31:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43355838/article/details/129138603
版权

01背包

不带价值的01背包，求最优解

92. 背包问题
解法1：背包型DP

class Solution {
public:
    int backPack(int m, vector<int> &a) {
        int n = a.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= a[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i - 1][j - a[i - 1]] + a[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPack(int m, vector<int> &a) {
        int n = a.size();

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0 to m] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = m; j >= a[i]; --j) {
                dp[j] = max(dp[j], dp[j - a[i]] + a[i]);
            }
        }

        // answer
        return dp[m];
    }
};
不带价值的01背包，求方案数

563. 背包问题 V
解法1：背包型DP

class Solution {
public:
    int backPackV(vector<int> &nums, int target) {
        int n = nums.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(target + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to target] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= target; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] + 
                        dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][target];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPackV(vector<int> &nums, int target) {
        int n = nums.size();

        // state
        vector<int> dp(target + 1);

        // initial
        dp[0] = 1;
        // dp[1 to target] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = target; j >= nums[i]; --j) {
                dp[j] += dp[j - nums[i]];
            }
        }

        // answer
        return dp[target];
    }
};
带价值的01背包，求最优解

125. 背包问题 II
解法1：背包型DP

class Solution {
public:
    int backPackII(int m, vector<int> &a, vector<int> &v) {
        int n = a.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= a[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i - 1][j - a[i - 1]] + v[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPackII(int m, vector<int> &a, vector<int> &v) {
        int n = a.size();

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0 to m] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = m; j >= a[i]; --j) {
                dp[j] = max(dp[j], dp[j - a[i]] + v[i]);
            }
        }

        // answer
        return dp[m];
    }
};
分割等和子集

416. 分割等和子集
解法1：背包型DP

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2) {
            return false;
        }
        int m = sum / 2;
        
        // state
        vector<vector<bool>> dp(n + 1, vector<bool>(m + 1));

        // initial
        dp[0][0] = true;
        // dp[0][1 to m] = false;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] ||
                        dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2) {
            return false;
        }
        int m = sum / 2;
        
        // state
        vector<bool> dp(m + 1);

        // initial
        dp[0] = true;
        // dp[1 to m] = false;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= nums[i - 1]; --j) {
                dp[j] = dp[j] || dp[j - nums[i - 1]];
            }
        }

        // answer
        return dp[m];
    }
};
最后一块石头的重量 II

1049. 最后一块石头的重量 II
解法1：背包型DP

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size();
        int sum = accumulate(stones.begin(), stones.end(), 0);
        int m = sum / 2;

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= stones[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i - 1][j - stones[i - 1]] + stones[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return sum - 2 * dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size();
        int sum = accumulate(stones.begin(), stones.end(), 0);
        int m = sum / 2;

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= stones[i - 1]; --j) {
                dp[j] = max(dp[j],
                    dp[j - stones[i - 1]] + stones[i - 1]);
            }
        }

        // answer
        return sum - 2 * dp[m];
    }
};
目标和

494. 目标和
解法1：DFS

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int count = 0;
        dfs(nums, target, 0, count);
        return count;
    }

    void dfs(
        vector<int>& vec, int sum,
        int start, int& count
    ) {
        if (start == vec.size()) {
            if (sum == 0) {
                ++count;
            }
            return;
        }
        dfs(vec, sum - vec[start], start + 1, count);
        dfs(vec, sum + vec[start], start + 1, count);
    }
};

解法2：背包型DP

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (abs(target) > sum) {
            return 0;
        }
        if ((target + sum) % 2) {
            return 0;
        }
        int m = (target + sum) / 2;

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] +
                        dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法3：背包型DP+滚动数组

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (abs(target) > sum) {
            return 0;
        }
        if ((target + sum) % 2) {
            return 0;
        }
        int m = (target + sum) / 2;

        // state
        vector<int> dp(m + 1);

        // initial
        dp[0] = 1;
        // dp[1 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= nums[i - 1]; --j) {
                dp[j] += dp[j - nums[i - 1]];
            }
        }

        // answer
        return dp[m];
    }
};
一和零

474. 一和零
解法1：背包型DP+滚动数组

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        // state
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        
        // initial
        // dp[0 to m][0] = 0, dp[0][0 to n] = 0;

        for (const auto& s: strs) {
            int n0 = 0, n1 = 0;
            for (const char& c: s) {
                if (c == '0') {
                    ++n0;
                }
                if (c == '1') {
                    ++n1;
                }
            }
            // function
            for (int i = m; i >= n0; --i) {
                for (int j = n; j >= n1; --j) {
                    dp[i][j] = max(dp[i][j],
                        dp[i - n0][j - n1] + 1);
                }
            }
        }

        // answer
        return dp[m][n];
    }
};

完全背包

不带价值的完全背包，求方案数

562. 背包问题 IV
解法1：背包型DP

class Solution {
public:
    int backPackIV(vector<int> &nums, int target) {
        int n = nums.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(target + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to target] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= target; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] +
                        dp[i][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][target];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPackIV(vector<int> &nums, int target) {
        int n = nums.size();

        // state
        vector<int> dp(target + 1);

        // initial
        dp[0] = 1;
        // dp[1 to target] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = nums[i]; j <= target; ++j) {
                dp[j] += dp[j - nums[i]];
            }
        }

        // answer
        return dp[target];
    }
};
带价值的完全背包，求最优解

440. 背包问题 III
解法1：背包型DP

class Solution {
public:
    int backPackIII(vector<int> &a, vector<int> &v, int m) {
        int n = a.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= a[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i][j - a[i - 1]] + v[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPackIII(vector<int> &a, vector<int> &v, int m) {
        int n = a.size();

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = a[i]; j <= m; ++j) {
                dp[j] = max(dp[j], dp[j - a[i]] + v[i]);
            }
        }

        // answer
        return dp[m];
    }
};
零钱兑换 II

518. 零钱兑换 II
解法1：背包型DP

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to amount] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= amount; ++j) {
                if (j >= coins[i - 1]) {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][amount];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();

        // state
        vector<int> dp(amount + 1);

        // initial
        dp[0] = 1;
        // dp[1 to amount] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = coins[i]; j <= amount; ++j) {
                dp[j] += dp[j - coins[i]];
            }
        }

        // answer
        return dp[amount];
    }
};
377. 组合总和 IV

377. 组合总和 IV
解法1：背包型DP

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        int n = nums.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(target + 1));

        // initial
        for (int i = 0; i <= n; ++i) {
            dp[i][0] = 1;
        }

        // function
        for (int j = 1; j <= target; ++j) {
            for (int i = 1; i <= n; ++i) {
                for (int k = i; k > 0; --k) {
                    if (j >= nums[k - 1] &&
                        dp[i][j] < INT_MAX - dp[i][j - nums[k - 1]]) {
                        dp[i][j] += dp[i][j - nums[k - 1]];
                    }
                }
            }
        }

        // answer
        return dp[n][target];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        int n = nums.size();

        // state
        vector<int> dp(target + 1);

        // initial
        dp[0] = 1;
        // dp[1 to target] = 0;

        // function
        for (int j = 0; j <= target; ++j) {
            for (int i = 0; i < n; ++i) {
                if (j >= nums[i] &&
                    dp[j] < INT_MAX - dp[j - nums[i]]) {
                    dp[j] += dp[j - nums[i]];
                }
            }
        }

        // answer
        return dp[target];
    }
};
爬楼梯

70. 爬楼梯
解法1：坐标型DP

class Solution {
public:
    int climbStairs(int n) {
        // state
        vector<int> dp(n + 1);

        // initial
        dp[0] = dp[1] = 1;

        // function
        for (int i = 2; i <= n; ++i) {
            dp[i] = dp[i - 2] + dp[i - 1];
        }
        
        // answer
        return dp[n];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int climbStairs(int n) {
        // state
        vector<int> dp(n + 1);

        // initial
        dp[0] = 1;

        // function
        for (int j = 1; j <= n; ++j) {
            for (int i = 1; i <= 2; ++i) {
                if (j >= i) {
                    dp[j] += dp[j - i];
                }
            }
        }

        // answer
        return dp[n];
    }
};
零钱兑换

322. 零钱兑换
解法1：背包型DP

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int n = coins.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));

        // initial
        fill(dp[0].begin(), dp[0].end(), INT_MAX);
        dp[0][0] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= amount; ++j) {
                if (j >= coins[i - 1] &&
                    dp[i][j - coins[i - 1]] < INT_MAX) {
                    if (dp[i - 1][j] < INT_MAX) {
                        dp[i][j] = min(dp[i - 1][j],
                            dp[i][j - coins[i - 1]] + 1);
                    } else {
                        dp[i][j] = dp[i][j - coins[i - 1]] + 1;
                    }
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][amount] == INT_MAX ? -1 : dp[n][amount];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int n = coins.size();

        // state
        vector<int> dp(amount + 1, INT_MAX);

        // initial
        dp[0] = 0;
        // dp[1 to amount] = INT_MAX;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = coins[i]; j <= amount; ++j) {
                if (dp[j - coins[i]] < INT_MAX) {
                    dp[j] = min(dp[j], dp[j - coins[i]] + 1);
                }
            }
        }

        // answer
        return dp[amount] == INT_MAX ? -1 : dp[amount];
    }
};
完全平方数

279. 完全平方数
解法1：背包型DP

class Solution {
public:
    int numSquares(int n) {
        // state
        vector<vector<int>> dp(n + 1, vector<int>(n + 1));

        // initial
        fill(dp[0].begin(), dp[0].end(), INT_MAX);
        dp[0][0] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= n; ++j) {
                if (j >= i * i) {
                    dp[i][j] = min(dp[i - 1][j],
                        dp[i][j - i * i] + 1);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][n];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int numSquares(int n) {
        // state
        vector<int> dp(n + 1, INT_MAX);

        // initial
        dp[0] = 0;
        // dp[1 to n] = INT_MAX;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = i * i; j <= n; ++j) {
                dp[j] = min(dp[j], dp[j - i * i] + 1);
            }
        }

        // answer
        return dp[n];
    }
};
koukouvagia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
背包型动态规划——背包问题1
sinat_40875078的博客
02-04 234
在n个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为A[i] 示例： 样例 1: 输入: [3,4,8,5], backpack size=10 输出: 9 样例 2: 输入: [2,3,5,7], backpack size=12 输出: 12 1、题目分析 首先要明确一点，在背包问题中，数组大小和总称重有关。 给定N个物品，重量分别为正整数A0, A1, …, AN-1。一个背包最大承重是M，物品的重量都是整数。每个装物品的方案的总重量都是0到M。如.
(01背包型动态规划+三维状态数组)lintcode中等668 · 一和零
weixin_46035615的博客
03-26 680
01背包型动态规划+三维状态数组
【算法】动态规划 ④ ( 动态规划分类 | 坐标型动态规划 | 前缀划分型动态规划 | 前缀匹配型动态规划 | 区间型动态规划 | 背包型动态规划 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-10 1098
一、动态规划场景、 二、动态规划分类、 1、坐标型动态规划、 2、前缀划分型动态规划、 3、前缀匹配型动态规划、 4、区间型动态规划、 5、背包型动态规划、
背包型动态规划——背包问题5
sinat_40875078的博客
02-04 156
给出 n 个物品, 以及一个数组, nums[i] 代表第i个物品的大小, 保证大小均为正数, 正整数 target 表示背包的大小, 找到能填满背包的方案数。 每一个物品只能使用一次 给出候选物品集合 [1,2,3,3,7] 以及 target 7 结果的集合为: [7] [1,3,3] 返回 2 1、题目分析 从题目的提问方式可以看出是属于典型的计数类型的动态规划。 2、确定状态 需要知道N个物品有多少种方式拼出重量W (W =0, 1, …, Target) 最后一步：第N个物品（重量AN-1 ）.
背包型动态规划——背包问题3
sinat_40875078的博客
02-04 169
给定 n 种物品, 每种物品都有无限个. 第 i 个物品的体积为 A[i], 价值为 V[i]. 再给定一个容量为 m 的背包. 问可以装入背包的最大价值是多少? 样例 1: 输入: A = [2, 3, 5, 7], V = [1, 5, 2, 4], m = 10 输出: 15 解释: 装入三个物品 1 (A[1] = 3, V[1] = 5), 总价值 15. 样例 2: 输入: A = [1, 2, 3], V = [1, 2, 3], m = 5 输出: 5 解释: 策略不唯一. 比如, 装入.
(背包型动态规划)lintcode92背包问题
weixin_46035615的博客
03-19 536
背包型动态规划
(01背包型动态规划)lintcode125背包问题（二）
weixin_46035615的博客
03-20 378
01背包型动态规划
背包型动态规划：整数划分
少儿编程乔老师
12-02 941
背包型动态规划：整数划分
(完全背包型动态规划)lintcode440 · 背包问题 III
weixin_46035615的博客
03-21 109
完全背包问题
改进动态规划跳跃点之0-1背包问题python实现
03-12
这个是动态规划之跳跃点0-1背包问题，如果只是想要动态规划0-1背包问题求解代码，请到主页查看。18级学姐自主完成的算法作业，呕心沥血，基于四舍五入等于0基础的python实现，如果在语言规范上存在不足，那就。就憋...
基于动态规划方法改进0-1背包问题.docx
06-03
【基于动态规划方法改进0-1背包问题】 0-1背包问题是一个经典的组合优化问题，其基本形式是：给定一组物品，每种物品都有一个重量和一个价值，目标是在不超过背包容量的前提下，选择物品使得总价值最大。在这个问题...
运筹学第七章：动态规划.pdf
11-23
这一章主要讨论了离散确定型的动态规划模型，这是最基础的形式，但其核心思想和原则同样适用于其他类型的动态规划问题。 首先，理解动态规划的关键在于掌握多阶段决策过程的最优化。在这样的过程中，每一阶段都需要...
基于动态规划的0-1背包问题的解决.docx
06-03
0-1背包问题的动态规划解决方案通常包含以下几个步骤： 1. **问题描述**： 我们需要确定在不超过背包容量W的情况下，如何从n个物品中选择，使得总价值最大。物品的价值和重量分别为v[i]和w[i]，i表示物品的编号。...
各种动态规划
07-19
合并类型动态规划，树形动态规划，线型动态规划，资源背包动态规划，坐标型动态规划。
多目标跟踪 (MOT) 算法简介
最新发布
weixin_41446370的博客
06-18 212
多目标跟踪 (MOT) 是一项计算机视觉任务，旨在识别和跟踪视频序列中的多个目标。与单目标跟踪不同，MOT 需处理多个目标的相互遮挡、消失和重新出现等复杂情况。
CF Round 944 （div.4）ABCDEFG
zaqjkl的博客
06-11 535
能够发生交换的ai和aj已经进行了限定只有ai XOR aj < 4之间的元素间可以交换，ai XOR aj < 4代表ai和aj二进制位只有后两位不同其他位相同，可以把只有后两位不同的数看成一个种类，无论数组中元素交换到什么位置，相互交换都只发生在同一种类中，所以只需要所有元素在输出时按要求分好种类，再在每个种类内部进行排序，输出时根据原本位置上数所属的种类依次从小到大输出对应种类内部排好序的元素即可。一种可行的解答方案是：枚举x(1<=x<=r)的值根据条件的变式。模板：是否是完全平方数。
算法笔记(二叉树1)
weixin_64704029的博客
06-18 97
二叉树刷题
网络空间安全数学基础·期末复习
Yhan涵涵
06-11 602
1.最大公因子性质：(0,a)=a2.最大公因子求解（欧几里得算法、辗转相除法）例：(-3824，1837)3.最大公因子定理：设a，b是两个不全为零的整数，则存在两个整数u, v，使得：(a, b)=ua+vb。例：将a = 888，b = 312的最大公因子表示为(a,b) = ua+vb。4.最小公倍数性质：，特别地，如果(a, b) = 1, [a, b] = |ab|。5.算术基本定理：定理：每个大于1的整数a都可以分解为有限个素数的乘积：a=p1p2…pr。
背包问题np完全和动态规划矛盾吗
05-12
不完全矛盾。背包问题是一个经典的动态规划问题，可以使用动态规划算法来解决。但是，背包问题是一个NP完全问题，这意味着在一定的时间内，无法找到一个多项式时间的算法来解决它，除非P=NP。因此，即使使用动态规划算法，对于大型的背包问题，仍然需要指数级的时间来解决，因此在实际应用中可能需要使用启发式算法等其他技术来解决。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值