题解 P1712 【[NOI2016]区间】

最新推荐文章于 2022-07-19 11:48:14 发布
原创 最新推荐文章于 2022-07-19 11:48:14 发布 · 418 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #线段树

本文介绍了一种利用线段树解决区间覆盖问题的方法。通过排序区间并逐步添加与移除，实现对区间覆盖次数的有效追踪。代码示例展示了如何在特定条件下找到最优解。

先按照长度排个序，然后依次添加区间。什么是添加？设这个区间是[l,r][l,r]，添加就是把al,al+1,al+2,...,aral,al+1,al+2,...,ar都加上11，其中ai表示第ii个位置被几个区间覆盖。拿走一个区间的含义就是把它们都减1。这个过程很显然可以用线段树维护。

如果在添加到一个区间 ii 时，有一个点被区间覆盖了M次，那么先更新答案，再把前面的加入过的区间一直拿直到没有一个点被覆盖MM次。如何判断有没有点被覆盖M次？因为是一个一个区间加的，所以只用维护一个aiai的最大值，看他是否=M=M就行了。

什么叫再把前面的加入过的区间一直拿直到没有一个点被覆盖MM次？

比如你一直添加区间到第5个，此时有一个点被覆盖了MM次。这时你就将第一个区间拿出，如果此时依然有有一个点被覆盖了M次，那么你就拿走第二个…

这个过程就好比一个队列，可以从后面添加区间达到一个点被覆盖了MM次；从前面弹出区间直到没有一个点被覆盖了M次。

差不多就是这样，还有注意一下li,ri≤109li,ri≤109，开线段树是要离散化的。上代码： 

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXN = 1000500;
int N, M, l[MAXN], r[MAXN], lid[MAXN], rid[MAXN], cnt;
struct node {
    int left, right, Max, lazy;
    node *ch[2];
}pool[MAXN * 3], *root; 
struct xianduan {
    int len, l, r;
    bool operator < (const xianduan& a) const {
        return len < a.len;
    }
}b[MAXN];
struct getin {
    int d, lid, rid, nid;
    bool operator < (const getin &a) const {
        return d < a.d;
    } 
}a[MAXN * 2];
inline void pushdown(node *r) {
    if(!r->lazy) return ;
    r->Max += r->lazy;
    if(r->ch[0]) r->ch[0]->lazy += r->lazy;
    if(r->ch[1]) r->ch[1]->lazy += r->lazy;
    r->lazy = 0;
}
inline void pushup(node *r) {
    r->Max = max(r->ch[0]->Max, r->ch[1]->Max);
}
inline void build(node *r, int left, int right) {
    r->left = left, r->right = right;
    if(left == right) return ;
    int mid = (left + right) / 2;
    node *lson = &pool[++cnt], *rson = &pool[++cnt];
    r->ch[0] = lson, r->ch[1] = rson;
    build(lson, left, mid); build(rson, mid + 1, right);
}
inline　void　change(node *r, int left, int right, int d) {
    if(r->left == left && r->right == right) {
        r->lazy += d; return ;
    }　　　　
    pushdown(r);
    if(r->ch[0]->right >= right) change(r->ch[0], left, right, d);　　　　
    else if(r->ch[1]->left <= left) change(r->ch[1], left, right, d);　　　　　
    else change(r->ch[0], left, r->ch[0]->right, d), change(r->ch[1], r->ch[1]->left, right, d);
    pushdown(r->ch[0]), pushdown(r->ch[1]), pushup(r);
}　　　　　　　　　　　　　　　　　　　　　　
int main()　 {　　　　　　　　　　　　　　　
    root = &pool[0];
    scanf("%d%d", &N, &M);
    for(int　i　=　1; i <= N; i++) {
        scanf("%d%d", &l[i], &r[i]);
        a[2 * i -　1].d = l[i], a[2 * i - 1].lid = i, a[2 * i - 1].rid = -1;　
        a[2 * i].d = r[i], a[2 * i].lid = -1, a[2 * i].rid　= i;　
    }　
    sort(a + 1, a　+　2 * N + 1);　
    a[0].d = -1;　
    for(int i = 1; i <= 2 * N; i++) {　
        if(a[i].d == a[i - 1].d) a[i].nid = a[i - 1].nid;
        else a[i].nid = a[i - 1].nid + 1;　
        if(a[i].lid != -1) lid[a[i].lid] = a[i].nid; 
        else rid[a[i].rid] = a[i].nid;　
    }　
    build(root, 1, a[2 * N].nid);
    for(int i = 1; i <= N; i++) {
        b[i].len = r[i] - l[i], b[i].l = lid[i], b[i].r = rid[i];
    }
    sort(b + 1, b + N + 1);
    int last =　1, ans = 2147483647;
    for(int i = 1; i <= N; i++) {
        change(root, b[i].l, b[i].r, 1);
        while(root->Max == M) {
            change(root, b[last].l, b[last].r, -1);
            ans = min(ans, b[i].len - b[last].len);
            last++;
        }　　
    }　
    if(ans == 2147483647) ans = -1;
    printf("%d\n", ans);
    return 0;
}

不要试图提交我的代码，你会因为一些奇怪的空格花式CE的。
[NOI2016] 优秀的拆分 题解
KonjakuLAF的博客
09-14 922
[NOI2016] 优秀的拆分 题解 link 题意 \(T\) 组询问，每组一个字符串 \(s\) 求 \(s\) 所有字串分成 \(AABB\) 的方案数之和。 \(A,B\) 为非空串。 题解 设 \(f_i\) 为一 \(i\) 结尾的 \(AA\) 串数量，\(g_i\) 为一 \(i\) 结尾的 \(AA\) 穿数量。 \(ans=\sum f_{i}\times g_{i+1}\)...
P1737 [NOI2016] 旷野大计算 题解
Chat_lsm2024的博客
04-18 1791
本篇题解作为旷野大计算的题解，思路清晰，解法自然，逻辑严谨，你可以利用这篇题解，为自己的解题之旅进行热身。苯蒟蒻相信，这篇优美的题解，可以给拼搏于获奖的逐梦之路上的你，提供一个有力的援助。不好意思走错片场了。整体代码就不往上放了，这里是评测记录。利用好 �(�)S(x) 函数。该函数是本题的灵魂。这话说着容易做起来难。极限是本题的经脉，使灵魂有了承载。二者结合，我认为是本题最重要的思想。利用连续函数构造分段函数，是二者结合的具体体现。注意计算节点的优化，有些可以特殊处理的就拿出来单独处理。
【线段树】[NOI2016]区间
weixin_30633405的博客
07-31 225
题目描述 在数轴上有 n 个闭区间 [l1,r1],[l2,r2],...,[ln,rn]。现在要从中选出 m 个区间，使得这 m 个区间共同包含至少一个位置。换句话说，就是使得存在一个 x，使得对于每一个被选中的区间 [li,ri]，都有 li≤x≤ri。 对于一个合法的选取方案，它的花费为被选中的最长区间长度减去被选中的最短区间长度。区间 [l...
【NOI2016】区间
zheng_lw的博客
08-22 448
戳我获得更好观看效果 这道题作为NOI的题目还算是比较水的（虽然是第一题） 这道题是区间操作，不难看出可以用线段树做 【思路分析】 由于数据很大，我们先进行离散化，然后按区间长度排序并建一棵空树(维护当前区间重合部分最大值) 根据该线段树维护的结果 ，我们可以知道t[1].sum记录的是当前各条线段重合的最大值，只要t[1].sum大于m就符合题目要求了 接着我们采用尺取法,就是搞两...
[NOI2016]区间
weixin_34138521的博客
02-13 230
对于$l_i$、$r_i$的范围太大，我们离散化一下就可以缩到百万的范围了。 这道题要求花费最小。所以根据区间的长度排序，就可以转化成单调性的问题了：选取一段区间，使得这些区间的覆盖存在一个点被覆盖$\geq M$次。 于是维护一颗线段树，然后维护选取区间的开头和结尾，加入区间时将线段树对应的区间修改$+1$，去掉时就$-1$。 当存在一个点被覆盖$m$次时，说明线段树中有一个点的值$=m$...
洛谷 P1117 [NOI2016] 优秀的拆分 题解
KaiserWilheim的博客
07-19 853
Luogu P1117 LibreOJ #2083 AcWing 1006 UOJ #219
noi2016 旷野大计算 题解1
08-03
【旷野大计算】是NOI（全国青少年信息学奥林匹克竞赛）在2016年推出的一道竞赛题目，由清华大学的吕凯风、王逸松、于纪平和张瑞喆共同设计和验证。这道题目的核心是构建计算网络来解决一系列计算任务，考验参赛者的...
P1117 [NOI2016]优秀的拆分题解（C++）
Gauss_0726的博客
10-24 3020
优秀的拆分 这题不简单，在洛谷里是一道NOI+的题，算法标签有，SA，字符串，暴力。优秀的拆分网址 题目描述 如果一个字符串可以被拆分为 AABB 的形式，其中 A 和B 是任意非空字符串，则我们称该字符串的这种拆分是优秀的。 例如，对于字符串aabaabaa ，如果令 A=aab，B=a，我们就找到了这个字符串拆分成AABB 的一种方式。 一个字符串可能没有优秀的拆分，也可能存在不止一种优秀的拆分。 比如我们令A=a，B=baa，也可以用 AABB 表示出上述字符串；但是，字符串 abaabaa 就没有优
NOI 2016 区间
anhaoti3785的博客
08-07 237
洛谷 P1712 [NOI2016]区间 题目传送门 题目描述 在数轴上有NN 个闭区间 [l_1,r_1],[l_2,r_2],...,[l_n,r_n][l1,r1],[l2,r2],...,[ln,rn] 。现在要从中选出MM 个区间，使得这MM 个区间共同包含至少一个位置。换句话说，就是使得存在一个 xx ，使得对于每一个被选中的区间[l_i,r_i][li,ri] ，都有 l_...
【bzoj4653】[Noi2016]区间
wang_sj的博客
05-08 345
Description在数轴上有 n个闭区间 [l1,r1],[l2,r2],…,[ln,rn]。现在要从中选出 m 个区间，使得这 m个区间共同包含至少一个位置。换句话说，就是使得存在一个 x，使得对于每一个被选中的区间 [li,ri]，都有 li≤x≤ri。 对于一个合法的选取方案，它的花费为被选中的最长区间长度减去被选中的最短区间长度。区间 [li,ri] 的长度定义为 ri−li，即等于它
4653: [Noi2016]区间
CRZbulabula的博客
08-17 1060
4653: [Noi2016]区间 Time Limit: 60 Sec  Memory Limit: 256 MB Submit: 168  Solved: 103 [Submit][Status][Discuss] Description 在数轴上有 n个闭区间 [l1,r1],[l2,r2],...,[ln,rn]。现在要从中选出 m 个区间，使得这 m个区间共同包含至少一个位
bzoj4653 [Noi2016]区间
weixin_30576827的博客
09-02 154
Description 在数轴上有 n个闭区间 [l1,r1],[l2,r2],…,[ln,rn]。现在要从中选出 m 个区间，使得这 m个区间共同包含至少一个位置。换句话说，就是使得存在一个 x，使得对于每一个被选中的区间 [li,ri]，都有 li≤x≤ri。 对于一个合法的选取方案，它的花费为被选中的最长区间长度减去被选中的最短区间长度。区间 [li,r...
BZOJ4653 [Noi2016]区间
neither_nor
08-04 1504
把区间按长度排序，我们发现对于每个区间，假设以其为最长区间，并保证当前存在一个点被m个区间覆盖的话，那么最短那个区间是不降的，所以我们排序后挨个进行区间+1操作，然后再维护一个指针代表当前的最短区间，指针往后扫同时进行区间-1操作直到当前最大值不大于m，期间更新答案，用一个线段树维护区间加和全局最大值即可 区间要离散化一下 #include #include #include #include
【NOI2016】 区间（线段树，尺取法）
DD(XYX)的硫氰化氘博客
05-28 218
我宣布个逝儿！我是大儍🖊！
洛谷P1712[NOI2016]区间
dichanpan2699的博客
02-11 135
线段树+尺取法。 我们先离散化一次，然后按照区间长度排序，每次一位一位往后移。 至于如何判断覆盖了多少个点，我们用一个线段树维护即可。 My Code: #include <bits/stdc++.h> #define il inline #define temp template<class T> #define lson(o) (o << 1) #...
洛谷P2042 [NOI2005] 维护数列怎么用分块做
最新发布
03-15
<think>嗯，用户想了解如何用分块方法解决洛谷P2042这个维护数列的问题。首先，我需要回忆一下分块算法的基本概念。分块通常是将数据分成多个块，每个块单独处理，平衡查询和修改的时间复杂度。不过，题目是NOI2005的，可能比较复杂，因为维护数列通常涉及插入、删除、区间修改、翻转、求和、最大子段和等操作。分块处理这些操作可能比较麻烦，尤其是动态的插入和删除，会导致块的大小变化，影响效率。 首先，我得确认分块是否适合这个问题。一般来说，分块的时间复杂度是O(n√n)，对于大数可能还行，但像这种NOI题目可能数据量较大，分块可能不够高效，不过用户明确问分块方法，所以需要找到如何结构设计。 维护数列的典型操作包括：在某个位置插入一段数列，删除某个区间，区间覆盖，区间翻转，区间求和，求最大子段和。分块的话，每个块需要维护这些操作的信息。比如每个块需要记录翻转标记、覆盖标记，以及各种区间和、最大子段和等。 接下来，分块的结构设计。每个块可以存储一个数组，同时维护块内的总和、最大前缀和、最大后缀和、最大子段和，以及翻转和覆盖的懒标记。插入和删除操作需要考虑块的分裂和合并，这可能比较复杂，因为频繁的插入删除会导致块的大小不均，影响效率。所以可能需要设置块的大小阈值，比如当块的大小超过2√n时分裂，小于√n/2时合并相邻块。 处理翻转操作时，每个块维护一个翻转标记，当需要翻转区间时，对覆盖的完整块标记翻转，并处理部分块。同样，覆盖操作需要懒标记，当块被完全覆盖时，直接更新块内的值，并记录覆盖值。 最大子段和的计算需要每个块维护内部的最大子段和、最大前缀和、最大后缀和，这样在查询时，可以将多个块的信息合并起来得到整体的最大子段和。这可能比较复杂，需要考虑块之间的前后缀如何组合。 插入和删除操作需要找到对应的位置所在的块，如果插入导致块过大，就分裂成两个块。删除时如果块变得过小，可能需要合并相邻块。这些操作需要维护块之间的链表结构，方便快速插入和删除块。 举个例子，当要在位置pos插入一段数列，首先找到pos所在的块，如果块的大小加上插入元素后超过阈值，就分裂该块为两个，然后将插入的元素作为新块插入到链表中。这样插入的时间复杂度是O(√n)，因为分裂和插入块的时间与块的大小有关。 对于翻转和覆盖操作，应用懒标记是关键，这样可以延迟实际的操作，直到需要访问块的具体内容时才进行实际的处理。例如，当需要访问一个带有翻转标记的块时，先执行翻转操作，并清除标记。 不过分块在处理这些动态操作时，尤其是频繁的插入和删除，可能效率不如平衡树结构（如Splay或Treap），但分块实现起来可能相对简单一些。需要权衡实现复杂度和效率。 总结一下，分块实现的关键点包括： 1. 分块的结构设计，每个块维护必要的信息和懒标记。 2. 插入和删除时的块分裂与合并策略。 3. 懒标记的处理，如翻转和覆盖，何时下传。 4. 查询操作时如何合并各个块的信息，如最大子段和。 可能遇到的问题包括块的大小管理不当导致性能下降，懒标记处理错误导致数据不一致，以及在合并块信息时逻辑错误。需要详细设计每个操作的步骤，并处理各种边界情况，比如操作区间跨多个块，或者在块的开头或结尾的部分操作。 最后，参考用户提供的引用，尤其是引用[1]提到递归图的理解，可能分块的递归处理不太相关，但引用[2]提到洛谷题目，可能需要参考类似题解中的分块实现方法。不过用户提供的引用可能没有直接相关的内容，所以需要依靠已有的分块知识来构建解决方案。</think>### 分块方法实现洛谷 P2042 维护数列问题 #### 分块结构设计 1. **块内信息**： - 数据存储：每个块存储$size \leq 2\sqrt{n}$个元素 - 维护以下字段： ```text sum: 区间和 lmax: 最大前缀和 rmax: 最大后缀和 tmax: 最大子段和 rev: 翻转标记（0/1） cov: 覆盖标记（特殊值表示未覆盖） ``` 2. **分块逻辑**： - 块间通过链表或数组连接 - 插入/删除时动态调整块大小，触发分裂或合并（例如块大小超过$2\sqrt{n}$时分裂，相邻块总大小低于$\sqrt{n}$时合并） #### 核心操作实现 **1. 区间翻转（REVERSE）**： - 对完整覆盖的块：翻转标记`rev ^= 1`，交换`lmax`与`rmax` - 对部分覆盖的块：下传标记后暴力翻转元素 时间复杂度：$O(\sqrt{n})$ **2. 区间覆盖（MAKE-SAME）**： - 对完整覆盖的块：更新`cov`标记，直接计算`sum`,`lmax`,`rmax`,`tmax` - 对部分覆盖的块：下传标记后暴力修改 时间复杂度：$O(\sqrt{n})$ **3. 最大子段和（MAX-SUM）**： - 合并相邻块的`rmax`和`lmax`，遍历所有块维护全局最大值 时间复杂度：$O(\sqrt{n})$ **4. 插入（INSERT）**： - 定位插入位置所在块，若插入后块大小超过阈值则分裂 时间复杂度：$O(\sqrt{n} + k/\sqrt{n})$ **5. 删除（DELETE）**： - 移除目标区间涉及的所有块，合并相邻小块 时间复杂度：$O(\sqrt{n} + k/\sqrt{n})$ #### 代码框架示例（关键部分） ```python class Block: def __init__(self): self.data = [] self.sum = 0 self.lmax = self.rmax = self.tmax = -inf self.rev = 0 self.cov = None def push_down(self): # 下传覆盖/翻转标记到数据层 if self.cov is not None: self.data = [self.cov] * len(self.data) if self.rev: self.data.reverse() self.rev = 0 self.cov = None def update_info(self): # 重新计算sum/lmax/rmax/tmax pass class BlockList: def __init__(self): self.blocks = [] def split(self, idx): # 分裂过大的块 pass def merge(self): # 合并过小的相邻块 pass ``` #### 复杂度分析 | 操作类型 | 时间复杂度 | |----------------|---------------------| | 插入/删除 | $O(\sqrt{n} + k)$ | | 翻转/覆盖/求和 | $O(\sqrt{n})$ | | 最大子段和 | $O(\sqrt{n})$ | #### 注意事项 1. **标记下传策略**：在访问块内数据前必须下传所有标记 2. **块大小平衡**：通过动态分裂/合并保证$size \in [\sqrt{n}/2, 2\sqrt{n}]$ 3. **边界处理**：特别注意区间跨多个块时的部分覆盖情况
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值