QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#760989#9553. The HermitStarrykillerAC ✓48ms11860kbC++236.7kb2024-11-18 20:31:032024-11-18 20:31:05

Judging History

你现在查看的是最新测评结果

  • [2024-11-18 20:31:05]
  • 评测
  • 测评结果:AC
  • 用时:48ms
  • 内存:11860kb
  • [2024-11-18 20:31:03]
  • 提交

answer

// Homura Akemi a.k.a. Starrykiller (/user/235125)
// I love Madoka Kaname forever!
#include <bits/stdc++.h>

using namespace std;

#ifndef __glibcxx_nonmember_container_access 
#define size(_Cont) _Cont.size()
#endif


namespace sk {
    // modint: https://www.cnblogs.com/hzy1/p/16344746.html
    // Edited by Starrykiller.
    using i64=int64_t;
    using i128=__int128;
    using u128=unsigned __int128;
    using u64=uint64_t;
    using i32=int32_t;
    using u32=uint32_t;
    struct barrett { // From Atcoder Library.
        u32 _m;
        u64 im;
        explicit barrett(u32 m) : _m(m), im((u64)(-1)/m+1) {}
        u32 umod() const { return _m; }
        u32 mul(u32 a, u32 b) const {
            u64 z=a; z*=b;
            u64 x=(u64)((u128(z)*im) >> 64);
            u64 y = x * _m;
            return (u32)(z-y+(z<y?_m:0));
        }
    };
    constexpr i32 inverse(i32 a, i32 m) { i32 r=1;
        while (a>1) { i32 t=m/a; r=i64(r)*(m-t)%m; a=m-t*a; }
        return r;
    }
    template<i32 p>
    struct static_modint { 
        using mi=static_modint;
        public:
        constexpr static_modint(i64 x) : x(normal(x%p)) {}
        constexpr static_modint(i32 x, std::nullptr_t) : x(x) {}
        constexpr static_modint(): x(0) {}
        constexpr i32 normal(i32 x) { 
            if (x>=p) x-=p;
            return x+((x>>31)&p); 
        }
        constexpr i32 val() const { return x; }
        constexpr static i32 mod() { return p; }
        constexpr explicit operator bool() const { return x; }
        constexpr mi inv() const { assert(x!=0); return mi(inverse(x,p),nullptr); }
        constexpr mi pow(i64 x) const { assert(x>=0); mi a=*this, res=1;
            while (x) { if (x&1) res*=a; a*=a; x>>=1; } return res; }
        constexpr mi operator-() const { return mi(p-x); }
        constexpr mi& operator+=(const mi &rhs) { x=normal(x+rhs.x); return *this; }
        constexpr mi& operator-=(const mi &rhs) { x=normal(x-rhs.x); return *this; }
        constexpr mi& operator++() { return (*this)+=1; }
        constexpr mi& operator--() { return (*this)-=1; }
        constexpr mi& operator*=(const mi &rhs) { x=i64(x)*rhs.x%p; return *this; }
        constexpr mi& operator/=(const mi &rhs) { return *this *= rhs.inv(); }
        constexpr friend mi operator+(const mi &lhs, const mi &rhs) { auto res=lhs; res+=rhs; return res; }
        constexpr friend mi operator-(const mi &lhs, const mi &rhs) { auto res=lhs; res-=rhs; return res; }
        constexpr friend mi operator*(const mi &lhs, const mi &rhs) { auto res=lhs; res*=rhs; return res; }
        constexpr friend mi operator/(const mi &lhs, const mi &rhs) { auto res=lhs; res/=rhs; return res; }
        constexpr friend mi operator++(mi &x, i32) { auto tmp=x; x+=1; return tmp; }
        constexpr friend mi operator--(mi &x, i32) { auto tmp=x; x-=1; return tmp; }
        constexpr friend std::istream& operator>>(std::istream &is, mi &a) { i64 v; is>>v; a=v; return is; }
        constexpr friend std::ostream& operator<<(std::ostream &os, const mi &a) { os<<a.val(); return os; }
        constexpr bool operator==(const mi& rhs) const { return val()==rhs.val(); }
        constexpr bool operator!=(const mi& rhs) const { return val()!=rhs.val(); }
        private:
        i32 x;
    };
    template<i32 id>
    struct dynamic_modint { 
        using mi=dynamic_modint;
        public:
        constexpr dynamic_modint(i64 x) : x(normal(x%mod())) {}
        constexpr dynamic_modint(i32 x, std::nullptr_t) : x(x) {}
        constexpr dynamic_modint(): x(0) {}
        constexpr i32 normal(i32 x) { 
            auto p=mod();
            if (x>=p) x-=p;
            return x+((x>>31)&p); 
        }
        constexpr i32 val() const { return x; }
        constexpr static void set_mod(i32 m) { assert(m>=1); bt=barrett((u32)m); }
        constexpr static i32 mod() { return bt.umod(); }
        constexpr explicit operator bool() const { return x; }
        constexpr mi inv() const { assert(x!=0); return mi(inverse(x,mod()),nullptr); }
        constexpr mi pow(i64 x) const { assert(x>=0); mi a=*this, res=1;
            while (x) { if (x&1) res*=a; a*=a; x>>=1; } return res; }
        constexpr mi operator-() const { return mi(mod()-x); }
        constexpr mi& operator+=(const mi &rhs) { x=normal(x+rhs.x); return *this; }
        constexpr mi& operator-=(const mi &rhs) { x=normal(x-rhs.x); return *this; }
        constexpr mi& operator++() { return (*this)+=1; }
        constexpr mi& operator--() { return (*this)-=1; }
        constexpr mi& operator*=(const mi &rhs) { x=bt.mul(val(),rhs.val()); return *this; }
        constexpr mi& operator/=(const mi &rhs) { return *this *= rhs.inv(); }
        constexpr friend mi operator+(const mi &lhs, const mi &rhs) { auto res=lhs; res+=rhs; return res; }
        constexpr friend mi operator-(const mi &lhs, const mi &rhs) { auto res=lhs; res-=rhs; return res; }
        constexpr friend mi operator*(const mi &lhs, const mi &rhs) { auto res=lhs; res*=rhs; return res; }
        constexpr friend mi operator/(const mi &lhs, const mi &rhs) { auto res=lhs; res/=rhs; return res; }
        constexpr friend mi operator++(mi &x, i32) { auto tmp=x; x+=1; return tmp; }
        constexpr friend mi operator--(mi &x, i32) { auto tmp=x; x-=1; return tmp; }
        constexpr friend std::istream& operator>>(std::istream &is, mi &a) { i64 v; is>>v; a=v; return is; }
        constexpr friend std::ostream& operator<<(std::ostream &os, const mi &a) { os<<a.val(); return os; }
        constexpr bool operator==(const mi& rhs) const { return val()==rhs.val(); }
        constexpr bool operator!=(const mi& rhs) const { return val()!=rhs.val(); }
        private:
        i32 x; 
        static barrett bt;
    };
    template<i32 id> barrett dynamic_modint<id>::bt(998244353);
    using modint998244353=static_modint<998244353>;
    using modint1000000007=static_modint<1000000007>;
    using mint=dynamic_modint<-1>; 
};

using ll=sk::modint998244353;

constexpr int MAXN=1e5+10;

ll f[MAXN][19];
ll fac[MAXN], ifac[MAXN];

ll C(int n, int m) {
    if (m>n || m<0) return 0;
    return fac[n]*ifac[n-m]*ifac[m];
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m; cin>>n>>m;
    fac[0]=ifac[0]=1;
    for (int i=1; i<=n; ++i) {
        fac[i]=fac[i-1]*i; ifac[i]=ifac[i-1]/i;
    }
    for (int i=1; i<=n; ++i) {
        f[i][1]=1;
        for (int j=i+i; j<=n; j+=i)
            for (int c=1; c<18; ++c)
                f[j][c+1]+=f[i][c];
    }
    ll ans=C(n,m)*m;
    for (int i=1; i<=n; ++i) 
        for (int j=1; j<18&&j<=m; ++j) {
            ans-=f[i][j]*C(n/i-1,m-j);
        }
    cout<<ans<<'\n';

}

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

詳細信息

Test #1:

score: 100
Accepted
time: 0ms
memory: 5644kb

input:

4 3

output:

7

result:

ok 1 number(s): "7"

Test #2:

score: 0
Accepted
time: 1ms
memory: 5708kb

input:

11 4

output:

1187

result:

ok 1 number(s): "1187"

Test #3:

score: 0
Accepted
time: 45ms
memory: 11728kb

input:

100000 99999

output:

17356471

result:

ok 1 number(s): "17356471"

Test #4:

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

input:

11451 1919

output:

845616153

result:

ok 1 number(s): "845616153"

Test #5:

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

input:

99998 12345

output:

936396560

result:

ok 1 number(s): "936396560"

Test #6:

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

input:

100000 1

output:

0

result:

ok 1 number(s): "0"

Test #7:

score: 0
Accepted
time: 45ms
memory: 11796kb

input:

100000 15

output:

190067060

result:

ok 1 number(s): "190067060"

Test #8:

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

input:

10 3

output:

299

result:

ok 1 number(s): "299"

Test #9:

score: 0
Accepted
time: 1ms
memory: 5632kb

input:

10 4

output:

743

result:

ok 1 number(s): "743"

Test #10:

score: 0
Accepted
time: 1ms
memory: 5624kb

input:

10 5

output:

1129

result:

ok 1 number(s): "1129"

Test #11:

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

input:

15 6

output:

28006

result:

ok 1 number(s): "28006"

Test #12:

score: 0
Accepted
time: 1ms
memory: 5652kb

input:

15 7

output:

42035

result:

ok 1 number(s): "42035"

Test #13:

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

input:

123 45

output:

214851327

result:

ok 1 number(s): "214851327"

Test #14:

score: 0
Accepted
time: 1ms
memory: 3748kb

input:

998 244

output:

964050559

result:

ok 1 number(s): "964050559"

Test #15:

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

input:

1919 810

output:

379720338

result:

ok 1 number(s): "379720338"

Test #16:

score: 0
Accepted
time: 1ms
memory: 3600kb

input:

1048 576

output:

216543264

result:

ok 1 number(s): "216543264"

Test #17:

score: 0
Accepted
time: 1ms
memory: 3744kb

input:

999 777

output:

635548531

result:

ok 1 number(s): "635548531"

Test #18:

score: 0
Accepted
time: 39ms
memory: 11744kb

input:

99999 77777

output:

448144614

result:

ok 1 number(s): "448144614"

Test #19:

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

input:

34527 6545

output:

748108997

result:

ok 1 number(s): "748108997"

Test #20:

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

input:

12345 12

output:

777496209

result:

ok 1 number(s): "777496209"

Test #21:

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

input:

1 1

output:

0

result:

ok 1 number(s): "0"

Test #22:

score: 0
Accepted
time: 39ms
memory: 11856kb

input:

100000 10101

output:

855985819

result:

ok 1 number(s): "855985819"

Test #23:

score: 0
Accepted
time: 41ms
memory: 11804kb

input:

100000 91919

output:

92446940

result:

ok 1 number(s): "92446940"

Test #24:

score: 0
Accepted
time: 45ms
memory: 11732kb

input:

100000 77979

output:

106899398

result:

ok 1 number(s): "106899398"

Test #25:

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

input:

10000 11

output:

326411649

result:

ok 1 number(s): "326411649"

Test #26:

score: 0
Accepted
time: 41ms
memory: 11772kb

input:

100000 2

output:

15322970

result:

ok 1 number(s): "15322970"

Test #27:

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

input:

100000 3

output:

93355797

result:

ok 1 number(s): "93355797"

Test #28:

score: 0
Accepted
time: 46ms
memory: 11800kb

input:

100000 99998

output:

331850772

result:

ok 1 number(s): "331850772"

Test #29:

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

input:

100000 99996

output:

885066226

result:

ok 1 number(s): "885066226"

Test #30:

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

input:

13115 2964

output:

0

result:

ok 1 number(s): "0"

Test #31:

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

input:

100000 17

output:

425792977

result:

ok 1 number(s): "425792977"

Test #32:

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

input:

99991 16

output:

667323936

result:

ok 1 number(s): "667323936"

Test #33:

score: 0
Accepted
time: 42ms
memory: 11728kb

input:

99991 17

output:

627396741

result:

ok 1 number(s): "627396741"

Test #34:

score: 0
Accepted
time: 45ms
memory: 11860kb

input:

99991 18

output:

874158501

result:

ok 1 number(s): "874158501"

Test #35:

score: 0
Accepted
time: 46ms
memory: 11744kb

input:

100000 100000

output:

99999

result:

ok 1 number(s): "99999"

Test #36:

score: 0
Accepted
time: 35ms
memory: 11360kb

input:

94229 94229

output:

94228

result:

ok 1 number(s): "94228"

Test #37:

score: 0
Accepted
time: 42ms
memory: 11324kb

input:

94229 94223

output:

476599876

result:

ok 1 number(s): "476599876"

Test #38:

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

input:

2 1

output:

0

result:

ok 1 number(s): "0"

Test #39:

score: 0
Accepted
time: 1ms
memory: 5636kb

input:

2 2

output:

0

result:

ok 1 number(s): "0"

Test #40:

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

input:

3 1

output:

0

result:

ok 1 number(s): "0"

Test #41:

score: 0
Accepted
time: 1ms
memory: 5636kb

input:

3 2

output:

2

result:

ok 1 number(s): "2"

Test #42:

score: 0
Accepted
time: 1ms
memory: 5524kb

input:

3 3

output:

2

result:

ok 1 number(s): "2"

Test #43:

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

input:

9 2

output:

44

result:

ok 1 number(s): "44"

Test #44:

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

input:

9 3

output:

206

result:

ok 1 number(s): "206"

Test #45:

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

input:

9 4

output:

441

result:

ok 1 number(s): "441"

Test #46:

score: 0
Accepted
time: 1ms
memory: 5596kb

input:

9 7

output:

224

result:

ok 1 number(s): "224"

Test #47:

score: 0
Accepted
time: 31ms
memory: 9352kb

input:

70839 22229

output:

0

result:

ok 1 number(s): "0"

Test #48:

score: 0
Accepted
time: 29ms
memory: 8988kb

input:

65536 17

output:

698801006

result:

ok 1 number(s): "698801006"

Test #49:

score: 0
Accepted
time: 25ms
memory: 9036kb

input:

65535 17

output:

433312902

result:

ok 1 number(s): "433312902"

Test #50:

score: 0
Accepted
time: 42ms
memory: 11844kb

input:

99856 317

output:

932131332

result:

ok 1 number(s): "932131332"

Test #51:

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

input:

99856 318

output:

398997854

result:

ok 1 number(s): "398997854"

Test #52:

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

input:

99856 2

output:

984791559

result:

ok 1 number(s): "984791559"

Test #53:

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

input:

100000 50000

output:

309108799

result:

ok 1 number(s): "309108799"

Extra Test:

score: 0
Extra Test Passed