#1148112 (C++17) No.3467 Bracket Warp

• 問題: No.3467 Bracket Warp
• ユーザー: dyktr_06
• 提出日時: 2026-02-13 01:44:58
• 言語: C++17 (gcc 15.2.0 + boost 1.89.0)
• 結果: AC
• 実行時間: 214 ms / 2,000 ms
• コード長: 13,983 bytes
• コンパイル時間: 3,186 ms
• コンパイル使用メモリ: 247,980 KB
• 実行使用メモリ: 26,300 KB
• 最終ジャッジ日時: 2026-02-28 13:06:59
• 合計ジャッジ時間: 10,660 ms
• ジャッジサーバーID （参考情報）: judge5 / judge7

ファイルパターン	結果
sample	AC * 2
other	AC * 25

ソースコード

#include <bits/stdc++.h>

using namespace std;

#define overload4(_1, _2, _3, _4, name, ...) name
#define rep1(n) for(int i = 0; i < (int)(n); ++i)
#define rep2(i, n) for(int i = 0; i < (int)(n); ++i)
#define rep3(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep4(i, a, b, c) for(int i = (a); i < (int)(b); i += (c))
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)

#define rrep(i,n) for(int i = (int)(n) - 1; i >= 0; --i)
#define ALL(a) (a).begin(), (a).end()
#define Sort(a) (sort((a).begin(), (a).end()))
#define RSort(a) (sort((a).rbegin(), (a).rend()))
#define UNIQUE(a) (a.erase(unique((a).begin(), (a).end()), (a).end()))

using i64 = int64_t;
using i128 = __int128_t;

using ll = long long;
using ul = unsigned long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vll = vector<long long>;
using vull = vector<unsigned long long>;
using vc = vector<char>;
using vst = vector<string>;
using vd = vector<double>;
using vld = vector<long double>;
using P = pair<long long, long long>;

template<class T> long long sum(const T &a){ return accumulate(a.begin(), a.end(), 0LL); }
template<class T> auto min(const T &a){ return *min_element(a.begin(), a.end()); }
template<class T> auto max(const T &a){ return *max_element(a.begin(), a.end()); }

const long long MINF = 0x7fffffffffff;
const long long INF = 0x1fffffffffffffff;
const long long MOD = 998244353;
const long double EPS = 1e-9;
const long double PI = acos(-1);

template<class T> inline bool chmax(T &a, T b) { if(a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if(a > b) { a = b; return 1; } return 0; }

template<typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p){ is >> p.first >> p.second; return is; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p){ os << "(" << p.first << ", " << p.second << ")"; return os; }
template<typename T> istream &operator>>(istream &is, vector<T> &v){ for(T &in : v) is >> in; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &v){ for(int i = 0; i < (int) v.size(); ++i){ os << v[i] << (i + 1 != (int) v.size() ? " " : ""); } return os; }
template <typename T, typename S> ostream &operator<<(ostream &os, const map<T, S> &mp){ for(auto &[key, val] : mp){ os << key << ":" << val << " "; } return os; }
template <typename T> ostream &operator<<(ostream &os, const set<T> &st){ auto itr = st.begin(); for(int i = 0; i < (int) st.size(); ++i){ os << *itr << (i + 1 != (int) st.size() ? " " : ""); itr++; } return os; }
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &st){ auto itr = st.begin(); for(int i = 0; i < (int) st.size(); ++i){ os << *itr << (i + 1 != (int) st.size() ? " " : ""); itr++; } return os; }
template <typename T> ostream &operator<<(ostream &os, queue<T> q){ while(q.size()){ os << q.front() << " "; q.pop(); } return os; }
template <typename T> ostream &operator<<(ostream &os, deque<T> q){ while(q.size()){ os << q.front() << " "; q.pop_front(); } return os; }
template <typename T> ostream &operator<<(ostream &os, stack<T> st){ while(st.size()){ os << st.top() << " "; st.pop(); } return os; }
template <class T, class Container, class Compare> ostream &operator<<(ostream &os, priority_queue<T, Container, Compare> pq){ while(pq.size()){ os << pq.top() << " "; pq.pop(); } return os; }

template<class T, class U>
void inGraph(vector<vector<T>> &G, U n, U m, bool directed = true, bool zero_index = true){
    G.resize(n);
    for(int i = 0; i < m; i++){
        int a, b;
        cin >> a >> b;
        if(!zero_index) a--, b--;
        G[a].push_back(b);
        if(!directed) G[b].push_back(a);
    }
}

template <typename T>
long long binary_search(long long ok, long long ng, T check){
    while(abs(ok - ng) > 1){
        long long mid = (ok + ng) / 2;
        if(check(mid)) ok = mid;
        else ng = mid;
    }
    return ok;
}

template <typename T>
long double binary_search_real(long double ok, long double ng, T check, int iter = 100){
    for(int i = 0; i < iter; ++i){
        long double mid = (ok + ng) / 2;
        if(check(mid)) ok = mid;
        else ng = mid;
    }
    return ok;
}

long long trisum(long long a, long long b){
    if(a > b) return 0;
    long long res = ((b - a + 1) * (a + b)) / 2;
    return res;
}

template <typename T>
T intpow(T x, int n){
    T ret = 1;
    while(n > 0) {
        if(n & 1) (ret *= x);
        (x *= x);
        n >>= 1;
    }
    return ret;
}

template <typename T>
T getDivision(T a, T b){
    if(b == 0) return -1;
    if(a >= 0 && b > 0){
        return a / b;
    } else if(a < 0 && b > 0){
        return a / b - (a % b != 0);
    } else if(a >= 0 && b < 0){
        return a / b;
    } else{
        return a / b + (a % b != 0);
    }
}

template <typename T>
T getReminder(T a, T b){
    if(b == 0) return -1;
    if(a >= 0 && b > 0){
        return a % b;
    } else if(a < 0 && b > 0){
        return ((a % b) + b) % b;
    } else if(a >= 0 && b < 0){
        return a % b;
    } else{
        return (abs(b) - abs(a % b)) % b;
    }
}

template<class T, class U> inline T vin(T &vec, U n) { vec.resize(n); for(int i = 0; i < (int) n; ++i) cin >> vec[i]; return vec; }
template<class T> inline void vout(T vec, string s = "\n"){ for(auto x : vec) cout << x << s; }
template<class... T> void in(T&... a){ (cin >> ... >> a); }
void out(){ cout << '\n'; }
template<class T, class... Ts> void out(const T &a, const Ts&... b){ cout << a; ((cout << ' ' << b), ...); cout << '\n'; }
void fout(){ cout << endl; }
template<class T, class... Ts> void fout(const T &a, const Ts&... b){ cout << a; ((cout << ' ' << b), ...); cout << endl; }
void debug(){ cerr << '\n'; }
template<class T, class... Ts> void debug(const T &a, const Ts&... b){ cerr << a; ((cout << ' ' << b), ...); cerr << '\n'; }

class HeavyLightDecomposition{
protected:
    int V;
    vector<vector<int>> G;
    vector<int> stsize, parent, pathtop, depth, in, reverse_in, out;
    int root;

private:
    // Subtree Size
    void buildStsize(int curr, int prev){
        stsize[curr] = 1, parent[curr] = prev;
        for(int &v : G[curr]){
            if(v == prev){
                if(v == G[curr].back()) break;
                else swap(v, G[curr].back());
            }
            buildStsize(v, curr);
            stsize[curr] += stsize[v];
            if(stsize[v] > stsize[G[curr][0]]){
                swap(v, G[curr][0]);
            }
        }
    }

    void buildPath(int curr, int prev, int &t){
        in[curr] = t++;
        reverse_in[in[curr]] = curr;
        for(int v : G[curr]){
            if(v == prev) continue;

            if(v == G[curr][0]){
                pathtop[v] = pathtop[curr];
            } else{
                pathtop[v] = v;
            }
            depth[v] = depth[curr] + 1;
            buildPath(v, curr, t);
        }
        out[curr] = t;
    }

public:
    HeavyLightDecomposition(int node_size) : V(node_size), G(V), stsize(V, 0), parent(V, -1),
        pathtop(V, -1), depth(V, 0), in(V, -1), reverse_in(V, -1), out(V, -1){}

    void add_edge(int u, int v){
        G[u].push_back(v);
        G[v].push_back(u);
    }

    void build(int _root = 0){
        root = _root;
        int t = 0;
        buildStsize(root, -1);
        pathtop[root] = root;
        buildPath(root, -1, t);
    }

    inline int get(int a){
        return in[a];
    }

    int la(int a, int k) {
        while(true){
            int u = pathtop[a];
            if(in[a] - k >= in[u]) return reverse_in[in[a] - k];
            k -= in[a] - in[u] + 1;
            a = parent[u];
        }
    }

    int lca(int a, int b){
        int pa = pathtop[a], pb = pathtop[b];
        while(pathtop[a] != pathtop[b]){
            if(in[pa] > in[pb]){
                a = parent[pa], pa = pathtop[a];
            } else{
                b = parent[pb], pb = pathtop[b];
            }
        }
        if(in[a] > in[b]) swap(a, b);
        return a;
    }

    int dist(int a, int b){ return depth[a] + depth[b] - 2 * depth[lca(a, b)]; }

    int jump(int from, int to, int k) {
        if(!k) return from;
        int l = lca(from, to);
        int d = dist(from, to);
        if(d < k) return -1;
        if(depth[from] - depth[l] >= k) return la(from, k);
        k -= depth[from] - depth[l];
        return la(to, depth[to] - depth[l] - k);
    }

    void subtree_query(int a, const function<void(int, int)> &func){
        func(in[a], out[a]);
    }

    void path_query(int a, int b, const function<void(int, int)> &func, bool include_root = true, bool reverse_path = false){
        vector<pair<int, int>> path;
        int pa = pathtop[a], pb = pathtop[b];
        while(pathtop[a] != pathtop[b]){
            if(in[pa] > in[pb]){
                path.emplace_back(in[pa], in[a] + 1);
                a = parent[pa], pa = pathtop[a];
            } else{
                path.emplace_back(in[pb], in[b] + 1);
                b = parent[pb], pb = pathtop[b];
            }
        }
        if(in[a] > in[b]) swap(a, b);

        if(include_root) path.emplace_back(in[a], in[b] + 1);
        else path.emplace_back(in[a] + 1, in[b] + 1);

        if(!reverse_path) reverse(path.begin(), path.end());
        else for(auto &p : path) p = make_pair(V - p.second, V - p.first);

        for(auto [u, v] : path){
            func(u, v);
        }
    }

    void path_noncommutative_query(int a, int b, const function<void(int, int)> &func, const function<void(int, int)> &func2){
        int l = lca(a, b);
        path_query(a, l, func2, false, true);
        path_query(l, b, func, true, false);
    }
};

ll T;

void input(){
    in(T);
}

bool parentheses_check(string &s){
    ll cs = 0;
    for(auto c : s){
        if(c == '('){
            cs++;
        }else{
            if(cs == 0){
                return false;
            }
            cs--;
        }
    }
    return cs == 0;
}

template <typename T>
void warshall_floyd(vector<vector<T>> &d, const T &INF) {
    int n = d.size();
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            for(int k = 0; k < n; k++){
                if(d[j][i] == INF || d[i][k] == INF) continue;
                d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
            }
        }
    }
}

vll naive(const string &s, ll q, const vector<P> query){
    ll n = s.size();
    vector<vll> dist(n, vll(n, INF));
    
    vll st;
    rep(i, n){
        if(s[i] == '('){
            st.push_back(i);
        }else{
            ll b = st.back();
            st.pop_back();
            dist[i][b] = dist[b][i] = 0;
        }
    }

    rep(i, n - 1){
        chmin(dist[i][i + 1], 1LL);
        chmin(dist[i + 1][i], 1LL);
    }

    warshall_floyd(dist, INF);

    vll ans;
    for(auto [l, r] : query){
        l--, r--;
        ans.push_back(dist[l][r]);
    }
    return ans;
}

vll main_solve(const string &s, ll q, const vector<P> &query){
    ll n = s.size();

    vector<P> e;
    vll id(n + 1, -1);
    id[n] = 0;
    vll st = {n};
    ll v = 1;
    rep(i, n){
        if(s[i] == '('){
            id[i] = v++;
            ll b = st.back();
            e.emplace_back(id[b], id[i]);
            st.push_back(i);
        }else{
            ll b = st.back();
            st.pop_back();
            id[i] = id[b];
        }
    }

    HeavyLightDecomposition hld(v);
    vector<vll> G(v);
    for(auto [a, b] : e){
        G[a].push_back(b);
        hld.add_edge(a, b);
    }

    hld.build(0);

    vll depth(v);
    auto dfs = [&](auto &self, ll cur) -> void {
        ll deg = G[cur].size();
        rep(i, deg){
            ll nxt = G[cur][i];
            // 実際には頂点 0 には行けないのでコストは INF
            if(cur == 0) depth[nxt] = depth[cur] + n * 2;
            else depth[nxt] = depth[cur] + min(1LL + i, deg - i);
            self(self, nxt);
        }
    };
    dfs(dfs, 0);
    auto dist = [&](ll a, ll b){
        return depth[a] + depth[b] - 2 * depth[hld.lca(a, b)];
    };

    vll ans;
    for(auto [l, r] : query){
        l--, r--;
        ll lca = hld.lca(id[l], id[r]);
        ll res = -1;
        if(lca == id[l] || lca == id[r]){
            res = dist(id[l], id[r]);
        }else{
            // 一つ上の階層を経由する場合
            ll res1 = dist(lca, id[l]) + dist(lca, id[r]);
            ll u = hld.jump(lca, id[l], 1);
            ll v = hld.jump(lca, id[r], 1);

            // 同じ階層の場合
            ll res2 = dist(u, id[l]) + dist(v, id[r]);
            if(u > v) swap(u, v);
            res2 += lower_bound(ALL(G[lca]), v) - lower_bound(ALL(G[lca]), u);
            res = min(res1, res2);
        }
        ans.push_back(res);
    }
    return ans;
}

void solve(){
    string s; in(s);
    ll q; in(q);
    vector<P> query(q); in(query);
    vout(main_solve(s, q, query));
}

void random_test(){
    rep(n, 2, 22, 2){
        rep(bit, 1 << n){
            string s = "";
            rep(i, n){
                if(bit & (1 << i)) s += '(';
                else s += ')';
            }

            if(!parentheses_check(s)) continue;
            vector<P> query;
            rep(i, n){
                rep(j, i + 1, n){
                    query.emplace_back(i + 1, j + 1);
                }
            }

            ll q = query.size();
            vll ans1 = naive(s, q, query);
            vll ans2 = main_solve(s, q, query);
            if(ans1 != ans2){
                out(s);
                rep(i, q){
                    if(ans1[i] != ans2[i]){
                        out("WA", query[i].first, query[i].second, ans1[i], ans2[i]);
                    }
                }
            }
        }
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(20);

    // random_test();

    T = 1;
    // input();
    while(T--) solve();
}