P2642 双子序列最大和

最新推荐文章于 2025-11-01 09:59:58 发布

原创

最新推荐文章于 2025-11-01 09:59:58 发布 · 1.2k 阅读

0 ·

CC 4.0 BY-SA版权

给定一个整数序列，需要找到两个不相交的连续子序列，使它们的和最大。子序列长度至少为1，且至少间隔一个数。需要处理包含负数的情况，并考虑边界条件。

题目描述

给定一个长度为n的整数序列，要求从中选出两个连续子序列，使得这两个连续子序列的序列和之和最大，最终只需输出最大和。一个连续子序列的和为该子序列中所有数之和。每个连续子序列的最小长度为1，并且两个连续子序列之间至少间隔一个数。

输入输出格式

输入格式：

第一行是一个整数表示n。

第二行是n个整数表示整数序列。

输出格式：

一个数，两个连续子序列的序列和之和。

输入输出样例

输入样例#1：

5
83 223 -13 1331 -935

输出样例#1：

1637

输入样例#2：

3
83 223 -13

输出样例#2：

70

说明

对于30%的数据N<=100。

对于60%的数据有N<=10000。

对于100%的数据有N<=1000000。

数据保证运算过程不会超过long long（int64）。

———————————————————————————————————————

解题思路

首先根据Luogu《P1115 最大子段和》可以知道我们可以求出一直到第i为的当前连续子串和和当前连续子串的最大和，只不过对于这道题我们必须记录每一个点之前（或之后）当前连续子串的最大长度。
我们分别把从左到右的以

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

burninghott

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

P2642 双子序列最大和（线性DP）（最大子段和 + 合唱队列）

繁凡さん的博客

09-08

547

P2642 双子序列最大和 首先考虑单个的最大子序列和 f[i] = max(f[i - 1] + a,a); ans = max(ans,f[i]); 这里的预处理方法类似合唱队列我们处理pre和nex两个数组，分别表示以i为结尾1~i的最大子序列和，以及以i为起点的i~n的最大子序列和，我们枚举中间点，答案就是 ll ans = pre[1] + nex[3]; for(int i = 3; i < n; ++ i){//题目要求至少隔一个数 ans = m

2021-08-26 P2642 双子序列最大和

c_137wyc的博客

08-26

352

前言求双子序列最大和的模板一、题目描述给定一个长度为n的整数序列，要求从中选出两个连续子序列，使得这两个连续子序列的序列和之和最大，最终只需输出最大和。一个连续子序列的和为该子序列中所有数之和。每个连续子序列的最小长度为1，并且两个连续子序列之间至少间隔一个数。 1.输入格式第一行是一个整数表示n。第二行是n个整数表示整数序列。 2.输出格式一个数，两个连续子序列的序列和之和。代码 #include<bits/stdc++.h> using namespa..

参与评论您还未登录，请先登录后发表或查看评论

python 实现最大和连续子序列算法

luthane的博客

10-12

1172

最大和连续子序列算法是寻找一个给定数组（或序列）中具有最大和的连续子数组（或子序列）的问题。这里，我们主要关注算法的实现和优化。1. 暴力法最直接的方法是穷举所有可能的连续子序列，并计算它们的和，然后找出和最大的那个。但这种方法的时间复杂度为O(n^3)，其中n是数组的长度，显然效率很低。2. 优化暴力法我们可以通过减少不必要的计算来优化暴力法。具体地，我们可以避免使用一个额外的数组来存储所有子序列的和，而是直接在计算过程中比较和更新当前找到的最大和。这种方法的时间复杂度为O(n^2)，仍然不是最优的。

【dp】P2642 双子序列最大和

weixin_30551963的博客

04-29

297

题目描述给定一个长度为n的整数序列，要求从中选出两个连续子序列，使得这两个连续子序列的序列和之和最大，最终只需输出最大和。一个连续子序列的和为该子序列中所有数之和。每个连续子序列的最小长度为1，并且两个连续子序列之间至少间隔一个数。输入输出格式输入格式：第一行是一个整数表示n。第二行是n个整数表示整数序列。输出格式：一个数，两个连续子序列的序列和之和。输入输出样例 ...

打卡信奥刷题（316）用Scratch图形化工具信奥P2642[普及组/提高] 双子序列最大和

Loge谈信奥--一个专注于信奥人的博客

07-13

2600

给定一个长度为n的整数序列，要求从中选出两个连续子序列，使得这两个连续子序列的序列和之和最大，最终只需输出最大和。一个连续子序列的和为该子序列中所有数之和。每个连续子序列的最小长度为1，并且两个连续子序列之间至少间隔一个数。

chenchen题解：NOIP2015-S

weixin_43403405的博客

08-25

607

具有 n 个节点，e 条边的图采用邻接表存储结构，进行深度优先遍历和广度优先遍历运算的时间复杂度为（ O(e+n)）解释：因为在遍历时我们有st数组来防止重复访问，故没每一个节点只访问一次，所以是e+n 双向链表中有两个指针域，llink 和 rlink，分别指回前驱及后继，设 p 指向链表中的一个结点，q 指向一待插入结点，现要求在 p 前插入 q，则正确的插入为（） p->llink->rlink=q; q->rlink=p; q->llink=p->lli...

3、时间序列数据与相关性分析深度解析

c7d8e的博客

11-01

本文深入解析了时间序列数据的分解、平滑处理与相关性分析方法。涵盖了加法与乘法分解模型、趋势和季节性效应的估计、中心化移动平均与loess平滑技术，并介绍了R语言中的decompose和stl函数应用。同时探讨了协方差、相关性计算及其在预测中的作用，结合价格指数计算与偏差校正因子的理论分析，帮助读者全面掌握时间序列分析的核心概念与实践技巧。

题解 P2642 【双子序列最大和】

ZHK's blog

04-04

952

前言其实这道题的关键就是在于预处理，其方法类似于合唱队形正文求最大子段和要想求出双子序列最大和，首先我们要会求出最大子段和最大子段和的求值方法很简单定义 fif_ifi 为以第 iii 个数结尾的最大子段和 #include <bits/stdc++.h> using namespace std; int f[1000010],a[1000010]; int main(...

最大子序列和

12-17

793

#include #include int main() { int this_sum, max_sum, old_first, old_last, new_first; int n,i, tmp, flag = 1; int first = 1; int *data; scanf("%d", &n); this_sum= max_sum = old_first = new_

[洛谷P2642]双子序列最大和

LOI_pingxing的博客

10-19

747

读清题目，交之前先检查一遍代码

双子序列最大和（线性 dp ）：最大子段和第 2 弹

m0_60738889的博客

06-15

1157

P2642 双子序列最大和-前缀最大子段和与后缀最大字段和

jisuanji2606414的博客

03-15

432

题目链接双子序列最大和 - 洛谷直接找肯定麻烦，不如枚举分界点 dpright[i]代表以i为结尾的最大子段和 for(int i=1;i<=n;i++) { dpright[i]=max(dpright[i-1]+a[i],a[i]); } 我们进行一下下面操作，dpright[i]就变成了可能包括i在内的i之前的最大子段和 for(int i=1;i<=n;i++) { dpright[i]=max(

poj-2479求最大子序列和（双子序列…

xiefubao的专栏

01-16

1170

be[i]记录着i之前最大的子序列之和；en[i]记录着i之后的子序列之和；这两个都可以通过O（n）的便利得到；然后枚举分界点，总体O（n）解决之。 #include #include using namespace std; int rem[50030]; int be[50030]; int en[50030]; int main() { int n; scanf("%d",

POJ 2479 + POJ 2593(DP 最大双子序列 ^_^)

sp_

07-05

1591

题目大意：序列a[] ，求如下S. 思路：自左向右和自右向左分别DP。 用left[i]表示序列1—i所能取最大和。 用right[i]表示序列n—i所能取到的最大和。 ans=max(left[i]+right[i+1]) (1<=i<=n-1) 或 max(right[i]+left[i-1]) (2<=i<=n) 思路很经典，学习了。 下面的程序

OpenJudge_P1481 Maximum sum(最大双子序列和)

BeiYu

12-02

1090

总时间限制: 1000ms 内存限制: 65536kB 描述 Given a set of n integers: A={a1, a2,…, an}, we define a function d(A) as below:Your task is to calculate d(A). 输入 The input consists of T(<=30) test cases. The numbe

简单DP【p2642】双子序列最大和

weixin_30245867的博客

10-24

249

Description 给定一个长度为n的整数序列，要求从中选出两个连续子序列，使得这两个连续子序列的序列和之和最大，最终只需输出最大和。一个连续子序列的和为该子序列中所有数之和。每个连续子序列的最小长度为1，并且两个连续子序列之间至少间隔一个数。 Input 第一行是一个整数表示n。第二行是n个整数表示整数序列。 Output 一个数，两个连续子序列的序列和之和。动态规划.这不某年初赛题...

双序列最大和

yrhuadonghui的博客

03-15

514

可分别从从前面和后面求最大的子列，并进行预处理。最后从前到后枚举一遍即可。

题目描述 RB（红黑）树除了是一个二叉搜索树之外，还满足下面规则： 1）每个结点要么是红的，要么是黑的。 2）根结点是黑的。 3）每个叶结点，即空结点是黑的。 4）如果一个结点是红的，那么它的俩个儿子都是黑的。 5）对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点。在给定插入序列的情况下，创建RB树，并输出最大值、最小值。使用c++ 输入格式：对于每种情况，第一行包含一个正整数N(<=20)。后边为N个不同的整数值，每个整数值以空格隔开。第二行为要删除的节点个数M，后边为M个不同的整数值，以空格隔开。输出格式：第一行为RB树的前序遍历序列，以空格隔开，其中节点值后使用(B)和(R)表示节点的颜色；第二行为RB树的最大值，最小值，以空格隔开；第三行为删除M个节点之后的RB树的前序遍历序列，以空格隔开，若树为空，则输出Null；样例输入1： 13 1 45 34 98 9 4 35 23 36 37 90 85 80 3 85 27 9 样例输出1： 34(B) 4(B) 1(B) 9(B) 23(R) 45(B) 36(B) 35(R) 37(R) 90(R) 85(B) 80(R) 98(B) 1 98 34(B) 4(B) 1(B) 23(B) 45(B) 36(B) 35(R) 37(R) 90(R) 80(B) 98(B) 样例输入2： 3 18 2 7 0 样例输出2： 7(B) 2(R) 18(R) 2 18 7(B) 2(R) 18(R) 注意：遍历输出最后一个结点有空格。删除带有双子结点时，找直接后继。样例输入输出样例1 输入: 13 1 45 34 98 9 4 35 23 36 37 90 85 80 3 85 27 9 输出: 34(B) 4(B) 1(B) 9(B) 23(R) 45(B) 36(B) 35(R) 37(R) 90(R) 85(B) 80(R) 98(B) 1 98 34(B) 4(B) 1(B) 23(B) 45(B) 36(B) 35(R) 37(R) 90(R) 80(B) 98(B) 样例2 输入: 3 18 2 7 0 输出: 7(B) 2(R) 18(R) 2 18 7(B) 2(R) 18(R)

最新发布

12-29

# 题目重述根据给定的插入序列构建红黑树，执行插入与删除操作后，输出以下内容： 1. 构建完成后红黑树的前序遍历结果，每个节点后标注颜色（B为黑，R为红）； 2. 树中最小值和最大值； 3. 删除指定节点后的前序遍历结果，若树为空则输出 Null。 --- # 详解本题要求实现一个完整的红黑树结构，包含插入、删除、旋转及颜色调整等操作，并支持前序遍历、查找最大/最小值等功能。 ### 步骤分析： 1. **红黑树性质维护**： - 每个节点是红色或黑色。 - 根节点为黑色。 - 叶子（NULL）视为黑色。 - 红色节点的子节点必须都是黑色。 - 从任一节点到其所有后代叶子路径上的黑节点数相同（黑高一致）。 2. **插入操作**： - 使用二叉搜索树规则插入新节点，初始颜色设为红色。 - 若破坏了红黑性质（如父节点也为红），通过变色和旋转修复。 3. **删除操作**： - 类似于普通二叉搜索树删除，但需考虑颜色平衡。 - 当删除黑色节点时可能破坏黑高性质，需要通过兄弟节点调整（变色、旋转）来修复。 4. **最大值与最小值查找**： - 最小值：从根开始一直向左直到空。 - 最大值：从根开始一直向右直到空。 5. **前序遍历输出格式化**： - 输出节点值 + (B)/(R)，注意最后一个也有空格（按样例要求）。 6. **删除双子节点的情况**： - 使用“直接后继”替换被删节点（即右子树中的最小值）。 7. **输入输出处理**： - 第一行读取 N 和 N 个整数进行插入。 - 第二行读取 M 和 M 个要删除的值。 --- ```cpp #include <iostream> #include <vector> using namespace std; enum Color { RED, BLACK }; struct Node { int data; Color color; Node *left, *right, *parent; Node(int value) : data(value), color(RED), left(nullptr), right(nullptr), parent(nullptr) {} }; class RBTree { private: Node* root; void leftRotate(Node* x) { Node* y = x->right; x->right = y->left; if (y->left != nullptr) y->left->parent = x; y->parent = x->parent; if (x->parent == nullptr) root = y; else if (x == x->parent->left) x->parent->left = y; else x->parent->right = y; y->left = x; x->parent = y; } void rightRotate(Node* y) { Node* x = y->left; y->left = x->right; if (x->right != nullptr) x->right->parent = y; x->parent = y->parent; if (y->parent == nullptr) root = x; else if (y == y->parent->left) y->parent->left = x; else y->parent->right = x; x->right = y; y->parent = x; } void fixInsert(Node* k) { while (k != root && k->parent->color == RED) { if (k->parent == k->parent->parent->left) { Node* u = k->parent->parent->right; if (u != nullptr && u->color == RED) { k->parent->color = BLACK; u->color = BLACK; k->parent->parent->color = RED; k = k->parent->parent; } else { if (k == k->parent->right) { k = k->parent; leftRotate(k); } k->parent->color = BLACK; k->parent->parent->color = RED; rightRotate(k->parent->parent); } } else { Node* u = k->parent->parent->left; if (u != nullptr && u->color == RED) { k->parent->color = BLACK; u->color = BLACK; k->parent->parent->color = RED; k = k->parent->parent; } else { if (k == k->parent->left) { k = k->parent; rightRotate(k); } k->parent->color = BLACK; k->parent->parent->color = RED; leftRotate(k->parent->parent); } } } root->color = BLACK; } Node* insertNode(int data) { Node* node = new Node(data); Node* parent = nullptr; Node* temp = root; while (temp != nullptr) { parent = temp; if (data < temp->data) temp = temp->left; else temp = temp->right; } node->parent = parent; if (parent == nullptr) root = node; else if (data < parent->data) parent->left = node; else parent->right = node; fixInsert(node); return node; } Node* findMin(Node* node) { while (node->left != nullptr) node = node->left; return node; } Node* findNode(int data) { Node* temp = root; while (temp != nullptr && temp->data != data) { if (data < temp->data) temp = temp->left; else temp = temp->right; } return temp; } void transplant(Node* u, Node* v) { if (u->parent == nullptr) root = v; else if (u == u->parent->left) u->parent->left = v; else u->parent->right = v; if (v != nullptr) v->parent = u->parent; } void deleteFixup(Node* x) { while (x != root && (x == nullptr || x->color == BLACK)) { if (x == x->parent->left) { Node* w = x->parent->right; if (w != nullptr && w->color == RED) { w->color = BLACK; x->parent->color = RED; leftRotate(x->parent); w = x->parent->right; } if (w == nullptr || (w->left == nullptr || w->left->color == BLACK) && (w->right == nullptr || w->right->color == BLACK)) { if (w != nullptr) w->color = RED; x = x->parent; } else { if (w->right == nullptr || w->right->color == BLACK) { if (w->left != nullptr) w->left->color = BLACK; w->color = RED; rightRotate(w); w = x->parent->right; } w->color = x->parent->color; x->parent->color = BLACK; if (w->right != nullptr) w->right->color = BLACK; leftRotate(x->parent); x = root; } } else { Node* w = x->parent->left; if (w != nullptr && w->color == RED) { w->color = BLACK; x->parent->color = RED; rightRotate(x->parent); w = x->parent->left; } if (w == nullptr || (w->right == nullptr || w->right->color == BLACK) && (w->left == nullptr || w->left->color == BLACK)) { if (w != nullptr) w->color = RED; x = x->parent; } else { if (w->left == nullptr || w->left->color == BLACK) { if (w->right != nullptr) w->right->color = BLACK; w->color = RED; leftRotate(w); w = x->parent->left; } w->color = x->parent->color; x->parent->color = BLACK; if (w->left != nullptr) w->left->color = BLACK; rightRotate(x->parent); x = root; } } } if (x) x->color = BLACK; } void deleteNode(int data) { Node* z = findNode(data); if (z == nullptr) return; Node* y = z; Node* x; Color y_original_color = y->color; if (z->left == nullptr) { x = z->right; transplant(z, z->right); } else if (z->right == nullptr) { x = z->left; transplant(z, z->left); } else { y = findMin(z->right); y_original_color = y->color; x = y->right; if (y->parent == z) { if (x) x->parent = y; } else { transplant(y, y->right); y->right = z->right; y->right->parent = y; } transplant(z, y); y->left = z->left; y->left->parent = y; y->color = z->color; } delete z; if (y_original_color == BLACK) { deleteFixup(x); } } void preorderHelper(Node* node) { if (node == nullptr) return; cout << node->data << "(" << (node->color == BLACK ? "B" : "R") << ") "; preorderHelper(node->left); preorderHelper(node->right); } Node* getMinNode() { if (root == nullptr) return nullptr; Node* p = root; while (p->left != nullptr) p = p->left; return p; } Node* getMaxNode() { if (root == nullptr) return nullptr; Node* p = root; while (p->right != nullptr) p = p->right; return p; } public: RBTree() : root(nullptr) {} void insert(int data) { insertNode(data); } void remove(int data) { deleteNode(data); } void preorder() { preorderHelper(root); cout << endl; } void printMinMax() { Node* minNode = getMinNode(); Node* maxNode = getMaxNode(); if (minNode && maxNode) { cout << minNode->data << " " << maxNode->data << endl; } } bool isEmpty() { return root == nullptr; } }; int main() { RBTree tree; int N; cin >> N; for (int i = 0; i < N; ++i) { int val; cin >> val; tree.insert(val); } tree.preorder(); tree.printMinMax(); int M; cin >> M; for (int i = 0; i < M; ++i) { int val; cin >> val; tree.remove(val); } if (tree.isEmpty()) { cout << "Null" << endl; } else { tree.preorder(); } return 0; } ``` --- # 知识点 - **红黑树插入修复**：通过变色与旋转维持平衡，确保红节点无红子。 - **红黑树删除修复**：删除黑节点可能导致黑高失衡，需通过兄弟节点调整恢复。 - **前序遍历与最值查找**：前序遍历遵循中左右顺序；最小值位于最左，最大值位于最右。