結果

問題 No.650 行列木クエリ
ユーザー ああいいああいい
提出日時 2022-02-25 16:53:01
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 670 ms / 2,000 ms
コード長 7,060 bytes
コンパイル時間 1,583 ms
コンパイル使用メモリ 86,764 KB
実行使用メモリ 127,732 KB
最終ジャッジ日時 2023-09-16 10:17:47
合計ジャッジ時間 4,883 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 74 ms
71,196 KB
testcase_01 AC 412 ms
95,112 KB
testcase_02 AC 585 ms
125,628 KB
testcase_03 AC 71 ms
71,560 KB
testcase_04 AC 408 ms
95,712 KB
testcase_05 AC 670 ms
127,732 KB
testcase_06 AC 74 ms
71,364 KB
testcase_07 AC 72 ms
71,624 KB
testcase_08 AC 300 ms
93,072 KB
testcase_09 AC 443 ms
126,160 KB
testcase_10 AC 71 ms
71,396 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

P = 10 ** 9 + 7

class SegTree:
    #単位元と結合演算はここ変える
    #いろんな種類のsegは作れないかも
    #→changeで変えれる
    
    unit = (1,0,0,1)
    def f(self,x,y):
        a,b,c,d = x
        e,f,g,h = y
        i = a * e + b * g
        j = a * f + b * h
        k = c * e + d * g
        l = c * f + d * h
        return (i%P,j%P,k%P,l%P)

    #頂点は1-index、一番下の段は0-index(bitは1-index)
    def __init__(self,N):
        self.N = N
        self.X = [self.unit] * (N + N)
    def build(self,seq):
        for i,x in enumerate(seq,self.N):
            self.X[i] = x
        for i in range(self.N-1,0,-1):
            self.X[i] = self.f(self.X[i << 1],self.X[i << 1 | 1])
    def set(self,i,x):
        i += self.N
        self.X[i] = x
        while i > 1:
            i >>= 1
            self.X[i] = self.f(self.X[i << 1],self.X[i << 1 | 1])
    def fold(self,L,R):
        #区間[L,R)についてfold
        #0 <= L,R <= N にしなきゃダメ
        L += self.N
        R += self.N
        vL = self.unit
        vR = self.unit
        while L < R:
            if L & 1:
                vL = self.f(vL,self.X[L])
                L += 1
            if R & 1:
                R -= 1
                vR = self.f(self.X[R],vR)
            L >>= 1
            R >>= 1
        return self.f(vL,vR)
    def change(self,f,unit):
        self.f = f
        self.unit = unit


#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


import sys
rr = sys.stdin

def seki(x,y):
    a,b,c,d = x
    e,f,g,h = y
    i = a * e + b * g
    j = a * f + b * h
    k = c * e + d * g
    l = c * f + d * h
    return (i%P,j%P,k%P,l%P)
n = int(rr.readline())
G = [[] for _ in range(n)]
edge = []
taiou = []
for _ in range(n-1):
    a,b = map(int,rr.readline().split())
    G[a].append(b)
    G[b].append(a)
    edge.append((a,b))
    
hl = HL(G,0)
seg = SegTree(n)
seg.build([(1,0,0,1)] * n)
for a,b in edge:
    if hl.p[a] == b:
        taiou.append(a)
    else:
        taiou.append(b)
q = int(rr.readline())
for _ in range(q):
    s,*t = rr.readline().split()
    t = list(map(int,t))
    if s == "x":
        i,a,b,c,d = t
        seg.set(hl._in[taiou[i]],(a,b,c,d))
    else:
        i,j = t
        L = hl.path_array(i,j)
        u,v = L.pop()
        ans = (1,0,0,1)
        for l,r in L:
            ans = seki(seg.fold(l,r),ans)
        ans = seki(seg.fold(u+1,v),ans)
        print(*ans)
0