結果

問題 No.900 aδδitivee
ユーザー ningenMeningenMe
提出日時 2019-10-04 23:11:10
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 344 ms / 2,000 ms
コード長 16,581 bytes
コンパイル時間 2,613 ms
コンパイル使用メモリ 194,600 KB
実行使用メモリ 47,916 KB
最終ジャッジ日時 2024-10-03 08:39:02
合計ジャッジ時間 10,895 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
5,248 KB
testcase_01 AC 1 ms
5,248 KB
testcase_02 AC 2 ms
5,248 KB
testcase_03 AC 2 ms
5,248 KB
testcase_04 AC 1 ms
5,248 KB
testcase_05 AC 2 ms
5,248 KB
testcase_06 AC 1 ms
5,248 KB
testcase_07 AC 314 ms
42,224 KB
testcase_08 AC 311 ms
42,492 KB
testcase_09 AC 334 ms
42,356 KB
testcase_10 AC 325 ms
42,344 KB
testcase_11 AC 331 ms
42,356 KB
testcase_12 AC 323 ms
42,356 KB
testcase_13 AC 327 ms
42,224 KB
testcase_14 AC 344 ms
42,344 KB
testcase_15 AC 329 ms
42,224 KB
testcase_16 AC 330 ms
42,232 KB
testcase_17 AC 327 ms
42,356 KB
testcase_18 AC 325 ms
42,220 KB
testcase_19 AC 332 ms
42,220 KB
testcase_20 AC 339 ms
42,224 KB
testcase_21 AC 339 ms
42,220 KB
testcase_22 AC 289 ms
47,792 KB
testcase_23 AC 288 ms
47,788 KB
testcase_24 AC 274 ms
47,660 KB
testcase_25 AC 279 ms
47,788 KB
testcase_26 AC 278 ms
47,660 KB
testcase_27 AC 270 ms
47,916 KB
testcase_28 AC 270 ms
47,664 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#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 N;
	int is_weighted;
	int MAX_bit;
	int idx;
	vector<vector<int>> edge;
	vector<vector<T>> weight;
	vector<int> depth;
	vector<int> order;
	vector<T> dist;
	
	vector<int> parent;
	vector<T> parent_dist;
	
	vector<vector<int>> child;
	vector<vector<T>> child_dist;
 
	vector<vector<int>> ancestor;
	vector<vector<int>> descendant;
	
	vector<int> euler_tour;
    vector<T> euler_tour_dist;
	vector<int> idxl;
	vector<int> idxr;
 
	Tree(const int N, const int is_weighted = 0, const int MAX_bit = 20) : 
	N(N),
	is_weighted(is_weighted),
	MAX_bit(MAX_bit),
	edge(N),
	depth(N),
	order(N)
	{
		if(is_weighted) weight.resize(N);
		if(is_weighted) dist.resize(N);
	}
 
	//O(1) anytime
	void make_edge(const int& from, const int& to, const T& w = 0) {
		edge[from].push_back(to);
		if(is_weighted)	weight[from].push_back(w);
	}
 
	//O(N) anytime
	void make_depth(const int root) {
		depth[root] = 0;
		if(is_weighted) dist[root] = 0;
		idx = 0;
		dfs1(root);
		order[idx++] = root;
	}
 
    //for make_depth
	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(is_weighted) dist[to] = dist[from] + weight[from][i];
			dfs1(to,from);
			order[idx++] = to;
		}
	}
 
    //O(N) anytime
	int diameter(void){
		make_depth(0);
		int tmp = max_element(depth.begin(), depth.end()) - depth.begin();
		make_depth(tmp);
		return *max_element(depth.begin(), depth.end());
	}
 
	//O(N) after make_depth
	void make_parent(void) {
		parent.resize(N);
		iota(parent.begin(),parent.end(),0);
		for (int i = 0; i < N; ++i) for (auto j : edge[i]) if (depth[i] > depth[j]) parent[i] = j;
 
		if(is_weighted) {
			parent_dist.resize(N);
			for (int i = 0; i < N; ++i) for (int j = 0; j < edge[i].size(); ++j) if (depth[i] > depth[edge[i][j]]) parent_dist[i] = weight[i][j];
		}
	}
 
	//O(N) after make_depth
	void make_child(void) {
		child.resize(N);
		for (int i = 0; i < N; ++i) for (auto j : edge[i]) if (depth[i] < depth[j]) child[i].push_back(j);
 
		if(is_weighted) {
			child_dist.resize(N);
			for (int i = 0; i < N; ++i) for (int j = 0; j < edge[i].size(); ++j) if (depth[i] < depth[edge[i][j]]) child_dist[i].push_back(weight[i][j]);
		}
	}
 
	//O(NlogN) after make_depth
	void make_ancestor(void) {
		ancestor.resize(N,vector<int>(MAX_bit));
		for (int i = 0; i < N; ++i) ancestor[i][0] = i;
		for (int i = 0; i < N; ++i) for (auto j : edge[i]) if (depth[i] > depth[j]) ancestor[i][0] = j;
		for (int bit = 1; bit < MAX_bit; ++bit) for (int i = 0; i < N; ++i) ancestor[i][bit] = ancestor[ancestor[i][bit - 1]][bit - 1];
	}
 
	//O(N^2) after make_depth
	void make_descendant(void) {
		descendant.resize(N);
		for (int i = 0; i < N; ++i) descendant[i].push_back(i);
		for (int i = 0; i < N; ++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 make_ancestor
	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 < MAX_bit; ++bit) if (diff & (1 << bit)) l = ancestor[l][bit];
		if(l==r) return l;
		for (int bit = MAX_bit - 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 make_child and make_parent
	void make_euler_tour(void){
        dfs2(order[N-1]);
		idxl.resize(N);
		idxr.resize(N);
		for(int i = 0; i < euler_tour.size(); ++i) idxr[euler_tour[i]] = i;
		for(int i = euler_tour.size()-1; 0 <= i; --i) idxl[euler_tour[i]] = i;
		return;
	}
 
    //for make_euler_tour
	void dfs2(int from, int prev = -1){
		euler_tour.push_back(from);
        if(is_weighted) euler_tour_dist.push_back(parent_dist[from]);
 
        for(int i = 0; i < child[from].size(); ++i){
            int to = child[from][i];
            
            dfs2(to,from);            
 
    		euler_tour.push_back(from);
            if(is_weighted) euler_tour_dist.push_back(-child_dist[from][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




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.make_edge(u,v,w);
        tree.make_edge(v,u,w);
    }

    tree.make_depth(0);
    tree.make_child();
    tree.make_parent();
    tree.make_euler_tour();
    int M = tree.euler_tour.size();
//    for(int i = 1; i < M; ++i) tree.euler_tour_dist[i] += tree.euler_tour_dist[i-1]
 
    vector<int> up,dn;
    vector<ll> upw,dnw;
    up.push_back(0);
    upw.push_back(0);
    for(int i = 1; i < M; ++i) {
        int l = tree.euler_tour[i-1];
        int r = tree.euler_tour[i];
        if(tree.depth[l] < tree.depth[r]) {
            up.push_back(i);
            upw.push_back(tree.euler_tour_dist[i]);
        }
        else {
            dn.push_back(i);
            dnw.push_back(tree.euler_tour_dist[i]);
        }
    }
    // print(tree.euler_tour);
    // print(tree.euler_tour_dist);
    // print(tree.idxl);
    // print(tree.idxr);
    // print(upw);
    // print(dnw);


    // //区間加算 + 区間総和
    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> SegUp(upw,0,0,funcNode,funcLazy,funcMerge),SegDn(dnw,0,0,funcNode,funcLazy,funcMerge);
    
    int Q; cin >> Q;
    while(Q--) {
        int q;
        cin >> q;
        if(q==1) {
            int a,x; cin >> a >> x;
            int l = tree.idxl[a];
            int r = tree.idxr[a];
            int ul = upper_bound(ALL(up),l) - up.begin();
            int ur = upper_bound(ALL(up),r) - up.begin();
            if(ul<ur) SegUp.update(ul,ur,x);
            int dl = lower_bound(ALL(dn),l) - dn.begin();
            int dr = upper_bound(ALL(dn),r) - dn.begin();
            if(dl<dr) SegDn.update(dl,dr,-x);
            // cout << endl;
            // print(a);
            // print(l,r);
            // print(ul,ur);
            // print(dl,dr);
            // for(auto e:up) cout << tree.euler_tour[e] << " "; cout << endl;
            // SegUp.print();
            // for(auto e:dn) cout << tree.euler_tour[e] << " "; cout << endl;
            // SegDn.print();
            // cout << endl;
        }
        else {
            int b; cin >> b;
            int l = tree.idxl[b];
            int ul = lower_bound(ALL(up),l) - up.begin();
            int dl = lower_bound(ALL(dn),l) - dn.begin();
            ll ans = SegUp.get(0,ul+1) + SegDn.get(0,dl);
            // cout << endl;
            // print(b);
            // print(l,ul,dl);

            // for(auto e:up) cout << tree.euler_tour[e] << " "; cout << endl;
            // SegUp.print();
            // for(auto e:dn) cout << tree.euler_tour[e] << " "; cout << endl;
            // SegDn.print();
            cout << ans << endl;
        }
    }




    return 0; 
}
0