哈理工OJ 1430 神秘植物

好久没写博客了，学的东西太多，想不到写些什么好，所以干脆就把之前刷OJ碰到的比较好的题的解题思路给写下来

神秘植物

Time Limit: 1000 MS Memory Limit: 65536 K Total Submit: 178(69 users) Total Accepted: 67(52 users) Rating:  Special Judge: No

Description

Leyni有一种神秘的植物，形状是一种“向上”三角形植物，每过一年，每个“向上”三角形植物会变成三个“向上”三角形植物和一个“向下”三角形植物，每个“向下”三角形植物会变成三个“向下”三角形植物和一个“向上”三角形植物。如下图： Leyni想知道经过n年有多少个“向上”三角形植物。

Input

输入包含多组测试数据。 对于每组测试数据： 第1行，包含一个整数n (0 ≤ n ≤ 1018) 处理到文件结束

Output

对于每组测试数据： 第1行，输出Leyni拥有多少个“向上”三角形植物。(MOD 1000000007) 扫描二维码关注公众号，回复： 5347336 查看本文章

Sample Input

1 2

Sample Output

3 10

一眼看过去就知道是一个找规律的题，发现输入数据特别大，故判断为矩阵快速幂的题，那么只需将找到的规律写成矩阵迭代的形式

我们假设f(n)代表第n年向上的三角形的个数，g(n)代表第n年向下的三角形的个数

因此我们可以得到

                                                                   

                                                                   

写成矩阵就是

                                                   

进而得到

                                 

代码实现应该就很容易了（以下代码仅供参考）

C++代码实现

#include <iostream>
#include <stdio.h>
#include <cstring>
#define LL long long
using namespace std;
const int _SIZE = 2;
const LL MOD = 1000000007;
struct Matrix{
        LL _[_SIZE][_SIZE] = {};
        Matrix(LL a[_SIZE][_SIZE]){
            for (int i = 0; i<_SIZE; i++)
                for (int j = 0; j<_SIZE; j++)
                    _[i][j] = a[i][j];
        }
};
// 矩阵相乘
Matrix matrixMultiply(const Matrix &A,const Matrix &B) {
    LL _C[_SIZE][_SIZE] = {{0,0},{0,0}};
    Matrix C(_C);
    for (int i = 0; i < _SIZE; i++)
        for (int j = 0; j < _SIZE; j++)
            for (int k = 0; k < _SIZE; k++)
              C._[i][k] = (C._[i][k]%MOD + (A._[i][j]%MOD * B._[j][k]%MOD)%MOD)%MOD;
    return C;
}
// 矩阵快速幂
Matrix matrixPower(Matrix &A,LL n) {
    LL _E[_SIZE][_SIZE] = {{1,0},{0,1}};
    Matrix E(_E);
    while (n != 0) {
        if (n%2) E = matrixMultiply(E, A);
        A = matrixMultiply(A, A);
        n /= 2;
    }
    return E;
}
int main() {
    LL n;
    while (scanf("%lld", &n) == 1) {
        LL _A[_SIZE][_SIZE] = {{3,1},{1,3}};
        Matrix A(_A);
        printf("%lld\n", matrixPower(A, n)._[0][0]);
    }
    return 0;
}

JAVA代码实现

import java.util.Scanner;

public class Main {
    static private final int SIZE = 2;
    static private final long MOD = 1000000007;
    static private Scanner scanner = new Scanner(System.in);
    static private long[][] R = new long[][]{{3, 1}, {1, 3}};

    static private long[][] matrixMultiply(long[][] A, long[][] B) {
        long[][] C = new long[][]{{0, 0}, {0, 0}};
        for (int i = 0; i < SIZE; i++)
            for (int j = 0; j < SIZE; j++)
                for (int k = 0; k < SIZE; k++)
                    C[i][k] = (C[i][k] % MOD + A[i][j] % MOD * B[j][k] % MOD) % MOD;
        return C;
    }

    static private long[][] matrixPower(long[][] A, long n) {
        long[][] E = new long[][]{{1, 0}, {0, 1}};
        while (n != 0) {
            if (n % 2 == 1) E = matrixMultiply(E, A);
            A = matrixMultiply(A, A);
            n /= 2;
        }
        return E;
    }

    static public void main(String[] args) {
        while (scanner.hasNextLong()) {
            long n = scanner.nextLong();
            System.out.println(matrixPower(R, n)[0][0]);
        }
    }
}

PYTHON代码实现

MOD = 1000000007
def matrix_multiply(A: list, B: list) -> list:
    C = [[0, 0], [0, 0]]
    for i in range(0, 2):
        for j in range(0, 2):
            for k in range(0, 2):
                C[i][k] = (C[i][k] % MOD + A[i][j] % MOD * B[j][k] % MOD) % MOD
    return C
def matrix_power(A: list, n: int) -> list:
    E = [[1, 0], [0, 1]]
    while n != 0:
        if n % 2: E = matrix_multiply(E, A)
        A = matrix_multiply(A, A)
        n //= 2
    return E
if __name__ == "__main__":
    while True:
        n = int(input())
        print(matrix_power([[3, 1], [1, 3]], n)[0][0])