QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#758279#9553. The Hermithos_lyricAC ✓56ms13324kbC++145.7kb2024-11-17 17:25:312024-11-17 17:25:37

Judging History

你现在查看的是测评时间为 2024-11-17 17:25:37 的历史记录

  • [2024-11-18 19:52:07]
  • 自动重测本题所有获得100分的提交记录
  • 测评结果:AC
  • 用时:60ms
  • 内存:13332kb
  • [2024-11-18 19:43:48]
  • hack成功,自动添加数据
  • (/hack/1196)
  • [2024-11-17 17:25:37]
  • 评测
  • 测评结果:100
  • 用时:56ms
  • 内存:13324kb
  • [2024-11-17 17:25:31]
  • 提交

answer

#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")

////////////////////////////////////////////////////////////////////////////////
template <unsigned M_> struct ModInt {
  static constexpr unsigned M = M_;
  unsigned x;
  constexpr ModInt() : x(0U) {}
  constexpr ModInt(unsigned x_) : x(x_ % M) {}
  constexpr ModInt(unsigned long long x_) : x(x_ % M) {}
  constexpr ModInt(int x_) : x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {}
  constexpr ModInt(long long x_) : x(((x_ %= static_cast<long long>(M)) < 0) ? (x_ + static_cast<long long>(M)) : x_) {}
  ModInt &operator+=(const ModInt &a) { x = ((x += a.x) >= M) ? (x - M) : x; return *this; }
  ModInt &operator-=(const ModInt &a) { x = ((x -= a.x) >= M) ? (x + M) : x; return *this; }
  ModInt &operator*=(const ModInt &a) { x = (static_cast<unsigned long long>(x) * a.x) % M; return *this; }
  ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }
  ModInt pow(long long e) const {
    if (e < 0) return inv().pow(-e);
    ModInt a = *this, b = 1U; for (; e; e >>= 1) { if (e & 1) b *= a; a *= a; } return b;
  }
  ModInt inv() const {
    unsigned a = M, b = x; int y = 0, z = 1;
    for (; b; ) { const unsigned q = a / b; const unsigned c = a - q * b; a = b; b = c; const int w = y - static_cast<int>(q) * z; y = z; z = w; }
    assert(a == 1U); return ModInt(y);
  }
  ModInt operator+() const { return *this; }
  ModInt operator-() const { ModInt a; a.x = x ? (M - x) : 0U; return a; }
  ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }
  ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }
  ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }
  ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }
  template <class T> friend ModInt operator+(T a, const ModInt &b) { return (ModInt(a) += b); }
  template <class T> friend ModInt operator-(T a, const ModInt &b) { return (ModInt(a) -= b); }
  template <class T> friend ModInt operator*(T a, const ModInt &b) { return (ModInt(a) *= b); }
  template <class T> friend ModInt operator/(T a, const ModInt &b) { return (ModInt(a) /= b); }
  explicit operator bool() const { return x; }
  bool operator==(const ModInt &a) const { return (x == a.x); }
  bool operator!=(const ModInt &a) const { return (x != a.x); }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &a) { return os << a.x; }
};
////////////////////////////////////////////////////////////////////////////////

constexpr unsigned MO = 998244353;
using Mint = ModInt<MO>;

constexpr int LIM_INV = 200'010;
Mint inv[LIM_INV], fac[LIM_INV], invFac[LIM_INV];

void prepare() {
  inv[1] = 1;
  for (int i = 2; i < LIM_INV; ++i) {
    inv[i] = -((Mint::M / i) * inv[Mint::M % i]);
  }
  fac[0] = invFac[0] = 1;
  for (int i = 1; i < LIM_INV; ++i) {
    fac[i] = fac[i - 1] * i;
    invFac[i] = invFac[i - 1] * inv[i];
  }
}
Mint binom(Int n, Int k) {
  if (n < 0) {
    if (k >= 0) {
      return ((k & 1) ? -1 : +1) * binom(-n + k - 1, k);
    } else if (n - k >= 0) {
      return (((n - k) & 1) ? -1 : +1) * binom(-k - 1, n - k);
    } else {
      return 0;
    }
  } else {
    if (0 <= k && k <= n) {
      assert(n < LIM_INV);
      return fac[n] * invFac[k] * invFac[n - k];
    } else {
      return 0;
    }
  }
}

////////////////////////////////////////////////////////////////////////////////


constexpr int E = 18;

int M, N;
Mint dp[E][100'010];

int main() {
  prepare();
  
  for (; ~scanf("%d%d", &M, &N); ) {
    memset(dp, 0, sizeof(dp));
    for (int x = 1; x <= M; ++x) dp[0][x] = 1;
    for (int k = 0; k + 1 < E; ++k) {
      for (int x = 1; x <= M; ++x) for (int y = 2 * x; y <= M; y += x) {
        dp[k + 1][y] += dp[k][x];
      }
    }
    
    Mint ans = 0;
    for (int k = 0; k < E; ++k) if (k + 2 <= N) {
      const int l = N - k - 2;
      // must remove x
      // can keep y
      for (int x = 1; x <= M; ++x) if (dp[k][x]) {
        for (int y = 2 * x; y <= M; y += x) {
// if(M<=4)cerr<<k<<" "<<x<<" "<<y<<": "<<dp[k][x]<<" "<<(binom(M/x - y/x, l) - binom(M/y - y/y, l))<<" "<<Mint(1 + l)<<endl;
          ans += dp[k][x] * (binom(M/x - y/x, l) - binom(M/y - y/y, l)) * Mint(1 + l);
        }
      }
    }
    {
      const int l = N - 1;
      for (int y = 1; y <= M; ++y) {
        ans += (binom(M/1 - y/1, l) - binom(M/y - y/y, l)) * Mint(1 + l);
      }
    }
    printf("%u\n", ans.x);
  }
  return 0;
}

这程序好像有点Bug,我给组数据试试?

詳細信息

Test #1:

score: 100
Accepted
time: 4ms
memory: 13244kb

input:

4 3

output:

7

result:

ok 1 number(s): "7"

Test #2:

score: 0
Accepted
time: 3ms
memory: 13244kb

input:

11 4

output:

1187

result:

ok 1 number(s): "1187"

Test #3:

score: 0
Accepted
time: 43ms
memory: 13172kb

input:

100000 99999

output:

17356471

result:

ok 1 number(s): "17356471"

Test #4:

score: 0
Accepted
time: 8ms
memory: 13164kb

input:

11451 1919

output:

845616153

result:

ok 1 number(s): "845616153"

Test #5:

score: 0
Accepted
time: 44ms
memory: 13292kb

input:

99998 12345

output:

936396560

result:

ok 1 number(s): "936396560"

Test #6:

score: 0
Accepted
time: 22ms
memory: 13160kb

input:

100000 1

output:

0

result:

ok 1 number(s): "0"

Test #7:

score: 0
Accepted
time: 53ms
memory: 13128kb

input:

100000 15

output:

190067060

result:

ok 1 number(s): "190067060"

Test #8:

score: 0
Accepted
time: 3ms
memory: 13188kb

input:

10 3

output:

299

result:

ok 1 number(s): "299"

Test #9:

score: 0
Accepted
time: 3ms
memory: 13164kb

input:

10 4

output:

743

result:

ok 1 number(s): "743"

Test #10:

score: 0
Accepted
time: 2ms
memory: 13168kb

input:

10 5

output:

1129

result:

ok 1 number(s): "1129"

Test #11:

score: 0
Accepted
time: 3ms
memory: 13252kb

input:

15 6

output:

28006

result:

ok 1 number(s): "28006"

Test #12:

score: 0
Accepted
time: 0ms
memory: 13108kb

input:

15 7

output:

42035

result:

ok 1 number(s): "42035"

Test #13:

score: 0
Accepted
time: 4ms
memory: 13244kb

input:

123 45

output:

214851327

result:

ok 1 number(s): "214851327"

Test #14:

score: 0
Accepted
time: 0ms
memory: 13184kb

input:

998 244

output:

964050559

result:

ok 1 number(s): "964050559"

Test #15:

score: 0
Accepted
time: 0ms
memory: 13248kb

input:

1919 810

output:

379720338

result:

ok 1 number(s): "379720338"

Test #16:

score: 0
Accepted
time: 3ms
memory: 13256kb

input:

1048 576

output:

216543264

result:

ok 1 number(s): "216543264"

Test #17:

score: 0
Accepted
time: 3ms
memory: 13124kb

input:

999 777

output:

635548531

result:

ok 1 number(s): "635548531"

Test #18:

score: 0
Accepted
time: 48ms
memory: 13252kb

input:

99999 77777

output:

448144614

result:

ok 1 number(s): "448144614"

Test #19:

score: 0
Accepted
time: 13ms
memory: 13244kb

input:

34527 6545

output:

748108997

result:

ok 1 number(s): "748108997"

Test #20:

score: 0
Accepted
time: 8ms
memory: 13240kb

input:

12345 12

output:

777496209

result:

ok 1 number(s): "777496209"

Test #21:

score: 0
Accepted
time: 3ms
memory: 13240kb

input:

1 1

output:

0

result:

ok 1 number(s): "0"

Test #22:

score: 0
Accepted
time: 48ms
memory: 13248kb

input:

100000 10101

output:

855985819

result:

ok 1 number(s): "855985819"

Test #23:

score: 0
Accepted
time: 44ms
memory: 13320kb

input:

100000 91919

output:

92446940

result:

ok 1 number(s): "92446940"

Test #24:

score: 0
Accepted
time: 48ms
memory: 13316kb

input:

100000 77979

output:

106899398

result:

ok 1 number(s): "106899398"

Test #25:

score: 0
Accepted
time: 7ms
memory: 13260kb

input:

10000 11

output:

326411649

result:

ok 1 number(s): "326411649"

Test #26:

score: 0
Accepted
time: 33ms
memory: 13240kb

input:

100000 2

output:

15322970

result:

ok 1 number(s): "15322970"

Test #27:

score: 0
Accepted
time: 40ms
memory: 13320kb

input:

100000 3

output:

93355797

result:

ok 1 number(s): "93355797"

Test #28:

score: 0
Accepted
time: 47ms
memory: 13168kb

input:

100000 99998

output:

331850772

result:

ok 1 number(s): "331850772"

Test #29:

score: 0
Accepted
time: 43ms
memory: 13124kb

input:

100000 99996

output:

885066226

result:

ok 1 number(s): "885066226"

Test #30:

score: 0
Accepted
time: 4ms
memory: 13172kb

input:

13115 2964

output:

0

result:

ok 1 number(s): "0"

Test #31:

score: 0
Accepted
time: 52ms
memory: 13168kb

input:

100000 17

output:

425792977

result:

ok 1 number(s): "425792977"

Test #32:

score: 0
Accepted
time: 53ms
memory: 13104kb

input:

99991 16

output:

667323936

result:

ok 1 number(s): "667323936"

Test #33:

score: 0
Accepted
time: 56ms
memory: 13256kb

input:

99991 17

output:

627396741

result:

ok 1 number(s): "627396741"

Test #34:

score: 0
Accepted
time: 56ms
memory: 13164kb

input:

99991 18

output:

874158501

result:

ok 1 number(s): "874158501"

Test #35:

score: 0
Accepted
time: 43ms
memory: 13248kb

input:

100000 100000

output:

99999

result:

ok 1 number(s): "99999"

Test #36:

score: 0
Accepted
time: 40ms
memory: 13252kb

input:

94229 94229

output:

94228

result:

ok 1 number(s): "94228"

Test #37:

score: 0
Accepted
time: 40ms
memory: 13128kb

input:

94229 94223

output:

476599876

result:

ok 1 number(s): "476599876"

Test #38:

score: 0
Accepted
time: 3ms
memory: 13124kb

input:

2 1

output:

0

result:

ok 1 number(s): "0"

Test #39:

score: 0
Accepted
time: 3ms
memory: 13240kb

input:

2 2

output:

0

result:

ok 1 number(s): "0"

Test #40:

score: 0
Accepted
time: 0ms
memory: 13324kb

input:

3 1

output:

0

result:

ok 1 number(s): "0"

Test #41:

score: 0
Accepted
time: 0ms
memory: 13164kb

input:

3 2

output:

2

result:

ok 1 number(s): "2"

Test #42:

score: 0
Accepted
time: 3ms
memory: 13112kb

input:

3 3

output:

2

result:

ok 1 number(s): "2"

Test #43:

score: 0
Accepted
time: 3ms
memory: 13236kb

input:

9 2

output:

44

result:

ok 1 number(s): "44"

Test #44:

score: 0
Accepted
time: 0ms
memory: 13180kb

input:

9 3

output:

206

result:

ok 1 number(s): "206"

Test #45:

score: 0
Accepted
time: 0ms
memory: 13248kb

input:

9 4

output:

441

result:

ok 1 number(s): "441"

Test #46:

score: 0
Accepted
time: 0ms
memory: 13168kb

input:

9 7

output:

224

result:

ok 1 number(s): "224"

Test #47:

score: 0
Accepted
time: 30ms
memory: 13324kb

input:

70839 22229

output:

0

result:

ok 1 number(s): "0"

Test #48:

score: 0
Accepted
time: 33ms
memory: 13252kb

input:

65536 17

output:

698801006

result:

ok 1 number(s): "698801006"

Test #49:

score: 0
Accepted
time: 36ms
memory: 13132kb

input:

65535 17

output:

433312902

result:

ok 1 number(s): "433312902"

Test #50:

score: 0
Accepted
time: 52ms
memory: 13236kb

input:

99856 317

output:

932131332

result:

ok 1 number(s): "932131332"

Test #51:

score: 0
Accepted
time: 53ms
memory: 13128kb

input:

99856 318

output:

398997854

result:

ok 1 number(s): "398997854"

Test #52:

score: 0
Accepted
time: 34ms
memory: 13240kb

input:

99856 2

output:

984791559

result:

ok 1 number(s): "984791559"

Test #53:

score: 0
Accepted
time: 43ms
memory: 13320kb

input:

100000 50000

output:

309108799

result:

ok 1 number(s): "309108799"

Extra Test:

score: 0
Extra Test Passed