結果

問題 No.2443 特殊線形群の標準表現
ユーザー MasKoaTSMasKoaTS
提出日時 2023-08-12 15:17:53
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 1,424 ms / 3,000 ms
コード長 3,614 bytes
コンパイル時間 584 ms
コンパイル使用メモリ 82,648 KB
実行使用メモリ 157,480 KB
最終ジャッジ日時 2024-11-20 01:07:45
合計ジャッジ時間 11,109 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 36 ms
51,968 KB
testcase_01 AC 36 ms
52,224 KB
testcase_02 AC 35 ms
52,864 KB
testcase_03 AC 36 ms
52,352 KB
testcase_04 AC 34 ms
52,480 KB
testcase_05 AC 36 ms
52,864 KB
testcase_06 AC 34 ms
52,992 KB
testcase_07 AC 36 ms
52,992 KB
testcase_08 AC 35 ms
52,352 KB
testcase_09 AC 35 ms
52,352 KB
testcase_10 AC 34 ms
52,352 KB
testcase_11 AC 34 ms
52,736 KB
testcase_12 AC 49 ms
65,408 KB
testcase_13 AC 117 ms
77,952 KB
testcase_14 AC 272 ms
87,020 KB
testcase_15 AC 1,399 ms
157,480 KB
testcase_16 AC 1,422 ms
157,100 KB
testcase_17 AC 1,408 ms
157,092 KB
testcase_18 AC 1,415 ms
157,236 KB
testcase_19 AC 1,424 ms
156,844 KB
testcase_20 AC 645 ms
153,048 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
input = sys.stdin.readline


"""  SegmentTree

ref : https://algo-logic.info/segment-tree/
"""

def segfunc(A, B):
    ret = [[0, 0], [0, 0]]
    for i in range(2):
        for j in range(2):
            for k in range(2):
                ret[i][j] += B[i][k] * A[k][j]
                ret[i][j] %= b
    return ret


def idefunc():
    """  単位元の例

    min: INF
    max: -INF
    XOR: 0
    区間和: 0
    区間積: 1
    GCD: 0
    """
    return [[1, 0], [0, 1]]
 

class SegmentTree:
    """  セグメント木（非可換な演算を考慮）

    セグ木に乗せる代数的構造(R,*)はモノイドである必要がある。すなわち、集合Rとその上の二項演算*が
    ・結合律 : 任意の a,b,c∈R に対して (a * b) * c = a * (b * c) が成り立つ。
    ・単位元の存在 : ある e∈R が存在し、任意の x∈R に対して e * x = x * e = x が成り立つ。
    を満たさなければならない。

    init(init_val, idefunc): 単位元の関数をidefuncとして配列init_valで初期化 O(N)
    update(k, x): k番目の値をxに更新 O(logN)
    query(l, r): 区間[l, r)を順方向にsegfuncしたものを返す O(logN)
    """
    def __init__(self, init_val, segfunc, idefunc):
        """  コンストラクタ

        init_val: 配列の初期値
        segfunc: 区間で作用させる二項演算の関数
        idefunc: 単位元の関数
        n: 要素数

        num: n以上の最小の2のべき乗
        tree: セグメント木(1-based)
        """
        n = len(init_val)
        self.segfunc = segfunc
        self.idefunc = idefunc
        self.num = 1 << (n - 1).bit_length()
        self.tree = [idefunc()] * (self.num << 1)
        # 配列の値を葉にセット
        for i in range(n):
            self.tree[self.num + i] = init_val[i]
        # 完全二分木を構築
        for i in range(self.num - 1, 0, -1):
            self.tree[i] = self.segfunc(self.tree[i << 1], self.tree[(i << 1) | 1])

    def update(self, k, x):
        """  k番目の値をxに更新

        k: 更新位置(0-based)
        x: 更新値
        """
        k += self.num
        self.tree[k] = x
        while(k > 1):
            self.tree[k >> 1] = self.segfunc(self.tree[k ^ (k & 1)], self.tree[k ^ ~(k & 1)])
            k >>= 1

    def query(self, l, r):
        """  [l, r)についてsegfuncしたものを得る

        l: 区間左端(0-based)
        r: 区間右端(0-based); r自身は含まない
        """
        ret = self.idefunc()

        l += self.num
        r += self.num
        left_trees = []
        right_trees = []
        while(l < r):
            if(l & 1):
                left_trees.append(self.tree[l])
                l += 1
            if(r & 1):
                right_trees.append(self.tree[r - 1])
            l >>= 1
            r >>= 1
        left_trees.reverse()
        while(left_trees):
            ret = self.segfunc(ret, left_trees.pop())
        while(right_trees):
            ret = self.segfunc(ret, right_trees.pop())
        return ret
 
 
"""
Main Code
"""

n, b, q = map(int, input().split())
As = [[list(map(int, input().split())) for _ in [0] * 2] for _ in [0] * n]
query = [list(map(int, input().split())) for _ in [0] * q]

seg = SegmentTree(As, segfunc, idefunc)

def prod_vector(A, vec):
    ret = [0, 0]
    for i in range(2):
        for j in range(2):
            ret[i] += A[i][j] * vec[j]
            ret[i] %= b
    return ret

for l, r, x, y in query:
    vec = [x, y]
    ans = prod_vector(seg.query(l, r), vec)
    print(*ans)
0