HDU多校第一场 1007 Chiaki Sequence Revisited

1007. Chiaki Sequence Revisited

求 。

打表发现差分数组为1,1,0,1,1,0,0,1,1,0...

即初始值为1，每次操作将数列的所有1变为1,1,0，所有0不变，迭代无穷多次，是分形结构。

现在已知差分序列，运用阿贝尔变换，即

可以将数组A与数组B的差分的乘积转换为数组B与数组A差分的乘积。

令原式中,，可得

令，则

递归处理da即可。

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int mod = 1e9 + 7;

struct value_t
{
    LL len, one, sum;
    value_t() = default;
    value_t(LL x, LL y, LL z): len(x), one(y), sum(z) {}
} dp[60];

void prepare()
{
    dp[0] = {3, 2, 1};
    for (int i = 1; i < 60; ++i)
    {
        dp[i].len = dp[i - 1].len + dp[i - 1].one * 2;
        assert(dp[i].len == dp[i - 1].len * 2 + 1);
        dp[i].one = dp[i - 1].one * 2;
        dp[i].sum = (dp[i - 1].sum * 2 + (dp[i - 1].len % mod) * (dp[i - 1].one % mod)) % mod;
    }
}

LL prefix, sum0, sum1;

void update(LL len, LL one, LL sum)
{
    sum0 += one;
    sum1 += sum + (one % mod) * (prefix % mod) % mod;
    prefix += len;
    sum0 %= mod, sum1 %= mod;
}

void solve(LL n, int depth, int trailing)
{
    if (n == dp[depth].len + trailing)
    {
        update(n, dp[depth].one, dp[depth].sum);
        return;
    }
    if (depth == 0)
    {
        if (n == 1)
            update(1, 1, 0);
        else
            update(n, 2, 1);
        return;
    }
    if (n <= dp[depth - 1].len)
    {
        solve(n, depth - 1, 0);
    }
    else
    {
        update(dp[depth - 1].len, dp[depth - 1].one, dp[depth - 1].sum);
        solve(n - dp[depth - 1].len, depth - 1, trailing + 1);
    }
}

int main()
{
    prepare();
    int T;
    for (scanf("%d", &T); T; T--)
    {
        LL n;
        scanf("%lld", &n);
        for (int i = 0; i < 60; ++i)
            if (dp[i].len >= n)
            {
                prefix = sum0 = sum1 = 0;
                solve(n, i, 0);
                printf("%lld
", ((n - 1) % mod * (sum0 % mod) % mod - sum1 % mod + 1 + mod) % mod);
                break;
            }
    }

    return 0;
}