結果

問題 No.1704 Many Bus Stops (easy)
ユーザー kohei2019kohei2019
提出日時 2023-06-04 20:04:02
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 469 ms / 2,000 ms
コード長 7,560 bytes
コンパイル時間 144 ms
コンパイル使用メモリ 82,708 KB
実行使用メモリ 80,012 KB
最終ジャッジ日時 2024-06-09 04:02:12
合計ジャッジ時間 14,850 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 42 ms
63,488 KB
testcase_01 AC 435 ms
78,848 KB
testcase_02 AC 208 ms
77,732 KB
testcase_03 AC 221 ms
78,420 KB
testcase_04 AC 201 ms
77,568 KB
testcase_05 AC 210 ms
77,696 KB
testcase_06 AC 231 ms
78,968 KB
testcase_07 AC 216 ms
77,952 KB
testcase_08 AC 204 ms
77,956 KB
testcase_09 AC 205 ms
77,564 KB
testcase_10 AC 216 ms
78,080 KB
testcase_11 AC 204 ms
77,568 KB
testcase_12 AC 208 ms
77,696 KB
testcase_13 AC 198 ms
77,396 KB
testcase_14 AC 205 ms
77,440 KB
testcase_15 AC 207 ms
77,312 KB
testcase_16 AC 199 ms
77,568 KB
testcase_17 AC 201 ms
77,468 KB
testcase_18 AC 202 ms
77,680 KB
testcase_19 AC 259 ms
79,476 KB
testcase_20 AC 206 ms
78,208 KB
testcase_21 AC 202 ms
77,696 KB
testcase_22 AC 441 ms
78,976 KB
testcase_23 AC 435 ms
79,104 KB
testcase_24 AC 436 ms
79,104 KB
testcase_25 AC 436 ms
78,976 KB
testcase_26 AC 434 ms
79,360 KB
testcase_27 AC 449 ms
80,012 KB
testcase_28 AC 435 ms
79,104 KB
testcase_29 AC 433 ms
79,068 KB
testcase_30 AC 449 ms
78,848 KB
testcase_31 AC 442 ms
79,360 KB
testcase_32 AC 435 ms
78,552 KB
testcase_33 AC 469 ms
79,436 KB
testcase_34 AC 450 ms
78,848 KB
testcase_35 AC 438 ms
78,976 KB
testcase_36 AC 438 ms
78,848 KB
testcase_37 AC 435 ms
78,720 KB
testcase_38 AC 434 ms
78,720 KB
testcase_39 AC 434 ms
78,788 KB
testcase_40 AC 435 ms
79,360 KB
testcase_41 AC 432 ms
78,592 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