結果

問題 No.1111 コード進行
ユーザー tonakaitonakai
提出日時 2020-07-10 21:53:29
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 661 ms / 2,000 ms
コード長 7,035 bytes
コンパイル時間 2,025 ms
コンパイル使用メモリ 203,736 KB
実行使用メモリ 262,692 KB
最終ジャッジ日時 2024-10-11 08:58:08
合計ジャッジ時間 14,908 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 176 ms
50,304 KB
testcase_01 AC 175 ms
50,304 KB
testcase_02 AC 175 ms
50,304 KB
testcase_03 AC 176 ms
50,184 KB
testcase_04 AC 176 ms
50,304 KB
testcase_05 AC 180 ms
53,120 KB
testcase_06 AC 183 ms
54,912 KB
testcase_07 AC 183 ms
54,144 KB
testcase_08 AC 178 ms
51,456 KB
testcase_09 AC 178 ms
53,248 KB
testcase_10 AC 184 ms
56,576 KB
testcase_11 AC 177 ms
51,684 KB
testcase_12 AC 184 ms
54,912 KB
testcase_13 AC 180 ms
53,688 KB
testcase_14 AC 191 ms
57,328 KB
testcase_15 AC 182 ms
50,952 KB
testcase_16 AC 186 ms
55,676 KB
testcase_17 AC 187 ms
56,960 KB
testcase_18 AC 180 ms
51,456 KB
testcase_19 AC 178 ms
51,456 KB
testcase_20 AC 179 ms
52,736 KB
testcase_21 AC 177 ms
50,304 KB
testcase_22 AC 189 ms
59,136 KB
testcase_23 AC 185 ms
53,284 KB
testcase_24 AC 183 ms
54,144 KB
testcase_25 AC 190 ms
58,368 KB
testcase_26 AC 182 ms
54,656 KB
testcase_27 AC 175 ms
51,584 KB
testcase_28 AC 329 ms
156,160 KB
testcase_29 AC 243 ms
93,440 KB
testcase_30 AC 293 ms
120,320 KB
testcase_31 AC 192 ms
62,152 KB
testcase_32 AC 290 ms
112,384 KB
testcase_33 AC 266 ms
90,880 KB
testcase_34 AC 290 ms
125,952 KB
testcase_35 AC 320 ms
147,072 KB
testcase_36 AC 392 ms
154,752 KB
testcase_37 AC 230 ms
75,264 KB
testcase_38 AC 221 ms
68,608 KB
testcase_39 AC 332 ms
119,296 KB
testcase_40 AC 368 ms
145,596 KB
testcase_41 AC 358 ms
167,660 KB
testcase_42 AC 280 ms
97,064 KB
testcase_43 AC 271 ms
91,200 KB
testcase_44 AC 212 ms
72,084 KB
testcase_45 AC 293 ms
120,760 KB
testcase_46 AC 174 ms
50,912 KB
testcase_47 AC 661 ms
262,692 KB
testcase_48 AC 177 ms
51,020 KB
testcase_49 AC 175 ms
51,064 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
#define endl "\n"
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define uniq(v) v.erase(unique(v.begin(),v.end()),v.end())
#define lb(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define ub(v,x) (upper_bound(v.begin(),v.end(),x)-v.begin())
using Pair = pair<ll,pair<int,int>>;
#define pq priority_queue<Pair, vector<Pair>, greater<Pair>> 
const ll mod=1000000007;
//const ll mod=998244353;
const ld pi=acos(-1.0);
const ll INF = 1LL<<61;
template<class T>bool chmax(T &a, const T &b) { 
  if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) {
  if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
//intの最大値2147483647 ≒ 2×10^9
//long longの最大値9223372036854775807 ≒ 9×10^18
//'大文字'+=32;    で小文字に
//  cout << fixed << setprecision (20);   小数点以下2０桁まで
//実行時間制約2秒では２×10^8回くらいまで計算できる


//——————————————————modint———————————————————————————


#define MAX 2000000  // 階乗をいくつまで計算するか
 
class mint {
    ll val;
    static ll *invs, *facts, *finvs;
 
    // 階乗, 逆元, 階乗の逆元をMAXまで求める
    bool initMint() {
        invs[1] = 
        facts[0] = facts[1] =
        finvs[0] = finvs[1] = 1;
        for (int i=2; i<=MAX; i++) {
            invs[i]  = -invs[MOD % i] * (MOD / i) % MOD;
            facts[i] = facts[i - 1] * i % MOD;
            finvs[i] = finvs[i - 1] * invs[i] % MOD;
        }
        return true;
    }
 
public:
    static ll MOD; // modの元
 
    // 初期化 値を引数に与えなかった場合はval=0としておく
    mint(ll init = 0) : val(init) {
        static bool call_once = initMint(); // static変数の性質により一度だけ呼ばれる
        assert(call_once); // unusedの回避
        if (val < 0 || val >= MOD) val %= MOD;
        if (val < 0) val += MOD;   // 0以上であることを保証
    }
 
    inline ll toll() { return this->val; }
 
    // 代入
    void operator=(const mint &r) { this->val = r.val; }
    void operator=(const ll &r) { *this = mint(r); }
 
    // 足し算; 符号反転; 引き算
    mint operator+(const mint &r) {
        ll ans = this->val + r.val;
        if (ans >= MOD) ans -= MOD;
        return mint(ans);
    }
    mint operator-() {
        ll ans = MOD - this->val;
        return mint(ans);
    }
    mint operator-(const mint &r) {
        mint rr = r;
        return *this + (-rr);
    }
 
    //かけ算; 逆元; わり算
    mint operator*(const mint &r) {
        ll ans = this->val * r.val;
        return mint(ans);
    }
    mint inv() {
        assert(this->val != 0);
        if (this->val == 1) return mint(1);
 
        mint p, q = *this, m(0), n(1), r, c;
        p.val = MOD;
        while (q.val > MAX) {
            r = p.val % q.val;
            c = m.val - n.val * (p.val / q.val);
            p = q, q = r, m = n, n = c;
        }
        return n * invs[q.val];
    }
    mint operator/(const mint &r) { return *this * mint(r).inv(); }
    mint operator%(const mint &r) { return mint(this->val % r.val); }
 
    // ++ -- 前付きと後ろ付き
    void operator++() { ++this->val; }
    void operator++(int a) {
        a = 0;
        this->val++;
    }
    void operator--() { --this->val; }
    void operator--(int a) {
        a = 0;
        this->val--;
    }
 
    // 四則演算&代入
    void operator+=(const mint &r) { *this = *this + r; }
    void operator-=(const mint &r) { *this = *this - r; }
    void operator*=(const mint &r) { *this = *this * r; }
    void operator/=(const mint &r) { *this = *this / r; }
    void operator%=(const mint &r) { *this = *this % r; }
 
    // べき乗
    mint pow(long n) {
        if (n < 0)
            return inv().pow(-n);  // 逆元の-n乗
        else if (n == 0)
            return mint(1);
 
        mint half = pow(n / 2);
        if (n % 2)
            return *this * half * half;
        else
            return half * half;
    }
    mint pow(mint n) { return pow(n.val); }
 
    // 順列
    mint per(mint _k) {
        assert(this->val <= MAX);
        const ll n = this->val, k = _k.val;
        if (k < 0 || k > n) return 0;
        if (k == 0) return 1;
        if (k == n) return facts[n];
        return mint(facts[n]) * finvs[n - k];
    }

    // コンビネーション
    mint com(mint _k) {
        assert(this->val <= MAX);
        const ll n = this->val, k = _k.val;
        if (k < 0 || k > n) return 0;
        if (k == 0 || k == n) return 1;
        return mint(facts[n]) * finvs[k] * finvs[n - k];
    }
 
    // 階乗
    mint fact() { 
        assert(this->val <= MAX);
        return mint(facts[this->val]);
    }
 
    friend bool operator<(const mint &l, const mint &r) { return l.val < r.val; }
    friend bool operator>(const mint &l, const mint &r) { return l.val > r.val; }
    friend bool operator==(const mint &l, const mint &r) { return l.val == r.val; }
    friend bool operator!=(const mint &l, const mint &r) { return !(l.val == r.val); }
    friend bool operator<=(const mint &l, const mint &r) { return !(l.val > r.val); }
    friend bool operator>=(const mint &l, const mint &r) { return !(l.val < r.val); }
 
    friend ostream &operator<<(ostream &os, const mint &out) {
        os << out.val;
        return os;
    }
    friend istream &operator>>(istream &is, mint &in) {
        ll inl;
        is >> inl;
        in.val = inl % mint::MOD;
        return is;
    }
};
 
// べき乗
inline mint mpow(ll n, ll k) { return mint(n).pow(k); }
// 順列
inline mint mper(ll n, ll k) { return mint(n).per(k); }
// コンビネーション
inline mint mcom(ll n, ll k) { return mint(n).com(k); }
// 階乗
inline mint mfac(ll n) { return mint(n).fact(); }
 
// static変数
ll *mint::invs  = new ll[MAX+1];
ll *mint::facts = new ll[MAX+1];
ll *mint::finvs = new ll[MAX+1];
 
ll mint::MOD = (ll)1e9 + 7;

//—————————————————————————————————————————————————


int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);

  int n,m,z;
  cin>>n>>m>>z;

  vector<int> p(m);
  vector<int> q(m);
  vector<int> c(m);
  rep(i,m){
    cin>>p[i]>>q[i]>>c[i];
    p[i]--;q[i]--;
  }

  mint ans[n+1][300][z+1];
  memset(ans,0,sizeof(ans));

  rep(i,300){
    ans[1][i][0]=1;
  }

  repo(i,n){
    rep(j,m){
      rep(k,z+1){
        if(k+c[j]<=z) ans[i+1][q[j]][k+c[j]]+=ans[i][p[j]][k];
      }
    }
  }

  mint x=0;
  rep(i,300){
    x+=ans[n][i][z];
  }

  cout << x << endl;
}
0