线段树模板题

mycugb2023

已于 2023-11-15 00:08:40 修改

阅读量59

点赞数

文章标签： c++ c语言算法

于 2023-10-29 23:39:16 首次发布

本文链接：https://blog.csdn.net/2301_79440964/article/details/134110152

版权

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <stdio.h>
#include <string.h>
#define dmax(a,b) (a) >(b) ? (a) :(b)
#define N 100001
struct treenode {
	int left;
	int right;
	long long value;
	long long lazy;
	int pos;
	struct treenode* leftson;
	struct treenode* rightson;
	struct treenode* parent;
}tree[N << 2];
long long value[N];
int Q;
int i;
int n, m;
int gnum;
void push_up(int pos) {
	tree[pos].value = tree[pos * 2].value + tree[pos * 2 + 1].value;
}
struct treenode* create_node(int left, int right, long long value, long long lazy, int pos, struct treenode* leftson, struct treenode* rightson, struct treenode* parent) {
	struct treenode *
}
void push_down(int pos) {
	if (tree[pos].lazy != 0) {
		tree[2 * pos].value += tree[pos].lazy*(tree[2*pos].right - tree[2*pos].left+1);
		tree[2 * pos + 1].value += tree[pos].lazy * (tree[2 * pos +1].right - tree[2 * pos + 1].left + 1);
		tree[2 * pos].lazy += tree[pos].lazy;
		tree[2 * pos + 1].lazy += tree[pos].lazy;
		tree[pos].lazy = 0;
	}
}
void build(int left, int right, int pos) {
	tree[pos].left = left;
	tree[pos].right = right;
	if (left == right) {
		tree[pos].value = value[left];
		return;
	}
	int mid = (tree[pos].left + tree[pos].right) / 2;
	build(left, mid, 2 * pos);
	build(mid + 1, right, 2 * pos + 1);
	push_up(pos);
}

long long query(int left, int right, int pos) {
	if (left > tree[pos].right || right < tree[pos].left) {
		return 0;
	}
	if (left <= tree[pos].left && tree[pos].right <= right) {
		return tree[pos].value;
	}
	long long ret = 0;
	push_down(pos);
	int mid = (tree[pos].left + tree[pos].right) / 2;
	if (left <= mid) {
		ret += query(left, right, pos * 2);
	}
	if (right > mid) {
		ret += query(left, right, pos * 2 + 1);
	}
	return ret;
}

void update_point(int a, int b, int pos) {
	if (a < tree[pos].left || a> tree[pos].right) {
		return;
	}
	if (a == tree[pos].left && tree[pos].left == tree[pos].right) {
		tree[pos].value = b;
		return;
	}
	int mid = (tree[pos].left + tree[pos].right) / 2;
	if (a <= mid) {
		update_point(a, b, pos * 2);
	}
	if (a > mid) {
		update_point(a, b, pos * 2 + 1);
	}
	push_up(pos);
	return;
}

void update(long long a, long long b, long long c, int pos) {

	if (b < tree[pos].left || a > tree[pos].right) {
		return;
	}
	if (tree[pos].left >= a && tree[pos].right <= b) {
		tree[pos].value += (tree[pos].right - tree[pos].left + 1) * c;
		tree[pos].lazy += c;
		return;
	}
	push_down(pos);
	int mid = (tree[pos].left + tree[pos].right) / 2;
	if (a <= mid) {
		update(a, b, c, pos * 2);
	}
	if (b > mid) {
		update(a, b, c, pos * 2 + 1);
	}
	push_up(pos);
}
int main(void) {

	scanf("%d%d", &n, &m);
	for (i = 1; i <= n; i++) {
		scanf("%lld", &value[i]);
	}
	getchar();
	gnum = 0;
	char ch;
	long long  a, b, c;
	//build(1, n, 1);	
	for (i = 1; i <= m; i++) {
		scanf("%c %lld", &ch, &a);
		if (ch == 'Q') {
			scanf("%lld", &b);
			//	if (i != m) {
			getchar();
			//	}
			printf("%lld\n", query(a, b, 1));
		}
		if (ch == 'C') {
			scanf("%lld %lld", &b, &c);
			//	if (i != m) {
			getchar();
			//	}
			update(a, b, c, 1);
		}

	}
	return 0;
}

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <stdio.h>
#include <string.h>
#define dmax(a,b) (a) >(b) ? (a) :(b)
#define N 100001
struct treenode {
	int left;
	int right;
	long long value;
	long long lazy;
	int pos;
	struct treenode* leftson;
	struct treenode* rightson;
	struct treenode* parent;
}tree[N << 2];
long long value[N];
int Q;
int i;
int n, m;
int gnum;
void push_up(struct treenode *node) {
	node->value = node->leftson->value + node->rightson->value;
}

struct treenode* create_node(int left, int right) {
	struct treenode* newnode = &tree[gnum++];
	newnode->left = left;
	newnode->right = right;
	newnode->value = 0;
	newnode->lazy = 0;
	newnode->leftson = NULL;
	newnode->rightson = NULL;
	newnode->parent = NULL;
	return newnode;
}

void push_down(struct treenode* node) {
	if (node->lazy != 0) {
		node->leftson->value += node->lazy * (node->leftson->right - node->leftson->left+1);
		node->rightson->value += node->lazy * (node->rightson->right - node->rightson->left + 1);
		node->leftson->lazy += node->lazy;
		node->rightson->lazy += node->lazy;
		node->lazy = 0;
	}
}

long long query(int left, int right, struct treenode *node) {
	if (left >node->right || right < node->left) {
		return 0;
	}
	if (left <= node->left && node->right <= right) {
		return node->value;
	}

	long long ret = 0;
	int mid = (node->left + node->right) / 2;
	if (node->leftson == NULL) {
		node->leftson = create_node(node->left, mid);
		node->leftson->parent = node;
	}
	if (node->rightson == NULL) {
		node->rightson = create_node(mid + 1, node->right);
		node->rightson->parent = node;
	}
	push_down(node);
	
	if (left <= mid) {
		ret += query(left, right, node->leftson);
	}
	if (right > mid) {
		ret += query(left, right, node->rightson);
	}
	return ret;
}

void update(long long a, long long b, long long c, struct treenode *node) {

	if (node->left || node->right) {
		return;
	}
	if (node->left >= a && node->right <= b) {
		node->value += (node->right - node->left + 1) * c;
		node->lazy += c;
		return;
	}

	int mid = (node->left + node->right) / 2;
	if (node->leftson == NULL) {
		node->leftson = create_node(node->left, mid);
		node->leftson->parent = node;
	}
	if (node->rightson == NULL) {
		node->rightson = create_node(mid + 1, node->right);
		node->rightson->parent = node;
	}
	push_down(node);

	int mid = (node->left + node->right) / 2;
	if (node->leftson == NULL) {
		node->leftson = create_node(node->left, mid);
		node->leftson->parent = node;
	}
	if (node->rightson == NULL) {
		node->rightson = create_node(mid + 1, node->right);
		node->rightson->parent = node;
	}

	if (a <= mid) {
		update(a, b, c, node->leftson);
	}
	if (b > mid) {
		update(a, b, c, node->rightson);
	}
	push_up(node);
}

int main(void) {

	scanf("%d%d", &n, &m);
	for (i = 1; i <= n; i++) {
		scanf("%lld", &value[i]);
	}
	getchar();
	gnum = 0;
	char ch;
	long long  a, b, c;
	struct treenode* root = create_node(1, n);
	
	for (i = 1; i <= m; i++) {
		scanf("%c %lld", &ch, &a);
		if (ch == 'Q') {
			scanf("%lld", &b);
			getchar();
			printf("%lld\n", query(a, b, root));
		}
		if (ch == 'C') {
			scanf("%lld %lld", &b, &c);
			getchar();
			update(a, b, c, root);
		}

	}
	return 0;
}

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <stdio.h>

int get_max(int a, int b) {
	if (a > b) {
		return a;
	}
	return b;
}
struct Stu {
	int left;
	int right;
	struct Stu* lson;
	struct Stu* rson;
	int value;
};
struct Stu students[500100];
int gnum;
int value[200100];
void push_up(struct Stu* node) {
	node->value = get_max(node->lson->value, node->rson->value);
}
struct Stu* createnode(int left, int right) {
	struct Stu* node = &students[gnum++];
	node->left = left;
	node->right = right;
	node->lson = NULL;
	node->rson = NULL;
	node->value = 0;
	return node;
}
int query(int left, int right, struct Stu* node) {
	if (right < node->left || left > node->right) {
		return 0;
	}
	if (node->left >= left  && right >= node->right) {
		return node->value;
	}
	
	int mid = (node->left + node->right) / 2;
	if (node->lson == NULL) {
		node->lson = createnode(node->left, mid);
	}
	if (node->rson == NULL) {
		node->rson = createnode(mid + 1, node->right);
	}
	int ret = 0;
	if (left <= mid) {
		ret = get_max(ret, query(left, right, node->lson));
	}
	if (right > mid) {
		ret = get_max(ret, query(left, right, node->rson));
	}
	return ret;
}
void update(int pos, int v, struct Stu* node) {
	if (pos < node->left || pos > node->right) {
		return;
	}
	if (pos == node->left && node->left == node->right) {
		node->value = v;
		return;
	}
	int mid = (node->left + node->right) / 2;
	if (node->lson == NULL) {
		node->lson = createnode(node->left, mid);
	}
	if (node->rson == NULL) {
		node->rson = createnode(mid + 1, node->right);
	}
	//int ret = 0;
	if (pos <= mid) {
		update(pos, v, node->lson);
	}
	if (pos > mid) {
		update(pos, v, node->rson);
	}
	push_up(node);
}
void build(int left, int right, struct Stu* node) {
	if (right < node->left || left > node->right) {
		return;
	}
	if (node->left == node->right) {
		node->value = value[node->left];
		return;
	}
	int mid = (node->left + node->right) / 2;
	if (node->lson == NULL) {
		node->lson = createnode(node->left, mid);
	}
	if (node->rson == NULL) {
		node->rson = createnode(mid + 1, node->right);
	}

	build(left, mid, node->lson);

	build(mid+1, right, node->rson);
	
	push_up(node);
}
int main()
{
	
	int n, m;
	while (scanf("%d%d", &n, &m) != EOF) {
		gnum = 0;
		struct Stu* root = createnode(1, n);
		for (int i = 1; i <= n; i++) {
			scanf("%d", &value[i]);
		}
		build(1, n, root);
		//getchar();
		for (int i = 0; i < m; i++) {
			char ch;
			int a, b;
			getchar();
			scanf("%c %d %d", &ch, &a, &b);
			
			//printf("%c %d %d\n", ch, a, b);
			if (ch == 'Q') {
				printf("%d\n", query(a, b, root));
			}
			if (ch == 'U') {
				update(a,b, root);
			}
		}
	}
	return 0;
}