【Luogu】 P8500 [NOI2022] 冒泡排序

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量160 收藏
点赞数
分类专栏： Luogu 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djx2021/article/details/132639366
版权

题目链接

点击打开链接

题目解法

一个一个性质考虑，然后得出正解
首先考虑把冒泡排序的交换次数转化为逆序对数

性质B

结论1： 没有限制的序列填的数一定单调不降
证明：考虑 a i > a j ( i < j ) a_i>a_j(i<j) ai​>aj​(i<j) 时交换 i , j i,j i,j，可以让 i , j i,j i,j 之间大于 a j a_j aj​ 小于 a i a_i ai​ 的数产生的逆序对贡献消失，而其他逆序对数的不变的，所以不会变劣

考虑对于一个没有限制的位置 i i i 的最优值（这里只是单独考虑它）
可以抽象一下问题，把限制按 V V V 从小到大排序，把下标小于 i i i 的数看做 A A A，下标大于 i i i 的数看做 B B B
那么根据结论1， i i i 只会和有限制的数产生贡献，其贡献 （ V < a i V<a_i V<ai​ 的 B B B 的个数） + + + （ v > a i v>a_i v>ai​ 的 A A A 的个数），其中的最小值便是单独考虑 i i i 位置的最优值

结论2： 单独考虑位置的最优值一定是单调不降的
因为随着 i i i 增大， A A A 会变多， B B B 会变少，不难发现 a i a_i ai​ 一定会上升，使 V < a i V<a_i V<ai​ 的 B B B 的个数 和 v > a i v>a_i v>ai​ 的 A A A 的个数 达到一种平衡

然后就可以用线段树维护了，时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

性质C

不难发现 a L = V a_L=V aL​=V 时是最优的，否则可以交换
现在限制变成了有一些位置固定，一些位置只能 ≥ V i \ge V_i ≥Vi​
考虑贪心：从大到小枚举每个位置，先只考虑一些位置 ≥ V i \ge V_i ≥Vi​ 的限制（包括固定的位置），然后得出当前位置的精确最小值，然后再用精确最小值去更新前面的位置
证明不会
用线段树维护，时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

正解

考虑将 V V V 从大到小排序，这样可以使做到 i i i 时，前面的限制不用变
考虑对于相同的 V V V，将 l l l 从大到小排序，然后尽量选最开头的，如果一个区间已经有位置被选过了就跳过，然后把这个区间都标记 ≥ V \ge V ≥V，使 V ′ < V V'<V V′<V 的区间不能选 V ′ ′ = V V''=V V′′=V 的区间的位置
显然，这样可以使相同的 V V V 限制最少的位置
不合法的情况是一个区间无法选 = V =V =V 的最小位置，即前面 V ′ > V V'>V V′>V 的区间已经把整个 V ′ ′ = V V''=V V′′=V 的区间全部标记过了
然后就变成了性质 C C C 的问题
时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

代码里面性质 B B B 和 性质 C C C 单独的部分都有

#include <bits/stdc++.h>
#define lowbit(x) x&-x
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
const int N=1000100;
struct Seg{
    int l,r,v;
}limit[N];
int n,m;
inline int read(){
	int FF=0,RR=1;
	char ch=getchar();
	for(;!isdigit(ch);ch=getchar()) if(ch=='-') RR=-1;
	for(;isdigit(ch);ch=getchar()) FF=(FF<<1)+(FF<<3)+ch-48;
	return FF*RR;
}
namespace solveB{
    int disc[N];
    bool cmp(const Seg &x,const Seg &y){ return x.l<y.l;}
    struct SegmentTree{
        int seg[N<<2],tag[N<<2];
        void clear(int len){ for(int i=1;i<=len;i++) seg[i]=tag[i]=0;}
        void pushdown(int x){
            seg[x<<1]+=tag[x],tag[x<<1]+=tag[x];
            seg[x<<1^1]+=tag[x],tag[x<<1^1]+=tag[x];
            tag[x]=0;
        }
        void modify(int l,int r,int x,int L,int R,int val){
            if(L<=l&&r<=R){ seg[x]+=val,tag[x]+=val;return;}
            pushdown(x);
            int mid=(l+r)>>1;
            if(mid>=L) modify(l,mid,x<<1,L,R,val);
            if(mid<R) modify(mid+1,r,x<<1^1,L,R,val);
            seg[x]=min(seg[x<<1],seg[x<<1^1]); 
        }
    }sg;
    struct BinaryTree{
        int tr[N];
        void add(int x,int val,int lim){ for(;x<=lim;x+=lowbit(x)) tr[x]+=val;}
        int ask(int x){
            int res=0;
            for(;x;x-=lowbit(x)) res+=tr[x];
            return res;
        }
    }tr;
    void solve(){
        for(int i=1;i<=m;i++) disc[i]=limit[i].v;
        sort(disc+1,disc+m+1);
        int cnt=unique(disc+1,disc+m+1)-disc-1;
        for(int i=1;i<=m;i++) limit[i].v=lower_bound(disc+1,disc+cnt+1,limit[i].v)-disc;
        sort(limit+1,limit+m+1,cmp);
        int j=1;
        for(int i=2;i<=m;i++){
            if(limit[i].l!=limit[i-1].l) limit[++j]=limit[i];
            else if(limit[i].v!=limit[i-1].v){ puts("-1");return;}
        }
        m=j;
        LL ans=0;
        sg.clear(cnt<<2);
        for(int i=1;i<=m;i++) if(limit[i].v<cnt) sg.modify(1,cnt,1,limit[i].v+1,cnt,1);
        for(int i=1;i<m;i++){
            if(limit[i].v<cnt) sg.modify(1,cnt,1,limit[i].v+1,cnt,-1);
            if(limit[i].v>1) sg.modify(1,cnt,1,1,limit[i].v-1,1);
            ans+=1ll*sg.seg[1]*(limit[i+1].l-limit[i].l-1);
            // cout<<"+++"<<sg.seg[1]<<' '<<limit[i+1].l<<' '<<limit[i].l<<' '<<ans<<'\n';
        }
        // cout<<ans<<'\n';
        for(int i=m;i;i--){
            if(limit[i].v>1) ans+=tr.ask(limit[i].v-1);
            tr.add(limit[i].v,1,cnt);
        }
        for(int i=1;i<=m;i++) tr.add(limit[i].v,-1,cnt);
        printf("%lld\n",ans);
    }
    bool check(){
        for(int i=1;i<=m;i++) if(limit[i].l!=limit[i].r) return false;
        return true;
    }
}
namespace solveC{
    int disc[N],low[N],val[N];
    struct SegmentTree{
        int seg[N<<2],tag[N<<2],pos[N<<2];
        void build(int l,int r,int x){
            seg[x]=0,tag[x]=0,pos[x]=l;
            if(l==r) return;
            int mid=(l+r)>>1;
            build(l,mid,x<<1),build(mid+1,r,x<<1^1);
        }
        void pushdown(int x){
            seg[x<<1]+=tag[x],tag[x<<1]+=tag[x];
            seg[x<<1^1]+=tag[x],tag[x<<1^1]+=tag[x];
            tag[x]=0;
        }
        void modify(int l,int r,int x,int L,int R,int val){
            if(L<=l&&r<=R){ seg[x]+=val,tag[x]+=val;return;}
            pushdown(x);
            int mid=(l+r)>>1;
            if(mid>=L) modify(l,mid,x<<1,L,R,val);
            if(mid<R) modify(mid+1,r,x<<1^1,L,R,val);
            if(seg[x<<1]<=seg[x<<1^1]) pos[x]=pos[x<<1];
            else pos[x]=pos[x<<1^1];
            seg[x]=min(seg[x<<1],seg[x<<1^1]); 
        }
        pii query(int l,int r,int x,int L,int R){
            if(L<=l&&r<=R) return make_pair(seg[x],pos[x]);
            pushdown(x);
            int mid=(l+r)>>1;
            if(mid>=L&&mid<R){
                pii tl=query(l,mid,x<<1,L,R),tr=query(mid+1,r,x<<1^1,L,R);
                if(tl.first<tr.first) return tl;
                else return tr;
            }
            if(mid>=L) return query(l,mid,x<<1,L,R);
            return query(mid+1,r,x<<1^1,L,R);
        }
    }sg;
    struct BinaryTree{
        int tr[N];
        void add(int x,int val,int lim){ for(;x<=lim;x+=lowbit(x)) tr[x]+=val;}
        int ask(int x){
            int res=0;
            for(;x;x-=lowbit(x)) res+=tr[x];
            return res;
        }
    }tr;
    void solve(){
        for(int i=1;i<=m;i++) disc[i]=limit[i].v;
        sort(disc+1,disc+m+1);
        for(int i=1;i<=m;i++) limit[i].v=lower_bound(disc+1,disc+m+1,limit[i].v)-disc;
        for(int i=1;i<=n;i++) low[i]=val[i]=-1;
        for(int i=1;i<=m;i++){
            val[limit[i].l]=limit[i].v;
            for(int j=limit[i].l;j<=limit[i].r;j++) low[j]=limit[i].v;
        }
        sg.build(1,m,1);
        for(int i=1;i<=n;i++) if(low[i]>1) sg.modify(1,m,1,1,low[i]-1,1);
        for(int i=n;i;i--){
            if(low[i]>1) sg.modify(1,m,1,1,low[i]-1,-1);
            if(val[i]==-1) val[i]=sg.query(1,m,1,low[i],m).second;
            if(val[i]+1<=m) sg.modify(1,m,1,val[i]+1,m,1);
        }
        LL ans=0;
        for(int i=n;i;i--){
            if(val[i]>1) ans+=tr.ask(val[i]-1);
            tr.add(val[i],1,m);
        }
        for(int i=1;i<=n;i++) tr.add(val[i],-1,m);
        printf("%lld\n",ans);
    }
}
namespace SOLVE{
    int fa[N],disc[N],val[N],low[N];
    vector<pii> T[N];
    int get_father(int x){ return x==fa[x]?x:fa[x]=get_father(fa[x]);}
    struct SegmentTree{
        int seg[N<<2],tag[N<<2],pos[N<<2];
        void build(int l,int r,int x){
            seg[x]=0,tag[x]=0,pos[x]=l;
            if(l==r) return;
            int mid=(l+r)>>1;
            build(l,mid,x<<1),build(mid+1,r,x<<1^1);
        }
        void pushdown(int x){
            seg[x<<1]+=tag[x],tag[x<<1]+=tag[x];
            seg[x<<1^1]+=tag[x],tag[x<<1^1]+=tag[x];
            tag[x]=0;
        }
        void modify(int l,int r,int x,int L,int R,int val){
            if(L<=l&&r<=R){ seg[x]+=val,tag[x]+=val;return;}
            pushdown(x);
            int mid=(l+r)>>1;
            if(mid>=L) modify(l,mid,x<<1,L,R,val);
            if(mid<R) modify(mid+1,r,x<<1^1,L,R,val);
            if(seg[x<<1]<=seg[x<<1^1]) pos[x]=pos[x<<1];
            else pos[x]=pos[x<<1^1];
            seg[x]=min(seg[x<<1],seg[x<<1^1]); 
        }
        pii query(int l,int r,int x,int L,int R){
            if(L<=l&&r<=R) return make_pair(seg[x],pos[x]);
            pushdown(x);
            int mid=(l+r)>>1;
            if(mid>=L&&mid<R){
                pii tl=query(l,mid,x<<1,L,R),tr=query(mid+1,r,x<<1^1,L,R);
                if(tl.first<tr.first) return tl;
                else return tr;
            }
            if(mid>=L) return query(l,mid,x<<1,L,R);
            return query(mid+1,r,x<<1^1,L,R);
        }
    }sg;
    struct BinaryTree{
        int tr[N];
        void add(int x,int val,int lim){ for(;x<=lim;x+=lowbit(x)) tr[x]+=val;}
        int ask(int x){
            int res=0;
            for(;x;x-=lowbit(x)) res+=tr[x];
            return res;
        }
    }tr;
    void solve(){
        for(int i=1;i<=n+1;i++) fa[i]=i,low[i]=val[i]=-1;
        for(int i=1;i<=m;i++) disc[i]=limit[i].v;
        sort(disc+1,disc+m+1);
        for(int i=1;i<=m;i++) limit[i].v=lower_bound(disc+1,disc+m+1,limit[i].v)-disc;
        for(int i=1;i<=m;i++) T[i].clear();
        for(int i=1;i<=m;i++) T[limit[i].v].push_back(make_pair(limit[i].l,limit[i].r));
        bool haveans=1;
        for(int i=m;i;i--){
            sort(T[i].begin(),T[i].end(),greater<pii>());
            int mxl=n+5;
            for(pii t:T[i])
                if(t.second<mxl){
                    int np=get_father(t.first);
                    if(np>t.second){ haveans=0;break;}
                    mxl=np,val[np]=i;
                }
            // cerr<<"+++";
            for(pii t:T[i]) for(int j=get_father(t.first);j<=t.second;j=get_father(j)) low[j]=i,fa[j]=j+1;
            // cerr<<"---";
        }
        if(!haveans){ puts("-1");return;}
        // for(int i=1;i<=n;i++) cout<<val[i]<<' ';cout<<'\n';
        sg.build(1,m,1);
        for(int i=1;i<=n;i++) if(low[i]>1) sg.modify(1,m,1,1,low[i]-1,1);
        for(int i=n;i;i--){
            if(low[i]>1) sg.modify(1,m,1,1,low[i]-1,-1);
            if(val[i]==-1) val[i]=sg.query(1,m,1,low[i],m).second;
            if(val[i]+1<=m) sg.modify(1,m,1,val[i]+1,m,1);
        }
        LL ans=0;
        for(int i=n;i;i--){
            if(val[i]>1) ans+=tr.ask(val[i]-1);
            tr.add(val[i],1,m);
        }
        for(int i=1;i<=n;i++) tr.add(val[i],-1,m);
        printf("%lld\n",ans);
    }
}
int main(){
    // freopen("bubble6.in","r",stdin);
    // freopen("bubble.out","w",stdout);
	int T=read();
    while(T--){
        n=read(),m=read();
        for(int i=1;i<=m;i++) limit[i].l=read(),limit[i].r=read(),limit[i].v=read();
        SOLVE::solve();
    }
	return 0;
}
Farmer_D
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Luogu P2278 [HNOI2003]操作系统
01-20
代码中定义了一个`task`结构体，包含了任务的所有信息，并重载了比较操作符以根据优先级和产生时间进行排序。主函数`main()`中，我们不断读取任务并根据当前时间对任务进行调度。在读取新任务之前，我们检查并处理完...
luogu P4568代码
01-27
洛谷P4568题解 其实就是个简单的NOIP..
P8500 [NOI2022] 冒泡排序
wangchenyu22的博客
12-12 2204
若 a_3 = 39a3​=39，且 39 < a_2 < 202239<a2​<2022，则冒泡排序算法第一轮交换 a_1, a_2a1​,a2​ 和 a_2, a_3a2​,a3​，第二轮交换 a_1, a_2a1​,a2​。若 a_2 = 39a2​=39，且 39 \leq a_3 < 202239≤a3​<2022，则冒泡排序只有第一轮有交换操作，这一轮交换了 a_1, a_2a1​,a2​ 和 a_2, a_3a2​,a3​，总交换次数为 22。如果不存在满足所有条件的序列，则输出 -1−1。
NOI2022 游记
偶耶的博客
08-26 3458
心情有点奇怪，该写些什么寄语呢
Luogu4769 NOI2018 冒泡排序
wennitao的博客
07-05 273
题面：luogu4769 题意：给定一个排列ppp。求字典序严格大于ppp，且冒泡排序交换次数=∑i=1n∣i−pi∣= \sum _{i = 1} ^n |i - p_i|=∑i=1n​∣i−pi​∣的排列个数。n≤6×105n \le 6 \times 10^5n≤6×105 题解：整理自luogu题解 可以证明该问题等价于最长下降子序列的长度不能超过2。因为如果长度大于2，那么中间的元素会被...
luogu P4769 [NOI2018] 冒泡排序 - 计数
liuzhangfeiabc的博客
07-19 1169
传送门：https://www.luogu.org/problemnew/show/P4769 题目大意：考虑用冒泡排序的过程求一个排列的逆序对数，由于将pi从i位置移动到pi位置至少需要移动|i-pi|次，而每次交换最多实现2次正向移动，所以逆序对数的下界是1/2 sigma |i-pi|，当然这个下界并不总能达到（比如3 2 1有3个逆序对而计算得到的下界是2），求：给定n和排列p，满足字典...
LOJ2719 && Luogu4769 && bzoj 5416 NOI2018冒泡排序
was__n的博客
08-28 580
这道题题目的要求是冒泡排序的交换次数达到下界1/2Sigma |i-pi| ，首先想要达到下界，那么每一个元素的贡献也要达到下界，即1/2|i-pi|，所以对于每一个元素，和它有关的逆序对数量都是|i-pi|。 接下来进行第二步的转化， 1.i&gt;pi 逆序对数量为i-pi,可以推出比pi小的数都在i位置前 2.i&lt;pi 逆序对数量为pi-i,可以推出比i位置前的数都是小于pi的 ...
Luogu6186 [NOI Online #1 提高组] 冒泡排序
ShadyPi的IT笔记
01-31 343
原题链接：https://www.luogu.com.cn/problem/P6186 冒泡排序 题目描述 给定一个 1∼n1 ∼ n1∼n 的排列 pip_ipi​ ，接下来有 mmm 次操作，操作共两种： 交换操作：给定 xxx，将当前排列中的第 xxx 个数与第 x+1x+1x+1 个数交换位置。 询问操作：给定 kkk，请你求出当前排列经过 kkk 轮冒泡排序后的逆序对个数。 对一个长度为 nnn 的排列 pip_ipi​ 进行一轮冒泡排序的伪代码如下： for i = 1 to n-1:
P4769-[NOI2018]冒泡排序【组合数学,树状数组】
QuantAsk
06-28 164
题目链接:https://www.luogu.com.cn/problem/P4769有一个冒泡排序的算法 然后给出一个排列aaa，求在所有字典序大于aaa的排列ppp中冒泡排序交换次数恰好为∑i=1n∣i−pi∣\sum_{i=1}^n|i-p_i|∑i=1n​∣i−pi​∣的排列数。1≤n≤6×105,∑n≤2×1061\leq n\leq 6\times 10^5,\sum n\leq 2\times 10^61≤n≤6×105,∑n≤2×106打一下表发现合法的排列条件是最长下降子序列不超过222。
Luogu P6186 [NOI Online 提高组]冒泡排序
macesuted的博客
03-08 242
题面 大意就是给定一个序列，对其进行两个操作，交换相邻的两个数，或者对全序列进行一遍冒泡排序。 观察题面可以发现 当ti=1时我们需要交换相邻的两个数 当ti=2时我们需要对全序列进行冒泡排序 由于数据量极大，显然暴力的模拟一定不行 我们记录第i位数前面比它大的数的数量为before[i]before[i]before[i]，显然，当前序列的总逆序对数量就是所有的beforebeforebef...
[NOI2018]冒泡排序
weixin_34258078的博客
06-16 217
[NOI2018]冒泡排序 题解 性质+模型转化 首先，一个排列是“好”的，当且仅当：每个数，要么是前缀最大值，要么是后缀最小值。（讨论i和Pi的关系即可证明） 也就是，排列不能存在>=3的下降子序列！ 换句话说，假设之前填了i个数，最大值是mx，那么第i+1个数，要么是剩下数的最小值，要么是比mx大的数。 字典序，肯定按位考虑，转化成没有限制的情况， 所以先处理没有限...
vscode-luogu:解决VSCode中落谷问题
05-30
vscode-luogu轻松的让你在VSCode 上提交洛谷代码使用说明查看题目按下F1或Ctrl+Shift+P ，查找Luogu: 查看题目命令，点击后输入题号完成搜索点击界面左侧洛谷图片，然后点击搜索图标，输入题号完成搜索完成功能查看...
luogu-cli：罗古在线裁判的cli工具
03-04
如果luogu-cli在运行时产生了类似下面的错误： /usr/bin/env: “node \r ”: 没有那个文件或目录 请尝试下面的操作： 罗古里 洛谷命令行工具 支持以下功能： 译文查看 译文提交 译文搜索 奔奔发送 奔奔查看 云剪切...
luogu8月比赛PPT讲解
08-10
这个是luogu的PPT 8月的比赛 讲解PPT 挺好的 没有看过的可以去luogu看看，题目挺好的；
P1145 约瑟夫
zty20120913的博客
08-06 404
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 924
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 206
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 556
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
Luogu P1088 火星人
06-07
这是一道算法竞赛中的题目，需要使用动态规划算法来解决。 题目描述：有n个火星人，他们的能力值分别为a1,a2,…,an。现在你需要将他们划分成两组，使得他们的能力值之差最小，求这个最小的差值。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值