結果

問題 No.900 aδδitivee
ユーザー ningenMe
提出日時 2019-10-05 03:14:35
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 345 ms / 2,000 ms
コード長 15,812 bytes
コンパイル時間 2,339 ms
コンパイル使用メモリ 195,356 KB
実行使用メモリ 47,792 KB
最終ジャッジ日時 2024-10-04 09:58:53
合計ジャッジ時間 11,159 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 2
other AC * 27
権限があれば一括ダウンロードができます

ソースコード

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 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;
 
    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(nodeNum) 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(nodeNum) 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(nodeNum) 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(nodeNum) 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(nodeNum^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(nodeNum) 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]);
        }
    }
 
};
 
//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();
    int M = tree.eulerTour.size();
    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.eulerTour[i-1];
        int r = tree.eulerTour[i];
        if(tree.depth[l] < tree.depth[r]) {
            up.push_back(i);
            upw.push_back(tree.eulerTourDist[i]);
        }
        else {
            dn.push_back(i);
            dnw.push_back(tree.eulerTourDist[i]);
        }
    }
    //区間加算 + 区間総和
    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);
        }
        else {
            int b; cin >> b;
            int l = tree.idxL[b];
            int ul = upper_bound(ALL(up),l) - up.begin();
            int dl = lower_bound(ALL(dn),l) - dn.begin();
            ll ans = SegUp.get(0,ul) + SegDn.get(0,dl);
            cout << ans << endl;
        }
    }
    return 0; 
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0