Solution -「树状数组」题目集合

T1 冒泡排序

题目描述

clj 想起当年自己刚学冒泡排序时的经历，不禁思绪万千

当年，clj 的冒泡排序(伪)代码是这样的:

flag=false

while (not flag):

   flag=true

   for i = 0 to N-2:

      if A[i+1] < A[i]:

         swap A[i], A[i+1]

         flag=false

现在的 clj 想知道冒泡排序究竟有多慢，所以在(伪)代码的第三行下面加入了这么一句:

printf("LJS NB\n");

但是随着需要排序的个数越来越多，这个程序的速度已经不能满足 clj 的耐心了

他想请你帮忙算出这个程序到底能输出多少行LJS NB

输入格式

第一行一个数 \(n\) ，表示 \(A\) 数组有 \(n\) 个数;

接下来一行共 \(n\) 个数,用空格隔开，表示 \(A\) 数组的每一个元素。
输出格式

一行一个整数，表示这个程序会输出多少行 LJS NB。

输入样例

5

1 5 3 8 2

输出样例1

分析

其实我很好奇 LJS 是哪个 LJS

呐，这道题应该有手就能做知道冒泡排序的原理就能做叭。。。

冒泡排序，是遇到不符合顺序的就交换

不符合顺序的？那不就是求逆序对吗？？！

求法GM讲过的

AC代码

#include <cstdio>

#include <algorithm>

using namespace std;

const int MAXN = 2000005;

int a[MAXN], dis[MAXN];

int n;

long long BIT[MAXN];

// 树状数组

int Low_Bit(int x) { return x & (-x); }

void Update(int k, int x) {

    for (int i = k; i <= n; i += Low_Bit(i)) BIT[i] += x;

    return;

}

long long Sum(int k) {

    int ans = 0;

    for (int i = k; i >= 1; i -= Low_Bit(i)) ans += BIT[i];

    return ans;

}

int main() {

    scanf("%d", &n);

    for (int i = 1; i <= n; i++) {

        scanf("%d", &a[i]);

        dis[i] = a[i];

    }

    sort(dis + 1, dis + n + 1);

    int len = unique(dis + 1, dis + n + 1) - dis - 1;

    // 去重函数

    for (int i = 1; i <= n; i++) a[i] = lower_bound(dis + 1, dis + len + 1, a[i]) - dis;

    // 离散化操作

    long long ans = 0;

    for (int i = 1; i <= n; i++) {

        Update(a[i], 1);

        ans = max(ans, (long long)(i - Sum(a[i])));

        // Sum(a[i])就是在它前面比它小的，即顺序对个数

        // i - Sum(a[i]) 就是逆序对个数

        // 求出逆序对，并记录每个位置求的逆序对个数的最大值

    }

    printf("%lld", ans + 1);

    // 加上最后一次交换

    return 0;

}

T2 校门外的树

题目描述

校门外有很多树，学校决定在某个时刻在某一段种上一种树，保证任一时刻不会出现两段相同种类的树，现有两种操作：

\(k = 1\), 读入 \(l, r\) 表示在 \(l\) 到 \(r\) 之间种上一种树，每次操作种的树的种类都不同；
\(k = 2\), 读入 \(l, r\) 表示在 \(l\) 到 \(r\) 之间有多少种树。

注意：每个位置都可以重复种树。

输入格式

第一行表示道路总长为，共有个操作；

接下来行为个操作。
输出格式

对于每个输出一个答案。

样例输入

样例输出

1

2

分析

我觉得这个很好，如下图

具体实现

#include <cstdio>

const int MAXN = 1000005;

int a[MAXN];

long long BIT1[MAXN], BIT2[MAXN];

int n, m;

int Low_Bit(int x) {

	return x & -x;

}

// 两个树状数组

void Update1(int k, int x) {

	for(int i = k; i <= n; i += Low_Bit(i))

		BIT1[i] += x;

	return ;

}

long long Sum1(int k) {

	long long ans = 0;

	for(int i = k; i >= 1; i -= Low_Bit(i))

		ans += BIT1[i];

	return ans;

}

void Update2(int k, int x) {

	for(int i = k; i <= n; i += Low_Bit(i))

		BIT2[i] += x;

	return ;

}

long long Sum2(int k) {

	long long ans = 0;

	for(int i = k; i >= 1; i -= Low_Bit(i))

		ans += BIT2[i];

	return ans;

}

int main() {

	scanf ("%d %d", &n, &m);

	for(int i = 1; i <= m; i++) {

		int flag;

		scanf ("%d", &flag);

		if(flag == 1) {

			int x, y;

			scanf ("%d %d", &x, &y);

			Update1(x, 1); // 左端点

			Update2(y, 1); // 右端点

		}

		else {

			int l, r;

			scanf ("%d %d", &l, &r);

			printf("%lld\n", Sum1(r) - Sum2(l - 1));

			// 左端点数 - 右端点数

			// 其实就是求区间啦

		}

	}

	return 0;

}

T3 数星星 Stars

天空中有一些星星，这些星星都在不同的位置，每个星星有个坐标。如果一个星星的左下方（包含正左和正下）有 \(k\) 颗星星，就说这颗星星是 \(k\) 级的。

例如，上图中星星 \(5\) 是 \(3\) 级的（ \(1, 2, 4\) 在它左下），星星 \(2, 4\) 是 \(1\) 级的。例图中有 \(1\) 个 \(0\) 级，\(2\) 个 \(1\) 级，\(1\) 个 \(2\) 级，\(1\) 个 \(3\) 级的星星。

给定星星的位置，输出各级星星的数目。

一句话题意 给定 \(n\) 个点，定义每个点的等级是在该点左下方（含正左、正下）的点的数目，试统计每个等级有多少个点。

输入格式

第一行一个整数 \(n\)，表示星星的数目；

接下来 \(n\) 行给出每颗星星的坐标，坐标用两个整数 \(x, y\) 表示；

不会有星星重叠。星星按 \(y\) 坐标增序给出，\(y\) 坐标相同的按 \(x\) 坐标增序给出。
输出格式

\(n\) 行，每行一个整数，分别是 \(0\) 级，\(1\) 级， \(2\) 级，……，\(n - 1\) 级的星星的数目。

样例输入

样例输出

分析

哈这道题。。。其实与 \(y\) 的值无关

这就不用再分析了叭

然后就很简单了

求出每个点前面（看成线性的）有多少个星星

并把新的这颗星星记录下来

最后利用桶排思想储存答案并输出即可

AC代码

#include <cstdio>

const int MAXN = 35555;

int flag[MAXN], n;

int BIT[MAXN]; 

int Low_Bit(int x) {

	return x & -x;

}

// 树状数组

void Update(int k, int x) {

	for(int i = k; i <= MAXN; i += Low_Bit(i))

		BIT[i] += x;

	return ;

}

int Sum(int k) {

	int ans = 0;

	for(int i = k; i >= 1; i -= Low_Bit(i))

		ans += BIT[i];

	return ans;

}

int main() {

	scanf ("%d", &n);

	for(int i = 1; i <= n; i++) {

		int x, y;

		scanf ("%d %d", &x, &y);

		int v = Sum(x + 1); // 前面的星星数

		Update(x + 1, 1); // 将这个新的星星加入树状数组

		flag[v]++;

	}

	for(int i = 0; i < n; i++)

		printf("%d\n", flag[i]); // 输出对应级数的星星数量

	return 0;

}

T4 加法

题目描述

可怜有一个长度为 \(n\) 的正整数序列 \(A\), 但是她觉得 \(A\) 中的数字太小了,这让她很不开心。

于是她选择了 \(m\) 个区间 \([l_i, r_i]\) 和两个正整数 \(a\), \(k\) 。她打算从这 \(m\) 个区间里选出恰好 \(k\) 个区间,并对每个区间执行一次区间加 \(a\) 的操作。 (每个区间最多只能选择一次。)

对区间 \([l, r]\) 进行一次加 \(a\) 操作可以定义为将 \(A[l], A[l + 1], A[l + 2]...A[r - 1], A[r]\) 变成 \(A[l] + a, A[l + 1] + a, A[l + 2] + a...A[r -1] + a, A[r] + a\)。

现在可怜想要知道怎么选择区间才能让操作后的序列的最小值尽可能的大,即最大化。

输入格式

第一行输入一个整数表示数据组数。

对于每组数据第一行输入四个整数 \(n, m, k, a\) 。

第二行输入 \(n\) 个整数描述序列 \(A\) 。

接下来 \(m\) 行每行两个整数 \(l_i, r_i\) 描述每一个区间。数据保证所有区间两两不同。
输出格式

对于每组数据输出一个整数表示操作后序列最小值的最大值。

样例输入

样例输出

样例解释

选择给区间 \([1, 1]\) 和 \([1, 3]\) 加 \(a\)。

分析

step 1：最小值的最大值？肯定是二分a，大家都看的出来吧。。。

所以我们只需要二分查找 \(mid\)（\(mid\) 表示操作后的最小值

然后判断 \(mid\) 是否可行，然后再放大或缩小 \(mid\) 的范围

step 2：如何判断呢？利用贪心的思想

遍历一遍 \(A\) 数组，如果 \(a[i]\) 严格小于 \(mid\)，那就一定要把 \(a[i]\) 往上调

也就是说，要对包含 \(a[i]\) 的区间进行操作。

在满足这个条件的同时，你会发现当包含 \(a[i]\) 的这个区间左端点确定时，它的右端点越大，对后面的效益就越大，所以我们每次操作都用右端点更大的

利用优先队列或堆即可实现

step 3：如何实现每个区间的操作呢？

利用树状数组的区间修改，单点查询即可啦（但这个做法比CC说的直接使用差分数列修改的方法慢了10倍，不过笔者还是写的这种方法，毕竟标题是树状数组嘛

AC代码

#include <cstdio>

#include <queue>

#include <cstring>

#include <algorithm>

using namespace std;

const int MAXN = 100005;

long long BIT[MAXN];

struct data {

    int l, r;

} s[MAXN];

int n, a_, m, a[MAXN];

struct node { // 优先队列，重载运算符，关于 r 建立小根堆

	int l, r;

	bool operator < (const node &x) const {

		if(r != x.r)

			return r < x.r;

		return l < x.l;

	}

};

bool cmp(data x, data y) {

    if (x.l == y.l)

        return x.r > y.r;

        // 一开始就先将右端点更大的，而左端点相同的放在前面

    else

        return x.l < y.l;

}

// 树状数组

int Low_Bit(int x) { return x & -x; }

void Update(int k, int x) {

    for (int i = k; i <= n; i += Low_Bit(i)) BIT[i] += (long long)x;

    return;

}

long long Sum(int k) {

    long long ans = 0;

    for (int i = k; i >= 1; i -= Low_Bit(i)) ans += BIT[i];

    return ans;

}

bool check(long long mid, int k) {

    memset(BIT, 0, sizeof BIT);

    for (int i = 1; i <= n; i++) Update(i, a[i] - a[i - 1]);

	priority_queue<node> q; // 定义关于可修改区间优先队列

	int j = 1; // 当前枚举到哪个可修改区间了

	int tot = 0; // 修改区间次数

	for(int i = 1; i <= n; i++) {

		while(s[j].l <= i && j <= m) { // 如果当前区间包含 i

			node x;

			x.l = s[j].l;

			x.r = s[j].r;

			j++;

			q.push(x); // 把这个区间操作放入优先队列

		}

		while(Sum(i) < mid) { // 如果 a[i] 还未加到大于 mid 的程度

			if(q.empty()) return false; // 没有可用的区间了？返回不行

			if(tot == k) return false;

			// 这说明现在的修改区间次数已经到 k 了，但却进入了循环

			// 即 Sum(i) < mid && tot == k 明显不能，返回不行

			node x = q.top(); // 取出第一个进行操作

			q.pop();

			Update(x.l, a_);

			Update(x.r + 1, -a_);

			tot++; // 修改次数加一

		}

	}

	return true;

}

int main() {

    int t;

    scanf("%d", &t);

    while (t--) {

        int k;

        scanf("%d %d %d %d", &n, &m, &k, &a_);

        long long l = 1, r = 0x3f3f3f3f;

        for (int i = 1; i <= n; i++) {

            scanf("%d", &a[i]);

            r = min(r, (long long)a[i]);

        }

        r += (k * a_);

        // r 最大取原数组的最小值加上最多的修改次数乘每次叠加的数

        for (int i = 1; i <= m; i++) scanf("%d %d", &s[i].l, &s[i].r);

        sort(s + 1, s + m + 1, cmp);

        while (l <= r) { // 二分

            long long mid = (l + r) >> 1;

            if (check(mid, k)) // 判断 mid 是否可行

                l = mid + 1;

            else

                r = mid - 1;

        }

        printf("%lld\n", l - 1); // 最后答案在 l - 1 里面

    }

    return 0;

}