2019南昌网络赛I题 Yukino With Subinterval (动态主席树/CDQ)

最新推荐文章于 2019-10-22 15:38:40 发布
最新推荐文章于 2019-10-22 15:38:40 发布
阅读量227 收藏
点赞数
分类专栏： ACM-主席树 文章标签： ACM 主席树 修改 2019南昌网络赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31411163/article/details/100731507
版权

题目链接 - 计蒜客2019南昌网络赛

一个ACMer萌新 Happier233~

题目简述：

一个长度为n的数组，一共有m次操作，有两种操作：

  1. 修改pos的值为x
  2. 查询[L,R]范围内，权值在[X,Y]范围内的连续线段（线段内的权值相同）个数

n,m<=2e5
内存512MB,时限3.5秒

题目思路：

每次查询[L,R]范围内的线段，其实维护每个线段的开头的值就行了，然后查询[L+1,R]之间又多少个线段的开头，再算上L这个点开头的线段，查询这些线段头有多少是在[X,Y]范围内的，就是答案了。
之前正好在学习CDQ分治，看了看概念什么的，所以第一感觉这就是个CDQ分治啊，可惜网络赛的时候我还没学会CDQ，写不出来，心塞。
然后转头去做动态修改主席树了，每次修改的时候维护pos,pos+1是否是开头，以及变更情况，这样把权值更新进主席树就行了，每次查询[L+1,R]区间内[X,Y]的个数和，再计算L这个位置的值是否在[X,Y]范围内，这样就可以得到答案了。
出题人非常良心的放过了主席树的做法，内存和时间正好可以跑完主席树。
然后我学习网上别人的做法，优化了一下自己的主席树板子，这个代码可以在3秒内跑完，但优化之后可读性–（反正是板子，为了性能将就了）
啊，时隔N个月，发现当初AC的主席树代码怎么T了，难道是计蒜客的评测姬变慢了？？？顺手更新一下当初已经补完的CDQ分治代码

代码（动态主席树）：

// 巨菜的ACMer-Happier233

#include <bits/stdc++.h>

using namespace std;

//-----
typedef double db;
typedef long long ll;
typedef unsigned int ui;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define fi first
#define se second
#define pw(x) (1ll << (x))
#define tw(x, k) (((x) >> k) & 1)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define rep(i, l, r) for(int i=(l);i<(r);++i)
#define per(i, l, r) for(int i=(r)-1;i>=(l);--i)
#define mst(t, v, n) memset(t, v, sizeof(decltype(*(t))) * (n))
#define sf(x) scanf("%d", &(x))
#ifndef ACM_LOCAL
#define endl '\n'
#endif

const int N = int(2e5 + 10);
// m: update count,MAXN>=m*log(n)^2
const int MAXN = int(4e7 + 10);
const int LN = 40;

struct PSegTree {
    const int *a;
    pii ran;
    int n;
    int c[MAXN];
    int tot = 0;
    int lson[MAXN], rson[MAXN];
    // t: static root,s: dynamic root
    int t[N], s[N];

    int build(int l, int r) {
        int k = ++tot;
        c[k] = 0;
        if (l == r) {
            return k;
        }
        int mid = (l + r) >> 1;
        lson[k] = build(l, mid);
        rson[k] = build(mid + 1, r);
        return k;
    }

    // SegTree Range and n points, num can be nullptr
    int init(int l, int r, int _n, const int num[]) {
        tot = 0;
        a = num;
        ran = {l, r};
        n = _n;
        int rt = build(l, r);
        for (int i = 0; i <= n; i++) t[i] = s[i] = rt;
        return rt;
    }

    // update the root in k
    void update(int k[], int rt[], int cnt, int p, int v) {
        // calc
        for (int i = 0; i < cnt; i++)
            c[k[i]] = c[rt[i]] + v;
        int l, r;
        tie(l, r) = ran;
        while (l < r) {
            int mid = (l + r) >> 1;
            // 下面的逗号表达式顺序不能换
            if (p <= mid) {
                // go left
                for (int i = 0; i < cnt; i++) {
                    rson[k[i]] = rson[rt[i]], rt[i] = lson[rt[i]], k[i] = lson[k[i]] = ++tot;
                }
                r = mid;
            } else {
                // go right
                for (int i = 0; i < cnt; i++) {
                    lson[k[i]] = lson[rt[i]], rt[i] = rson[rt[i]], k[i] = rson[k[i]] = ++tot;
                }
                l = mid + 1;
            }
            // calc
            for (int i = 0; i < cnt; i++)
                c[k[i]] = c[rt[i]] + v;
        }
    }

    // build static tree
    inline void change(int pos, int p, int v) {
        if (v == 0) t[pos] = t[pos - 1];
        else { // use int as the int[]
            int rt = t[pos - 1];
            int k = t[pos] = ++tot;
            update(&k, &rt, 1, p, v);
        }
    }

    int use1[LN], use2[LN];

    inline void add(int pos, int p, int v) {
        // memory reuse
        int *k = use1, *rt = use2;
        int cnt = 0;
        for (int i = pos; i <= n; i += (i & -i), cnt++) {
            rt[cnt] = s[i], s[i] = k[cnt] = ++tot;
        }
        update(k, rt, cnt, p, v);
    }

    // calc lson value in use
    inline int sum(int use[], int cnt) {
        int ans = 0;
        for (int i = 0; i < cnt; i++)
            ans += c[lson[use[i]]];
        return ans;
    }

    // calc value in use
    inline int calc(int use[], int cnt) {
        int ans = 0;
        for (int i = 0; i < cnt; i++)
            ans += c[use[i]];
        return ans;
    }

    // ans=p1-p2
    int query(int p1, int p2, int k) {
        int r1 = t[p1], r2 = t[p2];
        int cnt1 = 0, cnt2 = 0;
        // calc root in need
        for (int i = p1; i; i -= (i & -i)) use1[cnt1++] = s[i];
        for (int i = p2; i; i -= (i & -i)) use2[cnt2++] = s[i];
        int l, r;
        tie(l, r) = ran;
        int ans = 0;
        while (l < r) {
            int mid = (l + r) >> 1;
            int cnt = c[lson[r1]] - c[lson[r2]] + sum(use1, cnt1) - sum(use2, cnt2);
            if (k <= mid) {
                // go left
                r1 = lson[r1], r2 = lson[r2];
                for (int i = 0; i < cnt1; i++) use1[i] = lson[use1[i]];
                for (int i = 0; i < cnt2; i++) use2[i] = lson[use2[i]];
                r = mid;
            } else {
                // go right
                ans += cnt;
                r1 = rson[r1], r2 = rson[r2];
                for (int i = 0; i < cnt1; i++) use1[i] = rson[use1[i]];
                for (int i = 0; i < cnt2; i++) use2[i] = rson[use2[i]];
                l = mid + 1;
            }
        }
        int cnt = c[r1] - c[r2] + calc(use1, cnt1) - calc(use2, cnt2);
        ans += cnt;
        return ans;
    }
} tree;

int a[N], c[N];

void solve() {
    int n, q;
    while (cin >> n >> q) {
        for (int i = 1; i <= n; i++) cin >> a[i];
        c[1] = a[1];
        for (int i = 2; i <= n; i++) c[i] = (a[i] == a[i - 1] ? 0 : a[i]);
        tree.init(0, n, n, nullptr);
        for (int i = 1; i <= n; i++) tree.change(i, c[i], c[i] > 0);
        while (q--) {
            int op;
            cin >> op;
            if (op == 1) {
                int p, x;
                cin >> p >> x;
                if (a[p] == x) continue;
                // del p
                if (c[p]) {
                    tree.add(p, c[p], -1);
                    c[p] = 0;
                }
                // add p+1
                if (p < n && a[p] == a[p + 1]) {
                    c[p + 1] = a[p + 1];
                    tree.add(p + 1, c[p], 1);
                }
                if (p < n && x == a[p + 1]) {
                    tree.add(p + 1, c[p + 1], -1);
                    c[p + 1] = 0;
                }
                a[p] = x;
                // add p
                if (p == 1 || a[p - 1] != a[p]) {
                    c[p] = a[p];
                    tree.add(p, c[p], 1);
                }
            } else {
                int l, r, x, y;
                cin >> l >> r >> x >> y;
                int cnty = 0, cntx = 0;
                cnty = tree.query(r, l, y);
                cntx = tree.query(r, l, x - 1);
                int ans = cnty - cntx + (a[l] >= x && a[l] <= y);
                cout << ans << endl;
            }
        }
    }
}

int main() {
#ifdef ACM_LOCAL
    freopen("./data/std.in", "r", stdin);
    // freopen("./data/std.out", "w", stdout);
#else
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#endif

#ifdef ACM_LOCAL
    auto start = clock();
#endif
    int t = 1;
//    cin >> t;
    while (t--)
        solve();
#ifdef ACM_LOCAL
    auto end = clock();
    cerr << "Run Time: " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
#endif
    return 0;
}

###代码（CDQ分治）

// 巨菜的ACMer-Happier233

#include <bits/stdc++.h>

using namespace std;

//-----
typedef double db;
typedef long long ll;
typedef unsigned int ui;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define fi first
#define se second
#define pw(x) (1ll << (x))
#define bt(x, k) (((x) >> k) & 1)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define rep(i, l, r) for(int i=(l);i<(r);++i)
#define per(i, l, r) for(int i=(r)-1;i>=(l);--i)
#define mst(t, v, n) memset(t, v, sizeof(decltype(*(t))) * (n))
#define sf(x) scanf("%d", &(x))
#ifndef ACM_LOCAL
#define endl '\n'
#endif

const int N = int(3e5 + 10);

struct BITree {
    int n;
    ll c[N];

    void init(int _n) {
        n = _n + 1;
        memset(c, 0, sizeof(ll) * n);
    }

    void change(int pos, ll v) {
        for (int i = pos; i < n; i += i & (-i))
            c[i] += v;
    }

    ll query(int x) {
        ll ans = 0;
        for (int i = x; i > 0; i -= i & (-i))
            ans += c[i];
        return ans;
    }

    void update(int l, int r, ll v) {
        change(l, v);
        change(r + 1, -v);
    }
} tree;

struct node {
    // time: 修改时间 | id: 0,1 | f: 正负 | x是下标 | y是权值
    int time, id, f, x, y;
};

bool cmp(const node &a, const node &b) {
    return a.x < b.x;
}

int ans[N];
node p[N << 2], et[N << 2];

void cdq(int l, int r) {
    if (l + 1 == r) return;
    int mid = (l + r) >> 1;
    cdq(l, mid), cdq(mid, r);
    int t = l;
    for (int i = mid; i < r; i++) {
        if (p[i].id)continue;
        for (; t < mid && p[t].x <= p[i].x; t++) {
            if (p[t].id) tree.change(p[t].y, p[t].f);;

        }
        int f = p[i].f;
        int cnt = tree.query(p[i].y);
        ans[p[i].time] += f * cnt;
    }
    // 逆操作p[t].y
    while (--t >= l) {
        if (p[t].id) tree.change(p[t].y, -p[t].f);
    }
    // 归并排序
    int t1 = l, t2 = mid, k = 0;
    while (t1 < mid && t2 < r) {
        et[k++] = p[t1].x < p[t2].x ? p[t1++] : p[t2++];
    }
    copy(p + t1, p + mid, et + k);
    copy(p + t2, p + r, et + k);
    copy(et, et + (r - l), p + l);
}

int a[N];
int c[N];

void solve() {
    int n, q;
    while (cin >> n >> q) {
        a[0] = 0;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        int tot = 0;
        for (int i = 1; i <= n; i++) {
            if (a[i] != a[i - 1]) {
                p[tot++] = {0, 1, 1, i, a[i]};
            }
        }
        mst(c, 0, n + 1);
        for (int i = 1; i <= q; i++) {
            int op;
            cin >> op;
            if (op == 1) {
                int pos, v;
                cin >> pos >> v;
                ans[i] = -1;
                if (a[pos] == v) continue;
                // del p
                if (a[pos] != a[pos - 1]) {
                    p[tot++] = {i, 1, -1, pos, a[pos]};
                }
                // add pos+1
                if (pos < n && a[pos] == a[pos + 1]) {
                    p[tot++] = {i, 1, 1, pos + 1, a[pos + 1]};
                }
                if (pos < n && v == a[pos + 1]) {
                    p[tot++] = {i, 1, -1, pos + 1, a[pos + 1]};
                }
                a[pos] = v;
                // add pos
                if (pos == 1 || a[pos - 1] != a[pos]) {
                    p[tot++] = {i, 1, 1, pos, a[pos]};
                }
                ans[i] = -1;
            } else {
                ans[i] = 0;
                int l, r, x, y;
                cin >> l >> r >> x >> y;
                if (a[l] >= x && a[l] <= y && a[l] == a[l - 1]) {
                    ans[i] = 1;
                }
                p[tot++] = {i, 0, 1, r, y};
                p[tot++] = {i, 0, -1, r, x - 1};
                p[tot++] = {i, 0, -1, l - 1, y};
                p[tot++] = {i, 0, 1, l - 1, x - 1};
            }
        }
        tree.init(n);
        cdq(0, tot);
        for (int i = 1; i <= q; i++) {
            if (~ans[i]) cout << ans[i] << endl;
        }
    }
}

int main() {
#ifdef ACM_LOCAL
    freopen("./data/std.in", "r", stdin);
    // freopen("./data/std.out", "w", stdout);
#else
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#endif

#ifdef ACM_LOCAL
    auto start = clock();
#endif
    int t = 1;
//    cin >> t;
    while (t--)
        solve();
#ifdef ACM_LOCAL
    auto end = clock();
    cerr << "Run Time: " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
#endif
    return 0;
}
Happier233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
2019 南昌网络赛 I. Yukino With Subinterval（CDQ 分治）
qq_41997978的博客
09-23 148
题目大意：有一个数组，支持单点修改：将第 i 个位置的值变成 v。让你查询[L,R]区间内，值域在[x,y] 范围内，连续的段数，连续的段数指值相同位置连续的一段，并且连续段的长度在[L,R]内必须尽可能的长。 先对数组预处理，将连续的段缩到左端点，即新建一个数组 b, 若 a[i]!=a[i−1]a[i] != a[i - 1]a[i]!=a[i−1]，则b[i]=1b[i] = 1b[i...
2019南昌网络赛 Yukino With Subinterval —— 树套树 或 cbq分治
Scar_Halo
09-10 358
题目链接：点我啊╭(╯^╰)╮       最快写法： #include<bits/stdc++.h> #define rint register int #define deb(x) cerr<<#x<<" = "<<(x)<<'\n'; //#pragma GCC op...
2019ICPC南昌网络赛 - I. Yukino With Subinterval
weixin_44059127的博客
09-09 261
题意： 给定一个长为 n 的数组，定义值相同的区间为一子段，有 m 个操作，①：1，pos，v，修改 pos 上的值为 v；②：2，l，r，x，y，询问区间 [ l, r ] 的值域在 [ x, y ] 的段个数，只计最长段。(n, m <= 2e5) 链接： https://nanti.jisuanke.com/t/41356 题解： 考虑将段转化为点，令 b[i] = a[i] != a...
2019南昌网络赛 I Yukino With Subinterval
binarycopycode
09-20 147
https://nanti.jisuanke.com/t/41356 听说这题可以用cdq分治，昨天学习了一下cdq分治，发现这题是道水题了。。。 把每个询问拆成四个询问(1,r,1,y)-(1,l-1,1,y)-(1,r,1,x-1)+(1,l-1,1,x-1); 然后我们在每一段的开头第一个的颜色加上1，每一次修改操作，只会影响当前位置l和下一个位置l+1是不是新的一段的开头，这些变化都...
2019ICPC南昌网络赛 I. Yukino With Subinterval (带修主席树/CDQ分治)
积极的防守者的博客
09-18 300
题意： 给你一个数组，带修改，每次查询一个区间内，值在[x,y]区间内的最长连续段个数。 题解： 把所有连续段缩到它的左端点，查询的时候只要查[l+1,r]区间内有多少个左端点即可，a[l]这个点因为是第一个点所以特殊判断它是否在[x,y]范围内就可以了。 查询[l+1,r]区间内有多少个值在[x,y]范围内的数是经典的主席树问题，因为带修改所以用树状数组套主席树（上一次敲这玩意是一年前的事情了…...
北邮计院大二计算机网络课设
07-23
【计算机网络】是信息技术的重要组成部分，它涉及到计算机与计算机之间的通信和数据传输。在这个北邮计院大二的计算机网络课设中，学生被要求使用C语言来编写代码，这是一项基础而重要的编程技能，因为C语言对于理解...
yukino:以雪野为善
06-27
雪野 以雪野为善 规则 每个人有一个fork，拉一个topic分支 拉取请求总是由其他人审查和合并。
Yukino:[WIP] Rust的ORM框架
03-31
Yukino是Rust的ORM框架 特征 通过类型和注释定义模型 数据库抽象层 查询生成器 协会管理 延迟执行 自动缓存和反向缓存 命令行管理工具 为雪乃子做贡献 该项目使用Rust Stable构建。 设置测试架构 cargo run --...
Yukino可让您免费阅读漫画或从多个来源免费获取动漫广告！-Vue.js开发
05-27
Yukino允许您从多个来源阅读漫画或流媒体无广告的动漫。 该项目的名称“ Yukino”意为“雪”，以动漫“ Yahari Ore no Seishun Love Comedy wa Machigatteiru”中的角色“ Yukino Yukinoshita”命名。 Yukino Yukino...
bayesgrad:贝叶斯梯度
05-29
BayesGrad：解释图卷积网络的预测 该论文可在 arXiv 上获得， //arxiv.org/abs/1807.01985。 左起：tox21 吡啶 (C5H5N)、tox21 SR-MMP、德莱尼溶解度可视化。 引文 如果您发现我们的工作对您的研究有用，请考虑引用...
I. Yukino With Subinterval 树套树入门题
qq_44335608的博客
10-22 160
I. Yukino With Subinterval 题意：有两种操作，第一种修改一个位置的值，第二种求给定区间[l,r]内有多少合法区间。合法区间定义：al = al+1 = … = ar ,且该区间为最长。 题解：如果这题不带修改，主席树就写完了。那么带修改动态开点线段树套树状数组。 注意：这题卡常，需要快读。 #include<bits/stdc++.h> #define m (...
2019 Nanchang Online Contest Problem I Yukino With Subinterval
Gipsy
09-11 202
将每个连续的最右端赋值权值1，需要写带修改的主席树，我没写过拿CDQ分治水过 这题居然是全场AC最少的题目，我一个半小时搞定（其实是因为写主席树写了一半发现不会写，改成了CDQ分治） #include<bits/stdc++.h> using namespace std; #define maxn 2000005 int s,w,n,cnt; int ans[maxn],sum[...
Yukino With Subinterval（CDQ分治）
jkchen's Haven
09-11 306
original link - https://nanti.jisuanke.com/t/41356 题意： 给出一个数组，每次询问区间[L,R][L,R][L,R]内有多少个连续段，其值域在[x,y][x,y][x,y]上。有单点修改。 解析： 直接带修主席树内存被卡了，这个东西除了模板题我还没有AAA过题，不是内存被卡就是时间被卡…… 将一段连续值的点，集中在区间左端点上，即只有左端点有值。相...
2019南昌网络赛-I. Yukino With Subinterval 线段树套树状数组,CDQ分治
qq_40921866的博客
09-13 141
TMD。。。这题卡内存卡的真优秀。。。 所以以后还是别用主席树的写法。。。不然怎么死的都不知道。。。 树套树中，主席树方法开权值线段树。。。会造成空间的浪费。。。这道题内存卡的很紧。。。 由于树套树已经不需要持久化了，直接动态开点就完事了。。。用主席树方法开过不去，要么超内存，要么越界。。。 大概思路。。。这题要求的[L,R]区间内，满足x<=a[i]<=y的连续的段...
2019 南昌网络赛题解
mxYlulu的博客
09-11 325
A、B、E、G、H、IA、B、E、G、H、IA、B、E、G、H、I代码见githubgithubgithub链接：点击这里 比赛时候真的很可惜，差点可以校div2rank1div2 rank1div2rank1的，和第一差了一分钟的罚时(不到) 只做出来五题，EEE只是运气好，数据比较弱。 正解在这里，不过我并没有看懂： B Fire-Fighting Hero 题意 给定无向图 求kkk个点到...
深度优先遍历之树边，前向边，回边，横跨边
热门推荐
wshish920907的博客
06-15 1万+
根据在有向图G上进行深度优先遍历所产生的深度优先森林，可以把图中的边分为四类： （1）树边：是DFS森林的实际组成部分。如果顶点v是在探测边（u，v）时首次被发现的，那么（u，v）就是一条树边。 （2）前向边：：是DFS树中从一个顶点指向该顶点的一个非子顶点后裔的边。 （3）回边：是DFS树中从一个顶点指向其祖先的边（有向图中可能出现的自环也被认为是反向边）。 （4）横跨边：既不是从一个顶
C. Gerald and Giant Chess CodeForces - 559C(组合数学)
deerly_的博客
08-13 191
题目链接 Problem 从(1, 1)走到(n, m),只能往右走或者下走，有k个点不能走，问合法的路径条数有多少条？ 数据范围： 1&lt;=h, w&lt;=1e5, 1&lt;=n&lt;=2000. Input 3 4 2 2 2 2 3 Output 2 Ideas 前置技能：从(x1, y1)走到(x2, y2)...
第18届浙江省赛-Traffic Light （BFS）
Akatsuki
04-08 654
题目链接 从给定点的坐标走到目的地，问最短步数。 输入给出m*n的矩阵，矩阵只包含0和1。 最后一行输入起始点和终止点。 0代表只能向上向下走，1代表只能向左向右走。 每走一步之后，矩阵中所有的1变为0,0变为1。 当然，在当前的坐标中不能停留，下一秒必须要走。 思路大概就是判断步数的奇偶性然后和当前步数矩阵的奇偶性做BFS。 但是输入的数据很坑，只给了 n*m&lt;=1e5的数...
./huaweiyun: 40: ./huaweiyun: Syntax error: "(" unexpected ------------------ (program exited with code: 2) Press return to continue
最新发布
06-18
看起来你可能在尝试运行一个包含语法错误的 Huawei Cloud 相关的命令或脚本。错误信息提示有一个"("（左括号）是意外的，这通常意味着在预期的地方没有正确关闭一个括号或者括号使用不匹配。编程语言中，括号用于定义代码块或参数列表，如果它们没有配对使用，编译器或解释器就会报错。 修复这个问题，你需要检查出问题的代码行，看看是否有遗漏的")"或者其他应该关闭但未关闭的括号。逐步检查附近的语句，确保所有开始的括号都有相应的结束括号，并且它们之间的层次结构正确。有时，缩进或格式问题也可能导致这种错误。 如果你需要具体帮助，你可以提供代码片段，我会尽力帮你找出问题所在。现在，如果你有关于编程中的括号使用、语法错误排查或者华为云操作的一般性问题，也可以直接提问。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值