Codeforces Round #259 (Div. 1) D. Little Pony and Elements of Harmony FWT

最新推荐文章于 2023-02-04 15:35:33 发布
最新推荐文章于 2023-02-04 15:35:33 发布
阅读量170 收藏 1
点赞数
分类专栏： # 多项式 CodeForces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46173805/article/details/119386533
版权

D. Little Pony and Elements of Harmony

在这里插入图片描述

solution

e i [ u ] = ∑ v e i − 1 [ v ] ∗ b [ f ( u , v ) ] . e_i[u]=\sum_{v}e_{i-1}[v]*b[f(u,v)]. ei​[u]=v∑​ei−1​[v]∗b[f(u,v)].

设 c n t [ u ⊕ v ] = b [ f ( u ⊕ v ) ] cnt[u⊕v]=b[f(u⊕v)] cnt[u⊕v]=b[f(u⊕v)]，有：

e i [ u ] = ∑ v e i − 1 [ v ] ∗ c n t [ u ⊕ v ] . e_i[u]=\sum_{v}e_{i-1}[v]*cnt[u⊕v]. ei​[u]=v∑​ei−1​[v]∗cnt[u⊕v].

设 k = u ⊕ v k=u⊕v k=u⊕v，则：

e i [ u ] = ∑ v = u ⊕ k e i − 1 [ v ] ∗ c n t [ k ] . e_i[u]=\sum_{v=u⊕k}e_{i-1}[v]*cnt[k]. ei​[u]=v=u⊕k∑​ei−1​[v]∗cnt[k]. e i − 1 [ u ] = ∑ v = u ⊕ k e i − 2 [ v ] ∗ c n t [ k ] . e_{i-1}[u]=\sum_{v=u⊕k}e_{i-2}[v]*cnt[k]. ei−1​[u]=v=u⊕k∑​ei−2​[v]∗cnt[k]. . . . ... ... e 2 [ u ] = ∑ v = u ⊕ k e 1 [ v ] ∗ c n t [ k ] . e_2[u]=\sum_{v=u⊕k}e_{1}[v]*cnt[k]. e2​[u]=v=u⊕k∑​e1​[v]∗cnt[k].

= = > ==> ==>

e t [ u ] = ∑ v = u ⊕ k e 0 [ v ] ∗ c n t [ k ] t . e_t[u]=\sum_{v=u⊕k}e_{0}[v]*cnt[k]^t. et​[u]=v=u⊕k∑​e0​[v]∗cnt[k]t.

预处理 c n t [ k ] cnt[k] cnt[k].

code

/*SiberianSquirrel*//*CuteKiloFish*/
#include <bits/stdc++.h>
//#include<bits/extc++.h>
#include<ext/rope>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
#define gcd(a,b) __gcd(a,b)
#define Inv(x) quick_pow(x, mod - 2)
#define Polynomial vector<int>
#define DEBUG(x, y) cout << x << ": " << y << '\n';
#define mem(a, x) memset(a, x, sizeof a)
#define right_1_pos(x) __builtin_ffs(x)
#define left_0_num(x) __builtin_clz(x)
#define right_0_num(x) __builtin_ctz(x)
#define num_of_1(x) __builtin_popcount(x)
#define Pii pair<int, int>
#define mp_(x, y) make_pair(x, y)
tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> tr;
/*rb_tree_tag 和 splay_tree_tag 选择树的类型(红黑树和伸展树)
null_type//无映射（g++为null_mapped_type）*/
using ld = long double;
using ll = long long;
//using ill = __int128;
using ull = unsigned long long;
using i16 = short;
const ld pi = acos(-1.0);
//const ll mod = 998244353, mod_g = 3, img = 86583718;
ll mod, mod_g = 3, img = 86583718;
int inv2, inv3;
//-----------------------------------------------------------------IO Template
namespace StandardIO {
    template<typename T> inline void read(T &x) {
        x = 0; T f = 1;
        char c = getchar();
        for (; c < '0' || c > '9'; c = getchar()) if (c == '-') f = -1;
        for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - '0';
        x *= f;
    }

    template<typename T> inline void write(T x) {
        if (x < 0) putchar('-'), x *= -1;
        if (x >= 10) write(x / 10);
        putchar(x % 10 + '0');
    }
}
using namespace StandardIO;
// -------------------------------------------------------------------------------BASIC_MATH
namespace BASIC_MATH {
    ll mul(ll a, ll b) { ll z = (long double) a / mod * b; ll res = (unsigned long long) a * b - (unsigned long long) z * mod; return (res + mod) % mod; }
    // O(1) quick_mul, use long double
    inline ll quick_pow(ll ans, ll p, ll res = 1) {
        for(; p; p >>= 1, ans = mul(ans, ans) % mod)
            if(p & 1) res = mul(res, ans) % mod;
        return res % mod;
    }
}
using namespace BASIC_MATH;
// -------------------------------------------------------------------------------PRIME
namespace PRIME {
    int prime[int(7e5 + 10)], cnt;
    bool vis[int(7e6 + 10)];
    void get_prime(int n) {
        for (int i = 2; i <= n; ++i) {
            if (!vis[i]) prime[++cnt] = i;
            for (int j = 1; j <= cnt && prime[j] * i <= n; ++j) {
                vis[i * prime[j]] = true;
                if (i % prime[j] == 0) break;
            }
        }
    }
}
//using namespace PRIME;
// -------------------------------------------------------------------------------SOSDP
const int bit = 20;
const int mx = 1 << bit | 1;
void sosdp(vector<int> &a, vector<int> &dp, int n) {
//    for(int i = 0; i <= n; ++ i) dp[i] = 0;
    for(int i = n; i >= 0; ++ i) {
        for(int j = 0; j < bit; ++ j) {
            if((i | (1 << j)) > n) continue;
            dp[i] = (dp[i] + dp[i | (1 << j)]) % mod;
        }
    }
}
// -------------------------------------------------------------------------------PRUFER
namespace FWT {
    inline void OR(ll *f, int n, int x = 1) {
        for (int o = 2; o <= n; o <<= 1) {
            for (int i = 0, k = o >> 1; i < n; i += o) {
                for (int j = 0; j < k; ++j) {
                    f[i + j + k] = (f[i + j + k] + f[i + j] * x % mod + (x == 1 ? 0 : mod)) % mod;
                }
            }
        }
    }
    inline void AND(ll *f, int n, int x = 1) {
        for (int o = 2; o <= n; o <<= 1) {
            for (int i = 0, k = o >> 1; i < n; i += o) {
                for (int j = 0; j < k; ++j) {
                    f[i + j] = (f[i + j] + f[i + j + k] * x + (x == 1 ? 0 : mod)) % mod;
                }
            }
        }
    }
    inline void XOR(ll *f, int n, int x = 1) {
        for (int o = 2; o <= n; o <<= 1) {
            for (int i = 0, k = o >> 1; i < n; i += o) {
                for (int j = 0; j < k; ++j) {
                    f[i + j] += f[i + j + k],
                    f[i + j + k] = f[i + j] - f[i + j + k] - f[i + j + k],
                    f[i + j] *= x, f[i + j + k] *= x;
                    f[i + j] %= mod;
                    f[i + j + k] %= mod;
                    while (f[i + j] < 0) f[i + j] += mod;
                    while (f[i + j + k] < 0) f[i + j + k] += mod;
                }
            }
        }
    }
    inline void OR(vector<ll> &f, int n, int x = 1) {
        for (int o = 2; o <= n; o <<= 1) {
            for (int i = 0, k = o >> 1; i < n; i += o) {
                for (int j = 0; j < k; ++j) {
                    f[i + j + k] = (f[i + j + k] + f[i + j] * x % mod + (x == 1 ? 0 : mod)) % mod;
                }
            }
        }
    }
    inline void AND(vector<ll> &f, int n, int x = 1) {
        for (int o = 2; o <= n; o <<= 1) {
            for (int i = 0, k = o >> 1; i < n; i += o) {
                for (int j = 0; j < k; ++j) {
                    f[i + j] = (f[i + j] + f[i + j + k] * x + (x == 1 ? 0 : mod)) % mod;
                }
            }
        }
    }
    inline void XOR(vector<ll> &f, int n, int x = 1) {
        for (int o = 2; o <= n; o <<= 1) {
            for (int i = 0, k = o >> 1; i < n; i += o) {
                for (int j = 0; j < k; ++ j) {
                    ll X = f[i + j], Y = f[i + j + k];
                    f[i + j] = (X + Y) % mod;
                    f[i + j + k] = ((X - Y) % mod + mod) % mod;
                    // mod is a prime
//                    if(x != 1) {
//                        f[i + j] = f[i + j] * inv2 % mod;
//                        f[i + j + k] = f[i + j + k] * inv2 % mod;
//                    }
                }
            }
        }
        // mod is not a prime, let mod = mod * (1 << m), n = 1 << m;
         if(x != 1) for(int i = 0; i < n; ++ i) {
             f[i] /= n;
         }
    }
}
using namespace FWT;
// -------------------------------------------------------------------------------FWT
namespace PRUFER {
    int n;
    int d[int(5e6 + 10)], f[int(5e6 + 10)], p[int(5e6 + 10)];
    void TtoP() {
        for(int i = 1, j = 1; i <= n - 2; ++ i, ++ j) {
            while(d[j]) ++ j;
            p[i] = f[j];
            while(i <= n - 2 && -- d[p[i]] == 0 && p[i] < j)
                p[i + 1] = f[p[i]], ++ i;
        }
    }
    void PtoT() {
        p[n - 1] = n;
        for(int i = 1, j = 1; i <= n - 1; ++ i, ++ j) {
            while(d[j]) ++ j;
            f[j] = p[i];
            while(i <= n - 1 &&  -- d[p[i]] == 0 && p[i] < j)
                f[p[i]] = p[i + 1], ++ i;
        }
    }
}
//using namespace PRUFER;
// -------------------------------------------------------------------------------MATRIX
namespace MATRIX {
    struct Matrix {
        static const int M = 2;
        double mx[M][M];

        Matrix() { memset(mx, 0, sizeof mx); }

        void Out() {
            for (auto &i : mx) {
                for (auto j : i)
                    cout << j << ' ';
                cout << endl;
            }
        }

        void Tranfer_E() {
            memset(mx, 0, sizeof mx);
            for (int i = 0; i < M; ++i) mx[i][i] = 1;
        }

        Matrix operator*(const struct Matrix a) const {
            Matrix x;
            memset(x.mx, 0, sizeof x.mx);
            for (int i = 0; i < M; ++i)
                for (int j = 0; j < M; ++j)
                    for (int k = 0; k < M; ++k)
                        x.mx[i][j] = (x.mx[i][j] + mx[i][k] * a.mx[k][j]);
            return x;
        }
    };
    Matrix mat_pow(Matrix mx, int p) {
        Matrix res;
        res.Tranfer_E();
        for (; p; p >>= 1, mx = mx * mx)
            if (p & 1) res = res * mx;
        return res;
    }
}
//using namespace MATRIX;
// -------------------------------------------------------------------------------MODINT
namespace MODINT {
    template<unsigned M_> struct ModInt {
        static constexpr unsigned M = M_;
        unsigned x;

        constexpr ModInt() : x(0U) {}

        constexpr ModInt(unsigned x_) : x(x_ % M) {}

        constexpr ModInt(unsigned long long x_) : x(x_ % M) {}

        constexpr ModInt(int x_) : x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {}

        constexpr ModInt(long long x_) : x(
                ((x_ %= static_cast<long long>(M)) < 0) ? (x_ + static_cast<long long>(M)) : x_) {}

        ModInt &operator+=(const ModInt &a) {
            x = ((x += a.x) >= M) ? (x - M) : x;
            return *this;
        }

        ModInt &operator-=(const ModInt &a) {
            x = ((x -= a.x) >= M) ? (x + M) : x;
            return *this;
        }

        ModInt &operator*=(const ModInt &a) {
            x = (static_cast<unsigned long long>(x) * a.x) % M;
            return *this;
        }

        ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }

        ModInt quick_pow(long long e) const {
            if (e < 0) return inv().quick_pow(-e);
            ModInt a = *this, b = 1U;
            for (; e; e >>= 1) {
                if (e & 1) b *= a;
                a *= a;
            }
            return b;
        }

        ModInt inv() const {
            unsigned a = M, b = x;
            int y = 0, z = 1;
            for (; b;) {
                const unsigned q = a / b;
                const unsigned c = a - q * b;
                a = b;
                b = c;
                const int w = y - static_cast<int>(q) * z;
                y = z;
                z = w;
            }
            assert(a == 1U);
            return ModInt(y);
        }

        ModInt operator+() const { return *this; }

        ModInt operator-() const {
            ModInt a;
            a.x = x ? (M - x) : 0U;
            return a;
        }

        ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }

        ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }

        ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }

        ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }

        template<class T>
        friend ModInt operator+(T a, const ModInt &b) { return (ModInt(a) += b); }

        template<class T>
        friend ModInt operator-(T a, const ModInt &b) { return (ModInt(a) -= b); }

        template<class T>
        friend ModInt operator*(T a, const ModInt &b) { return (ModInt(a) *= b); }

        template<class T>
        friend ModInt operator/(T a, const ModInt &b) { return (ModInt(a) /= b); }

        explicit operator bool() const { return x; }

        bool operator==(const ModInt &a) const { return (x == a.x); }

        bool operator!=(const ModInt &a) const { return (x != a.x); }

        friend std::ostream &operator<<(std::ostream &os, const ModInt &a) { return os << a.x; }
    };
    constexpr unsigned MO = 998244353;
    using Mint = ModInt<MO>;
}
//using namespace MODINT;
// -------------------------------------------------------------------------------NTT
namespace NTT_ {
    Polynomial R;
//二进制向上取整，为方便NTT变换准备。
    inline int Binary_Rounding(const int &n) {
        int len = 1;
        while (len < n) len <<= 1;
        return len;
    }
//预处理R数组，准备变换，在每次NTT之前理论都要调用此函数。
    inline int Prepare_Transformation(int n) {
        int L = 0, len;
        for (len = 1; len < n; len <<= 1) L++;
        R.clear();
        R.resize(len);
        for (int i = 0; i < len; ++i)
            R[i] = (R[i >> 1] >> 1) | ((i & 1) << (L - 1));
        return len;
    }
    inline void NTT(Polynomial &a, int f) {
        int n = a.size();
        for (int i = 0; i < n; ++i)
            if (i < R[i])swap(a[i], a[R[i]]);
        for (int i = 1; i < n; i <<= 1)
            for (int j = 0, gn = quick_pow(mod_g, (mod - 1) / (i << 1)); j < n; j += (i << 1))
                for (int k = 0, g = 1, x, y; k < i; ++k, g = 1ll * g * gn % mod)
                    x = a[j + k], y = 1ll * g * a[i + j + k] % mod,
                    a[j + k] = (x + y) % mod, a[i + j + k] = (x - y + mod) % mod;
        if (f == -1) {
            reverse(a.begin() + 1, a.end());
            int inv = Inv(n);
            for (int i = 0; i < n; ++i) a[i] = 1ll * a[i] * inv % mod;
        }
    }
    inline Polynomial operator+(const Polynomial &a, const int &b) {
        int sizea = a.size();
        Polynomial ret = a;
        ret.resize(sizea);
        for (int i = 0; i < sizea; ++i)ret[i] = (1ll * a[i] + b + mod) % mod;
        return ret;
    }
    inline Polynomial operator-(const Polynomial &a, const int &b) {
        int sizea = a.size();
        Polynomial ret = a;
        ret.resize(sizea);
        for (int i = 0; i < sizea; ++i)ret[i] = (1ll * a[i] - b + mod) % mod;
        return ret;
    }
    inline Polynomial operator*(const Polynomial &a, const int &b) {
        int sizea = a.size();
        Polynomial ret = a;
        ret.resize(sizea);
        for (int i = 0; i < sizea; ++i) ret[i] = (1ll * a[i] * b % mod + mod) % mod;
        return ret;
    }
    inline Polynomial operator+(const Polynomial &a, const Polynomial &b) {
        int sizea = a.size(), sizeb = b.size(), size = max(sizea, sizeb);
        Polynomial ret = a;
        ret.resize(size);
        for (int i = 0; i < sizeb; ++i) ret[i] = (1ll * ret[i] + b[i]) % mod;
        return ret;
    }
    inline Polynomial operator-(const Polynomial &a, const Polynomial &b) {
        int sizea = a.size(), sizeb = b.size(), size = max(sizea, sizeb);
        Polynomial ret = a;
        ret.resize(size);
        for (int i = 0; i < sizeb; ++i) ret[i] = (1ll * ret[i] - b[i] + mod) % mod;
        return ret;
    }
    inline Polynomial Inverse(const Polynomial &a) {
        Polynomial ret, inv_a;
        ret.resize(1);
        ret[0] = Inv(a[0]);
        int ed = a.size();
        for (int len = 2; len <= ed; len <<= 1) {
            int n = Prepare_Transformation(len << 1);
            inv_a = a;
            inv_a.resize(n);
            ret.resize(n);
            for (int i = len; i < n; ++i) inv_a[i] = 0;
            NTT(inv_a, 1);
            NTT(ret, 1);
            for (int i = 0; i < n; ++i)
                ret[i] = 1ll * (2ll - 1ll * inv_a[i] * ret[i] % mod + mod) % mod * ret[i] % mod;
            NTT(ret, -1);
            for (int i = len; i < n; ++i) ret[i] = 0;
        }
        ret.resize(ed);
        return ret;
    }
    inline Polynomial operator*(const Polynomial &a, const Polynomial &b) {
        Polynomial lsa = a, lsb = b, ret;
        int n = lsa.size(), m = lsb.size();
        n = Prepare_Transformation(n + m);
        lsa.resize(n);
        lsb.resize(n);
        ret.resize(n);
        NTT(lsa, 1);
        NTT(lsb, 1);
        for (int i = 0; i < n; ++i) ret[i] = 1ll * lsa[i] * lsb[i] % mod;
        NTT(ret, -1);
        return ret;
    }
    inline Polynomial operator/(const Polynomial &a, const Polynomial &b) {
        Polynomial ret = a, ls = b;
        reverse(ret.begin(), ret.end());
        reverse(ls.begin(), ls.end());
        ls.resize(Binary_Rounding(a.size() + b.size()));
        ls = Inverse(ls);
        ls.resize(a.size() + b.size());
        ret = ret * ls;
        ret.resize(a.size() - b.size() + 1);
        reverse(ret.begin(), ret.end());
        return ret;
    }
    inline Polynomial operator%(const Polynomial &a, const Polynomial &b) {
        Polynomial ret = a / b;
        ret = ret * b;
        ret.resize(a.size() + b.size());
        ret = a - ret;
        ret.resize(a.size() + b.size());
        return ret;
    }
    inline Polynomial Derivation(const Polynomial &a) {
        int size = a.size();
        Polynomial ret;
        ret.resize(size);
        for (int i = 1; i < size; ++i) ret[i - 1] = 1ll * i * a[i] % mod;
        ret[size - 1] = 0;
        return ret;
    }
    inline Polynomial Integral(const Polynomial &a) {
        int size = a.size();
        Polynomial ret;
        ret.resize(size);
        for (int i = 1; i < size; ++i) ret[i] = 1ll * Inv(i) * a[i - 1] % mod;
        ret[0] = 0;
        return ret;
    }
    inline Polynomial Composition_Inverse(const Polynomial &a) {
        int n = a.size();
        Polynomial ret, Cinv = a, Pow;
        Cinv.resize(n);
        ret.resize(n);
        Pow.resize(n);
        Pow[0] = 1;
        for (int i = 0; i < n - 1; ++i) Cinv[i] = Cinv[i + 1];
        Cinv[n - 1] = 0;
        Cinv = Inverse(Cinv);
        for (int i = 1; i < n; ++i) {
            Pow = Pow * Cinv;
            Pow.resize(n);
            ret[i] = 1ll * Pow[i - 1] * Inv(i) % mod;
        }
        return ret;
    }
    inline Polynomial Logarithmic(const Polynomial &a) {
        Polynomial ln_a = Derivation(a) * Inverse(a);
        ln_a.resize(a.size());
        return Integral(ln_a);
    }
    inline Polynomial Exponential(const Polynomial &a, int Constant = 1) {
        Polynomial ret, D;
        int ed = a.size();
        ret.resize(1);
        ret[0] = Constant;
        for (int len = 2; len <= ed; len <<= 1) {
            D = Logarithmic(ret);
            D.resize(len);
            D[0] = (1ll * a[0] + 1ll - D[0] + mod) % mod;
            for (int i = 1; i < len; ++i) D[i] = (1ll * a[i] - D[i] + mod) % mod;
            int n = Prepare_Transformation(len << 1);
            ret.resize(n);
            D.resize(n);
            NTT(ret, 1);
            NTT(D, 1);
            for (int i = 0; i < n; ++i) ret[i] = 1ll * ret[i] * D[i] % mod;
            NTT(ret, -1);
            for (int i = len; i < (len << 1); ++i) ret[i] = D[i] = 0;
        }
        ret.resize(ed);
        return ret;
    }
}
//using namespace NTT_;

inline void solve() {
//    inv2 = Inv(2);
    ll m, t, p; cin >> m >> t >> p; ll n = 1 << m; mod = p * n;
    vector<ll> e(n | 1), b(n | 1), cnt(n | 1);
    for(int i = 0; i < n; ++ i) {
        cin >> e[i]; e[i] %= mod;
    }
    for(int i = 0; i < m + 1; ++ i) {
        cin >> b[i]; b[i] %= mod;
    }
    for(int i = 0; i < n; ++ i) {
        cnt[i] = b[num_of_1(i)];
    }
    XOR(cnt, n), XOR(e, n);
    for(int i = 0; i < n; ++ i) {
        cnt[i] = quick_pow(cnt[i], t);
        e[i] = mul(e[i], cnt[i]);
    }
    XOR(e, n, -1);
    for(int i = 0; i < n; ++ i) {
        cout << e[i] << '\n';
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
    signed test_index_for_debug = 1;
    char acm_local_for_debug = 0;
    do {
        if (acm_local_for_debug == '$') exit(0);
        if (test_index_for_debug > 20)
            throw runtime_error("Check the stdin!!!");
        auto start_clock_for_debug = clock();
        solve();
        auto end_clock_for_debug = clock();
        cout << "Test " << test_index_for_debug << " successful!" << endl;
        cerr << "Test " << test_index_for_debug++ << " Run Time: "
             << double(end_clock_for_debug - start_clock_for_debug) / CLOCKS_PER_SEC << "s" << endl;
        cout << "--------------------------------------------------" << endl;
    } while (cin >> acm_local_for_debug && cin.putback(acm_local_for_debug));
#else
    solve();
#endif
    return 0;
}
西伯利亚松鼠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
FFT/NTT解决字符匹配问题
qq_35577488的博客
03-22 392
参考博客 前言： 这题跟之前一道湖南对抗赛的题很像。都是FFT加速优化.这也是我第一道FFT的题目. FFT/NTT 该算法有四个精髓点： 1.将系数表示法转化为点值表示法。 2.利用函数奇偶对称性+分治+引入复数域单位根实现快速求nnn个点值. 3.利用矩阵的逆将点值表示法转化成系数表示法. 4.根据逆矩阵的特征继续跑一遍FFT.(IFFT) NTT:在模意义下的快速变化.将单位根换成原根进行运算.其他一致.由于避免了浮点运算.速度快于FFT. 题目大意: 给你两个二进制字符串S,TS,TS,T.问你最少
线性代数学习之向量空间，维度，和四大子空间
webor2006的博客
01-31 1万+
空间： 在上一次https://www.cnblogs.com/webor2006/p/14306046.html学习了诸多在线性代数中非常核心的概念(线性组合、线性相关、线性无关、生成空间，空间的基...)，这次则继续学习重要的核心概念(空间、维度、四大子空间)。在之前的学习中用到了很多的“空间”这俩词，比如二维空间、三维空间，n维空间，但是一直还木有严谨的对它进行定义，而数学又是一门非常讲究...
多项式全家桶
weixin_34163553的博客
04-09 60
Include 多项式乘法（* *=） 多项式求逆（~ Inv） 多项式除法（/） 多项式取模（%） 多项式对数函数（Ln） 多项式指数函数（Exp） 多项式正弦函数（Cos） 多项式余弦函数（Sin） upda：2019.4.28： 对于任意模数NTT全部适用。 位于：namespaceFastFourierTransform 开启方法： 1.取消...
51nod1059 算10万阶乘
iiiv__viii的博客
06-03 975
链接：51nod1059 给个数n求n阶乘准确值，n最大10万，会大整数知道100阶乘就很多了，普通大数乘法运算，1秒1万已经极限了，4秒求10万阶乘不可能，所以要考虑优化大数乘法，对于位数比较多的乘法用NTT或者FFT(事实上之后测试以及其他高手数学论证，FFT浮点数误差在大数乘法里可以忽略(代码里用+0.1转换)，且FFT比NTT快一点，FFT浮点数运算，但是FTT总运算次数少抵消了浮点数运...
Codeforces Round #142 Div.2 题解
Fuko_Ibuki的博客
09-06 1万+
A B C D E A 打n条龙,龙的攻击力xi,打死每条龙攻击力加yi,你的初始攻击力是s. 如果你的攻击力小于或者等于某条龙的攻击力你就死了. 问你能不能活着回去. 每次贪心打攻击力最小的龙,将龙排序既可. #include&lt;bits/stdc++.h&gt; //Ithea Myse Valgulious using namespace std; co...
Codeforces Round #469 div.2 A-D 思路及题解
热门推荐
Fuko_Ibuki的博客
03-09 1万+
其实这场我差点就掉分了 A B C D 其实这场我差点就掉分了 简直了.一上来A题,我说这题很水的,我用二分搞一下求稳.结果二分写挂了.然后我暴力枚举并判断,又挂了.最后我不得不O(1)O(1)O(1)出答案,一分钟标算就出来了.我都做了什么…… B题尺取法一搞就稳了.然后C题我差点就骂人了.D题我觉得自己能写出来,然后推了半天,放弃了.我又回去搞C题,终于在离比赛结束还有...
Codeforces Round #849 (Div. 4)
NEFU AB-IN's Blog
02-04 1447
A, B, C, D, E, F, G1
Codeforces Round #804 (Div. 2)题解
Euphria的博客
07-06 596
cf题解
Codeforces Round #803 (Div. 2) 题解
Euphria的博客
06-29 873
题解
Codeforces Round #758 (Div.1 + Div. 2)
weixin_45446715的博客
12-13 1611
Codeforces Round #758 (Div.1 + Div. 2) Problem A & Problem B & (Problem C) A. Find Array 从来都没有见过一个如此水的 Div 1 A题 就是让你从小到大的输出n个数字 唯一要注意的就是a[i]的取值范围 #include<bits/stdc++.h> using namespace std; int main(){ int t; cin>>t; while(t--){ i
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include #include #include #include #include #include #include #include #include #define pb push_back ...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
传送门 题意： 一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到...
Codeforces Round #635 (Div. 2)D. Xenia and Colorful Gems
01-03
传说门 刚好今晚是中国场！ 其实这道题比较水，但当时思路错，一心想着化简公式，浪费了好多时间a.a 题意：三个数组，求(x-y)(x-y)+(x-z)(x-z)+(y-z)*(y-z)的最小值 题解：6nlogn，先sort三个数组a,b,c, 六次枚举二...
2018 Yandex.Algorithm - Qualification Round C. Beautiful Tables 数学
qq_46173805的博客
03-26 1226
C. Beautiful Tables code /*Siberian Squirrel*/ /*Cute JinFish*/ #include<bits/stdc++.h> using namespace std; typedef long long ll; const double PI = acos(-1), eps = 1e-8; /*const int MOD = 998244353, r = 119, k = 23, g = 3; const int MOD = 100453580
Codeforces Round #701 (Div. 2) C. Floor and Mod codeforces 思维 + 数学
qq_46173805的博客
02-13 852
input 9 3 4 2 100 4 3 50 3 12 4 69 420 12345 6789 123456 789 12345678 9 output 1 0 2 3 5 141 53384 160909 36 solution 要想使x/i=x%i，有x/i=x%i=i−1，从1开始遍历即可，对于i最小符合的值为(i∗(i+2),i+1)，只需比较x，y中哪个“较小”即可，详情见代码要想使x/i=x\%i，有x/i=x\%i=i-1，从1开始遍历即可，对于i最小符合的值为(i*(i+2),i+1)，
Codeforces Global Round 14 D. Phoenix and Socks 思维
qq_46173805的博客
05-03 827
D. Phoenix and Socks solution 除去相同颜色的已配对袜子，剩余袜子遍历颜色考虑： 当前l总大于r总且a[i][0]>1，则只需一次把l变成r的费用当前l_总大于r_总且a[i][0]>1，则只需一次把l变成r的费用当前l总​大于r总​且a[i][0]>1，则只需一次把l变成r的费用 当前r总大于l总且a[i][1]>1，则只需一次把r变成l的费用当前r_总大于l_总且a[i][1]>1，则只需一次把r变成l的费用当前r总​大于l总​且a[i][1
Codeforces Global Round 1 C. Meaningless Operations 数学
qq_46173805的博客
03-26 809
C. Meaningless Operations code /*Siberian Squirrel*/ /*Cute JinFish*/ #include<bits/stdc++.h> using namespace std; typedef long long ll; const double PI = acos(-1), eps = 1e-8; /*const int MOD = 998244353, r = 119, k = 23, g = 3; const int MOD = 100
codeforces round #801 (div. 2) and epic institute of technology round
最新发布
04-06
b&#39;codeforces round #801 (div. 2) and epic institute of technology round&#39; 意思为：Codeforces # 801（div.2）比赛和Epic Institute of Technology Round。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值