猫王相亲

题目大意

给定一个金字塔，从第二层起每一层中的数均等于下面一层左右的两个数之和。给定正整数$n（nle10^5）$，金字塔的第一层为$1$到$n$从小到大排列而成的数列，求金字塔顶的数。

数列特征

从已知条件只能知道第一行为$1～N$的等差数列。

假设第一行中某三个连续的数字为$a-d, a, a+d$，（$d$为等差数列的公差，此处$d=1$），那么第二行对应的数为$2a-d,2a+d$，相差$2d$，由于$a$的一般性，所以对于第二行任意两项的差都为$2d$，以此类推每一行的数列都组成等差数列，第$i$行数列的公差为$d_i=2^{i-1}$。

首项的值

推导出公差之后，只要知道数列的首项，就能很快得出整个数列，而最后求的是金字塔顶的数，就相当于最顶上一层的首项，所以设$F_i$为第$i$层的首项。

根据每个数等于下一层左右两个数的和，那么就有
$$egin{array}\F_i&=&F_{i-1}+(F_{i-1}+d_{i-1}) \&=&2F_{i-1}+2^{i-1} end{array}$$

代入$n$，则有

$$egin{array} \ F_n&=&2F_{n-1}+2^{n-2} \ &=&2(2F_{n-2}+2^{n-3})+2^{n-2}&=&4F_{n-2}+2cdot 2^{n-2} \ &=&4(2F_{n-3}+2^{n-4})+2^{n-2}&=&8F_{n-3}+3cdot 2^{n-2} \&=&……\ _{第i行}&=&2^iF_{n-i}+icdot 2^{n-2} \ _{当i=n-1时}&=&2^{n-1}F_1+(n-1)cdot 2^{n-2} \ &=&(n+1)cdot 2^{n-2} end{array}$$

所以只要高精度加个快速幂就好了。

代码

#include <cstdio>
#include <cstring>

struct BigNumber
{
    static const long long BASE = 1000000000;
    static const int BASEDIGS = 9;
    
    int ndigs;
    long long *digs;
    
    void init(int n, const long long *d)
    {
        while (n > 0 && d[n - 1] == 0)
            --n;
        ndigs = n;
        digs = new long long[n];
        for (int i = 0; i < n; ++i)
            digs[i] = d[i];
    }
    
    BigNumber(int n, const long long *d)
    {
        init(n, d);
    }
    
    BigNumber(long long x = 0)
    {
        long long d[2];
        d[0] = x % BASE;
        d[1] = x / BASE;
        init(2, d);
    }
    
    BigNumber operator *(const BigNumber &a) const
    {
        int n = ndigs + a.ndigs;
        long long d[n], p;
        for (int i = 0; i < n; i++)
            d[i] = 0;
        for (int i = 0; i < ndigs; i++)
        {
            p = 0;
            for (int j = 0; j < a.ndigs; j++)
            {
                long long v = digs[i] * a.digs[j];
                long long v1 = v / BASE, v0 = v % BASE;
                d[i + j] += v0 + p;
                p = v1 + d[i + j] / BASE;
                d[i + j] %= BASE;
            }
            for(int j = i + a.ndigs; p > 0; ++j)
            {
                d[j] += p;
                p = d[j] / BASE;
                d[j] %= BASE;
            }
        }
        return BigNumber(n, d);
    }

    BigNumber operator *(long long x) const
    {
        int n = ndigs + 1;
        long long d[n];
        long long a = 0;
        for (int i = 0; i < ndigs; i++)
        {
            a += digs[i] * x;
            d[i] = a % BASE;
            a /= BASE;
        }
        d[ndigs] = a;
        return BigNumber(n, d);
    }

    void write() const
    {
        if (ndigs == 0) printf("0");
        else
        {
            printf("%lld", digs[ndigs - 1]);
            for (int i = ndigs - 2; i >= 0; i--)
                printf("%0*lld", BASEDIGS, digs[i]);
        }
    }
};

int n;

BigNumber pow(BigNumber x, int p)
{
    if (p == 0) return BigNumber(1);
    if (p == 1) return x;
    if (p == 2) return x * x;
    if (p & 1) return pow(pow(x, p / 2), 2) * x;
    return pow(pow(x, p / 2), 2);
}

int main()
{
    scanf("%d", &n);
    if (n == 1) printf("1");
    else (pow(BigNumber(2), n - 2) * (n + 1)).write();
}