#include #define REP_(i, a_, b_, a, b, ...) \ for (int i = (a), END_##i = (b); i < END_##i; ++i) #define REP(i, ...) REP_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__) #define ALL(x) std::begin(x), std::end(x) using i64 = long long; #include using Mint = atcoder::modint998244353; std::ostream &operator<<(std::ostream &os, const Mint &m) { return os << m.val(); } template inline bool chmax(T &a, U b) { return a < b and ((a = std::move(b)), true); } template inline bool chmin(T &a, U b) { return a > b and ((a = std::move(b)), true); } template inline int ssize(const T &a) { return (int) a.size(); } template inline std::ostream &print_one(const T &x, char endc) { if constexpr (std::is_same_v) { return std::cout << (x ? "Yes" : "No") << endc; } else { return std::cout << x << endc; } } template inline std::ostream &print(const T &x) { return print_one(x, '\n'); } template std::ostream &print(const T &head, Ts... tail) { return print_one(head, ' '), print(tail...); } inline std::ostream &print() { return std::cout << '\n'; } template std::ostream &print_seq(const Container &a, std::string_view sep = " ", std::string_view ends = "\n", std::ostream &os = std::cout) { auto b = std::begin(a), e = std::end(a); for (auto it = std::begin(a); it != e; ++it) { if (it != b) os << sep; os << *it; } return os << ends; } template struct is_iterable : std::false_type {}; template struct is_iterable())), decltype(std::end(std::declval()))>> : std::true_type { }; template::value && !std::is_same::value>> std::ostream &operator<<(std::ostream &os, const T &a) { return print_seq(a, ", ", "", (os << "{")) << "}"; } struct VersatileInput { template operator T() const { T x; std::cin >> x; return x; } struct Sized { std::size_t n; template operator T() const { T x(n); for (auto &e: x) std::cin >> e; return x; } }; Sized operator()(std::size_t n) const { return {n}; } } const in; inline void check(bool cond, const char *message = "!ERROR!") { if (not cond) throw std::runtime_error(message); } #ifdef MY_DEBUG #include "debug_dump.hpp" #else #define DUMP(...) #define cerr if(false)std::cerr #endif using namespace std; template struct Factorials { // factorials and inverse factorials. std::vector fact, ifact; // n: max cached value. Factorials(int n) : fact(n + 1), ifact(n + 1) { fact[0] = 1; for (int i = 1; i <= n; ++i) { fact[i] = fact[i - 1] * i; } ifact[n] = fact[n].inv(); for (int i = n; i >= 1; --i) { ifact[i - 1] = ifact[i] * i; } } // Combination (nCk) T C(int n, int k) const { if (k < 0 || k > n) return 0; return fact[n] * ifact[k] * ifact[n - k]; } }; template std::vector pow_seq(int n, int base = 2) { std::vector p(n + 1); p[0] = 1; for (int i = 0; i < n; ++i) { p[i + 1] = p[i] * base; } return p; } auto solve() { const int n = in, m = in, K = in; string X = in; Factorials fs(n); auto dp = vector(2, vector(n + 1, Mint(0))); dp[0][n] = 1; auto pow2 = pow_seq(n); auto ccum = vector(n + 1, Mint(0)); for (int i = K; i <= n; ++i) { Mint s = 0; for (int j = 0; j < K; ++j) { s += fs.C(i, j); } ccum[i] = s * pow2[n - i]; } REP(i, m) { if (X[i] == '1') { REP(j, K, n + 1) { if (dp[0][j].val() == 0 or ccum[j].val() == 0) continue; dp[1][j] += dp[0][j] * ccum[j]; } } else { REP(j, K, n + 1) { if (dp[0][j].val() == 0) continue; auto q = dp[0][j] * pow2[n - j]; for (int j2 = j; j2 >= K; --j2) { dp[1][j2] += q * fs.C(j, j2); } } } dp[0].swap(dp[1]); dp[1].assign(n + 1, 0); } Mint ans = 0; for (int i = K; i <= n; ++i) { ans += dp[0][i]; } return ans; } int main() { ios_base::sync_with_stdio(false), cin.tie(nullptr); cout << std::fixed << std::setprecision(18); const int T = 1;//in; REP(t, T) { auto ans = solve(); print(ans); } }