日常刷题2025-2-21

合集 - 日常刷题(44)

1.日常刷题2025-3-1603-162.日常训练2025-1-201-023.日常训练2025-1-301-034.日常训练2025-1-501-055.日常训练2025-1-801-086.日常训练2025-1-1101-117.日常训练2025-1-1201-128.日常训练2025-1-1301-139.日常训练2025-1-1401-1410.日常训练2025-1-1501-1511.日常训练2025-1-1601-1612.日常训练2025-1-1701-1713.日常训练2025-1-1801-1814.日常训练2025-1-1901-1915.日常训练2025-1-2101-2116.日常训练2025-1-2201-2217.日常刷题2025-1-2301-2318.日常训练2025-1-2401-2419.日常刷题2025-1-2501-2520.日常刷题02-0121.日常刷题2025-2-602-0622.日常刷题2025-2-902-0923.日常刷题2025-2-1402-1424.日常刷题2025-2-1502-1525.日常刷题2025-2-1702-1726.日常刷题2025-2-2002-20

27.日常刷题2025-2-2102-21

28.日常刷题2025-2-2202-2229.日常刷题2025-2-2402-2430.日常刷题2025-2-2602-2631.日常刷题2025-2-2702-2732.日常刷题2025-2-2802-2833.日常刷题2025-3-103-0134.日常刷题2025-3-203-0235.日常刷题2025-3-303-0336.日常刷题2025-3-503-0537.日常刷题2025-3-603-0638.日常刷题2025-3-703-0739.日常刷题2025-3-803-0840.日常刷题2025-3-903-0941.日常刷题2025-3-1003-1042.日常刷题2023-3-1103-1143.日常刷题2025-3-1303-1344.非常棒的二分和DP03-15

收起

日常刷题2025-2-21

C. Beautiful Sequence子序列计数问题

https://codeforces.com/contest/2069/problem/C

思路：线性DP

子序列计数的问题是一类典型的dp，我回头专门讲一下。大概就是：求子序列的DP，一般对于某个元素可以区分：选/不选，来做。求两个子序列可以区分：不选/选进序列1/选进序列2，三种转移。

代码

#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
 
#if !defined(ONLINE_JUDGE) && defined(LOCAL)
#include "helper.h"
#else
#define dbg(...) ;
#define local_go_m(x) int c;cin>>c;while(c--)x()
#endif
 
constexpr int M = 998244353;
 
template<class T>
constexpr T power(T a, i64 b) {
    T res = 1;
    for (; b != 0; b /= 2, a *= a) {
        if (b & 1) {
            res *= a;
        }
    }
    return res;
}
 
template<int M>
struct ModInt {
public:
    constexpr ModInt() : x(0) {}
 
    template<std::signed_integral T>
    constexpr ModInt(T x_) {
        T v = x_ % M;
        if (v < 0) {
            v += M;
        }
        x = v;
    }
 
    constexpr int val() const {
        return x;
    }
 
    constexpr ModInt operator-() const {
        ModInt res;
        res.x = (x == 0 ? 0 : M - x);
        return res;
    }
 
    constexpr ModInt inv() const {
        return power(*this, M - 2);
    }
 
    constexpr ModInt &operator*=(const ModInt &rhs) &{
        x = i64(x) * rhs.val() % M;
        return *this;
    }
 
    constexpr ModInt &operator+=(const ModInt &rhs) &{
        x += rhs.val();
        if (x >= M) {
            x -= M;
        }
        return *this;
    }
 
    constexpr ModInt &operator-=(const ModInt &rhs) &{
        x -= rhs.val();
        if (x < 0) {
            x += M;
        }
        return *this;
    }
 
    constexpr ModInt &operator/=(const ModInt &rhs) &{
        return *this *= rhs.inv();
    }
 
    friend constexpr ModInt operator*(ModInt lhs, const ModInt &rhs) {
        lhs *= rhs;
        return lhs;
    }
 
    friend constexpr ModInt operator+(ModInt lhs, const ModInt &rhs) {
        lhs += rhs;
        return lhs;
    }
 
    friend constexpr ModInt operator-(ModInt lhs, const ModInt &rhs) {
        lhs -= rhs;
        return lhs;
    }
 
    friend constexpr ModInt operator/(ModInt lhs, const ModInt &rhs) {
        lhs /= rhs;
        return lhs;
    }
 
    friend constexpr std::istream &operator>>(std::istream &is, ModInt &a) {
        i64 i;
        is >> i;
        a = i;
        return is;
    }
 
    friend constexpr std::ostream &operator<<(std::ostream &os, const ModInt &a) {
        return os << a.val();
    }
 
    friend constexpr std::strong_ordering operator<=>(ModInt lhs, ModInt rhs) {
        return lhs.val() <=> rhs.val();
    }
 
private:
    int x;
};
 
using Z = ModInt<M>;
 
template<typename T>
struct Comb {
    std::vector<T> fac;
    std::vector<T> facInv;
    int n;
 
    Comb(int n_) {
        n = n_;
        fac.assign(n, T{});
        facInv.assign(n, T{});
        fac[0] = 1;
        for (int i = 1; i < n; i++) {
            fac[i] = fac[i - 1] * i;
        }
        for (int i = 0; i < n; i++) {
            facInv[i] = fac[i].inv();
        }
    }
};
 
constexpr int COMB_N = 300300;
Comb<Z> comb(COMB_N);
 
template<std::signed_integral T>
Z P(T n, T m) {
    assert(n >= 0 && m >= 0 && m <= n);
    if (n < comb.n) {
        return comb.fac[n] * comb.facInv[n - m];
    } else {
        T v = n, rnd = m;
        Z res = 1;
        while (rnd--) {
            res *= v--;
        }
        return res;
    }
}
 
template<std::signed_integral T>
Z C(T n, T m) {
    return P(n, m) * comb.facInv[m];
}
 
void go() {
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    vector<Z> f(n, 0);
    int c1 = 0;
    Z res = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] == 1) {
            if (i) f[i] = f[i - 1];
            c1++;
        } else if (a[i] == 3) {
            if (i) f[i] = f[i - 1];
            res += f[i];
        } else {
            if (i) f[i] = f[i - 1] * 2;
            f[i] += c1;
        }
    }
    dbg(f);
    cout << res << endl;
}
 
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    local_go_m(go);
    return 0;
}