矩阵快速幂

---

1 HDU 1575 Tr A

2 HDU 1588 Gauss Fibonacci

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
int k, b, n, mod;
struct Matrix { ll det[4][4]; };
Matrix ans, ans_t, mat_t;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 4; ++i) {
        for (int k = 0; k < 4; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 4; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans_t = mul(mat_t, ans_t); }
        mat_t = mul(mat_t, mat_t); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%d %d %d %d", &k, &b, &n, &mod) != EOF) {
        memset(mat_t.det, 0, sizeof(mat_t.det));
        mat_t.det[0][1] = mat_t.det[1][0] = mat_t.det[1][1] = 1;
        memset(ans_t.det, 0, sizeof(ans_t.det));
        ans_t.det[0][0] = ans_t.det[1][1] = 1;
        if (k) { solve(k); } memset(mat_t.det, 0, sizeof(mat_t.det));
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                mat_t.det[i][j] = ans_t.det[i][j];
            }
            mat_t.det[i][i + 2] = mat_t.det[i + 2][i + 2] = 1;
        }
        memset(ans_t.det, 0, sizeof(ans_t.det));
        for (int i = 0; i < 4; ++i) { ans_t.det[i][i] = 1; }
        if (n) { solve(n); } ans = ans_t;
        memset(mat_t.det, 0, sizeof(mat_t.det));
        mat_t.det[0][1] = mat_t.det[1][0] = mat_t.det[1][1] = 1;
        memset(ans_t.det, 0, sizeof(ans_t.det));
        ans_t.det[0][0] = ans_t.det[1][1] = 1;
        if (b) { solve(b); }
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                ans.det[i][j] = ans.det[i][j + 2];
                ans.det[i][j + 2] = ans.det[i + 2][j] = 0;
                ans.det[i + 2][j + 2] = 0;
            }
        }
        ans = mul(ans, ans_t);
        printf("%lld
", ans.det[0][1]);
    }
    return 0;
}

3 HDU 1757 A Simple Math Problem

4 HDU 2157 How many ways??

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <bitset>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9

typedef long long ll;
typedef pair<int, int> pii;

const int INF = 0x7fffffff;
struct Matrix { ll det[20][20]; };
const int mod = 1000;
Matrix mat_t, mat, ans;
int n, m, q, a, b, k;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < n; ++i) {
        for (int k = 0; k < n; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < n; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    mat = ans = mat_t;
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%d %d", &n, &m) != EOF) {
        if (!n && !m) { break; } memset(mat_t.det, 0, sizeof(mat_t.det));
        for (int i = 0; i < m; ++i) {
            scanf("%d %d", &a, &b); mat_t.det[a][b] = 1;
        }
        scanf("%d", &q);
        while (q--) {
            scanf("%d %d %d", &a, &b, &k);
            if (k == 0 && a != b) { printf("0
"); continue; }
            if (k == 0) { printf("1
"); continue; }
            solve(k - 1); printf("%d
", ans.det[a][b]);
        }
    }
    return 0;
}

5 HDU 2254 奥运

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int maxn = 1e4;
const int mod = 2008;
struct Matrix { int det[30][30]; };
Matrix mat_t;
Matrix mat[maxn];
vector<ll> v;
ll p1[maxn], p2[maxn];
int n, q, t1, t2, id1, id2, ans;
ll v1, v2;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 30; ++i) {
        for (int k = 0; k < 30; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 30; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
int get_id(ll x) {
    int ret = lower_bound(v.begin(), v.end(), x) - v.begin();
    if (ret == (int)v.size() || v[ret] != x) { return -1; } return ret;
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%d", &n) != EOF) {
        v.clear();
        for (int i = 0; i < n; ++i) {
            scanf("%lld %lld", &p1[i], &p2[i]);
            v.push_back(p1[i]); v.push_back(p2[i]);
        }
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
        memset(mat_t.det, 0, sizeof(mat_t.det));
        for (int i = 0; i < n; ++i) {
            id1 = get_id(p1[i]); id2 = get_id(p2[i]);
            ++mat_t.det[id1][id2];
        }
        mat[1] = mat_t;
        for (int i = 2; i < maxn; ++i) { mat[i] = mul(mat[i - 1], mat_t); }
        scanf("%d", &q);
        while (q--) {
            scanf("%lld %lld %d %d", &v1, &v2, &t1, &t2);
            id1 = get_id(v1); id2 = get_id(v2);
            if (id1 == -1 || id2 == -1) { printf("0
"); continue; }
            ans = 0;
            for (int i = t1; i <= t2; ++i) {
                if (i == 0) { continue; }
                ans += mat[i].det[id1][id2]; ans %= mod;
            }
            printf("%d
", ans);
        }
    }
    return 0;
}

6 HDU 2256 Problem of Precision

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <ext/rope>

using namespace std;
using namespace __gnu_cxx;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef pair<int, int> pii;
const ll mod = 1024;

struct Matrix { ll det[2][2]; };
Matrix ans, mat;
int T, n;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 2; ++i) {
        for (int k = 0; k < 2; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 2; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d", &T);
    while (T--) {
        scanf("%d", &n);
        if (n == 1) { printf("9
"); continue; }
        ans.det[0][0] = 5; ans.det[1][0] = 2;
        mat.det[0][0] = 5; mat.det[0][1] = 12;
        mat.det[1][0] = 2; mat.det[1][1] = 5;
        solve(n - 1); ans.det[0][0] *= 2; --ans.det[0][0];
        ans.det[0][0] %= mod;
        if (ans.det[0][0] < 0) { ans.det[0][0] += mod; }
        printf("%d
", ans.det[0][0]);
    }
    return 0;
}

7 HDU 2276 Kiki & Little Kiki 2

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int maxn = 110;
const int mod = 2;
struct Matrix { int det[100][100]; };
Matrix ans, mat;
int n, m;
char s[maxn];

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < n; ++i) {
        for (int k = 0; k < n; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < n; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%d %s", &m, s) != EOF) {
        n = strlen(s); memset(ans.det, 0, sizeof(ans.det));
        for (int i = 0; i < n; ++i) {
            if (s[i] == '1') { ans.det[i][0] = 1; }
        }
        memset(mat.det, 0, sizeof(mat.det));
        mat.det[0][0] = mat.det[0][n - 1] = 1;
        for (int i = 1; i < n; ++i) {
            mat.det[i][i] = mat.det[i][i - 1] = 1;
        }
        solve(m);
        for (int i = 0; i < n; ++i) {
            printf(i == n - 1 ? "%d
" : "%d", ans.det[i][0]);
        }
    }
    return 0;
}

8 HDU 2604 Queuing

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
int n, mod;
struct Matrix { ll det[4][4]; };
Matrix ans, mat;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 4; ++i) {
        for (int k = 0; k < 4; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 4; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%d %d", &n, &mod) != EOF) {
        if (n == 0) { printf("0
"); continue; }
        if (n == 1) { printf("%d
", 2 % mod); continue; }
        if (n == 2) { printf("%d
", 4 % mod); continue; }
        if (n == 3) { printf("%d
", 6 % mod); continue; }
        ans.det[0][0] = 6; ans.det[1][0] = 4;
        ans.det[2][0] = 2; ans.det[3][0] = 1;
        memset(mat.det, 0, sizeof(mat.det));
        mat.det[0][0] = mat.det[0][2] = mat.det[0][3] = 1;
        mat.det[1][0] = mat.det[2][1] = mat.det[3][2] = 1;
        solve(n - 3); printf("%d
", ans.det[0][0]);
    }
    return 0;
}

9 HDU 2855 Fibonacci Check-up

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
struct Matrix { ll det[2][2]; };
Matrix mat, ans;
int T, n, mod;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 2; ++i) {
        for (int k = 0; k < 2; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 2; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d", &T);
    while (T--) {
        scanf("%d %d", &n, &mod); mat.det[1][1] = 2;
        mat.det[0][0] = mat.det[0][1] = mat.det[1][0] = 1;
        ans.det[0][0] = ans.det[1][1] = 1;
        ans.det[0][1] = ans.det[1][0] = 0;
        solve(n); printf("%lld
", ans.det[0][1]);
    }
    return 0;
}

10 HDU 3117 Fibonacci Numbers

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int maxn = 40;
const ll mod = 1e4;
const double k = (sqrt(5.0) + 1.0) / 2.0;
int n;
int f[maxn];
struct Matrix { ll det[4][4]; };
Matrix ans_t, mat_t;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 4; ++i) {
        for (int k = 0; k < 4; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 4; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans_t = mul(mat_t, ans_t); }
        mat_t = mul(mat_t, mat_t); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    f[0] = 0; f[1] = 1;
    for (int i = 2; i < maxn; ++i) {
        f[i] = f[i - 1] + f[i - 2];
    }
    while (scanf("%d", &n) != EOF) {
        if (n < maxn) { printf("%d
", f[n]); continue; }
        double ans = -0.5 * log10(5.0) + 1.0 * n * log10(k);
        ans = ans - floor(ans); ans = pow(10.0, ans);
        while (ans < 1000.0) { ans *= 10.0; }
        printf("%d...", (int)ans);
        ans_t.det[0][0] = 1; ans_t.det[1][0] = 0;
        mat_t.det[0][0] = mat_t.det[0][1] = 1;
        mat_t.det[1][0] = 1; mat_t.det[1][1] = 0;
        solve(n - 1); printf("%04lld
", ans_t.det[0][0]);
    }
    return 0;
}

11 HDU 3306 Another kind of Fibonacci

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const ll mod = 1e4 + 7;
struct Matrix { ll det[4][4]; };
Matrix mat, ans;
ll n, x, y;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 4; ++i) {
        for (int k = 0; k < 4; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 4; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%lld %lld %lld", &n, &x, &y) != EOF) {
        memset(mat.det, 0, sizeof(mat.det)); x %= mod; y %= mod;
        mat.det[0][0] = mat.det[2][1] = 1;
        mat.det[0][1] = mat.det[1][1] = (x * x) % mod;
        mat.det[0][2] = mat.det[1][2] = (y * y) % mod;
        mat.det[0][3] = mat.det[1][3] = (2 * x * y) % mod;
        mat.det[3][1] = x; mat.det[3][3] = y;
        ans.det[0][0] = 2;
        for (int i = 1; i < 4; ++i) { ans.det[i][0] = 1; }
        solve(n - 1); printf("%lld
", ans.det[0][0]);
    }
    return 0;
}

12 HDU 4565 So Easy!

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <ext/rope>

using namespace std;
using namespace __gnu_cxx;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef pair<int, int> pii;

struct Matrix { ll det[2][2]; };
Matrix ans, mat;
ll a, b, n, mod;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 2; ++i) {
        for (int k = 0; k < 2; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 2; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%lld %lld %lld %lld", &a, &b, &n, &mod) != EOF) {
        if (n == 1) { printf("%lld
", (2 * a) % mod); continue; }
        ans.det[0][0] = a; ans.det[1][0] = 1;
        mat.det[0][0] = a; mat.det[0][1] = b;
        mat.det[1][0] = 1; mat.det[1][1] = a;
        solve(n - 1); ans.det[0][0] *= 2;  ans.det[0][0] %= mod;
        printf("%d
", ans.det[0][0]);
    }
    return 0;
}

13 HDU 5950 Recursive sequence

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <bitset>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9

typedef long long ll;
typedef pair<int, int> pii;

const int INF = 0x7fffffff;
struct Matrix { ll det[7][7]; };
const ll mod = 2147493647;
Matrix mat, ans;
int T;
ll n, a, b;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 7; ++i) {
        for (int k = 0; k < 7; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 7; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d", &T);
    while (T--) {
        scanf("%lld %lld %lld", &n, &a, &b);
        if (n == 1) { printf("%lld
", a); continue; }
        if (n == 2) { printf("%lld
", b); continue; }
        ans.det[0][0] = b; ans.det[1][0] = a; ans.det[2][0] = 16;
        ans.det[3][0] = 8; ans.det[4][0] = 4; ans.det[5][0] = 2; ans.det[6][0] = 1;
        memset(mat.det, 0, sizeof(mat.det));
        mat.det[0][0] = 1; mat.det[0][1] = 2; mat.det[0][2] = 1; mat.det[0][3] = 4;
        mat.det[0][4] = 6; mat.det[0][5] = 4; mat.det[0][6] = 1; mat.det[1][0] = 1;
        mat.det[2][2] = 1; mat.det[2][3] = 4; mat.det[2][4] = 6; mat.det[2][5] = 4;
        mat.det[2][6] = 1; mat.det[3][3] = 1; mat.det[3][4] = 3; mat.det[3][5] = 3;
        mat.det[3][6] = 1; mat.det[4][4] = 1; mat.det[4][5] = 2; mat.det[4][6] = 1;
        mat.det[5][5] = 1; mat.det[5][6] = 1; mat.det[6][6] = 1;
        solve(n - 2); printf("%lld
", ans.det[0][0]);
    }
    return 0;
}

---

1 POJ 3223 Matrix Power Series

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <bitset>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9

typedef long long ll;
typedef pair<int, int> pii;

const int INF = 0x7fffffff;

struct Matrix { ll det[60][60]; };
int n, k, mod;
Matrix ans, mat;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < n; ++i) {
        for (int k = 0; k < n; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < n; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(ans, mat); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d %d %d", &n, &k, &mod);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) { scanf("%lld", &mat.det[i][j]); }
        mat.det[i][n + i] = mat.det[n + i][n + i] = 1;
    }
    n *= 2; ++k; ans = mat;
    solve(k - 1); n /= 2;
    for (int i = 0; i < n; ++i) {
        --ans.det[i][n + i];
        if (ans.det[i][n + i] < 0) { ans.det[i][n + i] += mod; }
    }
    for (int i = 0; i < n; ++i) {
        for (int j = n; j < 2 * n - 1; ++j) { printf("%d ", ans.det[i][j]); }
        printf("%d
", ans.det[i][2 * n - 1]);
    }
    return 0;
}

---

1 FZU 1683 纪念SlingShot

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const ll mod = 2009;
int n, Case = 0, T;
struct Matrix { ll det[4][4]; };
Matrix ans, mat;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 4; ++i) {
        for (int k = 0; k < 4; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 4; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d", &T);
    while (T--) {
        scanf("%d", &n); printf("Case %d: ", ++Case);
        if (n == 0) { printf("1
"); continue; }
        if (n == 1) { printf("4
"); continue; }
        if (n == 2) { printf("9
"); continue; }
        ans.det[0][0] = 9; ans.det[1][0] = 5;
        ans.det[2][0] = 3; ans.det[3][0] = 1;
        memset(mat.det, 0, sizeof(mat.det));
        mat.det[0][0] = mat.det[2][1] = mat.det[3][2] = 1;
        mat.det[0][1] = mat.det[1][1] = 3;
        mat.det[0][2] = mat.det[1][2] = 2;
        mat.det[0][3] = mat.det[1][3] = 7;
        solve(n - 2); printf("%lld
", ans.det[0][0]);
    }
    return 0;
}

2 FZU 1692 Key problem

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int maxn = 110;
struct Matrix { ll det[100][100]; };
Matrix mat, unit;
int T, n, m, l, r, mod;
ll ans[maxn], a[maxn];

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int k = 0; k < n; ++k) {
        for (int j = 0; j < n; ++j) {
            ret.det[0][j] = (ret.det[0][j] + x.det[0][k] * y.det[k][j]) % mod;
        }
    }
    for (int i = 1; i < n; ++i) {
        ret.det[i][0] = ret.det[i - 1][n - 1];
        for (int j = 1; j < n; ++j) {
            ret.det[i][j] = ret.det[i - 1][j - 1];
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { unit = mul(mat, unit); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d", &T);
    while (T--) {
        scanf("%d %d %d %d %d", &n, &m, &l, &r, &mod);
        for (int i = 0; i < n; ++i) { scanf("%lld", &a[i]); }
        memset(unit.det, 0, sizeof(unit.det));
        for (int i = 0; i < n; ++i) { unit.det[i][i] = 1; }
        memset(mat.det, 0, sizeof(mat.det));
        for (int i = 0; i < n; ++i) {
            mat.det[i][i] = 1;
            mat.det[i][(i + n - 1) % n] = r;
            mat.det[i][(i + 1) % n] = l;
        }
        solve(m); memset(ans, 0, sizeof(ans));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                ans[i] += a[j] * unit.det[i][j]; ans[i] %= mod;
            }
        }
        for (int i = 0; i < n; ++i) {
            printf(i == n - 1 ? "%lld
" : "%lld ", ans[i]);
        }
    }
    return 0;
}

---

1 Codeforces 185A Plant

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
struct Matrix { ll det[2][2]; };
Matrix mat, ans;
ll n;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 2; ++i) {
        for (int k = 0; k < 2; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 2; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    mat.det[0][0] = mat.det[1][1] = 3;
    mat.det[0][1] = mat.det[1][0] = 1;
    ans.det[0][0] = 1; scanf("%lld", &n);
    solve(n); printf("%lld
", ans.det[0][0]);
    return 0;
}

2 Codeforces 450B Jzzhu and Sequences

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
struct Matrix { ll det[2][2]; };
Matrix ans, mat;
ll n, x, y;

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < 2; ++i) {
        for (int k = 0; k < 2; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < 2; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%lld %lld %lld", &x, &y, &n);
    x = (x + mod) % mod; y = (y + mod) % mod;
    if (n == 1) { printf("%lld
", x); return 0; }
    if (n == 2) { printf("%lld
", y); return 0; }
    ans.det[0][0] = y; ans.det[1][0] = x;
    mat.det[0][0] = mat.det[1][0] = 1;
    mat.det[0][1] = -1;
    solve(n - 2); if (ans.det[0][0] < 0) { ans.det[0][0] += mod; }
    printf("%lld
", ans.det[0][0]);
    return 0;
}

3 Codeforces 691E Xor-sequences

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int maxn = 110;
struct Matrix { ll det[100][100]; };
Matrix ans, mat;
int n;
ll k;
ll a[maxn];
int cnt[maxn];

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < n; ++i) {
        for (int k = 0; k < n; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < n; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d %lld", &n, &k);
    for (int i = 0; i < n; ++i) { scanf("%lld", &a[i]); }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (__builtin_popcountll(a[i] ^ a[j]) % 3 == 0) { mat.det[i][j] = 1; ++cnt[i]; }
        }
    }
    for (int i = 0; i < n; ++i) { ans.det[i][0] = 1; }
    solve(k - 1); ll ret = 0;
    for (int i = 0; i < n; ++i) { ret += ans.det[i][0]; ret %= mod; }
    printf("%lld
", ret);
    return 0;
}

4 Codeforces 852B Neural Network country

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define SZ(x) ((int)x.size())
#define PI acos(-1.0)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int maxn = 1e6 + 10;
struct Matrix { ll det[100][100]; };
int n, l, m;
Matrix ans, mat;
int cnt[maxn], a[3][maxn];

Matrix mul(Matrix x, Matrix y) {
    Matrix ret; memset(ret.det, 0, sizeof(ret.det));
    for (int i = 0; i < m; ++i) {
        for (int k = 0; k < m; ++k) {
          if (x.det[i][k] == 0) { continue; }
            for (int j = 0; j < m; ++j) {
                ret.det[i][j] = (ret.det[i][j] + x.det[i][k] * y.det[k][j]) % mod;
            }
        }
    }
    return ret;
}
void solve(ll x) {
    while (x) {
        if (x & 1) { ans = mul(mat, ans); }
        mat = mul(mat, mat); x >>= 1;
    }
}
void cal() {
    memset(mat.det, 0, sizeof(mat.det));
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < m; ++j) {
            mat.det[i][j] = cnt[(m + i - j) % m];
        }
    }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d %d %d", &n, &l, &m);
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < n; ++j) { scanf("%d", &a[i][j]); }
    }
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; ++i) { ++cnt[a[0][i]]; }
    for (int i = 0; i < m; ++i) { ans.det[i][0] = cnt[(i + 1) % m]; }
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; ++i) { ++cnt[a[1][i]]; } cal();
    solve(l - 2); memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; ++i) { ++cnt[(a[1][i] + a[2][i]) % m]; }
    cal(); ans = mul(mat, ans); printf("%lld
", ans.det[m - 1][0]);
    return 0;
}

---