2019 力扣杯全国秋季编程大赛：5. 发 LeetCoin（线段树+懒惰标记）

5. 发 LeetCoin

 显示英文描述 

我的提交

• 用户通过次数83
• 用户尝试次数285
• 通过次数86
• 提交次数862
• 题目难度Hard

力扣决定给一个刷题团队发LeetCoin作为奖励。同时，为了监控给大家发了多少LeetCoin，力扣有时候也会进行查询。

 

该刷题团队的管理模式可以用一棵树表示：

1. 团队只有一个负责人，编号为1。除了该负责人外，每个人有且仅有一个领导（负责人没有领导）；
2. 不存在循环管理的情况，如A管理B，B管理C，C管理A。

 

力扣想进行的操作有以下三种：

1. 给团队的一个成员（也可以是负责人）发一定数量的LeetCoin；
2. 给团队的一个成员（也可以是负责人），以及他/她管理的所有人（即他/她的下属、他/她下属的下属，……），发一定数量的LeetCoin；
3. 查询某一个成员（也可以是负责人），以及他/她管理的所有人被发到的LeetCoin之和。

 

输入：

1. N表示团队成员的个数（编号为1～N，负责人为1）；
2. leadership是大小为(N - 1) * 2的二维数组，其中每个元素[a, b]代表b是a的下属；
3. operations是一个长度为Q的二维数组，代表以时间排序的操作，格式如下：
   1. operations[i][0] = 1: 代表第一种操作，operations[i][1]代表成员的编号，operations[i][2]代表LeetCoin的数量；
   2. operations[i][0] = 2: 代表第二种操作，operations[i][1]代表成员的编号，operations[i][2]代表LeetCoin的数量；
   3. operations[i][0] = 3: 代表第三种操作，operations[i][1]代表成员的编号；

输出：

返回一个数组，数组里是每次查询的返回值（发LeetCoin的操作不需要任何返回值）。由于发的LeetCoin很多，请把每次查询的结果模1e9+7 (1000000007)。

 

示例 1：

输入：N = 6, leadership = [[1, 2], [1, 6], [2, 3], [2, 5], [1, 4]], operations = [[1, 1, 500], [2, 2, 50], [3, 1], [2, 6, 15], [3, 1]]
输出：[650, 665]
解释：团队的管理关系见下图。
第一次查询时，每个成员得到的LeetCoin的数量分别为（按编号顺序）：500, 50, 50, 0, 50, 0;
第二次查询时，每个成员得到的LeetCoin的数量分别为（按编号顺序）：500, 50, 50, 0, 50, 15.

 

限制：

1. 1 <= N <= 50000
2. 1 <= Q <= 50000
3. operations[i][0] != 3 时，1 <= operations[i][2] <= 5000

思路：太久没写中等偏上的算法题了，线段树撸出来一堆bug，就是一个线段树懒惰标记延迟更新区间和的模板题而已。。。。艹

import java.awt.Paint;
import java.awt.Point;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.TreeSet;
import java.util.Vector;


class Solution {
	
	int[] t=new int[50005];
	int[] st=new int[50005];
	int[] ed=new int[50005];
	int[] head=new int[50005];
	int[] nxt=new int[50005];
	int[] v=new int[50005];
	int[] tag=new int[200005];
	int[] sum=new int[200005];
	int cnt,tot,mod;
	
    public int[] bonus(int n, int[][] leadership, int[][] operations) {
        
    	cnt=tot=0;
    	mod=1000000007;
    	
    	for(int i=0;i<n-1;i++)
    		add(leadership[i][0],leadership[i][1]);
    	
    	dfs(1);
    	
    	Vector<Integer> ans=new Vector();
    	int m=operations.length;
    	for(int i=0;i<m;i++) 
    	{
    		if(operations[i][0]==1)
    			_add(1,1,n,st[operations[i][1]],st[operations[i][1]],operations[i][2]);
    		else if(operations[i][0]==2)
    			_add(1,1,n,st[operations[i][1]],ed[operations[i][1]],operations[i][2]);
    		else
    			ans.add(query(1,1,n,st[operations[i][1]],ed[operations[i][1]]));
    	}
    	int[] res=new int[ans.size()];
    	for(int i=0;i<ans.size();i++)
    		res[i]=ans.get(i);
    	
    	return res;
    }
    
    private void add(int x,int y)
    {
    	tot++;
    	nxt[tot]=head[x];
    	head[x]=tot;
    	v[tot]=y;
    }
    
    private void dfs(int pos)
    {
    	st[pos]=++cnt;
    	for(int i=head[pos];i!=0;i=nxt[i])
    		dfs(v[i]);
    	ed[pos]=cnt;
    }
    
    private void _add(int pos,int l,int r,int lp,int rp,int x)
    {
    	if(l==lp && r==rp)
    	{
    		tag[pos]+=x; tag[pos]%=mod;
    		sum[pos]+=(long)x*(r-l+1)%mod; sum[pos]%=mod;
    		return;
    	}
    	down(pos,l,r);
    	int mid=(l+r) >> 1;
    	if(rp<=mid)
    		_add(pos<<1,l,mid,lp,rp,x);
    	if(lp>mid)
    		_add((pos<<1)+1,mid+1,r,lp,rp,x);
    	if(lp<=mid && rp>mid)
    	{
    		_add(pos<<1,l,mid,lp,mid,x);
    		_add((pos<<1)+1,mid+1,r,mid+1,rp,x);
    	}
    	sum[pos]=sum[pos<<1]+sum[(pos<<1)+1];
    	sum[pos]%=mod;
    }
    
    private int query(int pos,int l,int r,int lp,int rp)
    {
    	if(l==lp && r==rp)
    		return sum[pos];
    	down(pos,l,r);
    	int mid=(l+r) >> 1;
    	if(rp<=mid)
    		return query(pos<<1,l,mid,lp,rp)%mod;
    	if(lp>mid)
    		return query((pos<<1)+1,mid+1,r,lp,rp)%mod;
    	return (query(pos<<1,l,mid,lp,mid)+query((pos<<1)+1,mid+1,r,mid+1,rp))%mod;
    }
    
    private void down(int pos,int l,int r)
    {
    	if(tag[pos]!=0)
    	{
    		int mid=(l+r)/2;
    		tag[pos<<1]+=tag[pos]; tag[pos<<1]%=mod;
    		tag[(pos<<1)+1]+=tag[pos]; tag[(pos<<1)+1]%=mod;
     		sum[pos<<1]+=(long)tag[pos]*(mid-l+1)%mod; sum[pos<<1]%=mod;
    		sum[(pos<<1)+1]+=(long)tag[pos]*(r-mid)%mod; sum[(pos<<1)+1]%=mod;
    		tag[pos]=0;
    	}
    }
}