結果

問題 No.2443 特殊線形群の標準表現
ユーザー MasKoaTSMasKoaTS
提出日時 2023-08-11 21:49:42
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 609 ms / 3,000 ms
コード長 4,115 bytes
コンパイル時間 673 ms
コンパイル使用メモリ 82,048 KB
実行使用メモリ 168,480 KB
最終ジャッジ日時 2024-11-18 15:54:45
合計ジャッジ時間 7,496 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 35 ms
52,096 KB
testcase_01 AC 35 ms
52,224 KB
testcase_02 AC 35 ms
52,736 KB
testcase_03 AC 36 ms
52,352 KB
testcase_04 AC 36 ms
52,480 KB
testcase_05 AC 36 ms
52,480 KB
testcase_06 AC 35 ms
52,736 KB
testcase_07 AC 35 ms
52,480 KB
testcase_08 AC 36 ms
52,480 KB
testcase_09 AC 36 ms
52,224 KB
testcase_10 AC 35 ms
52,096 KB
testcase_11 AC 36 ms
52,480 KB
testcase_12 AC 47 ms
62,464 KB
testcase_13 AC 97 ms
77,184 KB
testcase_14 AC 162 ms
86,400 KB
testcase_15 AC 609 ms
168,212 KB
testcase_16 AC 591 ms
167,572 KB
testcase_17 AC 608 ms
167,692 KB
testcase_18 AC 598 ms
167,440 KB
testcase_19 AC 607 ms
167,564 KB
testcase_20 AC 540 ms
168,480 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
input = sys.stdin.readline

"""  累積リスト（累積和の一般化）
"""

class CumulativeList:
    """  一次元累積リスト

    累積リストに乗せる代数的構造(R,*)における集合Rとその上の二項演算*が満たす性質として、
    1. 結合律 : 任意の a,b,c∈R に対して (a * b) * c = a * (b * c) が成り立つ。
    2. 単位元の存在 : ある e∈R が存在し、任意の x∈R に対して e * x = x * e = x が成り立つ。
    3. 逆元の存在 : 任意の x∈R に対してある y∈R が存在し、x * y = y * x = e が成り立つ（eは単位元）。
    が考えられる。
    ・left_queryはいずれの条件も不要。
    ・right_queryは条件1.が必要（半群）。
    ・queryは条件1.2.3.がすべて必要（群）。

    init(a, cumfunc, idefunc, invfunc): 配列aで初期化して二項演算の関数cumfuncによる順累積と逆累積を構成 O(N)
    left_query(r): 区間[0, r)を順方向にcumfuncしたものを返す O(1)
    right_query(l): 区間[l, n)を順方向にcumfuncしたものを返す O(1)
    query(l, r): 区間[l, r)を順方向にcumfuncしたものを返す O(1)
    """
    def __init__(self, a, cumfunc, idefunc = None, invfunc = None):
        """  コンストラクタ

        a: 対象とする配列
        cumfunc: 区間で作用させる二項演算の関数
        invfunc: 逆元の関数
        
        n: 要素数
        ac: 順累積[0,r)
        rev_ac: 逆累積[l,n)
        """
        self.n = len(a)
        self.a = a
        self.cumfunc = cumfunc
        self.idefunc = idefunc
        self.invfunc = invfunc
        self.ac = [0] * self.n
        self.rev_ac = [0] * self.n
        self._build()

    def _build(self):
        """  順累積・逆累積を構成

        順累積[0,r): a[0]*a[1]*...*a[r-1]
        逆累積[l,n): a[l]*a[l+1]*...*a[n-1]（※結合律が必要）
        """
        # 順方向に累積
        self.ac[0] = self.a[0]
        for i in range(1, self.n):
            self.ac[i] = self.cumfunc(self.ac[i - 1], self.a[i])
        # 逆方向に累積
        self.rev_ac[self.n - 1] = self.a[self.n - 1]
        for i in range(self.n - 2, -1, -1):
            self.rev_ac[i] = self.cumfunc(self.a[i], self.rev_ac[i + 1])

    def left_query(self, r):
        """  順累積[0,r): a[0]*a[1]*...*a[r-1]を得る

        Note: オブジェクトの参照が返るため、取り扱いに注意。
        """
        return self.ac[r - 1]
    
    def right_query(self, l):
        """  逆累積[l,n): a[l]*a[l+1]*...*a[n-1]を得る

        Note: 結合律が必要。オブジェクトの参照が返るため、取り扱いに注意。
        """
        return self.rev_ac[l]
    
    def query(self, l, r):
        """  部分累積[l,r): a[l]*a[l+1]*...*a[r-1]を得る

        Note: 結合律、単位元、逆元が必要。l==r ならば単位元が返る。
        """
        if(l == r):
            return self.idefunc()
        inv = self.invfunc(self.ac[l - 1]) if(l > 0) else self.idefunc()
        return self.cumfunc(inv, self.ac[r - 1])
 
 
"""
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]

def prod_matrix(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 ide_matrix():
    ret = [[1, 0], [0, 1]]
    return ret

def inv_matrix(A):
    # det = A[0][0] * A[1][1] - A[0][1] * A[1][0] = 1
    return [[A[1][1], -A[0][1]], [-A[1][0], A[0][0]]]

cum = CumulativeList(As, prod_matrix, ide_matrix, inv_matrix)

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]
    A = cum.query(l, r)
    ans = prod_vector(A, vec)
    print(*ans)
0