Mancala 2（曼卡拉 2）

时间限制：2s 内存限制：1024MB

【原题地址】

所有图片源自Atcoder，题目译文源自脚本Atcoder Better!

点击此处跳转至原题

【问题描述】

【输入格式】

【输出格式】

【样例1】

【样例输入1】

5 3
1 2 3 4 5
2 4 0

【样例输出1】

0 4 2 7 2

【样例说明1】

【样例2】

【样例输入2】

3 10
1000000000 1000000000 1000000000
0 1 0 1 0 1 0 1 0 1

【样例输出2】

104320141 45436840 2850243019

【样例3】

【样例输入3】

1 4
1
0 0 0 0

【样例输出3】

1

【解题思路】

老汉使用到的是差分+数状数组的解题方式

本题要求进行几次操作后最终的数组数值。
如果只是对每一次分配进行单独计算，会tle（起初我就是单纯的以为如此简单，结果超时了）
那么我们需要考虑一个优化方式来降低我们的时间复杂度，分析到每次操作都是区间更新且最终是当点查询，那我们可以使用差分+树状数组的形式去解题（不懂的小伙伴们可以去搜索学习一下）

代码注释有详细过程

【代码】

package ABC340_E_Mancala2;

import java.util.*;

public class Main {
	static long[] tree;
	// 差分数组
	static long[] sub;
	// 初始值数组
	static long[] arr;
	static int n;

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		n = scan.nextInt();
		int m = scan.nextInt();
		arr = new long[n + 1];
		sub = new long[n + 2];
		tree = new long[n + 2];
		// 为差分数组赋初值
		for (int i = 1; i <= n; i++) {
			arr[i] = scan.nextLong();
			sub[i] = arr[i] - arr[i - 1];
		}
		build();
		for (int i = 0; i < m; i++) {
			int x = scan.nextInt() + 1;
			long val = query(x);
			// x下标位置数值变化，x差分-val
			add(x, -val);
			sub[x] -= val;
			// x下标位置数值变化，x+1差分+val
			add(x + 1, val);
			sub[x + 1] += val;
			// 每个位置都能分配到的数
			long v = val / n;
			// 都+v，差分不变，唯独下标为1的差分增加v，sub[1]=sub[1]-0
			add(1, v);
			sub[1] += v;
			// 求余下无法每个位置平均分配的数
			val = val % n;
			// 当余下分配到x右半边的位置刚好分完时
			if (x + val <= n) {
				// 当刚好分配到最后一个点时，x+1下标位置差分+1即可
				if (x + val == n) {
					add(x + 1, 1);
					sub[x + 1] += 1;
				} else {
					add(x + 1, 1);
					sub[x + 1] += 1;
					// 否则要在分配到的最后一个点的下一个点的差分-1
					add((int) (x + val + 1), -1);
					sub[(int) (x + val + 1)] += -1;
				}
			} else {
				// 当x下标位置左边也被分配到时，x+1下标位置差分+1
				add(x + 1, 1);
				sub[x + 1] += 1;
				add(1, 1);
				sub[1] += 1;
				// 接着在分配到的最后一个点的下一个点的差分-1
				val -= (n - x);
				add((int) (1 + val), -1);
				sub[(int) (1 + val)] += -1;
			}
		}
		// 输出最终答案
		for (int i = 1; i <= n; i++) {
			System.out.print(query(i) + " ");
		}
		scan.close();
	}

	// 查询该下标数组当前值
	public static long query(int x) {
		long res = 0;
		while (x > 0) {
			res += tree[x];
			x -= lowbit(x);
		}
		return res;
	}

	// 更新树值
	public static void add(int x, long v) {
		while (x <= n) {
			tree[x] += v;
			x += lowbit(x);
		}
	}

	// 构建差分树
	public static void build() {
		for (int i = 1; i <= n; i++) {
			int t = i;
			tree[i] += sub[t];
			t += lowbit(t);
			if (t <= n)
				tree[t] += tree[i];
		}
	}

	public static int lowbit(int x) {
		return x & (-x);
	}

}