题目## 题目
解题思路
-
问题分析：
- 需要多次查询矩阵子区域的和
- 直接累加会导致时间复杂度 O ( n ∗ m ∗ q ) \mathcal{O}(n*m*q) O(n∗m∗q)
- 可以使用二维前缀和优化到 O ( n ∗ m + q ) \mathcal{O}(n*m + q) O(n∗m+q)
-
二维前缀和优化：
- 预处理矩阵，计算二维前缀和
- 对于查询
(
x
1
,
y
1
,
x
2
,
y
2
)
(x1,y1,x2,y2)
(x1,y1,x2,y2)，结果为：
p r e f i x [ x 2 ] [ y 2 ] − p r e f i x [ x 1 − 1 ] [ y 2 ] − p r e f i x [ x 2 ] [ y 1 − 1 ] + p r e f i x [ x 1 − 1 ] [ y 1 − 1 ] prefix[x2][y2] - prefix[x1-1][y2] - prefix[x2][y1-1] + prefix[x1-1][y1-1] prefix[x2][y2]−prefix[x1−1][y2]−prefix[x2][y1−1]+prefix[x1−1][y1−1] - 预处理时间 O ( n ∗ m ) \mathcal{O}(n*m) O(n∗m)，每次查询 O ( 1 ) \mathcal{O}(1) O(1)
-
实现要点：
- 注意前缀和可能超出 int \text{int} int 范围，使用 long long \text{long long} long long
- 注意输入的下标从 1 1 1 开始
- 使用快速输入输出优化读写时间
代码
#include <iostream>
#include <vector>
using namespace std;
int main() {
ios::sync_with_stdio(false); // 优化输入输出
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
// 构建二维前缀和数组，多加一行一列便于计算
vector<vector<long long>> prefix(n + 1, vector<long long>(m + 1, 0));
// 读入矩阵并计算前缀和
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
int x;
cin >> x;
// 二维前缀和公式
prefix[i][j] = prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1] + x;
}
}
// 处理查询
while(q--) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
// 计算子矩阵的和
long long sum = prefix[x2][y2] - prefix[x1-1][y2] - prefix[x2][y1-1] + prefix[x1-1][y1-1];
cout << sum << "\n";
}
return 0;
}
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
String[] line = br.readLine().split(" ");
int n = Integer.parseInt(line[0]);
int m = Integer.parseInt(line[1]);
int q = Integer.parseInt(line[2]);
// 构建二维前缀和数组
long[][] prefix = new long[n + 1][m + 1];
// 读入矩阵并计算前缀和
for(int i = 1; i <= n; i++) {
line = br.readLine().split(" ");
for(int j = 1; j <= m; j++) {
int x = Integer.parseInt(line[j-1]);
prefix[i][j] = prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1] + x;
}
}
// 处理查询
while(q-- > 0) {
line = br.readLine().split(" ");
int x1 = Integer.parseInt(line[0]);
int y1 = Integer.parseInt(line[1]);
int x2 = Integer.parseInt(line[2]);
int y2 = Integer.parseInt(line[3]);
long sum = prefix[x2][y2] - prefix[x1-1][y2] - prefix[x2][y1-1] + prefix[x1-1][y1-1];
out.println(sum);
}
out.flush();
br.close();
}
}
def main():
# 读取输入
n, m, q = map(int, input().split())
# 构建二维前缀和数组
prefix = [[0] * (m + 1) for _ in range(n + 1)]
# 读入矩阵并计算前缀和
for i in range(1, n + 1):
row = list(map(int, input().split()))
for j in range(1, m + 1):
prefix[i][j] = prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1] + row[j-1]
# 处理查询
for _ in range(q):
x1, y1, x2, y2 = map(int, input().split())
# 计算子矩阵的和
sum_region = prefix[x2][y2] - prefix[x1-1][y2] - prefix[x2][y1-1] + prefix[x1-1][y1-1]
print(sum_region)
if __name__ == "__main__":
main()
算法及复杂度
- 算法：二维前缀和
- 时间复杂度：预处理 O ( n × m ) \mathcal{O}(n \times m) O(n×m)，查询 O ( 1 ) \mathcal{O}(1) O(1)，总体 O ( n × m + q ) \mathcal{O}(n \times m + q) O(n×m+q)
- 空间复杂度： O ( n × m ) \mathcal{O}(n \times m) O(n×m)，用于存储二维前缀和数组
解题思路
-
问题分析：
- 第一问：求背包能装下的最大价值（不要求装满）
- 第二问：求背包恰好装满时的最大价值（要求装满）
-
状态定义：
- d p 1 [ j ] dp1[j] dp1[j]：容量为 j j j 时能装下的最大价值（不要求装满）
- d p 2 [ j ] dp2[j] dp2[j]：容量为 j j j 时恰好装满的最大价值（要求装满）
-
初始化：
- d p 1 dp1 dp1 全部初始化为 0 0 0（表示空背包，价值为 0 0 0）
- d p 2 dp2 dp2 除了 d p 2 [ 0 ] = 0 dp2[0]=0 dp2[0]=0 外，其他都初始化为负无穷（表示还未找到恰好装满的方案）
-
状态转移：
对每个物品
i
i
i:
对每个容量
j
j
j 从
V
V
V 到
v
i
v_i
vi：
d p 1 [ j ] = max ( d p 1 [ j ] , d p 1 [ j − v i ] + w i ) dp1[j] = \max(dp1[j], dp1[j-v_i] + w_i) dp1[j]=max(dp1[j],dp1[j−vi]+wi) // 不要求装满
d p 2 [ j ] = max ( d p 2 [ j ] , d p 2 [ j − v i ] + w i ) dp2[j] = \max(dp2[j], dp2[j-v_i] + w_i) dp2[j]=max(dp2[j],dp2[j−vi]+wi) // 要求装满
-
结果获取：
- 第一问：直接输出 d p 1 [ V ] dp1[V] dp1[V]
- 第二问：如果 d p 2 [ V ] dp2[V] dp2[V] 为负无穷，输出 0 0 0；否则输出 d p 2 [ V ] dp2[V] dp2[V]
-
优化方案：
- 使用滚动数组（一维dp）节省空间
- 从后向前遍历避免重复使用物品
- 使用
long long类型避免整数溢出
代码
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
int main() {
int n, V;
cin >> n >> V;
// 不要求装满的dp数组
vector<long long> dp1(V + 1, 0);
// 恰好装满的dp数组
vector<long long> dp2(V + 1, LLONG_MIN);
dp2[0] = 0;
for(int i = 0; i < n; i++) {
int v, w;
cin >> v >> w;
// 从后向前遍历避免重复使用
for(int j = V; j >= v; j--) {
if(dp1[j-v] != LLONG_MIN)
dp1[j] = max(dp1[j], dp1[j-v] + w);
if(dp2[j-v] != LLONG_MIN)
dp2[j] = max(dp2[j], dp2[j-v] + w);
}
}
cout << dp1[V] << endl;
cout << (dp2[V] == LLONG_MIN ? 0 : dp2[V]) << endl;
return 0;
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int V = sc.nextInt();
// 不要求装满的dp数组
long[] dp1 = new long[V + 1];
// 恰好装满的dp数组
long[] dp2 = new long[V + 1];
Arrays.fill(dp2, Long.MIN_VALUE);
dp2[0] = 0;
for(int i = 0; i < n; i++) {
int v = sc.nextInt();
int w = sc.nextInt();
// 从后向前遍历避免重复使用
for(int j = V; j >= v; j--) {
if(dp1[j-v] != Long.MIN_VALUE)
dp1[j] = Math.max(dp1[j], dp1[j-v] + w);
if(dp2[j-v] != Long.MIN_VALUE)
dp2[j] = Math.max(dp2[j], dp2[j-v] + w);
}
}
System.out.println(dp1[V]);
System.out.println(dp2[V] == Long.MIN_VALUE ? 0 : dp2[V]);
sc.close();
}
}
def solve_knapsack():
n, V = map(int, input().split())
# 不要求装满的dp数组
dp1 = [0] * (V + 1)
# 恰好装满的dp数组
dp2 = [-float('inf')] * (V + 1)
dp2[0] = 0
for _ in range(n):
v, w = map(int, input().split())
# 从后向前遍历避免重复使用
for j in range(V, v - 1, -1):
if dp1[j-v] != -float('inf'):
dp1[j] = max(dp1[j], dp1[j-v] + w)
if dp2[j-v] != -float('inf'):
dp2[j] = max(dp2[j], dp2[j-v] + w)
print(dp1[V])
print(dp2[V] if dp2[V] != -float('inf') else 0)
if __name__ == "__main__":
solve_knapsack()
算法及复杂度
- 算法：动态规划（01背包）
- 时间复杂度： O ( n V ) \mathcal{O}(nV) O(nV)， n n n 是物品数量， V V V 是背包容量
- 空间复杂度： O ( V ) \mathcal{O}(V) O(V)，使用滚动数组优化
扫一扫
814
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
