01背包 HDU2602

挺想哭的调试了好久都没用,结果是int的问题。。。

Problem Description

Many years ago , in Teddy’s hometown there was a man who was called “Bone Collector”. This man like to collect varies of bones , such as dog’s , cow’s , also he went to the grave …
The bone collector had a big bag with a volume of V ,and along his trip of collecting there are a lot of bones , obviously , different bone has different value and different volume, now given the each bone’s value along his trip , can you calculate out the maximum of the total value the bone collector can get ?

Input

The first line contain a integer T , the number of cases.
Followed by T cases , each case three lines , the first line contain two integer N , V, (N <= 1000 , V <= 1000 )representing the number of bones and the volume of his bag. And the second line contain N integers representing the value of each bone. The third line contain N integers representing the volume of each bone.

Output

One integer per line representing the maximum of the total value (this number will be less than 231).

Sample Input

1
5 10
1 2 3 4 5
5 4 3 2 1

Sample Output

14

#include<iostream>
#include<stdio.h>
#include<memory.h>
using namespace std;
int mon[1003],w[1003];
int f[1001]={0};
int max(int x,int y)
{
        if(x>y)
                return x;
        else
                return y;
}
int main()
{
        int n,v,i,j,k;
        int t;
        cin>>t;
        for( k=0;k<t;k++)
        {
                memset(f,0,sizeof(f));
                cin>>n>>v;
                for(i=0;i<n;i++)
                {
                        cin>>mon[i];
                }
                 for(i=0;i<n;i++)
                {
                        cin>>w[i];
                }
                //for(i=0;i<n;i++)
                // {
                //         cout<<mon[i]<<w[i];
                // }
                for(i=0;i<n;i++)
                {
                        for(j=v;j>=w[i];j--)
                        {
                              f[j]=max(f[j],f[j-w[i]]+mon[i]);
                              //cout<<f[v]<<endl;
                        }
                }
                cout<<f[v]<<endl;
        }
        /*for(i=0;i<t;i++)
        {
                cout<<a[i]<<endl;
        }*/
        return 0;
}
### HDU 2602 骨头收藏家 解题思路及代码实现 #### 完全背包问题 HDU 2602 是一个典型的完全背包问题,目标是通过选择若干骨头使得总价值最大[^5]。定义 `dp[i]` 表示容量为 `i` 的背包所能装下的最大价值。 #### 状态转移方程 对于每个骨头 `j`,更新状态转移方程: ```cpp dp[v] = max(dp[v], dp[v - cost[j]] + value[j]); ``` 其中,`cost[j]` 和 `value[j]` 分别表示第 `j` 块骨头的体积和价值。 #### 时间复杂度分析 - 外层循环遍历所有骨头,内层循环遍历背包容量。 - 总体时间复杂度为 \(O(n \cdot V)\),其中 \(n\) 为骨头数量,\(V\) 为背包容量。 ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX_V = 1001; int dp[MAX_V]; int main() { int T; cin >> T; while (T--) { int n, V; cin >> n >> V; vector<int> value(n), cost(n); for (int i = 0; i < n; ++i) cin >> value[i]; for (int i = 0; i < n; ++i) cin >> cost[i]; fill(dp, dp + V + 1, 0); for (int i = 0; i < n; ++i) { for (int v = cost[i]; v <= V; ++v) { dp[v] = max(dp[v], dp[v - cost[i]] + value[i]); } } cout << dp[V] << endl; } return 0; } ``` --- ### HDU 1159 一行空间复杂度求最长公共子序列最优值 #### 动态规划优化 HDU 1159 要求计算两个字符串的最长公共子序列长度,并且需要优化空间复杂度为 \(O(\min(m, n))\)。使用一维数组 `dp` 来存储当前行的状态[^3]。 #### 状态转移方程 当 `str1[i-1] == str2[j-1]` 时: ```cpp dp[j] = pre + 1; ``` 否则: ```cpp dp[j] = max(dp[j], dp[j - 1]); ``` 其中,`pre` 表示上一行的状态。 #### 时间复杂度分析 - 外层循环遍历字符串 `str1`,内层循环遍历字符串 `str2`。 - 总体时间复杂度为 \(O(m \cdot n)\),空间复杂度为 \(O(\min(m, n))\)。 ```cpp #include <iostream> #include <string> #include <vector> #include <algorithm> using namespace std; int main() { string str1, str2; while (cin >> str1 >> str2) { int m = str1.size(), n = str2.size(); if (m > n) swap(str1, str2), swap(m, n); vector<int> dp(n + 1, 0); for (int i = 1; i <= m; ++i) { int pre = 0; for (int j = 1; j <= n; ++j) { int temp = dp[j]; if (str1[i - 1] == str2[j - 1]) { dp[j] = pre + 1; } else { dp[j] = max(dp[j], dp[j - 1]); } pre = temp; } } cout << dp[n] << endl; } return 0; } ``` --- ### HDU 2159 完全背包问题 解题思路及代码实现 #### 完全背包变形 HDU 2159 是一个完全背包问题的变形,要求在给定预算下购买物品的最大满意度。与 HDU 2602 类似,但需要注意物品的数量限制。 #### 状态转移方程 对于每种物品,更新状态转移方程: ```cpp dp[v] = max(dp[v], dp[v - k * cost[i]] + k * value[i]); ``` 其中,`k` 表示当前物品的数量。 #### 时间复杂度分析 - 外层循环遍历所有物品,内层循环遍历背包容量和物品数量。 - 总体时间复杂度为 \(O(n \cdot V \cdot c)\),其中 \(c\) 为物品的最大数量。 ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX_V = 10001; int dp[MAX_V]; int main() { int T; cin >> T; while (T--) { int n, V; cin >> n >> V; vector<int> value(n), cost(n), num(n); for (int i = 0; i < n; ++i) cin >> value[i]; for (int i = 0; i < n; ++i) cin >> cost[i]; for (int i = 0; i < n; ++i) cin >> num[i]; fill(dp, dp + V + 1, 0); for (int i = 0; i < n; ++i) { for (int v = V; v >= cost[i]; --v) { for (int k = 1; k <= num[i] && k * cost[i] <= v; ++k) { dp[v] = max(dp[v], dp[v - k * cost[i]] + k * value[i]); } } } cout << dp[V] << endl; } return 0; } ``` --- ### HDU 3506 环形石子合并 解题思路及代码实现 #### 区间动态规划 HDU 3506 是一个环形石子合并问题,目标是找到合并石子的最小和最大得分。将环形问题转化为线性问题,枚举断点并计算区间和。 #### 状态转移方程 定义 `sum[i][j]` 表示从 `i` 到 `j` 的石子总和,`dp_min[i][j]` 和 `dp_max[i][j]` 分别表示从 `i` 到 `j` 的最小和最大得分: ```cpp dp_min[i][j] = min(dp_min[i][k] + dp_min[k + 1][j] + sum[i][j]); dp_max[i][j] = max(dp_max[i][k] + dp_max[k + 1][j] + sum[i][j]); ``` #### 时间复杂度分析 - 三重循环遍历所有区间,总体时间复杂度为 \(O(n^3)\)。 ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX_N = 201; int sum[2 * MAX_N], dp_min[2 * MAX_N][2 * MAX_N], dp_max[2 * MAX_N][2 * MAX_N]; int main() { int T; cin >> T; while (T--) { int n; cin >> n; for (int i = 1; i <= n; ++i) { cin >> sum[i]; sum[i + n] = sum[i]; } for (int i = 1; i <= 2 * n; ++i) { sum[i] += sum[i - 1]; dp_min[i][i] = dp_max[i][i] = 0; } for (int len = 2; len <= n; ++len) { for (int i = 1; i + len - 1 <= 2 * n; ++i) { int j = i + len - 1; dp_min[i][j] = INT32_MAX; dp_max[i][j] = 0; for (int k = i; k < j; ++k) { dp_min[i][j] = min(dp_min[i][j], dp_min[i][k] + dp_min[k + 1][j] + sum[j] - sum[i - 1]); dp_max[i][j] = max(dp_max[i][j], dp_max[i][k] + dp_max[k + 1][j] + sum[j] - sum[i - 1]); } } } int res_min = INT32_MAX, res_max = 0; for (int i = 1; i <= n; ++i) { res_min = min(res_min, dp_min[i][i + n - 1]); res_max = max(res_max, dp_max[i][i + n - 1]); } cout << res_min << " " << res_max << endl; } return 0; } ``` --- ### HDU 2196 Computer 解题思路及代码实现 #### 并查集方法 HDU 2196 是一个网络连通性问题,可以通过并查集解决。每次连接两台计算机后,检查是否形成环。 #### 时间复杂度分析 - 并查集操作的时间复杂度接近 \(O(\alpha(n))\),其中 \(\alpha\) 为反阿克曼函数。 - 总体时间复杂度为 \(O(m \cdot \alpha(n))\)。 ```cpp #include <iostream> #include <vector> using namespace std; class UnionFind { public: vector<int> parent; UnionFind(int n) : parent(n + 1) { for (int i = 0; i <= n; ++i) parent[i] = i; } int find(int x) { if (parent[x] != x) parent[x] = find(parent[x]); return parent[x]; } void unite(int x, int y) { int rootX = find(x), rootY = find(y); if (rootX != rootY) parent[rootX] = rootY; } }; int main() { int n; cin >> n; UnionFind uf(n); int m; cin >> m; while (m--) { int u, v; cin >> u >> v; int rootU = uf.find(u), rootV = uf.find(v); if (rootU == rootV) cout << "YES" << endl; else { cout << "NO" << endl; uf.unite(u, v); } } return 0; } ``` --- ### HDU 4539 炮兵阵地 解题思路及代码实现 #### 状态压缩动态规划 HDU 4539 是一个状态压缩动态规划问题,目标是在地图上放置炮兵以最大化数量。将每一行的状态用二进制表示,并预处理合法状态。 #### 时间复杂度分析 - 预处理合法状态的时间复杂度为 \(O(2^n)\)。 - 动态规划的时间复杂度为 \(O(m \cdot 2^{2n})\)。 ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; const int MAX_M = 101, MAX_S = 1 << 10; int dp[MAX_M][MAX_S]; vector<int> states; vector<string> map_data; bool isValid(int s, const string &row) { for (int i = 0; i < row.size(); ++i) { if ((s >> i) & 1 && row[i] != '.') return false; if (((s >> i) & 1) && ((s >> (i - 1)) & 1 || (s >> (i + 1)) & 1)) return false; } return true; } int main() { int m, n; cin >> m >> n; map_data.resize(m); for (int i = 0; i < m; ++i) cin >> map_data[i]; for (int s = 0; s < (1 << n); ++s) { if (isValid(s, map_data[0])) states.push_back(s); } fill(&dp[0][0], &dp[0][0] + MAX_M * MAX_S, 0); for (int i = 0; i < states.size(); ++i) dp[0][states[i]] = __builtin_popcount(states[i]); for (int r = 1; r < m; ++r) { for (int i = 0; i < states.size(); ++i) { int s = states[i]; if (!isValid(s, map_data[r])) continue; dp[r][s] = __builtin_popcount(s); for (int j = 0; j < states.size(); ++j) { int ps = states[j]; if (!(s & ps) && !(s & (ps >> 1)) && !((s >> 1) & ps)) { dp[r][s] = max(dp[r][s], dp[r - 1][ps] + __builtin_popcount(s)); } } } } int res = 0; for (int s = 0; s < (1 << n); ++s) res = max(res, dp[m - 1][s]); cout << res << endl; return 0; } ``` --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值