結果

問題 No.1704 Many Bus Stops (easy)
ユーザー kohei2019kohei2019
提出日時 2023-06-04 20:04:02
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 577 ms / 2,000 ms
コード長 7,560 bytes
コンパイル時間 783 ms
コンパイル使用メモリ 86,744 KB
実行使用メモリ 82,740 KB
最終ジャッジ日時 2023-08-28 08:22:35
合計ジャッジ時間 20,438 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge12
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 94 ms
76,464 KB
testcase_01 AC 561 ms
82,212 KB
testcase_02 AC 286 ms
80,928 KB
testcase_03 AC 308 ms
80,668 KB
testcase_04 AC 276 ms
80,212 KB
testcase_05 AC 282 ms
80,812 KB
testcase_06 AC 308 ms
80,084 KB
testcase_07 AC 297 ms
80,388 KB
testcase_08 AC 290 ms
80,892 KB
testcase_09 AC 282 ms
81,616 KB
testcase_10 AC 299 ms
80,544 KB
testcase_11 AC 285 ms
80,328 KB
testcase_12 AC 280 ms
81,080 KB
testcase_13 AC 275 ms
80,948 KB
testcase_14 AC 284 ms
81,268 KB
testcase_15 AC 283 ms
79,776 KB
testcase_16 AC 279 ms
80,136 KB
testcase_17 AC 278 ms
79,984 KB
testcase_18 AC 284 ms
80,568 KB
testcase_19 AC 318 ms
80,216 KB
testcase_20 AC 286 ms
80,268 KB
testcase_21 AC 281 ms
80,360 KB
testcase_22 AC 556 ms
81,632 KB
testcase_23 AC 566 ms
81,624 KB
testcase_24 AC 557 ms
82,120 KB
testcase_25 AC 565 ms
81,584 KB
testcase_26 AC 557 ms
81,572 KB
testcase_27 AC 576 ms
81,956 KB
testcase_28 AC 560 ms
81,684 KB
testcase_29 AC 555 ms
81,868 KB
testcase_30 AC 569 ms
81,460 KB
testcase_31 AC 561 ms
82,136 KB
testcase_32 AC 569 ms
82,044 KB
testcase_33 AC 577 ms
81,448 KB
testcase_34 AC 564 ms
81,628 KB
testcase_35 AC 564 ms
81,440 KB
testcase_36 AC 561 ms
82,300 KB
testcase_37 AC 567 ms
82,040 KB
testcase_38 AC 561 ms
81,432 KB
testcase_39 AC 565 ms
81,652 KB
testcase_40 AC 565 ms
82,740 KB
testcase_41 AC 563 ms
81,360 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import copy
class matrix():
    def __init__(self):
        self.mod = 10**9+7

    def multiplication(self,arr1,arr2):
        '''
        例
        arr1
        2 3 4 5
        6 7 8 9
        arr2
        1 2
        3 4
        5 6
        7 8
        '''
        H = len(arr1)
        W = len(arr2[0])
        arr3 = [[0]*W for i in range(H)]
        for i in range(H):
            for j in range(W):
                val = 0
                for k in range(len(arr1[0])):
                    val += arr1[i][k]*arr2[k][j]
                arr3[i][j] = val
        return arr3
    
    def determinant(self,arr):
        '''
        正方行列N*Nの行列式
        計算量O(N**3)
        '''
        arr_calc = copy.deepcopy(arr)
        N = len(arr_calc)
        for i in range(N-1):
            d = arr_calc[i][i]
            for j in range(i+1,N):
                e = arr_calc[j][i]/d
                for k in range(i,N):
                    arr_calc[j][k] -= e*arr_calc[i][k]
        #arr_calc 上△行列
        det = 1
        for i in range(N):
            det *= arr_calc[i][i]
        return det
    
    def invarr(self,arr):
        '''
        正方行列N*Nの逆行列
        det == 0ならreturn False
        計算量O(N**3)
        ''' 
        arr_calc = copy.deepcopy(arr)
        if self.determinant(arr_calc) == 0:
            return False
        N = len(arr_calc)
        for i in range(N):
            v = [0]*(N)
            v[i] = 1
            arr_calc[i].extend(v)
        for i in range(N-1):
            d = arr_calc[i][i]
            for j in range(i+1,N):
                e = arr_calc[j][i]/d
                for k in range(i,2*N):
                    arr_calc[j][k] -= e*arr_calc[i][k]
        for i in range(N-1,-1,-1):
            d = arr_calc[i][i]
            for k in range(i,2*N):
                arr_calc[i][k] /= d
            for j in range(i-1,-1,-1):
                c = arr_calc[j][i]
                for k in range(i,2*N):
                    arr_calc[j][k] -= c*arr_calc[i][k]
        inv = [[0]*(N) for i in range(N)]
        for i in range(N):
            for j in range(N):
                inv[i][j] = arr_calc[i][j+N]
        return inv
    
    def SimultaneousE(self,arr):
        '''
        3x+2y+z = 4
        4x+5y+6z = 3
        7x+8y+9z = 2
        ->
        3 2 1 4
        4 5 6 3
        7 8 9 2
        '''
        N = len(arr)
        arr1 = [[0]*(N) for i in range(N)]
        for i in range(N):
            for j in range(N):
                arr1[i][j] = arr[i][j]
        v = [[0] for i in range(N)]
        for i in range(N):
            v[i][0] = arr[i][-1]
        if self.determinant(arr1) == 0:
            return False
        inva = self.invarr(arr1)
        return self.multiplication(inva,v)


    def invmod(self,a):#mod逆元
        if a == 0:
            return 0
        if a == 1:
            return 1
        return (-self.invmod(self.mod % a) * (self.mod // a)) % self.mod
    
    def multiplication_mod(self,arr1,arr2):
        H = len(arr1)
        W = len(arr2[0])
        arr3 = [[0]*W for i in range(H)]
        for i in range(H):
            for j in range(W):
                val = 0
                for k in range(len(arr1[0])):
                    val += arr1[i][k]*arr2[k][j]
                arr3[i][j] = val%self.mod
        return arr3

    def determinant_mod(self,arr):
        '''
        正方行列N*Nの行列式
        計算量O(N**3)
        '''
        arr_calc = copy.deepcopy(arr)
        N = len(arr_calc)
        for i in range(N-1):
            d = arr_calc[i][i]
            for j in range(i+1,N):
                e = arr_calc[j][i]*self.invmod(d)
                e %= self.mod
                for k in range(i,N):
                    arr_calc[j][k] -= e*arr_calc[i][k]
                    arr_calc[j][k] %= self.mod
        #arr_calc 上△行列
        det = 1
        for i in range(N):
            det *= arr_calc[i][i]
            det %= self.mod
        return det

    def invarr_mod(self,arr):
        '''
        正方行列N*Nの逆行列
        det == 0ならreturn False
        計算量O(N**3)
        '''
        arr_calc = copy.deepcopy(arr)
        det = self.determinant_mod(arr_calc)
        if det == 0:
            return False
        N = len(arr_calc)
        for i in range(N):
            v = [0]*(N)
            v[i] = det
            arr_calc[i].extend(v)
        for i in range(N-1):
            d = arr_calc[i][i]
            for j in range(i+1,N):
                e = arr_calc[j][i]*self.invmod(d)
                for k in range(i,2*N):
                    arr_calc[j][k] -= e*arr_calc[i][k]
                    arr_calc[j][k] %= self.mod
        for i in range(N-1,-1,-1):
            d = arr_calc[i][i]
            for k in range(i,2*N):
                arr_calc[i][k] *= self.invmod(d)
            for j in range(i-1,-1,-1):
                c = arr_calc[j][i]
                for k in range(i,2*N):
                    arr_calc[j][k] -= c*arr_calc[i][k]
                    arr_calc[j][k] %= self.mod
        inv = [[0]*(N) for i in range(N)]
        for i in range(N):
            for j in range(N):
                inv[i][j] = arr_calc[i][j+N]*self.invmod(det)%self.mod
        return inv
    
    def SimultaneousE_mod(self,arr):
        '''
        3x+2y+z = 4
        4x+5y+6z = 3
        7x+8y+9z = 2
        ->
        3 2 1 4
        4 5 6 3
        7 8 9 2
        '''
        N = len(arr)
        arr1 = [[0]*(N) for i in range(N)]
        for i in range(N):
            for j in range(N):
                arr1[i][j] = arr[i][j]
        v = [[0] for i in range(N)]
        for i in range(N):
            v[i][0] = arr[i][-1]
        det = self.determinant_mod(arr1)
        if det == 0:
            return False
        inva = self.invarr_mod(arr1)
        v2 = self.multiplication_mod(inva,v)
        for i in range(N):
            v2[i][0] %= self.mod
        return v2

    def modPow_matrix(self,arr,n):
        '''
        N*Nの正方行列arrをn乗する。
        '''
        N = len(arr)
        if n==0:
            arr1 = [[0]*(N) for i in range(N)]
            for i in range(N):
                arr1[i][i] = 1
            return arr1
        if n==1:
            for i in range(N):
                for j in range(N):
                    arr[i][j] %= self.mod
            return arr
        if n % 2 == 1:
            arr2 = self.multiplication_mod(arr,self.modPow_matrix(arr,n-1))
            return arr2
        arr3 = self.modPow_matrix(arr,n//2)
        return self.multiplication_mod(arr3,arr3)

    def Pow_matrix(self,arr,n):
        '''
        N*Nの正方行列arrをn乗する。
        '''
        N = len(arr)
        if n==0:
            arr1 = [[0]*(N) for i in range(N)]
            for i in range(N):
                arr1[i][i] = 1
            return arr1
        if n==1:
            return arr
        if n % 2 == 1:
            arr2 = self.multiplication(arr,self.Pow_matrix(arr,n-1))
            return arr2
        arr3 = self.Pow_matrix(arr,n//2)
        return self.multiplication(arr3,arr3)

T = int(input())
mod = 10**9+7
MX = matrix()
one_3 = MX.invmod(3)
two_3 = (2*MX.invmod(3))%mod
one_2 = MX.invmod(2)

arr = [[one_3,0,0,two_3,0,0],[0,one_3,0,0,two_3,0],[0,0,one_3,0,0,two_3],[0,one_2,one_2,0,0,0],[one_2,0,one_2,0,0,0],[one_2,one_2,0,0,0,0]]
ansls = []
for i in range(T):
    N = int(input())
    m = MX.modPow_matrix(arr, N)
    ans = MX.multiplication_mod(m,[[1],[0],[0],[0],[0],[0]])
    ansls.append(ans[0][0])
print(*ansls,sep='\n')
0