第 20 题
2.（最大值之和）给定整数序列 ![第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)](/d/file/p/2024/05-29/95f115a21ad2402a2f7152c06c185f11.png "第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)")
，求该序列所有非空连续子序列的最大值之和。上述参数满足 ![第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)](/d/file/p/2024/05-29/ea0c6fd40f86c5f85850fecc607e1648.png "第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)")
。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为![第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)](/d/file/p/2024/05-29/8c46ddae4037964b7491a62270890ae9.png "第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)")
。两个非空连续子序列不同，当且仅当下标不同。
例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
解决该问题有许多算法，以下程序使用分治算法，时间复杂度![第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)](/d/file/p/2024/05-29/714d54793fb1dd6c99f101de1a06df9a.png "第 20 题 2.（最大值之和）给定整数序列 ，求该序列所有非空连续子序列的最大值之和。上述参数满足 。一个序列的非空连续子序列可以用两个下标 l和 r（其中 0≤l≤r<n）表示，对应的序列为。两个非空连续子序列不同，当且仅当下标不同。 例如，当原序列为 [1,2,1,2]时，要计算子序列 [1]、[2]、[1]、[2]、[1,2]、[2,1]、[1,2]、[1,2,1]、[2,1,2]、[1,2,1,2] 的最大值之和，答案为 18。注意 [1,1]和 [2,2]虽然是原序列的子序列，但不是连续子序列，所以不应该被计算。另外，注意其中有一些值相同的子序列，但由于他们在原序列中的下标不同，属于不同的非空连续子序列，所以会被分别计算。 解决该问题有许多算法，以下程序使用分治算法，时间复杂度 试补全程序。 #include <iostream> #include <algorithm> #include <vector> const int MAXN = 100000; int n; int a[MAXN]; long long ans; void solve(int l, int r) { if (l + 1 == r) { ans += a[l]; return; } int mid = (l + r) >> 1; std::vector<int> pre(a + mid, a + r); for (int i = 1; i < r - mid; ++i) ①; std::vector<long long> sum(r - mid + 1); for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i]; for (int i = mid - l, j = mid, max = 0; i >= l; --i) { while (j < r && ②) ++j; max = std::max(max, a[i]); ans += ③; ans += ④; } solve(l, mid); solve(mid, r); } int main() { std::cin >> n; for (int i = 0; i < n; ++i) std::cin >> a[i]; ⑤; std::cout << ans << std::endl; return 0; } ①处应填（） ②处应填（） ③处应填（） ④处应填（） ⑤处应填（） 1. A. pre[i] = std::max(pre[i - 1], a[i - 1]) B. pre[i + 1] = std::max(pre[i],pre[i + 1]) C. pre[i] = std::max(pre[i -1], a[i]) D. pre[i] = std::max(pre[i], pre[i - 1]) 2. A. a[j] < max B. a[j] < a[i] C. pre[j - mid] < max D. pre[j - mid] > max 3. A. (long long)(j - mid) * max B. (long long)(j - mid) * (i - 1) * max C. sum[j - mid] D. sum[j - mid] * (i - 1) 4. A. (long long)(r - j) * max B. (long long)(r - j) * (mid - i) * max C. sum[r - mid] - sum[j - mid] D. (sum[r - mid] - sum[j - mid]) * (mid - i) 5. A. solve(0，n) B. solve(0，n - 1) C. solve(1，n) D. solve(1，n - 1)")
D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
试补全程序。D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
- #include <iostream>
- #include <algorithm>
- #include <vector>
-
- const int MAXN = 100000;
-
- int n;
- int a[MAXN];
- long long ans;
-
- void solve(int l, int r) {
- if (l + 1 == r) {
- ans += a[l];
- return;
- }
- int mid = (l + r) >> 1;
- std::vector<int> pre(a + mid, a + r);
- for (int i = 1; i < r - mid; ++i) ①;
- std::vector<long long> sum(r - mid + 1);
- for (int i = 0; i < r - mid; ++i)
- sum[i + 1] = sum[i] + pre[i];
- for (int i = mid - l, j = mid, max = 0; i >= l; --i) {
- while (j < r && ②) ++j;
- max = std::max(max, a[i]);
- ans += ③;
- ans += ④;
- }
- solve(l, mid);
- solve(mid, r);
- }
-
- int main() {
- std::cin >> n;
- for (int i = 0; i < n; ++i)
- std::cin >> a[i];
- ⑤;
- std::cout << ans << std::endl;
- return 0;
- }
-
①处应填（）D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
-
②处应填（）D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
-
③处应填（）D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
-
④处应填（）D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
-
⑤处应填（）D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
1.D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
A. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
pre[i] = std::max(pre[i - 1], a[i - 1])D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
B. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
pre[i + 1] = std::max(pre[i],pre[i + 1])D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
C. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
pre[i] = std::max(pre[i -1], a[i])D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
D. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
pre[i] = std::max(pre[i], pre[i - 1])D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
2.D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
A. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
a[j] < maxD6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
B. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
a[j] < a[i]D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
C. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
pre[j - mid] < maxD6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
D. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
pre[j - mid] > maxD6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
3.D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
A. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
(long long)(j - mid) * maxD6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
B. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
(long long)(j - mid) * (i - 1) * maxD6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
C. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
sum[j - mid]D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
D. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
sum[j - mid] * (i - 1)D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
4.D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
A. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
(long long)(r - j) * maxD6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
B. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
(long long)(r - j) * (mid - i) * maxD6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
C. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
sum[r - mid] - sum[j - mid]D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
D. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
(sum[r - mid] - sum[j - mid]) * (mid - i)D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
5.D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
A. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
solve(0，n)D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
B. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
solve(0，n - 1)D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
C. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
solve(1，n)D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
D. D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
solve(1，n - 1)D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
D6H100150满分答卷(100150.com)-青少年编程等级考试及竞赛题库
