提出 #66389152

---

ソースコード 拡げる

#include<bits/stdc++.h>
#define For(i,l,r) for(int i=l,i##_e=r;i<=i##_e;++i)
#define rFor(i,r,l) for(int i=r,i##_e=l;i>=i##_e;--i)
#define y0 y_zero
#define y1 y_one
#define all(a) a.begin(),a.end()
#define cmin(a,b) a=min<remove_reference<decltype(a)>::type>(a,b)
#define cmax(a,b) a=max<remove_reference<decltype(a)>::type>(a,b)
#define vect basic_string
// #define ensure(_) ((_) || (__builtin_unreachable(),0))
using namespace std;
using u32=unsigned;
using i64=long long;
using ll=long long;
using u64=unsigned long long;
using ull=unsigned long long;
#if __SIZEOF_POINTER__==8
using i128=__int128;
using u128=__uint128_t;
#endif
using pii=array<int,2>;
using pll=array<ll,2>;
using a3=array<int,3>;
using a4=array<int,4>;
using a5=array<int,5>;
#define mtc() int T; cin>>T; while(T--) work();

#ifndef _MOD_INT_H
#define _MOD_INT_H
template<typename T=u32,T M=998244353,typename I=i64,typename U=u64> struct mint_static {
  private:
	using mint=mint_static;
	static constexpr void exgcd(I a,I b,I &x,I &y) {!b?(x=1,y=0):(exgcd(b,a%b,y,x),y-=x*(a/b));}
	static constexpr void mod(I &x) {
		x%=I(M); if(x<0) x+=M;
	}
	T x;
  public:
	static constexpr T getM(){return M;}
	constexpr T val()const{ return x; }
	static constexpr mint raw(T x){ mint s; s.x=x; return s; }
	constexpr mint inv()const{
		I _x=0,_y=0;
		exgcd(x,M,_x,_y);
		mod(_x); return raw(_x);
	}
	constexpr mint_static():x(0){};
	constexpr mint_static(I a):x((a%=I(M),a>=0?a:a+M)) {}
	constexpr mint& operator+=(const mint b) {
		if(int((x+=b.x)-M)>=0) x-=M;
		return *this;
	}
	constexpr mint& operator-=(const mint b) {
		x-=b.x; if(x>=M) x+=M;
		return *this;
	}
	constexpr mint& operator*=(const mint b) {
		x=U(x)*b.x%M; return *this;
	}
	constexpr mint& operator/=(const mint b) {return *this*=b.inv();}
	friend constexpr mint operator+(mint a,const mint b) {return a+=b;}
	friend constexpr mint operator-(mint a,const mint b) {return a-=b;}
	friend constexpr mint operator*(mint a,const mint b) {return a*=b;}
	friend constexpr mint operator/(mint a,const mint b) {return a/=b;}
	friend constexpr mint operator-(mint a) { if(a.x) a.x=M-a.x; return a; }
	friend constexpr bool operator!(const mint a) { return !a.x; }
	friend constexpr bool operator==(const mint a,const mint b) { return a.x==b.x; }
	friend constexpr bool operator!=(const mint a,const mint b) { return a.x!=b.x; }
#ifdef with_buffer
	template<size_t S> friend IO::my_istream<S>
	  operator>>(const IO::my_istream<S> in,mint &x) {
		I y; in>>y; x=y; return in;
	}
	template<size_t S> friend IO::my_ostream<S>
	  operator<<(const IO::my_ostream<S> out,const mint x) {
		out<<x.x; return out;
	}
#endif
	friend istream& operator>>(istream &in,mint &x) {
		I y; in>>y; x=y; return in;
	}
	friend ostream& operator<<(ostream &out,const mint x) {
		out<<x.x; return out;
	}
};
template<u32 M> using mintI=mint_static<u32,M>;
template<unsigned short M> using mintS=mint_static<unsigned short,M,int,u32>;
template<u64 M> using mintL=mint_static<u64,M,i128,u128>;
#endif // _MOD_INT_H
constexpr int M=998244353;
using mint=mintI<M>;

#ifndef _C_H
#define _C_H
template<typename mint> class Comb_t {
	static constexpr double alpha=1.3;
	static constexpr int Cm1m1=0; // Sometimes C(-1,-1)=1
	static vector<mint> f,g;
	static void init(int m) {
		if(m<int(f.size())) return; m*=alpha; if(m>=mint::getM()) m=mint::getM()-1;
		int n=f.size(); f.resize(m+1); g.resize(m+1);
		For(i,n,m) f[i]=f[i-1]*mint::raw(i);
		g[m]=f[m].inv(); rFor(i,m-1,n) g[i]=g[i+1]*mint::raw(i+1);
	}
  public:
	static mint C(int n,int m) {
		if(!~n && !~m) return Cm1m1;
		if(m<0 || n<m) return 0;
		init(n);
		return f[n]*g[m]*g[n-m];
	}
	static mint fac(int n) { init(n); return n<0?0:f[n]; }
	static mint ifac(int n) { init(n); return n<0?0:g[n]; }
	static mint _inv(int n) { init(n); return n<=0?0:g[n]*f[n-1]; }
};
template<typename mint> vector<mint> Comb_t<mint>::f{1};
template<typename mint> vector<mint> Comb_t<mint>::g{1};
#endif // _C_H
using Comb=Comb_t<mint>;
static auto C=Comb::C; static auto fac=Comb::fac,ifac=Comb::ifac,_inv=Comb::_inv;

struct nd {
	mint f,g;
	nd operator+(const nd b)const{
		return {f+b.f,g+b.g};
	}
	nd operator*(const nd b)const{
		return {f*b.f,g*b.f+f*b.g};
	}
	nd ad(int s) { return {f,g+f*s}; }
};
nd get(mint x,mint y) {
	return {x,x*y};
}
const int N=2e5+10,B=1000;
int n,m;
nd to[B][B];
vector<nd> f[N];
int main() {
#ifdef LOCAL
	freopen(".in","r",stdin);
	// freopen(".out","w",stdout);
	// freopen(".debug","w",stderr);
#endif
#ifndef with_buffer
	ios::sync_with_stdio(0); cin.tie(0);
#endif
	cin>>n>>m;
	if(n<m) swap(n,m);
	For(i,1,m) {
		For(x,0,i) For(y,0,max(0,i-x-1)) {
			to[i][y]=to[i][y]+get(C(max(0,i-x-1),y),x);
		}
	}
	For(i,0,n) f[i].resize(m+1),f[i][0]={1,0};
	For(i,0,m) f[0][i]={1,0};
	For(i,1,n) For(j,1,m) {
		For(k,0,j) {
			f[i][j]=f[i][j]+f[i-1][j-k]*(to[j][k].ad(i*k));
		}
	}
	cout<<f[n][m].g<<"\n";
}

提出情報

コンパイルエラー

Main.cpp: In static member function ‘static void Comb_t<mint>::init(int)’:
Main.cpp:100:17: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
  100 |                 if(m<int(f.size())) return; m*=alpha; if(m>=mint::getM()) m=mint::getM()-1;
      |                 ^~
Main.cpp:100:45: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’
  100 |                 if(m<int(f.size())) return; m*=alpha; if(m>=mint::getM()) m=mint::getM()-1;
      |                                             ^
Main.cpp: In instantiation of ‘static void Comb_t<mint>::init(int) [with mint = mint_static<unsigned int, 998244353, long long int, long long unsigned int>]’:
Main.cpp:109:7:   required from ‘static mint Comb_t<mint>::C(int, int) [with mint = mint_static<unsigned int, 998244353, long long int, long long unsigned int>]’
Main.cpp:120:21:   required from here
Main.cpp:100:59: warning: comparison of integer expressions of different signedness: ‘int’ and ‘unsigned int’ [-Wsign-compare]
  100 |                 if(m<int(f.size())) return; m*=alpha; if(m>=mint::getM()) m=mint::getM()-1;
      |                                                          ~^~~~~~~~~~~~~~
Main.cpp: At global scope:
Main.cpp:120:66: warning: ‘_inv’ defined but not used [-Wunused-variable]
  120 | static auto C=Comb::C; static auto fac=Comb::fac,ifac=Comb::ifac,_inv=Comb::_inv;
      |                                                                  ^~~~
Main.cpp:120:50: warning: ‘ifac’ defined but not used [-Wunused-variable]
  120 | static auto C=Comb::C; static auto fac=Comb::fac,ifac=Comb::ifac,_inv=Comb::_inv;
      |                                                  ^~~~
Main.cpp:120:36: warning: ‘fac’ defined but not used [-Wunused-variable]
  120 | static auto C=Comb::C; static auto fac=Comb::fac,ifac=Comb::ifac,_inv=Comb::_inv;
      |                                    ^~~

ジャッジ結果