#387199 (C++14) No.900 aδδitivee

提出ソース
結果

問題	No.900 aδδitivee
ユーザー	ningenMe
提出日時	2019-10-05 14:06:02
言語	C++14 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	416 ms / 2,000 ms
コード長	16,719 bytes
コンパイル時間	2,848 ms
コンパイル使用メモリ	196,824 KB
実行使用メモリ	48,544 KB
最終ジャッジ日時	2024-10-05 20:12:50
合計ジャッジ時間	12,572 ms
ジャッジサーバーID （参考情報）	judge2 / judge5
このコードへのチャレンジ
（要ログイン）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 5,248 KB
testcase_01	AC	2 ms 5,248 KB
testcase_02	AC	2 ms 5,248 KB
testcase_03	AC	2 ms 5,248 KB
testcase_04	AC	2 ms 5,248 KB
testcase_05	AC	2 ms 5,248 KB
testcase_06	AC	2 ms 5,248 KB
testcase_07	AC	395 ms 43,640 KB
testcase_08	AC	411 ms 43,768 KB
testcase_09	AC	413 ms 43,760 KB
testcase_10	AC	409 ms 43,632 KB
testcase_11	AC	401 ms 43,760 KB
testcase_12	AC	411 ms 43,648 KB
testcase_13	AC	407 ms 43,764 KB
testcase_14	AC	407 ms 43,752 KB
testcase_15	AC	399 ms 43,764 KB
testcase_16	AC	397 ms 43,768 KB
testcase_17	AC	416 ms 43,760 KB
testcase_18	AC	412 ms 43,628 KB
testcase_19	AC	410 ms 43,760 KB
testcase_20	AC	415 ms 43,760 KB
testcase_21	AC	403 ms 43,756 KB
testcase_22	AC	322 ms 48,544 KB
testcase_23	AC	320 ms 48,544 KB
testcase_24	AC	333 ms 48,540 KB
testcase_25	AC	323 ms 48,540 KB
testcase_26	AC	325 ms 48,540 KB
testcase_27	AC	333 ms 48,544 KB
testcase_28	AC	323 ms 48,540 KB
権限があれば一括ダウンロードができます
ソースコード

raw source code
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;

#define REP(i,n) for(long long i = 0; i < (n); i++)
#define FOR(i, m, n) for(long long i = (m);i < (n); ++i)
#define ALL(obj) (obj).begin(),(obj).end()
#define SPEED cin.tie(0);ios::sync_with_stdio(false);

template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQR = priority_queue<T,vector<T>,greater<T>>;

constexpr long long MOD = (long long)1e9 + 7;
constexpr long long MOD2 = 998244353;
constexpr long long HIGHINF = (long long)1e18;
constexpr long long LOWINF = (long long)1e15;
constexpr long double PI = 3.1415926535897932384626433;

template <class T> vector<T> multivector(size_t N,T init){return vector<T>(N,init);}
template <class... T> auto multivector(size_t N,T... t){return vector<decltype(multivector(t...))>(N,multivector(t...));}
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
template <class T, class U>ostream &operator<<(ostream &o, const map<T, U>&obj) {o << "{"; for (auto &x : obj) o << " {" << x.first << " : " << x.second << "}" << ","; o << " }"; return o;}
template <class T>ostream &operator<<(ostream &o, const set<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const multiset<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const vector<T>&obj) {o << "{"; for (int i = 0; i < (int)obj.size(); ++i)o << (i > 0 ? ", " : "") << obj[i]; o << "}"; return o;}
template <class T, class U>ostream &operator<<(ostream &o, const pair<T, U>&obj) {o << "{" << obj.first << ", " << obj.second << "}"; return o;}
template <template <class tmp>  class T, class U> ostream &operator<<(ostream &o, const T<U> &obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr)o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
void print(void) {cout << endl;}
template <class Head> void print(Head&& head) {cout << head;print();}
template <class Head, class... Tail> void print(Head&& head, Tail&&... tail) {cout << head << " ";print(forward<Tail>(tail)...);}
template <class T> void chmax(T& a, const T b){a=max(a,b);}
template <class T> void chmin(T& a, const T b){a=min(a,b);}
void YN(bool flg) {cout << (flg ? "YES" : "NO") << endl;}
void Yn(bool flg) {cout << (flg ? "Yes" : "No") << endl;}
void yn(bool flg) {cout << (flg ? "yes" : "no") << endl;}

template<class T = int> class Tree {
public:
	int nodeNum;
	int isWeighted;
	int maxBit;
	int idx;
	vector<vector<int>> edge;
	vector<vector<T>> weight;
	vector<int> depth;
	vector<int> order;
	vector<T> dist;
	
	vector<int> parent;
	vector<T> parentDist;
	
	vector<vector<int>> child;
	vector<vector<T>> childDist;
 
	vector<vector<int>> ancestor;
	vector<vector<int>> descendant;
	
	vector<int> eulerTour;
    vector<T> eulerTourDist;
	vector<int> idxL;
	vector<int> idxR;
    vector<int> eulerTourDive,eulerTourFloat;
    vector<T> eulerTourDiveDist,eulerTourFloatDist;
	vector<int> idxLDive,idxLFloat;
	vector<int> idxRDive,idxRFloat;
 
	Tree(const int nodeNum, const int isWeighted = 0, const int maxBit = 20) : 
	nodeNum(nodeNum),
	isWeighted(isWeighted),
	maxBit(maxBit),
	edge(nodeNum),
	depth(nodeNum),
	order(nodeNum)
	{
		if(isWeighted) weight.resize(nodeNum);
		if(isWeighted) dist.resize(nodeNum);
	}
 
	//O(1) anytime
	void makeEdge(const int& from, const int& to, const T& w = 0) {
		edge[from].push_back(to);
		if(isWeighted)	weight[from].push_back(w);
	}
 
	//O(N) anytime
	void makeDepth(const int root) {
		depth[root] = 0;
		if(isWeighted) dist[root] = 0;
		idx = 0;
		dfs1(root);
		order[idx++] = root;
	}
 
    //for makeDepth
	void dfs1(int from, int prev = -1){
		for(int i = 0; i < edge[from].size(); ++i){
			int to = edge[from][i];
			if(to==prev) continue;
			depth[to] = depth[from] + 1;
			if(isWeighted) dist[to] = dist[from] + weight[from][i];
			dfs1(to,from);
			order[idx++] = to;
		}
	}
 
    //O(N) anytime
	int diameter(void){
		makeDepth(0);
		int tmp = max_element(depth.begin(), depth.end()) - depth.begin();
		makeDepth(tmp);
		return *max_element(depth.begin(), depth.end());
	}
 
	//O(N) after makeDepth
	void makeParent(void) {
		parent.resize(nodeNum);
		iota(parent.begin(),parent.end(),0);
		for (int i = 0; i < nodeNum; ++i) for (auto j : edge[i]) if (depth[i] > depth[j]) parent[i] = j;
 
		if(isWeighted) {
			parentDist.resize(nodeNum);
			for (int i = 0; i < nodeNum; ++i) for (int j = 0; j < edge[i].size(); ++j) if (depth[i] > depth[edge[i][j]]) parentDist[i] = weight[i][j];
		}
	}
 
	//O(N) after makeDepth
	void makeChild(void) {
		child.resize(nodeNum);
		for (int i = 0; i < nodeNum; ++i) for (auto j : edge[i]) if (depth[i] < depth[j]) child[i].push_back(j);
 
		if(isWeighted) {
			childDist.resize(nodeNum);
			for (int i = 0; i < nodeNum; ++i) for (int j = 0; j < edge[i].size(); ++j) if (depth[i] < depth[edge[i][j]]) childDist[i].push_back(weight[i][j]);
		}
	}
 
	//O(NlogN) after makeDepth
	void makeAncestor(void) {
		ancestor.resize(nodeNum,vector<int>(maxBit));
		for (int i = 0; i < nodeNum; ++i) ancestor[i][0] = i;
		for (int i = 0; i < nodeNum; ++i) for (auto j : edge[i]) if (depth[i] > depth[j]) ancestor[i][0] = j;
		for (int bit = 1; bit < maxBit; ++bit) for (int i = 0; i < nodeNum; ++i) ancestor[i][bit] = ancestor[ancestor[i][bit - 1]][bit - 1];
	}
 
	//O(N^2) after makeDepth
	void makeDescendant(void) {
		descendant.resize(nodeNum);
		for (int i = 0; i < nodeNum; ++i) descendant[i].push_back(i);
		for (int i = 0; i < nodeNum; ++i) for (auto j : edge[order[i]]) if (depth[order[i]] < depth[j]) for(auto k: descendant[j]) descendant[order[i]].push_back(k);
	}
 
	//O(logN) after makeAncestor
	int lca(int l, int r) {
		if (depth[l] < depth[r]) swap(l, r);
		int diff = depth[l] - depth[r];
		for (int bit = 0; bit < maxBit; ++bit) if (diff & (1 << bit)) l = ancestor[l][bit];
		if(l==r) return l;
		for (int bit = maxBit - 1; 0 <= bit; --bit) if(ancestor[l][bit]!=ancestor[r][bit]) l = ancestor[l][bit], r = ancestor[r][bit];
		return ancestor[l][0];
	}
 
	//O(N) after makeChild and makeParent
	void makeEulerTour(void){
        dfs2(order[nodeNum-1]);
		idxL.resize(nodeNum);
		idxR.resize(nodeNum);
		for(int i = 0; i < eulerTour.size(); ++i) idxR[eulerTour[i]] = i;
		for(int i = eulerTour.size()-1; 0 <= i; --i) idxL[eulerTour[i]] = i;
		return;
	}
 
    //for makeEulerTour
	void dfs2(int from, int prev = -1){
		eulerTour.push_back(from);
        if(isWeighted) eulerTourDist.push_back(parentDist[from]);
 
        for(int i = 0; i < child[from].size(); ++i){
            int to = child[from][i];            
            dfs2(to,from);            
    		eulerTour.push_back(from);
            if(isWeighted) eulerTourDist.push_back(-childDist[from][i]);
        }
	}

	//after makeEulerTour
	void makeEulerTourEdge(void) {
		eulerTourDive.push_back(order[nodeNum-1]);
		if(isWeighted) eulerTourDiveDist.push_back(0);
		for(int i = 1; i < eulerTour.size(); ++i) {
			int l = eulerTour[i-1];
			int r = eulerTour[i];
			if(depth[l] < depth[r]) {
				eulerTourDive.push_back(i);
				if(isWeighted) eulerTourDiveDist.push_back(eulerTourDist[i]);
			}
			else {
				eulerTourFloat.push_back(i);
				if(isWeighted) eulerTourFloatDist.push_back(eulerTourDist[i]);
			}
		}
		idxLDive.resize(nodeNum);
		idxRDive.resize(nodeNum);
		idxLFloat.resize(nodeNum);
		idxRFloat.resize(nodeNum);
		for(int i = 0; i < nodeNum; ++i) {
			int l = idxL[i];
			int r = idxR[i];
			idxLDive[i]  =  upper_bound(eulerTourDive.begin() ,eulerTourDive.end() ,l) - eulerTourDive.begin()     ;
			idxRDive[i]  = (upper_bound(eulerTourDive.begin() ,eulerTourDive.end() ,r) - eulerTourDive.begin())  -1;
			idxLFloat[i] =  upper_bound(eulerTourFloat.begin(),eulerTourFloat.end(),l) - eulerTourFloat.begin()    ;
			idxRFloat[i] = (upper_bound(eulerTourFloat.begin(),eulerTourFloat.end(),r) - eulerTourFloat.begin()) -1;
			idxRDive[i]  = max(idxLDive[i]-1 ,idxRDive[i]);
			idxRFloat[i] = max(idxLFloat[i]-1,idxRFloat[i]);
		}
	}
		// iの部分木の頂点に加算するとき
		// [ idxL[i]  ,idxR[i]  ]に　+val
		// [i]の頂点クエリ
		// [idxL[i],idxL[i]]

		// iの部分木の辺に加算するとき
		// [ idxLDive[i]  ,idxRDive[i]  ]に　+val
		// [ idxLFloat[i] ,idxRFloat[i] ]に　-val
		// [0,i]のパスクエリ
		// [ 0, idxLDive[i] ) + [0, idxLFloat[i])
 
};
 
//depth,dist
//https://atcoder.jp/contests/abc126/tasks/abc126_d
 
//lca
//https://atcoder.jp/contests/abc014/tasks/abc014_4
 
//child
//https://atcoder.jp/contests/abc133/tasks/abc133_e

//eulerTour
//https://yukicoder.me/problems/no/900



template<class T> class LazySegmentTree {
	size_t length;                  //セグメント木の最下段の要素の数(vectorの要素の数を超える2べきの数)
	size_t height;                  //セグメント木の高さ 
	T unitNode;                     //nodeの単位元
	T unitLazy;                     //lazyの単位元
	vector<T> node;                 //node
	vector<T> lazy;                 //lazy
	vector<int> width;              //width
	function<T(T,T)> funcNode;      //node同士の演算
	function<T(T,T)> funcLazy;      //lazy同士の演算
	function<T(T,T,int)> funcMerge; //nodeとlazyの演算

public:
	//vectorで初期化
	LazySegmentTree(const vector<T> & vec, const T unitNode, const T unitLazy, function<T(T,T)> funcNode, function<T(T,T)> funcLazy,function<T(T,T,int)> funcMerge)
	 : unitNode(unitNode), unitLazy(unitLazy), funcNode(funcNode),funcLazy(funcLazy),funcMerge(funcMerge) {
		for (length = 1,height = 0; length < vec.size(); length *= 2, height++);
		node.resize(2 * length, unitNode);
		lazy.resize(2 * length, unitLazy);
		for (int i = 0; i < vec.size(); ++i) node[i + length] = vec[i];
		for (int i = length - 1; i >= 0; --i) node[i] = funcNode(node[(i<<1)+0],node[(i<<1)+1]);
		width.resize(2 * length, 0);
		for(int i = length; i < 2*length; ++i) for(int j = i, k = 1; j && !width[j] ; j >>= 1,k <<= 1) width[j] = k;
	}

	//同じinitで初期化
	LazySegmentTree(const size_t num, const T unitNode, const T unitLazy, const T init, function<T(T,T)> funcNode, function<T(T,T)> funcLazy,function<T(T,T,int)> funcMerge)
	 : unitNode(unitNode), unitLazy(unitLazy), funcNode(funcNode),funcLazy(funcLazy),funcMerge(funcMerge) {
		for (length = 1,height = 0; length < num; length *= 2, height++);
		node.resize(2 * length, unitNode);
		lazy.resize(2 * length, unitLazy);
		for (int i = 0; i < num; ++i) node[i + length] = init;
		for (int i = length - 1; i >= 0; --i) node[i] = funcNode(node[(i<<1)+0],node[(i<<1)+1]);
		width.resize(2 * length, 0);
		for(int i = length; i < 2*length; ++i) for(int j = i, k = 1; j && !width[j] ; j >>= 1,k <<= 1) width[j] = k;
	}
 
	//unitだけで初期化
	LazySegmentTree(const size_t num, const T unitNode, const T unitLazy, function<T(T,T)> funcNode, function<T(T,T)> funcLazy,function<T(T,T,int)> funcMerge)
	: unitNode(unitNode), unitLazy(unitLazy), funcNode(funcNode),funcLazy(funcLazy),funcMerge(funcMerge) {
		for (length = 1,height = 0; length < num; length *= 2, height++);
		node.resize(2 * length, unitNode);
		lazy.resize(2 * length, unitLazy);
		width.resize(2 * length, 0);
		for(int i = length; i < 2*length; ++i) for(int j = i, k = 1; j && !width[j] ; j >>= 1,k <<= 1) width[j] = k;
	}


	void propagate(int k) {
		if(lazy[k] == unitLazy) return;
		node[k] = funcMerge(node[k],lazy[k],width[k]);
		if(k < length) lazy[2*k+0] = funcLazy(lazy[2*k+0],lazy[k]);
		if(k < length) lazy[2*k+1] = funcLazy(lazy[2*k+1],lazy[k]);
		lazy[k] = unitLazy;
    }


	//idx : 0-indexed
    void update(int a, int b, T x) {
		int l = a + length, r = b + length - 1;
		for (int i = height; 0 < i; --i) propagate(l >> i), propagate(r >> i);
		for(r++; l < r; l >>=1, r >>=1) {
			if(l&1) lazy[l] = funcLazy(lazy[l],x), propagate(l),l++;
			if(r&1) --r,lazy[r] = funcLazy(lazy[r],x), propagate(r);
		}
		l = a + length, r = b + length - 1;
		while ((l>>=1),(r>>=1),l) {
			if(lazy[l] == unitLazy) node[l] = funcNode(funcMerge(node[(l<<1)+0],lazy[(l<<1)+0],width[(l<<1)+0]),funcMerge(node[(l<<1)+1],lazy[(l<<1)+1],width[(l<<1)+1]));
			if(lazy[r] == unitLazy) node[r] = funcNode(funcMerge(node[(r<<1)+0],lazy[(r<<1)+0],width[(r<<1)+0]),funcMerge(node[(r<<1)+1],lazy[(r<<1)+1],width[(r<<1)+1]));
		}
    }

	//[l,r)
	T get(int a, int b) {
		int l = a + length, r = b + length - 1;
		for (int i = height; 0 < i; --i) propagate(l >> i), propagate(r >> i);
		T vl = unitNode, vr = unitNode;
		for(r++; l < r; l >>=1, r >>=1) {
			if(l&1) vl = funcNode(vl,funcMerge(node[l],lazy[l],width[l])),l++;
			if(r&1) r--,vr = funcNode(vr,funcMerge(node[r],lazy[r],width[r]));
		}
		return funcNode(vl,vr);
	}

	void print(){
		// cout << "height" << " " << height << endl;
		// cout << "node" << endl;
		// for(int i = 1,j = 1; i < 2*length; ++i) {
		// 	cout << node[i] << " ";
		// 	if(i==((1<<j)-1) && ++j) cout << endl;
		// }
		// cout << "lazy" << endl;
		// for(int i = 1,j = 1; i < 2*length; ++i) {
		// 	cout << lazy[i] << " ";
		// 	if(i==((1<<j)-1) && ++j) cout << endl;
		// }
		// cout << "width" << endl;
		// for(int i = 1,j = 1; i < 2*length; ++i) {
		// 	cout << width[i] << " ";
		// 	if(i==((1<<j)-1) && ++j) cout << endl;
		// }
		cout << "vector" << endl;
		cout << "{ " << get(0,1);
		for(int i = 1; i < length; ++i) cout << ", " << get(i,i+1);
		cout << " }" << endl;
	}

};

//RUQ + RMQ
//verify https://atcoder.jp/contests/nikkei2019-final/tasks/nikkei2019_final_d
//verify https://atcoder.jp/contests/code-festival-2018-final/tasks/code_festival_2018_final_e

//RUQ + RMQ
//verify https://atcoder.jp/contests/nikkei2019-final/tasks/nikkei2019_final_d

// 区間加算 + 区間最小
// function<ll(ll,ll)> funcNode  = [&](ll l,ll r){return min(l,r);};
// function<ll(ll,ll)> funcLazy  = [&](ll l,ll r){return l+r;};
// function<ll(ll,ll,int)> funcMerge = [&](ll l,ll r,int c){return l+r;};
// LazySegmentTree<ll> Seg(N,inf,0,0,funcNode,funcLazy,funcMerge);

// 区間加算 + 区間総和
// function<ll(ll,ll)> funcNode  = [&](ll l,ll r){return l+r;};
// function<ll(ll,ll)> funcLazy  = [&](ll l,ll r){return l+r;};
// function<ll(ll,ll,int)> funcMerge = [&](ll l,ll r,int c){return l+r*c;};
// LazySegmentTree<ll> Seg(N,0,0,funcNode,funcLazy,funcMerge);

// 区間更新 + 区間総和
// function<ll(ll,ll)> funcNode  = [&](ll l,ll r){return l+r;};
// function<ll(ll,ll)> funcLazy  = [&](ll l,ll r){return r;};
// function<ll(ll,ll,int)> funcMerge = [&](ll l,ll r,int c){return r!=-2000?r*c:l;};
// LazySegmentTree<ll> Seg(N,0,-2000,0,funcNode,funcLazy,funcMerge);

// 区間更新 + 区間最大
// function<ll(ll,ll)> funcNode  = [&](ll l,ll r){return max(l,r);};
// function<ll(ll,ll)> funcLazy  = [&](ll l,ll r){return r;};
// function<ll(ll,ll,int)> funcMerge = [&](ll l,ll r,int c){return r!=0?r:l;};
// LazySegmentTree<ll> Seg(N+2,0,0,funcNode,funcLazy,funcMerge);

	// 区間加算　区間総和 mod
	// function<ll(ll,ll)> funcNode  = [&](ll l,ll r){return (l+r) % MOD;};
	// function<ll(ll,ll)> funcLazy  = [&](ll l,ll r){return (l+r) % MOD;};
	// function<ll(ll,ll,int)> funcMerge = [&](ll l,ll r,int c){return (l+(r*c) % MOD) % MOD;};
	// LazySegmentTree<ll> dp(N+3,0,0,funcNode,funcLazy,funcMerge);


int main() {
    SPEED
    int N;
    cin >> N;
    Tree<ll> tree(N,1);
    for(int i = 0; i < N-1; ++i) {
        int u,v,w;
        cin >> u >> v >> w;
        tree.makeEdge(u,v,w);
        tree.makeEdge(v,u,w);
    }

    tree.makeDepth(0);
    tree.makeChild();
    tree.makeParent();
    tree.makeEulerTour();
	tree.makeEulerTourEdge();

    //区間加算 + 区間総和
    function<ll(ll,ll)> funcNode  = [&](ll l,ll r){return l+r;};
    function<ll(ll,ll)> funcLazy  = [&](ll l,ll r){return l+r;};
    function<ll(ll,ll,int)> funcMerge = [&](ll l,ll r,int c){return l+r*c;};
    LazySegmentTree<ll> SegDive(tree.eulerTourDiveDist,0,0,funcNode,funcLazy,funcMerge),SegFloat(tree.eulerTourFloatDist,0,0,funcNode,funcLazy,funcMerge);
    
    int Q; cin >> Q;
    while(Q--) {
        int q;
        cin >> q;
        if(q==1) {
            int a,x; cin >> a >> x;
            SegDive.update(tree.idxLDive[a],tree.idxRDive[a]+1,x);
            SegFloat.update(tree.idxLFloat[a],tree.idxRFloat[a]+1,-x);
        }
        else {
            int b; cin >> b;
            cout << SegDive.get(0,tree.idxLDive[b])+SegFloat.get(0,tree.idxLFloat[b]) << endl;
        }
    }

    return 0; 
}