[HIHO1555] 四次方根（递推，容斥，矩阵快速幂）

题目链接：http://hihocoder.com/problemset/problem/1555

首先要知道一元四次方程根与系数的关系：

设x^4+ax^3+bx²+cx+d=0的四个根是x1,x2,x3,x4,则
x1+x2+x3+x4=﹣a
x1x2+x1x3+x1x4+x2x3+x2x4+x3x4=b
x1x2x3+x1x2x4+x1x3x4+x2x3x4=﹣c
x1x2x3x4=d

设f(n)=x1^n+x2^n+x3^n+x4^n。

容斥一下就能找到一个递推关系：

f(n)=(x1+x2+x3+x4)*f(n-1)-(x1x2+x1x3+x1x4+x2x3+x2x4+x3x4)*f(n-2)+(x1x2x3+x1x2x4+x2x3x4)*f(n-3)-(x1x2x3x4)*(fn-4)。

整理得：f(n)=-af(n-1)-bf(n-2)-cf(n-3)-df(n-4)。

初始值是这样的：显然f(0)=4，f(1)=-a，f(2)可以由f(1)的结果推过来，展开(x1+x2+x3+x4)^2后，使用上述关系，把f(2)以外的式子减掉，可以得f(2)=a*a-2*b，同理f(3)=f(1)*f(2)+a*b-3*c。

构造四阶矩阵：

-a -b -c -d
 1  0  0  0
 0  1  0  0
 0  0  1  0

负数模运算要注意，先+mod变成正数。

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

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

typedef struct Matrix {
    LL m[maxn][maxn];
    int r, c;
    Matrix(){
        r = c = 0;
        memset(m, 0, sizeof(m));
    } 
} Matrix;
Matrix mul(Matrix m1, Matrix m2, LL mod) {
    Matrix ans = Matrix();
    ans.r = m1.r; ans.c = m2.c;
    for(int i = 1; i <= m1.r; i++) {
        for(int j = 1; j <= m2.r; j++) {
            for(int k = 1; k <= m2.c; k++) {
                if(m2.m[j][k] == 0) continue;
                ans.m[i][k] = (ans.m[i][k] + (m1.m[i][j] * m2.m[j][k]) % mod) % mod;
            }
        }
    }
    return ans;
}
Matrix quickmul(Matrix m, LL n, LL mod) {
    Matrix ans = Matrix();
    for(int i = 1; i <= m.r; i++) ans.m[i][i] = 1;
    ans.r = m.r;
    ans.c = m.c;
    while(n) {
        if(n & 1) ans = mul(m, ans, mod);
        m = mul(m, m, mod);
        n >>= 1;
    }
    return ans;
}

LL n,a,b,c,d;

signed main() {
    // freopen("in", "r", stdin);
    int T;
    LL f[11];
    scanf("%d", &T);
    while(T--) {
        scanf("%lld%lld%lld%lld%lld",&n,&a,&b,&c,&d);
        f[0] = 4LL;
        f[1]=-a;
        f[2]=-2LL*b%mod-1LL*a*f[1]%mod;
        f[3]=-3LL*c%mod-1LL*b*f[1]%mod-1LL*a*f[2]%mod;
        f[4]=-4LL*d%mod-1LL*c*f[1]%mod-1LL*b*f[2]%mod-1LL*a*f[3]%mod;
        f[1]=(mod+f[1]%mod)%mod;f[2]=(mod+f[2]%mod)%mod;f[3]=(mod+f[3]%mod)%mod;f[4]=(mod+f[4]%mod)%mod;
        Matrix p; p.r = p.c = 4;
        p.m[1][1] = (-a+mod)%mod; p.m[1][2] = (-b+mod)%mod;
        p.m[1][3] = (-c+mod)%mod; p.m[1][4] = (-d+mod)%mod;
        p.m[2][1] = 1; p.m[3][2] = 1; p.m[4][3] = 1;
        if(n <= 4) {
            printf("%lld
", f[n]);
            continue;
        }
        p = quickmul(p, n-4, mod);
        LL ret = 0;
        for(int i = 1; i <= 4; i++) {
            ret += p.m[1][i]*f[4-i+1]%mod;
            ret %= mod;
        }
        printf("%lld
", ret);
    }
    return 0;
}