problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
double S = A / B;
cout << fixed << setprecision(10) << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double A, B;
cin >> A >> B;
double S = A / B;
cout << fixed << setprecision(10) << S << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,080 | 934,081 | u046313635 | cpp |
p03135 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int t, x;
cin >> t, x;
double ans = double(t) / x;
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int t, x;
cin >> t >> x;
double ans = double(t) / x;
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| [] | 934,084 | 934,085 | u186506670 | cpp |
p03135 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define pb push_back
#define f(i, n) for (i = 0; i < n; i++)
#define F(i, a, b) for (i = a; a <= b; i++)
#define arr(a, n) \
for (i = 0; i < n; i++) \
cin >> a[i];
#define fi first
#define se second
#define mp make_pair
#define mod 1000000007
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
#define yes cout << "yes" << endl;
#define no cout << "no" << endl;
#define vi vector<ll>
#define ed end()
#define bg begin()
#define sz size()
#define ln length()
#define s() sort(a, a + n);
#define sr() sort(a, a + n, greater<ll>());
#define v() sort(v.begin(), v.end());
#define vr() sort(v.begin(), v.end(), greater<ll>());
#define mod 1000000007
#define fast() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
ll gcd(ll a, ll b) {
if (!b)
return a;
return gcd(b, a % b);
}
ll power(ll x, ll y, ll p) {
ll res = 1;
x %= p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
/*#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif*/
/*
Ofcourse it's Hard.
It's supposed to be Hard.
If it's easy everyone would do it.
HARD IS WHAT MAKES IT GREAT
YESTERDAY U SAID TOMORROW
SLOWLY BECOMING THE PERSON I
SHOULD HAVE BEEN A LONG TIME AGO
SAME TASK CAN'T BE FOUND DIFFICULT TWICE
BTBHWSITW
SPRH TU KAB P
CP IS ALL ABOUT THINKING
YOU HAVE MUCH MORE POTENTIAL THAN U THINK
AJIT SHIDDAT 10
UR DAILY ROUTINE
*/
fast();
// ll t;cin>>t;while(t--)
{
ll t, x;
cin >> t >> x;
ll d = t / double(x);
cout << d << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define pb push_back
#define f(i, n) for (i = 0; i < n; i++)
#define F(i, a, b) for (i = a; a <= b; i++)
#define arr(a, n) \
for (i = 0; i < n; i++) \
cin >> a[i];
#define fi first
#define se second
#define mp make_pair
#define mod 1000000007
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
#define yes cout << "yes" << endl;
#define no cout << "no" << endl;
#define vi vector<ll>
#define ed end()
#define bg begin()
#define sz size()
#define ln length()
#define s() sort(a, a + n);
#define sr() sort(a, a + n, greater<ll>());
#define v() sort(v.begin(), v.end());
#define vr() sort(v.begin(), v.end(), greater<ll>());
#define mod 1000000007
#define fast() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
ll gcd(ll a, ll b) {
if (!b)
return a;
return gcd(b, a % b);
}
ll power(ll x, ll y, ll p) {
ll res = 1;
x %= p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
/*#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif*/
/*
Ofcourse it's Hard.
It's supposed to be Hard.
If it's easy everyone would do it.
HARD IS WHAT MAKES IT GREAT
YESTERDAY U SAID TOMORROW
SLOWLY BECOMING THE PERSON I
SHOULD HAVE BEEN A LONG TIME AGO
SAME TASK CAN'T BE FOUND DIFFICULT TWICE
BTBHWSITW
SPRH TU KAB P
CP IS ALL ABOUT THINKING
YOU HAVE MUCH MORE POTENTIAL THAN U THINK
AJIT SHIDDAT 10
UR DAILY ROUTINE
*/
fast();
// ll t;cin>>t;while(t--)
{
ll t, x;
cin >> t >> x;
double d = t / double(x);
cout << d << endl;
}
return 0;
} | [
"variable_declaration.type.change"
] | 934,086 | 934,087 | u159663513 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
double a;
cin >> t >> x;
a = t / x;
cout << a << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double t, x;
double a;
cin >> t >> x;
a = t / x;
cout << a << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,088 | 934,089 | u666712170 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int T, X;
cin >> T >> X;
float t = T / X;
cout << t;
} | #include <iostream>
using namespace std;
int main() {
float T, X;
cin >> T >> X;
float t = T / X;
cout << t;
} | [
"variable_declaration.type.primitive.change"
] | 934,092 | 934,093 | u212144411 | cpp |
p03135 | #include "bits/stdc++.h"
#define MOD 1000000007
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define ALL(v) v.begin(), v.end()
#define DUMP(i, v) \
for (ll i = 0; i < v.size(); i++) \
cout << v[i] << " "
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
struct Edge {
ll from, to, cost;
};
struct node {
ll cost, to;
bool friend operator>(node a, node b) { return a.cost > b.cost; }
};
ll mod(ll a, ll mod) {
ll res = a % mod;
if (res < 0)
res = res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll modinv(ll a, ll mod) { return modpow(a, mod - 2, mod); }
ll gcd(ll a, ll b) {
ll r = a % b;
if (r == 0)
return b;
else
return gcd(b, a % b);
}
bool is_prime(ll n) {
ll i = 2;
if (n == 1)
return false;
if (n == 2)
return true;
bool res = true;
while (i * i < n) {
if (n % i == 0) {
res = false;
}
i = i + 1;
}
// if(i==1)res = false;
if (n % i == 0)
res = false;
return res;
}
/**************************************
** A main function starts from here **
***************************************/
int main() {
ll X, T;
cin >> X >> T;
cout << (double)T / X;
return 0;
}
| #include "bits/stdc++.h"
#define MOD 1000000007
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define ALL(v) v.begin(), v.end()
#define DUMP(i, v) \
for (ll i = 0; i < v.size(); i++) \
cout << v[i] << " "
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
struct Edge {
ll from, to, cost;
};
struct node {
ll cost, to;
bool friend operator>(node a, node b) { return a.cost > b.cost; }
};
ll mod(ll a, ll mod) {
ll res = a % mod;
if (res < 0)
res = res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll modinv(ll a, ll mod) { return modpow(a, mod - 2, mod); }
ll gcd(ll a, ll b) {
ll r = a % b;
if (r == 0)
return b;
else
return gcd(b, a % b);
}
bool is_prime(ll n) {
ll i = 2;
if (n == 1)
return false;
if (n == 2)
return true;
bool res = true;
while (i * i < n) {
if (n % i == 0) {
res = false;
}
i = i + 1;
}
// if(i==1)res = false;
if (n % i == 0)
res = false;
return res;
}
/**************************************
** A main function starts from here **
***************************************/
int main() {
ll X, T;
cin >> T >> X;
cout << (double)T / X;
return 0;
}
| [
"expression.operation.binary.remove"
] | 934,101 | 934,102 | u225053756 | cpp |
p03135 | #include <stdio.h>
int main(void) {
int T, X, t;
scanf("%d %d", &T, &X);
printf("%d", T / X);
return 0;
}
| #include <stdio.h>
int main(void) {
float T, X, t;
scanf("%f %f", &T, &X);
printf("%f", T / X);
return 0;
}
| [
"variable_declaration.type.primitive.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,103 | 934,104 | u818573308 | cpp |
p03135 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int t, x;
double ans;
cin >> t >> x;
ans = ~t / x;
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
double t, x;
double ans;
cin >> t >> x;
ans = t / x;
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"expression.operation.unary.bitwise.remove"
] | 934,105 | 934,106 | u206390098 | cpp |
p03135 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define print(x) cout << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
int main() {
double t, x;
cin >> t >> x;
printf(".10%f\n", t / x);
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define print(x) cout << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
int main() {
double t, x;
cin >> t >> x;
printf("%.10f\n", t / x);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,107 | 934,108 | u814715203 | cpp |
p03135 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int t, x;
cin >> t >> x;
double ans = t / x;
cout << fixed << setprecision(8) << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
double t, x;
cin >> t >> x;
double ans = t / x;
cout << fixed << setprecision(8) << ans << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,109 | 934,110 | u816145694 | cpp |
p03135 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
double x, t;
cin >> x >> t;
printf("%.3f\n", t / x);
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
double x, t;
cin >> x >> t;
printf("%.3f\n", x / t);
} | [
"expression.operation.binary.remove"
] | 934,119 | 934,120 | u120050685 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << fixed << setprecision(10);
cout << a / b << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double a, b;
cin >> a >> b;
cout << fixed << setprecision(10);
cout << a / b << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,121 | 934,122 | u330025192 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << fixed << setprecision(10);
cout << x / t << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << fixed << setprecision(10);
cout << t / x << endl;
} | [
"expression.operation.binary.remove"
] | 934,125 | 934,126 | u201928947 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int t, x, k;
cin >> t >> x;
k = t / x;
cout << k;
}
| #include <iostream>
using namespace std;
int main() {
float t, x, k;
cin >> t >> x;
k = t / x;
cout << k;
}
| [
"variable_declaration.type.primitive.change"
] | 934,130 | 934,131 | u406246506 | cpp |
p03135 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(n) for (int i = 0; i < n; i++)
int N, M;
vector<int> x, d;
int main() {
scanf("%d %d", &N, &M);
printf("%d", (double)N / M);
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(n) for (int i = 0; i < n; i++)
int N, M;
vector<int> x, d;
int main() {
scanf("%d %d", &N, &M);
printf("%f", (double)N / M);
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,138 | 934,139 | u128572736 | cpp |
p03135 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(n) for (int i = 0; i < n; i++)
int N, M;
vector<int> x, d;
int main() {
scanf("%d %d ", &N, &M);
printf("%d", N / M);
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(n) for (int i = 0; i < n; i++)
int N, M;
vector<int> x, d;
int main() {
scanf("%d %d", &N, &M);
printf("%f", (double)N / M);
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,140 | 934,139 | u128572736 | cpp |
p03135 | #include <bits/stdc++.h>
#include <math.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int mINF = -1001001001;
int main() {
int x, y, z;
cin >> x >> y;
double ans = x / y;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <math.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int mINF = -1001001001;
int main() {
double x, y, z;
cin >> x >> y;
double ans = x / y;
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 934,141 | 934,142 | u281876921 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
double T, X;
cin >> T, X;
cout << T / X << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double T, X;
cin >> T >> X;
cout << T / X << endl;
} | [] | 934,143 | 934,144 | u762259033 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int T, X;
cin >> T, X;
cout << T / X << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
double T, X;
cin >> T >> X;
cout << T / X << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,145 | 934,144 | u762259033 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int T, X;
cin >> T >> X;
double ans = T / X;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double T, X;
cin >> T >> X;
double ans = T / X;
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,148 | 934,149 | u811472478 | cpp |
p03135 | // Entrance Examination
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, X;
cin >> T >> X;
cout << T / X << endl;
return 0;
} | // Entrance Examination
#include <bits/stdc++.h>
using namespace std;
int main() {
double T, X;
cin >> T >> X;
cout << T / X << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 934,150 | 934,151 | u896325626 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << (double)t / (double)x << endl;
return 0;
} | [
"type_conversion.add"
] | 934,152 | 934,153 | u611571299 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
double X;
double T;
double ans;
cin >> X >> T;
ans = T / X;
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
double X;
double T;
double ans;
cin >> T >> X;
ans = T / X;
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 934,154 | 934,155 | u644568158 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int X;
int T;
double ans;
cin >> T >> X;
ans = T / X;
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
double X;
double T;
double ans;
cin >> T >> X;
ans = T / X;
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 934,156 | 934,155 | u644568158 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int X;
int T;
double ans;
cin >> X >> T;
ans = T / X;
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
double X;
double T;
double ans;
cin >> T >> X;
ans = T / X;
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"expression.operation.binary.remove"
] | 934,157 | 934,155 | u644568158 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ALL(a) (a).begin(), (a).end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using DoP = pair<double, double>;
using edge = struct {
int to;
ll cost;
};
const int di[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dj[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int INF = 1e9 + 100;
const ll INF64 = 1ll << 40;
const int mod = 1000000007;
struct Sieve {
int n;
vector<int> f, primes;
Sieve(int n = 1) : n(n), f(n + 1) {
f[0] = f[1] = -1;
for (ll i = 2; i <= n; ++i) {
if (f[i])
continue;
primes.push_back(i);
f[i] = i;
for (ll j = i * i; j <= n; j += i) {
if (!f[j])
f[j] = i;
}
}
}
bool isPrime(int x) { return f[x] == x; }
vector<int> factorList(int x) {
vector<int> res;
while (x != 1) {
res.push_back(f[x]);
x /= f[x];
}
return res;
}
vector<P> factor(int x) {
vector<int> fl = factorList(x);
if (fl.size() == 0)
return {};
vector<P> res(1, P(fl[0], 0));
for (int p : fl) {
if (res.back().first == p) {
res.back().second++;
} else {
res.emplace_back(p, 1);
}
}
return res;
}
};
struct UnionFind {
vector<int> par;
vector<int> siz;
UnionFind(int N) : par(N), siz(N, 1) {
for (int i = 0; i < N; i++)
par[i] = i;
}
void init(int N) {
siz.assign(N, 1);
par.resize(N);
for (int i = 0; i < N; ++i)
par[i] = i;
}
int root(int x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool isSame(int x, int y) { return root(x) == root(y); }
int size(int x) { return siz[root(x)]; }
};
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
// h(n, r) = c(n+r-1, r)
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int main() {
double t, x;
cin >> t >> x;
printf("0.6%f\n", t / x);
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ALL(a) (a).begin(), (a).end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using DoP = pair<double, double>;
using edge = struct {
int to;
ll cost;
};
const int di[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dj[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int INF = 1e9 + 100;
const ll INF64 = 1ll << 40;
const int mod = 1000000007;
struct Sieve {
int n;
vector<int> f, primes;
Sieve(int n = 1) : n(n), f(n + 1) {
f[0] = f[1] = -1;
for (ll i = 2; i <= n; ++i) {
if (f[i])
continue;
primes.push_back(i);
f[i] = i;
for (ll j = i * i; j <= n; j += i) {
if (!f[j])
f[j] = i;
}
}
}
bool isPrime(int x) { return f[x] == x; }
vector<int> factorList(int x) {
vector<int> res;
while (x != 1) {
res.push_back(f[x]);
x /= f[x];
}
return res;
}
vector<P> factor(int x) {
vector<int> fl = factorList(x);
if (fl.size() == 0)
return {};
vector<P> res(1, P(fl[0], 0));
for (int p : fl) {
if (res.back().first == p) {
res.back().second++;
} else {
res.emplace_back(p, 1);
}
}
return res;
}
};
struct UnionFind {
vector<int> par;
vector<int> siz;
UnionFind(int N) : par(N), siz(N, 1) {
for (int i = 0; i < N; i++)
par[i] = i;
}
void init(int N) {
siz.assign(N, 1);
par.resize(N);
for (int i = 0; i < N; ++i)
par[i] = i;
}
int root(int x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool isSame(int x, int y) { return root(x) == root(y); }
int size(int x) { return siz[root(x)]; }
};
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
// h(n, r) = c(n+r-1, r)
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int main() {
double t, x;
cin >> t >> x;
printf("%0.6f\n", t / x);
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,158 | 934,159 | u740054550 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int T, X;
cin >> T >> X;
double x = T / X;
printf("%lf\n", x);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double T, X;
cin >> T >> X;
double x = T / X;
printf("%lf\n", x);
} | [
"variable_declaration.type.primitive.change"
] | 934,160 | 934,161 | u820224016 | cpp |
p03135 | #include <stdio.h>
int main(void) {
int t, x;
scanf("%d%d", &t, &x);
printf("%.12f\n", t / x);
return 0;
} | #include <stdio.h>
int main(void) {
int t, x;
scanf("%d%d", &t, &x);
printf("%.12f\n", (double)t / x);
return 0;
} | [
"type_conversion.add"
] | 934,162 | 934,163 | u088895504 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int T, X;
cin >> T >> X;
cout << T / X << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
float T, X;
cin >> T >> X;
cout << T / X << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,168 | 934,169 | u217508499 | cpp |
p03135 | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
int main() {
double t, x;
scanf("%lf", &t, &x);
printf("[%.5f]\n", t / x);
return 0;
}
| #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
int main() {
double t, x;
scanf("%lf %lf", &t, &x);
printf("%.5f\n", t / x);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,173 | 934,174 | u201553784 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll t, x;
cin >> t >> x;
cout << setprecision(10) << t / x << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
double t, x;
cin >> t >> x;
cout << fixed << setprecision(10) << t / x << endl;
return 0;
} | [
"variable_declaration.type.change",
"io.output.change"
] | 934,175 | 934,176 | u316322317 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
cout << fixed << setprecision(10);
int a, b;
cin >> a >> b;
cout << a / b << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
cout << fixed << setprecision(13);
int a, b;
cin >> a >> b;
cout << (double)a / b << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 934,177 | 934,178 | u613960672 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
double t, x;
cin >> t >> x;
double ans = t / x;
cout << fixed << setprecision(10) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
double t, x;
cin >> t >> x;
double ans = t / x;
cout << fixed << setprecision(10) << ans << endl;
}
| [
"io.output.change"
] | 934,179 | 934,180 | u559578080 | cpp |
p03135 | #include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
typedef long long int ll;
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << x / t << endl;
} | #include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
typedef long long int ll;
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << t / x << endl;
}
| [
"expression.operation.binary.remove"
] | 934,185 | 934,186 | u473023730 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll(i) = 0; i < (n); ++(i))
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll x, t;
cin >> t >> x;
double ans = t / x;
printf("%.10f", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll(i) = 0; i < (n); ++(i))
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
double x, t;
cin >> t >> x;
double ans = t / x;
printf("%.10f", ans);
return 0;
}
| [
"variable_declaration.type.change"
] | 934,195 | 934,196 | u894339989 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll(i) = 0; i < (n); ++(i))
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll x, t;
cin >> x >> t;
double ans = t / x;
printf("%.10f", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll(i) = 0; i < (n); ++(i))
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
double x, t;
cin >> t >> x;
double ans = t / x;
printf("%.10f", ans);
return 0;
}
| [
"variable_declaration.type.change",
"expression.operation.binary.remove"
] | 934,197 | 934,196 | u894339989 | cpp |
p03135 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int T, X;
cin >> T >> X;
double ans = T / X;
printf("%.10f", ans);
cout << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int T, X;
cin >> T >> X;
double ans = (double)T / X;
printf("%.10f", ans);
cout << endl;
return 0;
} | [
"type_conversion.add"
] | 934,198 | 934,199 | u828388155 | cpp |
p03135 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int T, X;
cin >> T >> X;
int ans = T / X;
printf("%.10f", ans);
cout << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int T, X;
cin >> T >> X;
double ans = (double)T / X;
printf("%.10f", ans);
cout << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 934,200 | 934,199 | u828388155 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int t;
int x;
cin >> t >> x;
cout << t / x << endl;
} | #include <iostream>
using namespace std;
int main() {
double t;
double x;
cin >> t >> x;
cout << t / x << endl;
} | [
"variable_declaration.type.primitive.change"
] | 934,201 | 934,202 | u600215903 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int t;
int x;
cin >> t >> x;
cout << x / t << endl;
} | #include <iostream>
using namespace std;
int main() {
double t;
double x;
cin >> t >> x;
cout << t / x << endl;
} | [
"variable_declaration.type.primitive.change",
"expression.operation.binary.remove"
] | 934,203 | 934,202 | u600215903 | cpp |
p03135 | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
#define PI acos(-1)
#define EPS 1e-3
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<ll> row;
typedef vector<row> matrix;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
file();
fast();
int T, x;
cin >> T >> x;
cout << setprecision(10) << T / (double)x << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
#define PI acos(-1)
#define EPS 1e-3
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<ll> row;
typedef vector<row> matrix;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
// file();
fast();
int T, x;
cin >> T >> x;
cout << setprecision(10) << T / (double)x << endl;
return 0;
} | [
"call.remove"
] | 934,206 | 934,207 | u824459059 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long n, m, a[333][333], pw[666], cnt, pos, cur, upper;
/*long long Guass(long long Row,long long Column)
{
long long row=1,col=1,max_r;
for(row=1;row<=Row&&col<=Column;row++,col++)
{
max_r=row;
for(long long i=row+1;i<=Row;i++)
if(abs(a[i][col])>abs(a[max_r][col]))
max_r=i;
if(a[max_r][col]==0)
{
row--;
continue;
}
if(max_r!=row)
for(long long i=col;i<=Column;i++)
swap(a[row][i],a[max_r][i]);
for(long long i=row+1;i<=Row;i++)
{
if(a[i][col]!=0)
{
for(long long j=col;j<=Column;j++)
a[i][j]^=a[row][j];
}
}
}
return Column-row+1;
}*/
void gauss() {
upper = 1;
for (long long i = 1; i <= m; i++) {
pos = -1;
for (long long j = upper; j <= n; j++) {
if (a[j][i]) {
pos = j;
break;
}
}
if (~pos) {
for (long long j = 1; j <= m; j++)
swap(a[upper][j], a[pos][j]);
for (long long j = upper + 1; j <= n; j++) {
if (a[j][i]) {
for (long long k = i; k <= m; k++) {
a[j][k] ^= a[upper][k];
}
}
}
upper++;
}
}
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
scanf("%lld", &a[i][j]);
}
}
pw[0] = 1;
for (long long i = 1; i <= 600; i++)
pw[i] = pw[i - 1] * 2 % mod;
gauss();
cur = pw[m - upper];
printf("%lld\n", ((pw[n + m - 1] - pw[n - 1] * cur) % mod + mod) % mod);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long n, m, a[333][333], pw[666], cnt, pos, cur, upper;
/*long long Guass(long long Row,long long Column)
{
long long row=1,col=1,max_r;
for(row=1;row<=Row&&col<=Column;row++,col++)
{
max_r=row;
for(long long i=row+1;i<=Row;i++)
if(abs(a[i][col])>abs(a[max_r][col]))
max_r=i;
if(a[max_r][col]==0)
{
row--;
continue;
}
if(max_r!=row)
for(long long i=col;i<=Column;i++)
swap(a[row][i],a[max_r][i]);
for(long long i=row+1;i<=Row;i++)
{
if(a[i][col]!=0)
{
for(long long j=col;j<=Column;j++)
a[i][j]^=a[row][j];
}
}
}
return Column-row+1;
}*/
void gauss() {
upper = 1;
for (long long i = 1; i <= m; i++) {
pos = -1;
for (long long j = upper; j <= n; j++) {
if (a[j][i]) {
pos = j;
break;
}
}
if (~pos) {
for (long long j = 1; j <= m; j++)
swap(a[upper][j], a[pos][j]);
for (long long j = upper + 1; j <= n; j++) {
if (a[j][i]) {
for (long long k = i; k <= m; k++) {
a[j][k] ^= a[upper][k];
}
}
}
upper++;
}
}
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
scanf("%lld", &a[i][j]);
}
}
pw[0] = 1;
for (long long i = 1; i <= 600; i++)
pw[i] = pw[i - 1] * 2 % mod;
gauss();
cur = pw[m - upper + 1];
printf("%lld\n", ((pw[n + m - 1] - pw[n - 1] * cur) % mod + mod) % mod);
return 0;
} | [
"assignment.change"
] | 934,229 | 934,230 | u900309151 | cpp |
p03133 | //
// binary 行列 (行列累乗と、掃き出し法)
//
// verified:
// みんなのプロコン 2019 E - Odd Subrectangles
// https://atcoder.jp/contests/yahoo-procon2019-qual/tasks/yahoo_procon2019_qual_e
//
#include <bitset>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_ROW = 510; // to be set
const int MAX_COL = 510; // to be set
struct BitMatrix {
int n, m;
bitset<MAX_COL> val[MAX_ROW];
BitMatrix(int n_ = 1, int m_ = 1) {
n = n_;
m = m_;
}
inline bitset<MAX_COL> &operator[](int i) { return val[i]; }
inline friend ostream &operator<<(ostream &s, BitMatrix M) {
s << endl;
for (int i = 0; i < M.n; ++i) {
for (int j = 0; j < M.m; ++j)
s << M.val[i][j];
s << endl;
}
return s;
}
};
inline BitMatrix operator*(BitMatrix A, BitMatrix B) {
BitMatrix R(A.n, B.m);
BitMatrix tB(B.m, B.n);
for (int i = 0; i < tB.n; ++i)
for (int j = 0; j < tB.m; ++j)
tB[i][j] = B[j][i];
for (int i = 0; i < R.n; ++i)
for (int j = 0; j < R.m; ++j)
R[i][j] = (A[i] & tB[j]).any();
return R;
}
inline BitMatrix pow(BitMatrix A, long long n) {
BitMatrix R(A.n, A.n);
for (int i = 0; i < A.n; ++i)
R[i][i] = 1;
while (n > 0) {
if (n & 1)
R = R * A;
A = A * A;
n >>= 1;
}
return R;
}
int calc_rank(BitMatrix &A) {
int r = 0;
for (int i = 0; i < A.m; ++i) {
int pivot = -1;
for (int j = r; j < A.n; ++j) {
if (A[j][i]) {
pivot = j;
break;
}
}
if (pivot != -1) {
swap(A[pivot], A[r]);
for (int j = 0; j < A.n; ++j)
if (j != r && A[j][i])
A[j] ^= A[r];
++r;
}
}
return r;
}
vector<vector<int>> linear_equation(BitMatrix A, vector<int> b) {
int rank = 0;
for (int i = 0; i < A.n; ++i) {
A[i][A.m] = b[i];
}
vector<int> core, rem;
for (int i = 0; i < A.m; ++i) {
int pivot = -1;
for (int j = rank; j < A.n; ++j) {
if (A[j][i]) {
pivot = j;
break;
}
}
if (pivot != -1) {
core.push_back(i);
swap(A[pivot], A[rank]);
for (int j = 0; j < A.n; ++j)
if (j != rank && A[j][i])
A[j] ^= A[rank];
++rank;
} else
rem.push_back(i);
}
vector<vector<int>> res;
for (int i = rank; i < A.n; ++i)
if (A[i][A.m])
return res; // return -1;
vector<int> sol(A.m, 0);
for (int i = 0; i < core.size(); ++i)
sol[core[i]] = A[i][A.m];
res.push_back(sol);
for (int i = 0; i < rem.size(); ++i) {
vector<int> temp(A.m, 0);
temp[rem[i]] = 1;
for (int j = 0; j < core.size(); ++j)
temp[core[j]] = A[j][rem[i]];
res.push_back(temp);
}
return res; // return A[0].size()-rank;
};
const int MOD = 998244353;
const int MAX = 2100;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
COMinit();
int N, M;
cin >> N >> M;
BitMatrix A(N, M);
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) {
int a;
cin >> a;
if (a)
A[i][j] = 1;
}
int r = calc_rank(A);
long long fact = modpow(2LL, N - r, MOD) * modpow(2LL, M - r, MOD) % MOD;
long long res = 0;
for (int i = 1; i <= r; ++i) {
long long tmp = COM(r, i) * modpow(2LL, i - 1, MOD) % MOD *
modpow(2LL, M - i, MOD) % MOD;
res = (res + tmp) % MOD;
}
res = (res * fact) % MOD;
cout << res << endl;
}
| //
// binary 行列 (行列累乗と、掃き出し法)
//
// verified:
// みんなのプロコン 2019 E - Odd Subrectangles
// https://atcoder.jp/contests/yahoo-procon2019-qual/tasks/yahoo_procon2019_qual_e
//
#include <bitset>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_ROW = 510; // to be set
const int MAX_COL = 510; // to be set
struct BitMatrix {
int n, m;
bitset<MAX_COL> val[MAX_ROW];
BitMatrix(int n_ = 1, int m_ = 1) {
n = n_;
m = m_;
}
inline bitset<MAX_COL> &operator[](int i) { return val[i]; }
inline friend ostream &operator<<(ostream &s, BitMatrix M) {
s << endl;
for (int i = 0; i < M.n; ++i) {
for (int j = 0; j < M.m; ++j)
s << M.val[i][j];
s << endl;
}
return s;
}
};
inline BitMatrix operator*(BitMatrix A, BitMatrix B) {
BitMatrix R(A.n, B.m);
BitMatrix tB(B.m, B.n);
for (int i = 0; i < tB.n; ++i)
for (int j = 0; j < tB.m; ++j)
tB[i][j] = B[j][i];
for (int i = 0; i < R.n; ++i)
for (int j = 0; j < R.m; ++j)
R[i][j] = (A[i] & tB[j]).any();
return R;
}
inline BitMatrix pow(BitMatrix A, long long n) {
BitMatrix R(A.n, A.n);
for (int i = 0; i < A.n; ++i)
R[i][i] = 1;
while (n > 0) {
if (n & 1)
R = R * A;
A = A * A;
n >>= 1;
}
return R;
}
int calc_rank(BitMatrix &A) {
int r = 0;
for (int i = 0; i < A.m; ++i) {
int pivot = -1;
for (int j = r; j < A.n; ++j) {
if (A[j][i]) {
pivot = j;
break;
}
}
if (pivot != -1) {
swap(A[pivot], A[r]);
for (int j = 0; j < A.n; ++j)
if (j != r && A[j][i])
A[j] ^= A[r];
++r;
}
}
return r;
}
vector<vector<int>> linear_equation(BitMatrix A, vector<int> b) {
int rank = 0;
for (int i = 0; i < A.n; ++i) {
A[i][A.m] = b[i];
}
vector<int> core, rem;
for (int i = 0; i < A.m; ++i) {
int pivot = -1;
for (int j = rank; j < A.n; ++j) {
if (A[j][i]) {
pivot = j;
break;
}
}
if (pivot != -1) {
core.push_back(i);
swap(A[pivot], A[rank]);
for (int j = 0; j < A.n; ++j)
if (j != rank && A[j][i])
A[j] ^= A[rank];
++rank;
} else
rem.push_back(i);
}
vector<vector<int>> res;
for (int i = rank; i < A.n; ++i)
if (A[i][A.m])
return res; // return -1;
vector<int> sol(A.m, 0);
for (int i = 0; i < core.size(); ++i)
sol[core[i]] = A[i][A.m];
res.push_back(sol);
for (int i = 0; i < rem.size(); ++i) {
vector<int> temp(A.m, 0);
temp[rem[i]] = 1;
for (int j = 0; j < core.size(); ++j)
temp[core[j]] = A[j][rem[i]];
res.push_back(temp);
}
return res; // return A[0].size()-rank;
};
const int MOD = 998244353;
const int MAX = 2100;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
COMinit();
int N, M;
cin >> N >> M;
BitMatrix A(N, M);
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) {
int a;
cin >> a;
if (a)
A[i][j] = 1;
}
int r = calc_rank(A);
long long fact = modpow(2LL, N - r, MOD) * modpow(2LL, M - r, MOD) % MOD;
long long res = 0;
for (int i = 1; i <= r; ++i) {
long long tmp = COM(r, i) * modpow(2LL, i - 1, MOD) % MOD *
modpow(2LL, r - i, MOD) % MOD;
res = (res + tmp) % MOD;
}
res = (res * fact) % MOD;
cout << res << endl;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 934,236 | 934,237 | u692336506 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
//#define che
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define MK make_pair
#define PB push_back
#define fi first
#define se second
typedef long long LL;
typedef pair<int, int> PII;
const int N = 303;
const LL MOD = 998244353;
typedef bitset<N> bs;
bs a[N];
LL pw[N];
int n, m;
int main() {
#ifdef che
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
scanf("%d%d", &n, &m);
pw[0] = 1;
for (int i = 1; i < N; ++i)
pw[i] = (pw[i - 1] << 1) % MOD;
for (int i = 0, x; i < n; ++i)
for (int j = 0; j < m; ++j) {
scanf("%d", &x);
if (x)
a[i].flip(j);
}
for (int i = 0, j = 0; i < n && j < m; ++j) {
bool flag = false;
for (int k = i; k < n; ++k)
if (a[k].test(j)) {
swap(a[i], a[k]);
flag = true;
break;
}
if (flag) {
for (int k = i; k < n; ++k)
if (a[k].test(j))
a[k] ^= a[i];
++i;
}
}
int fr = 0; // free row
for (int i = 0; i < n; ++i)
if (a[i].count() == 0)
++fr;
LL ans = (pw[n] - pw[fr] + MOD) % MOD;
ans = ans * pw[m - 1] % MOD;
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
//#define che
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define MK make_pair
#define PB push_back
#define fi first
#define se second
typedef long long LL;
typedef pair<int, int> PII;
const int N = 303;
const LL MOD = 998244353;
typedef bitset<N> bs;
bs a[N];
LL pw[N];
int n, m;
int main() {
#ifdef che
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
scanf("%d%d", &n, &m);
pw[0] = 1;
for (int i = 1; i < N; ++i)
pw[i] = (pw[i - 1] << 1) % MOD;
for (int i = 0, x; i < n; ++i)
for (int j = 0; j < m; ++j) {
scanf("%d", &x);
if (x)
a[i].flip(j);
}
for (int i = 0, j = 0; i < n && j < m; ++j) {
bool flag = false;
for (int k = i; k < n; ++k)
if (a[k].test(j)) {
swap(a[i], a[k]);
flag = true;
break;
}
if (flag) {
for (int k = i + 1; k < n; ++k)
if (a[k].test(j))
a[k] ^= a[i];
++i;
}
}
int fr = 0; // free row
for (int i = 0; i < n; ++i)
if (a[i].count() == 0)
++fr;
LL ans = (pw[n] - pw[fr] + MOD) % MOD;
ans = ans * pw[m - 1] % MOD;
printf("%lld\n", ans);
return 0;
} | [
"control_flow.loop.for.initializer.change"
] | 934,238 | 934,239 | u460246101 | cpp |
p03133 | #include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
const int maxd = 998244353, N = 100000;
const double pi = acos(-1.0);
typedef long long ll;
int n, m, cnt = 0;
ll bin[320];
bitset<320> a[320], p[320];
int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-')
f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
int main() {
n = read();
m = read();
int i, j;
bin[0] = 1;
for (i = 1; i <= 300; i++)
bin[i] = (bin[i - 1] * 2) % maxd;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
int tmp = read();
if (tmp)
a[i][j] = 1;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j]) {
if (p[i][j])
a[i] ^= p[i];
else {
p[i] = a[i];
cnt++;
break;
}
}
}
}
ll ans = (((bin[n] - bin[n - cnt]) * bin[m - 1]) % maxd + maxd) % maxd;
printf("%lld", ans);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
const int maxd = 998244353, N = 100000;
const double pi = acos(-1.0);
typedef long long ll;
int n, m, cnt = 0;
ll bin[320];
bitset<320> a[320], p[320];
int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-')
f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
int main() {
n = read();
m = read();
int i, j;
bin[0] = 1;
for (i = 1; i <= 300; i++)
bin[i] = (bin[i - 1] * 2) % maxd;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
int tmp = read();
if (tmp)
a[i][j] = 1;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j]) {
if (p[j][j])
a[i] ^= p[j];
else {
p[j] = a[i];
cnt++;
break;
}
}
}
}
ll ans = (((bin[n] - bin[n - cnt]) * bin[m - 1]) % maxd + maxd) % maxd;
printf("%lld", ans);
return 0;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"assignment.variable.change"
] | 934,240 | 934,241 | u473013083 | cpp |
p03133 | #include <bits/stdc++.h>
#define rep(i, k, n) for (int i = k; i <= n; i++)
#define rep2(i, k, n) for (int i = k; i >= n; i--)
#define mod 998244353
using namespace std;
inline void upd(int &x, int y) {
x += y;
x -= (x >= mod) ? mod : 0;
}
const int N = 305;
int pw[N << 1], f[N], a[N][N], n, m;
int main() {
pw[0] = 1;
rep(i, 1, 600) pw[i] = pw[i - 1], upd(pw[i], pw[i - 1]);
rep(i, 1, N - 1) f[i] = pw[(i - 1) << 1], upd(f[i], f[i - 1]),
upd(f[i], f[i - 1]);
scanf("%d%d", &n, &m);
rep(i, 1, n) rep(j, 1, m) scanf("%d", &a[i][j]);
int r = 0;
rep(i, 1, m) {
int t = 0;
rep(j, i, n) if (a[j][i]) {
t = j;
break;
}
if (!t)
continue;
r++;
rep(j, 1, m) swap(a[i][j], a[t][j]);
rep(j, i + 1, n) if (a[j][i]) { rep(k, i, m) a[j][k] ^= a[i][k]; }
}
int ans = 1ll * f[r] * pw[n - r] % mod * pw[m - r] % mod;
printf("%d\n", ans);
} | #include <bits/stdc++.h>
#define rep(i, k, n) for (int i = k; i <= n; i++)
#define rep2(i, k, n) for (int i = k; i >= n; i--)
#define mod 998244353
using namespace std;
inline void upd(int &x, int y) {
x += y;
x -= (x >= mod) ? mod : 0;
}
const int N = 305;
int pw[N << 1], f[N], a[N][N], n, m;
int main() {
pw[0] = 1;
rep(i, 1, 600) pw[i] = pw[i - 1], upd(pw[i], pw[i - 1]);
rep(i, 1, N - 1) f[i] = pw[(i - 1) << 1], upd(f[i], f[i - 1]),
upd(f[i], f[i - 1]);
scanf("%d%d", &n, &m);
rep(i, 1, n) rep(j, 1, m) scanf("%d", &a[i][j]);
int r = 0;
rep(i, 1, m) {
int t = 0;
rep(j, r + 1, n) if (a[j][i]) {
t = j;
break;
}
if (!t)
continue;
r++;
rep(j, 1, m) swap(a[r][j], a[t][j]);
rep(j, r + 1, n) if (a[j][i]) { rep(k, i, m) a[j][k] ^= a[r][k]; }
}
int ans = 1ll * f[r] * pw[n - r] % mod * pw[m - r] % mod;
printf("%d\n", ans);
} | [
"call.arguments.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 934,252 | 934,253 | u266485840 | cpp |
p03133 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define show(x) cout << #x << " = " << (x) << endl;
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <int COL_SIZE> class mat {
private:
// (or, and)
// の意味での積(正方かつ対称行列に限る(重みなし無向グラフの隣接行列とか))
mat operator*(const mat &m) const {
mat ans;
for (int i = 0; i < COL_SIZE; i++) {
for (int j = 0; j < COL_SIZE; j++) {
if (this->a[i][j] == 0)
continue;
ans.a[i] |= m.a[j];
}
}
return ans;
}
public:
bitset<COL_SIZE> *a;
int r;
// 正方行列の場合
mat() { a = new bitset<COL_SIZE>[COL_SIZE]; }
// 一般の行列の場合
mat(int row_size) : r(row_size) { a = new bitset<COL_SIZE>[r]; }
int rank() const {
int res = 0;
mat<COL_SIZE> b(r);
for (int i = 0; i < r; i++)
b[i] = a[i];
// auto b = a;
for (int i = 0; i < COL_SIZE; i++) {
if (res == r)
return res;
int pivot = res;
if (!b[pivot][i]) {
for (int j = res + 1; j < r; j++) {
if (b[j][i]) {
pivot = j;
break;
}
}
if (!b[pivot][i])
continue;
swap(b[pivot], b[res]);
}
for (int j = res + 1; j < r; j++) {
if (b[j][i])
b[j] ^= b[res];
}
res++;
}
return res;
}
inline const bitset<COL_SIZE> &operator[](size_t index) const {
return a[index];
}
inline bitset<COL_SIZE> &operator[](size_t index) { return a[index]; }
friend mat pow(mat m, long long cnt) {
mat res;
for (int i = 0; i < COL_SIZE; i++)
res[i][i] = 1;
while (cnt) {
if (cnt & 1) {
res = res * m;
}
m = m * m;
cnt >>= 1;
}
return res;
}
};
ll mod = 998244353;
ll mod_pow(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll res = mod_pow(a, b / 2);
res = res * res % mod;
if (b % 2)
res = res * a % mod;
return res;
}
int main() {
int n, m;
cin >> n >> m;
mat<305> a;
rep(i, n) {
rep(j, m) {
int x;
cin >> x;
a[i][j] = x;
}
}
int r = a.rank();
cerr << r << endl;
cout << (mod_pow(2, n + m - 1) - mod_pow(2, n + m - r - 1) + mod) % mod
<< endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define show(x) cout << #x << " = " << (x) << endl;
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <int COL_SIZE> class mat {
private:
// (or, and)
// の意味での積(正方かつ対称行列に限る(重みなし無向グラフの隣接行列とか))
mat operator*(const mat &m) const {
mat ans;
for (int i = 0; i < COL_SIZE; i++) {
for (int j = 0; j < COL_SIZE; j++) {
if (this->a[i][j] == 0)
continue;
ans.a[i] |= m.a[j];
}
}
return ans;
}
public:
bitset<COL_SIZE> *a;
int r;
// 正方行列の場合
mat() { a = new bitset<COL_SIZE>[COL_SIZE]; }
// 一般の行列の場合
mat(int row_size) : r(row_size) { a = new bitset<COL_SIZE>[r]; }
int rank() const {
int res = 0;
mat<COL_SIZE> b(r);
for (int i = 0; i < r; i++)
b[i] = a[i];
for (int i = 0; i < COL_SIZE; i++) {
if (res == r)
return res;
int pivot = res;
if (!b[pivot][i]) {
for (int j = res + 1; j < r; j++) {
if (b[j][i]) {
pivot = j;
break;
}
}
if (!b[pivot][i])
continue;
swap(b[pivot], b[res]);
}
for (int j = res + 1; j < r; j++) {
if (b[j][i])
b[j] ^= b[res];
}
res++;
}
return res;
}
inline const bitset<COL_SIZE> &operator[](size_t index) const {
return a[index];
}
inline bitset<COL_SIZE> &operator[](size_t index) { return a[index]; }
friend mat pow(mat m, long long cnt) {
mat res;
for (int i = 0; i < COL_SIZE; i++)
res[i][i] = 1;
while (cnt) {
if (cnt & 1) {
res = res * m;
}
m = m * m;
cnt >>= 1;
}
return res;
}
};
ll mod = 998244353;
ll mod_pow(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll res = mod_pow(a, b / 2);
res = res * res % mod;
if (b % 2)
res = res * a % mod;
return res;
}
int main() {
int n, m;
cin >> n >> m;
mat<300> a(n);
rep(i, n) {
rep(j, m) {
int x;
cin >> x;
a[i][j] = x;
}
}
int r = a.rank();
cerr << r << endl;
cout << (mod_pow(2, n + m - 1) - mod_pow(2, n + m - r - 1) + mod) % mod
<< endl;
}
| [
"literal.number.change"
] | 934,256 | 934,257 | u628047647 | cpp |
p03133 | #include <algorithm>
#include <bitset>
#include <cstdio>
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
using namespace std;
const int N = 510, mod = 998244353;
int n, m, y, rk, ans, a[N][N], pw[N];
bitset<N> b[N];
int main() {
scanf("%d%d", &n, &m);
pw[0] = 1;
rep(i, 1, n) {
bitset<N> x(0);
rep(j, 1, m) scanf("%d", &y), x[j - 1] = y;
for (int j = m - 1; ~j; j--)
if (x[j]) {
if (b[j].any())
x ^= b[j];
else {
b[j] = x;
break;
}
}
}
rep(i, 1, min(n, m)) pw[i] = 2 * pw[i - 1] % mod;
rep(i, 0, m - 1) if (b[i].any()) rk++;
ans = 1ll * (pw[n] - pw[n - rk]) * pw[m - 1] % mod;
printf("%d\n", (ans + mod) % mod);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cstdio>
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
using namespace std;
const int N = 510, mod = 998244353;
int n, m, y, rk, ans, a[N][N], pw[N];
bitset<N> b[N];
int main() {
scanf("%d%d", &n, &m);
pw[0] = 1;
rep(i, 1, n) {
bitset<N> x(0);
rep(j, 1, m) scanf("%d", &y), x[j - 1] = y;
for (int j = m - 1; ~j; j--)
if (x[j]) {
if (b[j].any())
x ^= b[j];
else {
b[j] = x;
break;
}
}
}
rep(i, 1, max(n, m)) pw[i] = 2 * pw[i - 1] % mod;
rep(i, 0, m - 1) if (b[i].any()) rk++;
ans = 1ll * (pw[n] - pw[n - rk]) * pw[m - 1] % mod;
printf("%d\n", (ans + mod) % mod);
return 0;
} | [
"misc.opposites",
"assignment.variable.change",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 934,260 | 934,261 | u706008189 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define rollcall cout << "I'm Sucu." << endl;
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define fi first
#define se second
// debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << " ";
os << *it;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
for (auto x : mp)
os << "(" << x.first << "," << x.second << ")" << endl;
return os;
}
template <typename T, int SIZE> int array_length(const T (&)[SIZE]) {
return SIZE;
}
template <typename T, int N>
void PRINTF(const T (&a)[N], int s = N, int t = -1, bool f = true) {
if (t == -1) {
rep(i, s) {
if (i)
cout << " ";
cout << a[i];
}
} else
repi(i, s, t) {
if (i != s)
cout << " ";
cout << a[i];
}
if (f)
cout << "\n";
}
template <typename T, int N1, int N2>
void PRINTF(const T (&a)[N1][N2], int h = N1, int w = N2) {
rep(i, h) {
rep(j, w) { cout << a[i][j] << " \n"[j == w - 1]; }
}
}
string substr(const string &str, int S1, int S2 = -1) {
if (S2 == -1)
return str.substr(S1);
return str.substr(S1, S2 - S1);
}
// typedef
typedef complex<double> Point;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
const int mod = 998244353;
vector<int> mat[400];
void XOR(vi &A, vi &B) {
int n = A.size();
rep(i, n) A[i] ^= B[i];
}
int Pow(int x, int n) {
if (n < 0)
n += mod - 1;
int ans = 1;
while (n > 0) {
if (n & 1)
ans = (ans * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return ans;
}
int calc_rank(int h, int w) {
int r = 0;
rep(j, w) {
int pivot = -1;
rep(i, h) if (mat[i][j]) {
pivot = i;
break;
}
if (pivot == -1)
continue;
swap(mat[pivot], mat[r]);
rep(i, h) if (i != r) {
if (mat[i][j])
XOR(mat[i], mat[r]);
}
r++;
if (r >= h)
break;
}
return r;
}
signed main() {
int h, w;
scanf("%lld%lld", &h, &w);
rep(i, h) rep(j, w) {
int tmp;
scanf("%lld", &tmp);
mat[i].pb(tmp);
}
int r = calc_rank(h, w);
int ans = mod + Pow(2, h) - Pow(2, h - r);
ans = (ans % mod) * Pow(2, w - 1);
printf("%lld\n", ans % mod);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define rollcall cout << "I'm Sucu." << endl;
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define fi first
#define se second
// debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << " ";
os << *it;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
for (auto x : mp)
os << "(" << x.first << "," << x.second << ")" << endl;
return os;
}
template <typename T, int SIZE> int array_length(const T (&)[SIZE]) {
return SIZE;
}
template <typename T, int N>
void PRINTF(const T (&a)[N], int s = N, int t = -1, bool f = true) {
if (t == -1) {
rep(i, s) {
if (i)
cout << " ";
cout << a[i];
}
} else
repi(i, s, t) {
if (i != s)
cout << " ";
cout << a[i];
}
if (f)
cout << "\n";
}
template <typename T, int N1, int N2>
void PRINTF(const T (&a)[N1][N2], int h = N1, int w = N2) {
rep(i, h) {
rep(j, w) { cout << a[i][j] << " \n"[j == w - 1]; }
}
}
string substr(const string &str, int S1, int S2 = -1) {
if (S2 == -1)
return str.substr(S1);
return str.substr(S1, S2 - S1);
}
// typedef
typedef complex<double> Point;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
const int mod = 998244353;
vector<int> mat[400];
void XOR(vi &A, vi &B) {
int n = A.size();
rep(i, n) A[i] ^= B[i];
}
int Pow(int x, int n) {
if (n < 0)
n += mod - 1;
int ans = 1;
while (n > 0) {
if (n & 1)
ans = (ans * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return ans;
}
int calc_rank(int h, int w) {
int r = 0;
rep(j, w) {
int pivot = -1;
repi(i, r, h) if (mat[i][j]) {
pivot = i;
break;
}
if (pivot == -1)
continue;
swap(mat[pivot], mat[r]);
rep(i, h) if (i != r) {
if (mat[i][j])
XOR(mat[i], mat[r]);
}
r++;
if (r >= h)
break;
}
return r;
}
signed main() {
int h, w;
scanf("%lld%lld", &h, &w);
rep(i, h) rep(j, w) {
int tmp;
scanf("%lld", &tmp);
mat[i].pb(tmp);
}
int r = calc_rank(h, w);
int ans = mod + Pow(2, h) - Pow(2, h - r);
ans = (ans % mod) * Pow(2, w - 1);
printf("%lld\n", ans % mod);
return 0;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.add"
] | 934,271 | 934,272 | u691493208 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
int a[305][305], b[305][305];
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int fpow(int x, int k) {
int ans = 1;
while (k) {
if (k & 1)
ans = 1LL * ans * x % p;
x = 1LL * x * x % p;
k >>= 1;
}
return ans;
}
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] = read();
}
}
memset(b, 0, sizeof(b));
for (int i = 1; i <= m; i++) {
for (int j = n; j >= 1; j--) {
if (a[i][j]) {
if (b[j][j])
for (int k = 1; k <= n; k++)
a[i][k] ^= b[j][k];
else {
for (int k = 1; k <= n; k++)
b[j][k] = a[i][k];
break;
}
}
}
}
int cnt = 0;
for (int j = 1; j <= n; j++)
if (b[j][j])
++cnt;
printf("%d\n", ((fpow(2, n + m - 1) - fpow(2, n + m - cnt - 1)) % p + p) % p);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
int a[305][305], b[305][305];
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int fpow(int x, int k) {
int ans = 1;
while (k) {
if (k & 1)
ans = 1LL * ans * x % p;
x = 1LL * x * x % p;
k >>= 1;
}
return ans;
}
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] = read();
}
}
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--) {
if (a[i][j]) {
if (b[j][j])
for (int k = 1; k <= m; k++)
a[i][k] ^= b[j][k];
else {
for (int k = 1; k <= m; k++)
b[j][k] = a[i][k];
break;
}
}
}
}
int cnt = 0;
for (int j = 1; j <= m; j++)
if (b[j][j])
++cnt;
printf("%d\n", ((fpow(2, n + m - 1) - fpow(2, n + m - cnt - 1)) % p + p) % p);
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change"
] | 934,297 | 934,298 | u860104539 | cpp |
p03133 | #include <bits/stdc++.h>
#define MOD 998244353
using namespace std;
int pow(int x, int pow) {
int res = 1, t = x;
while (pow) {
if (pow & 1) {
res = 1LL * res * t % MOD;
}
t = 1LL * t * t % MOD;
pow >>= 1;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
int **mat = new int *[n];
for (int i = 0; i < n; i++) {
mat[i] = new int[m];
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
}
}
int cur = 0;
for (int c = 0; c < m; c++) {
for (int r = cur; r < n; r++) {
if (mat[r][c]) {
swap(mat[cur], mat[r]);
break;
}
}
if (!mat[cur][c]) {
continue;
}
for (int r = 0; r < n; r++) {
if (r != cur && mat[r][c]) {
for (int k = c; k < m; k++) {
mat[r][k] ^= mat[cur][k];
}
}
}
cur++;
}
int tot = pow(2, n + m - 1);
tot -= pow(2, n + m - cur - 1);
if (tot < 0) {
tot += MOD;
}
cout << tot << endl;
for (int i = 0; i < n; i++) {
delete mat[i];
}
delete mat;
return 0;
} | #include <bits/stdc++.h>
#define MOD 998244353
using namespace std;
int pow(int x, int pow) {
int res = 1, t = x;
while (pow) {
if (pow & 1) {
res = 1LL * res * t % MOD;
}
t = 1LL * t * t % MOD;
pow >>= 1;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
int **mat = new int *[n];
for (int i = 0; i < n; i++) {
mat[i] = new int[m];
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
}
}
int cur = 0;
for (int c = 0; cur < n && c < m; c++) {
for (int r = cur; r < n; r++) {
if (mat[r][c]) {
swap(mat[cur], mat[r]);
break;
}
}
if (!mat[cur][c]) {
continue;
}
for (int r = 0; r < n; r++) {
if (r != cur && mat[r][c]) {
for (int k = c; k < m; k++) {
mat[r][k] ^= mat[cur][k];
}
}
}
cur++;
}
int tot = pow(2, n + m - 1);
tot -= pow(2, n + m - cur - 1);
if (tot < 0) {
tot += MOD;
}
cout << tot << endl;
for (int i = 0; i < n; i++) {
delete mat[i];
}
delete mat;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 934,307 | 934,308 | u891482208 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
const int N = 305;
const int mod = 998244353;
int a[N][N];
int main() {
int n, m, i, j, k;
scanf("%i %i", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
scanf("%i", &a[i][j]);
int r = 0;
for (i = 1; i <= n; i++) {
bool ok = 0;
for (j = r + 1; j <= n; j++) {
if (a[j][i]) {
for (k = i; k <= m; k++)
swap(a[j][k], a[r + 1][k]);
ok = 1;
break;
}
}
if (!ok)
continue;
r++;
for (j = r + 1; j <= n; j++)
if (a[j][i]) {
for (k = i; k <= m; k++)
a[j][k] = (a[j][k] - a[r][k] + 2) % 2;
}
}
int ans = 1, sol = 1;
for (i = 1; i <= n + m - 1; i++)
ans = ans * 2 % mod;
for (i = 1; i <= n + m - r - 1; i++)
sol = sol * 2 % mod;
ans -= sol;
if (ans < 0)
ans += mod;
printf("%i\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
const int N = 305;
const int mod = 998244353;
int a[N][N];
int main() {
int n, m, i, j, k;
scanf("%i %i", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
scanf("%i", &a[i][j]);
int r = 0;
for (i = 1; i <= m; i++) {
bool ok = 0;
for (j = r + 1; j <= n; j++) {
if (a[j][i]) {
for (k = i; k <= m; k++)
swap(a[j][k], a[r + 1][k]);
ok = 1;
break;
}
}
if (!ok)
continue;
r++;
for (j = r + 1; j <= n; j++)
if (a[j][i]) {
for (k = i; k <= m; k++)
a[j][k] = (a[j][k] - a[r][k] + 2) % 2;
}
}
int ans = 1, sol = 1;
for (i = 1; i <= n + m - 1; i++)
ans = ans * 2 % mod;
for (i = 1; i <= n + m - r - 1; i++)
sol = sol * 2 % mod;
ans -= sol;
if (ans < 0)
ans += mod;
printf("%i\n", ans);
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 934,321 | 934,322 | u939096624 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
const int N = 305;
const int mod = 998244353;
int a[N][N];
int main() {
int n, m, i, j, k;
scanf("%i %i", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
scanf("%i", &a[i][j]);
int r = 0;
for (i = 1; i <= n; i++) {
bool ok = 0;
for (j = r + 1; j <= n; j++) {
if (a[j][i]) {
for (k = i; k <= n; k++)
swap(a[j][k], a[r + 1][k]);
ok = 1;
break;
}
}
if (!ok)
continue;
r++;
for (j = r + 1; j <= n; j++)
if (a[j][i]) {
for (k = i; k <= n; k++)
a[j][k] = (a[j][k] - a[r][k] + 2) % 2;
}
}
int ans = 1, sol = 1;
for (i = 1; i <= n + m - 1; i++)
ans = ans * 2 % mod;
for (i = 1; i <= n + m - r - 1; i++)
sol = sol * 2 % mod;
ans -= sol;
if (ans < 0)
ans += mod;
printf("%i\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
const int N = 305;
const int mod = 998244353;
int a[N][N];
int main() {
int n, m, i, j, k;
scanf("%i %i", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
scanf("%i", &a[i][j]);
int r = 0;
for (i = 1; i <= m; i++) {
bool ok = 0;
for (j = r + 1; j <= n; j++) {
if (a[j][i]) {
for (k = i; k <= m; k++)
swap(a[j][k], a[r + 1][k]);
ok = 1;
break;
}
}
if (!ok)
continue;
r++;
for (j = r + 1; j <= n; j++)
if (a[j][i]) {
for (k = i; k <= m; k++)
a[j][k] = (a[j][k] - a[r][k] + 2) % 2;
}
}
int ans = 1, sol = 1;
for (i = 1; i <= n + m - 1; i++)
ans = ans * 2 % mod;
for (i = 1; i <= n + m - r - 1; i++)
sol = sol * 2 % mod;
ans -= sol;
if (ans < 0)
ans += mod;
printf("%i\n", ans);
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 934,323 | 934,322 | u939096624 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
int64_t power_mod(int64_t num, int64_t power) {
int64_t prod = 1;
num %= MOD;
while (power > 0) {
if (power & 1)
prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int main() {
int N, M, A[300][300];
cin >> N >> M;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
cin >> A[i][j];
int rank = 0;
for (int j = 0; j < M; j++) {
int pivot = -1;
for (int i = rank; i < N; i++) {
if (A[i][j]) {
pivot = i;
break;
}
}
if (pivot >= 0) {
if (pivot != rank)
for (int k = 0; k < M; k++)
swap(A[pivot][k], A[rank][k]);
for (int i = rank + 1; i < N; i++) {
if (A[i][j])
for (int k = 0; k < M; k++)
A[i][k] ^ A[rank][k];
}
rank++;
}
}
int64_t ans =
(MOD + power_mod(2, N + M - 1) - power_mod(2, N + M - rank - 1)) % MOD;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
int64_t power_mod(int64_t num, int64_t power) {
int64_t prod = 1;
num %= MOD;
while (power > 0) {
if (power & 1)
prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int main() {
int N, M, A[300][300];
cin >> N >> M;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
cin >> A[i][j];
int rank = 0;
for (int j = 0; j < M; j++) {
int pivot = -1;
for (int i = rank; i < N; i++) {
if (A[i][j]) {
pivot = i;
break;
}
}
if (pivot >= 0) {
if (pivot != rank)
for (int k = 0; k < M; k++)
swap(A[pivot][k], A[rank][k]);
for (int i = rank + 1; i < N; i++) {
if (A[i][j])
for (int k = 0; k < M; k++)
A[i][k] ^= A[rank][k];
}
rank++;
}
}
int64_t ans =
(MOD + power_mod(2, N + M - 1) - power_mod(2, N + M - rank - 1)) % MOD;
cout << ans << endl;
return 0;
} | [
"assignment.compound.bitwise.replace.add",
"expression.operator.bitwise.replace.remove",
"expression.operation.binary.change"
] | 934,341 | 934,342 | u314396879 | cpp |
p03133 | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
int64_t power_mod(int64_t num, int64_t power) {
int64_t prod = 1;
num %= MOD;
while (power > 0) {
if (power & 1)
prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int main() {
int N, M, A[300][300];
cin >> N >> M;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
cin >> A[i][j];
int rank = 0;
for (int j = 0; j < M; j++) {
int pivot = -1;
for (int i = rank; i < N; i++) {
if (A[i][j]) {
pivot = i;
break;
}
}
if (pivot >= 0) {
if (pivot != rank)
for (int k = 0; k < M; k++)
swap(A[pivot][k], A[rank][k]);
for (int i = rank + 1; i < N; i++) {
if (A[i][j])
for (int k = i; k < M; k++)
A[j][k] ^ A[rank][k];
}
rank++;
}
}
int64_t ans =
(MOD + power_mod(2, N + M - 1) - power_mod(2, N + M - rank - 1)) % MOD;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
int64_t power_mod(int64_t num, int64_t power) {
int64_t prod = 1;
num %= MOD;
while (power > 0) {
if (power & 1)
prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int main() {
int N, M, A[300][300];
cin >> N >> M;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
cin >> A[i][j];
int rank = 0;
for (int j = 0; j < M; j++) {
int pivot = -1;
for (int i = rank; i < N; i++) {
if (A[i][j]) {
pivot = i;
break;
}
}
if (pivot >= 0) {
if (pivot != rank)
for (int k = 0; k < M; k++)
swap(A[pivot][k], A[rank][k]);
for (int i = rank + 1; i < N; i++) {
if (A[i][j])
for (int k = 0; k < M; k++)
A[i][k] ^= A[rank][k];
}
rank++;
}
}
int64_t ans =
(MOD + power_mod(2, N + M - 1) - power_mod(2, N + M - rank - 1)) % MOD;
cout << ans << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.initializer.change",
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.compound.bitwise.replace... | 934,343 | 934,342 | u314396879 | cpp |
p03133 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define EACH(i, c) \
for (__typeof((c).begin()) i = (c).begin(), i##_end = (c).end(); \
i != i##_end; ++i)
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
template <class T> inline void amin(T &x, const T &y) {
if (y < x)
x = y;
}
template <class T> inline void amax(T &x, const T &y) {
if (x < y)
x = y;
}
template <class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
template <unsigned MOD> struct ModInt {
static const unsigned static_MOD = MOD;
unsigned x;
void undef() { x = (unsigned)-1; }
bool isnan() const { return x == (unsigned)-1; }
inline int geti() const { return (int)x; }
ModInt() { x = 0; }
ModInt(const ModInt &y) { x = y.x; }
ModInt(int y) {
if (y < 0 || (int)MOD <= y)
y %= (int)MOD;
if (y < 0)
y += MOD;
x = y;
}
ModInt(unsigned y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt(long long y) {
if (y < 0 || MOD <= y)
y %= MOD;
if (y < 0)
y += MOD;
x = y;
}
ModInt(unsigned long long y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt &operator+=(const ModInt y) {
if ((x += y.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt y) {
if ((x -= y.x) & (1u << 31))
x += MOD;
return *this;
}
ModInt &operator*=(const ModInt y) {
x = (unsigned long long)x * y.x % MOD;
return *this;
}
ModInt &operator/=(const ModInt y) {
x = (unsigned long long)x * y.inv().x % MOD;
return *this;
}
ModInt operator-() const { return (x ? MOD - x : 0); }
ModInt inv() const {
unsigned a = MOD, b = x;
int u = 0, v = 1;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0)
u += MOD;
return ModInt(u);
}
ModInt pow(long long y) const {
ModInt b = *this, r = 1;
if (y < 0) {
b = b.inv();
y = -y;
}
for (; y; y >>= 1) {
if (y & 1)
r *= b;
b *= b;
}
return r;
}
friend ModInt operator+(ModInt x, const ModInt y) { return x += y; }
friend ModInt operator-(ModInt x, const ModInt y) { return x -= y; }
friend ModInt operator*(ModInt x, const ModInt y) { return x *= y; }
friend ModInt operator/(ModInt x, const ModInt y) { return x *= y.inv(); }
friend bool operator<(const ModInt x, const ModInt y) { return x.x < y.x; }
friend bool operator==(const ModInt x, const ModInt y) { return x.x == y.x; }
friend bool operator!=(const ModInt x, const ModInt y) { return x.x != y.x; }
};
const LL MOD = 998244353;
typedef ModInt<MOD> Mint;
int N, M;
int A[311][311];
void MAIN() {
scanf("%d%d", &N, &M);
REP(i, N) REP(j, M) scanf("%d", &A[i][j]);
int r = 0, c = 0;
while (r < N && c < M) {
int p = -1;
for (int i = r; i < N; i++)
if (A[i][c]) {
p = i;
break;
}
if (p == -1) {
c++;
continue;
}
for (int j = c; j < M; j++)
swap(A[r][j], A[p][j]);
REP(i, N) if (i != p && A[i][c]) {
for (int j = c; j < M; j++)
A[i][j] ^= A[p][j];
}
r++;
}
Mint ans = (Mint(2).pow(r) - 1) * Mint(2).pow(N - r) * Mint(2).pow(M - 1);
printf("%d\n", ans.geti());
}
int main() {
int TC = 1;
// scanf("%d", &TC);
REP(tc, TC) MAIN();
return 0;
}
| #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define EACH(i, c) \
for (__typeof((c).begin()) i = (c).begin(), i##_end = (c).end(); \
i != i##_end; ++i)
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
template <class T> inline void amin(T &x, const T &y) {
if (y < x)
x = y;
}
template <class T> inline void amax(T &x, const T &y) {
if (x < y)
x = y;
}
template <class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
template <unsigned MOD> struct ModInt {
static const unsigned static_MOD = MOD;
unsigned x;
void undef() { x = (unsigned)-1; }
bool isnan() const { return x == (unsigned)-1; }
inline int geti() const { return (int)x; }
ModInt() { x = 0; }
ModInt(const ModInt &y) { x = y.x; }
ModInt(int y) {
if (y < 0 || (int)MOD <= y)
y %= (int)MOD;
if (y < 0)
y += MOD;
x = y;
}
ModInt(unsigned y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt(long long y) {
if (y < 0 || MOD <= y)
y %= MOD;
if (y < 0)
y += MOD;
x = y;
}
ModInt(unsigned long long y) {
if (MOD <= y)
x = y % MOD;
else
x = y;
}
ModInt &operator+=(const ModInt y) {
if ((x += y.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt y) {
if ((x -= y.x) & (1u << 31))
x += MOD;
return *this;
}
ModInt &operator*=(const ModInt y) {
x = (unsigned long long)x * y.x % MOD;
return *this;
}
ModInt &operator/=(const ModInt y) {
x = (unsigned long long)x * y.inv().x % MOD;
return *this;
}
ModInt operator-() const { return (x ? MOD - x : 0); }
ModInt inv() const {
unsigned a = MOD, b = x;
int u = 0, v = 1;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0)
u += MOD;
return ModInt(u);
}
ModInt pow(long long y) const {
ModInt b = *this, r = 1;
if (y < 0) {
b = b.inv();
y = -y;
}
for (; y; y >>= 1) {
if (y & 1)
r *= b;
b *= b;
}
return r;
}
friend ModInt operator+(ModInt x, const ModInt y) { return x += y; }
friend ModInt operator-(ModInt x, const ModInt y) { return x -= y; }
friend ModInt operator*(ModInt x, const ModInt y) { return x *= y; }
friend ModInt operator/(ModInt x, const ModInt y) { return x *= y.inv(); }
friend bool operator<(const ModInt x, const ModInt y) { return x.x < y.x; }
friend bool operator==(const ModInt x, const ModInt y) { return x.x == y.x; }
friend bool operator!=(const ModInt x, const ModInt y) { return x.x != y.x; }
};
const LL MOD = 998244353;
typedef ModInt<MOD> Mint;
int N, M;
int A[311][311];
void MAIN() {
scanf("%d%d", &N, &M);
REP(i, N) REP(j, M) scanf("%d", &A[i][j]);
int r = 0, c = 0;
while (r < N && c < M) {
int p = -1;
for (int i = r; i < N; i++)
if (A[i][c]) {
p = i;
break;
}
if (p == -1) {
c++;
continue;
}
for (int j = c; j < M; j++)
swap(A[r][j], A[p][j]);
REP(i, N) if (i != r && A[i][c]) {
for (int j = c; j < M; j++)
A[i][j] ^= A[r][j];
}
r++;
c++;
}
Mint ans = (Mint(2).pow(r) - 1) * Mint(2).pow(N - r) * Mint(2).pow(M - 1);
printf("%d\n", ans.geti());
}
int main() {
int TC = 1;
// scanf("%d", &TC);
REP(tc, TC) MAIN();
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.unary.arithmetic.add"
] | 934,360 | 934,359 | u805729268 | cpp |
p03134 | #include <bits/stdc++.h>
using namespace std;
#define ALL(x) x.begin(), x.end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { \
cout << x << ' '; \
} \
cout << endl;
#define mod 998244353
using ll = long long;
const int INF = 1000000000;
const ll LINF = 1001002003004005006ll;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
// ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
struct IOSetup {
IOSetup() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(12);
}
} iosetup;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i + 1 == v.size() ? "" : " ");
return os;
}
template <ll Mod> struct ModInt {
long long x;
ModInt() : x(0) {}
ModInt(long long y) : x(y >= 0 ? y % Mod : (Mod - (-y) % Mod) % Mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= Mod)
x -= Mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += Mod - p.x) >= Mod)
x -= Mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1ll * x * p.x % Mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
(*this) *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
ModInt operator==(const ModInt &p) const { return x == p.x; }
ModInt operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = Mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(long long n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
long long t;
is >> t;
a = ModInt<Mod>(t);
return (is);
}
static int get_mod() { return Mod; }
};
using mint = ModInt<mod>;
template <int MAX> struct comcalc {
vector<mint> fact, finv, inv;
comcalc() : fact(MAX), finv(MAX), inv(MAX) {
fact[0] = mint(1), fact[1] = mint(1), finv[0] = mint(1), finv[1] = mint(1),
inv[1] = mint(1);
for (int i = 2; i < MAX; i++) {
fact[i] = fact[i - 1] * mint(i);
inv[i] = mint(0) - inv[mod % i] * (mint(mod / i));
finv[i] = finv[i - 1] * inv[i];
}
}
mint com(int n, int k) {
if (n < k)
return mint(0);
if (n < 0 or k < 0)
return mint(0);
return fact[n] * (finv[k] * finv[n - k]);
}
mint fac(int n) { return fact[n]; }
// 重複組み合わせ:n種類の物から重複を許し，k個選ぶ
mint nHk(int n, int k) { return com(n + k - 1, k); }
// 玉n区別，箱k区別，各箱1個以上O(k)
mint F12_dis_dis_one(int n, int k) {
mint ret = 1;
for (int i = 0; i <= k; i++) {
mint add = com(k, i) * (mint(i).pow(n));
if ((k - i) % 2)
ret -= add;
else
ret += add;
}
return ret;
}
};
mint pow_mod(mint x, ll n) { return x.pow(n); }
mint inv_mod(mint x) { return x.inverse(); }
// O(n)
mint fact_mod(ll n) {
mint ret = 1;
for (int i = 2; i <= n; i++)
ret *= mint(i);
return ret;
}
// O(r)
mint comb_mod(ll n, ll r) {
if (r > n - r)
r = n - r;
if (r == 0)
return 1;
mint a = 1, b = mint(fact_mod(r)).inverse();
for (int i = 0; i < r; i++)
a *= mint(n - i);
return a * b;
}
const int MAX = 4010000;
using cominit = comcalc<MAX>;
int ng[4001][4001];
mint dp[4001][4001];
signed main() {
string s;
cin >> s;
int n = s.size();
vector<int> rv(n), bv(n);
int rc = 0, bc = 0;
rep(i, n) {
rv[i] = (s[i] - '0');
bv[i] = 2 - rv[i];
rc += rv[i];
bc += bv[i];
}
rep(i, rc + 1) rep(j, bc + 1) ng[i][j] = false, dp[i][j] = 0;
dp[0][0] = 1;
{
int r = 0, b = 0;
for (int i = 0; b < bc; i++) {
b += bv[i];
if (b + r < i + 1) {
ng[r][i + 1] = true;
r++;
}
}
}
{
int r = 0, b = 0;
for (int i = 0; r < rc; i++) {
r += rv[i];
if (r + b < i + 1) {
ng[i + 1][b] = true;
b++;
}
}
}
rep(i, rc + 1) {
rep(j, bc + 1) {
if (i > 0 and !ng[i - 1][j])
dp[i][j] += dp[i - 1][j];
if (j > 0 and !ng[i][j - 1])
dp[i][j] += dp[i][j - 1];
}
}
// rep(i,rc+1){
// rep(j,bc+1){
// if(ng[i][j]) cout<<"x";
// else cout<<"o";
// }cout<<endl;
// }
cout << dp[rc][bc] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(x) x.begin(), x.end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) { \
cout << x << ' '; \
} \
cout << endl;
#define mod 998244353
using ll = long long;
const int INF = 1000000000;
const ll LINF = 1001002003004005006ll;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
// ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
struct IOSetup {
IOSetup() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(12);
}
} iosetup;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i + 1 == v.size() ? "" : " ");
return os;
}
template <ll Mod> struct ModInt {
long long x;
ModInt() : x(0) {}
ModInt(long long y) : x(y >= 0 ? y % Mod : (Mod - (-y) % Mod) % Mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= Mod)
x -= Mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += Mod - p.x) >= Mod)
x -= Mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1ll * x * p.x % Mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
(*this) *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
ModInt operator==(const ModInt &p) const { return x == p.x; }
ModInt operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = Mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(long long n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
long long t;
is >> t;
a = ModInt<Mod>(t);
return (is);
}
static int get_mod() { return Mod; }
};
using mint = ModInt<mod>;
template <int MAX> struct comcalc {
vector<mint> fact, finv, inv;
comcalc() : fact(MAX), finv(MAX), inv(MAX) {
fact[0] = mint(1), fact[1] = mint(1), finv[0] = mint(1), finv[1] = mint(1),
inv[1] = mint(1);
for (int i = 2; i < MAX; i++) {
fact[i] = fact[i - 1] * mint(i);
inv[i] = mint(0) - inv[mod % i] * (mint(mod / i));
finv[i] = finv[i - 1] * inv[i];
}
}
mint com(int n, int k) {
if (n < k)
return mint(0);
if (n < 0 or k < 0)
return mint(0);
return fact[n] * (finv[k] * finv[n - k]);
}
mint fac(int n) { return fact[n]; }
// 重複組み合わせ:n種類の物から重複を許し，k個選ぶ
mint nHk(int n, int k) { return com(n + k - 1, k); }
// 玉n区別，箱k区別，各箱1個以上O(k)
mint F12_dis_dis_one(int n, int k) {
mint ret = 1;
for (int i = 0; i <= k; i++) {
mint add = com(k, i) * (mint(i).pow(n));
if ((k - i) % 2)
ret -= add;
else
ret += add;
}
return ret;
}
};
mint pow_mod(mint x, ll n) { return x.pow(n); }
mint inv_mod(mint x) { return x.inverse(); }
// O(n)
mint fact_mod(ll n) {
mint ret = 1;
for (int i = 2; i <= n; i++)
ret *= mint(i);
return ret;
}
// O(r)
mint comb_mod(ll n, ll r) {
if (r > n - r)
r = n - r;
if (r == 0)
return 1;
mint a = 1, b = mint(fact_mod(r)).inverse();
for (int i = 0; i < r; i++)
a *= mint(n - i);
return a * b;
}
const int MAX = 4010000;
using cominit = comcalc<MAX>;
int ng[4001][4001];
mint dp[4001][4001];
signed main() {
string s;
cin >> s;
int n = s.size();
vector<int> rv(n), bv(n);
int rc = 0, bc = 0;
rep(i, n) {
rv[i] = (s[i] - '0');
bv[i] = 2 - rv[i];
rc += rv[i];
bc += bv[i];
}
rep(i, rc + 1) rep(j, bc + 1) ng[i][j] = false, dp[i][j] = 0;
dp[0][0] = 1;
{
int r = 0, b = 0;
for (int i = 0; b < bc; i++) {
b += bv[i];
if (b + r < i + 1) {
ng[r][b + 1] = true;
r++;
}
}
}
{
int r = 0, b = 0;
for (int i = 0; r < rc; i++) {
r += rv[i];
if (r + b < i + 1) {
ng[r + 1][b] = true;
b++;
}
}
}
rep(i, rc + 1) {
rep(j, bc + 1) {
if (i > 0 and !ng[i - 1][j])
dp[i][j] += dp[i - 1][j];
if (j > 0 and !ng[i][j - 1])
dp[i][j] += dp[i][j - 1];
}
}
cout << dp[rc][bc] << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 934,377 | 934,378 | u022832318 | cpp |
p03134 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 998244353;
int dp[5000][5000];
int sum[5000], sum2[5000];
int main() {
string s;
cin >> s;
rep(i, s.size() * 2) {
if (i)
sum[i] += sum[i - 1], sum2[i] += sum2[i - 1];
if (i < s.size()) {
int d = s[i] - '0';
sum[i] += d;
sum2[i] += 2 - d;
}
}
dp[0][0] = 1;
rep(i, s.size() * 2) rep(j, s.size() + 1) {
if (!dp[i][j])
continue;
if (j + 1 <= sum[i]) {
(dp[i + 1][j + 1] += dp[i][j]) %= MOD;
}
if (i - j + 1 <= sum2[i]) {
(dp[i + 1][j] += dp[i][j]) %= MOD;
}
}
cout << dp[s.size() * 2][sum[s.size()]] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 998244353;
int dp[5000][5000];
int sum[5000], sum2[5000];
int main() {
string s;
cin >> s;
rep(i, s.size() * 2) {
if (i)
sum[i] += sum[i - 1], sum2[i] += sum2[i - 1];
if (i < s.size()) {
int d = s[i] - '0';
sum[i] += d;
sum2[i] += 2 - d;
}
}
dp[0][0] = 1;
rep(i, s.size() * 2) rep(j, sum[s.size()] + 1) {
if (!dp[i][j])
continue;
if (j + 1 <= sum[i]) {
(dp[i + 1][j + 1] += dp[i][j]) %= MOD;
}
if (i - j + 1 <= sum2[i]) {
(dp[i + 1][j] += dp[i][j]) %= MOD;
}
}
cout << dp[s.size() * 2][sum[s.size()]] << endl;
} | [
"call.arguments.change"
] | 934,381 | 934,382 | u781091740 | cpp |
p03134 | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
int r[4003], b[4003];
ll dp[2][4003][4003];
int main() {
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '0')
r[i] += 2;
if (s[i] == '1') {
r[i]++;
b[i]++;
}
if (s[i] == '2')
b[i] += 2;
r[i + 1] += r[i];
b[i + 1] += b[i];
}
for (int i = n; i < n * 2; i++) {
r[i + 1] = r[i];
b[i + 1] = b[i];
}
dp[0][0][0] = 1;
for (int i = 1; i <= n * 2; i++) {
for (int j = 1; j <= min(i, r[i - 1]); j++)
dp[i % 2][j][i - j] =
(dp[i % 2][j][i - j] + dp[(i + 1) % 2][j - 1][i - j]) % MOD;
for (int j = 1; j <= min(i, b[i - 1]); j++)
dp[i % 2][i - j][j] =
(dp[i % 2][i - j][j] + dp[(i + 1) % 2][i - j][j - 1]) % MOD;
}
cout << dp[n % 2][r[n * 2]][b[n * 2]] << endl;
} | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
int r[4003], b[4003];
ll dp[2][4003][4003];
int main() {
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '0')
r[i] += 2;
if (s[i] == '1') {
r[i]++;
b[i]++;
}
if (s[i] == '2')
b[i] += 2;
r[i + 1] += r[i];
b[i + 1] += b[i];
}
for (int i = n; i < n * 2; i++) {
r[i + 1] = r[i];
b[i + 1] = b[i];
}
dp[0][0][0] = 1;
for (int i = 1; i <= n * 2; i++) {
for (int j = 1; j <= min(i, r[i - 1]); j++)
dp[i % 2][j][i - j] =
(dp[i % 2][j][i - j] + dp[(i + 1) % 2][j - 1][i - j]) % MOD;
for (int j = 1; j <= min(i, b[i - 1]); j++)
dp[i % 2][i - j][j] =
(dp[i % 2][i - j][j] + dp[(i + 1) % 2][i - j][j - 1]) % MOD;
}
cout << dp[0][r[n * 2]][b[n * 2]] << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"io.output.change",
"expression.operation.binary.remove"
] | 934,397 | 934,398 | u681557252 | cpp |
p03134 | #include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9 + 7)
#define inf (int)(3e18)
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i < n; i++)
#define P std::pair<int, int>
#define PiP std::pair<int, std::pair<int, int>>
#define all(v) v.begin(), v.end()
#define mkp std::make_pair
#define prique(T) std::priority_queue<T, vector<T>, greater<T>>
using namespace std;
template <class T> inline void chmax(T &a, T b) { a = std::max(a, b); }
template <class T> inline void chmin(T &a, T b) { a = std::min(a, b); }
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return x != 1;
}
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int mod_pow(int x, int y, int m = mod) {
int res = 1;
x %= m;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
return kai(x, y) * mod_pow(kai(y, y), mod - 2, mod) % mod;
}
int get_rand(int MIN, int MAX) {
std::random_device rnd;
std::mt19937 mt32(rnd());
std::uniform_int_distribution<int> engine(MIN, MAX);
return engine(mt32);
}
struct BIT {
vector<int> bit;
int n;
BIT(int x) {
bit.resize(x + 1, 0);
n = x;
}
void add(int x, int y) {
while (x <= n) {
bit[x] += y;
x += x & -x;
}
}
int sum(int x) {
int res = 0;
while (x > 0) {
res += bit[x];
x -= x & -x;
}
return res;
}
};
struct UnionFind {
vector<int> par, size;
UnionFind(int x) {
par.resize(x);
size.resize(x, 1);
rep(i, x) par[i] = i;
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
bool same(int x, int y) { return find(x) == find(y); }
int consize(int x) { return size[find(x)]; }
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (size[x] < size[y]) {
par[x] = y;
size[y] += size[x];
} else {
par[y] = x;
size[x] += size[y];
}
}
};
struct Tree {
int size;
vector<int> par, depth;
vector<int> doubling[30];
vector<vector<int>> G;
int root = 0;
Tree(int x) {
par.resize(x);
depth.resize(x);
rep(i, 30) { doubling[i].resize(x, -1); }
G.resize(x);
size = x;
}
void add_edge(int x, int y) {
G[x].push_back(y);
G[y].push_back(x);
}
void dfs(int x) {
for (int i : G[x]) {
if (depth[i] == -1) {
depth[i] = depth[x] + 1;
doubling[0][i] = x;
dfs(i);
}
}
}
void init() {
rep(i, size) depth[i] = -1;
depth[root] = 0;
dfs(root);
rep(i, 29) {
rep(j, size) {
if (doubling[i][j] == -1)
doubling[i + 1][j] = -1;
else
doubling[i + 1][j] = doubling[i][doubling[i][j]];
}
}
}
int lca(int x, int y) {
if (depth[x] > depth[y])
swap(x, y);
for (int i = 29; i >= 0; i--) {
if ((depth[y] - depth[x]) >> i & 1) {
y = doubling[i][y];
}
}
if (x == y)
return x;
for (int i = 29; i >= 0; i--) {
if (doubling[i][x] != doubling[i][y]) {
x = doubling[i][x];
y = doubling[i][y];
}
}
return doubling[0][x];
}
};
struct RollingHash {
int Base = 283;
const int MASK30 = (1ll << 30) - 1;
const int MASK31 = (1ll << 31) - 1;
const int MOD = (1ll << 61) - 1;
vector<int> hash, power;
int calcmod(int val) {
val = (val & MOD) + (val >> 61);
if (val > MOD)
val -= MOD;
return val;
}
int mul(int x, int y) {
int xu = x >> 31;
int xd = x & MASK31;
int yu = y >> 31;
int yd = y & MASK31;
int mid = xd * yu + xu * yd;
int midu = mid >> 30;
int midd = mid & MASK30;
return calcmod(xu * yu * 2 + midu + (midd << 31) + xd * yd);
}
RollingHash(string s) {
// Base=get_rand(1<<7,1<<8);
int sz = s.size();
hash.resize(sz + 1, 0);
power.resize(sz + 1, 1);
rep(i, sz) {
hash[i + 1] = (mul(hash[i], Base) + s[i]) % MOD;
power[i + 1] = mul(power[i], Base) % MOD;
}
}
int get(int l, int r) {
int res = (hash[r] - mul(hash[l], power[r - l]) + MOD) % MOD;
return res;
}
int lcp(int x, int y) {
int len = min(hash.size() - y, hash.size() - x);
int ok = 0, ng = len + 1;
while (ng - ok > 1) {
int mid = (ok + ng) / 2;
if (get(x, x + mid) == get(y, y + mid))
ok = mid;
else
ng = mid;
}
return ok;
}
};
struct Segtree {
int size = 1;
vector<int> dat, lazy;
Segtree(int x) {
while (size < x)
size *= 2;
dat.resize(size * 2 - 1, inf);
lazy.resize(size * 2 - 1, inf);
}
void eval(int k, int l, int r) {
chmin(dat[k], lazy[k]);
if (r - l > 1) {
chmin(lazy[k * 2 + 1], lazy[k]);
chmin(lazy[k * 2 + 2], lazy[k]);
}
lazy[k] = inf;
}
void update(int a, int b, int x, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = size;
eval(k, l, r);
if (r <= a || b <= l)
return;
if (a <= l && r <= b) {
chmin(lazy[k], x);
eval(k, l, r);
return;
}
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
int query(int a, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = size;
eval(k, l, r);
if (r - l == 1) {
return dat[k];
}
if (a < (l + r) / 2) {
return query(a, k * 2 + 1, l, (l + r) / 2);
}
return query(a, k * 2 + 2, (l + r) / 2, r);
}
};
template <class T> vector<int> KMP(vector<T> target, vector<T> pattern) {
vector<int> table(pattern.size() + 1);
table[0] = 0;
int j = 0;
REP(i, (int)pattern.size()) {
if (pattern[i] == pattern[j]) {
table[i] = j++;
} else {
table[i] = j;
j = 0;
}
}
table[pattern.size()] = j;
j = 0;
vector<int> res;
int i = 0;
while (i < target.size()) {
if (j < pattern.size() && target[i] == pattern[j]) {
i++;
j++;
} else {
if (!j)
i++;
j = table[j];
}
if (j == pattern.size())
res.push_back(i - j);
}
return res;
}
int perm[1000005];
void init_perm() {
perm[0] = 1;
REP(i, 1000005) perm[i] = perm[i - 1] * i % mod;
}
int nCk(int x, int y) {
return perm[x] * mod_pow(perm[x - y], mod - 2) % mod *
mod_pow(perm[y], mod - 2) % mod;
}
/*--------Library Zone!--------*/
string s;
int dp[4005][4005], sum[2005], sum2[2005];
const int MOD = 998244353;
signed main() {
cin >> s;
rep(i, s.size()) {
sum[i + 1] = sum[i] + ('2' - s[i]);
sum2[i + 1] = sum2[i] + (s[i] - '0');
}
dp[0][0] = 1;
rep(i, s.size() * 2) rep(j, i + 1) {
dp[i][j] %= MOD;
if (dp[i][j] == 0)
continue;
if (sum[min((int)s.size(), i + 1)] >= j + 1) {
dp[i + 1][j + 1] += dp[i][j];
}
if (sum2[min((int)s.size(), i + 1)] >= i - j + 1) {
dp[i + 1][j] += dp[i][j];
}
}
int res = 0;
rep(i, s.size() * 2) {
res += dp[s.size() * 2][i];
res %= MOD;
}
cout << res << endl;
}
| #include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9 + 7)
#define inf (int)(3e18)
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i < n; i++)
#define P std::pair<int, int>
#define PiP std::pair<int, std::pair<int, int>>
#define all(v) v.begin(), v.end()
#define mkp std::make_pair
#define prique(T) std::priority_queue<T, vector<T>, greater<T>>
using namespace std;
template <class T> inline void chmax(T &a, T b) { a = std::max(a, b); }
template <class T> inline void chmin(T &a, T b) { a = std::min(a, b); }
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return x != 1;
}
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int mod_pow(int x, int y, int m = mod) {
int res = 1;
x %= m;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
return kai(x, y) * mod_pow(kai(y, y), mod - 2, mod) % mod;
}
int get_rand(int MIN, int MAX) {
std::random_device rnd;
std::mt19937 mt32(rnd());
std::uniform_int_distribution<int> engine(MIN, MAX);
return engine(mt32);
}
struct BIT {
vector<int> bit;
int n;
BIT(int x) {
bit.resize(x + 1, 0);
n = x;
}
void add(int x, int y) {
while (x <= n) {
bit[x] += y;
x += x & -x;
}
}
int sum(int x) {
int res = 0;
while (x > 0) {
res += bit[x];
x -= x & -x;
}
return res;
}
};
struct UnionFind {
vector<int> par, size;
UnionFind(int x) {
par.resize(x);
size.resize(x, 1);
rep(i, x) par[i] = i;
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
bool same(int x, int y) { return find(x) == find(y); }
int consize(int x) { return size[find(x)]; }
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (size[x] < size[y]) {
par[x] = y;
size[y] += size[x];
} else {
par[y] = x;
size[x] += size[y];
}
}
};
struct Tree {
int size;
vector<int> par, depth;
vector<int> doubling[30];
vector<vector<int>> G;
int root = 0;
Tree(int x) {
par.resize(x);
depth.resize(x);
rep(i, 30) { doubling[i].resize(x, -1); }
G.resize(x);
size = x;
}
void add_edge(int x, int y) {
G[x].push_back(y);
G[y].push_back(x);
}
void dfs(int x) {
for (int i : G[x]) {
if (depth[i] == -1) {
depth[i] = depth[x] + 1;
doubling[0][i] = x;
dfs(i);
}
}
}
void init() {
rep(i, size) depth[i] = -1;
depth[root] = 0;
dfs(root);
rep(i, 29) {
rep(j, size) {
if (doubling[i][j] == -1)
doubling[i + 1][j] = -1;
else
doubling[i + 1][j] = doubling[i][doubling[i][j]];
}
}
}
int lca(int x, int y) {
if (depth[x] > depth[y])
swap(x, y);
for (int i = 29; i >= 0; i--) {
if ((depth[y] - depth[x]) >> i & 1) {
y = doubling[i][y];
}
}
if (x == y)
return x;
for (int i = 29; i >= 0; i--) {
if (doubling[i][x] != doubling[i][y]) {
x = doubling[i][x];
y = doubling[i][y];
}
}
return doubling[0][x];
}
};
struct RollingHash {
int Base = 283;
const int MASK30 = (1ll << 30) - 1;
const int MASK31 = (1ll << 31) - 1;
const int MOD = (1ll << 61) - 1;
vector<int> hash, power;
int calcmod(int val) {
val = (val & MOD) + (val >> 61);
if (val > MOD)
val -= MOD;
return val;
}
int mul(int x, int y) {
int xu = x >> 31;
int xd = x & MASK31;
int yu = y >> 31;
int yd = y & MASK31;
int mid = xd * yu + xu * yd;
int midu = mid >> 30;
int midd = mid & MASK30;
return calcmod(xu * yu * 2 + midu + (midd << 31) + xd * yd);
}
RollingHash(string s) {
// Base=get_rand(1<<7,1<<8);
int sz = s.size();
hash.resize(sz + 1, 0);
power.resize(sz + 1, 1);
rep(i, sz) {
hash[i + 1] = (mul(hash[i], Base) + s[i]) % MOD;
power[i + 1] = mul(power[i], Base) % MOD;
}
}
int get(int l, int r) {
int res = (hash[r] - mul(hash[l], power[r - l]) + MOD) % MOD;
return res;
}
int lcp(int x, int y) {
int len = min(hash.size() - y, hash.size() - x);
int ok = 0, ng = len + 1;
while (ng - ok > 1) {
int mid = (ok + ng) / 2;
if (get(x, x + mid) == get(y, y + mid))
ok = mid;
else
ng = mid;
}
return ok;
}
};
struct Segtree {
int size = 1;
vector<int> dat, lazy;
Segtree(int x) {
while (size < x)
size *= 2;
dat.resize(size * 2 - 1, inf);
lazy.resize(size * 2 - 1, inf);
}
void eval(int k, int l, int r) {
chmin(dat[k], lazy[k]);
if (r - l > 1) {
chmin(lazy[k * 2 + 1], lazy[k]);
chmin(lazy[k * 2 + 2], lazy[k]);
}
lazy[k] = inf;
}
void update(int a, int b, int x, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = size;
eval(k, l, r);
if (r <= a || b <= l)
return;
if (a <= l && r <= b) {
chmin(lazy[k], x);
eval(k, l, r);
return;
}
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
int query(int a, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = size;
eval(k, l, r);
if (r - l == 1) {
return dat[k];
}
if (a < (l + r) / 2) {
return query(a, k * 2 + 1, l, (l + r) / 2);
}
return query(a, k * 2 + 2, (l + r) / 2, r);
}
};
template <class T> vector<int> KMP(vector<T> target, vector<T> pattern) {
vector<int> table(pattern.size() + 1);
table[0] = 0;
int j = 0;
REP(i, (int)pattern.size()) {
if (pattern[i] == pattern[j]) {
table[i] = j++;
} else {
table[i] = j;
j = 0;
}
}
table[pattern.size()] = j;
j = 0;
vector<int> res;
int i = 0;
while (i < target.size()) {
if (j < pattern.size() && target[i] == pattern[j]) {
i++;
j++;
} else {
if (!j)
i++;
j = table[j];
}
if (j == pattern.size())
res.push_back(i - j);
}
return res;
}
int perm[1000005];
void init_perm() {
perm[0] = 1;
REP(i, 1000005) perm[i] = perm[i - 1] * i % mod;
}
int nCk(int x, int y) {
return perm[x] * mod_pow(perm[x - y], mod - 2) % mod *
mod_pow(perm[y], mod - 2) % mod;
}
/*--------Library Zone!--------*/
string s;
int dp[4005][4005], sum[2005], sum2[2005];
const int MOD = 998244353;
signed main() {
cin >> s;
rep(i, s.size()) {
sum[i + 1] = sum[i] + ('2' - s[i]);
sum2[i + 1] = sum2[i] + (s[i] - '0');
}
dp[0][0] = 1;
rep(i, s.size() * 2) rep(j, i + 1) {
dp[i][j] %= MOD;
if (dp[i][j] == 0)
continue;
if (sum[min((int)s.size(), i + 1)] >= j + 1) {
dp[i + 1][j + 1] += dp[i][j];
}
if (sum2[min((int)s.size(), i + 1)] >= i - j + 1) {
dp[i + 1][j] += dp[i][j];
}
}
int res = 0;
rep(i, s.size() * 2 + 1) {
res += dp[s.size() * 2][i];
res %= MOD;
}
cout << res << endl;
}
| [
"expression.operation.binary.add"
] | 934,399 | 934,400 | u147049801 | cpp |
p03134 | //#pragma GCC optimize ("-O3","unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define pb(a) push_back
#define print(x) cout << (x) << '\n'
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), n)
#define ub(v, n) upper_bound(v.begin(), v.end(), n)
#define int long long
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
#define move(x) ans.push_back(x), c[x]--, now = x;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> P;
const int MOD = 998244353;
const int MAX = 200020;
const double pi = acos(-1);
const double EPS = 1e-12;
const ll INF = 2e18;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll add(ll x, ll y) {
x += y;
if (x >= MOD)
return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0)
return x + MOD;
return x;
}
ll mult(ll x, ll y) { return (x * y) % MOD; }
ll bin_pow(ll x, ll p) {
if (p == 0)
return 1;
if (p & 1)
return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
int dp[2020][2020];
int cumR[2020];
int A[2020], B[2020];
int sumR, sumB;
void solve() {
string S;
cin >> S;
int N = S.size();
COMinit();
REP(i, N) {
int num = S[i] - '0';
A[i] += num;
B[i] += 2 - num;
cumR[i + 1] += cumR[i] + A[i];
sumR += A[i];
sumB += B[i];
}
dp[0][0] = 1;
REP(i, N) {
REP(r, N + 1) {
if (r > 0 && cumR[i + 1] >= r)
dp[i + 1][r] += dp[i][r - 1];
int cumB = (i + 1) * 2 - cumR[i + 1];
if (cumB >= i + 1 - r)
dp[i + 1][r] += dp[i][r];
assert(dp[i + 1][r] < 0);
// pe(i+1);pe(r);print(dp[i+1][r]);
}
}
ll ans = 0;
REP(r, N + 1) {
ll res = mult(dp[N][r], fac[N]);
res = mult(res, mult(finv[sumR - r], finv[sumB - (N - r)]));
ans = add(ans, res);
}
print(ans);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
} | //#pragma GCC optimize ("-O3","unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define pb(a) push_back
#define print(x) cout << (x) << '\n'
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), n)
#define ub(v, n) upper_bound(v.begin(), v.end(), n)
#define int long long
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
#define move(x) ans.push_back(x), c[x]--, now = x;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> P;
const int MOD = 998244353;
const int MAX = 200020;
const double pi = acos(-1);
const double EPS = 1e-12;
const ll INF = 2e18;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll add(ll x, ll y) {
x += y;
if (x >= MOD)
return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0)
return x + MOD;
return x;
}
ll mult(ll x, ll y) { return (x * y) % MOD; }
ll bin_pow(ll x, ll p) {
if (p == 0)
return 1;
if (p & 1)
return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
int dp[2020][2020];
int cumR[2020];
int A[2020], B[2020];
int sumR, sumB;
void solve() {
string S;
cin >> S;
int N = S.size();
COMinit();
REP(i, N) {
int num = S[i] - '0';
A[i] += num;
B[i] += 2 - num;
cumR[i + 1] += cumR[i] + A[i];
sumR += A[i];
sumB += B[i];
}
dp[0][0] = 1;
REP(i, N) {
REP(r, N + 1) {
if (r > 0 && cumR[i + 1] >= r)
dp[i + 1][r] += dp[i][r - 1];
int cumB = (i + 1) * 2 - cumR[i + 1];
if (cumB >= i + 1 - r)
dp[i + 1][r] += dp[i][r];
dp[i + 1][r] %= MOD;
// pe(i+1);pe(r);print(dp[i+1][r]);
}
}
ll ans = 0;
REP(r, N + 1) {
ll res = mult(dp[N][r], fac[N]);
res = mult(res, mult(finv[sumR - r], finv[sumB - (N - r)]));
ans = add(ans, res);
}
print(ans);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
} | [
"call.remove",
"call.arguments.change"
] | 934,403 | 934,402 | u859396346 | cpp |
p03134 | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define inf 1000000007
#define LINF 1000000000000000007LL
#define ll long long
using namespace std;
int dp[4010][4010];
int ka[214514], inv[214514];
void setkaijo(int n) {
ka[0] = 1;
for (int i = 1; i <= n; i++) {
ka[i] = ka[i - 1] * i;
ka[i] %= inf;
}
}
int modpow(int x, int k) {
// x ^ k mod inf
int p2[55], res = 1;
p2[0] = 1;
p2[1] = x % inf;
for (int i = 2; i <= 50; i++) {
p2[i] = p2[i - 1] * p2[i - 1];
p2[i] %= inf;
}
for (int i = 1; i <= 50; i++) {
if (k % 2 == 1) {
res *= p2[i];
res %= inf;
}
k /= 2;
}
return res;
}
void setinv(int n) {
for (int i = 0; i <= n; i++) {
inv[i] = modpow(ka[i], (ll)inf - 2);
}
}
int comb(int n, int k) {
if (k < 0 || n < 0 || k > n)
return 0;
if (k == 0 || k == n)
return 1;
int res = (ka[n] * inv[k]) % inf;
res = (res * inv[n - k]) % inf;
return res;
}
signed main() {
string st;
cin >> st;
int n = st.size();
setkaijo(10000);
setinv(10000);
dp[0][0] = 1;
int rc = 0, bc = 0;
for (int i = 1; i <= n; i++) {
char cur = st[i - 1];
if (cur == '2') {
rc += 2;
} else if (cur == '1') {
rc++;
bc++;
} else {
bc += 2;
}
for (int j = 0; j <= 2000; j++) {
if (j < rc) {
dp[i][j + 1] += dp[i - 1][j];
dp[i][j + 1] %= inf;
}
if ((i - 1 - j) >= 0 && (i - 1 - j) < bc) {
dp[i][j] += dp[i - 1][j];
dp[i][j] %= inf;
}
}
}
// for(int i=0;i<=n;i++){for(int j=0;j<=i;j++){cout<<"dp"<<i<<j<<"
// "<<dp[i][j]<<endl;}}
int ans = 0;
for (int i = 0; i <= n; i++) {
ans += dp[n][i] * comb(n, rc - i);
ans %= inf;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define inf 998244353
#define LINF 1000000000000000007LL
#define ll long long
using namespace std;
int dp[4010][4010];
int ka[214514], inv[214514];
void setkaijo(int n) {
ka[0] = 1;
for (int i = 1; i <= n; i++) {
ka[i] = ka[i - 1] * i;
ka[i] %= inf;
}
}
int modpow(int x, int k) {
// x ^ k mod inf
int p2[55], res = 1;
p2[0] = 1;
p2[1] = x % inf;
for (int i = 2; i <= 50; i++) {
p2[i] = p2[i - 1] * p2[i - 1];
p2[i] %= inf;
}
for (int i = 1; i <= 50; i++) {
if (k % 2 == 1) {
res *= p2[i];
res %= inf;
}
k /= 2;
}
return res;
}
void setinv(int n) {
for (int i = 0; i <= n; i++) {
inv[i] = modpow(ka[i], (ll)inf - 2);
}
}
int comb(int n, int k) {
if (k < 0 || n < 0 || k > n)
return 0;
if (k == 0 || k == n)
return 1;
int res = (ka[n] * inv[k]) % inf;
res = (res * inv[n - k]) % inf;
return res;
}
signed main() {
string st;
cin >> st;
int n = st.size();
setkaijo(10000);
setinv(10000);
dp[0][0] = 1;
int rc = 0, bc = 0;
for (int i = 1; i <= n; i++) {
char cur = st[i - 1];
if (cur == '2') {
rc += 2;
} else if (cur == '1') {
rc++;
bc++;
} else {
bc += 2;
}
for (int j = 0; j <= 2000; j++) {
if (j <= n && j < rc) {
dp[i][j + 1] += dp[i - 1][j];
dp[i][j + 1] %= inf;
}
if ((i - 1 - j) >= 0 && (i - 1 - j) < bc) {
dp[i][j] += dp[i - 1][j];
dp[i][j] %= inf;
}
}
}
// for(int i=0;i<=n;i++){for(int j=0;j<=i;j++){cout<<"dp"<<i<<j<<"
// "<<dp[i][j]<<endl;}}
int ans = 0;
for (int i = 0; i <= n; i++) {
ans += dp[n][i] * comb(n, rc - i);
ans %= inf;
}
cout << ans << endl;
return 0;
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 934,408 | 934,409 | u335590796 | cpp |
p03134 | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, m, n) for (int i = int(m); i < int(n); i++)
#define all(c) begin(c), end(c)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
//改造
typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
using Int = long long int;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 //デバッグする時1にしてね
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 998244353
//ここから編集する
class Combination {
public:
vector<ll> fact;
Combination(int max_n) {
// 1 ~ n!までの階乗modを求める
int n = max_n;
vector<ll> fact(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
this->fact = fact;
}
template <typename T>
// templateをつかってみｔか
ll pow(T x, int y) {
if (y == 0)
return 1;
if (y == 1)
return x;
if (y == 2)
return (x * x) % MOD;
// if (y % 2 == 1) return pow(x, y / 2) * pow(x, y / 2) % MOD;
if (y % 2 == 1)
return pow(pow(x, y / 2), 2) * x % MOD;
// return pow(x, y / 2) * pow(x, y / 2) % MOD;
return pow(pow(x, y / 2), 2) % MOD;
}
ll nCk(int n, int k) {
// return (fact[n] * pow(fact[n-k],MOD-2) * pow(fact[k],MOD-2)) %
// MOD;
return (((fact[n] * pow(fact[n - k], MOD - 2)) % MOD) *
pow(fact[k], MOD - 2)) %
MOD;
}
/**
* x ^ -1を求める
*/
template <typename T> ll inv(T x) { return pow(x, MOD - 2); }
};
Combination cmb(4001);
class Solve {
public:
string S;
vector<Int> B;
vector<Int> C;
Int N;
void solve() {
cin >> S;
N = S.size();
B.resize(N + 1);
C.resize(N + 1);
for (int i = 0; i < N; ++i) {
B[i] = S[i] - '0';
}
C[0] = B[0];
for (int i = 1; i < N; ++i) {
C[i] = B[i] + C[i - 1];
}
vector<vector<Int>> dp(N + 1, vector<Int>(2 * N + 1));
dp[0][0] = 1;
for (int i = 0; i < N; ++i) {
for (int j = 0; j <= i; ++j) {
dp[i][j] %= MOD;
Int b = 0;
Int r = 0;
if (i > 0) {
b = C[i - 1] - j;
r = (2 * i - C[i - 1]) - b;
}
if (b < 0)
continue;
// あお追加できる場合
if (b > 0 || B[i] > 0) {
(dp[i + 1][j + 1] += dp[i][j]) %= MOD;
}
// あか追加できる場合
if (r > 0 || B[i] <= 1) {
(dp[i + 1][j] += dp[i][j]) %= MOD;
}
}
}
Int ans = 0;
for (int i = 0; i <= N; ++i) {
Int blue = C[N - 1] - i;
Int red = (2 * N - C[N - 1]) - (N - i);
if (blue + red != N) {
exit(-1);
}
if (blue >= 0 && red >= 0) {
Int left = dp[N][i] % MOD;
Int right = cmb.nCk(blue + red, blue);
Int tmp = (left * right) % MOD;
ans += tmp;
ans %= MOD;
}
}
cout << ans << endl;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
Solve().solve();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, m, n) for (int i = int(m); i < int(n); i++)
#define all(c) begin(c), end(c)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
//改造
typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
using Int = long long int;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 //デバッグする時1にしてね
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 998244353
//ここから編集する
class Combination {
public:
vector<ll> fact;
Combination(int max_n) {
// 1 ~ n!までの階乗modを求める
int n = max_n;
vector<ll> fact(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
this->fact = fact;
}
template <typename T>
// templateをつかってみｔか
ll pow(T x, int y) {
if (y == 0)
return 1;
if (y == 1)
return x;
if (y == 2)
return (x * x) % MOD;
// if (y % 2 == 1) return pow(x, y / 2) * pow(x, y / 2) % MOD;
if (y % 2 == 1)
return pow(pow(x, y / 2), 2) * x % MOD;
// return pow(x, y / 2) * pow(x, y / 2) % MOD;
return pow(pow(x, y / 2), 2) % MOD;
}
ll nCk(int n, int k) {
// return (fact[n] * pow(fact[n-k],MOD-2) * pow(fact[k],MOD-2)) %
// MOD;
return (((fact[n] * pow(fact[n - k], MOD - 2)) % MOD) *
pow(fact[k], MOD - 2)) %
MOD;
}
/**
* x ^ -1を求める
*/
template <typename T> ll inv(T x) { return pow(x, MOD - 2); }
};
Combination cmb(4001);
class Solve {
public:
string S;
vector<Int> B;
vector<Int> C;
Int N;
void solve() {
cin >> S;
N = S.size();
B.resize(N + 1);
C.resize(N + 1);
for (int i = 0; i < N; ++i) {
B[i] = S[i] - '0';
}
C[0] = B[0];
for (int i = 1; i < N; ++i) {
C[i] = B[i] + C[i - 1];
}
vector<vector<Int>> dp(N + 1, vector<Int>(2 * N + 1));
dp[0][0] = 1;
for (int i = 0; i < N; ++i) {
for (int j = 0; j <= i; ++j) {
dp[i][j] %= MOD;
Int b = 0;
Int r = 0;
if (i > 0) {
b = C[i - 1] - j;
r = (2 * i - C[i - 1]) - (i - j);
}
if (b < 0)
continue;
// あお追加できる場合
if (b > 0 || B[i] > 0) {
(dp[i + 1][j + 1] += dp[i][j]) %= MOD;
}
// あか追加できる場合
if (r > 0 || B[i] <= 1) {
(dp[i + 1][j] += dp[i][j]) %= MOD;
}
}
}
Int ans = 0;
for (int i = 0; i <= N; ++i) {
Int blue = C[N - 1] - i;
Int red = (2 * N - C[N - 1]) - (N - i);
if (blue + red != N) {
exit(-1);
}
if (blue >= 0 && red >= 0) {
Int left = dp[N][i] % MOD;
Int right = cmb.nCk(blue + red, blue);
Int tmp = (left * right) % MOD;
ans += tmp;
ans %= MOD;
}
}
cout << ans << endl;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
Solve().solve();
return 0;
}
| [
"assignment.value.change",
"expression.operation.binary.change"
] | 934,410 | 934,411 | u003873207 | cpp |
p03134 | #include <bits/stdc++.h>
using namespace std;
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<long long, long long>
#define FOR(i, a, b) for (long long i = a; i < b; ++i)
#define RFOR(i, a, b) for (long long i = a; i > b; --i)
#define f first
#define se second
#define maxn 400005
#define all(v) v.begin(), v.end()
#define sz(x) (long long)x.size()
#define mod 998244353
#define pqueue priority_queue<long long>
#define pdqueue priority_queue<long long, vector<long long>, greater<long long>>
typedef long long ll;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// const long long md = 998244353;
/*const long long mod = 998244353;
long long power(long long a,long long n)
{
if(n == 1)return a%mod;
if(n == 0)return 1;
if(n&1)return ((a%mod)*(power((a*a)%mod,n/2))%mod)%mod;
return power((a*a)%mod,n/2)%mod;
}
*/
int main() {
ll n, ans = 0;
string s;
cin >> s;
n = s.length() * 2;
ll dpA[4001];
ll dpB[4001];
ll *dp1;
ll *dp2;
FOR(i, 0, n + 1) { dpA[0] = 0; }
if (s[0] != '2')
dpA[0] = 1;
if (s[0] != '0')
dpA[1] = 1;
dp2 = dpA;
ll r = s[0] == '0' ? 2 : (s[0] == '1' ? 1 : 0);
ll w = 2;
FOR(i, 1, n) {
if (i % 2 > 0) {
dp1 = dpA;
dp2 = dpB;
} else {
dp1 = dpB;
dp2 = dpA;
}
if (i < s.length()) {
w += 2;
r += s[i] == '0' ? 2 : (s[i] == '1' ? 1 : 0);
}
if ((w - r) > i)
dp2[0] = dp1[0];
else
dp2[0] = 0;
FOR(j, 1, n + 1) {
if (r >= j)
dp2[j] = dp1[j - 1];
else
dp2[j] = 0;
if ((w - r) > (i - j)) {
dp2[j] += dp1[j];
if (dp2[j] > mod)
dp2[j] -= mod;
}
}
}
cout << dp2[r] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<long long, long long>
#define FOR(i, a, b) for (long long i = a; i < b; ++i)
#define RFOR(i, a, b) for (long long i = a; i > b; --i)
#define f first
#define se second
#define maxn 400005
#define all(v) v.begin(), v.end()
#define sz(x) (long long)x.size()
#define mod 998244353
#define pqueue priority_queue<long long>
#define pdqueue priority_queue<long long, vector<long long>, greater<long long>>
typedef long long ll;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// const long long md = 998244353;
/*const long long mod = 998244353;
long long power(long long a,long long n)
{
if(n == 1)return a%mod;
if(n == 0)return 1;
if(n&1)return ((a%mod)*(power((a*a)%mod,n/2))%mod)%mod;
return power((a*a)%mod,n/2)%mod;
}
*/
int main() {
ll n, ans = 0;
string s;
cin >> s;
n = s.length() * 2;
ll dpA[4001];
ll dpB[4001];
ll *dp1;
ll *dp2;
FOR(i, 0, n + 1) { dpA[0] = 0; }
if (s[0] != '2')
dpA[1] = 1;
if (s[0] != '0')
dpA[0] = 1;
dp2 = dpA;
// cerr << dp2[0] << " " << dp2[1] << " " << dp2[2] << endl;
ll r = s[0] == '0' ? 2 : (s[0] == '1' ? 1 : 0);
ll w = 2;
FOR(i, 1, n) {
if (i % 2 > 0) {
dp1 = dpA;
dp2 = dpB;
} else {
dp1 = dpB;
dp2 = dpA;
}
if (i < s.length()) {
w += 2;
r += s[i] == '0' ? 2 : (s[i] == '1' ? 1 : 0);
}
if ((w - r) > i)
dp2[0] = dp1[0];
else
dp2[0] = 0;
// cerr << dp2[0] << " ";
FOR(j, 1, n + 1) {
if (r >= j)
dp2[j] = dp1[j - 1];
else
dp2[j] = 0;
if ((w - r) > (i - j)) {
dp2[j] += dp1[j];
if (dp2[j] > mod)
dp2[j] -= mod;
}
// cerr << dp2[j] << " ";
}
// cerr << endl;
}
cout << dp2[r] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 934,426 | 934,427 | u869644355 | cpp |
p03134 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define fst first
#define snd second
/* clang-format off */
template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };
template <class T> struct _vec<T, 0> { using type = T; };
template <class T, size_t D> using vec = typename _vec<T, D>::type;
template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }
template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }
template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }
/* clang-format on */
const ll MOD = 998244353ll;
int main() {
string S;
while (cin >> S) {
int N = S.size();
vector<ll> dp(N + 10, 0ll);
dp[0] = 1;
int sr = 0, sb = 0;
for (int i = 0; i < 2 * N; i++) {
if (i < N) {
if (S[i] == '0') {
sr += 2;
} else if (S[i] == '1') {
sr += 1;
sb += 1;
} else {
sb += 2;
}
}
vector<ll> ndp(N + 10, 0ll);
for (int r = 0; r <= i; r++) {
int b = i - r;
if (sr - r > 0) {
(ndp[r + 1] += dp[r]) %= MOD;
}
if (sb - b > 0) {
(ndp[r] += dp[r]) %= MOD;
}
}
dp.swap(ndp);
}
cout << dp[sr] << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define fst first
#define snd second
/* clang-format off */
template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };
template <class T> struct _vec<T, 0> { using type = T; };
template <class T, size_t D> using vec = typename _vec<T, D>::type;
template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }
template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }
template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }
/* clang-format on */
const ll MOD = 998244353ll;
int main() {
string S;
while (cin >> S) {
int N = S.size();
vector<ll> dp(2 * N + 10, 0ll);
dp[0] = 1;
int sr = 0, sb = 0;
for (int i = 0; i < 2 * N; i++) {
if (i < N) {
if (S[i] == '0') {
sr += 2;
} else if (S[i] == '1') {
sr += 1;
sb += 1;
} else {
sb += 2;
}
}
vector<ll> ndp(2 * N + 10, 0ll);
for (int r = 0; r <= i; r++) {
int b = i - r;
if (sr - r > 0) {
(ndp[r + 1] += dp[r]) %= MOD;
}
if (sb - b > 0) {
(ndp[r] += dp[r]) %= MOD;
}
}
dp.swap(ndp);
}
cout << dp[sr] << endl;
}
return 0;
}
| [
"assignment.change"
] | 934,430 | 934,431 | u107292917 | cpp |
p03134 | #include <bits/stdc++.h>
#define int long long
using namespace std;
int dp[4001][4001];
int MOD = 998244353;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
for (int i = 0; i <= 2 * n; i++)
for (int j = 0; j <= 2 * n; j++)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j <= 2 * n; j++) {
if (dp[i][j] == 0)
continue;
int blue = min(2 * i, 2 * n) - j, red = j;
if (i < n) {
blue += s[i] - '0';
red += 2 - (s[i] - '0');
}
if (blue > 0) {
dp[i + 1][red] += dp[i][j];
dp[i + 1][red] %= MOD;
}
if (red > 0) {
dp[i + 1][red - 1] += dp[i][j];
dp[i + 1][red - 1] %= MOD;
}
}
}
cout << dp[2 * n][0];
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
int dp[4001][4001];
int MOD = 998244353;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
for (int i = 0; i <= 2 * n; i++)
for (int j = 0; j <= 2 * n; j++)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j <= 2 * n; j++) {
if (dp[i][j] == 0)
continue;
// cout << i << " " << j << " " << dp[i][j] << endl;
int blue = min(2 * i, 2 * n) - i - j, red = j;
if (i < n) {
blue += s[i] - '0';
red += 2 - (s[i] - '0');
}
if (blue > 0) {
dp[i + 1][red] += dp[i][j];
dp[i + 1][red] %= MOD;
}
if (red > 0) {
dp[i + 1][red - 1] += dp[i][j];
dp[i + 1][red - 1] %= MOD;
}
}
}
cout << dp[2 * n][0];
}
| [
"assignment.change"
] | 934,444 | 934,445 | u053547321 | cpp |
p03134 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define llong long long
using namespace std;
const int N = 4000;
const int P = 998244353;
llong dp[N + 3][N + 3];
char str[N + 3];
int sa[N + 3], sb[N + 3];
int n;
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; i++) {
int x = str[i] - '0', y = 2 - x;
sa[i] = sa[i - 1] + x;
sb[i] = sb[i - 1] + y;
}
for (int i = n + 1; i <= n + n; i++)
sa[i] = sa[i - 1], sb[i] = sb[i - 1];
dp[0][0] = 1ll;
for (int i = 1; i <= n + n; i++) {
for (int j = max(0, i - sb[i]); j <= min(i, sa[i]); j++) {
dp[i][j] = 0ll;
dp[i][j] += dp[i - 1][j];
if (j > 0)
dp[i][j] += dp[i - 1][j - 1];
// printf("dp[%d][%d]=%lld\n",i,j,dp[i][j]);
dp[i][j] %= P;
}
}
llong ans = 0ll;
for (int i = 0; i <= n; i++)
ans = (ans + dp[n + n][i]) % P;
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define llong long long
using namespace std;
const int N = 4000;
const int P = 998244353;
llong dp[N + 3][N + 3];
char str[N + 3];
int sa[N + 3], sb[N + 3];
int n;
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; i++) {
int x = str[i] - '0', y = 2 - x;
sa[i] = sa[i - 1] + x;
sb[i] = sb[i - 1] + y;
}
for (int i = n + 1; i <= n + n; i++)
sa[i] = sa[i - 1], sb[i] = sb[i - 1];
dp[0][0] = 1ll;
for (int i = 1; i <= n + n; i++) {
for (int j = max(0, i - sb[i]); j <= min(i, sa[i]); j++) {
dp[i][j] = 0ll;
dp[i][j] += dp[i - 1][j];
if (j > 0)
dp[i][j] += dp[i - 1][j - 1];
// printf("dp[%d][%d]=%lld\n",i,j,dp[i][j]);
dp[i][j] %= P;
}
}
llong ans = 0ll;
for (int i = 0; i <= n + n; i++)
ans = (ans + dp[n + n][i]) % P;
printf("%lld\n", ans);
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 934,454 | 934,455 | u396278429 | cpp |
p03134 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1 << 29)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
Int dp[2160][2160];
Int res;
Int n;
string str;
Int fact[1080000];
Int revfact[1080000];
Int rev[1080000];
void init() {
Int m = MOD;
fact[0] = 1;
revfact[0] = 1;
rev[0] = 0;
rev[1] = 1;
for (int i = 1; i < 1080000; i++) {
fact[i] = fact[i - 1] * i % m;
if (i > 1)
rev[i] = MOD / i * (MOD - rev[MOD % i]) % MOD;
revfact[i] = revfact[i - 1] * rev[i] % MOD;
}
}
class Initter {
public:
Initter() { init(); }
};
Initter initter;
Int nCk(Int n, Int k) {
if (n < k)
return 0;
if (k < 0)
return 0;
return fact[n] * revfact[n - k] % MOD * revfact[k] % MOD;
}
Int cntr, cntb;
int main() {
dp[0][0] = 1;
cin >> str;
n = str.size();
for (int i = 1; i <= n; i++) {
char s = str[i - 1];
s -= '0';
cntr += 2 - s;
cntb += s;
for (int j = 0; j <= n; j++) {
if (cntr - j > 0) {
dp[i][j + 1] += dp[i - 1][j];
dp[i][j + 1] %= MOD;
}
if (cntb - (i - j - 1) > 0) {
dp[i][j] += dp[i - 1][j];
dp[i][j] %= MOD;
}
}
}
for (int j = 0; j <= n; j++) {
// cout << dp[n][j] << endl;
res += dp[n][j] * nCk(n, cntr - j) % MOD;
res %= MOD;
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 998244353
#define INF (1 << 29)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
Int dp[2160][2160];
Int res;
Int n;
string str;
Int fact[1080000];
Int revfact[1080000];
Int rev[1080000];
void init() {
Int m = MOD;
fact[0] = 1;
revfact[0] = 1;
rev[0] = 0;
rev[1] = 1;
for (int i = 1; i < 1080000; i++) {
fact[i] = fact[i - 1] * i % m;
if (i > 1)
rev[i] = MOD / i * (MOD - rev[MOD % i]) % MOD;
revfact[i] = revfact[i - 1] * rev[i] % MOD;
}
}
class Initter {
public:
Initter() { init(); }
};
Initter initter;
Int nCk(Int n, Int k) {
if (n < k)
return 0;
if (k < 0)
return 0;
return fact[n] * revfact[n - k] % MOD * revfact[k] % MOD;
}
Int cntr, cntb;
int main() {
dp[0][0] = 1;
cin >> str;
n = str.size();
for (int i = 1; i <= n; i++) {
char s = str[i - 1];
s -= '0';
cntr += 2 - s;
cntb += s;
for (int j = 0; j <= n; j++) {
if (cntr - j > 0) {
dp[i][j + 1] += dp[i - 1][j];
dp[i][j + 1] %= MOD;
}
if (cntb - (i - j - 1) > 0) {
dp[i][j] += dp[i - 1][j];
dp[i][j] %= MOD;
}
}
}
for (int j = 0; j <= n; j++) {
// cout << dp[n][j] << endl;
res += dp[n][j] * nCk(n, cntr - j) % MOD;
res %= MOD;
}
cout << res << endl;
return 0;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 934,456 | 934,457 | u299869545 | cpp |
p03134 | #include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)
#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const pid_t pid = getpid();
// Problem Specific Parameter:
template <unsigned MOD> class ModInt {
public:
ModInt() : x(0) {}
ModInt(signed y) : x(y >= 0 ? y % MOD : MOD - (-y) % MOD) {}
ModInt(signed long long y) : x(y >= 0 ? y % MOD : MOD - (-y) % MOD) {}
// Arithmetic Oprators
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = 1LL * x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) {
return *this *= ModInt(get<1>(extgcd(that.x, int(MOD))));
}
ModInt &operator%=(ModInt that) {
x %= that.x;
return *this;
}
ModInt &operator+=(const int that) { return *this += ModInt(that); }
ModInt &operator-=(const int that) { return *this -= ModInt(that); }
ModInt &operator*=(const int that) { return *this *= ModInt(that); }
ModInt &operator/=(const int that) { return *this /= ModInt(that); }
ModInt &operator%=(const int that) { return *this %= ModInt(that); }
// Comparators
bool operator<(ModInt that) { return x < that.x; }
bool operator>(ModInt that) { return x > that.x; }
bool operator<=(ModInt that) { return x <= that.x; }
bool operator>=(ModInt that) { return x >= that.x; }
bool operator!=(ModInt that) { return x != that.x; }
bool operator==(ModInt that) { return x == that.x; }
// Utilities
unsigned getval() const { return x; }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt operator%(ModInt that) const { return ModInt(*this) %= that; }
ModInt operator+(const int that) const { return ModInt(*this) += that; }
ModInt operator-(const int that) const { return ModInt(*this) -= that; }
ModInt operator*(const int that) const { return ModInt(*this) *= that; }
ModInt operator/(const int that) const { return ModInt(*this) /= that; }
ModInt operator%(const int that) const { return ModInt(*this) %= that; }
ModInt operator=(const int that) { return *this = ModInt(that); }
friend istream &operator>>(istream &is, ModInt &that) {
ll tmp;
is >> tmp;
that = ModInt(tmp);
return is;
}
friend ostream &operator<<(ostream &os, const ModInt &that) {
return os << that.x;
}
ModInt power(ll n) const {
ll b = 1LL, a = x;
while (n) {
if (n & 1)
b = b * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ModInt(b);
}
private:
unsigned x;
inline auto extgcd(int a, int b) {
if (b == 0)
return make_tuple(a, 1, 0);
tuple<int, int, int> ret = extgcd(b, a % b);
swap(get<1>(ret), get<2>(ret));
get<2>(ret) -= a / b * get<1>(ret);
return ret;
}
};
const int mod = 998244353;
using mint = ModInt<mod>;
const mint ZERO = mint(0);
const mint ONE = mint(1);
mint dp[4010][4010][2];
inline int rest_ball(int i, int n) {
const int total = 2 * min(i, n) - i;
return total;
}
int main(void) {
string s;
cin >> s;
const int n = s.size();
if (s == string(n, '2')) {
puts("1");
return 0;
}
dp[0][0][0] = ONE;
rep(i, 2 * n) rep(j, 2 * n + 1) rep(k, 2) {
if (dp[i][j][k] == ZERO)
continue;
const int all = rest_ball(i, n);
int nr = j, nb = all - j;
if (i < n) {
const int idx = s[i] - '0';
nr += idx;
nb += 2 - idx;
}
// red
if (nr > 0) {
int nk = k;
if (nr - 1 == 0)
nk = 1;
dp[i + 1][nr - 1][nk] += dp[i][j][k];
}
// blue
if (nb > 0) {
int nk = k;
dp[i + 1][nr][nk] += dp[i][j][k];
}
}
mint ans = dp[2 * n][0][1];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)
#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const pid_t pid = getpid();
// Problem Specific Parameter:
template <unsigned MOD> class ModInt {
public:
ModInt() : x(0) {}
ModInt(signed y) : x(y >= 0 ? y % MOD : MOD - (-y) % MOD) {}
ModInt(signed long long y) : x(y >= 0 ? y % MOD : MOD - (-y) % MOD) {}
// Arithmetic Oprators
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = 1LL * x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) {
return *this *= ModInt(get<1>(extgcd(that.x, int(MOD))));
}
ModInt &operator%=(ModInt that) {
x %= that.x;
return *this;
}
ModInt &operator+=(const int that) { return *this += ModInt(that); }
ModInt &operator-=(const int that) { return *this -= ModInt(that); }
ModInt &operator*=(const int that) { return *this *= ModInt(that); }
ModInt &operator/=(const int that) { return *this /= ModInt(that); }
ModInt &operator%=(const int that) { return *this %= ModInt(that); }
// Comparators
bool operator<(ModInt that) { return x < that.x; }
bool operator>(ModInt that) { return x > that.x; }
bool operator<=(ModInt that) { return x <= that.x; }
bool operator>=(ModInt that) { return x >= that.x; }
bool operator!=(ModInt that) { return x != that.x; }
bool operator==(ModInt that) { return x == that.x; }
// Utilities
unsigned getval() const { return x; }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt operator%(ModInt that) const { return ModInt(*this) %= that; }
ModInt operator+(const int that) const { return ModInt(*this) += that; }
ModInt operator-(const int that) const { return ModInt(*this) -= that; }
ModInt operator*(const int that) const { return ModInt(*this) *= that; }
ModInt operator/(const int that) const { return ModInt(*this) /= that; }
ModInt operator%(const int that) const { return ModInt(*this) %= that; }
ModInt operator=(const int that) { return *this = ModInt(that); }
friend istream &operator>>(istream &is, ModInt &that) {
ll tmp;
is >> tmp;
that = ModInt(tmp);
return is;
}
friend ostream &operator<<(ostream &os, const ModInt &that) {
return os << that.x;
}
ModInt power(ll n) const {
ll b = 1LL, a = x;
while (n) {
if (n & 1)
b = b * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ModInt(b);
}
private:
unsigned x;
inline auto extgcd(int a, int b) {
if (b == 0)
return make_tuple(a, 1, 0);
tuple<int, int, int> ret = extgcd(b, a % b);
swap(get<1>(ret), get<2>(ret));
get<2>(ret) -= a / b * get<1>(ret);
return ret;
}
};
const int mod = 998244353;
using mint = ModInt<mod>;
const mint ZERO = mint(0);
const mint ONE = mint(1);
mint dp[4010][4010][2];
inline int rest_ball(int i, int n) {
const int total = 2 * min(i, n) - i;
return total;
}
int main(void) {
string s;
cin >> s;
const int n = s.size();
if (s == string(n, '2')) {
puts("1");
return 0;
}
dp[0][0][0] = ONE;
rep(i, 2 * n) rep(j, 2 * n + 1) rep(k, 2) {
if (dp[i][j][k] == ZERO)
continue;
const int all = rest_ball(i, n);
int nr = j, nb = all - j;
if (i < n) {
const int idx = s[i] - '0';
nr += 2 - idx;
nb += idx;
}
// red
if (nr > 0) {
int nk = k;
if (nr - 1 == 0)
nk = 1;
dp[i + 1][nr - 1][nk] += dp[i][j][k];
}
// blue
if (nb > 0) {
int nk = k;
dp[i + 1][nr][nk] += dp[i][j][k];
}
}
mint ans = dp[2 * n][0][1];
cout << ans << endl;
return 0;
} | [
"assignment.add"
] | 934,469 | 934,470 | u269175074 | cpp |
p03134 | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef long long ll;
const int N = 200010;
const int mod = 998244353;
const int oo = 1e9;
const int base = 27;
typedef pair<int, int> pii;
int dp[4010][4010], f1[4001], f2[4001];
string s;
ll adl(ll a, ll b) { return (1ll * a + b) % mod; }
int calc(int r, int b) {
if (r + b == 2 * s.size())
return 1;
int &ret = dp[r][b];
if (ret != -1)
return ret;
ret = 0;
int idx = r + b;
if (idx == s.size()) {
if (b != f1[s.size() - 1])
ret = adl(ret, calc(r, b + 1));
if (r != f2[s.size() - 1])
ret = adl(ret, calc(r + 1, b));
} else {
if (b != f1[idx])
ret = adl(ret, calc(r, b + 1));
if (r != f2[idx])
ret = adl(ret, calc(r + 1, b));
}
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1')
f1[i]++, f2[i]++;
if (s[i] == '2')
f2[i] += 2;
if (s[i] == '0')
f1[i] += 2;
if (i)
f1[i] += f1[i - 1];
if (i)
f2[i] += f2[i - 1];
}
printf("%d\n", calc(0, 0));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef long long ll;
const int N = 200010;
const int mod = 998244353;
const int oo = 1e9;
const int base = 27;
typedef pair<int, int> pii;
int dp[4010][4010], f1[4001], f2[4001];
string s;
ll adl(ll a, ll b) { return (1ll * a + b) % mod; }
int calc(int r, int b) {
if (r + b == 2 * s.size())
return 1;
int &ret = dp[r][b];
if (ret != -1)
return ret;
ret = 0;
int idx = r + b;
if (idx >= s.size()) {
if (b != f1[s.size() - 1])
ret = adl(ret, calc(r, b + 1));
if (r != f2[s.size() - 1])
ret = adl(ret, calc(r + 1, b));
} else {
if (b != f1[idx])
ret = adl(ret, calc(r, b + 1));
if (r != f2[idx])
ret = adl(ret, calc(r + 1, b));
}
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1')
f1[i]++, f2[i]++;
if (s[i] == '2')
f2[i] += 2;
if (s[i] == '0')
f1[i] += 2;
if (i)
f1[i] += f1[i - 1];
if (i)
f2[i] += f2[i - 1];
}
printf("%d\n", calc(0, 0));
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 934,479 | 934,480 | u417705043 | cpp |
p03134 | #include <bits/stdc++.h>
using namespace std;
;
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define INF 1 << 30
#define LINF 1LL << 62
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
const ll MOD = 998244353;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
ll dp[4005][4005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
ll n = s.size();
ll r[n], b[n];
REP(i, n) {
r[i] = 0;
b[i] = 0;
}
REP(i, n) {
if (s[i] == '0') {
r[i] += 2;
} else if (s[i] == '1') {
r[i]++;
b[i]++;
} else {
b[i] += 2;
}
if (i != 0) {
r[i] += r[i - 1];
b[i] += b[i - 1];
}
}
dp[0][0] = 1;
REP(i, 2 * n) {
REP(j, i + 1) {
if (i < n) {
if (r[i] >= j + 1) {
dp[i + 1][j + 1] += dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
if (b[i] >= i + 1 - j) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j] %= MOD;
}
} else {
if (r[n - 1] >= j + 1) {
dp[i + 1][j + 1] += dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
if (b[n - 1] >= i + 1 - j) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j] %= MOD;
}
}
}
}
ll ans = 0;
REP(i, 2 * n) {
ans += dp[2 * n][i];
ans %= MOD;
}
if (n == 1) {
if (s[0] == '1') {
ans = 2;
} else {
ans = 1;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
;
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define INF 1 << 30
#define LINF 1LL << 62
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
const ll MOD = 998244353;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
ll dp[4005][4005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
ll n = s.size();
ll r[n], b[n];
REP(i, n) {
r[i] = 0;
b[i] = 0;
}
REP(i, n) {
if (s[i] == '0') {
r[i] += 2;
} else if (s[i] == '1') {
r[i]++;
b[i]++;
} else {
b[i] += 2;
}
if (i != 0) {
r[i] += r[i - 1];
b[i] += b[i - 1];
}
}
dp[0][0] = 1;
REP(i, 2 * n) {
REP(j, i + 1) {
if (i < n) {
if (r[i] >= j + 1) {
dp[i + 1][j + 1] += dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
if (b[i] >= i + 1 - j) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j] %= MOD;
}
} else {
if (r[n - 1] >= j + 1) {
dp[i + 1][j + 1] += dp[i][j];
dp[i + 1][j + 1] %= MOD;
}
if (b[n - 1] >= i + 1 - j) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j] %= MOD;
}
}
}
}
ll ans = 0;
REP(i, 2 * n + 1) {
ans += dp[2 * n][i];
ans %= MOD;
}
if (n == 1) {
if (s[0] == '1') {
ans = 2;
} else {
ans = 1;
}
}
cout << ans << endl;
} | [
"expression.operation.binary.add"
] | 934,485 | 934,486 | u013628553 | cpp |
p03134 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define __builtin_popcount __builtin_popcountll
#define endl '\n'
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 998244353;
int T, n, m;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
string s;
while (cin >> s) {
n = s.size();
vi mxr(n * 2 + 1), mxb(n * 2 + 1);
REP(i, n) {
if (s[i] == '0')
mxr[i] = 2;
if (s[i] == '1')
mxr[i] = 1;
if (s[i] == '1')
mxb[i] = 1;
if (s[i] == '2')
mxb[i] = 2;
}
REP(i, 2 * n) {
mxr[i + 1] += mxr[i];
mxb[i + 1] += mxb[i];
}
vector<ll> dp(n * 2);
dp[0] = 1;
REP(i, n * 2) {
vector<ll> nxt(n * 2);
REP(r, i + 1) {
int b = i - r;
if (r <= mxr[i] && b + 1 <= mxb[i]) {
(nxt[r] += dp[r]) %= MOD;
}
if (r + 1 <= mxr[i] && b <= mxb[i]) {
(nxt[r + 1] += dp[r]) %= MOD;
}
}
swap(dp, nxt);
}
cout << accumulate(ALL(dp), 0ll) % MOD << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define __builtin_popcount __builtin_popcountll
#define endl '\n'
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 998244353;
int T, n, m;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
string s;
while (cin >> s) {
n = s.size();
vi mxr(n * 2 + 1), mxb(n * 2 + 1);
REP(i, n) {
if (s[i] == '0')
mxr[i] = 2;
if (s[i] == '1')
mxr[i] = 1;
if (s[i] == '1')
mxb[i] = 1;
if (s[i] == '2')
mxb[i] = 2;
}
REP(i, 2 * n) {
mxr[i + 1] += mxr[i];
mxb[i + 1] += mxb[i];
}
vector<ll> dp(n * 2 + 1);
dp[0] = 1;
REP(i, n * 2) {
vector<ll> nxt(n * 2 + 1);
REP(r, i + 1) {
int b = i - r;
if (r <= mxr[i] && b + 1 <= mxb[i]) {
(nxt[r] += dp[r]) %= MOD;
}
if (r + 1 <= mxr[i] && b <= mxb[i]) {
(nxt[r + 1] += dp[r]) %= MOD;
}
}
swap(dp, nxt);
}
cout << accumulate(ALL(dp), 0ll) % MOD << endl;
}
return 0;
}
| [
"assignment.change"
] | 934,506 | 934,507 | u557275893 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
double a, b;
cin >> a, b;
cout << fixed << setprecision(5);
cout << a / b << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
double a, b;
cin >> a >> b;
cout << fixed << setprecision(5);
cout << a / b << endl;
return 0;
}
| [] | 934,526 | 934,527 | u883297128 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
double ans = double(t) / x;
cout << fixed << setprecision << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
double ans = double(t) / x;
cout << setprecision(10) << ans << endl;
return 0;
} | [
"expression.operation.binary.remove",
"call.arguments.add"
] | 934,528 | 934,529 | u129177780 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
double ans = double(t) / x;
cout << setprecision << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
double ans = double(t) / x;
cout << setprecision(10) << ans << endl;
return 0;
} | [
"call.arguments.add"
] | 934,530 | 934,529 | u129177780 | cpp |
p03135 | #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <limits>
#include <numeric>
#include <sstream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T, X;
cin >> T >> X;
cout.setf(ios::fixed);
cout.precision(10);
cout << T / X;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <limits>
#include <numeric>
#include <sstream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
float T, X;
cin >> T >> X;
cout.setf(ios::fixed);
cout.precision(10);
cout << T / X;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 934,541 | 934,542 | u557207741 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
long double T, X;
cin >> T >> X;
cout << fixed << setprecision(15) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long double T, X;
cin >> T >> X;
cout << fixed << setprecision(15) << T / X << endl;
}
| [
"io.output.change"
] | 934,543 | 934,544 | u187772564 | cpp |
p03135 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll INFll = 1ll << 60;
int main() {
int t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll INFll = 1ll << 60;
int main() {
double t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 934,549 | 934,550 | u735008991 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
double A;
int T, X;
cin >> T >> X;
A = T / X;
cout << A << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
double A, T, X;
cin >> T >> X;
A = T / X;
cout << A << endl;
}
| [] | 934,553 | 934,554 | u936105062 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
double ans = A / B / 1.0;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
double ans = A * 1.0 / B;
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 934,555 | 934,556 | u347057617 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
double ans = A / B;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
double ans = A * 1.0 / B;
cout << ans << endl;
} | [
"assignment.change"
] | 934,557 | 934,556 | u347057617 | cpp |
p03135 | #include <stdio.h>
int t, x;
int main() {
scanf("%d %d", &t, &x);
printf("%0.2lf", (double)t / x);
} | #include <stdio.h>
int t, x;
int main() {
scanf("%d %d", &t, &x);
printf("%0.4lf", (double)t / x);
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,560 | 934,561 | u691912637 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
int time = t / x;
cout << time << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
double t, x;
cin >> t >> x;
double time = t / x;
cout << time << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 934,569 | 934,570 | u356754940 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int x, t;
cin >> x >> t;
double res = x / t;
cout << fixed << setprecision(10) << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double x, t;
cin >> x >> t;
double res = x / t;
cout << fixed << setprecision(10) << res << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 934,573 | 934,574 | u430341757 | cpp |
p03135 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << (double)(t / x);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << (t / (double)x);
return 0;
} | [
"type_conversion.add"
] | 934,575 | 934,576 | u021358975 | cpp |
p03135 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << (double)(t / x);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << ((double)t / (double)x);
return 0;
} | [
"type_conversion.add"
] | 934,575 | 934,577 | u021358975 | cpp |
p03135 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)n; i++)
#define all(x) (x).begin(), (x).end()
typedef long long int ll;
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << setprecision(10) << x / t << endl;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)n; i++)
#define all(x) (x).begin(), (x).end()
typedef long long int ll;
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << setprecision(10) << t / x << endl;
}
| [
"expression.operation.binary.remove"
] | 934,578 | 934,579 | u138062788 | cpp |
p03135 | #include <bits/stdc++.h>
#define rep(var, cnt) for (int(var) = 0; (var) < (int)(cnt); ++(var))
#define Rep(var, init, cnt) for (int(var) = (init); (var) < (int)(cnt); ++(var))
#define ran(var, vec) for (auto &(var) : (vec))
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define SORT(v) sort(all(v))
#define RSORT(v) sort(rall(v))
#define SUM(v) accumulate(all(v), 0)
#define tget(tp, idx) get<idx>(tp)
#define TF(flag) ((flag) ? 1 : 0)
#define YN(flag) cout << (flag ? "YES" : "NO") << endl;
#define Yn(flag) cout << (flag ? "Yes" : "No") << endl;
#define yn(flag) cout << (flag ? "yes" : "no") << endl;
#define Cout(v) cout << (v) << endl
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using ti = tuple<int, int, int>;
using tl = tuple<ll, ll, ll>;
template <typename T> using vec = vector<T>;
template <typename T> using mat = vector<vec<T>>;
template <typename T> using cub = vector<mat<T>>;
template <typename T> using val = valarray<T>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using rpq = priority_queue<T, vec<T>, greater<T>>;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "P(" << p.first << ", " << p.second << ") ";
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
cout << "V{";
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << (i + 1 != v.size() ? " " : "");
}
cout << "}";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const valarray<T> &v) {
cout << "V{";
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << (i + 1 != v.size() ? " " : "");
}
cout << "}";
return os;
}
template <typename T> istream &operator>>(istream &is, valarray<T> &v) {
for (T &in : v)
is >> in;
return is;
}
// Usual Template End ===================
// Template End =========================
int main(void) {
int a, b, c;
cin >> a >> b;
cout << fixed << setprecision(10) << a / b;
}
| #include <bits/stdc++.h>
#define rep(var, cnt) for (int(var) = 0; (var) < (int)(cnt); ++(var))
#define Rep(var, init, cnt) for (int(var) = (init); (var) < (int)(cnt); ++(var))
#define ran(var, vec) for (auto &(var) : (vec))
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define SORT(v) sort(all(v))
#define RSORT(v) sort(rall(v))
#define SUM(v) accumulate(all(v), 0)
#define tget(tp, idx) get<idx>(tp)
#define TF(flag) ((flag) ? 1 : 0)
#define YN(flag) cout << (flag ? "YES" : "NO") << endl;
#define Yn(flag) cout << (flag ? "Yes" : "No") << endl;
#define yn(flag) cout << (flag ? "yes" : "no") << endl;
#define Cout(v) cout << (v) << endl
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using ti = tuple<int, int, int>;
using tl = tuple<ll, ll, ll>;
template <typename T> using vec = vector<T>;
template <typename T> using mat = vector<vec<T>>;
template <typename T> using cub = vector<mat<T>>;
template <typename T> using val = valarray<T>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using rpq = priority_queue<T, vec<T>, greater<T>>;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "P(" << p.first << ", " << p.second << ") ";
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
cout << "V{";
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << (i + 1 != v.size() ? " " : "");
}
cout << "}";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const valarray<T> &v) {
cout << "V{";
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << (i + 1 != v.size() ? " " : "");
}
cout << "}";
return os;
}
template <typename T> istream &operator>>(istream &is, valarray<T> &v) {
for (T &in : v)
is >> in;
return is;
}
// Usual Template End ===================
// Template End =========================
int main(void) {
int a, b, c;
cin >> a >> b;
cout << fixed << setprecision(10) << (double)a / b;
}
| [
"type_conversion.add"
] | 934,580 | 934,581 | u143572112 | cpp |
p03135 | #include <stdio.h>
int main() {
int t, x;
scanf("%d %d", &t, &x);
printf("%d", t / x);
return 0;
}
| #include <stdio.h>
int main() {
int t, x;
scanf("%d %d", &t, &x);
printf("%f", (double)(t) / x);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 934,584 | 934,585 | u309151030 | cpp |
p03135 | #include <iostream>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << x * t << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"expression.operation.binary.remove"
] | 934,586 | 934,587 | u741144749 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << fixed << setprecision(10) << (t / x);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << fixed << setprecision(10) << (double)(t) / x;
return 0;
} | [
"type_conversion.add"
] | 934,588 | 934,589 | u130797451 | cpp |
p03135 | #include <bits/stdc++.h>
#include <iostream>
#include <string>
using namespace std;
int main() {
int x, t;
cin >> t >> x;
cout << double(t / x) << endl;
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
#include <string>
using namespace std;
int main() {
double x, t;
cin >> t >> x;
cout << t / x << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"call.remove",
"call.arguments.change"
] | 934,590 | 934,591 | u904995051 | cpp |
p03135 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
typedef long long ll;
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
//素因数分解
vector<pair<ll, int>> factorize(ll n) {
vector<pair<ll, int>> res;
for (ll i = 2; i * i <= n; i++) {
if (n % i)
continue;
res.emplace_back(i, 0);
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1)
res.emplace_back(n, 1);
return res;
}
int main() {
int T, X;
float asn;
cin >> T >> X;
asn = T / X;
cout << asn << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
typedef long long ll;
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
//素因数分解
vector<pair<ll, int>> factorize(ll n) {
vector<pair<ll, int>> res;
for (ll i = 2; i * i <= n; i++) {
if (n % i)
continue;
res.emplace_back(i, 0);
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1)
res.emplace_back(n, 1);
return res;
}
int main() {
float T, X;
float asn;
cin >> T >> X;
asn = T / X;
cout << asn << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 934,594 | 934,595 | u355371431 | cpp |
p03135 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int t, x;
cin >> t >> x;
double ans = t / x;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int t, x;
cin >> t >> x;
double ans = (double)t / x;
cout << ans << endl;
return 0;
} | [
"type_conversion.add"
] | 934,596 | 934,597 | u915797797 | cpp |
p03135 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b;
float f;
f = (float)(a / b);
cout << f;
} | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b;
float f;
f = ((float)a / b);
cout << f;
} | [] | 934,598 | 934,599 | u259356079 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
long double a, b, k;
cin >> a >> b;
k = b / a;
cout << fixed << setprecision(7) << k;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long double a, b, k;
cin >> a >> b;
k = a / b;
cout << fixed << setprecision(8) << k;
}
| [
"expression.operation.binary.remove",
"assignment.change",
"literal.number.change",
"io.output.change"
] | 934,600 | 934,601 | u376946371 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int T, X;
cin >> T >> X;
cout << T / X << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
double T, X;
cin >> T >> X;
cout << T / X << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 934,610 | 934,611 | u281840563 | cpp |
p03135 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
double t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 934,612 | 934,613 | u479097347 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double t, x;
cin >> t >> x;
cout << t / x << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 934,614 | 934,615 | u857640866 | cpp |
p03135 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << a / b << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
double a, b;
cin >> a >> b;
cout << a / b << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 934,616 | 934,617 | u530329977 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.