text
stringlengths 49
983k
|
|---|
#include<stdio.h>
int main(void)
{
int i,a,s,d;
for(i=1;i<=4;i++){
scanf("%d %d",&s,&d);
if(s==1){
s=6000;
}
if(s==2){
s=4000;
}
if(s==3){
s=3000;
}
if(s==4){
s=2000;
}
a=s*d;
printf("%d\n",a);
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int a,b,ans;
for(int i=0;i<4;i++){
cin >> a >> b;
if(a==1)ans=6000*b;
else if(a==2)ans=4000*b;
else if(a==3)ans=3000*b;
else if(a==4)ans=2000*b;
cout << ans << endl;
}
}
|
#include <iostream>
using namespace std;
int main(){
int t,n;
for(int i=0;i<4;i++){
cin>>t>>n;
if(t==1)cout<<6000*n<<endl;
else if(t==2)cout<<4000*n<<endl;
else if(t==3)cout<<3000*n<<endl;
else cout<<2000*n<<endl;
}
}
|
#include <iostream>
using namespace std;
int main(){
int a,b;
for (int A=0;A<4;A++){
cin>>a>>b;
if (a==1)cout<<6000*b<<endl;
if (a==2)cout<<4000*b<<endl;
if (a==3)cout<<3000*b<<endl;
if (a==4)cout<<2000*b<<endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int t,n;
for(int i=0;i<4;i++){
cin >> t >> n;
int re;
if(t==1){
re=6000*n;
}else if(t==2){
re=4000*n;
}else if(t==3){
re=3000*n;
}else if(t==4){
re=2000*n;
}
cout<< re << "\n";
}
return 0;
}
|
#include <iostream>
using namespace std;
int price[4] = { 6000, 4000, 3000, 2000 };
int main() {
int t, n;
for (int i=0; i<4; ++i) {
cin >> t >> n;
cout << price[t-1] * n << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
for(int i=0;i<4;i++){
cin >> a >> b;
if(a==1){
cout << b*6000 << endl;
}else if(a==2){
cout << b*4000 << endl;
}else if(a==3){
cout << b*3000 << endl;
}else{
cout << b*2000 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t, n, a[] = {6000, 4000, 3000, 2000};
for (int i = 0; i < 4; i++) {
cin >> t >> n;
cout << a[t-1] * n << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int m[] = {6000,4000,3000,2000};
int a, b;
for(int i=0; i<4; i++) {
cin >> a >> b;
cout << b*m[a-1] << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int price[4] = {6000, 4000, 3000, 2000};
void solve()
{
for(int i = 0; i < 4; ++i)
{
int t, n;
cin >> t >> n;
cout << price[t - 1] * n << endl;
}
}
int main()
{
solve();
return(0);
}
|
#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<vector>
#include<map>
using namespace std;
int main(){
int p[5]={0,6000,4000,3000,2000};
int t,n;
for(int i=0;i<4;i++){
scanf("%d %d",&t,&n);
printf("%d\n",p[t]*n);
}
}
|
#include <iostream>
using namespace std;
int main() {
int money[] = { 0, 6000, 4000, 3000, 2000 };
int s, n;
for (int i = 0; i < 4; i++) {
cin >> s >> n;
cout << money[s] * n << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(void){
int t,n,i;
for(i=0; i<4; i++){
cin>>t>>n;
if(t==1)cout<<6000*n<<endl;
else if(t==2)cout<<4000*n<<endl;
else if(t==3)cout<<3000*n<<endl;
else if(t==4)cout<<2000*n<<endl;
}
return 0;
}
|
#include <iostream>
int main(){
int cost[] = {0, 6000, 4000, 3000, 2000};
int t,n;
for(int i=0; i<4; i++){
std::cin >> t >> n;
std::cout << cost[t]*n << std::endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int kingaku[] ={6000, 4000, 3000, 2000};
for (int i =0; i < 4; i++){
int t,n;
cin >> t >> n;
cout << kingaku[t-1] * n << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main () {
int a[4]={6,4,3,2},b,c,i;
for (i=0;i<4;i++) {
cin >> b >> c;
cout << a[b-1]*c*1000 << endl;
}
return 0;
}
|
#include<stdio.h>
int main(void)
{
int a,b,i,s;
for(i=0;i<4;i++){
scanf("%d %d",&a,&b);
if(a==1){
s=b*6000;
}
if(a==2){
s=b*4000;
}
if(a==3){
s=b*3000;
}
if(a==4){
s=b*2000;
}
printf("%d\n",s);
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
long long t,n,sum=0;
while(cin>>t>>n){
sum=0;
if(t==1)sum+=6000*n;
else if(t==2)sum+=4000*n;
else if(t==3)sum+=3000*n;
else if(t==4)sum+=2000*n;
cout<<sum<<endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
int val[5] = {0, 6000,4000,3000,2000};
rep(i,4){
int t, n;
cin >> t >> n;
cout << val[t]*n << endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
const int p[] = {6000,4000,3000,2000};
int main(){
int t,n;
for(int i=0;i<4;i++){
cin >> t >> n;
cout << p[t-1] * n << endl;
}
}
|
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i < 4; i++) {
int t, n; cin >> t >> n;
if (t == 1) cout << 6000 * n << endl;
if (t == 2) cout << 4000 * n << endl;
if (t == 3) cout << 3000 * n << endl;
if (t == 4) cout << 2000 * n << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int t,n,price[4]={6000,4000,3000,2000};
for(int i=1;i<=4;++i){
cin>>t>>n;
cout<<price[t-1]*n<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(void){
int s[5] = { 0,6000,4000,3000,2000 };
int a, b;
for (int i = 0; i < 4; i++) {
cin >> a >> b;
cout << s[a] * b << endl;
}
}
|
#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 price[] = {0, 6000, 4000, 3000, 2000};
REP(i, 4){
int t, n;
std::cin >> t >> n;
std::cout << price[t] * n << std::endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int a,b;
for(int i=0;i<4;i++){
cin>>a>>b;
if(a==1)
cout<<b*6000<<endl;
if(a==2)
cout<<b*4000<<endl;;
if(a==3)
cout<<b*3000<<endl;
if(a==4)
cout<<b*2000<<endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main()
{
int t,n;
for(int i=0;i<4;i++){
cin>>t>>n;
if(t==1){
cout<<n*6000<<'\n';
}else if(t==2){
cout<<n*4000<<'\n';
}else if(t==3){
cout<<n*3000<<'\n';
}else{
cout<<n*2000<<'\n';
}
}
return(0);
}
|
#include<iostream>
using namespace std;
int main(){
int tick, n;
int temp[5] = {0, 6000, 4000, 3000, 2000};
for(int i=0;i<4;i++){
cin >> tick >> n;
cout << temp[tick] * n << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
vector<int> v = {6000,4000,3000,2000};
int main(){
for(int i=0;i<4;i++){
int t,n;
cin>>t>>n;
cout<<v[t-1]*n<<endl;
}
}
|
#include<stdio.h>
int main(void){
int t,n,i;
for(i=0;i<4;i++){
scanf("%d %d",&t,&n);
if(t==1) printf("%d\n",n*6000);
else if(t==2) printf("%d\n",n*4000);
else if(t==3) printf("%d\n",n*3000);
else printf("%d\n",n*2000);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tmp[] = {6000,4000,3000,2000};
int main(){
int a,b;
for(int i = 0;i < 4;i++){
cin >> a >> b;
cout << tmp[a-1] * b << endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int ticket[]={0,6000,4000,3000,2000};
int t,n;
while(cin>>t>>n)cout<<ticket[t]*n<<endl;
return 0;
}
|
#include<stdio.h>
int c[]={0,6000,4000,3000,2000};
int main(){for(int i=0;i<4;i++){int a,b;scanf("%d%d",&a,&b);printf("%d\n",c[a]*b);}}
|
#define scanf_s scanf
#include<stdio.h>
int main(void) {
int a, b, i, mo[4] = { 6000,4000,3000,2000 };
for (i = 0; i < 4; i++) {
scanf_s("%d %d", &a, &b);
printf("%d\n", mo[a - 1] * b);
}
return(0);
}
|
#include <iostream>
using namespace std;
int main() {
int t,n,s=4;
while(s--) {
cin >> t >>n;
int sum=0;
if(t==1) cout << 6000*n << endl;
else if(t==2) cout << 4000*n << endl;
else if(t==3) cout << 3000*n << endl;
else cout << 2000*n << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int t, n;
for (int i = 0; i < 4; i++) {
cin >> t >> n;
if (t == 1) cout << 6000 * n << endl;
if (t == 2) cout << 4000 * n << endl;
if (t == 3) cout << 3000 * n << endl;
if (t == 4) cout << 2000 * n << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
for(int i=0;i<4;i++){
int a,b;
cin>>a>>b;
if(a==1){
b*=6000;
}
if(a==2) b*=4000;
if(a==3) b*=3000;
if(a==4) b*=2000;
cout<<b<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
int x[4]={6000,4000,3000,2000};
int main(){
int t,n,d[4];
for(int i=0;i<4;i++){ scanf("%d%d",&t,&n); printf("%d\n",n*x[t-1]);}
}
|
#include <iostream>
using namespace std;;
int main(){
int t,n;
for(int i=0;i<4;i++){
cin>>t>>n;
if(t==1) cout<<6000*n<<endl;
if(t==2) cout<<4000*n<<endl;
if(t==3) cout<<3000*n<<endl;
if(t==4) cout<<2000*n<<endl;
}
return 0;
}
|
/*
0277:Ticket Sales
*/
#include <iostream>
#include <cstdio>
using namespace std;
int main(void) {
const int saleTic[4] = { 6000, 4000, 3000, 2000 };
for(int i = 0; i < 4; i++) {
int a, b;
cin >> a >> b;
cout << saleTic[a - 1] * b << endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(void)
{
int t,n;
for(int i=0;i<4;i++){
cin>>t>>n;
if(t==1)cout<<n*6000<<"\n";
else if(t==2)cout<<n*4000<<"\n";
else if(t==3)cout<<n*3000<<"\n";
else cout<<n*2000<<"\n";
}
}
|
#include<stdio.h>
int main(void)
{
int i,a,b,c;
for(i=1;i<=4;i++){
scanf("%d %d",&a,&b);
if(a==1){
c=6000*b;
}
if(a==2){
c=4000*b;
}
if(a==3){
c=3000*b;
}
if(a==4){
c=2000*b;
}
printf("%d\n",c);
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int i=0;
int a=0;
int b=0;
int s[5];
int n[4]={6000,4000,3000,2000};
for(i=0;i<4;i++){
cin>>a>>b;
a--;
s[i]=n[a]*b;
}
for(i=0;i<4;i++){
cout<<s[i]<<endl;
}
}
|
#include<iostream>
using namespace std;
int main(void)
{
int t, n, ans = 0;
for(int i = 0;i < 4; i++){
cin >> t >> n;
if(t == 1) cout << 6000 * n << endl;
if(t == 2) cout << 4000 * n << endl;
if(t == 3) cout << 3000 * n << endl;
if(t == 4) cout << 2000 * n << endl;
}
}
|
#include<iostream>
using namespace std;
int main(){
int ticket[]={6000,4000,3000,2000};
int a,b;
int ans[4]={0};
for(int i=0;i<4;i++){
cin >> a >> b;
ans[i] = b * ticket[a-1];
}
for(int i=0;i<4;i++){
cout << ans[i] << endl;
}
}
|
#include <iostream>
using namespace std;
int main()
{
int a[4]={6000,4000,3000,2000},b,c;
for(int i=0;i<4;i++){
cin>>b>>c;
cout<<c*a[b-1]<<endl;
}
return 0;
}
|
#include<stdio.h>
int main (void)
{
int n,s,m;
int i;
for(i=0;i<4;i++){
scanf("%d %d",&n,&s);
if(n==1){
m=6000*s;
}
else if(n==2){
m=4000*s;
}
else if(n==3){
m=3000*s;
}
else if(n==4){
m=2000*s;
}
printf("%d\n",m);
}
return 0;
}
|
#include <stdio.h>
int main(void){
int price[]={0,6,4,3,2};
int t, n;
for (int i=0; i<4; i++){
scanf("%d %d", &t, &n);
printf("%d\n", price[t]*n*1000);
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int nedan[5] = {0,6,4,3,2};
for(int i=0; i<4; i++){
int a,b;
cin>>a>>b;
cout<<nedan[a]*b*1000<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
int n;
for(int i=0;i<4;++i){
cin>>t>>n;
if(t==1)
cout<<6000*n<<endl;
else if(t==2)
cout<<4000*n<<endl;
else if(t==3)
cout<<3000*n<<endl;
else if(t==4)
cout<<2000*n<<endl;
}
}
|
#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
int N,M,S;
int dp[2][50][3001];
#define AMA (100000)
int solve(){
memset(dp,0,sizeof(dp));
int now;
int next;
int ret = 0;
dp[1][0][0]=1;
for(int m=1;m<=M;m++){
now = m&1;
next = now^1;
memset(dp[next],0,sizeof(dp[next]));
for(int id = 0;id<N*N;id++){
for(int j=0;j<S;j++){
if(!dp[now][id][j]) continue;
if(j+m>S) break;
// printf("dp[%d][%d][%d] = %d , %d\n",m,id,j,dp[now][id][j],j+m);
if(id==N*N-1 && j+m==S) ret+=dp[now][id][j]%AMA;
else {
// printf("%d %d %d next = %d\n",m+1,id,j,dp[next][id][j]);
dp[next][id+1][j+m] += dp[now][id][j]%AMA;
dp[next][id][j] += dp[now][id][j]%AMA;
}
}
}
}
return ret%AMA;
}
int main(){
while(1){
scanf("%d %d %d",&N,&M,&S);
if(!N && !M && !S) break;
printf("%d\n",solve());
}
}
|
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<array>
#include<bitset>
#include<cassert>
#include<cctype>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<functional>
#include<limits>
#include<list>
#include<map>
#include<numeric>
#include<set>
#include<stack>
#include<string>
#include<sstream>
#include<unordered_map>
#include<queue>
#include<vector>
using namespace std;
//#define int long long
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(a) (a).begin(),(a).end()
#define dump(o) {cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) {cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
const int MOD = 100000;
signed main() {
int dp[55][3010] = {};
for (int N, M, S; cin >> N >> M >> S&&N;) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
rep(m, 1, M + 1) {
rrep(i, 1, N*N + 1) {
rep(j, 0, S + 1) {
if (j + m > S)break;
(dp[i][j + m] += dp[i - 1][j]) %= MOD;
}
}
}
cout << dp[N*N][S] << endl;
}
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[2][50][3001];
const int mod = 100000;
rep (i, nn + 1)
rep (j, s + 1)
dp[0][i][j] = dp[1][i][j] = 0;
dp[0][0][0] = 1;
for (int i = 1; i <= m; ++i)
{
int (*prev)[3001] = dp[(i + 1) & 1];
int (*cur)[3001] = dp[i & 1];
rep (j, nn + 1)
rep (k, s + 1)
cur[j][k] = prev[j][k];
for (int j = nn; j > 0; --j)
for (int k = s; k >= i; --k)
(cur[j][k] += prev[j - 1][k - i]) %= mod;
}
printf("%d\n", dp[m & 1][nn][s]);
}
}
|
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <functional>
#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 Fi first
#define Se second
#define INF (1<<29)
#define EPS 1e-10
#define MOD 1000000007
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int N,M,S;
int dp[64][3005];
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=SQ(N);j>=0;j--){
for(int s=0;s+i<=S;s++){
dp[j+1][s+i] = (dp[j+1][s+i] + dp[j][s])%100000;
}
}
}
printf("%d\n", dp[SQ(N)][S]);
}
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
const int MOD = 100000;
int N, M, S;
int dp[50][3010];
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
while (cin >> N >> M >> S, N) {
const int K = N * N;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
REP(i, M) {
for (int j = K - 1; j >= 0; --j) {
for (int k = S; k >= 0; --k) {
if (!dp[j][k]) continue;
if (k + i + 1 <= S) (dp[j + 1][k + i + 1] += dp[j][k]) %= MOD;
}
}
}
cout << dp[K][S] << endl;
}
}
|
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 100000;
int main() {
while (true) {
int n, numLimit, sum;
cin >> n >> numLimit >> sum;
if (n == 0)break;
n *= n;
vector<vector<int>> dp(n + 1, vector<int>(sum + 1));
dp[0][0] = 1;
for (int nowNum = 1; nowNum <= numLimit; nowNum++) {
for (int backCount = n - 1; backCount >= 0; backCount--) {
for (int backSum = sum - nowNum; backSum >= 0; backSum--) {
dp[backCount + 1][backSum + nowNum] += dp[backCount][backSum];
dp[backCount + 1][backSum + nowNum] %= MOD;
}
}
}
cout << dp[n][sum] << 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]);
if(dp[j][k] >= MOD) dp[j][k] -= 100000;
}
}
}
cout << dp[N*N][S] << endl;
}
}
|
#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <map>
#include <stack>
#include <queue>
#include <set>
#include <cstring>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) unique(v.begin(), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for(int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for(int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int> >
#define all(v) (v).begin(), (v).end()
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e18;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
vector<ll> rsl;
int mod = 100000;
while(true) {
int N, M, S;
cin >> N >> M >> S;
if(N == 0 and M == 0 and S == 0) break;
int k = N * N;
int n = S - k * (k + 1) / 2;
int m = M - k;
ll dp[k + 1][n + 1];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
rep(i, 1, k + 1) rep(j, 0, n + 1) {
if(j - i >= 0) {
dp[i][j] = (dp[i - 1][j] + dp[i][j - i]) % mod;
if(j - i - m >= 0) (dp[i][j] -= dp[i - 1][j - i - m]) %= mod;
} else dp[i][j] = dp[i - 1][j];
}
rsl.push_back(dp[k][n]);
}
rep(i, 0, rsl.size()) cout << rsl[i] << endl;
}
|
/* 剰余取り忘れてしもたwガハハw */
#include <stdio.h>
#include <string.h>
int dp[50][3001];
int main() {
while (1) {
int i;
int n, m, s;
int square;
scanf("%d %d %d", &n, &m, &s);
if (n == 0 && m == 0 && s == 0) {
return 0;
}
memset(dp, 0, sizeof(dp));
square = n*n;
dp[0][0] = 1;
for (i=1; i<m+1; i++) {
int j;
for (j=s; j>=i; j--) {
int k;
for (k=0; k<square; k++) {
dp[k+1][j] += dp[k][j-i];
dp[k+1][j] %= 100000;
}
}
}
printf("%d\n", dp[square][s]);
}
}
|
#include <cstdio>
#include <algorithm>
int N, M, S;
int dp[2][2001][3001];
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 = 1; i <= M; i++)
{
for (int j = 1; j <= S; j++)
{
if (j >= i)
{
dp[n % 2][i][j] = (dp[n % 2][i - 1][j - 1] + dp[(n + 1) % 2][i - 1][j - i]) % 100000;
}
}
}
}
int sum = 0;
for (int i = 1; i <= M; i++)
{
sum += dp[A % 2][i][S];
sum %= 100000;
}
printf("%d\n", sum);
}
return 0;
}
|
#include<stdio.h>
int main()
{
int N,M,S,i,j,k,MOD=100000;
while(scanf("%d%d%d",&N,&M,&S),N)
{
int dp[50][3001]={1};
for(i=M;i>0;--i)
for(j=N*N;j>0;--j)
for(k=S-i;k>=0;--k)
{
int &r=dp[j][i+k];
r=(r+dp[j-1][k])%MOD;
}
printf("%d\n",dp[N*N][S]);
}
return 0;
}
|
#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++)
{
sum += dp[A % 2][i][S];
sum %= MOD;
}
printf("%d\n", sum);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;int d[51][3210],n,m,s,i,j,k;int main(){while(cin>>n>>m>>s&&n){n*=n;memset(d,0,sizeof(d));d[0][0]=1;for(k=1;k<=m;k++)for(i=n;i;i--)for(j=k;j<=s;j++)d[i][j]=(d[i][j]+d[i-1][j-k])%100000;cout<<d[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>
#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()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e9;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
int main(){
int n,m,s;
while(cin>>n>>m>>s,n){
int N=n*n;
vvi dp(N+1,vi(s+1));
dp[0][0]=1;
loop(k,1,m+1)for(int i=N-1;i>=0;i--)rep(j,s){
if(j+k>s)continue;
dp[i+1][j+k]+=dp[i][j];
dp[i+1][j+k]%=100000;
}
cout<<dp[N][s]<<endl;
}
}
|
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
const int mod = 100000;
for(int n, m, s; cin >> n >> m >> s, n;) {
vector<vector<int> > dp(s + 1, vector<int>(n * n + 1, 0));
dp[0][0] = 1;
for(int i = 1; i <= m; ++i) {
for(int j = s - i; j >= 0; --j) {
for(int k = 0; k < n * n; ++k) {
if(dp[j][k] == 0)
continue;
dp[j + i][k + 1] += dp[j][k];
dp[j + i][k + 1] %= mod;
}
}
}
cout << dp[s][n * n] << endl;
}
return EXIT_SUCCESS;
}
|
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <complex>
#include <string>
#include <sstream>
#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 long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define SORT(x) sort((x).begin(),(x).end())
#define all(x) (x).begin(),(x).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define MOD 100000
int main()
{
while(1)
{
int dp[50][3010];
memset(dp,0,sizeof(dp));
dp[0][0]=1;
int n,m,s;
cin >> n >> m >> s;
if(n==0&&m==0&&s==0)break;
for(int i=1;i<=m;i++)
{
for(int j=n*n-1;j>=0;j--)
{
for(int k=i;k<=s;k++)
{
dp[j+1][k]+=dp[j][k-i];
dp[j+1][k]%=MOD;
}
}
}
cout << dp[n*n][s] << endl;
}
return 0;
}
|
#include <cstdio>
#include <cstring>
using namespace std;
int d[50][3001];
int main() {
int n,m,s;
while(scanf("%d%d%d",&n,&m,&s),n) {memset(d,0,sizeof(d));
d[0][0]=1;for (int i=1;i<=m;++i)for (int j=n*n;j;--j)for (int k=s;k>=i;--k)
d[j][k]=(d[j][k]+d[j-1][k-i])%100000;
printf("%d\n",d[n*n][s]);
}
}
|
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#include <stack>
#include <bitset>
#include <utility>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cctype>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define repa(i,s,e) for(int i=s; i<=e; i++)
#define repd(i,s,e) for(int i=s; i>=e; i--)
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
const int MAX_N = 7;
const int CSIZE = 50;
const int MAX_S = 3001;
int N, M, S;
int dp[CSIZE][MAX_S];
void solve() {
memset(dp, 0, sizeof(dp));
int n2 = N * N;
dp[0][0] = 1;
repa(k,1,M) {
repd(i,n2,1) {
repa(j,0,S) {
if(j - k >= 0) {
dp[i][j] += dp[i-1][j-k];
if(dp[i][j] > 100000) {
dp[i][j] -= 100000;
}
}
}
}
}
printf("%d\n", dp[n2][S]);
}
int main() {
while(scanf("%d%d%d", &N, &M, &S), N | M | S) {
solve();
}
}
|
#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int N,M,S;
while(1){
int fie[51][3002]={0};
cin>>N>>M>>S;
if(N==0&&M==0&&S==0)break;
fie[0][0]=1;
for(int i=1;i<=M;i++){
for(int j=N*N;0<=j;j--){
for(int k=S;0<=k;k--){
if(k+i<=3000)fie[j+1][k+i]+=fie[j][k];
fie[j][k]%=100000;
}
}
}
cout<<fie[N*N][S]%100000<<endl;
}
return 0;
}
|
#include <stdio.h>
int dp[50][3333];
int dpw[50][3333];
int main()
{
while(1)
{
int n,m,s;
scanf("%d %d %d",&n,&m,&s);
if(n == 0)
{
break;
}
n *= n;
for(int i = 0; i < n; i++)
{
for(int ii = 0; ii <= s; ii++)
{
dp[i][ii] = 0;
}
}
for(int i = 1; i <= m; i++)
{
for(int ii = 0; ii < n; ii++)
{
for(int iii = 0; iii <= s; iii++)
{
dpw[ii][iii] = dp[ii][iii];
}
}
for(int ii = 0; ii < n - 1; ii++)
{
for(int iii = 0; iii < s; iii++)
{
if(i + iii <= s)
{
dpw[ii + 1][i + iii] += dp[ii][iii];
}
}
}
dpw[0][i] += 1;
for(int ii = 0; ii < n; ii++)
{
for(int iii = 0; iii <= s; iii++)
{
dp[ii][iii] = dpw[ii][iii] % 100000;
}
}
}
printf("%d\n",dp[n - 1][s]);
}
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int n,m,s;
int dp[55][3003];
int main(void){
while(cin >> n >> m >> s && n){
memset(dp,0,sizeof(dp));
dp[n*n][s] = 1;
for(int i = 1; i <= m; i++){
for(int j = 0; j < n*n; j++){
for(int k = 0; k+i <= s; k++){
dp[j][k] += dp[j + 1][k + i];
dp[j][k] %= 100000;
}
}
}
cout << dp[0][0] << endl;
}
}
|
#include <iostream>
#include <vector>
template <class T>
std::vector<T> vec(int len, T elem) { return std::vector<T>(len, elem); }
constexpr int MOD = 100000;
bool solve() {
int n, m, s;
std::cin >> n >> m >> s;
if (n == 0) return false;
n *= n;
auto dp = vec(n + 1, vec(s + 1, 0));
dp[0][0] = 1;
for (int x = 1; x <= m; ++x) {
for (int i = n - 1; i >= 0; --i) {
for (int y = 0; y + x <= s; ++y) {
dp[i + 1][y + x] += dp[i][y];
if (dp[i + 1][y + x] >= MOD) dp[i + 1][y + x] -= MOD;
}
}
}
std::cout << dp[n][s] << "\n";
return true;
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
while (solve()) {}
return 0;
}
|
#include<iostream>
#include<cstdio>
using namespace std;
#define LATTE 100000
int dp[2][2001][3001];
int main(){
int N,M,S;
while(cin>>N>>M>>S, N||M||S){
for(int i=1;i<=M;i++)for(int j=1;j<=S;j++) dp[0][i][j]=dp[1][i][j]=0;
for(int i=1;i<=M;i++){
dp[1][i][i]=1;
}
for(int i=1;i<N*N;i++){
for(int j=1;j<=M;j++){
for(int k=1;k<=S;k++){
//printf("%d,%d,%d\n",i,j,k);
if(k+j+1<=S && j+1<=M){
dp[(i+1)&1][j+1][k+j+1] +=
dp[i&1][j][k]+dp[(i+1)&1][j][k+j];
dp[(i+1)&1][j+1][k+j+1]%=LATTE;
}
dp[i&1][j][k]=0;
/*for(int l=j+1;l<=50;l++){
dp[i+1][l][k+l] += dp[i][j][k];
dp[i+1][l][k+l]%=LATTE;
}*/
}
}
}
int ans=0;
for(int i=1;i<=M;i++){
ans += dp[(N*N)&1][i][S];
}
printf("%d\n",ans%LATTE);
}
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <utility>
#include <cmath>
#include <map>
#include <set>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define INF_LL 1e18
#define INF 1e9
#define REP(i, n) for(int i = 0;i < (n);i++)
#define FOR(i, a, b) for(int i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fst first
#define snd second
using namespace std;
using ll = long long;
using PII = pair<int, int>;
class Union_find{
private:
vector<int> par;
vector<int> rank;
int n;
public:
Union_find(int a){
n = a;
for(int i = 0;i < n;i++){
par.push_back(i);
rank.push_back(0);
}
}
int find(int x){
if(par[x] == x){
return x;
}else{
return par[x] = find(par[x]);
}
}
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y) return;
if(rank[x] < rank[y]){
par[x] = y;
}else{
par[y] = x;
if(rank[x] == rank[y]) rank[x]++;
}
}
bool same(int x, int y){
return find(x) == find(y);
}
};
int dp[2][2020][3030] = {};
int main(void){
int N, M, S;
while(cin >> N >> M >> S && N && M && S){
memset(dp, 0, sizeof dp);
FOR(i, 1, M+1){
dp[1][i][i] = dp[1][i-1][i] + 1;
}
FOR(i, 2, N*N+1){
memset(dp[i%2], 0, sizeof dp[i%2]);
FOR(j, i, M+1){
FOR(k, 1, S+1){
dp[(i+1)%2][j-1][k] += dp[(i+1)%2][j-2][k];
if(k >= j){
dp[i%2][j][k] += dp[(i+1)%2][min(k, j-1)][k-j];
dp[i%2][j][k] = dp[i%2][j][k] % 100000;
}
}
}
}
ll res = 0;
REP(i, M+1){
res += dp[(N*N)%2][i][S];
res = res % 100000;
}
cout << res << endl;
}
}
|
#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int N, M, S;
typedef long long int ll;
int DP[2001][3001];
int MOD = 100000;
int main()
{
while (true){
scanf("%d%d%d", &N, &M, &S);
if (N == 0 && M == 0 && S == 0)break;
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 i = 1; i <= M; i++){
for (int j = S; j >= 0; j--){
if (j + i <= S){
for (int k = 1; k <= N*N; k++){
DP[k][j + i] = (DP[k][j + i] + DP[k - 1][j]) % MOD;
}
}
}
}
int ans = 0;
printf("%d\n", DP[N*N][S]%MOD);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e5;
int main() {
int N, M, S;
while (true) {
cin >> N >> M >> S;
if (N == 0) break;
long long dp[N * N + 1][S + 1];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= N * N; ++i) {
for (int j = 0; j <= S; ++j) {
if (j >= i) (dp[i][j] += dp[i][j - i] + dp[i - 1][j - i]) %= mod;
if (j >= M + 1) (dp[i][j] += mod - dp[i - 1][j - (M + 1)]) %= mod;
}
}
cout << dp[N * N][S] << endl;
}
return 0;
}
|
# include <iostream>
# include <algorithm>
# include <vector>
# include <string>
# include <set>
# include <map>
# include <cmath>
# include <iomanip>
# include <functional>
# include <utility>
# include <stack>
# include <queue>
# include <list>
# include <tuple>
# include <unordered_map>
# include <numeric>
# include <complex>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
constexpr int INF = 2000000000;
constexpr int HINF = INF / 2;
constexpr double DINF = 100000000000000000.0;
constexpr long long LINF = 9223372036854775807;
constexpr long long HLINF = 4500000000000000000;
const double PI = acos(-1);
int dx[4] = { 0,1,0,-1 }, dy[4] = { 1,0,-1,0 };
# define ALL(x) (x).begin(),(x).end()
# define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
# define mp make_pair
# define eb emplace_back
# define FOR(i,a,b) for(int i=(a);i<(b);++i)
# define REP(i,n) FOR(i,0,n)
# define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
const int MOD = 100000;
LL n, m, s;
LL dp[50][4005];
int main() {
while ((cin >> n >> m >> s) && (n || m || s)){
n *= n;
for (int i = 0; i < 50; i++)for (int j = 0; j < 4005; j++)dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 1; i <= m; i++) {
for (LL j = n; j >= 1; j--) {
for (int k = i; k <= s; k++) {
(dp[j][k] += dp[j - 1][k - i]) %= MOD;
}
}
}
cout << dp[n][s] << endl;
}
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
int main(){
int n,m,s;
while(cin>>n>>m>>s&&(n||m||s)){
ll dp[51][3001] = {};
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n*n;j>=1;j--){
for(int k=1;k<=s;k++){
if(k-i>=0)dp[j][k] = ( dp[j][k] + dp[j-1][k-i] )%100000 ;
}
}
}
cout<<dp[n*n][s]<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int mod=100000;
int N,M,S;
int dp[2001][3001];
int dpsum[2001][3001];
//int dp1[2009][3009];
int main()
{
while(true){
scanf("%d%d%d",&N,&M,&S);
if(N==0&&M==0&&S==0)break;
for(int i=0;i<=M;i++){
for(int j=0;j<=S;j++){
dp[i][j]=0;dpsum[i][j]=0;
}
}
dp[0][0]=1;
for(int i=1;i<=N*N;i++){
for(int j=i-1;j<=M;j++){
int xx=S;
for(int k=i+1;k<=N*N;k++){
xx-=(j+k-i-1);
}
for(int k=i*(i-1)/2;k<=xx;k++){
if(j!=0){
dpsum[j][k]=dpsum[j-1][k]+dp[j][k];
if(dpsum[j][k]>=mod)dpsum[j][k]-=mod;
}
else{
dpsum[j][k]=dp[j][k];
}
/*
if(j+k+1<=S){
dp1[j+1][j+k+1]=dpsum[j][k];
}*/
//dp1[l][k+l]
/*
if(dp[j][k]==0)continue;
for(int l=j+1;l<=M;l++){
if(k+l<=S){
dp1[l][k+l]+=dp[j][k];
if(dp1[l][k+l]>=mod)dp1[l][k+l]-=mod;
}
}*/
}
}
for(int j=0;j<=M;j++){
for(int k=j;k<=S;k++){
dp[j][k]=0;
}
}
for(int j=0;j<=M;j++){
for(int k=0;k<=S-j-1;k++){
dp[j+1][j+k+1]=dpsum[j][k];dpsum[j][k]=0;
}
}
/*
for(int j=0;j<=M;j++){
for(int k=0;k<=S;k++){
if(dp[j][k]!=0)printf("%d %d %d:%d\n",i,j,k,dp[j][k]);
}
}*/
}
int ans=0;
for(int j=1;j<=M;j++){
//printf("")
ans+=dp[j][S];ans%=mod;
}
printf("%d\n",ans);
}
return 0;
}
|
#include <iostream>
#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>
#include <algorithm>
#include <vector>
using namespace std;
#define UNDEF -1
int N,M,S,dp[2001][3001];
int ths(int begin,int end,int count)
{
return ((begin + end) * count) / 2;
}
int main(void)
{
while(true)
{
cin >> N >> M >> S;
if(N == 0 && M == 0 && S == 0)
exit(0);
for(int i = 0;i < 2001;i++)
{
for(int ii = 0;ii < 3001;ii++)
dp[i][ii] = 0;
}
dp[0][0] = 1;
int t = ths(1,N*N,N*N);
for(int i = 1;i <= N * N;i++)
{
for(int j = 0;j < M-(N*N);j++)
{
for(int k = 0;k < S - t;k++)
{
if(j < 2000 && k+i < 3001)
dp[j+1][k+i] = (dp[j+1][k+i] + dp[j][k]) % 100000;
}
}
}
int result = 0;
for(int i = 0;i <= M - (N*N);i++)
{
result = (result + dp[i][S - t]) % 100000;
}
cout << result << endl;
}
}
|
#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])%MOD;
}
}
printf("%d\n",sum[b][c]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1.1e9
#define LINF 1.1e18
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = (n) - 1; i >= 0; i--)
#define ALL(v) (v).begin(), (v).end()
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define BIT(x, n) bitset<n>(x)
#define PI 3.14159265358979323846
typedef long long ll;
typedef pair< int, int > P;
typedef pair< int, P > PP;
//-------------------------------------------------
int n, m, s;
const int MOD = 100000;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(true) {
cin >> n >> m >> s;
if (n == 0) break;
int dp[50][3010] = {};
dp[0][0] = 1;
for (int j = 1; j <= m; j++) {
for (int i = n * n - 1; i >= 0; i--) {
for (int k = s - j; k >= 0; k--) {
if (dp[i][k] > 0) {
dp[i + 1][k + j] += dp[i][k];
dp[i + 1][k + j] %= MOD;
}
}
}
}
cout << dp[n * n][s] << endl;
}
return 0;
}
|
#include <cstdio>
#include <cstring>
using namespace std;
#define MAX_N 7
#define MAX_S 3000
#define MOD 100000
int dp[MAX_N * MAX_N + 1][MAX_S + 1];
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 k = 1; k <= M; ++k) {
for (int i = N * N; i >= 1; --i) {
for (int j = k; j <= S; ++j) {
dp[i][j] += dp[i - 1][j - k];
dp[i][j] %= MOD;
}
}
}
printf("%d\n", dp[N * N][S]);
}
}
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<cstdio>
#include<cstring>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(n) rep(i,n)
#define all(n) n.begin(),n.end()
const int MAXN = 7, MAXS = 3000 ;
int n, m, s;
unsigned int dp[MAXN * MAXN + 2][MAXS + 10], UB = 100000;
int main()
{
while(cin >> n >> m >> s && n)
{
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for(int i_m = 1; i_m <= m; i_m++)
for(int i_n = n * n + 1; i_n > 0; i_n--)
for(int i_s = s; i_s > 0; i_s--)
if(i_s - i_m >= 0)
dp[i_n][i_s] =
(dp[i_n][i_s] + dp[i_n - 1][i_s - i_m]) % UB;
//rep(i,n*n){rep(j,s) cout << dp[i][j] << ","; cout << endl;}
cout << dp[n * n][s] << 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++) {
for (int j = S; j >= i; j--) {
for (int k = N; k > 0; k--) {
(dp[j][k] += dp[j - i][k - 1]) %= mod;
}
}
}
printf("%d\n", dp[S][N]);
}
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std ;
const int M = 100000;
int main(){
int n, m, s, dp[50][3001];
while(cin >> n >> m >> s && (n|m|s)){
fill(dp[0], dp[50], 0);
dp[0][0] = 1;
for(int k=1;k<=m;k++){
for(int i=n*n;i>0;i--){
for(int j=k;j<=s;j++){
dp[i][j] = (dp[i][j] + dp[i-1][j-k]) % M;
}
}
}
cout << dp[n*n][s] << 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<=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] %= 100000;
}
}
}
cout << dp[N*N][S] << endl;
}
return 0;
}
|
#include<iostream>
#include<sstream>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<algorithm>
#include<numeric>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#define rep(i,n) for(int i=0;i<n;i++)
#define all(c) (c).begin(),(c).end()
#define mp make_pair
#define pb push_back
#define rp(i,c) rep(i,(c).size())
#define fr(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define dbg(x) cerr<<#x<<" = "<<(x)<<endl
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
const int inf=1<<28;
const double INF=1e12,EPS=1e-9;
int n,m,s;
int dp[50][3001];
int main()
{
while(scanf("%d%d%d",&n,&m,&s),n){
rep(i,n*n+1)rep(j,s+1)dp[i][j]=0;
dp[0][0]=1;
m=min(m,s);
rep(i,m){
for(int j=n*n;j>0;j--)for(int k=s;k>n*n-j;k--){
dp[j][k]=dp[j-1][k-(n*n-j+1)]+dp[j][k-(n*n-j+1)];
if(dp[j][k]>100000)dp[j][k]-=100000;
}
}
printf("%d\n",dp[n*n][s]);
}
return 0;
}
|
#include<iostream>
using namespace std;
typedef long long ll;
ll mod=100000;
int N,M,S;
ll dp[50][3001];
void init(){
for(int i=0;i<50;i++)
for(int j=0;j<3001;j++)
dp[i][j]=0;
dp[0][0]=1;
}
int main(){
while(1){
cin>>N>>M>>S;
if(N==0&&M==0&&S==0)break;
init();
for(int i=1;i<=N*N;i++){
for(int j=0;j<=S;j++){
if(j-i>=0)dp[i][j]+=dp[i-1][j-i];
if(j-i>=0)dp[i][j]+=dp[i][j-i];
if(j-M-1>=0)dp[i][j]+=(mod-dp[i-1][j-M-1]);
dp[i][j]%=mod;
}
}
cout<<dp[N*N][S]<<endl;
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
int main(){
int n,m,s;
while(cin>>n>>m>>s){
if(n==0&&m==0&&s==0)break;
static int dp[2][2300][3300];
rep(i,2)rep(j,2300)rep(k,3300)dp[i][j][k]=0;
dp[0][0][0] = 1;
for(int i=1;i<=n*n;i++){
for(int j=0;j<2300;j++)
for(int k=0;k<3300;k++)
dp[i%2][j][k] = 0;
for(int j=1;j<=m;j++){
for(int k=1;k<=s;k++){
if(k-j>=0){
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;
}
}
}
}
ll ans = 0;
for(int i=0;i<=m;i++){
ans+=dp[(n*n)%2][i][s];
ans%=100000;
}
cout<<ans<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int dp[2][2000][3000];
signed main() {
int a, b, c;
while (cin >> a >> b >> c, a || b || c) {
a *= a;
c -= a*(a + 1) / 2;
b -= a;
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int d = 1; d <= a; d++) {
memset(dp[d & 1], 0, sizeof(dp[d & 1]));
for (int e = 0; e <= b; e++) {
for (int f = 0; f <= c; f++) {
dp[d & 1][e][f] = dp[(d + 1) & 1][e][f];
if (e >= 1 && f >= (a - d + 1)) {
dp[d & 1][e][f] = (dp[d & 1][e][f] + dp[d & 1][e - 1][f - (a - d + 1)])%100000;
}
}
}
}
int sum = 0;
for (int i = 0; i <= b; i++) {
sum = (sum+dp[a & 1][i][c])%100000;
}
cout << sum << endl;
}
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
int dp[2][2300][3300];
int main(){
int n,m,s;
while(cin>>n>>m>>s){
if(n==0&&m==0&&s==0)break;
rep(i,2)rep(j,2300)rep(k,3300)dp[i][j][k]=0;
dp[0][0][0] = 1;
for(int i=1;i<=n*n;i++){
for(int j=0;j<2300;j++)
for(int k=0;k<3300;k++)
dp[i%2][j][k] = 0;
for(int j=1;j<=m;j++){
for(int k=1;k<=s;k++){
if(k-j>=0){
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;
}
}
}
}
ll ans = 0;
for(int i=0;i<=m;i++){
ans+=dp[(n*n)%2][i][s];
ans%=100000;
}
cout<<ans<<endl;
}
}
|
#include <iostream>
#include <cstring>
using namespace std;
int n,m,s;
int dp[50][3001];
int main(){
while(cin >> n >> m >> s && n){
n *= n;
m = min(m,s);
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int j = 1 ; j <= m ; j++){
for(int k = s-j ; k >= 0 ; k--){
for(int i = 1 ; i <= n ; i++){
(dp[i][k+j] += dp[i-1][k])%=100000;
}
}
}
cout << dp[n][s] << endl;
}
}
|
#include<iostream>
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;
for(int j=0;j<=m;j++)
for(int k=0;k<=s;k++)
dp[0][j][k]=0;
dp[0][0][0]=1;
for(int i=0;i<=n;i++){
int now=i&1;
int next=now^1;
for(int j=0;j<=m;j++)
for(int k=0;k<=s;k++)
dp[next][j][k]=0;
for(int j=0;j<m;j++){
for(int k=0;k<=s;k++){
if(dp[now][j][k]==0)continue;
(dp[now][j+1][k]+=dp[now][j][k]) %= mod;
if(k+j+1<= s)(dp[next][j+1][k+j+1]+=dp[now][j][k]) %= mod;
//cout << dp[now][j+1][k] << " " ;
}
//cout << endl;
}
//cout << endl;
}
cout << dp[n&1][m][s] << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
#include <functional>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define rep1(i,n) for(int i=1;i<=(n);++i)
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl;
int mod=100000;
int dp[2][50][3001];
void add(int& x,int y){
x+=y;
if(x>=mod) x-=mod;
}
int main(){
while(true){
int n,m,s;
scanf("%d%d%d",&n,&m,&s);
if(n==0) break;
n=n*n;
rep(j,n+1) rep(k,s+1) dp[0][j][k]=0;
dp[0][0][0]=1;
rep(i,m){
rep(j,n+1) rep(k,s+1) dp[1-i%2][j][k]=0;
rep(j,n+1){
rep(k,s+1){
if((i*2+1+n-j)*(n-j)/2>s) break;
add(dp[1-i%2][j][k],dp[i%2][j][k]);
if(j+1<=n&&k+i+1<=s) add(dp[1-i%2][j+1][k+i+1],dp[i%2][j][k]);
}
}
}
cout<<dp[m%2][n][s]<<endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
#define MOD 100000
int N, M, S;
int dp[2][2001][2001];
int T[2001][2001];
int main() {
while (cin >> N >> M >> S) {
if (N == 0 && M == 0 && S == 0) break;
for (int j=1; j<=M; j++) {
for (int k=1; k<=S; k++) {
dp[0][j][k] = 0;
}
}
N *= N;
S -= N*(N+1) / 2;
M = min(M - N, S);
for (int i=0; i<=M; i++) dp[0][i][i] = 1;
for (int i=0; i<N-1; i++) {
int _ = i%2;
for (int j=0; j<=M; j++) {
for (int k=0; k<=S; k++) {
dp[_^1][j][k] = 0;
T[j][k] = 0;
}
}
for (int j=0; j<=M; j++) {
for (int k=0; k<=S; k++) {
if (j + k <= S) {
T[j][j+k] = (T[j][j+k] + dp[_][j][k]) % MOD;
}
}
}
for (int j=0; j<=M; j++) {
for (int k=0; k<=S; k++) {
if (j > 0 && k > 0) T[j][k] = (T[j][k] + T[j-1][k-1]) % MOD;
dp[_^1][j][k] = (dp[_^1][j][k] + T[j][k]) % MOD;
}
}
}
int m = 0;
for (int i=0; i<=M; i++) m = (m + dp[(N-1)%2][i][S]) % MOD;
cout << m << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using ll = long long;
constexpr int mod = 100000;
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 = 1; i <= N * 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] = (dp[i][j] + mod) % mod;
}
}
cout << dp[N * N][S] << endl;
}
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
static const int MAX_N = 7;
static const int MAX_M = 2000;
static const int MAX_S = 3000;
static const int MOD = 100000;
int N, M, S;
int memo[2][MAX_M + 1][MAX_S + 1];
int main(){
for(;;){
scanf("%d %d %d", &N, &M, &S);
if(N == 0 && M == 0 && S == 0) break;
N *= N;
fill(memo[0][0], memo[2][0], 0);
memo[0][0][0]++;
for(int i = 1; i <= N; i++){
for(int j = 1; j <= M; j++){
for(int k = 0; k <= S; k++){
int diff = N - i + 1;
if(k - diff < 0) continue;
memo[1][j][k] = memo[1][j - 1][k - diff]; // b_iの値を1つ増やす場合
memo[1][j][k] += memo[0][j - 1][k - diff]; // b_(i-1)からb_iに切り替える場合
memo[1][j][k] %= MOD;
}
}
for(int j = 0; j <= M; j++){
for(int k = 0; k <= S; k++){
memo[0][j][k] = memo[1][j][k];
}
}
}
int res = 0;
for(int i = 0; i <= M; i++){
res += memo[0][i][S];
res %= MOD;
}
printf("%d\n", res);
}
return 0;
}
|
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAX_N 2000
#define MAX_M 3000
int x[MAX_N + 1][MAX_M + 1];
int y[MAX_N + 1][MAX_M + 1];
int z[50][MAX_M];
int sum = 0;
int main() {
int n, m, s, d, e, f, g;
while (true) {
cin >> n >> m >> s;
if ((n == 0 && m == 0) && s == 0) {
break;
}
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
memset(z,0,sizeof(z));
if(m<s-((n*n)-2)*((n*n)-1)/2){
memset(y, 0, sizeof(y));
for (int i = 1; i <= m; i++) {
x[i][i] = 1;
}
for (int i = 2; i <= n*n; i++) {
d = s / (n*n - i + 1);
e = min(m, d);
f = s*i / (n*n) + i - n * n;
g = (i - 2)*(i - 1) / 2;
for (int j = i - 1; j <= e; j++) {
for (int k = j + g; k <= f; k++) {
for (int l = j + 1; l <= e; l++) {
y[l][k + l] += x[j][k];
}
}
}
y[2000][3000] = 0;
for (int j = i; j <= e; j++) {
for (int k = j; k <= s; k++) {
x[j][k] = y[j][k] % 100000;
y[j][k] = 0;
}
}
y[0][0] = 0;
}
sum=0;
for (int i = 0; i <= m; i++) {
sum += x[i][s];
sum %= 100000;
}
}
else{
z[0][0]=1;
for(int i=1;i<=n*n;i++){
d=n*n-i+1;
for(int j=0;j<=s;j++){
e=0;
while(j+e*d<=s){
z[i][j+e*d] += z[i-1][j];
z[i][j+e*d] %= 100000;
e++;
}
}
}
sum=z[n*n][s-((n*n)+1)*(n*n)/2]%100000;
}
cout << sum << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int mod=100000;
int dp[2][2001][3001];
int main(){
int n,m,s;
while(cin>>n>>m>>s,n){
fill(dp[0][0],dp[0][0]+2*2001*3001,0);
n*=n;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
for(int k=1;k<=s;k++){
if(i==1){
if(k<=j)dp[i&1][j][k]=1;
}
else{
dp[i&1][j][k]=dp[i&1][j-1][k];
if(k-j>=0)dp[i&1][j][k]+=dp[(i-1)&1][j-1][k-j];
}
dp[i&1][j][k]%=mod;
}
}
}
cout<<dp[n&1][m][s]<<endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.