#pragma GCC optimize("Ofast") #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; typedef long long ll; typedef vector vi; typedef pair pii; #define MP make_pair #define PB push_back #define inf 1000000007 #define rep(i,n) for(int i = 0; i < (int)(n); ++i) #define all(x) (x).begin(),(x).end() template void Fill(A (&array)[N], const T &val){ std::fill( (T*)array, (T*)(array+N), val ); } template inline bool chmax(T &a, T b){ if(a inline bool chmin(T &a, T b){ if(a>b){ a = b; return true; } return false; } template class UnorderedMapIterator; template, bool DOWNSIZE = false> class UnorderedMap { private: using iterator = UnorderedMapIterator<_Key, _Tp, _Hash, DOWNSIZE>; using value_type = _Tp; using data_type = pair<_Key, _Tp>; using aligned_pointer = typename aligned_storage::type; friend UnorderedMapIterator<_Key, _Tp, _Hash, DOWNSIZE>; struct bucket { _Key _key; short int _dist; bool _last, _end; aligned_pointer _value_ptr; bucket() noexcept : _dist(-1), _last(false), _end(false){} bucket& operator=(const bucket& another) noexcept { _key = another._key, _dist = another._dist, _last = another._last, _end = another._end; if(!another.empty()){ new(&_value_ptr) value_type(*reinterpret_cast(&another._value_ptr)); } return *this; } ~bucket(){ if(!empty()) _delete(); } inline void clear() noexcept { _dist = -1; } inline void _delete(){ _dist = -1, value_ptr()->~value_type(); } inline bool empty() const noexcept { return (_dist == -1); } inline value_type& value() noexcept { return *reinterpret_cast(&_value_ptr); } inline value_type* value_ptr() noexcept { return reinterpret_cast(&_value_ptr); } inline void new_value(value_type&& value){ new(&_value_ptr) value_type(move(value)); } }; inline static unsigned int ceilpow2(unsigned int u) noexcept { if(u == 0u) return 0u; --u, u |= u >> 1, u |= u >> 2, u |= u >> 4, u |= u >> 8; return (u | (u >> 16)) + 1u; } inline static bucket *increment(bucket *cur) noexcept { for(++cur; !cur->_end; ++cur){ if(!cur->empty()) break; } return cur; } inline bucket *next_bucket(bucket *cur) const noexcept { return cur->_last ? _buckets : cur + 1; } inline unsigned int make_hash(const _Key& key) const noexcept { return _Hash()(key); } inline float load_rate() const noexcept { return (float)_data_count / _bucket_count; } bucket *insert(bucket *cur, _Key&& key, short int dist, value_type&& value){ bucket *ret = cur; bool flag = false; while(true){ if(cur->empty()){ cur->_key = move(key), cur->_dist = dist, cur->new_value(move(value)); if(!flag) ret = cur, flag = true; break; }else if(dist > cur->_dist){ swap(key, cur->_key), swap(dist, cur->_dist), swap(value, cur->value()); if(!flag) ret = cur, flag = true; } ++dist; cur = next_bucket(cur); } return ret; } template bucket *_find(Key&& key, bool push = false){ unsigned int hash = make_hash(key); bucket *cur = _buckets + (hash & _mask); short int dist = 0; while(dist <= cur->_dist){ if(key == cur->_key) return cur; ++dist, cur = next_bucket(cur); } if(!push) return _buckets + _bucket_count; ++_data_count; if(rehash_check()){ cur = _buckets + (hash & _mask), dist = 0; } value_type new_value = value_type(); _Key new_key = forward(key); return insert(cur, move(new_key), dist, move(new_value)); } template bucket *find_insert(Data&& data){ const _Key& key = data.first; unsigned int hash = make_hash(key); bucket *cur = _buckets + (hash & _mask); short int dist = 0; while(dist <= cur->_dist){ if(key == cur->_key) return cur; ++dist, cur = next_bucket(cur); } ++_data_count; if(rehash_check()){ cur = _buckets + (hash & _mask), dist = 0; } data_type new_data = forward(data); return insert(cur, move(new_data.first), dist, move(new_data.second)); } template bucket *emplace(Args&&... args){ return find_insert(data_type(forward(args)...)); } bucket *backward_shift(bucket *cur, bool next_ret){ bucket *next = next_bucket(cur), *ret = cur; if(next->_dist < 1) return next_ret ? increment(cur) : cur; do { cur->_key = next->_key, cur->_dist = next->_dist - 1; cur->new_value(move(next->value())); cur = next, next = next_bucket(cur); }while(next->_dist >= 1); cur->clear(); return ret; } bucket *erase_impl(bucket *cur, bool next_ret){ assert(static_cast(cur - _buckets) != _bucket_count); cur->_delete(); --_data_count; return backward_shift(cur, next_ret); } bucket *erase_itr(bucket *cur, bool next_ret = true){ const _Key key = cur->_key; return erase_impl(rehash_check() ? _find(key) : cur, next_ret); } size_t erase_key(const _Key& key){ rehash_check(); bucket *cur = _find(key); if(static_cast(cur - _buckets) == _bucket_count){ return 0; }else{ erase_impl(_find(key), false); return 1; } } bool rehash_check(){ if(_bucket_count == 0){ rehash(1u); return true; }else if(load_rate() >= MAX_LOAD_RATE){ rehash(_bucket_count * 2u); return true; }else if(DOWNSIZE){ if(load_rate() <= MIN_LOAD_RATE && _bucket_count >= DOWNSIZE_THRESHOLD){ rehash(_bucket_count / 2u); return true; } } return false; } void move_data(bucket *cur){ insert(_buckets + (make_hash(cur->_key) & _mask), move(cur->_key), 0, move(cur->value())); } void rehash(unsigned int new_bucket_count){ UnorderedMap new_unordered_map(new_bucket_count); new_unordered_map._data_count = _data_count; for(bucket *cur = _buckets; !cur->_end; ++cur){ if(!cur->empty()){ new_unordered_map.move_data(cur); } } swap(*this, new_unordered_map); } friend void swap(UnorderedMap& ump1, UnorderedMap& ump2){ swap(ump1._bucket_count, ump2._bucket_count); swap(ump1._mask, ump2._mask); swap(ump1._data_count, ump2._data_count); swap(ump1._buckets, ump2._buckets); } private: unsigned int _bucket_count, _mask, _data_count; bucket *_buckets; public: const float MAX_LOAD_RATE = 0.5f; const float MIN_LOAD_RATE = 0.1f; const unsigned int DOWNSIZE_THRESHOLD = 16u; UnorderedMap(unsigned int bucket_size = 0u) : _bucket_count(ceilpow2(bucket_size)), _mask(_bucket_count - 1), _data_count(0u), _buckets(new bucket[_bucket_count + 1]){ if(_bucket_count > 0) _buckets[_bucket_count - 1]._last = true; else _mask = 0; _buckets[_bucket_count]._end = true; } UnorderedMap(const UnorderedMap& another) : _bucket_count(another._bucket_count), _mask(another._mask), _data_count(another._data_count){ _buckets = new bucket[_bucket_count + 1u]; for(unsigned int i = 0u; i <= _bucket_count; ++i){ _buckets[i] = another._buckets[i]; } } UnorderedMap(UnorderedMap&& another) : _bucket_count(move(another._bucket_count)), _mask(move(another._mask)), _data_count(move(another._data_count)), _buckets(another._buckets){ another._buckets = nullptr; } UnorderedMap& operator=(const UnorderedMap& another){ delete[] _buckets; _bucket_count = another._bucket_count; _mask = another._mask; _data_count = another._data_count; _buckets = new bucket[_bucket_count + 1u]; for(unsigned int i = 0u; i <= _bucket_count; ++i){ _buckets[i] = another._buckets[i]; } return *this; } UnorderedMap& operator=(UnorderedMap&& another){ delete[] _buckets; _bucket_count = move(another._bucket_count); _mask = move(another._mask); _data_count = move(another._data_count); _buckets = another._buckets; another._buckets = nullptr; return *this; } void allocate(unsigned int element_size){ rehash(ceilpow2(ceil(element_size / MAX_LOAD_RATE) + 1)); } ~UnorderedMap(){ delete[] _buckets; } friend ostream& operator<< (ostream& os, UnorderedMap& ump) noexcept { for(auto val : ump) os << '{' << val.first << ',' << val.second << "} "; return os; } _Tp& operator[](const _Key& key){ return _find(key, true)->value(); } _Tp& operator[](_Key&& key){ return _find(move(key), true)->value(); } const _Tp& at(const _Key& key){ bucket *res = _find(key); if(res == _buckets + _bucket_count) __throw_out_of_range("Unordered_Map::at"); return res->value(); } void clear(){ UnorderedMap new_unordered_map(0u); swap(*this, new_unordered_map); } size_t size() const noexcept { return _data_count; } size_t bucket_count() const noexcept { return _bucket_count; } bool empty() const noexcept { return (_data_count == 0); } iterator begin() noexcept { return (_buckets->empty() && _bucket_count > 0) ? iterator(increment(_buckets)) : iterator(_buckets); } iterator end() noexcept { return iterator(_buckets + _bucket_count); } iterator find(const _Key& key){ return iterator(_find(key)); } iterator insert(const data_type& data){ return iterator(find_insert(data)); } iterator insert(data_type&& data){ return iterator(find_insert(move(data))); } template iterator emplace(Args&&... args){ return iterator(_emplace(forward(args)...)); } size_t erase(const _Key& key){ return erase_key(key); } iterator erase(const iterator& itr){ return iterator(erase_itr(itr.bucket_ptr)); } void simple_erase(const _Key& key){ erase_key(key); } void simple_erase(const iterator& itr){ erase_itr(itr.bucket_ptr, false); } // DEBUG 用 short int maximum_distance() const noexcept { short int ret = -1; for(bucket *cur = _buckets; !cur->_end; ++cur){ ret = max(ret, cur->_dist); } return ret; } }; template class UnorderedMapIterator { private: friend UnorderedMap<_Key, _Tp, _Hash, DOWNSIZE>; typename UnorderedMap<_Key, _Tp, _Hash, DOWNSIZE>::bucket *bucket_ptr; using iterator_category = forward_iterator_tag; using value_type = pair; using difference_type = ptrdiff_t; using reference = pair; private: UnorderedMapIterator(typename UnorderedMap<_Key, _Tp, _Hash, DOWNSIZE>::bucket *_bucket_ptr) noexcept : bucket_ptr(_bucket_ptr){} public: UnorderedMapIterator() noexcept : bucket_ptr(){} UnorderedMapIterator(const UnorderedMapIterator& itr) noexcept : bucket_ptr(itr.bucket_ptr){} UnorderedMapIterator& operator=(const UnorderedMapIterator& itr) & noexcept { return bucket_ptr = itr.bucket_ptr, *this; } UnorderedMapIterator& operator=(const UnorderedMapIterator&& itr) & noexcept { return bucket_ptr = itr.bucket_ptr, *this; } reference operator*() const noexcept { return {bucket_ptr->_key, bucket_ptr->value()}; } UnorderedMapIterator& operator++() noexcept { return bucket_ptr = UnorderedMap<_Key, _Tp, _Hash, DOWNSIZE>::increment(bucket_ptr), *this; } UnorderedMapIterator operator++(int) const noexcept { return UnorderedMapIterator(UnorderedMap<_Key, _Tp, _Hash, DOWNSIZE>::increment(this->bucket_ptr)); } bool operator==(const UnorderedMapIterator& itr) const noexcept { return !(*this != itr); }; bool operator!=(const UnorderedMapIterator& itr) const noexcept { return bucket_ptr != itr.bucket_ptr; } }; template class BIT { private: int n;ll m; vector > bit; public: void add(int i, ll j, T val){ chmax(m,j+2); for(int i_ = i+1; i_ < n; i_ += i_ & -i_) for(ll j_ = j+1; j_ < m; j_ += j_ & -j_) bit[i_][j_] += val; } // [0,i]×[0,j]の範囲の和を求める T sum(int i, ll j){ T s = 0; for(int i_ = i+1; i_ > 0; i_ -= i_ & -i_) for(ll j_ = j+1; j_ > 0; j_ -= j_ & -j_) if(bit[i_].find(j_)!=bit[i_].end())s += bit[i_][j_]; return s; } // [lx, rx)×[ly, ry)の範囲の和を求める // T sum(int lx, int rx, ll ly, ll ry){ // return sum(rx-1, ry-1) - sum(lx-1, ry-1) - sum(rx-1, ly-1) + sum(lx-1, ly-1); // } BIT(int sz1,int sz2){ n = sz1 + 1; m = sz2 + 1; bit.resize(n); } void print(){ for(int i = 0; i < n; i++){ for(int j = 0; j < m; j++){ cout<< sum(i-1, i, j-1, j) << " "; } cout << "\n"; } } void print_sum(){ for(int i = 0; i < n; i++){ for(int j = 0; j < m; j++){ cout<< sum(i-1, j-1) << " "; } cout << "\n"; } } }; vector > > g; ll parent[17][50000]; ll dep[50000]; int in[50000]; int out[50000]; int te; void init(int id,int pre){ in[id] = te; te++; for(auto x:g[id]){ if(x.first == pre)continue; dep[x.first] = dep[id] + x.second; parent[0][x.first] = id; init(x.first,id); } out[id] = te; te++; } int main(){ cin.tie(0); ios::sync_with_stdio(false); int n,Q; cin >> n >> Q; g.resize(n); rep(i,n-1){ int a,b; ll c; cin >> a >> b >> c; a--;b--; g[a].push_back({b,c}); g[b].push_back({a,c}); } init(0,-1); for(int i=1;i<17;i++){ for(int j=0;j,int> > p; vector cand; cand.push_back(0); rep(tt,Q){ int type,V; ll T,L; cin >> type >> V >> T >> L; V--; if(type==0){ p.push_back({{T+dep[V],in[V]},1});cand.push_back(T+dep[V]); ll TT = T+dep[V]; for(int i=16;i>=0;i--){ int P = parent[i][V]; if(dep[V]-dep[P] <= L){ L -= dep[V]-dep[P]; V = P; } } if(V!=0){ p.push_back({{TT,in[parent[0][V]]},-1}); } }else{ p.push_back({{T+dep[V],V},0}); cand.push_back(T+dep[V]); } } sort(all(cand)); cand.erase(unique(all(cand)),cand.end()); UnorderedMap mp; for(int i=0;i<(int)cand.size();i++){ mp[cand[i]] = i; } BIT bit((int)cand.size(),2*n+2); for(auto&x:p){ if(x.second!=0){ // cerr <<"ADD:" << x.first.first << " " << mp[x.first.first] << " " << x.first.second << " " << x.second << endl; bit.add(mp[x.first.first],x.first.second,x.second); }else{ if(in[x.first.second]!=0){ cout << bit.sum(mp[x.first.first],out[x.first.second]) - bit.sum(mp[x.first.first],in[x.first.second]-1) << "\n"; // cerr << "Q: " << mp[x.first.first] << " " << out[x.first.second] << " " << mp[x.first.first] << " " << in[x.first.second]-1 << endl; }else{ cout << bit.sum(mp[x.first.first],out[x.first.second]) << "\n"; // cerr << "Q: " << mp[x.first.first] << " " << out[x.first.second] << endl; } } } return 0; }