###
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;
}
```
---
###
本文探讨了一道关于树形结构中寻找特定点集的问题，采用DFS算法进行遍历，并通过调整枚举策略来减少重复计算，最终给出了正确的实现代码。
扫一扫
588
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
