提出 #68598104

---

ソースコード 拡げる

//  ↘ ⬇ ⬇ ⬇ ⬇ ⬇ ↙
//  ➡ @roadfromroi ⬅
//  ↗ ⬆ ⬆ ⬆ ⬆ ⬆ ↖
/*
░░░░░░░█▐▓▓░████▄▄▄█▀▄▓▓▓▌█
░░░░░▄█▌▀▄▓▓▄▄▄▄▀▀▀▄▓▓▓▓▓▌█
░░░▄█▀▀▄▓█▓▓▓▓▓▓▓▓▓▓▓▓▀░▓▌█
░░█▀▄▓▓▓███▓▓▓███▓▓▓▄░░▄▓▐█▌
░█▌▓▓▓▀▀▓▓▓▓███▓▓▓▓▓▓▓▄▀▓▓▐█
▐█▐██▐░▄▓▓▓▓▓▀▄░▀▓▓▓▓▓▓▓▓▓▌█▌
█▌███▓▓▓▓▓▓▓▓▐░░▄▓▓███▓▓▓▄▀▐█
█▐█▓▀░░▀▓▓▓▓▓▓▓▓▓██████▓▓▓▓▐█
▌▓▄▌▀░▀░▐▀█▄▓▓██████████▓▓▓▌█▌
▌▓▓▓▄▄▀▀▓▓▓▀▓▓▓▓▓▓▓▓█▓█▓█▓▓▌█▌
█▐▓▓▓▓▓▓▄▄▄▓▓▓▓▓▓█▓█▓█▓█▓▓▓▐█ йоу
 */
#include <iostream>
#include "queue"
#include "vector"
#include "algorithm"
#include "numeric"
#include "climits"
#include "iomanip"
#include "bitset"
#include "cmath"
#include "map"
#include "deque"
#include "array"
#include "set"
#include "random"
#ifndef __APPLE__
#include "bits/stdc++.h"
#endif
#define all(x) x.begin(), x.end()
using namespace std;

template<int M>
struct modint {
    modint() : x(0) {}

    template<class T>
    modint(T n) {
        n %= M;
        if (n < 0) n += M;
        this->x = n;
    }

    modint &operator+=(const modint &r) {
        x += r.x;
        if (x >= M) x -= M;
        return *this;
    }

    modint &operator-=(const modint &r) {
        x -= r.x;
        if (x < 0) x += M;
        return *this;
    }

    modint &operator*=(const modint &r) {
        x = (int) ((long long) x * r.x % M);
        return *this;
    }

    modint &operator--() {
        if (--x == -1) x = M - 1;
        return *this;
    }

    modint &operator++() {
        if (++x == M) x = 0;
        return *this;
    }

    modint operator--(int) {
        modint t = *this;
        --*this;
        return t;
    }

    modint operator++(int) {
        modint t = *this;
        ++*this;
        return t;
    }

    modint operator-() const { return 0 - *this; }

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

    modint power(long long k = M - 2) const {
        modint f = 1, p = *this;
        while (k > 0) {
            if (k & 1) f *= p;
            p *= p, k >>= 1;
        }
        return f;
    }

    int mod() const { return M; }

    friend modint operator+(modint l, const modint &r) { return l += r; }

    friend modint operator-(modint l, const modint &r) { return l -= r; }

    friend modint operator*(modint l, const modint &r) { return l *= r; }

    friend bool operator==(const modint &l, const modint &r) { return l.x == r.x; }

    friend bool operator!=(const modint &l, const modint &r) { return l.x != r.x; }

    friend ostream &operator<<(ostream &out, const modint &r) { return out << r.x; }

    int x;
};

// using mint = modint<1000000007>;
using mint = modint<998244353>;
mint dps(int n, vector<int> a, vector<int> b, int r) {
    vector<vector<mint>> dp(n + 1, vector<mint>(n + 1));
    vector<vector<int>> dpval(n + 1, vector<int>(n + 1));
    dpval[n][n] = r;
    dp[n][n] = 1;
    for (int i = n; i >= 0; --i) {
        for (int j = n; j >= 0; --j) {
            if (i < j)
                continue;
            if (i + 1 <= n) {
                dpval[i][j] = dpval[i + 1][j] + a[i];
            } else if (j + 1 <= n) {
                dpval[i][j] = dpval[i][j + 1] - b[j];
            }
            if (dpval[i][j] >= 0) {
                if (i + 1 <= n) {
                    dp[i][j] += dp[i + 1][j];
                }
                if (j + 1 <= n) {
                    dp[i][j] += dp[i][j + 1];
                }
                //cout << i << ' ' << j << ' ' << dp[i][j] << '\n';
            }
        }
    }
    return dp[0][0];
}

void solve() {
    int n, l, r;
    cin >> n >> l >> r;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    vector<int> b(n);
    for (int i = 0; i < n; ++i) {
        cin >> b[i];
    }
    //cout << dps(n, a, b, l-1);
    cout << dps(n, a, b, r) - dps(n, a, b, l-1) << '\n';
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }
}

/*
2 2 50
3 4 0 1 1 0 1 1
4 5 1 2 1 1 1 2
 */

提出情報

ジャッジ結果