ACM：平衡树(3)——另一个Splay

题目来源： 

        HihoCoder1333
 
题目描述：

    定义一个包含数字的集合，集合的初始情况为空。给定下面两种操作：
        插入：向集合中添加一个数字k。
        询问：询问区间[a, b]内元素的总和。
        更新：更新落在区间[a, b]内的数字，将其所有数字都增加k。
        删除：删除落在区间[a, b]内的所有数字。
题目要求对于每次询问，输出对应的答案。

解答：
    相比HihoCoder1329，本题又增加了更新数据的操作。本题也可以通过构建Splay树来完成，更新操作和删除操作类似，可以通过splay操作将区间内的所有元素都转移到一棵子树中，然后将其元素更新即可。这样的策略的执行效率和树的节点数目有关，当树的节点数目很多时，效率不是很高，我们需要对节点的结构进行改进，提高更新操作的效率。

·数据结构：
    本题的询问、更新、删除操作均涉及到了区间。并且更新操作使批量更新。因此，我们设计树的节点的结构如下：

   

 struct node {key, parent, left, right, sum, count, update, update_value}

其中：key、parent、left、right 分别代表了节点的：关键字、父节点、左右孩子节点，sum记录了以该节点为根的子树内的所有节点值的总和；count则代表了该子树中的节点个数；update、update_value则用于批量更新时的操作，下文中会有说明。 

·插入操作： 
    对于插入操作，本题和HihoCoder1329题类似，这里不多说明。注意新插入的初始化节点sum就是节点值本身，count值为1，update 和 update_value都赋值为0。注意再插入的过程中，新插入节点的所有祖先界定的sum值和count值都要对应更新。

·查询操作：
    查询操作本题也涉及到了区间，可以通过Splay操作将区间内的节点转移到一棵子树中，然后读取树的根节点的sum值即可。

·删除操作：
    删除操作也和1329题相同，通过Splay操作将要删除的节点转移到一棵子树中，然后删除之，注意相关祖先节点的count域和sum域也要做相应改动。

·更新操作：
    更新操作本题中是批量更新，更新给定区间内的所有节点，并统一增加k值。这里首先可以通过splay操作将所有待更新节点转移到一棵子树上。但是这里不会更新子树中所有的节点，而是采用懒惰策略，仅仅将更新信息记录在子树的根节点中。此时更新子树根节点的key值，将子树根节点的update标记置为1，表示该子树数据有更新，并且还尚未同步到其子节点。更新的k值则存储在update_value域中，此时，整个子树中的节点的总和可以直接计算出来，即：sum = sum + update_value * count；
    
·同步：
    为了保证数据在任何情况下都是正确的，这里需要增加一个新的曹组——同步。同步是指对于一个有更新信息的节点，将其更新信息同步到其左右孩子中，此时设置其左右孩子节点update标记为1，更新左右孩子的key值，更新左右孩子的update_value值。此时就将更新的信息同步到子节点中。最后将当前节点的update值和update_value标记置为0。
    在某些情况下，可能会出现父节点和子节点的update标记同时为1的情况。此时将父节点的更新信息同步到子节点后，要和子节点包含的更新信息整合。方法就是将update_value值叠加即可。
    同步操作保证了树中节点信息的正确性，因此在进行插入、删除、旋转等操作过程中如果遇到update标记为1的节点，都必须先将其更新信息同步后再执行其他的操作。

·虚节点问题：
    本题中同样会遇到虚节点的问题。注意虚节点并不是真实存在的，因此在插入时，节点本身的count域为0，sum的初始值也为0，当通过操作将虚节点转化为非叶节点时，节点的sum域也不能包含该节点的key值。在同步过程中，虚节点的key值也不会更改。

输入输出格式：
    输入：
          第1行：1个正整数n，表示操作数量，100≤n≤200,000

  第2..n+1行：可能包含下面4种规则：

1个字母'I'，紧接着2个数字id,val，表示一个编号为id的新成员加入，其兴趣值为val，保证在团队中的每个人id都不相同。

1个字母'Q'，紧接着2个数字a,b。表示询问团队中id在区间[a,b]的所有成员总兴趣值，保证区间内至少有一个成员，结果有可能超过int的范围。

1个字母'M'，紧接着3个数字a,b,d，表示将团队中id在区间[a,b]的成员兴趣值都改变d，其中d有可能为负数。保证操作之后每个成员的兴趣值仍然在0~10,000,000。

1个字母'D'，紧接着2个数字a,b，表示将团队中id在区间[a,b]的成员除去。

注意有可能出现一个id为1的成员加入团队，被除去之后，又有一个新的id为1的成员加入团队的情况。

    输出：
          若干行：每行1个整数，表示针对询问的回答，保证一定有合法的解。

数据范围：
     1≤id≤100,000,000
     1≤val≤10,000,000

程序代码：

/****************************************************/
/* File        : Hiho_Week_105                      */
/* Author      : Zhang Yufei                        */
/* Date        : 2016-07-05                         */
/* Description : HihoCoder ACM program. (submit:g++)*/
/****************************************************/

#include<stdio.h>
#include<stdlib.h>

/* Define structure to store the information of 
 * the member:
 * Parameters:
 *		@id: The id of member.
 *		@value: The value of interest of this member.
 *		@sum: The total value of value in this sub-tree.
 *		@count: The number of nodes in this sub-tree.
 *		@update: Mark if the value has been updated into child node.
 *		@update: Record the update value.
 *		@left & @right: The left and right child of node.
 *		@parent: The parent node of this node.
 */
typedef struct node {
	int id;
	int value;
	long long sum;
	int count; 
	int update;
	int update_value;
	struct node *left, *right;
	struct node *parent;
} node;

// The root of splay tree.
node *root = NULL;

/*
 * This function update the child value in subtree.
 * Parameters:
 *		@cur: The current root node.
 * Returns:
 *		None.
 */
void split(node* cur) {
	if(cur == NULL || cur->update == 0) {
		return;
	}
	
	cur->update = 0;
	if(cur->left != NULL) {
		if(cur->left->value != 0)
			cur->left->value += cur->update_value;
		cur->left->sum += cur->update_value * cur->left->count; 
		cur->left->update = 1;
		cur->left->update_value += cur->update_value;
	}
	
	if(cur->right != NULL) {
		if(cur->right->value != 0)
			cur->right->value += cur->update_value;
		cur->right->sum += cur->update_value * cur->right->count;
		cur->right->update = 1;
		cur->right->update_value += cur->update_value;
	}
	
	cur->update_value = 0;
}

/*
 * The left rotate operation.
 * Parameters:
 *		@cur: The node to rotate.
 * Returns:
 *		None.
 */
void left_rotate(node* cur) {
	node *right = cur->right;	
	node *right_left = right->left;
	node *parent = cur->parent;
	
	split(parent);
	split(cur);
	split(right);
	
	right->parent = parent;
	if(parent != NULL) {
		if(cur == parent->left) {
			parent->left = right;	
		} else {
			parent->right = right;
		}
	} else {
		root = right;
	}
	
	right->left = cur;
	cur->parent = right;
	
	cur->right = right_left;
	if(right_left != NULL) {
		right_left->parent = cur;
	}
	
	cur->sum = cur->value;
	if(cur->value == 0) {
		cur->count = 0;
	} else {
		cur->count = 1;
	}
	if(cur->left != NULL) {
		cur->sum += cur->left->sum;
		cur->count += cur->left->count;
	}
	if(cur->right != NULL) {
		cur->sum += cur->right->sum;
		cur->count += cur->right->count;
	}
	
	right->sum = right->value;
	if(right->value == 0) {
		right->count = 0;
	} else {
		right->count = 1;
	}
	if(right->left != NULL) {
		right->sum += right->left->sum;
		right->count += right->left->count;
	}
	if(right->right != NULL) {
		right->sum += right->right->sum;
		right->count += right->right->count;
	}
}

/*
 * The right rotate operation.
 * Parameters:
 *		@cur: The node to rotate.
 * Returns:
 *		None.
 */
void right_rotate(node* cur) {
	node *left = cur->left;	
	node *left_right = left->right;
	node *parent = cur->parent;
	
	split(parent);
	split(cur);
	split(left);
	
	left->parent = parent;
	if(parent != NULL) {
		if(cur == parent->left) {
			parent->left = left;	
		} else {
			parent->right = left;
		}
	} else {
		root = left;
	}
	
	left->right = cur;
	cur->parent = left;
	
	cur->left = left_right;
	if(left_right != NULL) {
		left_right->parent = cur;
	}
	
	cur->sum = cur->value;
	if(cur->value == 0) {
		cur->count = 0;
	} else {
		cur->count = 1;
	}
	if(cur->left != NULL) {
		cur->sum += cur->left->sum;
		cur->count += cur->left->count;
	}
	if(cur->right != NULL) {
		cur->sum += cur->right->sum;
		cur->count += cur->right->count;
	}
	
	left->sum = left->value;
	if(left->value == 0) {
		left->count = 0;
	} else {
		left->count = 1;
	}
	if(left->left != NULL) {
		left->sum += left->left->sum;
		left->count += left->left->count;
	}
	if(left->right != NULL) {
		left->sum += left->right->sum;
		left->count += left->right->count;
	}
}

/*
 * Define the zig operation.
 * Parameters:
 *		@cur: The current node to operate.
 * Returns:
 *		None.
 */
void zig(node* cur) {
	node* p = cur->parent;
	if(p->left == cur) {
		right_rotate(p);
	} else {
		left_rotate(p);
	}
}

/*
 * Define the zig-zig operation.
 * Parameters:
 *		@cur: The current node to operate.
 * Returns:
 *		None.
 */
void zig_zig(node* cur) {
	node *p = cur->parent;
	node *pp = p->parent;
	
	if(p->left == cur) {
		right_rotate(pp);
		right_rotate(p);
	} else {
		left_rotate(pp);
		left_rotate(p);
	}
}

/*
 * Define the zig-zag operation.
 * Parameters:
 *		@cur: The current node to operate.
 * Returns:
 *		None.
 */
void zig_zag(node* cur) {
	node *p = cur->parent;
	node *pp = p->parent;
	
	if(p->left == cur) {
		right_rotate(p);
		left_rotate(pp);
	} else {
		left_rotate(p);
		right_rotate(pp);
	}
}

/*
 * Define the splay operation.
 * Parameters:
 *		@cur: The current node to operate.
 *		@dst: The distination position of the operation.
 * Returns:
 *		None.
 */
void splay(node* cur, node* dst) {
	while(cur->parent != dst) {
		node* p = cur->parent;
		if(p->parent == dst) {
			zig(cur);
		} else {
			node *pp = p->parent;
			if(p == pp->left && cur == p->left ||
				p == pp->right && cur == p->right) {
				zig_zig(cur);
			} else {
				zig_zag(cur);
			}
		}
	}
} 

/*
 * This function insert a node into the tree.
 * Parameters:
 *		@ins: The node to insert.
 * Returns:
 *		The node to inserted.
 */
node* insert(node* ins) {
	node* p = root;
	node* pre = NULL;
	while(p != NULL) {
		pre = p;
		split(p);
		if(ins->value != 0) {
			p->sum += ins->value;
			p->count++;
		}
		if(p->id > ins->id) {
			p = p->left;
		} else if(p->id < ins->id){
			p = p->right;
		} else {
			if(ins->value != 0) {
				p->value = ins->value;
				p->sum += p->value;
			}
			free(ins);
			ins = p;
			splay(ins, NULL);
			return ins;
		}
	}
	if(pre != NULL) {
		if(ins->id > pre->id) {
			pre->right = ins;
		} else {
			pre->left = ins;
		}
		ins->parent = pre;
	} else {
		root = ins;
	}
	
	splay(ins, NULL);
	
	return ins;
}

/*
 * This function find the preview node of the current node.
 * Parameters:
 *		@cur: The current node to search.
 * Returns:
 *		The preview node.
 */
node* preview(node* cur) {
	node* pre = cur->left;
	if(pre != NULL) {
		while(pre->right != NULL) {
			pre = pre->right;
		}
	} else {
		pre = cur;
		while(pre != NULL) {
			if(pre->parent == NULL) {
				pre = NULL;
				break;
			}
			if(pre == pre->parent->right) {
				pre = pre->parent;
				break;
			}
			pre = pre->parent;
		}
	}
	
	return pre;
}

/*
 * This function find the next node of the current node.
 * Parameters:
 *		@cur: The current node to search.
 * Returns:
 *		The next node.
 */
node* successor(node* cur) {
	node* suc = cur->right;
	if(suc != NULL) {
		while(suc->left != NULL) {
			suc = suc->left;
		}
	} else {
		suc = cur;
		while(suc != NULL) {
			if(suc->parent == NULL) {
				suc = NULL;
				break;
			}
			if(suc == suc->parent->left) {
				suc = suc->parent;
				break;
			}
			suc = suc->parent;
		}
	}
	
	return suc;
}

/*
 * This function search the nodes according to given range.
 * Parameters:
 *		@s & @e: The left and right edge of range.
 * Returns:
 *		The root of the sub-tree according given range.
 */
node* search(int s, int e) {
	node* s_node = (node*) malloc(sizeof(node));
	node* e_node = (node*) malloc(sizeof(node));
	
	s_node->id = s;
	s_node->value = 0;
	s_node->sum = 0;
	s_node->left = s_node->right = s_node->parent = NULL;
	s_node->update = 0;
	s_node->update_value = 0;
	s_node->count = 0;
	
	e_node->id = e;
	e_node->value = 0;
	e_node->sum = 0;
	e_node->left = e_node->right = e_node->parent = NULL;
	e_node->update = 0;
	e_node->update_value = 0;
	e_node->count = 0;
	 
	s_node = insert(s_node);
	e_node = insert(e_node);

	node* s_pre = preview(s_node);
	node* e_next = successor(e_node);

	splay(s_pre, NULL);
	splay(e_next, s_pre);
	
	return e_next->left;
}

/*
 * This function deletes the nodes according to given range.
 * Parameters:
 *		@s & @e: The left and right edge of range.
 * Returns:
 *		None.
 */
void remove(int s, int e) {
	node *del = search(s, e);
	if(del == NULL) {
		return;
	}

	node* p = del->parent;
	
	while(p != NULL) {
		p->sum -= del->sum;
		p->count -= del->count;
		p = p->parent;
	}
	
	if(del->parent == NULL) {
		root = NULL;
	} else if(del->parent->left == del) {
		del->parent->left = NULL;
	} else {
		del->parent->right = NULL;
	}
}

/*
 * This function update the value of nodes according to given range.
 * Parameters:
 *		@s & @e: The left and right edge of range.
 *		@new_value: The new value to upeate.
 * Returns:
 *		The root of the sub-tree according given range.
 */
void update_node(int s, int e, int new_value) {
	node *up = search(s, e);
	
	if(up != NULL) {
		if(up->value != 0) {
			up->value += new_value;
		}
		up->sum += new_value * up->count;
		up->update = 1;
		up->update_value += new_value;
		
		node *p = up->parent;
		while(p != NULL) {
			p->sum += new_value * up->count;
			p = p->parent;
		}
	}
}

/*
 * The main program.
 */
int main(void) {
	int n;
	scanf("%d", &n);
	
	node* min = (node*) malloc(sizeof(node));
	min->id = 0;
	min->value = min->sum = 0;
	min->left = min->right = min->parent = NULL;
	min->count = 0;
	min->update = 0;
	min->update_value = 0;
	
	node* max = (node*) malloc(sizeof(node));
	max->id = 100000001;
	max->value = max->sum = 0;
	max->left = max->right = max->parent = NULL;
	max->count = 0;
	max->update = 0;
	max->update_value = 0;
	
	min = insert(min);
	max = insert(max); 
	
	for(int i = 0; i < n; i++) {
		getchar();
		char operate;
		int a, b, d, id, value;
		scanf("%c", &operate);
		
		if(operate == 'I') {
			scanf("%d %d", &id, &value);
			node *n = (node*) malloc(sizeof(node));
			n->id = id;
			n->value = value;
			n->parent = n->left = n->right = NULL;
			n->count = 1;
			n->sum = value;
			n->update = 0; 
			n->update_value = 0;
			n = insert(n);
		} else if(operate == 'Q') {
			scanf("%d %d", &a, &b);
			a = a > 1 ? a : 1;
			b = b < 100000000 ? b : 100000000;
			node *r = search(a, b);
			printf("%lld\n", r->sum);
		} else if(operate == 'M') {
			scanf("%d %d %d", &a, &b, &d);
			a = a > 1 ? a : 1;
			b = b < 100000000 ? b : 100000000;
			update_node(a, b, d);	
		} else if(operate == 'D') {
			scanf("%d %d", &a, &b);
			a = a > 1 ? a : 1;
			b = b < 100000000 ? b : 100000000;
			remove(a, b);
		}
	}
	
	return 0;
}