#724444 (C++17) No.1787 Do Use Dynamic Tree

• 問題: No.1787 Do Use Dynamic Tree
• ユーザー: 👑 Nachia
• 提出日時: 2021-12-16 20:46:18
• 言語: C++17 (gcc 12.3.0 + boost 1.83.0)
• 結果: TLE
• 実行時間: -
• コード長: 9,485 bytes
• コンパイル時間: 2,037 ms
• コンパイル使用メモリ: 137,500 KB
• 実行使用メモリ: 52,476 KB
• 最終ジャッジ日時: 2024-09-13 18:47:37
• 合計ジャッジ時間: 21,150 ms
• ジャッジサーバーID （参考情報）: judge5 / judge4

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	2 ms; 5,248 KB
testcase_01	AC	2 ms; 5,376 KB
testcase_02	AC	2 ms; 5,376 KB
testcase_03	AC	2 ms; 5,376 KB
testcase_04	AC	2 ms; 5,376 KB
testcase_05	AC	2 ms; 5,376 KB
testcase_06	AC	2 ms; 5,376 KB
testcase_07	AC	2 ms; 5,376 KB
testcase_08	AC	2 ms; 5,376 KB
testcase_09	AC	2 ms; 5,376 KB
testcase_10	AC	2 ms; 5,376 KB
testcase_11	AC	2 ms; 5,376 KB
testcase_12	AC	4 ms; 5,376 KB
testcase_13	AC	4 ms; 5,376 KB
testcase_14	AC	5 ms; 5,376 KB
testcase_15	AC	4 ms; 5,376 KB
testcase_16	AC	4 ms; 5,376 KB
testcase_17	AC	4 ms; 5,376 KB
testcase_18	AC	4 ms; 5,376 KB
testcase_19	AC	4 ms; 5,376 KB
testcase_20	AC	4 ms; 5,376 KB
testcase_21	AC	4 ms; 5,376 KB
testcase_22	AC	826 ms; 34,276 KB
testcase_23	AC	792 ms; 49,196 KB
testcase_24	AC	651 ms; 30,132 KB
testcase_25	AC	1,250 ms; 52,476 KB
testcase_26	AC	1,214 ms; 52,352 KB
testcase_27	AC	1,178 ms; 52,316 KB
testcase_28	TLE	-
testcase_29	--	-
testcase_30	--	-
testcase_31	--	-
testcase_32	--	-
testcase_33	--	-
testcase_34	--	-
testcase_35	--	-
testcase_36	--	-
testcase_37	--	-
testcase_38	--	-
testcase_39	--	-

ソースコード

#include <atcoder/segtree>




#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;


struct heavy_light_decomposition{
private:

  int N;
  vector<int> P;
  vector<int> PP;
  vector<int> PD;
  vector<int> D;
  vector<int> I;

  vector<int> rangeL;
  vector<int> rangeR;

public:

  heavy_light_decomposition(const vector<vector<int>>& E = {{}}){
    N = E.size();
    P.assign(N, -1);
    I = {0};
    I.reserve(N);
    for(int i=0; i<I.size(); i++){
      int p = I[i];
      for(int e : E[p]) if(P[p] != e){
        I.push_back(e);
        P[e] = p;
      }
    }
    vector<int> Z(N, 1);
    vector<int> nx(N, -1);
    PP.resize(N);
    for(int i=0; i<N; i++) PP[i] = i;
    for(int i=N-1; i>=1; i--){
      int p = I[i];
      Z[P[p]] += Z[p];
      if(nx[P[p]] == -1) nx[P[p]] = p;
      if(Z[nx[P[p]]] < Z[p]) nx[P[p]] = p;
    }

    for(int p : I) if(nx[p] != -1) PP[nx[p]] = p;

    PD.assign(N,N);
    PD[0] = 0;
    D.assign(N,0);
    for(int p : I) if(p != 0){
      PP[p] = PP[PP[p]];
      PD[p] = min(PD[PP[p]], PD[P[p]]+1);
      D[p] = D[P[p]]+1;
    }
    
    rangeL.assign(N,0);
    rangeR.assign(N,0);
    vector<int> dfs;
    dfs.push_back(0);
    while(dfs.size()){
      int p = dfs.back();
      rangeR[p] = rangeL[p] + Z[p];
      int ir = rangeR[p];
      dfs.pop_back();
      for(int e : E[p]) if(P[p] != e) if(e != nx[p]){
        rangeL[e] = (ir -= Z[e]);
        dfs.push_back(e);
      }
      if(nx[p] != -1){
        rangeL[nx[p]] = rangeL[p] + 1;
        dfs.push_back(nx[p]);
      }
    }

    I.resize(N);
    for(int i=0; i<N; i++) I[rangeL[i]] = i;
  }

  int depth(int p) const {
    return D[p];
  }

  int lca(int u, int v) const {
    if(PD[u] < PD[v]) swap(u, v);
    while(PD[u] > PD[v]) u = P[PP[u]];
    while(PP[u] != PP[v]){ u = P[PP[u]]; v = P[PP[v]]; }
    return (D[u] > D[v]) ? v : u;
  }

  int dist(int u, int v) const {
    return depth(u) + depth(v) - depth(lca(u,v)) * 2;
  }

  vector<pair<int,int>> path(int r, int c, bool include_root = true, bool reverse_path = false) const {
    vector<pair<int,int>> res;
    while(PD[r] < PD[c]){
      res.push_back({ rangeL[PP[c]], rangeL[c]+1 });
      c = P[PP[c]];
    }
    if(PP[r] != PP[c]) return {};
    if(D[r] > D[c]) return {};
    res.push_back({ rangeL[r], rangeL[c]+1 });
    if(!include_root){
      res.back().first++;
      if(res.back().first == res.back().second) res.pop_back();
    }
    if(!reverse_path) reverse(res.begin(),res.end());
    return res;
  }

  const vector<int>& idxs() const {
    return rangeL;
  }
  const vector<int>& invidxs() const {
    return I;
  }

  int meet(int x, int y, int z) const {
    return lca(x,y) ^ lca(y,z) ^ lca(x,z);
  }

  int jump(int from, int to, int d) const {
    int g = lca(from,to);
    int dist0 = D[from] - D[g] * 2 + D[to];
    if(dist0 > d) return -1;
    int p = from;
    if(D[from] - D[g] > d){ p = to; d = dist0 - d; }
    while(D[p] - D[PP[p]] > d){
      d -= D[p] - D[PP[p]] + 1;
      p = P[PP[p]];
    }
    return I[rangeL[p] - d];
  }
  
  int heavy_path_child(int p){
    int ip = rangeL[p];
    if(ip == N-1) return -1;
    int cand = I[ip + 1];
    if(PP[cand] != PP[p]) return -1;
    return cand;
  }
  
  int parent(int p){ return P[p]; }
  
};




#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <utility>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)

namespace ruq {
    map<int,int> rq;
    void init(){
        rq[-1] = 0;
    }
    int query(int p){
        auto i = rq.upper_bound(p);
        i--;
        return i->second;
    }
    void apply(int l, int r, int updval){
        if(l >= r) return;
        int lastval = query(l);
        auto i = rq.lower_bound(l);
        while(true){
            if(i == rq.end()) break;
            if(r < i->first) break;
            lastval = i->second;
            i = rq.erase(i);
        }
        rq.insert(make_pair(l, updval));
        rq.insert(make_pair(r, lastval));
    }
}


int N;
vector<int> A;
vector<vector<int>> E;
heavy_light_decomposition hld;
vector<set<pair<int,int>, greater<pair<int,int>>>> children;
vector<int> maxchild;
vector<int> ismaxchild;

namespace all_is_good_query{
    using S = int;
    S op(S l, S r){ return l & r; }
    S e(){ return 1; }
    using rq = atcoder::segtree<S,op,e>;
    bool check(S x){ return x; }
}


all_is_good_query::rq isparentparentmax_rq;
all_is_good_query::rq ismaxchild_rq;

int is_parent_max(int p){
    if(p == 0) return 0;
    if(maxchild[p] < 0) return 1;
    return (A[hld.parent(p)] > A[maxchild[p]]) ? 1 : 0;
}

int is_parent_parent_max(int p){
    if(hld.depth(p) < 2) return 0;
    int pp = hld.parent(p);
    int ppp = hld.parent(pp);
    if(children[pp].size() <= 1) return 1;
    if(maxchild[pp] != p) return (A[ppp] > A[maxchild[pp]]) ? 1 : 0;
    auto i = children[pp].begin(); i++;
    return (A[ppp] > A[i->second]) ? 1 : 0;
}

int solve_parentmax(int x){
    if(x == 0) return x;
    if(is_parent_max(x) == 0) return x;
    while(is_parent_parent_max(x)) x = hld.parent(x);
    if(x != 0) x = hld.parent(x);
    return x;
}
/*
int solve_parentmax(int x){
    if(x == 0) return x;
    if(is_parent_max(x) == 0) return x;
    auto path = hld.path(0,x);
    while(!path.empty()){
        auto p = path.back();
        path.pop_back();
        int l = isparentparentmax_rq.min_left(p.second, all_is_good_query::check);
        l = min(max(l, p.first + 2), p.second);
        if(p.first + 2 < l){ return hld.invidxs()[l-2]; }
        while(l != p.first){
            l--;
            int pathp = hld.invidxs()[l];
            if(is_parent_parent_max(pathp)) continue;
            return hld.parent(hld.invidxs()[l]);
        }
    }
    return 0;
}
*/

int solve_maxchild(int x){
    auto path = hld.path(0,x);
    while(!path.empty()){
        auto p = path.back();
        path.pop_back();
        int l = ismaxchild_rq.min_left(p.second, all_is_good_query::check);
        if(p.first + 1 < l){ return hld.invidxs()[l-1]; }
        int pathp = hld.invidxs()[p.first];
        if(!ismaxchild[pathp]) return pathp;
    }
    return 0;
}
int solve_maxchild2(int c){
    while(ismaxchild[c]) c = hld.parent(c);
    return c;
}


vector<int> dp;

void set_A(int p, int a){
    int heavy_child = hld.heavy_path_child(p);
    int parent = hld.parent(p);
    int heavy_child2 = -1;
    if(heavy_child != -1) heavy_child2 = hld.heavy_path_child(heavy_child);
    
    if(parent != -1){
        children[parent].erase(make_pair(A[p], p));
    }
    
    A[p] = a;
    
    if(parent != -1){
        children[parent].insert(make_pair(A[p], p));
        ismaxchild[maxchild[parent]] = 0;
        ismaxchild_rq.set(hld.idxs()[maxchild[parent]], 0);
        maxchild[parent] = children[parent].begin() -> second;
        ismaxchild[maxchild[parent]] = 1;
        ismaxchild_rq.set(hld.idxs()[maxchild[parent]], 1);

        //int updv = ruq::query(hld.idxs()[maxchild[parent]]);
        int updv = dp[maxchild[parent]];
        int updr = solve_maxchild(parent);
        int c = parent;
        while(c != updr){ dp[c] = updv; c = hld.parent(c); }
        dp[c] = updv;
    }

    if(heavy_child2 != -1) isparentparentmax_rq.set(hld.idxs()[heavy_child2], is_parent_parent_max(heavy_child2));
    isparentparentmax_rq.set(hld.idxs()[p], is_parent_parent_max(p));
}


int query(int u, int v){
    int au = A[u];
    int av = A[v];
    set_A(u, av);
    set_A(v, au);
    int g = solve_parentmax(u);
    if(u != g){
        if(children[g].size() <= 1) return g;
        else if(hld.lca(u, maxchild[g]) == maxchild[g]){
            auto i = children[g].begin();
            i++;
            g = i -> second;
        }
    }
    // g = ruq::query(hld.idxs()[g]);
    g = dp[g];
    return g;
}


int main(void){
    cin >> N;
    A.resize(N);
    rep(i,N) A[i] = i;
    E.resize(N);
    rep(i,N-1){
        int u,v; cin >> u >> v; u--; v--;
        E[u].push_back(v);
        E[v].push_back(u);
    }
    
    hld = heavy_light_decomposition(E);
    E.clear();
    E.resize(N);
    children.resize(N);
    
    for(int i=1; i<N; i++){
        E[hld.parent(i)].push_back(i);
        children[hld.parent(i)].insert(make_pair(A[i],i));
    }
    
    maxchild.assign(N,-1);
    rep(i,N) if(!children[i].empty()) maxchild[i] = children[i].begin() -> second;
    ismaxchild.assign(N,0);
    for(int i=1; i<N; i++) ismaxchild[i] = (maxchild[hld.parent(i)] == i) ? 1 : 0;
    
    isparentparentmax_rq = all_is_good_query::rq(N);
    rep(i,N) isparentparentmax_rq.set(hld.idxs()[i], is_parent_parent_max(i));
    ismaxchild_rq = all_is_good_query::rq(N);
    rep(i,N) ismaxchild_rq.set(hld.idxs()[i], ismaxchild[i]);
    
    int prevans = 0;
    int Q; cin >> Q;

    ruq::init();

    {
        //vector<int> dp(N);
        dp.resize(N);
        rep(i,N) dp[i] = i;
        for(int i=N-1; i>=0; i--){
            int p = hld.invidxs()[i];
            if(children[p].empty()) continue;
            dp[p] = dp[maxchild[p]];
        }
        rep(p,N) ruq::rq[hld.idxs()[p]] = dp[p];
    }

    rep(queryid, Q){
        int u,v; cin >> u >> v;
        u = (u+N-1+prevans) % N + 1;
        v = (v+N-1+prevans) % N + 1;
        u--; v--;
        int ans = query(u,v) + 1;
        cout << ans << "\n";
        prevans = ans;
    }
    
    return 0;
} 
 
struct ios_do_not_sync{
    ios_do_not_sync(){
        ios::sync_with_stdio(false);
        cin.tie(nullptr);
    }
} ios_do_not_sync_instance;