結果

問題 No.891 隣接3項間の漸化式
ユーザー kohei2019kohei2019
提出日時 2022-05-10 22:20:33
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 90 ms / 2,000 ms
コード長 7,280 bytes
コンパイル時間 817 ms
コンパイル使用メモリ 87,220 KB
実行使用メモリ 71,960 KB
最終ジャッジ日時 2023-09-25 06:10:32
合計ジャッジ時間 6,667 ms
ジャッジサーバーID
（参考情報） 		judge14 / judge11
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 85 ms
71,764 KB
testcase_01 AC 90 ms
71,708 KB
testcase_02 AC 85 ms
71,784 KB
testcase_03 AC 86 ms
71,616 KB
testcase_04 AC 87 ms
71,644 KB
testcase_05 AC 85 ms
71,960 KB
testcase_06 AC 87 ms
71,612 KB
testcase_07 AC 86 ms
71,688 KB
testcase_08 AC 85 ms
71,920 KB
testcase_09 AC 88 ms
71,728 KB
testcase_10 AC 87 ms
71,728 KB
testcase_11 AC 88 ms
71,676 KB
testcase_12 AC 86 ms
71,708 KB
testcase_13 AC 86 ms
71,880 KB
testcase_14 AC 85 ms
71,904 KB
testcase_15 AC 88 ms
71,792 KB
testcase_16 AC 89 ms
71,728 KB
testcase_17 AC 86 ms
71,688 KB
testcase_18 AC 86 ms
71,672 KB
testcase_19 AC 87 ms
71,604 KB
testcase_20 AC 85 ms
71,488 KB
testcase_21 AC 87 ms
71,484 KB
testcase_22 AC 87 ms
71,612 KB
testcase_23 AC 87 ms
71,464 KB
testcase_24 AC 87 ms
71,464 KB
testcase_25 AC 87 ms
71,608 KB
testcase_26 AC 87 ms
71,904 KB
testcase_27 AC 86 ms
71,696 KB
testcase_28 AC 87 ms
71,640 KB
testcase_29 AC 89 ms
71,896 KB
testcase_30 AC 86 ms
71,664 KB
testcase_31 AC 87 ms
71,464 KB
testcase_32 AC 87 ms
71,612 KB
testcase_33 AC 86 ms
71,708 KB
testcase_34 AC 87 ms
71,700 KB
testcase_35 AC 89 ms
71,876 KB
testcase_36 AC 87 ms
71,812 KB
testcase_37 AC 89 ms
71,832 KB
testcase_38 AC 85 ms
71,832 KB
testcase_39 AC 88 ms
71,768 KB
testcase_40 AC 87 ms
71,900 KB
testcase_41 AC 87 ms
71,708 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)

a,b,n = map(int,input().split())
arr = [[a,b],[1,0]]
MT = matrix()
arr2 = MT.modPow_matrix(arr, n)
vec = [[1],[0]]
vec2 = MT.multiplication_mod(arr2, vec)
print(vec2[1][0])
0