結果

問題 No.1778 括弧列クエリ / Bracketed Sequence Query
ユーザー ああいいああいい
提出日時 2022-02-26 11:39:17
言語 PyPy3
(7.3.15)
結果
WA  
実行時間 -
コード長 5,324 bytes
コンパイル時間 330 ms
コンパイル使用メモリ 82,176 KB
実行使用メモリ 148,924 KB
最終ジャッジ日時 2024-07-04 07:19:38
合計ジャッジ時間 20,511 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 WA -
testcase_01 WA -
testcase_02 WA -
testcase_03 WA -
testcase_04 WA -
testcase_05 WA -
testcase_06 WA -
testcase_07 AC 171 ms
85,248 KB
testcase_08 AC 795 ms
114,176 KB
testcase_09 AC 239 ms
90,240 KB
testcase_10 WA -
testcase_11 WA -
testcase_12 WA -
testcase_13 AC 820 ms
113,536 KB
testcase_14 AC 422 ms
102,272 KB
testcase_15 AC 38 ms
52,992 KB
testcase_16 WA -
testcase_17 AC 776 ms
115,072 KB
testcase_18 WA -
testcase_19 AC 801 ms
114,048 KB
testcase_20 WA -
testcase_21 AC 40 ms
52,864 KB
testcase_22 AC 38 ms
52,608 KB
testcase_23 WA -
testcase_24 WA -
testcase_25 WA -
testcase_26 WA -
testcase_27 AC 704 ms
143,440 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

N,Q = map(int,input().split())
S = input()
taiou = [0] * (N+1)
parent = [0] * (N+1)
stack = []
for i in range(N):
    if S[i] == "(":
        stack.append(i+1)
    else:
        x = stack.pop()
        taiou[x] = i+1
        taiou[i+1] = x
        if stack:
            p = stack[-1]
            parent[x] = p
            parent[i+1] = x
        else:
            parent[i+1] = x
G = [[] for _ in range(N+1)]
for i in range(1,N+1):
    p = parent[i]
    G[p].append(i)
    G[i].append(p)


#HL分解

class HL:

    #u,vを結ぶpathへのクエリはここにでも
    #  f は区間　[l,r)に対するクエリ
    def f(self,l,r):
        pass
    def merge(self,x,y):
        return x + y


    
    def __init__(self,G,root):
        self.G = G
        self.root = root
        self.N = len(G) 
        self.size = [1] * self.N     #部分木のサイズ
        self.p = [0] * self.N        #親頂点
        self.H = [None] * self.N     #Heavy_edgeでつながる子頂点。葉ではNoneが入ってる
        self._in = [-1] * self.N     #最初に探索したときの位置
        self.out = [-1] * self.N     #部分木をでるタイミング。オイラーとはちょっと違う。
                                     #開区間  [_in[i],out[i]) がiの部分木に対応
        self.pathtop = [0] * self.N  #iの属するpathの中で最も根に近い頂点。代表にする
        self.build()
        self.build_path()
    def build(self):
        stack = [(~self.root,-1),(self.root,-1)]
        G = self.G
        size = self.size
        H = self.H
        while stack:
            now,parent = stack.pop()
            if now < 0:
                now = ~now
                _max = 0
                for v in G[now]:
                    if v == parent:continue
                    size[now] += size[v]
                    if size[v] > _max:
                        _max = size[v]
                        H[now] = v
            else:
                for v in G[now]:
                    if v == parent:continue
                    self.p[v] = now
                    stack.append((~v,now))
                    stack.append((v,now))
    def build_path(self):
        stack = [(~self.root,-1,self.root),(self.root,-1,self.root)]
        count = 0
        G = self.G
        H = self.H
        while stack:
            now,parent,top = stack.pop()
            if now >= 0:
                self._in[now] = count
                count += 1
                self.pathtop[now] = top
                h = H[now]
                if h is None:continue
                for v in G[now]:
                    if v == parent or v == h:continue
                    stack.append((~v,now,v))
                    stack.append((v,now,v))
                stack.append((~h,now,top))
                stack.append((h,now,top))
            else:
                now = ~now
                self.out[now] = count
    def lca(self,a,b):
        #最近共通先祖
        pathtop = self.pathtop
        _in = self._in
        pa = pathtop[a]
        pb = pathtop[b]
        while pa != pb:
            if _in[pa] > _in[pb]:
                a = self.p[pa]
                pa = pathtop[a]
            else:
                b = self.p[pb]
                pb = pathtop[b]
        return a if _in[a] < _in[b] else b
    def subtree_query(self,a,f = None):
        #if f is None:f = self.f
        return f(self._in[a],self.out[a])
    def subtree_array(self,a):
        return (self._in[a],self.out[a])
        #下のpath_arrayとほぼ同じ。タプルを一つだけ返す

    #f = lambda l,r:seg.fold(l,r)  とか
    #f = lambda l,r:seg.oparete_range(l,r,x)　とか
    #代入して使う
    def path_query(self,a,b,f = None,merge = None):
        #if f is None:f = self.f
        #if merge is None:merge = self.merge
        pathtop = self.pathtop
        p = self.p
        _in = self._in
        pa = pathtop[a]
        pb = pathtop[b]
        ans = 0
        while pa != pb:
            if _in[pa] > _in[pb]:
                ans = merge(ans,f(_in[pa],_in[a]+1))
                a = p[pa]
                pa = pathtop[a]
            else:
                ans = merge(ans,f(_in[pb],_in[b]+1))
                b = p[pb]
                pb = pathtop[b]
        if _in[a] > _in[b]:
            a,b = b,a
        ans = merge(ans,f(_in[a],_in[b]+1))
        return ans
    
    def path_array(self,a,b):
        # a,b を結ぶpath、を分割した配列を返す。こっちのほうが便利かも
        #半開区間 [l,r) の集まりを返す
        #現状順番は適当
        #こっちのほうが早かった
        pathtop = self.pathtop
        p = self.p
        _in = self._in
        ans = []
        pa = pathtop[a]
        pb = pathtop[b]
        while pa != pb:
            if _in[pa] > _in[pb]:
                ans.append((_in[pa],_in[a]+1))
                a = p[pa]
                pa = pathtop[a]
            else:
                ans.append((_in[pb],_in[b]+1))
                b = p[pb]
                pb = pathtop[b]
        if _in[a] > _in[b]:
            a,b = b,a
        ans.append((_in[a],_in[b]+1))
        return ans

hl = HL(G,0)
for _ in range(Q):
    x,y = map(int,input().split())
    ans = hl.lca(x,y)
    if ans == 0:
        print(-1)
    else:
        print(ans,taiou[ans])
0