题目:排序(二分&线段树)

题目

传送门

思路

此题两个思路

卡着过

表面上看这是一道紫题,但是数据真的水
用心造题,用脚造数据
实际上桶排就能过
但是需要加一个小优化
对于每次排序的区间
只需要从区间的最小值枚举到最大值就行了

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<climits>
#include<algorithm>
using namespace std;
void read(int &x)
{
    x=0;
    int f=1;
    char c=getchar();
    while('0'>c||c>'9')
    {
        if(c=='-')
            f=-1;
        c=getchar();
    }
    while('0'<=c&&c<='9')
    {
        x=(x<<3)+(x<<1)+c-'0';
        c=getchar();
    }
    x*=f;
}
void write(int x)
{
    if(x<10)
        putchar(x+'0');
    else
    {
        write(x/10);
        putchar(x%10+'0');
    }
}
int n,m;
int minn;
int maxx;
int a[100005];
int cm;
int be;
int ne;
int q;
bool t[100005];
inline void sortt(int l,int r,int f)
{
    minn=INT_MAX;
    maxx=INT_MIN;
    for(int i=l;i<=r;i++)
    {
        t[a[i]]=1;
        minn=min(minn,a[i]);
        maxx=max(maxx,a[i]);
    }
    if(f==0)
    {
        for(int i=minn;i<=maxx;i++)
        {
            if(t[i])
            {
                a[l++]=i;
                t[i]=0;
            }
        }
    }
    else
    {
        for(int i=maxx;i>=minn;i--)
            if(t[i])
            {
                a[l++]=i;
                t[i]=0;
            }
    }
}
int main()
{
    read(n);
    read(m);
    for(int i=1;i<=n;i++)
        read(a[i]);
    for(int i=1;i<=m;i++)
    {
        read(cm);
        read(be);
        read(ne);
        sortt(be,ne,cm);
        /*for(int j=1;j<=n;j++)
        {
            cout<<a[j]<<' ';
        }
        cout<<'\n';*/
    }
    read(q);
    write(a[q]);
    return 0;
}   

正解

题目上有一个很有意思的点,也是本题的突破口
我们只需要输出\(a_q\)就行了
将序列重新构造成为一个01序列
如果\(a_i<x\)
则\(b_i==0\)
否则\(b_i==1\)
这样子序列的排列就很简单了
如果是从小到大,就直接000011111
或者就11100000
之后我们查\(a_q\)的值,如果\(a_q<x\)则\(ans<x\)
反之则\(ans>x\)
也就是我们可以将最后的答案通过二分确定在一个范围之内

代码(直接贴trymyedge发的STD)

#include <cstdio>
#include <cstring>
#include <cctype>
#define lc o << 1
#define rc o << 1 | 1
#define mid (l + r) / 2
using namespace std;

const int N = 100010;
int n, m, p;
int T[4 * N], lazy[4 * N];    // segment tree
int a[N], ch[N], L[N], R[N];  // the information by reading

inline int read() {
    char ch = getchar();
    int x = 0;
    while (!isdigit(ch)) ch = getchar();
    while (isdigit(ch)) {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x;
}

inline void build(int o, int l, int r, int x) {
    if (l == r) {
        T[o] = a[l] >= x;
        lazy[o] = 0;
        return;
    }
    build(lc, l, mid, x);
    build(rc, mid + 1, r, x);
    T[o] = T[lc] + T[rc];
    lazy[o] = 0;
}

inline void pushdown(int o, int l, int r) {
    if (!lazy[o])
        return;
    lazy[lc] = lazy[rc] = lazy[o];
    if (lazy[o] == 1) {
        T[lc] = mid - l + 1;
        T[rc] = r - mid;
    } else
        T[lc] = T[rc] = 0;
    lazy[o] = 0;
}

inline int query(int o, int l, int r, int x, int y) {
    if (x <= l && y >= r)
        return T[o];
    if (x > r || y < l)
        return 0;
    pushdown(o, l, r);
    return query(lc, l, mid, x, y) + query(rc, mid + 1, r, x, y);
}

inline int queryPoint(int o, int l, int r, int x) {
    if (l == x && r == x)
        return T[o];
    pushdown(o, l, r);
    if (x <= mid)
        return queryPoint(lc, l, mid, x);
    else
        return queryPoint(rc, mid + 1, r, x);
}

inline void update(int o, int l, int r, int x, int y, int val) {
    if (x <= l && y >= r) {
        T[o] = val * (r - l + 1);
        lazy[o] = val ? 1 : -1;
        return;
    }
    if (x > r || y < l)
        return;
    pushdown(o, l, r);
    update(lc, l, mid, x, y, val);
    update(rc, mid + 1, r, x, y, val);
    T[o] = T[lc] + T[rc];
}

inline bool check(int x) {
    build(1, 1, n, x);
    for (int i = 1; i <= m; i++) {
        int cnt1 = query(1, 1, n, L[i], R[i]);
        if (ch[i] == 0) {
            update(1, 1, n, R[i] - cnt1 + 1, R[i], 1);
            update(1, 1, n, L[i], R[i] - cnt1, 0);
        } else {
            update(1, 1, n, L[i], L[i] + cnt1 - 1, 1);
            update(1, 1, n, L[i] + cnt1, R[i], 0);
        }
    }
    return queryPoint(1, 1, n, p);
}

int main() {

    n = read();
    m = read();
    for (int i = 1; i <= n; i++) a[i] = read();
    for (int i = 1; i <= m; i++) {
        ch[i] = read();
        L[i] = read();
        R[i] = read();
    }
    p = read();
    int ll = 1, rr = n, midd, ans;
    while (ll <= rr) {
        midd = (ll + rr) >> 1;
        if (check(midd))
            ans = midd, ll = midd + 1;
        else
            rr = midd - 1;
    }
    printf("%d\n", rr);
    return 0;
}

原文地址:https://www.cnblogs.com/loney-s/p/11845381.html

时间: 2024-10-29 04:20:22

题目:排序(二分&线段树)的相关文章

[BZOJ] 4552: [Tjoi2016&amp;Heoi2016]排序 #二分+线段树+算法设计策略

4552: [Tjoi2016&Heoi2016]排序 Time Limit: 60 Sec  Memory Limit: 256 MBSubmit: 1451  Solved: 734[Submit][Status][Discuss] Description 在2016年,佳媛姐姐喜欢上了数字序列.因而他经常研究关于序列的一些奇奇怪怪的问题,现在他在研究一个难题 ,需要你来帮助他.这个难题是这样子的:给出一个1到n的全排列,现在对这个全排列序列进行m次局部排序,排 序分为两种:1:(0,l,r

【BZOJ4552】排序(线段树,二分答案)

[BZOJ4552]排序(线段树,二分答案) 题面 BZOJ 题解 好神的题啊 直接排序我们做不到 怎么维护? 考虑一下,如果我们随便假设一个答案 怎么检验它是否成立? 把这个数设成\(1\),其他的数字都设成\(0\) 最后检查一下这个位置是不是\(1\)就好啦 但是这样没法排序 那么,我们考虑二分一个答案, 把所有比\(mid\)大的数都设成\(1\) 这样,如果在第\(Q\)位上的数字是\(1\) 意味着有一个不小于当前\(mid\)的数在这个位置上 否则就是一个比\(mid\)小的数在这

【BZOJ-3110】K大数查询 整体二分 + 线段树

3110: [Zjoi2013]K大数查询 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 6265  Solved: 2060[Submit][Status][Discuss] Description 有N个位置,M个操作.操作有两种,每次操作如果是1 a b c的形式表示在第a个位置到第b个位置,每个位置加入一个数c如果是2 a b c形式,表示询问从第a个位置到第b个位置,第C大的数是多少. Input 第一行N,M接下来M行,每行形如1 a

bzoj4552排序(线段树,二分)

题目大意 给定一个长度为n的序列,有m个操作,操作包括两种: \(0\ l\ r\)区间[l,r]的数字升序排序 \(1\ l\ r\)区间[l,r]的数字降序排序 最后询问在q位置上的数是多少? 其中\(n \le 100000,m\le 100000\) QWQ这个题是看了题解才会的,感觉思路很不错 我们考虑,这个题的询问其实只有一组,所以我们可以 二分一个最终在q的数是多少(或者说在原来的排名是多少) 每次将大于等于\(mid\)的数变为1,小于的为0. 那么对于升序排序,假设这个区间有\

bzoj4552 [Tjoi2016&amp;Heoi2016]排序 (线段树+二分)

题意:一个1~n的排列,m个操作: 0 x y:将ax~ay按升序排列: 1 x y:将ax~ay按降序排列. 询问m次操作后第aq的值. 输入:第一行:两个正整数n,m,表示序列的长度与询问的个数: 第二行:一个1~n的排列: 第3~m+2行:每行一个操作. 第m+3行:一个数q表示询问的位置. 输出:一个数表示aq的值. 样例输入: 6 3 1 6 2 5 3 4 0 1 4 1 3 6 0 2 4 3 样例输出: 5 解析:考虑二分答案,将小于答案的数变为0,将大于等于答案的变为1,这样整

HDU5008 Boring String Problem(后缀数组 + 二分 + 线段树)

题目 Source http://acm.hdu.edu.cn/showproblem.php?pid=5008 Description In this problem, you are given a string s and q queries. For each query, you should answer that when all distinct substrings of string s were sorted lexicographically, which one is

【10.7校内测试】【队列滑窗】【2-sat】【贪心+栈二分+线段树(noip模拟好题)】【生日祭!】

比较好想的一道题,直接用队列滑窗,因为扫一遍往队列里加东西时,改变的只有一个值,开桶储存好就行了! #include<bits/stdc++.h> using namespace std; int n, k, r; inline int min(int a, int b) { return a > b ? b : a; } inline int max(int a, int b) { return a > b ? a : b; } int sum[200005], q[200005

Hacker Cups and Balls Gym - 101234A 二分+线段树

题目:题目链接 题意:有编号从1到n的n个球和n个杯子. 每一个杯子里有一个球, 进行m次排序操作,每次操作给出l,r. 如果l<r,将[l,r]范围内的球按升序排序, 否则降序排, 问中间位置的数是多少. 思路: 暴力复杂度为m*nlog(n), 不能暴力排序 二分答案, 对于当前mid, 我们将大于等于mid的数记为1, 否则记0, 则排序就是将某个区间的数改为1或0, 通过线段树区间更新可以方便的做到, 对排序后的结果查询判断二分区间应该取左还是取右, 若中间的数是1, 则说明答案大于等于

JZOJ4605. 排序(线段树合并与分裂)

题目大意: 每次把一个区间升序或降序排序,最后问一个点是什么. 题解: 如果只是问一个点,这确乎是个经典题,二分一下答案然后线段树维护01排序. 从pty那里get到了可以用线段树的合并与分裂实时地维护整个序列. 考虑一次排序就把这个区间的数搞到一个线段树上,在根处标记是正的还是反的. 如果想搞到一棵树上就需要用到分裂与合并,根据势能分析,复杂度还是\(O(n~log~n)\). Code: #include<bits/stdc++.h> #define fo(i, x, y) for(int

(困难) CF 484E Sign on Fence,整体二分+线段树

Bizon the Champion has recently finished painting his wood fence. The fence consists of a sequence of n panels of 1 meter width and of arbitrary height. The i-th panel's height is hi meters. The adjacent planks follow without a gap between them. Afte