Acwing 4339 敌兵布阵 暴力 + 分块 + 线段树 + Zkw线段树 + 树状数组

置顶 已于 2022-03-20 11:27:28 修改
阅读量571 收藏 1
点赞数 1
分类专栏： AcWing c++ 文章标签： c++
于 2022-03-20 11:25:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WangXinyu_090926/article/details/123609808
版权

来一篇超全题解

数据结构大杂烩

原题连接

题目描述

敌人有 N N N 个工兵营地，编号 1 ∼ N 1∼N 1∼N。

初始时，第 i i i 个营地有 a i a_i ai​ 个人。

接下来有若干个命令，命令有 4 4 4 种形式：

Add i j， i i i 和 j j j 为正整数，表示第 i i i 个营地增加 j j j 个人。（ j j j 不超过 30 30 30）
Sub i j， i i i 和 j j j 为正整数，表示第 i i i 个营地减少 j j j 个人。（ j j j 不超过 30 30 30）
Query i j， i i i 和 j j j 为正整数 （ i ≤ j ） （i≤j） （i≤j），表示询问第 i i i 到第 j j j 个营地的总人数。
End，表示结束，此命令只会作为最后一条命令出现。
请你计算每个 Query 的答案。

输入格式
第一行包含整数 T T T，表示共有 T T T 组测试数据。

每组数据第一行包含一个整数 N N N。

第二行包含 N N N 个整数 a 1 , a 2 , … , a N a1,a2,…,aN a1,a2,…,aN。

接下来若干行，每行包含一条命令，格式如题目所述。

输出格式
对于第 i i i 组数据，首先输出一行 Case i:，然后对于每个 Query 询问，输出一行一个整数，表示询问的段中的总人数。

数据范围

1 ≤ T ≤ 10 , 1≤T≤10, 1≤T≤10,
1 ≤ N ≤ 50000 , 1≤N≤50000, 1≤N≤50000,
1 ≤ a i ≤ 50 , 1≤ai≤50, 1≤ai≤50,
每组数据最多有 40000 40000 40000 条命令，
保证任何营地的人数都不会减少为负数。

输入样例：

1
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End

输出样例：

Case 1:
6
33
59

Code

暴力 + 快读快写 + 吸氧 T L 90 p t s TL 90pts TL90pts

#include <cstdio>

#pragma GCC target ("avx") 
#pragma GCC optimize (2, 3, "Ofast", "inline", "-ffast-math")

const int N = 5e4 + 10;

int n, a[N];

namespace IO
{
    template <class T> inline void read (T &x) { x = 0; bool f = 0; char ch = getchar (); while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar (); while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar (); x = f ? ~x + 1 : x; }
    template <class T> inline void write (T x) { static char c[20]; unsigned p = 0; if (x < 0) putchar ('-'), x = ~x + 1; if (!x) { putchar ('0'); return ; } while (x) c[++p] = x % 10 ^ 48, x /= 10; while (p) putchar (c[p]), --p; }
    template <class T, class... U> inline void read (T &x, U &...t) { read (x), read (t...); }
    template <class T, class... U> inline void write (T x, U ...t) { write (x), write (t...); }
}

using namespace IO;

int main ()
{
    int _; read (_);
    for (int T = 1; T <= _; ++T)
    {
        read (n);
        for (int i = 1; i <= n; ++i) read (a[i]);
        
        printf ("Case %d:\n", T);
        while (true)
        {
            char opt[5];
            int x, y;
            
            scanf ("%s", opt);
            if (*opt == 'A') read (x, y), a[x] += y;
            if (*opt == 'S') read (x, y), a[x] -= y;
            if (*opt == 'Q')
            {
                read (x, y);
                int res = 0;
                for (int i = x; i <= y; ++i) res += a[i];
                write (res), putchar ('\n');
            }
            if (*opt == 'E') break;
        }
    }
    return 0;
}

优雅的暴力永不过时~~

分块 A C AC AC 1194 m s 1194ms 1194ms

O ( m n ) O(m \sqrt{n}) O(mn ​)

#include <cstdio>
#include <cmath>
#include <cstring>

#pragma GCC target ("avx")
#pragma GCC optimize (2, 3, "Ofast", "inline", "-ffast-math")

const int N = 5e4 + 10, M = 230;

int n, m, unit, w[N], pos[N], sum[M];

inline void update (int k, int x)
{
    w[k] += x, sum[pos[k]] += x;
}

inline int query (int l, int r)
{
    int res = 0;
    if (pos[l] == pos[r])
        for (int k = l; k <= r; ++k) res += w[k];
    else
    {
        int i = l, j = r;
        while (pos[i] == pos[l]) res += w[i], ++i;
        while (pos[j] == pos[r]) res += w[j], --j;
        for (int k = pos[i]; k <= pos[j]; ++k) res += sum[k];
    }
    return res;
}

namespace IO
{
    template <class T> inline void read (T &x) { x = 0; bool f = 0; char ch = getchar (); while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar (); while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar (); x = f ? ~x + 1 : x; }
    template <class T> inline void write (T x) { static char c[20]; unsigned p = 0; if (x < 0) putchar ('-'), x = ~x + 1; if (!x) { putchar ('0'); return ; } while (x) c[++p] = x % 10 ^ 48, x /= 10; while (p) putchar (c[p]), --p; }
    template <class T, class... U> inline void read (T &x, U &...t) { read (x), read (t...); }
    template <class T, class... U> inline void write (T x, U ...t) { write (x), write (t...); }
}

using namespace IO;

inline void init ()
{
    unit = sqrt (n);
    for (int i = 1; i <= n; ++i) read (w[i]), sum[pos[i] = i / unit] += w[i];
}

int main ()
{
    int _; read (_);
    
    for (int T = 1; T <= _; ++T)
    {
        memset (sum, 0, sizeof sum);
        
        read (n);
        init ();
        
        printf ("Case %d:\n", T);
        while (true)
        {
            char opt[5];
            int x, y;
            scanf ("%s", opt);
            
            if (*opt == 'A') read (x, y), update (x, y);
            if (*opt == 'S') read (x, y), update (x, -y);
            if (*opt == 'Q') read (x, y), write (query (x, y)), putchar ('\n');
            if (*opt == 'E') break;
        }
    }
    return 0;
}

大杀器

线段树 A C AC AC 1868 m s 1868ms 1868ms

O ( m log ⁡ 2 n ) O(m \log_2{n}) O(mlog2​n)

#include <cstdio>

#pragma GCC target ("avx")
#pragma GCC optimize (2, 3, "Ofast", "inline", "-ffast-math")

const int N = 5e4 + 10;

int n, a[N], tr[N << 2], tag[N << 2];

inline void push_up (int x)
{
    tr[x] = tr[x << 1] + tr[x << 1 | 1];   
}

inline void push_down (int mid, int l, int r, int x)
{
    tr[x << 1] += tag[x] * (mid - l + 1);
    tr[x << 1 | 1] += tag[x] * (r - mid);
    tag[x << 1] += tag[x], tag[x << 1 | 1] += tag[x], tag[x] = 0;
}

inline void build (int l = 1, int r = n, int x = 1)
{
    if (l == r) tr[x] = a[l];
    else
    {
        int mid = l + r >> 1;
        build (l, mid, x << 1), build (mid + 1, r, x << 1 | 1);
        push_up (x);
    }
}

inline void update (int l, int r, int d, int nl = 1, int nr = n, int x = 1)
{
    if (l > nr || r < nl) return ;
    if (l <= nl && r >= nr) tag[x] += d, tr[x] += d * (nr - nl + 1);
    else
    {
        int mid = nl + nr >> 1;
        push_down (mid, nl, nr, x);
        update (l, r, d, nl, mid, x << 1), update (l, r, d, mid + 1, nr, x << 1 | 1);
        push_up (x);
    }
}

inline int query (int l, int r, int nl = 1, int nr = n, int x = 1)
{
    if (l > nr || r < nl) return 0;
    if (l <= nl && r >= nr) return tr[x];
    else
    {
        int mid = nl + nr >> 1;
        push_down (mid, nl, nr, x);
        return query (l, r, nl, mid, x << 1) + query (l, r, mid + 1, nr, x << 1 | 1);
    }
}

namespace IO
{
    template <class T> inline void read (T &x) { x = 0; bool f = 0; char ch = getchar (); while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar (); while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar (); x = f ? ~x + 1 : x; }
    template <class T> inline void write (T x) { static char c[20]; unsigned p = 0; if (x < 0) putchar ('-'), x = ~x + 1; if (!x) { putchar ('0'); return ; } while (x) c[++p] = x % 10 ^ 48, x /= 10; while (p) putchar (c[p]), --p; }
    template <class T, class... U> inline void read (T &x, U &...t) { read (x), read (t...); }
    template <class T, class... U> inline void write (T x, U ...t) { write (x), write (t...); }
}

using namespace IO;

int main ()
{
    int _; read (_);
    
    for (int T = 1; T <= _; ++T)
    {
        read (n);
        for (int i = 1; i <= n; ++i) read (a[i]);
        
        build ();
        printf ("Case %d:\n", T);
        while (true)
        {
            char opt[5];
            int x, y;
            scanf ("%s", opt);
            
            if (*opt == 'A') read (x, y), update (x, x, y);
            if (*opt == 'S') read (x, y), update (x, x, -y);
            if (*opt == 'Q') read (x, y), write (query (x, y)), putchar ('\n');
            if (*opt == 'E') break;
        }
    }
    return 0;
}

常数稍小的线段树

Z k w Zkw Zkw线段树 A C AC AC 1158 m s 1158ms 1158ms

O ( m log ⁡ 2 n ) O(m \log_2{n}) O(mlog2​n)

#include <cstdio>
#include <cstring>

#pragma GCC target ("avx")
#pragma GCC optimize (2, 3, "Ofast", "inline", "-ffast-math")

const int N = 5e4 + 10;

int n, M, a[N], tr[N << 2], tag[N << 2];

inline void update (int s, int t, int d)
{
    int ln = 0, rn = 0, nn = 1;
    for (s += M - 1, t += M + 1; s ^ t ^ 1; s >>= 1, t >>= 1, nn <<= 1)
    {
        tr[s] += d * ln, tr[t] += d * rn;
        if (~s & 1) tag[s ^ 1] += d, tr[s ^ 1] += d * nn, ln += nn;
        if (t & 1) tag[t ^ 1] += d, tr[t ^ 1] += d * nn, rn += nn;
    }
    for (; s; s >>= 1, t >>= 1) tr[s] += d * ln, tr[t] += d * rn;
}

inline int query (int s, int t)
{
    int ans = 0, ln = 0, rn = 0, nn = 1;
    for (s += M - 1, t += M + 1; s ^ t ^ 1; s >>= 1, t >>= 1, nn <<= 1)
    {
        if (tag[s]) ans += tag[s] * ln;
        if (tag[t]) ans += tag[t] * rn;
        if (~s & 1) ans += tr[s ^ 1], ln += nn;
        if (t & 1) ans += tr[t ^ 1], rn += nn;
    }
    for (; s; s >>= 1, t >>= 1) ans += tag[s] * ln, ans += tag[t] * rn;
    return ans;
}

namespace IO
{
    template <class T> inline void read (T &x) { x = 0; bool f = 0; char ch = getchar (); while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar (); while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar (); x = f ? ~x + 1 : x; }
    template <class T> inline void write (T x) { static char c[20]; unsigned p = 0; if (x < 0) putchar ('-'), x = ~x + 1; if (!x) { putchar ('0'); return ; } while (x) c[++p] = x % 10 ^ 48, x /= 10; while (p) putchar (c[p]), --p; }
    template <class T, class... U> inline void read (T &x, U &...t) { read (x), read (t...); }
    template <class T, class... U> inline void write (T x, U ...t) { write (x), write (t...); }
}

using namespace IO;

inline void init ()
{
    M = 1;
    while (M <= n + 1) M <<= 1;
    for (int i = 1; i <= n; ++i) read (tr[M + i]);
    for (int i = M - 1; i; --i) tr[i] = tr[i << 1] + tr[i << 1 | 1];
}

int main ()
{
    int _; read (_);
    
    for (int T = 1; T <= _; ++T)
    {
        read (n);
        init ();
        
        printf ("Case %d:\n", T);
        while (true)
        {
            char opt[5];
            int x, y;
            
            scanf ("%s", opt);
            if (*opt == 'A') read (x, y), update (x, x, y);
            if (*opt == 'S') read (x, y), update (x, x, -y);
            if (*opt == 'Q') read (x, y), write (query (x, y)), putchar ('\n');
            if (*opt == 'E') break;
        }
    }
    return 0;
}

树状数组 A C AC AC 890 m s 890ms 890ms

O ( m log ⁡ 2 n ) O(m \log_2{n}) O(mlog2​n)

#include <cstdio>
#include <cstring>

#pragma GCC target ("avx")
#pragma GCC optimize (2, 3, "Ofast", "inline", "-ffast-math")

#define lowbit(x) ((x) & ~(x) + 1)

const int N = 5e4 + 10;

int n, tr[N];

inline void update (int k, int x)
{
    while (k <= n) tr[k] += x, k += lowbit (k);
}

inline int query (int k)
{
    int ans = 0;
    while (k) ans += tr[k], k -= lowbit (k);
    return ans;
}

namespace IO
{
    template <class T> inline void read (T &x) { x = 0; bool f = 0; char ch = getchar (); while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar (); while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar (); x = f ? ~x + 1 : x; }
    template <class T> inline void write (T x) { static char c[20]; unsigned p = 0; if (x < 0) putchar ('-'), x = ~x + 1; if (!x) { putchar ('0'); return ; } while (x) c[++p] = x % 10 ^ 48, x /= 10; while (p) putchar (c[p]), --p; }
    template <class T, class... U> inline void read (T &x, U &...t) { read (x), read (t...); }
    template <class T, class... U> inline void write (T x, U ...t) { write (x), write (t...); }
}

using namespace IO;

int main ()
{
    int _; read (_);
    
    for (int T = 1; T <= _; ++T)
    {
        memset (tr, 0, sizeof tr);
        
        read (n);
        for (int i = 1, x; i <= n; ++i)
        {
            read (x), tr[i] += x;
            if (i + lowbit (i) <= n) tr[i + lowbit (i)] += tr[i];
        }
        
        printf ("Case %d:\n", T);
        while (true)
        {
            char opt[5];
            int x, y;
            scanf ("%s", opt);
            
            if (*opt == 'A') read (x, y), update (x, y);
            if (*opt == 'S') read (x, y), update (x, -y);
            if (*opt == 'Q') read (x, y), write (query (y) - query (x - 1)), putchar ('\n');
            if (*opt == 'E') break;
        }
    }
    return 0;
}

总结:

想题目中这样的数据范围，暴力一般都是过不了的，我们自然而然地就想到了上述的这些 O ( m n ) O(m\sqrt{n}) O(mn ​)和 O ( m log ⁡ 2 n ) O(m\log_2{n}) O(mlog2​n)的数据结构。只要把模板打熟，以后遇到这样的题就不怕了~~

制作不易，请一键三连~~

Dennis M. Ritchie
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zkw线段树（详解）
weixin_43823476的博客
06-19 2593
定义 我们已经了解了线段树的许多操作与结构 但是有一些缺点： 1.它是递归操作的 所以空间可能会很大 2.叶子节点深度都不同 这样操作会很麻烦 3.代码量太大... 所以现在可以引进zkw线段树 和普通的线段树相比，zkw线段树主要有这样几个不同点： 1.所有的叶子结点都在同一深度 2.在左右两端各增加了一个哨兵 3.每个点可以根据自己的编号计算父节点编号 以上三点保证了...
【算法】线段树详解
热门推荐
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
杭电OJ 敌兵布阵 树状数组
hunxiejun
09-28 262
是一道简单的树状数组的题，，是一道简单题。。。。。题目： C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干...
A - 敌兵布阵(线段树模版题)
_Alexander的博客
09-19 218
传送门 C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。 中央情报局要研究敌人究竟演习什么战...
HDU 3333 树状数组（线段树） + 离散化 + 离线处理
退役ACMer
11-22 522
传送门：HDU 3333题意 　给定一个长为ｎ的序列，　做ｍ次查询，　查询结果为区间内只出现一次的数字集合之和 题解 刚开始想的读入时用map映射,如果前面出现过， 线段树之前出现位置结点为0当前点原值， 没出现的话直接原值， 但是发现这样只能查询右端为当前位置左端为1的结点， 所以要先对查询做处理 查询预处理是对查询做r递增排序， 同时要有个idx对应查询下标 所以为了实现全部
10/2 模拟题+倍增lca+zkw线段树
weixin_51934288的博客
10-02 450
1.当getline接收一整行数据时，注意在前一个接受的数据后用getchar接收换行符。4.采用map实现字符串的映射，由于不可嵌套转换，因此转换后需要对字符串进行标记。使用线段树单点修改，若改点被除过，则直接不去乘。zkw线段树代码较短，容易记。一个处理小细节，因为第一层根节点深度为0，所以要从-1开始累加。一道省选的模拟题，虽然说思路简单，但是实现的技巧真的很多。记录从根节点到该节点所有深度的k次方，最后询问的答案。建树：先创建出分支节点，再根据具体要求赋值。，减去公共祖先的累加值。
【学习笔记】浅谈线段树与树状数组
ModestCoder_的博客
08-07 741
这是两种类似的算法 这是两种O(n^2)-&gt;O(nlogn)的算法 这两种算法有区别 树状数组支持： 单点修改（+-*/，维护最值） 区间修改（+-，维护最值） 注意：树状数组覆盖的区间不灵活，只能前缀或后缀，值的变化还好说，维护区间最值的话就很伤了，但这篇题解宽了我的思路，说明要做到树状数组维护区间最值可以浪费点时间 线段树支持： 单点修改（+-*/，维护最值） 区间修...
线段树（常规操作+zkw线段树）
m0_66640248的博客
11-02 74
哈哈哈哈哈哈哈哈
线段树之zkw
月巴虫丰博客
05-13 2636
线段树之zkw，主要的作用是用来卡常，虽然平时的使用似乎不太多，但是可以学习一下。
ZKW线段树源码-pascal
03-10
ZKW线段树的实现源码-pascal版，可保证其正确性并在logN时间复杂度类进行区间操作
ZKW线段树
06-10
线段树
统计的力量(zkw线段树)
06-09
传说中的ZKW线段树 比一般线段树快 这个是ZKW讲课的课件 线段树是二叉搜索树的一种。与一般的二叉搜索树不同的是，线段树保存的是所有元素可能取的值，而不是每个元素。通常情况下，线段树只用叶节点表示每个值。而...
ZKW线段树模板类
08-06
ZKW线段树，由ZKW（Zhang Kewei）提出，是线段树的一种优化模板，它在C++中实现，能有效地动态维护区间最大值或区间和。 线段树的基本思想是将一维数组划分成若干个子区间，每个子区间对应线段树的一个节点。线段树...
【zkw线段树讲稿】统计的力量-线段树.pdf
04-14
【zkw线段树讲稿】统计的力量-线段树.pdf
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1168
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 338
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
Delphi5实现鱼C屏幕保护程序
最新发布
weixin_52116519的博客
07-24 336
使用Form1的events的oncreate事件，双击命名为FormCreate。即上面的“- □ ×”不显示。
C++中的模板函数和模板类
2302_81171591的博客
07-22 672
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
线段树在统计计算中的威力
线段树是一种二叉树形结构，最初来源于计算几何领域，用于解决区间查询和更新的问题。在书中，作者张昆玮指出，线段树的优势在于其能够快速响应区间操作，如求区间和，而其灵活性使其能适应各种不同的统计需求。尽管...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值