背包问题复习

本文详细解析了背包问题及最长公共子序列(LCS)问题的解决方法,通过记忆化搜索和动态规划实现高效求解,并附带完整代码示例。

背包问题复习

vijos 1025

想法:记忆化搜索,或者动态规划都行,基础题。
code

#include<iostream>
#include<memory.h>
using namespace std;
int n,size;
int value[105],bag[105];
int record[105][1500];
int search(int count,int rest){
    if(count==n){
        return 0;
    }
    else if(rest-bag[count]<0){
        record[count][rest]=search(count+1,rest);
    }
    if(record[count][rest]<0){
        record[count][rest]=max(search(count+1,rest),search(count+1,rest-bag[count])+value[count]);
    }
    return record[count][rest];
}
int main(void){
    memset(record,-1,sizeof(record));
    cin>>n>>size;
    for(int i=0;i<n;i++){
        cin>>value[i]>>bag[i];
    }
    cout<<search(0,size)<<endl;
}

vijos 1111

想法:其实这是一个LCS的问题(longest common subsequence)最长公共子序列问题。嗯就是按顺序从两个字串中取字符可以跳着取,然后看二者中最长的公共部分最长是多少。可以这么想,现在我手上比较到了s,t字串,s字串长度为i,t字串长度为j,那么如果s[i+1]==t[j+1],那么很明显对于各加一个字符的长度的两个字串公共部分长度就是原来的+1,那如果没有相同呢,那么肯定就是s(i)&t(j+1) or s(i+1)(j)二者中较大的那个。然后接着向下递推,直到进行完所有的字串,复杂度为o(n*m),其实突然感觉动态规划的思路有点像数学归纳法诶=。=
code

#include <iostream>
#include <memory.h>
using namespace std;
int dp[105][105];
int main(void){
    string a,b;
    while(cin>>a){
        cin>>b;
        memset(dp,0,sizeof(dp));
        for(int i=0;i<a.size();i++){
            for(int j=0;j<b.size();j++){
                if(a[i]==b[j]){
                    dp[i+1][j+1]=dp[i][j]+1;
                }
                else{
                    dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
                }
            }
        }
        cout<<a.size()+b.size()-dp[a.size()][b.size()]<<endl;
    }
}

完全背包

**其实就是第一种的增强版啦,但是如果还是照着第一种的思路写会写出3个for循环,但是如果仔细想的话会出现重复运算。也就是每次都让其加上k倍的该包的重量,那么下次如果遇到加到该大小的时候直接应用上次的数据就行了。。。

#include <iostream>
#include <memory.h>
using namespace std;
int dp[1000][1000];
int main(void){
    int n,size;
    int bag[1000],value[1000];
    cin>>n>>size;
    for(int i=0;i<n;i++){
        cin>>bag[i]>>value[i];
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<=size;j++){
            if(j<bag[i]){
                dp[i+1][j]=dp[i][j];
            }
            else{
                dp[i+1][j]=max(dp[i][j],dp[i+1][j-bag[i]]+value[i]);
            }
        }
    }
    cout<<dp[n][size];
}
### 背包问题的记忆化搜索实现 背包问题是经典的动态规划问题之一,可以通过记忆化搜索来优化递归解决方案。以下是基于 Python 的背包问题记忆化搜索实现及其解释。 #### 记忆化搜索的核心概念 记忆化搜索结合了递归和动态规划的思想,在解决问题的过程中记录已计算的结果以避免重复计算。这种方法可以显著提高效率,尤其是在子问题重叠的情况下[^2]。 #### 0/1 背包问题描述 假设有一个容量为 `W` 的背包和若干物品,每个物品具有重量 `w[i]` 和价值 `v[i]`。目标是在不超过背包容量的前提下最大化总价值。 #### 记忆化搜索实现 下面是一个使用记忆化搜索解决 0/1 背包问题的 Python 实现: ```python def knapsack_memoization(W, weights, values): n = len(weights) # 创建一个二维数组用于存储中间结果,初始化为 None memo = [[None for _ in range(W + 1)] for _ in range(n)] def dp(i, w): if i < 0 or w <= 0: # 边界条件:没有物品或者背包容量为零 return 0 if memo[i][w] is not None: # 如果已经计算过当前状态,则直接返回 return memo[i][w] if weights[i] > w: # 当前物品无法放入背包 result = dp(i - 1, w) else: # 取最大值:不选当前物品 vs 选择当前物品 result = max(dp(i - 1, w), values[i] + dp(i - 1, w - weights[i])) memo[i][w] = result # 将结果保存到备忘录中 return result return dp(n - 1, W) # 测试数据 weights = [2, 3, 4, 5] values = [3, 4, 5, 6] capacity = 5 max_value = knapsack_memoization(capacity, weights, values) print(f"Maximum value that can be obtained: {max_value}") ``` #### 关键点分析 1. **边界条件** 当索引 `i` 或者剩余容量 `w` 不满足继续处理的要求时,直接返回 0。 2. **状态转移方程** 对于第 `i` 个物品,有两种可能的选择: - 不选取该物品:`dp(i-1, w)`; - 选取该物品:`values[i] + dp(i-1, w-weights[i])`。 结果取两者中的较大值。 3. **记忆化存储** 使用二维列表 `memo` 存储 `(i, w)` 状态下的最优解,避免重复计算相同的子问题[^5]。 #### 时间复杂度与空间复杂度 时间复杂度为 \(O(n \times W)\),其中 \(n\) 是物品数量,\(W\) 是背包的最大容量。这是因为每种状态最多只会被计算一次并存储下来。空间复杂度同样为 \(O(n \times W)\)。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值