算法训练 操作格子

试题 算法训练 操作格子

资源限制

内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s

问题描述

有n个格子，从左到右放成一排，编号为1-n。

共有m次操作，有3种操作类型：

1.修改一个格子的权值，

2.求连续一段格子权值和，

3.求连续一段格子的最大值。

对于每个2、3操作输出你所求出的结果。

输入格式

第一行2个整数n，m。

接下来一行n个整数表示n个格子的初始权值。

接下来m行，每行3个整数p,x,y，p表示操作类型，p=1时表示修改格子x的权值为y，p=2时表示求区间[x,y]内格子权值和，p=3时表示求区间[x,y]内格子最大的权值。

输出格式

有若干行，行数等于p=2或3的操作总数。

每行1个整数，对应了每个p=2或3操作的结果。

样例输入

4 3
1 2 3 4
2 1 3
1 4 3
3 1 4

样例输出

6
3

数据规模与约定

对于20%的数据n <= 100，m <= 200。

对于50%的数据n <= 5000，m <= 5000。

对于100%的数据1 <= n <= 100000，m <= 100000，0 <= 格子权值 <= 10000。

---

分析

这道题用暴力肯定不难的，但是成绩只有50，很明显，不可能直接用暴力可以解决

---

代码（暴力）

// 算法训练 操作格子

#include <iostream> 
#include <vector>

using namespace std;

int main() {
	int n;
	int m;
	cin >> n >> m;
	vector<int> gz(n+1);
	for (int i = 1; i <= n; i++) {
		cin >> gz[i];
	}
	
	for (int i = 0; i < m; i++) {
		int p;
		int x;
		int y;
		cin >> p >> x >> y;
		if (p == 1) {
			gz[x] = y;
		} else if (p == 2) {
			long long ans = 0;
			for (int j = x; j <= y; j++) {
				ans += gz[j];
			}
			cout << ans << endl;
		} else if (p == 3) {
			int ans = -0x3f3f3f3f;
			for (int j = x; j <= y; j++) {
				ans = max(ans, gz[j]);
			}
			cout << ans << endl;
		}
	}	
	return 0;
}

---

思路

这道题时间主要是浪费在操作2 和 操作3中，即累加和查询

所以，我们必须要减少累加和查询的次数

用空间换时间思路是：

设置recordSum10、recordMax10，每10个，记录累加和，还有最大值；

设置recordSum100、recordMax100，每100个，保存累加和，还有最大值；

设置recordSum1000、recordMax1000，每1000个，保存累加和，还有最大值；

即映射，为了简便，定义

对10来说，0映射[0_{9]，1映射[10}19]……即 index = x / 10;

对100来说，0映射[0_{99]，1映射[100}199]……即 index = x / 100;

对1000来说，0映射[0_{999]，1映射[1000}1999]……即 index = x / 1000;

比如要找[111, 9999]区间的累加和时候，先累加111到119，然后就可以用recordSum10中记录的值累加到199，再用recordSum100中的值累加到999，最后用recordSum1000中的值累加到9999；

直接暴力：9999 - 111 = 9888次

优化后：8 + 8 + 9 = 25次

---

难点

思路并不难想到，难点是对修改时的操作进行处理，以及查询时到边界值的处理，这些特别费时；

插入

主要分成累加和最大值

累加

这个修改的特殊处理并不难，只需要减去旧值再加上新值即可

最大值

修改时会有两种情况

情况一

记录的最大值比旧值小，这时只需要和新值比较一下大小，然后覆盖即可

情况二

记录的最大值和旧值相同，这时，就说明当前修改的位置的数值有可能就是最大值（会有多个位置是最大值），如果这时单纯判断取较大的，就会导致，位置的值该小了，而最大值没变。所以遇到这种情况，要重新计算最大值

查询

要对题目的查询区间进行理解，还有对自己设置的映射区间

在这道题，是左闭右闭区间；

映射：0 => [0~9]、1 => [10~19]

所以条件应该是：j % 10 == 0 && j + 9 <= y

而且应该先从较大的进行判断，1000 => 100 => 10 ，因为，在1000时对10的判断也是true

---

代码

中间有很多内存浪费的地方，如都是long long型，还有 record的长度全部设置为格子数的长度，其实不需要，但是能过就行~~~

// 算法训练 操作格子

#include <iostream> 
#include <vector>
#define MAX 0x3f3f3f3f
#define MIN -MAX
#define LEN 1000000
using namespace std;

int main() {
	long long n;
	long long m;
	cin >> n >> m;
	vector<long long> gz(LEN);
	
	vector<long long> recordSum10(LEN);
	vector<long long> recordSum100(LEN);
	vector<long> recordSum1000(LEN);
	
	vector<long long> recordMax10(LEN, MIN);
	vector<long long> recordMax100(LEN, MIN);
	vector<long long> recordMax1000(LEN, MIN);
	
	
	for (long long i = 1; i <= n; i++) {
		cin >> gz[i];
		recordSum10[i/10] += gz[i];
		recordSum100[i/100] += gz[i];
		recordSum1000[i/1000] += gz[i];
		recordMax10[i/10] = max(recordMax10[i/10], gz[i]);
		recordMax100[i/100] = max(recordMax100[i/100], gz[i]);
		recordMax1000[i/1000] = max(recordMax1000[i/1000], gz[i]);
	}
	
	for (long long i = 0; i < m; i++) {
		long long p;
		long long x;
		long long y;
		cin >> p >> x >> y;
		if (p == 1) {
			long long old = gz[x];	
			gz[x] = y;
			recordSum10[x/10] += y - old;
			recordSum100[x/100] += y - old;
			recordSum1000[x/1000] += y - old;
			
			if (recordMax10[x/10] == old) {
				// 重新计算
				recordMax10[x/10] = MIN;
				long long start = x/10*10;
				long long end = x/10*10+10;
			 	for (long long i = start; i < end; i++) {
				 	recordMax10[i/10] = max(recordMax10[i/10], gz[i]);
				 } 
			} else {
				recordMax10[x/10] = max(recordMax10[x/10], y);
			}
			
			if (recordMax100[x/100] == old) {
				// 重新计算
				recordMax100[x/100] = MIN;
				long long start = x/100*100;
				long long end = x/100*100+100;
			 	for (long long i = start; i < end; i++) {
				 	recordMax100[i/100] = max(recordMax100[i/100], gz[i]);
				 } 
			} else {
				recordMax100[x/100] = max(recordMax100[x/100], y);
			}
			
			if (recordMax1000[x/1000] == old) {
				// 重新计算
				recordMax1000[x/1000] = MIN;
				long long start = x/1000*1000;
				long long end = x/1000*1000+1000;
			 	for (long long i = start; i < end; i++) {
				 	recordMax1000[i/1000] = max(recordMax1000[i/1000], gz[i]);
				 } 
			} else {
				recordMax1000[x/1000] = max(recordMax1000[x/1000], y);
			} 

		} else if (p == 2) {
			long long ans = 0;
			for (long long j = x; j <= y; j++) {
				if (j % 1000 == 0 && j + 999 <= y) {
					ans += recordSum1000[j/1000];
					j += 999;
				} else if (j % 100 == 0 && j + 99 <= y) {
					ans += recordSum100[j/100];
					j += 99;
				} else if (j % 10 == 0 && j + 9 <= y) {
					ans += recordSum10[j/10];
					j += 9;
				} else {	
					ans += gz[j];
				} 
			}
			cout << ans << endl;
		} else if (p == 3) {
			long long ans = -0x3f3f3f3f;
			for (long long j = x; j <= y; j++) {
				if (j % 1000 == 0 && j + 999 <= y) {
					ans = max(ans, recordMax1000[j/1000]);
					j += 999;
				} else if (j % 100 == 0 && j + 99 <= y) {
					ans = max(ans, recordMax100[j/100]);
					j += 99;
				} else if (j % 10 == 0 && j + 9 <= y) {
					ans = max(ans, recordMax10[j/10]);
					j += 9;
				} else {	
					ans = max(ans, gz[j]);
				} 
			}
			cout << ans << endl;
		}
	}	
	return 0;
}