字符串的数量V3

这题没什么好说的，直接贴代码吧。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>

typedef long long ll;

const int MAXN = 61;
const int MOD = 1e9 + 7;

int deg;
int iact[MAXN + 1];
int val[MAXN + 1];
int nxt[MAXN + 1];
int seq[MAXN + 1];

ll n, m;

inline int mod_add(int x, int y)
{
    return x + y < MOD ? x + y : x + y - MOD;
}

inline int mod_dec(int x, int y)
{
    return x - y >= 0 ? x - y : x - y + MOD;
}

int value(int a)
{
    if (a < deg)
    {
        return val[a];
    }
    static int pre[MAXN], suf[MAXN];
    pre[0] = a;
    for (int i = 1; i < deg; ++i)
    {
        pre[i] = (ll)(a - i) * pre[i - 1] % MOD;
    }
    suf[deg - 1] = a - deg + 1;
    for (int i = deg - 2; i >= 0; --i)
    {
        suf[i] = (ll)(a - i) * suf[i + 1] % MOD;
    }
    int ret = 0;
    for (int i = 0; i < deg; ++i)
    {
        int tmp = (ll)val[i] * iact[i] % MOD * iact[deg - 1 - i] % MOD;
        if (i > 0)
        {
            tmp = (ll)tmp * pre[i - 1] % MOD;
        }
        if (i < deg - 1)
        {
            tmp = (ll)tmp * suf[i + 1] % MOD;
        }
        if (((deg - 1 - i) & 1) && tmp > 0)
        {
            tmp = MOD - tmp;
        }
        ret += tmp;
        if (ret >= MOD)
        {
            ret -= MOD;
        }
    }
    return ret;
}

struct Matrix
{
    int r, c, num[MAXN][MAXN];
    Matrix operator * (const Matrix &t) const
    {
        Matrix ret = {r, t.c};
        for (int i = 0; i < r; ++i)
        {
            for (int j = 0; j < c; ++j)
            {
                for (int k = 0; k < t.c; ++k)
                {
                    ret.num[i][k] = (ret.num[i][k] + (ll)num[i][j] * t.num[j][k]) % MOD;
                }
            }
        }
        return ret;
    }
    Matrix pow(ll k)
    {
        Matrix ret = {r, r}, tmp = *this;
        for (int i = 0; i < r; ++i)
        {
            ret.num[i][i] = 1;
        }
        for (; k > 0; k >>= 1, tmp = tmp * tmp)
        {
            if (k & 1)
            {
                ret = ret * tmp;
            }
        }
        return ret;
    }
} A;

int main()
{
    int T;
    scanf("%d", &T);

    while (T--) 
    {
        iact[0] = 0;
        iact[1] = 1;
        for (int i = 2; i <= MAXN; ++i)
        {
            iact[i] = MOD - MOD / i * (ll)iact[MOD % i] % MOD;
        }
        iact[0] = 1;
        for (int i = 1; i <= MAXN; ++i)
        {
            iact[i] = iact[i - 1] * (ll)iact[i] % MOD;
        }

        int len;
        scanf("%lld%lld", &n, &m);

        ll tmp = (n << 1) - 1;
        deg = val[0] = 1;
        for (len = 1; --tmp >= 0; ++len)
        {
            for (int i = 0, pos = tmp & 1; i <= deg; ++i, pos = mod_add(pos, 2))
            {
                nxt[i] = mod_add(i > 0 ? nxt[i - 1] : 0, value(pos));
            }
            ++deg;
            for (int i = 0; i < deg; ++i)
            {
                val[i] = nxt[i];
            }
            tmp >>= 1;
            seq[len] = value(tmp % MOD);
        }
        --len;

        ll tmp_ = n - 1;
        deg = val[0] = 1;
        for (int j = 1; --tmp_ >= 0; ++j)
        {
            for (int i = 0, pos = tmp_ & 1; i <= deg; ++i, pos = mod_add(pos, 2))
            {
                nxt[i] = mod_add(i > 0 ? nxt[i - 1] : 0, value(pos));
            }
            ++deg;
            for (int i = 0; i < deg; ++i)
            {
                val[i] = nxt[i];
            }
            tmp_ >>= 1;
            seq[j] = mod_dec(seq[j], value(tmp_ % MOD));
        }

        A = (Matrix){len, len};
        for (int i = 1; i < len; ++i)
        {
            A.num[i][i - 1] = 1;
        }
        for (int i = 0; i < len; ++i)
        {
            A.num[i][len - 1] = seq[len - i];
        }
        A = A.pow(m);
        printf("%d\n", A.num[len - 1][len - 1]);
    }

    return 0;
}