2017中国大学生程序设计竞赛

Happy Necklace

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 1146    Accepted Submission(s): 491

Problem Description

Little Q wants to buy a necklace for his girlfriend. Necklaces are single strings composed of multiple red and blue beads.
Little Q desperately wants to impress his girlfriend, he knows that she will like the necklace only if for every prime length continuous subsequence in the necklace, the number of red beads is not less than the number of blue beads.
Now Little Q wants to buy a necklace with exactly beads. He wants to know the number of different necklaces that can make his girlfriend happy. Please write a program to help Little Q. Since the answer may be very large, please print the answer modulo .
Note: The necklace is a single string, {not a circle}.

 

Input

The first line of the input contains an integer , denoting the number of test cases.
For each test case, there is a single line containing an integer , denoting the number of beads on the necklace.

 

Output

For each test case, print a single line containing a single integer, denoting the answer modulo .

 

Sample Input

223

 

 

Sample Output

34

 

 

Source

2017中国大学生程序设计竞赛 - 女生专场

题目描述：你有一个有n个颜色为红色或蓝色的珠子的项链，你可以将项链截断成长度为素数的珠子，如果截取出的一段红色的珠子的个数大于蓝色的珠子，则成为good，问一共有多少种good的可能性。

    可以发现

    n=2，res=3；n=3，res=4；n=4，res=6；n=5，res=9；

    故有递推式 An=An-1+An-3；

    如果用a表示红色，用b表示蓝色。题意明显可以看出只需要管长度2和3的连续序列是否符合！

    如果以b结尾，那么下一个必须是a，或者加个aab就可以了！

    所以同理就可以推出递推式An=An-1+An-3;

    看一下题目的数据范围，n最大1e18，因此常规O(n)的递推显然不可行，因此直接上O(logn)的矩阵快速幂。

    发现递推式是四阶的递推式，故所得的常数矩阵应该是四维的。之后只需带入矩阵快速幂模板即可。

先看这个特征方程F[i] = F[i - 1] + F[i - 3]，那么就有一个矩阵如下

我们的目标矩阵就是

那么，针对这个矩阵我们如何转置呢？

先看目标矩阵第一个：F[i]

F[i] = F[i - 1] + F[i - 3]

那么，由矩阵乘法，转置矩阵第一行，似乎就定了：1 0 1

同样的，二三行就是1 0 0 和 0 1 0

整个矩阵如下：

 

#include<iostream>  
#include<algorithm>  
#include<cmath>  
#include<cstdio>  
#include<cstring>  
  
#define INF 0x3f3f3f3f  
  
#define mod 1000000007  
  
using namespace std;  
  
typedef long long ll;  
const int maxn = 100010;  
  
ll n;  
  
struct Matrix {  
    ll a[5][5];  
};  
  
  
Matrix mul(Matrix x, Matrix y)  
{  
    Matrix temp;  
    for (int i = 1; i <= 3; i++)  
        for (int j = 1; j <= 3; j++) temp.a[i][j] = 0;  
  
    for (int i = 1; i <= 3; i++)  
    {  
        for (int j = 1; j <= 3; j++)  
        {  
            ll sum = 0;  
            for (int k = 1; k <= 3; k++)  
            {  
                sum = (sum + x.a[i][k] * y.a[k][j] % mod) % mod;  
            }  
            temp.a[i][j] = sum;  
        }  
    }  
    return temp;  
}  
  
Matrix quickpow(Matrix A,ll k)  
{  
    Matrix res;  
    res.a[1][1] = 1; res.a[1][2] = 0; res.a[1][3] = 0;  
    res.a[2][1] = 0; res.a[2][2] = 1; res.a[2][3] = 0;  
    res.a[3][1] = 0; res.a[3][2] = 0; res.a[3][3] = 1;  
    while (k)  
    {  
        if (k & 1) res = mul(res, A);  
        A = mul(A, A);  
        k >>= 1;  
    }  
    return res;  
}  
  
int main()  
{  
    int t;  
    scanf("%d", &t);  
    while (t--)  
    {  
        scanf("%lld", &n);  
        if (n == 2)  
        {  
            printf("3
");  
            continue;  
        }  
        Matrix A;  
        A.a[1][1] = 1; A.a[1][2] = 0; A.a[1][3] = 1;  
        A.a[2][1] = 1; A.a[2][2] = 0; A.a[2][3] = 0;  
        A.a[3][1] = 0; A.a[3][2] = 1; A.a[3][3] = 0;  
        Matrix res = quickpow(A, n - 2);  
        ll x = (res.a[1][1] + res.a[1][2] + res.a[1][3]) % mod;  
        ll y = (res.a[2][1] + res.a[2][2] + res.a[2][3]) % mod;  
        ll z = (res.a[3][1] + res.a[3][2] + res.a[3][3]) % mod;  
        printf("%lld
", (x + y + z) % mod);  
    }  
}