結果

問題 No.2001 Distanced Triple
ユーザー 👑 KazunKazun
提出日時 2022-05-15 15:36:03
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 2 ms / 2,000 ms
コード長 3,373 bytes
コンパイル時間 2,051 ms
コンパイル使用メモリ 201,784 KB
実行使用メモリ 6,944 KB
最終ジャッジ日時 2024-09-20 20:20:19
合計ジャッジ時間 3,371 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,816 KB
testcase_01 AC 2 ms
6,944 KB
testcase_02 AC 2 ms
6,940 KB
testcase_03 AC 2 ms
6,940 KB
testcase_04 AC 2 ms
6,944 KB
testcase_05 AC 2 ms
6,940 KB
testcase_06 AC 2 ms
6,940 KB
testcase_07 AC 2 ms
6,940 KB
testcase_08 AC 2 ms
6,940 KB
testcase_09 AC 2 ms
6,940 KB
testcase_10 AC 2 ms
6,944 KB
testcase_11 AC 2 ms
6,940 KB
testcase_12 AC 2 ms
6,940 KB
testcase_13 AC 2 ms
6,944 KB
testcase_14 AC 2 ms
6,944 KB
testcase_15 AC 2 ms
6,944 KB
testcase_16 AC 2 ms
6,940 KB
testcase_17 AC 2 ms
6,944 KB
testcase_18 AC 2 ms
6,940 KB
testcase_19 AC 2 ms
6,940 KB
testcase_20 AC 1 ms
6,940 KB
testcase_21 AC 2 ms
6,940 KB
testcase_22 AC 2 ms
6,940 KB
testcase_23 AC 2 ms
6,940 KB
testcase_24 AC 1 ms
6,944 KB
testcase_25 AC 2 ms
6,940 KB
testcase_26 AC 2 ms
6,940 KB
testcase_27 AC 2 ms
6,944 KB
testcase_28 AC 2 ms
6,940 KB
testcase_29 AC 2 ms
6,940 KB
testcase_30 AC 2 ms
6,940 KB
testcase_31 AC 2 ms
6,940 KB
testcase_32 AC 2 ms
6,944 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<bits/stdc++.h>

using namespace std;
using ll=long long;

template<const int mod>
struct modint{
    int64_t a;

    public:
        // 初期化
        modint (): a(0){}
        modint (int64_t a): a((a%mod+mod)%mod) {}

        // マイナス元
        modint operator-() const { return modint(-a);}

        // 加法
        modint& operator+=(const modint &y){
            if ((a+=y.a)>=mod) a-=mod;
            return *this;
        }

        modint operator+(const modint &y) const { return modint(*this)+=y;}
        modint& operator+=(const int64_t &b) { return (*this)+=modint<mod>(b);}
        modint operator+(const int64_t b) const { return modint(*this)+=b;}

        // 減法
        modint& operator-=(const modint &y){
            if ((a+=mod-y.a)>=mod) a-=mod;
            return *this;
        }

        modint operator-(const modint &y) const { return modint(*this)-=y;}
        modint& operator-=(const int64_t &b) { return (*this)-=modint<mod>(b);}
        modint operator-(const int64_t b) const { return modint(*this)-=b;}

        // 乗法
        modint& operator*=(const modint &y){
            (a*=y.a)%=mod;
            return *this;
        }

        modint operator*(const modint &y) const { return modint(*this)*=y;}
        modint& operator*=(const int64_t &b) {return (*this)*=modint<mod>(b);}
        modint operator*(const int64_t b) const { return modint(*this)*=b;}

        // 除法
        modint& operator/=(const modint &y){
            return (*this)*=y.inverse();
        }

        modint operator/(const modint &y) const { return modint(*this)/=y;}
        modint& operator/=(const int64_t &b) { return (*this)/=modint<mod>(b);}
        modint operator/(const int64_t b) const { return modint(*this)/=b;}

        // モジュラー逆元
        modint inverse() const{
            int64_t s=1,t=0,u;
            int64_t x=a,y=mod;
            while (y){
                auto q=x/y,r=x%y;
                x=y; y=r;
                u=s-q*t;
                s=t; t=u;
            }
            assert(x==1);

            modint res(s);
            return res;
        }

        // 比較
        bool operator==(const modint &y) const { return (a==y.a);}
        bool operator==(const int64_t &b) const { return ((a-b)%mod==0);}

        bool operator!=(const modint &y) const { return !(a==y);}
        bool operator!=(const int64_t &b) const { return !(a==b);}

        // 入力
        friend istream &operator>>(istream &is, modint &x) {is >> x.a; return (is);}

        // 出力
        friend ostream &operator<<(ostream &os, const modint &x) { return os << x.a;}
};

template<const int mod>
modint<mod> operator+(const int64_t &a, const modint<mod> x){
    return modint<mod>((a%mod)+x.a);
}

template<const int mod>
modint<mod> operator-(const int64_t &a, const modint<mod> x){
    return modint<mod>((a%mod)-x.a);
}
template<const int mod>
modint<mod> operator*(const int64_t &a, const modint<mod> x){
    return modint<mod>((a%mod)*x.a);
}

using modint998244353=modint<998244353>;

modint998244353 solve(ll L, ll R, ll A, ll B, ll C){
    ll C2=max(0LL,C-A-B), D=R+1-(L+A+B+C2);

    if (D<0) {return modint998244353();}

    modint998244353 c2(C2), d(D);
    return d*(d+1)*(3*c2+d+2)/6;
}

int main(){
    ll L,R,A,B,C;
    cin >> L >> R >> A >> B >> C;
    cout << solve(L,R,A,B,C) << endl;
}
0