text
stringlengths 49
983k
|
|---|
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
while(1){
int n,m,s;
static int dp[2][2002][3002];
for(int i=0;i<2;i++)for(int j=0;j<2002;j++)for(int k=0;k<3002;k++)dp[i][j][k]=0;
scanf("%d%d%d",&n,&m,&s);
if(n==0&&m==0&&s==0)break;
for(int j=0;j<=m;j++)dp[0][j][0]=1;
for(int i=1;i<=n*n;i++){
for(int j=i;j<=m;j++){
for(int k=1;k<=s;k++){
if(k-j>=0){
dp[1][j][k]=dp[0][j-1][k-j];
}
dp[1][j][k]+=dp[1][j-1][k];
dp[1][j][k]%=100000;
}
}
for(int j=0;j<=m;j++)for(int k=0;k<=s;k++){dp[0][j][k]=dp[1][j][k]; dp[1][j][k]=0;}
}
printf("%d\n",dp[0][m][s]);
}
}
|
#include<iostream>
#include<sstream>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<string>
#include<stack>
#include<queue>
#include<deque>
#include<set>
#include<map>
#include<algorithm>
#include<functional>
#include<utility>
#include<cmath>
#include<ctime>
#include<complex>
using namespace std;
#define REP(i,s,e) for(int i=int(s);i<=int(e);i++)
#define rep(i,n) for(int i=0;i<int(n);i++)
int B[50][3001];
int main(){
int N,M,S;
while(1){
cin >> N >> M >> S;
if(N==0 && M==0 && S==0) break;
int mod=100000;
B[0][0]=1;
for(int k=1;k<=M;k++){
for(int n=N*N;n>=1;n--){
for(int s=S;s>=1;s--){
if(s-k>=0 && n-1>=0)
B[n][s]=B[n-1][s-k]%mod+B[n][s]%mod;
else
B[n][s]=B[n][s]%mod;
}
}
}
cout << B[N*N][S]%mod << endl;
REP(n,0,N*N) REP(s,0,S) B[n][s]=0;
}
return 0;
}
|
#include<bits/stdc++.h>
int d[50][3001];
int main() {
int n, m, s;
while (scanf("%d%d%d", &n, &m, &s), n *= n) {
memset(d, 0, sizeof(d));
d[0][0] = 1;
for (int i = 1; i <= m; i++)
for (int j = n; j > 0; j--)
for (int k = i; k <= s; k++)
(d[j][k] += d[j - 1][k - i]) %= 100000;
printf("%d\n", d[n][s]);
}
}
|
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
const int mod = 100000;
int main()
{
while(true) {
int n, m, s;
scanf("%d%d%d", &n, &m, &s);
if(n == 0 && m == 0 && s == 0)
break;
n = n * n;
s -= (0 + (n - 1)) * n / 2;
m = min(m, s);
static int dp[3001][2001] = {0};
memset(dp[0], 0, 3001 * 2001 * sizeof(int));
for(int i = 1; i <= m; ++i)
dp[i][i] = 1;
for(int i = 1; i < n; ++i) {
for(int x = 1; x <= m - i; ++x) {
for(int sum = s; sum > x; --sum)
dp[sum][x] = (dp[sum - 1][x - 1] + dp[sum - x][x]) % mod;
for(int sum = x; sum > 0; --sum)
dp[sum][x] = (dp[sum - 1][x - 1]) % mod;
}
}
int ans = 0;
for(int i = 1; i <= m - (n - 1); ++i) {
ans += dp[s][i];
ans %= mod;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
int dp[2][2001][3001];
int main() {
while(cin >> n >> m >> s, n){
for(int i=0;i<2;i++){
for(int j=0;j<=m;j++){
fill(dp[i][j], dp[i][j]+s+1, 0);
}
}
dp[0][0][0] = 1;
for(int i=0;i<n*n;i++){
for(int j=0;j<m;j++){
for(int k=0;k<=s;k++){
dp[i%2][j+1][k] += dp[i%2][j][k];
dp[i%2][j+1][k] %= 100000;
if(k+j+1 <= s){
dp[(i+1)%2][j+1][k+j+1] += dp[i%2][j][k];
dp[(i+1)%2][j+1][k+j+1] %= 100000;
}
}
}
for(int j=0;j<=m;j++){
fill(dp[i%2][j], dp[i%2][j]+s+1, 0);
}
}
int ans = 0;
for(int i=0;i<=m;i++){
ans += dp[(n*n)%2][i][s];
ans %= 100000;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int dp[50][3010];
const int mod=100000;
int main(){
while(true){
int n,m,s; cin>>n>>m>>s;
if(n==0) return 0;
int a=n*n;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=a;i++){
for(int j=0;j<=s;j++){
if(j-(a-i+1)>=0){
(dp[i][j]+=dp[i-1][j-(a-i+1)])%=mod;
(dp[i][j]+=dp[i][j-(a-i+1)])%=mod;
}
if(j>m) (dp[i][j]+=mod-dp[i-1][j-m-1])%=mod;
}
}
cout<<dp[a][s]<<endl;
}
}
|
#include <iostream>
using namespace std;
const int mod = 100000;
int dp[2][2001][3001];
int main(int argc, char const* argv[])
{
int n, m, s;
do{
cin >> n >> m >> s;
if(n == 0)break;
for(int i = 0; i < n * n; i++){
for(int j = 1; j <= m; j++){
for(int k = 1; k <= s; k++){
if(i == 1){
if(j < k)dp[1][j][k] = 0;
else dp[1][j][k] = 1;
}
dp[(i + 1) & 1][j][k] = dp[(i + 1) & 1][j-1][k];
if(k -j >= 0)dp[(i + 1) & 1][j][k] += dp[i & 1][j-1][k-j];
dp[(i + 1) & 1][j][k] %= mod;
// cout << i << " " << j << " " << k << " " << dp[(i + 1) & 1][j][k] << endl;
}
}
}
cout << dp[(n*n) & 1][m][s] << endl;
}while(true);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n,m,s;
int main(){
while(true){
cin >> n >> m >> s;
if(n==0){
break;
}
int mod=pow(10,5);
n=pow(n,2);
m-=n;
s-=(n*(n+1))/2;
int m3=min(max((s+1)/n+1,1),m);
vector<vector<int>> dp(s+1,vector<int>(m3+1,0));
dp[0][0]=1;
for(int i=0;i<n;i++){
int m2=min(max((s+1)/(n-i)+1,1),m);
vector<vector<int>> dp2(s+1,vector<int>(m2+1,0));
for(int j=0;j<s+1;j++){
for(int k=0;k<m3+1;k++){
if(j+k<=s){
dp2[j+k][k]+=dp[j][k];
}
}
}
for(int l=-(m2+1);l<s+2;l++){
for(int j=max(0,l)+1;j<min(s,m2+l)+1;j++){
dp2[j][j-l]=(dp2[j][j-l]+dp2[j-1][j-l-1])%mod;
}
}
dp=dp2;
m3=m2;
}
cout << accumulate(dp[s].begin(),dp[s].end(),0)%mod << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int dp[2200][3200],_prev[2200][3200],n,m,s;
int main(){
while(true){
cin>>n>>s>>m;if(n==0)return 0;n*=n;
for(int i=0;i<2200;i++){fill(dp[i],dp[i]+3180,0);fill(_prev[i],_prev[i]+3180,0);}
for(int i=0;i<=s;i++)_prev[i][0]=1;
for(int i=0;i<n;i++){
for(int j=1;j<=s;j++){
for(int k=j;k<=m;k++){
dp[j][k]+=_prev[j-1][k-j];dp[j][k]%=100000;
}
}
for(int j=0;j<=s;j++){
for(int k=0;k<=m;k++){
_prev[j][k]=dp[j][k];dp[j][k]=0;
}
}
for(int j=1;j<=s;j++){
for(int k=1;k<=m;k++){
_prev[j][k]+=_prev[j-1][k];
}
}
}
cout<<_prev[s][m]%100000<<endl;
}
}
|
//y09-6 ビンゴ(2回目)
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <stack>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <cassert>
using namespace std;
#define LL long long
#undef INT_MIN
#undef INT_MAX
#define INT_MIN -2147483648
#define INT_MAX 2147483647
#define LL_MIN -9223372036854775808
#define LL_MAX 9223372036854775807
#define segment_size 65536
#define ROOP() while (true)
int main(){
ROOP(){
int N,M,S;
cin >> N >> M >> S;
if(N==0) return 0;
int dp[50][3001];
for(int i=0; i<50; i++){
for(int j=0; j<3001; j++){
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for(int i=1; i<=N*N; i++){
for(int j=1; j<=S; j++){
if(j>=i) dp[i][j] = dp[i-1][j-i] + dp[i][j-i];
if(j>M) dp[i][j] -= dp[i-1][j-M-1];
dp[i][j] %= 100000;
if(dp[i][j]<0) dp[i][j]+=100000;
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N, M, S;
while(cin >> N >> M >> S, N){
// dp[i][j]: 場所iで今の合計がjのときの組み合わせ数
vector < vector< int > > dp( N * N + 1, vector< int >( S + 1, 0));
dp[0][0] = 1;
for(int i = 1; i <= M; i++){ // 選ぶ数字
for(int j = N * N; j >= 1; j--){ // idx
for(int k = i; k <= S; k++){ // 合計
(dp[j][k] += dp[j - 1][k - i]) %= 100000;
}
}
}
cout << dp[N * N][S] << endl;
}
}
|
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
int n, m, s;
const int MOD = 100000;
int dp[2010][3010];
int main() {
while (scanf("%d %d %d", &n, &m, &s), n|m|s) {
MEMSET(dp, 0);
FOREQ(i, 0, m) {
dp[i][0] = 1;
}
REP(iter, n * n) {
dp[m][s] = 0;
for (int i = m; i >= 1; i--) {
FOREQ(j, 0, s - i) {
if (i > (s - j) / (n * n - iter)) {
break;
}
dp[i][j + i] = dp[i - 1][j];
}
REP(j, i) { dp[i][j] = 0; }
}
FOREQ(i, 1, m) {
FOREQ(j, 0, s) {
if (i > (s - j + i) / (n * n - iter)) { break; }
dp[i][j] += dp[i - 1][j];
dp[i][j] %= MOD;
}
}
if (iter == 0) {
FOREQ(i, 0, m) {
dp[i][0] = 0;
}
}
}
printf("%d\n", dp[m][s]);
}
}
|
#include<bits/stdc++.h>
#define LL long long
#define rep(i,n) for(int i=0;i<n;++i)
#define per(i,n) for(int i=n;i>0;i--)
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define ROF(i,a,b) for(int i=a;i>=b;i--);
#define push_back PB;
#define pop_back PPB;
using namespace std;
static const LL INF = 1LL<<61LL;
static const double EPS = 1e-8;
static const int mod = 100000;
typedef pair<int,int> PII;
LL dp[51][3001];
int main(){
while(1){
LL N,M,S;
cin>>N>>M>>S;
if(N==0&&M==0&&S==0)break;
N*=N;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
FOR(i,1,M){
per(j,N){
FOR(k,i,S){
dp[j][k]+=(mod+dp[j-1][k-i])%mod;
}
}
}
cout<<dp[N][S]%mod<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e5;
int main()
{
ios::sync_with_stdio(false), cin.tie(0);
int N, M, S;
while (cin >> N >> M >> S, N | M | S) {
N *= N;
vector<vector<int>> dp(S + 1, vector<int>(N + 1));
dp[0][0] = 1;
for (int i = 1; i <= M; i++) {
auto tmp = dp;
for (int j = 0; j + i <= S; j++) {
for (int k = 0; k < N; k++) {
(dp[j + i][k + 1] += tmp[j][k]) %= mod;
}
}
}
printf("%d\n", dp[S][N]);
}
return 0;
}
|
#include <vector>
#include <iostream>
using namespace std;
const int mod = 100000;
int N, M, S;
int main() {
while (cin >> N >> M >> S, N) {
N *= N;
M -= N;
S -= N * (N + 1) / 2;
vector<vector<int> > dp(M + 1, vector<int>(S + 1, 0));
dp[0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 1; j <= M; j++) {
for (int k = S; k >= j; k--) {
dp[j][k] = dp[j][k - j];
if (j >= 1) {
dp[j][k] += dp[j - 1][k - 1];
if (dp[j][k] >= mod) dp[j][k] -= mod;
}
}
}
}
int ret = 0;
for (int i = 0; i <= M; i++) {
ret += dp[i][S];
if (ret >= mod) ret -= mod;
}
cout << ret << endl;
}
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <queue>
#include <vector>
#include <functional>
#include <map>
#include <set>
#include <cmath>
#include <string>
#define SIZE 200005
#define INF 1000000005LL
#define MOD 100000
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
int dp[3005][50];
int main()
{
int N,M,S;
while(1){
scanf("%d%d%d",&N,&M,&S);
if(N==0 && M == 0)break;
N = N*N;
S -= N*(N+1)/2;
M -= N;
if(S < 0 || M < 0){
puts("0");
continue;
}
for(int i=0;i<=S;i++){
for(int j=0;j<=N;j++){
dp[i][j]=0;
}
}
dp[0][0]=1;
for(int i=0;i<=S;i++){
for(int j=1;j<=N;j++){
dp[i][j] = dp[i][j-1];
if(i-j>=0)(dp[i][j] += dp[i-j][j])%=MOD;
if(i-j-M >= 0)(dp[i][j] += MOD-dp[i-j-M][j-1])%=MOD;
}
}
printf("%d\n",dp[S][N]);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int dp[2][2001][3001];
const int mod = 100000;
int main(){
int n,m,s;
while(cin >> n >> m >> s){
if(n==0)break;
n = n*n;
for(int i=0;i<=m;i++){
for(int j=0;j<=s;j++)dp[0][i][j] = 0;
}
dp[0][0][0] = 1;
for(int i=0;i<n;i++){
int cur = i&1, nxt = 1-cur;
for(int j=0;j<=m;j++){
for(int k=0;k<=s;k++)dp[nxt][j][k] = 0;
}
for(int j=0;j<=m;j++){
for(int k=0;k<=s;k++){
if(dp[cur][j][k]==0)continue;
if(j<m){
(dp[cur][j+1][k] += dp[cur][j][k]) %= mod;
if(k+j+1<=s)(dp[nxt][j+1][k+j+1] += dp[cur][j][k]) %= mod;
}
}
}
}
for(int i=0;i<m;i++)(dp[n&1][i+1][s] += dp[n&1][i][s]) %= mod;
cout << dp[n&1][m][s] << endl;
}
}
|
#include <cmath>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
int dp[100][5000];
int const mod=100000;
int main(){
int N,M,S;
while(scanf("%d%d%d",&N,&M,&S)!=EOF && N|M|S){
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1; i<=M; ++i){
for(int j=N*N; j>0; --j){
for(int k=i; k<=S; ++k){
dp[j][k]+=dp[j-1][k-i];
dp[j][k]%=mod;
}
}
}
printf("%d\n",dp[N*N][S]%mod);
}
}
|
#include <cstdio>
#include <cstring>
using namespace std;
int dp[50][3001];
int main(){
int n, m, s;
while(scanf("%d %d %d", &n, &m, &s), n){
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for(int i=1; i<=m; ++i){
for(int j=n*n; j>0; --j){
for(int l=i; l<=s; ++l){
dp[j][l] = (dp[j][l] + dp[j-1][l-i]) % 100000;
}
}
}
printf("%d\n", dp[n*n][s]);
/* for(int i=0; i<n*n; i++){
for(int j=0; j<s; j++){
printf("%d\t", dp[i+1][j+1]);
}
printf("\n");
}
*/ }
}
|
#include<bits/stdc++.h>
#define LL long long
#define rep(i,n) for(int i=0;i<n;++i)
#define per(i,n) for(int i=n;i>0;i--)
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define ROF(i,a,b) for(int i=a;i>=b;i--);
#define push_back PB;
#define pop_back PPB;
using namespace std;
static const LL INF = 1LL<<61LL;
static const double EPS = 1e-8;
static const int mod = 100000;
typedef pair<int,int> PII;
LL dp[51][3001];
int main(){
while(1){
LL N,M,S;
cin>>N>>M>>S;
if(N==0&&M==0&&S==0)break;
N*=N;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
FOR(i,1,M){
per(j,N){
FOR(k,i,S){
dp[j][k]+=dp[j-1][k-i]%mod;
}
}
}
cout<<dp[N][S]%mod<<endl;
}
return 0;
}
|
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MOD 100000
int dp[50][3001];
int main(){
int n,m,s;
while(scanf("%d%d%d",&n,&m,&s),(n|m|s)){
for(int i = 0; i < n*n+1; i++){
for(int j = 0; j < s+1; j++){
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for(int i = 1; i < m+1; i++){
for(int j = n*n;j > 0; j--){
for(int k = i; k < s+1; k++){
dp[j][k] += dp[j-1][k-i];
dp[j][k] %= MOD;
}
}
}
printf("%d\n",dp[n*n][s]);
}
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
const int MOD = 100000;
int main() {
int N, M, S;
while(cin >> N >> M >> S, N | M | S) {
vector<vector<int>> dp(N * N + 1, vector<int>(S + 1, 0));
dp[0][0] = 1;
for(int i = 1; i <= M; ++i) for(int j = N * N; j >= 1; --j) for(int k = i; k <= S; ++k)
dp[j][k] = (dp[j][k] + dp[j - 1][k - i]) % MOD;
cout << dp[N * N][S] << endl;
}
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <iostream>
typedef long long int ll;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int dp[50][3001];
void func(int N,int M,int S,int limit){
for(int i = 0; i <= 49; i++){
for(int k = 0; k <= 3000; k++)dp[i][k] = 0;
}
dp[0][0] = 1;
for(int number = 1; number <= M; number++){
for(int loc = limit; loc >= 1; loc--){
for(int sum = number; sum <= S; sum++){
dp[loc][sum] = (dp[loc][sum] + dp[loc-1][sum-number])%100000;
}
}
}
printf("%d\n",dp[limit][S]);
}
int main(){
int N,M,S,limit;
while(true){
scanf("%d %d %d",&N,&M,&S);
if(N == 0 && M == 0 && S == 0)break;
limit = N*N;
func(N,M,S,limit);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define mod 100000
typedef pair<int, int> P;
int n, m, s, ans;
int dp[2][2001][3001];
int main()
{
while(cin >> n >> m >> s && n)
{
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for(int i = 0; i < n * n; ++i)
{
for(int j = 0; j < m; ++j)
for(int k = j; k < s; ++k)
dp[1][j + 1][k + 1] = (dp[1][j][k] + dp[0][j][k - j]) % mod;
for(int j = 0; j <= m; ++j)
{
for(int k = 0; k <= s; ++k)
{
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = 0;
}
}
}
ans = 0;
for(int i = 0; i <= m; ++i)
{
ans += dp[0][i][s];
ans %= mod;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define mod 100000
typedef pair<int, int> P;
int n, m, s, ans;
int dp[2][2010][3010];
int main()
{
while(cin >> n >> m >> s && n)
{
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for(int i = 0; i < n * n; ++i)
{
for(int j = 0; j < m; ++j)
for(int k = j; k < s; ++k)
dp[1][j + 1][k + 1] = (dp[1][j][k] + dp[0][j][k - j]) % mod;
for(int j = 0; j <= m; ++j)
{
for(int k = 0; k <= s; ++k)
{
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = 0;
}
}
}
ans = 0;
for(int i = 0; i <= m; ++i)
{
ans += dp[0][i][s];
ans %= mod;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 100000;
int main()
{
int N, M, S;
while(cin >> N >> M >> S, N || M || S) {
int dp[55][3005] = {};
dp[0][0] = 1;
for(int p = 1; p <= M; p++) {
for(int i = N * N; i >= 0; i--) {
for(int j = S; j >= 0; j--) {
if(j + p <= 3000) (dp[i + 1][j + p] += dp[i][j]) %= mod;
}
}
}
cout << dp[N * N][S] << endl;
}
return (0);
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<sstream>
#include<iomanip>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int main(){
int n,m,s;
while(cin>>n>>m>>s,n){
int N=n*n;
int MOD=100000;
vvi dp(N+1,vi(s+1));
dp[0][0]=1;
loop(x,1,m+1)for(int i=N-1;i>=0;i--)rep(j,s)if(j+x<=s){
(dp[i+1][j+x]+=dp[i][j])%=MOD;
}
cout<<dp[N][s]<<endl;
}
}
|
#include <iostream>
using namespace std;
int D = 100000;
int dp[2][50][3001];
int n, m, s;
void set(){
int x, y, z;
for(x = 0; x < 2; x++){
for(y = 0; y <= n*n; y++){
for(z = 0; z <= s; z++){
dp[x][y][z] = 0;
}
}
}
dp[0][0][0] = 1;
for(y = 1; y <= m; y++){
for(x = 0; x <= n*n; x++){
for(z = 0; z <= s; z++){
if(x && z >= y){
dp[y%2][x][z]
= (dp[(y-1)%2][x][z]+dp[(y-1)%2][x-1][z-y]);
}else{
dp[y%2][x][z] = dp[(y-1)%2][x][z];
}
dp[y%2][x][z] %= D;
}
}
}
}
int main(){
while( cin >> n >> m >> s, n|m|s ){
set();
cout << dp[m%2][n*n][s] << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define FOR(i,a,b) for(int i = (a); i < (b); i++)
#define REP(i,n) FOR(i,0,n)
int dp[50][3001];
int n, m, s;
const int mod = 100000;
int main() {
while (cin >> n >> m >> s, n || m || s) {
n *= n;
fill(dp[0], dp[n + 1], 0);
dp[0][0] = 1;
FOR(i, 1, m + 1) for (int j = n - 1; j >= 0; j--) REP(k, s + 1) {
if (k + i > s) break;
dp[j + 1][k + i] += dp[j][k];
dp[j + 1][k + i] %= mod;
}
cout << dp[n][s] << endl;
}
return 0;
}
|
#include <iostream>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,j) FOR(i,0,j)
int main(){
int N, M, S, dp[60][3010];
while(std::cin >> N >> M >> S, N){
REP(i, 60){
REP(j, 3010){
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for(int i=1;i<=M;i++){// 1つずつ入れてるdp
for(int j=N*N;j>=1;j--){
for(int s=i;s<=S;s++){
dp[j][s] = (dp[j][s] + dp[j-1][s-i]) % 100000;
}
}
}
std::cout << dp[N*N][S] << std::endl;
}
}
|
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <memory.h>
#include <cassert>
#include <iomanip>
using namespace std;
#define all(c) ((c).begin()), ((c).end())
#define debug(c) cerr << "> " << #c << " = " << (c) << endl;
#define iter(c) __typeof((c).begin())
#define present(c, e) ((c).find((e)) != (c).end())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
#define tr(i, c) for (iter(c) i = (c).begin(); i != (c).end(); i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define mp make_pair
#define fst first
#define snd second
#define pb push_back
const double EPS = 1e-10;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef complex<double> P;
#define MOD (100000)
#define NOR(x) ((x) % MOD)
int main() {
for (int N, M, S; cin >> N >> M >> S, (N | M | S) != 0; ) {
int N2 = N * N;
int dp[3010][55];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
REP(i, 1, M) {
for (int j = S; j >= i; j--) for (int k = N2; k >= 1; k--) {
dp[j][k] = NOR(dp[j][k] + dp[j - i][k - 1]);
}
}
cout << dp[S][N2] << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
constexpr int mod = 100000;
constexpr int MAX_N = 50;
constexpr int MAX_S = 3010;
constexpr int MAX_M = 2010;
typedef long long LL;
int main(){
int N[5],M[5],S[5];
int ret[5];
LL dp[MAX_S][MAX_N];
vector<int> query[MAX_M];
int q=0;
for(q=0;;q++){
scanf("%d%d%d",N+q,M+q,S+q);if(N[q]+M[q]+S[q]==0)break;
query[M[q]].push_back(q);
}
for(int i=0;i<MAX_S;i++)for(int j=0;j<MAX_N;j++)dp[i][j]=0;
dp[0][0]=1;
for(int i=1;i<MAX_M;i++){
for(int j=MAX_S-1;j>=i;j--)for(int k=1;k<MAX_N;k++){
dp[j][k]+=dp[j-i][k-1];
if(dp[j][k]>=mod)dp[j][k]-=mod;
}
for(auto &id:query[i])ret[id] = (int)dp[S[id]][N[id]*N[id]];
}
for(int i=0;i<q;i++)printf("%d\n",ret[i]);
return 0;
}
|
// aoj - - 0537 / 2016-03-04
#include<iostream>
#include<vector>
#include<cassert>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<tuple>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef ll int__;
#define rep(i,j) for(int__ i=0;i<(int__)(j);i++)
#define repeat(i,j,k) for(int__ i=(j);i<(int__)(k);i++)
#define all(v) v.begin(),v.end()
template<typename T>ostream& operator << (ostream &os , const vector<T> &v){
rep(i,v.size()) os << v[i] << (i!=v.size()-1 ? " " : "\n"); return os;
}
template<typename T>istream& operator >> (istream &is , vector<T> &v){
rep(i,v.size()) is >> v[i]; return is;
}
#ifdef DEBUG
void debug(){ cerr << endl; }
#endif
template<class F,class...R> void debug(const F &car,const R&... cdr){
#ifdef DEBUG
cerr << car << " "; debug(cdr...);
#endif
}
const int MOD = 100000;
bool solve(){
int N, M, S; cin >> N >> M >> S;
if(N == 0) return false;
vector<vector<int>> dp(N*N+1, vector<int>(S+1));
// dp[i][j] := i???????????§?????????j????????????????????°
dp[0][0] = 1;
repeat(i, 1, M+1){
for(int j = N*N-1; j >= 0; j--){
rep(k, S+1-i){
dp[j+1][k+i] += dp[j][k];
dp[j+1][k+i] %= MOD;
}
}
}
cout << dp[N*N][S] << endl;
return true;
}
int main()
{
ios::sync_with_stdio(false);
while(solve());
return 0;
}
|
#include <iostream>
using namespace std;
int dp[2][59][3010];
int main(){
int N,M,S,n2,ii,io;
while(1){
cin>>N>>M>>S;
if(N==0&&M==0&&S==0)break;
n2=N*N;
for(int j=0;j<=n2;j++){
for(int k=0;k<=S;k++){
dp[0][j][k]=0;
}
}
dp[0][0][0]=1;
for(int i=1;i<=M;i++){
//for(int k=0;k<=n2;k++){//
// for(int j=0;j<=S;j++){//
// cout<<dp[i-1][k][j]<<" ";//
// }//
// cout<<endl;//
//}//
//cout<<endl;//
if(i%2){
ii=0;
io=1;
}
else{
ii=1;
io=0;
}
for(int j=0;j<=n2;j++){
for(int k=0;k<=S;k++){
dp[io][j][k]=0;
}
}
for(int j=0;j<=n2;j++){
for(int k=0;k<=S;k++){
if(dp[ii][j][k]!=0){
if(k<=S-i&&j!=n2){
dp[io][j+1][k+i]+=dp[ii][j][k];
dp[io][j+1][k+i]%=100000;
}
dp[io][j][k]+=dp[ii][j][k];
dp[io][j][k]%=100000;
}
}
}
}
//for(int i=0;i<=n2;i++){//
// for(int j=0;j<=S;j++){//
// cout<<dp[M][i][j]<<" ";//
// }//
// cout<<endl;//
//}//
cout<<dp[M%2][n2][S]<<endl;
}
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> P1;
typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
long long dp[3001][50];
int n,m,s;
int main(){
while(1){
memset(dp,0,sizeof(dp));
scanf("%d %d %d",&n,&m,&s);
if(!n) break;
dp[0][0]=1;
for (int i=1;i<=m;i++){
for (int j=n*n;j>=0;j--){
for (int k=i;k<=s;k++){
dp[k][j]+=dp[k-i][j-1];
dp[k][j]%=100000;
}
}
}
printf("%d\n",dp[s][n*n]);
}
}
|
#include<cstdio>
using namespace std;
const int M=100000;
int main(){
for(int n,m,sum;scanf("%d%d%d",&n,&m,&sum),n;){
n*=n;
int dp[50][3001]={}; dp[0][0]=1;
for(int d=1;d<=m;d++){
for(int i=n;i>0;i--)for(int s=d;s<=sum;s++){
dp[i][s]+=dp[i-1][s-d];
if(dp[i][s]>=M) dp[i][s]-=M;
}
}
printf("%d\n",dp[n][sum]);
}
return 0;
}
|
#include <cstdio>
#include <cstring>
#define mod 100000
int n, m, s;
int dp[3001][50];
int main() {
while (scanf("%d%d%d",&n,&m,&s)) {
if (!n&&!m&&!s) break;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for (int i=1; i<=m; i++) {
for (int j=n*n; j>0; j--) {
for (int k=s; k>=i; k--) {
dp[k][j]=(dp[k][j]+dp[k-i][j-1])%mod;
}
}
}
printf("%d\n",dp[s][n*n]);
}
}
|
#include<iostream>
using namespace std;
int N, M, S;
int dp[50][3001];//dp[i][j][k] i????????°??§ j??????????????????????????°
const int MOD = 100000;
int main() {
while (cin >> N >> M >> S, N * M) {
dp[0][0] = 1;
for (int m = 1; m <= M ; m++) {
for (int n = N * N; n > 0; n--) {
for (int s = m; s <= S; s++) {
dp[n][s] += dp[n - 1][s - m];
dp[n][s] %= MOD;
}
}
}
cout << dp[N * N][S] % MOD << endl;
for (int i = 0; i <= N * N; i++)for (int j = 1; j <= S; j++)dp[i][j] = 0;
}
return 0;
}
//I have a little question about this problem.
|
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm> // require sort next_permutation count __gcd reverse etc.
#include <cstdlib> // require abs exit
#include <cstdio> // require scanf printf
#include <functional>
#include <numeric> // require accumulate
#include <cmath>
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip> // require setw
#include <sstream> // require stringstream
#include <cstring> // require memset
#include <cctype> // require tolower, toupper
#include <fstream> // require freopen
#include <ctime>
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()
#define DEBUG 0
using namespace std;
const int mod = 100000;
int dp[55][3005];
int main(void)
{
// freopen ("testcase.bingo", "r", stdin );
int n, m, s; // n: êÓÌ·³ m: g¦éÌãÀ s: lÌa
while (cin >> n >> m >> s && n && m && s ){
memset (dp, 0, sizeof (dp ) );
dp[0][0] = 1;
m = min (m, s );
rep (i, m ){
// for (int i = 1; i <= n*n; i++ ){
for (int j = n*n; j > 0; j-- ){
for (int k = s; k >= n*n - j + 1; k-- ){
dp[j][k] = dp[j-1][k - (n*n-j+1)]+dp[j][k - (n*n-j+1)];
if (dp[j][k] >= mod ) dp[j][k] -= mod;
} // end for
} // end for
} // end rep
cout << dp[n*n][s] << endl;
// cout << (dp[n*n][s] - dp[n*n-1][s] + mod) % mod << endl;
// cout << dp[n*n][s] << endl;
#if DEBUG
rep (i, n*n+1 ){
rep (j, s+1 ){
cout << setw(3) << dp[i][j];
} // end rep
cout << endl;
} // end rep
#endif
} // end while
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
int dp[55][3030];
int main() {
int const MOD = 100000;
for(int N, M, S; cin >> N >> M >> S && (N|M|S);) {
rep(i, 55) rep(j, 3030)
dp[i][j] = 0;
dp[0][0] = 1;
REP(add, 1, M + 1) {
for(int currIndex = N * N; currIndex >= 1; currIndex--) {
for(int currSum = add; currSum <= S; currSum++) {
(dp[currIndex][currSum] += dp[currIndex - 1][currSum - add]) %= MOD;
}
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <functional>
#include <string>
#include <map>
using namespace std;
#define rep(i, n) for(int i = 0; i < int(n); i++)
#define rrep(i, n) for(int i = int(n) - 1; i >= 0; i--)
#define all(co) co.begin(), co.end()
const int INF = 1 << 29;
int dp[51][3001];
signed main()
{
int n, m, s;
while (cin >> n >> m >> s && n)
{
n = n * n;
memset(dp, 0, sizeof(dp));
const int MOD = 100000;
dp[0][0] = 1;
for (int i = 1; i <= m; i++)
{
for (int j = n; j > 0; j--)
{
for (int k = i; k <= s; k++)
{
dp[j][k] += dp[j - 1][k - i];
dp[j][k] %= MOD;
}
}
}
cout << dp[n][s] << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define PB push_back
#define PPB pop_back
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
static const int INF = 1LL << 61;
static const int MOD = 100000;
int dp[55][3005];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, s;
while (cin >> n >> m >> s, n) {
fill(dp[0], dp[55], 0);
dp[0][0] = 1;
for (int i = 1; i <= m; ++i) {
for (int j = n * n; 0 < j; --j) {
for (int k = i; k <= s; ++k) {
dp[j][k] += dp[j - 1][k - i];
dp[j][k] %= MOD;
}
}
}
cout << dp[n * n][s] << endl;
}
}
|
#include<iostream>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
#include<set>
#include<map>
#include<random>
#include<functional>
#include<utility>
typedef long long ll;
#define rep(i,n) for(int i=0; i<n; i++)
#define pb push_back
#define P pair<int, int>
#define PLI pair<ll, int>
using namespace std;
const int MOD = 100000;
int N, M, S;
int dp[50][3005];
int main() {
while (cin >> N >> M >> S, N) {
for (int n = 0; n <= N*N; n++) {
for (int s = 0; s <= S; s++) {
dp[n][s] = 0;
}
}
dp[0][0] = 1;
for (int m = 1; m <= M; m++) {
for (int n = N*N; n >= 1; n--) {
for (int s = m; s <= S; s++) {
dp[n][s] += dp[n - 1][s - m] % MOD;
dp[n][s] %= MOD;
}
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#include<cstdio>
#include<iostream>
using namespace std;
int num[60][3010];
int main(){
int n,m,s;
while(scanf("%d %d %d",&n,&m,&s) && (n||m||s)){
n = n*n;
for(int i=0;i<=n;i++)
for(int j=0;j<=s;j++)num[i][j] = 0;
num[0][0] = 1;
for(int i=1;i<=m;i++){
for(int j=n-1;j>=0;j--){
for(int k=s;k>=0;k--){
if(num[j][k]>0){
if(k+i<=s){
num[j+1][k+i] += num[j][k];
num[j+1][k+i] %= 100000;
}
}
}
}
}
printf("%d\n",num[n][s]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
int dp[55][3030];
int main() {
for(int N, M, S; cin >> N >> M >> S && (N|M|S);) {
rep(i, 55) rep(j, 3030)
dp[i][j] = 0;
dp[0][0] = 1;
REP(add, 1, M + 1) {
for(int index = N*N; index>=1; index--) {
for(int curr=0; curr<=S-add; curr++) {
(dp[index][curr + add] += dp[index - 1][curr]) %= 100000;
}
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#define _USE_MATH_DEFINES
#include <iostream>
#include <memory>
#include <memory.h>
#include <fstream>
#include <cmath>
#include <math.h>
#include <numeric>
#include <vector>
#include <stack>
#include <string>
#include <queue>
#include <sstream>
#include <cstdlib>
#include <cassert>
#include <cstdio>
#include <map>
#include <iomanip>
#include <list>
#include <cctype>
#include <algorithm>
#include <complex>
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, m, n) for(int i = m; i < n; i++)
using namespace std;
typedef complex<double> xy_t;
typedef pair<xy_t, xy_t> line;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<double, double> Pd;
typedef pair<int, P> PP;
typedef pair<int, PP> PPP;
const int INF = 1 << 29;
const double EPS = 1E-10;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, m, n) for(int i = m; i < n; i++)
int dp[51][4000];
const int mod = 100000;
int main(){
int N, M, S;
while(cin >> N >> M >> S && (N || M || S)){
N = N * N;
memset(dp, 0, sizeof(dp));
dp[N][0] = 1;
for(int i = 1; i <= M; i++){
for(int j = 0; j <= N; j++){
for(int s = S; s >= 0; s--){
int c = dp[j][s];
if(s - i >= 0) c += dp[j+1][s-i];
dp[j][s] = c % mod;
}
}
}
cout << dp[0][S] << endl;
}
return 0;
}
|
#include <cstdio>
#include <stack>
#include <cstring>
#include <algorithm>
using namespace std;
#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)
#define rep(i,n) reep(i, 0, n)
const int WIDTH = 3001;
const int HEIGHT = 51;
int main()
{
int* dp = new int[HEIGHT * WIDTH];
int n, m, s;
while(scanf("%d%d%d", &n, &m, &s), n){
n *= n;
fill_n(dp, HEIGHT*WIDTH, 0);
dp[0] = 1;
reep(i, 1, m+1){
for(int j=n; j>=0; --j){
for(int k=s; k>=0; --k){
if(j && i <= k){
dp[j*WIDTH + k] = (dp[j*WIDTH + k] + dp[(j-1)*WIDTH + k-i]) % 100000;
}
}
}
}
// rep(i, n+1){
// rep(j, s+1)
// printf("%d\t", dp[i][j]);
// puts("");
// }
printf("%d\n", dp[n*WIDTH + s]);
}
delete dp;
return 0;
}
|
#include<iostream>
#include<cstring>
using namespace std;
int main(){
int n,m,s;
int dp[50][3001];
while(1){
cin >> n >> m >> s;
if(n == 0 && m == 0 && s == 0) break;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i=1;i<=m;i++){
for(int j=n*n;j>0;j--){
for(int l=i;l<=s;l++){
dp[j][l] = (dp[j][l] + dp[j-1][l-i])%100000;
}
}
}
cout << dp[n*n][s] << endl;
}
}
|
#include <cstdio>
#include <algorithm>
#pragma warning(disable: 4996)
#define MOD 100000
#define MAX_M 2000
#define MAX_S 3000
int N, M, S;
int dp[2][MAX_M + 1][MAX_S + 1];
int main()
{
while (true)
{
scanf("%d", &N);
scanf("%d", &M);
scanf("%d", &S);
if (N == 0 && M == 0 && S == 0) { break; }
for (int i = 0; i < M; i++)
{
for (int j = 0; j < S; j++)
{
if (i == j && i != 0 && j != 0)
{
dp[1][i][j] = 1;
}
else
{
dp[1][i][j] = 0;
}
}
}
int A = N * N;
for (int n = 2; n <= A; n++)
{
for (int i = 0; i < M; i++)
{
dp[n % 2][i][0] = 0;
}
for (int j = 0; j < S; j++)
{
dp[n % 2][0][j] = 0;
}
for (int i = 1; i <= M; i++)
{
for (int j = 1; j <= S; j++)
{
if (n % 2 == 0)
{
dp[0][i][j] = (dp[0][i - 1][j - 1] + (j >= i ? dp[1][i - 1][j - i] : 0)) % MOD;
}
else
{
dp[1][i][j] = (dp[1][i - 1][j - 1] + (j >= i ? dp[0][i - 1][j - i] : 0)) % MOD;
}
}
}
}
int sum = 0;
for (int i = 1; i <= M; i++)
{
if (A % 2 == 0)
{
sum += dp[0][i][S];
}
else
{
sum += dp[1][i][S];
}
sum %= MOD;
}
printf("%d\n", sum);
}
return 0;
}
|
#include<cstdio>
using namespace std;
int n, m, s, dp[50][3001];
int main() {
while (scanf("%d%d%d", &n, &m, &s), n) {
for (int i = 0; i <= n*n; i++) for (int j = 0; j <= s; j++) dp[i][j] = 0;
dp[0][0] = 1;
for (int k = 1; k <= m; k++) {
for (int i = n*n-1; i >= 0; i--) {
for (int j = k; j <= s; j++) dp[i+1][j] = (dp[i+1][j] + dp[i][j-k]) % 100000;
}
}
printf("%d\n", dp[n*n][s]);
}
}
|
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cstring>
#define mod 100000
using namespace std;
int dp[50][3001];
int main(){
int n,m,s;
while(scanf("%d %d %d",&n,&m,&s)){
if(n==0&&m==0&&s==0)
break;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n*n;j>0;j--){
for(int k=i;k<=s;k++){
dp[j][k]=(dp[j][k]+dp[j-1][k-i])%mod;
}
}
}
printf("%d\n",dp[n*n][s]);
}
}
|
#include<iostream>
#include<cstdio>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define MOD 100000
using namespace std;
int N,M,S;
int dp[50][3001];
int main()
{
while(scanf("%d %d %d",&N,&M,&S),N|M|S)
{
rep(i,N*N+1)rep(j,S+1)dp[i][j] = 0;
dp[0][0] = 1;
for(int v=1;v<=M;v++)
{
for(int cnt=N*N-1;cnt>=0;cnt--)
{
for(int def=0;def<=S;def++)
{
if(dp[cnt][def] == 0)continue;
if(def+v <= S)
{
dp[cnt+1][def+v] = (dp[cnt+1][def+v] + dp[cnt][def]) % MOD;
}
}
}
}
printf("%d\n",dp[N*N][S]);
}
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T>
int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
#define rep(i, n) for (int i = 0; i < n; ++i)
template <class T> void max_swap(T& a, const T b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T b) { a = min(a, b); }
const double EPS = 1e-10;
typedef long long ll;
typedef pair<int, int> pint;
int main()
{
int n, m, s;
while (scanf("%d%d%d", &n, &m, &s), n | m | s)
{
int nn = n * n;
// dp[iȺðgÁ½][j(a_jÜÅ)][s] = sum|k=[1..i-1](dp[k][j-1][s-k])
static int dp[50][3001];
const int mod = 100000;
rep (i, nn + 1)
rep (j, s + 1)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 1; i <= m; ++i)
for (int j = nn; j > 0; --j)
for (int k = i; k <= s; ++k)
(dp[j][k] += dp[j - 1][k - i]) %= mod;
printf("%d\n", dp[nn][s]);
}
}
|
#include<bits/stdc++.h>
#define int long long int
#define rep(a,b,c) for(int a=b;a<c;a++)
#define repm(a,b,c) for(int a=(b-1);a>=c;a--)
#define pb push_back
#define str string
#define sf(a) scanfs("%d",&a)
#define pb push_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) (v).begin(), (v).end()
using namespace std;
const int INF = 1e18 + 9;
const int Mod = 1e9 + 7;
inline int replac(str s){double ans=0;rep(i,0,s.length()){ans+=(s[i]-'0')*pow(10,s.length()-i-1);}return (int)ans;}
inline string numstr(int m){str s="";while(m>0){char c;int a=m/10;if(a>0)a=m%(a*10);else a=m;c=(char)('0'+a);s+=c;m/=10;}str st="";for(int i=s.size()-1;i>=0;i--){st+=s[i];}return st;}
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef vector<pii> vii;
int dp[50][3003];
///?£????????£???????????§???????????????????£??????§???????????£???(???????°????????????¨???????¶?...)(?????????????????§???.)
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,m,s;
int mod=100000;
while(1){
cin >> n >> m >> s;
if(n==0&&m==0&&s==0)break;
rep(i,0,50){
rep(j,0,3003){
dp[i][j]=0;
}
}
dp[0][0]=1;
rep(i,1,m+1){
for(int j=n*n;j>0;j--){
rep(k,i,s+1){
(dp[j][k]+=dp[j-1][k-i])%=mod;
}
}
}
cout << dp[n*n][s]%mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(true){
int n,m,s;
cin >> n >> m >> s;
if(n == 0) break;
int ans = 0;
int dp[2][50][3005];
memset(dp,0,sizeof(dp));
dp[0][0][0] = 1;
for (int i = 1;i <= m ;i++){
for (int j = 0;j <= n*n;j++){
for (int k = 0;k <= s;k++){
if(k-i>= 0) dp[i%2][j][k] = dp[(i-1)%2][j][k] + dp[(i-1)%2][j-1][k-i];
else dp[i%2][j][k] = dp[(i-1)%2][j][k];
dp[i%2][j][k] %= 100000;
}
}
}
cout << dp[m%2][n*n][s] << endl;
}
return 0;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
#define reps(i,b,n) for(int i = b ; i < n ; ++i )
#define rep(i,n) reps(i,0,n)
#define INF (1 << 30)
#define MOD 100000
int dp[51][3001],N,M,S;
int main(){
while(cin >> N >> M >> S , N){
fill_n(dp[0],51*3001,0);
dp[0][0] = 1;
for(int i = 1 ; i <= M ; i++ ){
for(int j = N * N ; j > 0 ; j-- ){
for(int k = i ; k <= S ; k++ ){
dp[j][k] = (dp[j][k] + dp[j-1][k-i]) % MOD;
}
}
}
cout << dp[N*N][S] << endl;
}
}
|
#include <iostream>
#include <stack>
#include <map>
#include <algorithm>
#include <sstream>
#include <queue>
#include <string>
#include <cstring>
#include <cmath>
using namespace std;
#define F first
#define S second
const int INF=100000000;
int dp[50][3001];
const int mod=100000;
int main(){
int n,m,s;
while(cin >> n >> m >> s){
if(n==0&&m==0&&s==0) break;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1; i<=m; ++i){
for(int j=n*n; j>0; --j){
for(int k=i; k<=s; ++k){
dp[j][k]+=dp[j-1][k-i]%mod;
}
}
}
cout << dp[n*n][s]%mod << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <cstring>
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, n) for(int i = 0; i < (n); i++)
#define MP make_pair
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> P;
const int INF = 1<<29;
const int MOD = 100000;
ll dp[50][3001];
int main(){
int n, m, s;
while(cin >> n >> m >> s, n|m|s){
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for(int i = 1; i <= m; i++){
for(int j = n*n; j >= 1; j--){
for(int k = i; k <= s; k++){
dp[j][k] += dp[j-1][k-i];
dp[j][k] %= MOD;
}
}
}
cout << dp[n*n][s] << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(){
int N,M,S;
while(cin>>N>>M>>S,N){
vector<vector<int> > dp(N*N+1,vector<int>(S+1));
dp[0][0]=1;
for(int i=0;i<M;i++){
for(int j=N*N-1;j>=0;j--){
for(int k=0;k<S-i;k++){
dp[j+1][k+(i+1)]+=dp[j][k];
dp[j+1][k+(i+1)]%=100000;
}
}
}
cout<<dp[N*N][S]<<endl;
}
}
|
#include <iostream>
#include <cstring>
using namespace std;
const int MAX_N = 7;
const int MAX_S = 3000;
int dp[MAX_N * MAX_N + 1][MAX_S + 1];
int main()
{
int N, M, S;
while (cin >> N >> M >> S, N) {
memset(dp, 0, sizeof dp);
N *= N;
dp[0][0] = 1;
for (int i = 1; i <= M; ++i) {
for (int j = N; j >= 1; --j) {
for (int k = S; k >= i; --k) {
dp[j][k] += dp[j - 1][k - i];
dp[j][k] %= 100000;
}
}
}
cout << dp[N][S] << endl;
}
}
|
#include <iostream>
#include <string>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <utility>
#include <iomanip>
#define ll long long int
#define pb push_back
#define mk make_pair
#define pq priority_queue
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, int> Pl;
const int inf = 1e9;
const ll linf = 1LL << 50;
int n, m, s;
const int mod = 1e5;
ll dp[2][2001][3001];
int main(int argc, char const* argv[])
{
while(true){
scanf("%d %d %d", &n, &m, &s);
if(n == 0)break;
int target = s - n * n * (n * n + 1) / 2;
int sup = m - n * n;
for(int i = 0; i < 2; i++){
for(int j = 0; j <= sup; j++){
for(int k = 0; k <= target; k++){
if(j == 0 && k == 0)dp[i][j][k] = 1;
else dp[i][j][k] = 0;
}
}
}
dp[0][0][0] = 1;
for(int i = 0; i < n * n; i++){
for(int j = 1; j <= sup; j++){
for(int k = 1; k <= target; k++){
dp[(i+1) & 1][j][k] = dp[i & 1][j][k];
if(k - (n * n - i) >= 0)dp[(i+1) & 1][j][k] += dp[(i+1) & 1][j-1][k-(n * n - i)];
dp[(i+1) & 1][j][k] %= mod;
}
}
}
int res = 0;
for(int i = 0; i <= sup; i++)res = (res + dp[(n*n) & 1][i][target]) % mod;
cout << res << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int main ()
{
int n, m, s, dp[50][3001];
while (1)
{
cin>>n>>m>>s;
if (!n) break;
n*=n;
m=min(m, s);
memset(dp, 0, sizeof(dp));
dp[0][0]=1;
for (int i=1; i<=n; i++)
{
for (int j=1; j<=s; j++)
{
if (j>=i) dp[i][j]=dp[i-1][j-i]+dp[i][j-i];
if (j>m) dp[i][j]-=dp[i-1][j-m-1];
dp[i][j]%=100000;
if (dp[i][j]<0) dp[i][j]+=100000;
}
}
cout<<dp[n][s]<<'\n';
}
return 0;
}
|
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef double db;
const ll mod=100000;
ll dp[50][3001];
ll N,M,S;
int main()
{while(1){
scanf("%lld%lld%lld",&N,&M,&S);
if(!N) return 0;
N*=N;
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(ll i=1;i<=M;i++){
for(ll j=N;j>=1;j--){
for(ll k=i;k<=S;k++){
dp[j][k]=(dp[j][k]+dp[j-1][k-i])%mod;
}
}
}
printf("%lld\n",dp[N][S]);
}}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
int DP[2][2002][3001];
int main(){
int n, m, s;
while(true){
cin >> n >> m >> s;
if(n == 0){
break;
}
n *= n;
for(int i = 0; i <= m; i++){
for(int j = 0; j <= s; j++){
DP[0][i][j] = 0;
DP[1][i][j] = 0;
}
DP[1][i][i] = 1;
}
DP[1][0][0] = 0;
for(int i = 2; i <= n; i++){
for(int j = 1; j <= m; j++){
for(int k = j; k <= s; k++){
DP[i % 2][j][k] = DP[i % 2][j - 1][k - 1] + DP[(i + 1) % 2][j - 1][k - j];
DP[i % 2][j][k] %= 100000;
}
}
}
int ans = 0;
for(int i = 0; i <= m; i++){
ans += DP[n % 2][i][s];
ans %= 100000;
}
cout << ans << endl;
}
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
#define rep(i,n) for(i=0;i<n;i++)
#define reps(i,n) for(i=1;i<=n;i++)
int dp[50][2][3001];
int main(){
int n,m,s,nn,st,i,j,k;
int t1=0,t2=1;
while(1){
scanf("%d%d%d",&n,&m,&s);
if(n==0)break;
t1=0;
t2=1;
n*=n;
rep(i,50)rep(j,2)rep(k,s+1)dp[i][j][k]=0;
dp[0][0][0]=1;
reps(j,m){
dp[0][t2][0]=1;
reps(i,n){
nn=i;
st=(nn*(nn+1))/2;
int mm,pp,end;
mm=(j-1)/2;
if(j%2==0)pp=j/2;
else pp=0;
end= min(mm*(mm+1) + pp + st,s+1);
for(k=st-1;k<=end;k++){
dp[i][t2][k]=0;
if(k-j>=0){
dp[i][t2][k]+=dp[i-1][t1][k-j];
}
dp[i][t2][k]+=dp[i][t1][k];
if(dp[i][t2][k]<0)puts("AAAAAAA");
dp[i][t2][k]%=100000;
}
/*
if(i<9&&j<12){
printf("%d %d\n",i,j);
for(int k=0;k<50;k++){
printf("%d ",dp[i][t2][k]);
}puts("");
}*/
}
swap(t1,t2);
}
printf("%d\n",dp[n][t1][s]);
}
}
|
#include <iostream>
using namespace std;
typedef long long ll;
int N,M,S;
int inf = 1e5;
int dp[2][2010][3010] = {};
int main(){
while(cin >> N >> M >> S && N>0){
for(int i=0;i<=M;i++){
for(int j=0;j<=S;j++){
dp[0][i][j] = 0;
dp[1][i][j] = 0;
}
}
dp[0][0][0] = 1;
for(int i=1;i<=N*N;i++){
for(int j=1;j<=M;j++){
for(int k=1;k<=S;k++){
if(k-(N*N-i+1)>=0) dp[i%2][j][k] = (dp[i%2][j-1][k-(N*N-i+1)]+dp[(i+1)%2][j-1][k-(N*N-i+1)])%inf;
}
}
for(int j=0;j<=M;j++) for(int k=0;k<=S;k++) dp[(i+1)%2][j][k] = 0;
}
int ans = 0;
for(int j=1;j<=M;j++){
(ans += dp[(N*N)%2][j][S])%=inf;
}
cout << ans << endl;
}
}
|
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
while(1){
int n,m,s;
static int dp[2][2002][3002];
for(int i=0;i<2;i++)for(int j=0;j<2002;j++)for(int k=0;k<3002;k++)dp[i][j][k]=0;
scanf("%d%d%d",&n,&m,&s);
if(n==0&&m==0&&s==0)break;
for(int j=0;j<=m;j++)dp[0][j][0]=1;
for(int i=1;i<=n*n;i++){
for(int j=1;j<=m;j++){
for(int k=1;k<=s;k++){
if(k-j>=0){
dp[1][j][k]=dp[0][j-1][k-j];
}
dp[1][j][k]+=dp[1][j-1][k];
dp[1][j][k]%=100000;
}
}
for(int j=0;j<=m;j++)for(int k=0;k<=s;k++){dp[0][j][k]=dp[1][j][k]; dp[1][j][k]=0;}
}
printf("%d\n",dp[0][m][s]);
}
}
|
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define mod 100000
int dp[50][3001];
int main(){
int n,m,s;
while(scanf("%d%d%d",&n,&m,&s),(n|m|s)){
for(int i = 0; i < n*n+1; i++){
for(int j = 0; j < s+1; j++){
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for(int i = 1; i < m+1; i++){
for(int j = n*n;j > 0; j--){
for(int k = i; k < s+1; k++){
dp[j][k] += dp[j-1][k-i];
dp[j][k] %= mod;
}
}
}
/*for(int i = 0; i < n*n+1; i++){
for(int j = 0; j < s+1;j++){
printf("%3d",dp[i][j]);
}
puts("");
}*/
printf("%d\n",dp[n*n][s]);
}
return 0;
}
|
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
const int MOD = 100000;
for(;;){
int n, m, s;
cin >> n >> m >> s;
if(n == 0)
return 0;
m = min(m, s);
vector<vector<int> > num(n*n+1, vector<int>(s+1, 0));
num[0][0] = 1;
for(int i=1; i<=m; ++i){
for(int j=n*n; j>0; --j){
for(int k=i; k<=s; ++k){
num[j][k] += num[j-1][k-i];
num[j][k] %= MOD;
}
}
}
cout << num[n*n][s] << endl;
}
}
|
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define MOD 100000
#define rep(i,n) for(i=0;i<(n);i++)
#define loop(i,a,n) for(i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
int dp[2][55][3005];
int main(void) {
int i,j,k;
int n,m,s;
while(1){
cin>>n>>m>>s;
if(n==0)break;
rep(i,2)rep(j,55)rep(k,3005)
dp[i][j][k]=0;
dp[0][0][0]=1;
bool c=false;
rep(i,m){
int cnt=0;
rep(j,n*n+1)rep(k,s+1)if(dp[i%2][j][k]>0){
// cout<<i<<" "<<j<<" "<<k<<" "<<dp[i%2][j][k]<<endl;
(dp[(i+1)%2][j][k]+=dp[i%2][j][k])%=MOD;
if(k+i+1<=s)
(dp[(i+1)%2][j+1][k+i+1]+=dp[i%2][j][k])%=MOD,cnt++;
dp[i%2][j][k]=0;
}
if(c&&cnt==0)break;
if(cnt==0)c=true;
}
cout<<dp[m%2][n*n][s]<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 100000
#define MAX_N 50
#define MAX_S 3001
typedef long long ll;
int main(){
int N,M,S;
while(cin >> N >> M >> S, N){
ll dp[MAX_N][MAX_S] = {{}};
dp[0][0] = 1;
for(int i = 1 ; i <= M ; i++){
for(int j = N*N ; j > 0 ; j--){
for(int k = 0 ; k <= S-i ; k++){
dp[j][k+i] += dp[j-1][k];
dp[j][k+i] %= MOD;
}
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#include <cstdio>
#include <cstring>
int dp[50][3001];
int main() {
int N,M,S;
while(scanf("%d %d %d",&N,&M,&S),N|M|S) {
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int m=1;m<=M;m++) {
for(int n=N*N;n>=1;n--) {
for(int s=m;s<=S;s++) {
dp[n][s]+=dp[n-1][s-m];
if(dp[n][s]>=100000) dp[n][s]-=100000;
}
}
}
printf("%d\n",dp[N*N][S]);
}
}
|
#include <iostream>
#include <cstring>
using namespace std;
int dp[50][3001];
int main() {
int n,m,s;
while(cin >>n>>m>>s,n) {
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for (int i=1; i<=m; ++i)
for (int j=n*n; j>0; --j)
for (int k=s; k>=i; --k)
dp[j][k] = (dp[j][k] + dp[j-1][k-i])%100000;
cout << dp[n*n][s] << endl;
}
}
|
#include <iostream>
#include <cstring>
using namespace std;
int dp[59][3001];
int main(void)
{
while(1)
{
int num,max,sum;
cin >> num >> max >> sum;
if(num+max+sum == 0)
return 0;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int m=1;m<=max;++m)//その数を使ッた時のあれ
{
for(int n=num*num;n>=1;--n)//どの数が使う？(num
{
for(int i=m;i<=sum;++i){//どの数が使う？(sum
dp[n][i] += dp[n-1][i-m];//mを使った時の通り数を足す
dp[n][i] %= 100000;
}
}
}
cout << dp[num*num][sum] << endl;
}
return 0;
}
|
//31
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
for(int n,m,s;cin>>n>>m>>s,n|m|s;){
int dp[2][51][3001]={{{1}}};
for(int i=1;i<=m;i++){
copy(dp[i+1&1][0],dp[(i+1&1)+1][0],dp[i&1][0]);
for(int j=0;j<n*n;j++){
for(int k=0;k+i<=s;k++){
dp[i&1][j+1][k+i]=(dp[i&1][j+1][k+i]+dp[i+1&1][j][k])%100000;
}
}
}
cout<<dp[m&1][n*n][s]<<endl;
}
return 0;
}
|
#include <cstdio>
#include <cstring>
using namespace std;
int main()
{
int dp[50][3001];
int N, M, S;
while (scanf("%d %d %d", &N, &M, &S), N + M + S){
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= M; i++){
for (int j = N * N; j >= 1; j--){
for (int k = S; k >= i; k--){
dp[j][k] = (dp[j][k] + dp[j - 1][k - i]) % 100000;
}
}
}
printf("%d\n", dp[N * N][S]);
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define SQ(x) ((x)*(x))
#define Mod(x, mod) (((x)+(mod)%(mod))
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
#define MOD 100000
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int dp[2][64][4096];
int N, M, S;
int main(){
while(cin >> N >> M >> S){;
if(!N && !M && !S) break;
memset(dp, 0, sizeof(dp));
int res = 0;
int cur, tar;
dp[0][0][0]=1;
REP(i, 1, M+1){
cur = (i+1)%2;
tar = (cur+1)%2;
memset(dp[tar], 0, sizeof(dp[tar]));
rep(j,SQ(N)){
rep(k, S){
if(k+i <= S) dp[tar][j+1][k+i] = (dp[tar][j+1][k+i] + dp[cur][j][k])%MOD;
dp[tar][j][k] = (dp[tar][j][k] + dp[cur][j][k])%MOD;
}
}
/* rep(i, SQ(N)+1){
rep(j, S+1) cout << dp[tar][i][j] << " ";
cout << endl;
}cout<<endl;*/
res = (res+dp[tar][SQ(N)][S])%MOD;
}
// int res = 0;
// REP(i,1, M+1) res = (res+dp[tar][i][S])%MOD;
// cout << res << endl;
cout << res << endl;
}
return 0;
}
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "math.h"
#include "utility"
#include "string"
#include "map"
#include "unordered_map"
#include "iomanip"
#include "random"
using namespace std;
const long long int MOD = 1000000007;
int N, M, S;
int main() {
ios::sync_with_stdio(false);
cin >> N >> M >> S;
while (N) {
int dp[50][3001] = {};
dp[0][0] = 1;
for (int i = 1; i <= M; i++) {
for (int j = N*N; j >= 1; j--) {
for (int k = S; k >= i; k--) {
dp[j][k] += dp[j - 1][k - i];
dp[j][k] %= 100000;
}
}
}
cout << dp[N*N][S] << endl;
cin >> N >> M >> S;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int dp[55][3010];
int n,m,s;
while(1){
for(int i=0;i<55;i++)
for(int j=0;j<3010;j++)dp[i][j]=0;
cin >> n >> m >> s;
if(n==0&&m==0&&s==0)break;
int bin = n*n;
dp[0][0]=1;
for(int k=1;k<=m;k++)
for(int i=bin;i>0;i--){
for(int j=k;j<=s;j++){
dp[i][j] = (dp[i-1][j-k]+dp[i][j])%100000;
}
}
cout << dp[bin][s] << endl;
}
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
int main(){
int dp1[50][3001];
int dp2[50][3001];
// x?????????, ?????¨???????¨???????y
int mod=100000;
int n,m,s;
while(scanf("%d%d%d",&n,&m,&s)){
if(n==0&&m==0&&s==0)
break;
memset(dp1,0,sizeof(dp1));
dp1[0][0]=1;
for(int i=1;i<=m;i++){
memset(dp2,0,sizeof(dp2));
for(int j=0;j<n*n+1;j++){
for(int k=0;k<s+1;k++){
//i???????????´???
if(j<n*n&&k+i<=s){
dp2[j+1][k+i]+=dp1[j][k];
dp2[j+1][k+i]%=mod;
}
//??????????????´???
dp2[j][k]+=dp1[j][k];
dp2[j][k]%=mod;
}
}
//dp2???dp1????????????
for(int j=0;j<n*n+1;j++){
for(int k=0;k<s+1;k++){
dp1[j][k]=dp2[j][k];
}
}
}
printf("%d\n",dp1[n*n][s]);
}
}
|
//TLEしなかったらAOJが神になった証
#include "bits/stdc++.h"
using namespace std;
#define int long long
int mod=1e9+7;
signed main(){
while(true){
int n,m,s;
cin>>n>>m>>s;
if(n==0&&m==0&&s==0)break;
vector<vector<int> > dp(n*n+1,vector<int>(s+1,0));
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n*n-1;j>=0;j--){
for(int k=0;k<s;k++){
if(k+i<=s)(dp[j+1][k+i]+=dp[j][k])%=100000;
}
}
}
cout<<dp[n*n][s]<<endl;
/*
vector<vector<vector<int> > > dp(n*n+1,vector<vector<int> >(s+1,vector<int>(m+1,0)));
dp[0][0][0]=1;
for(int i=0;i<n*n;i++){
for(int j=0;j<s;j++){
for(int k=0;k<m;k++){
for(int l=k+1;l<=m;l++){
if(j+l<=s)(dp[i+1][j+l][l]+=dp[i][j][k])%=100000;
}
}
}
}
int ans=0;
for(int i=1;i<=m;i++)(ans+=dp[n*n][s][i])%=100000;
cout<<ans<<endl;
*/
}
}
|
#include <cstdio>
#include <cstring>
using namespace std;
int n, m, s;
int dp[100][3010];
void solve(){
n *= n;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i = 1; i <= m; i++){
for(int j = n; j > 0; j--){
for(int k = i; k <= s; k++){
dp[j][k] = (dp[j][k]+dp[j-1][k-i])%100000;
}
}
}
printf("%d\n", dp[n][s]);
}
int main(){
while(scanf("%d%d%d",&n,&m,&s),n||m||s) solve();
}
|
//y09-6 ビンゴ(2回目)
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <stack>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <cassert>
using namespace std;
#define LL long long
#undef INT_MIN
#undef INT_MAX
#define INT_MIN -2147483648
#define INT_MAX 2147483647
#define LL_MIN -9223372036854775808
#define LL_MAX 9223372036854775807
#define segment_size 65536
#define ROOP() while (true)
int main(){
ROOP(){
int N,M,S;
cin >> N >> M >> S;
if(N==0) return 0;
M = min(M,S);
int dp[50][3001];
for(int i=0; i<50; i++){
for(int j=0; j<3001; j++){
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for(int i=1; i<=N*N; i++){
for(int j=1; j<=S; j++){
if(j>=i) dp[i][j] = dp[i-1][j-i] + dp[i][j-i];
if(j>M) dp[i][j] -= dp[i-1][j-M-1];
dp[i][j] %= 100000;
if(dp[i][j]<0) dp[i][j]+=100000;
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define reps(i,n) for(int i=1;i<=n;i++)
int dp[50][2][3001];
int main(){
while(1){
int n,m,s;
scanf("%d%d%d",&n,&m,&s);
if(n==0)break;
int t1=0,t2=1;
n*=n;
rep(i,50)rep(j,2)rep(k,s+1)dp[i][j][k]=0;
dp[0][0][0]=1;
reps(j,m){
dp[0][t2][0]=1;
reps(i,n){
int nn=i;
int st=(nn*(nn+1))/2;
for(int k=st-1;k<s+1;k++){
dp[i][t2][k]=0;
if(k-j>=0){
dp[i][t2][k]+=dp[i-1][t1][k-j];
}
dp[i][t2][k]+=dp[i][t1][k];
if(dp[i][t2][k]<0)puts("AAAAAAA");
dp[i][t2][k]%=100000;
}
/*
if(i<9&&j<9){
printf("%d %d\n",i,j);
for(int k=0;k<50;k++){
printf("%d ",dp[i][t2][k]);
}puts("");
}*/
}
swap(t1,t2);
}
printf("%d\n",dp[n][t1][s]);
}
}
|
//Bokann ga bokka--nn!!
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> P1;
typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 2000000000
#define mod 100000
int main(){
int n,m,s;
while(1)
{
int dp[50][3005]={};
cin >> n >> m >> s;
if(!n) return 0;
dp[0][0]=1;
for(int i=1;i<=m;i++)
{
for(int j=n*n;j>=1;j--)
{
for(int k=s;k>=i;k--)
{
dp[j][k]+=dp[j-1][k-i];
dp[j][k]%=mod;
}
}
}
cout << dp[n*n][s] << endl;
}
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
typedef pair<P, P> PPP;
const ll MOD = 1e9 + 7;
const ll INF = 9e18;
const double DINF = 5e14;
const double eps = 1e-10;
const int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 };
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
#define pb push_back
#define eb emplace_back
#define fr first
#define sc second
int n, m, s, mod = 100000;
int main() {
while (true) {
cin >> n >> m >> s;
if (n==0 && m==0 && s==0)break;
vector<vector<int>>dp(n*n + 1, vector<int>(s+1));
dp[0][0] = 1;
for (int i = 1;i <= m;i++) {
for (int j = n * n - 1;j >= 0;j--) {
for (int k = 0;k <= s - i;k++) {
dp[j + 1][k + i] += dp[j][k];
dp[j + 1][k + i] %= mod;
}
}
}
cout << dp[n*n][s] << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e5;
ll partnum[50][3100];
void partition(ll a){
for(ll i = 0; i < 50; i++){
for(ll j = 0; j < 3100; j++){
partnum[i][j] = 0LL;}
}
partnum[0][0] = 1LL;
for(ll i = 0; i <= a; i++){ partnum[1][i] = 1LL;}
for(ll i = 2; i < 50; i++){
for(ll j = 0; j < 3100; j++){
ll res = 0LL;
res += partnum[i-1][j];
if( j-i >= 0){
res += partnum[i][j-i];
if( j-a-i >= 0){
res -= partnum[i-1][j-a-i];
}
}
res = (mod*mod+res)%mod;
partnum[i][j] = res;
}
}
}
int main(){
ll N,M,S;
while( cin >> N >> M >> S){
if( !N && !M && !S){ break;}
ll res = N*N;
M = M-res;
S = S -(res*(res+1))/2;
N = res;
partition(M);
cout << partnum[N][S] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define be(v) (v).begin(),(v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod=1000000007, INF=mod*mod*3LL;
#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll n, m, s, N = 100000;
while(cin >> n >> m >> s, n && m && s){
n *= n;
vector<vector<ll> > dp(n+1, vector<ll> (s+1, 0));
dp[0][0] = 1;
for(int i=1;i<=n;i++){
for(int j=0;j<=s;j++){
if(i<=j) dp[i][j] += dp[i][j-i] + dp[i-1][j-i];
if(j - m - 1 >= 0) dp[i][j] -= dp[i-1][j-m-1];
dp[i][j] %= N;
}
}
cout << (dp[n][s]+N)%N << endl;
}
return 0;
}
|
#include<cstdio>
#include<iostream>
using namespace std;
int num[60][3010];
int main(){
int n,m,s;
while(scanf("%d %d %d",&n,&m,&s) && (n||m||s)){
n = n*n;
for(int i=0;i<=n;i++)
for(int j=0;j<=s;j++)num[i][j] = 0;
num[0][0] = 1;
for(int i=1;i<=m;i++){
for(int j=n-1;j>=0;j--){
for(int k=s-i;k>=0;k--){
if(num[j][k]>0){
num[j+1][k+i] += num[j][k];
num[j+1][k+i] %= 100000;
}
}
}
}
printf("%d\n",num[n][s]);
}
}
|
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int dp[64][4096];
int N,M,S;
int main(){
while(scanf("%d%d%d",&N,&M,&S) && N||M||S){
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for(int i=1;i<=M;i++){
for(int j=N*N;j>=0;j--){
for(int s=1;s<=S;s++){
if(s-i>=0) dp[j+1][s] = (dp[j+1][s]+dp[j][s-i])%100000;
}
}
}
printf("%d\n", dp[N*N][S]);
}
return 0;
}
|
#include <vector>
#include <iostream>
using namespace std;
const int mod = 100000;
int N, M, S;
int main() {
while (cin >> N >> M >> S, N) {
N *= N;
M -= N;
S -= N * (N + 1) / 2;
vector<vector<int> > dp(M + 1, vector<int>(S + 1, 0));
dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
vector<vector<int> > dp2(M + 1, vector<int>(S + 1, 0));
for (int j = 0; j <= M; j++) {
for (int k = j; k <= S; k++) {
dp2[j][k] = dp[j][k - j];
if (j >= 1) {
dp2[j][k] += dp2[j - 1][k - 1];
if (dp2[j][k] >= mod) dp2[j][k] -= mod;
}
}
}
dp = dp2;
}
int ret = 0;
for (int i = 0; i <= M; i++) {
ret += dp[i][S];
if (ret >= mod) ret -= mod;
}
cout << ret << endl;
}
return 0;
}
|
/*#include<stdio.h>
#include<string.h>
int dp[50][2001][3001];
int main(){
memset(dp,0,sizeof(dp));
for(int i=0;i<=2000;i++)dp[0][i][0]=1;
for(int i=1;i<=2000;i++){
for(int j=1;j<=49;j++){
for(int k=0;k<=3000;k++){
dp[j][i][k]+=dp[j][i-1][k];
if(k-i>=0) dp[j][i][k]+=dp[j-1][i-1][k-i];
dp[j][i][k]%=100000;
}
}
}
while(1){
int n,m,s;
scanf("%d %d %d",&n,&m,&s);
if(n==0&&m==0&&s==0) return 0;
printf("%d\n",dp[n*n][m][s]);
}
}*/
#include<stdio.h>
#include<string.h>
int dp[50][3001];
int main(){
memset(dp,0,sizeof(dp));
while(1){
int n,m,s;
scanf("%d %d %d",&n,&m,&s);
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=49;j>=1;j--){
for(int k=3000;k>=0;k--){
if(k-i>=0) dp[j][k]+=dp[j-1][k-i];
dp[j][k]%=100000;
}
}
}
if(n==0&&m==0&&s==0) return 0;
printf("%d\n",dp[n*n][s]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define each(itr,c) for(__typeof(c.begin()) itr=c.begin(); itr!=c.end(); ++itr)
#define all(x) (x).begin(),(x).end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
int dp[50][3001];
int newdp[50][3001];
int main()
{
const int mod=100000;
int n,m,s;
while(cin >>n >>m >>s,n)
{
memset(dp,0,sizeof(dp));
dp[0][0]=1;
//i?????????????????????
for(int i=1; i<=m; ++i)
{
memset(newdp,0,sizeof(newdp));
rep(j,n*n+1)rep(k,s+1)
{
//??????
if(j<n*n && k+i<=s)
{
newdp[j+1][k+i]+=dp[j][k];
newdp[j+1][k+i]%=mod;
}
//????????????
newdp[j][k]+=dp[j][k];
newdp[j][k]%=mod;
}
//copy
rep(j,n*n+1)rep(k,s+1) dp[j][k]=newdp[j][k];
}
cout << dp[n*n][s] << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
const int mod = 100000;
int main(){
int n, m, s;
while(cin >> n >> m >> s, n+m+s){
vector<vector<int>> dp(n*n+1, vector<int>(s+1,0));
dp[0][0] = 1;
for(int i = 1; i <= m; i++){ // 今採用することを検討している数
vector<vector<int>> dp2 = dp;
for(int j = n*n; j >= 1; j--){ // iを含めて、選択した要素数
for(int k = s; k >= 0; k--){ // 今iを採用した時の選択した要素数の総和
if(k >= i) dp2[j][k] = (dp2[j][k] + dp[j-1][k-i])%mod; // iを使う
}
}
dp = dp2;
}
cout << dp[n*n][s] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
int dp[55][3030];
int main() {
int const MOD = 100000;
for(int N, M, S; cin >> N >> M >> S && (N|M|S);) {
rep(i, 55) rep(j, 3030)
dp[i][j] = 0;
dp[0][0] = 1;
REP(i, 1, N * N + 1) {
REP(j, i, S + 1) {
dp[i][j] = (dp[i - 1][j - i] + dp[i][j - i]) % MOD;
if(j >= M+1) {
dp[i][j] -= dp[i - 1][j - M - 1];
(dp[i][j] += MOD) %= MOD;
}
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}
template<typename T>
vector<vector<T> > make_v(size_t a,size_t b){
return vector<vector<T> >(a,make_v<T>(b));
}
template<typename T>
vector<vector<vector<T> > > make_v(size_t a,size_t b,size_t c){
return vector<vector<vector<T> > > (a,make_v<T>(b,c));
}
template<typename T,typename V>
typename enable_if<is_class<T>::value==0>::type
fill_v(T &t,const V &v){t=v;}
template<typename T,typename V>
typename enable_if<is_class<T>::value!=0>::type
fill_v(T &t,const V &v){
for(auto &e:t) fill_v(e,v);
}
//INSERT ABOVE HERE
signed main(){
Int n,m,s;
while(cin>>n>>m>>s,n){
const Int MOD=100000;
int v=n*n;
m-=v;
s-=v*(v+1)/2;
auto dp=make_v<int>(s+1,m+1);
fill_v(dp,0);
dp[0][0]=1;
for(int i=0;i<v;i++){
int c=v-i;
auto nx=make_v<int>(s+1,m+1);
fill_v(nx,0);
for(int j=0;j<=s;j++){
for(int k=0;k<=m;k++){
nx[j][k]+=dp[j][k];
nx[j][k]%=MOD;
if(j+c<=s&&k+1<=m){
dp[j+c][k+1]+=dp[j][k];
dp[j+c][k+1]%=MOD;
}
}
}
swap(dp,nx);
}
int ans=0;
for(int i=0;i<=m;i++){
ans+=dp[s][i];
ans%=MOD;
}
cout<<ans<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define reps(i,j,n) for(int i = (j) ; i < (int)(n) ; ++i)
#define rep(i,n) reps(i,0,n)
#define each(it,c) for(__typeof (c).begin() it = (c).begin(); it != (c).end(); it++)
#define all(v) (v).begin(), (v).end()
#define pb(x) push_back(x)
#define sz(x) (int)((x).size())
#define UNQ(s) {sort(ALL(s));(s).erase(unique(ALL(s)),(s).end());}
#define fr first
#define sc second
typedef pair< int , int > Pi;
typedef pair< int , Pi > Pii;
typedef long long int64;
const int INF = 1 << 30;
template<typename T1, typename T2> istream& operator>>(istream& is, pair<T1,T2>& a){ return is>>a.first>>a.second; }
template<typename T1, typename T2> ostream& operator<<(ostream& os, pair<T1,T2>& a){ return os<<a.first<<" "<<a.second; }
template<typename T> istream& operator>>(istream& is, vector< T >& vc){ rep(i,sz(vc)) is >> vc[i]; return is;}
template<typename T> ostream& operator<<(ostream& os, vector< T >& vc){ rep(i,sz(vc)) os << vc[i] << endl; return os; }
int main(){
int N, M, S, dp[50][3001];
while(cin >> N >> M >> S, N){
fill_n( *dp, 50 * 3001, 0);
dp[0][0] = 1;
for(int i = 1; i <= M; i++){
for(int j = N * N; j > 0; j--){
for(int k = S; k >= i; k--){ // マスまでの総和
(dp[j][k] += dp[j - 1][k - i]) %= 100000;
}
}
}
cout << dp[N * N][S] << endl;
}
return(0);
}
|
#include<stdio.h>
#include<algorithm>
using namespace std;
int MOD=100000;
int dp[2001][3001];
int sum[2001][3001];
int main(){
int a,b,c;
while(scanf("%d%d%d",&a,&b,&c),a+b+c){
for(int i=0;i<2001;i++)
for(int j=0;j<3001;j++)
dp[i][j]=dp[i][j]=sum[i][j]=0;
dp[0][0]=1;
for(int i=0;i<=b;i++){
sum[i][0]=1;
}
for(int i=1;i<=a*a;i++){
// printf("%d %d\n",i,min(b,(a*a-i)?(c/(a*a-i)):b));
for(int j=i;j<=min(b,(a*a-i)?(c/(a*a-i)):b);j++){
for(int k=i*(i+1)/2;k+(a*a-i)*j<=c;k++){
dp[j][k]=sum[j-1][k-j];
}
}
for(int j=i-1;j<=min(b,(a*a-i)?(c/(a*a-i)):b);j++)
for(int k=0;k+(a*a-i)*j<=c;k++)
sum[j][k]=0;
for(int j=i;j<=min(b,(a*a-i)?(c/(a*a-i)):b);j++){
for(int k=i*(i+1)/2;k+(a*a-i)*j<=c;k++){
sum[j][k]=(sum[j-1][k]+dp[j][k]);
if(sum[j][k]>=MOD)sum[j][k]-=MOD;
}
}
}
printf("%d\n",sum[b][c]);
}
}
|
#include"bits/stdc++.h"
int main(){for(int n,m,s,i,j,d[50][3500],M=1e5;std::cin>>n>>m>>s,n*=n;){std::fill(d[0],d[50],M);d[0][0]=1;for(i=1;i<=n;++i)for(j=0;j<=s;++j){if(j>=i)d[i][j]+=d[i-1][j-i]+d[i][j-i];if(j>m)d[i][j]-=d[i-1][j-m-1];d[i][j]%=M;}printf("%d\n",d[n][s]);}}
|
//y09-6 ビンゴ(3回目・自分で)
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <stack>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <cassert>
using namespace std;
#define LL long long
#undef INT_MIN
#undef INT_MAX
#define INT_MIN -2147483648
#define INT_MAX 2147483647
#define LL_MIN -9223372036854775808
#define LL_MAX 9223372036854775807
#define segment_size 65536
#define ROOP() while (true)
//i回目までの合計値がjとなる組み合わせは
//(i) i-1回目に合計値がj-iだった場合の組み合わせ(ピッタリ)
//(ii) i回目に合計値がj-iだった場合の組み合わせ(ここまでに取ってきたすべての値(i個)を1ずつ加算させればjとなる)
//(i),(ii)を合わせたもの
//ただし、合計値jが数字の個数Mを超える場合、(i)でMより大きい数を取ることはできず、
//i-1回目に合計値がj-M-1であったものを引く
int main(){
ROOP(){
int N,M,S;
cin >> N >> M >> S;
if(N==0) return 0;
int dp[50][3001];
for(int i=0; i<50; i++){
for(int j=0; j<3001; j++){
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for(int i=1; i<=N*N; i++){
for(int j=1; j<=S; j++){
if(j>=i){
dp[i][j] = dp[i-1][j-i] + dp[i][j-i];
if(j>M) dp[i][j] -= dp[i-1][j-M-1];
dp[i][j] %= 100000;
if(dp[i][j] < 0) dp[i][j] += 100000;
}
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.