【???】【???】了不起的郁杨

【背景】
众所周知，郁杨是一个十分优秀的人，他每天都会用课余时间想物理问题，以保持对物理火热般地热爱。也因此，他的物理成绩每次都是95+。有一天我问他:“为什么你这么优秀？”，郁杨红了脸，很不好意思地对我说了一番话，看起来好像很萌的样子，说完了我就傻了。
【问题描述】
原来郁杨说：“成功无捷径,我每次做题的时候会先规定这题最多想K秒,然后休息一下再想,你可以想像你想问题的时候就像在读进度条，我每想S秒，那么这个进度条就会前进S格，只要恰好到了进度条的终点N，那么我就能把这题解决了！另外，多一秒都不行，要恰好N秒，不然脑子会坏掉的.”；
我：“。。。。”
给出K和N，求出郁杨解决这道题有多少种姿势D。
因为D可能很大所以只需输出其mod 7777777之后的结果就可以了.
//看完样例说明你就知道我在讲什么了,其中开始时进度条为0，所涉及到的计算都是整数。
【输入格式】

输入的第一行为K(1<=k<=10);
输入的第二行为N(N<=2^31-1);
【输出格式】
一个整数，为郁杨解决这道题的方案数 mod 7777777之后的结果.
【样例输入】
2
4
【样例输出】
5
【样例说明】
一共有5种姿势
(即最多想2秒，也就是说可以想1秒也可以想2秒,只要最后进度条恰好为4即可);
→1→2→3→4
→2→3→4
→2→4
→1→3→4
→1→2→4
【后话】
因为勤于思考郁杨成就了自己的理想，获得了人生的成功。

【题解】

显然有递推关系
f[n] = f[n-1]+f[n-2]+f[n-3]+…+f[n-k];
但是n巨大.
用迭代的方法虽然可以解决空间问题，但是时间还是会超的。
更优秀的办法:
用矩阵乘法进行迭代.
构造一个矩阵
以k = 3为例

[0 1 0]   [f(n-3)]   [f(n-2)]
[0 0 1] * [f(n-2)] = [f(n-1)] 
[1 1 1]   [f(n-1)]   [f(n)]

则

[0 1 0]         [f(1)]   [f(n-2)]
[0 0 1] ^(n-3)* [f(2)] = [f(n-1)] 
[1 1 1]         [f(3)]   [f(n)]

先处理出f[1..k]
然后处理出那个构造矩阵的(n-3)次方。然后就能够快速获得f(n)了;
因为n巨大，所以要用快速幂;
记得取模;


当时自己瞎编的背景，现在看到留下的就只有感动了,虽然当时有点幼稚，但很怀念。

#include <cstdio>
#include <algorithm>
#include <iostream>
#define LL long long

using namespace std;

const int MAXK = 12;
const LL mod = 7777777;

struct abc
{
    LL jz[MAXK][MAXK];
};

abc temp = { 0 },a;
int k,n;
LL f[MAXK];

void input(int &r)
{
    r = 0;
    char t = getchar();
    while (!isdigit(t)) t = getchar();
    while (isdigit(t)) r = r * 10 + t - '0', t = getchar();
}

abc jc(abc a, abc b)//矩阵a左乘b
{
    abc c;
    for (int i = 1;i <= k;i++)
        for (int j = 1; j <= k; j++)
        {
            c.jz[i][j] = 0;
            for (int l = 1; l <= k; l++)
                c.jz[i][j] = (c.jz[i][j] + a.jz[i][l] * b.jz[l][j])%mod;
        }
    return c;
}

abc ksm(int x)//矩阵快速幂
{
    if (x == 1)
        return temp;
    abc dd;
    dd = ksm(x >> 1);
    dd = jc(dd,dd);
    if (x & 1)
        dd = jc(dd, temp);
    return dd;
}

int main()
{
    input(k); input(n);
    f[0] = 1;
    for (int i = 1; i <= k; i++)
        for (int j = 0; j <= i - 1; j++)//预处理出f[1..k]
            f[i] += f[j];
    if (n <= k)//小于k直接输出
    {
        printf("%I64d
", f[n]);
        return 0;
    }
    for (int i = 1; i <= k - 1; i++)
        temp.jz[i][i+1] = 1;
    for (int i = 1; i <= k; i++)
        temp.jz[k][i] = 1;
    a = ksm(n - k);
    f[11] = 0;
    for (int i = 1; i <= k; i++)
        f[11] = (f[11]+a.jz[k][i]*f[i])%mod;
    printf("%I64d
", f[11]);
    return 0;
}