Codeforces 1197F Coloring Game 矩阵快速幂 (看题解)

Coloring Game

我写的复杂度是 1000 * 64 * 64 * 64 * log(1e9),  感觉这个东西是很好想的, 肯定是T了的。

其实可以优化掉一个64, 就是在转移的时候用64 * 64的矩阵和 64 * 1的答案相邻相乘,

这样就可以优化掉一个64了, 以前好像没有见过这种小技巧。

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
#include<bits/stdc++.h>
#define LL long long
#define LD long double
#define ull unsigned long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ALL(x) (x).begin(), (x).end()
#define fio ios::sync_with_stdio(false); cin.tie(0);

using namespace std;

const int N = 1000 + 7;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;
const double PI = acos(-1);

template<class T, class S> inline void add(T &a, S b) {a += b; if(a >= mod) a -= mod;}
template<class T, class S> inline void sub(T &a, S b) {a -= b; if(a < 0) a += mod;}
template<class T, class S> inline bool chkmax(T &a, S b) {return a < b ? a = b, true : false;}
template<class T, class S> inline bool chkmin(T &a, S b) {return a > b ? a = b, true : false;}

const int MN = 64;

struct Vec {
    int a[MN];
    Vec() {
        for(int i = 0; i < MN; i++) {
            a[i] = 0;
        }
    }
};

struct Matrix {
    int a[MN][MN];
    Matrix(int v = 0) {
        for(int i = 0; i < MN; i++) {
            for(int j = 0; j < MN; j++) {
                a[i][j] = (i == j) ? v : 0;
            }
        }
    }
    inline Matrix operator * (const Matrix &B) const {
        Matrix C(0);
        for(int i = 0; i < MN; i++) {
            for(int k = 0; k < MN; k++) {
                if(!a[i][k]) continue;
                for(int j = 0; j < MN; j++) {
                    C.a[i][j] += 1LL * a[i][k] * B.a[k][j] % mod;
                    if(C.a[i][j] >= mod) C.a[i][j] -= mod;
                }
            }
        }
        return C;
    }
    Vec operator * (const Vec &B) const {
        Vec C;
        for(int i = 0; i < MN; i++) {
            for(int j = 0; j < MN; j++) {
                add(C.a[i], 1LL *  a[i][j] * B.a[j] % mod);
            }
        }
        return C;
    }
} M[30], M2[4];

int n, m, a[N];
int ret[N][4];
vector<PII> V[N];

int f[4][4];
int dp[N][4];
bool vis[4];
int v[3];

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    scanf("%d", &m);
    for(int i = 1; i <= m; i++) {
        int x, y, c;
        scanf("%d%d%d", &x, &y, &c);
        V[x].push_back(mk(y, c));
    }
    for(int i = 1; i <= n; i++) {
        sort(ALL(V[i]));
    }

    for(int i = 1; i <= n; i++) {
        V[i].push_back(mk(a[i] + 1, 1));
    }

    for(int i = 1; i <= 3; i++) {
        for(int j = 1; j <= 3; j++) {
            scanf("%d", &f[i][j]);
        }
    }

    for(int mask = 0; mask < MN; mask++) {
        for(int i = 0; i < 3; i++) {
            v[i] = mask >> (i * 2) & 3;
        }
        for(int color = 1; color <= 3; color++) {
            memset(vis, 0, sizeof(vis));
            if(f[color][1]) vis[v[0]] = true;
            if(f[color][2]) vis[v[1]] = true;
            if(f[color][3]) vis[v[2]] = true;
            int sg = -1;
            for(int i = 0; i < 4; i++) {
                if(!vis[i]) {
                    sg = i;
                    break;
                }
            }
            int nmask = sg + (v[0] << 2) + (v[1] << 4);
            add(M[0].a[nmask][mask], 1);
            add(M2[color].a[nmask][mask], 1);
        }
    }

    for(int i = 1; i < 30; i++) {
        M[i] = M[i - 1] * M[i - 1];
    }

    for(int i = 1; i <= n; i++) {
        Vec tmp; tmp.a[63] = 1;
        int last = 0;
        for(auto &t : V[i]) {
            int cnt = t.fi - last - 1;
            for(int j = 0; j < 30; j++) {
                if(cnt >> j & 1) {
                    tmp = M[j] * tmp;
                }
            }
            if(t.fi != a[i] + 1) {
                tmp = M2[t.se] * tmp;
            }
            last = t.fi;
        }
        for(int j = 0; j < MN; j++) {
            add(ret[i][j & 3], tmp.a[j]);
        }
    }
    dp[0][0] = 1;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < 4; j++) {
            for(int k = 0; k < 4; k++) {
                add(dp[i + 1][j ^ k], 1LL * dp[i][j] * ret[i + 1][k] % mod);
            }
        }
    }
    printf("%d\n", dp[n][0]);
    return 0;
}

/*
*/

原文地址:https://www.cnblogs.com/CJLHY/p/11235124.html

时间: 2024-10-11 10:27:01

Codeforces 1197F Coloring Game 矩阵快速幂 (看题解)的相关文章

Codeforces 576D Flights for Regular Customers 矩阵快速幂 (看题解)

Flights for Regular Customers 临接矩阵的 k 次 就是 恰好 走 k 步从 i 走到 j 的方案数, 方案数在这里并不关键, 所以可以把它变成01矩阵. 一个很直观的想法是用二分取check它, 但是这并不单调.. 然后就不会了.. 我们可以把G[ n - 1] [ n - 1 ] 变成  1 , 这个函数就变成单调了, 然后直接二分check就好了, 可以用bitset优化一下, 不优化其实也能过. 还有一种方法就是, 每新加入一条边, 我们暴力跑一遍图取chec

CodeForces 185A. Plant(矩阵快速幂)

题目链接:http://codeforces.com/problemset/problem/185/A Dwarfs have planted a very interesting plant, which is a triangle directed "upwards". This plant has an amusing feature. After one year a triangle plant directed "upwards" divides int

codeforces 691E Xor-sequences(矩阵快速幂)

引自:http://www.cnblogs.com/shuguangzw/p/5674089.html /* *********************************************** Author :devil ************************************************ */ #include <cstdio> #include <cstring> #include <iostream> #include &l

POJ——3070Fibonacci(矩阵快速幂)

Fibonacci Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 12329   Accepted: 8748 Description In the Fibonacci integer sequence, F0 = 0, F1 = 1, and Fn = Fn − 1 + Fn − 2 for n ≥ 2. For example, the first ten terms of the Fibonacci sequenc

Codeforces Round #291 (Div. 2) E - Darth Vader and Tree (DP+矩阵快速幂)

这题想了好长时间,果断没思路..于是搜了一下题解.一看题解上的"快速幂"这俩字,不对..这仨字..犹如醍醐灌顶啊...因为x的范围是10^9,所以当时想的时候果断把dp递推这一方法抛弃了.我怎么就没想到矩阵快速幂呢.......还是太弱了..sad..100*100*100*log(10^9)的复杂度刚刚好. 于是,想到了矩阵快速幂后,一切就变得简单了.就可以把距离<=x的所有距离的点数都通过DP推出来,然后一个快速幂就解决了. 首先DP递推式很容易想到.递推代码如下: for(

【矩阵快速幂 】Codeforces 450B - Jzzhu and Sequences (公式转化)

[题目链接]click here~~ [题目大意] Jzzhu has invented a kind of sequences, they meet the following property: You are given x and y, please calculate fn modulo1000000007(109?+?7). [解题思路] /*A - Jzzhu and Sequences Codeforces 450B - Jzzhu and Sequences ( 矩阵快速幂 )

Codeforces Round #257 (Div. 2) B. Jzzhu and Sequences (矩阵快速幂)

题目链接:http://codeforces.com/problemset/problem/450/B 题意很好懂,矩阵快速幂模版题. 1 /* 2 | 1, -1 | | fn | 3 | 1, 0 | | fn-1 | 4 */ 5 #include <iostream> 6 #include <cstdio> 7 #include <cstring> 8 using namespace std; 9 typedef __int64 LL; 10 LL mod =

Xor-sequences CodeForces - 691E || 矩阵快速幂

Xor-sequences CodeForces - 691E 题意:在有n个数的数列中选k个数(可以重复选,可以不按顺序)形成一个数列,使得任意相邻两个数异或的结果转换成二进制后其中1的个数是三的倍数.求可能形成的不同数列个数(只要选出的数列中,任意两个元素在原序列中的位置不同,就算作不同的序列,比如在原数列[1,1]中选1个,那么第一个1和第二个1要分开算). 方法: 很容易列出dp方程: dp[k][i]表示取了k个,最后一个在第i位.a[i][j]表示i和j异或结果转换成二进制后1的个数

[递推+矩阵快速幂]Codeforces 1117D - Magic Gems

传送门:Educational Codeforces Round 60 – D 题意: 给定N,M(n <1e18,m <= 100) 一个magic gem可以分裂成M个普通的gem,现在需要N个gem,可以选择一定的magic gem,指定每一个分裂或不分裂,问一共有多少种方案 两种分裂方案不同当且仅当magic gem的数量不同,或者分裂的magic gem的索引不同. 思路: 1.首先从dp的角度出发 设F(i)为最终需要i个gem的方案数,容易得到递推式: (总方案数 = 最右边的m