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 |
|---|---|---|---|---|---|---|---|
p03179 | // Vivek Rai
// Blazer_007
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/detail/standard_policies.hpp>
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define inf 0x3f3f3f3f
//#define INF 0x3f3f3f3f3f3f3f3fLL
#define ll long long
#define pb push_back
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pii>
#define mi map<ll, ll>
#define mii map<pii, ll>
#define ppi pair<ll, pii>
#define all(a) (a).begin(), (a).end()
#define FF first
#define SS second
#define sz(x) (int)x.size()
#define endl '\n'
#define hell 1000000007
#define see(x) cout << x << endl;
#define see2(x, y) cout << x << " " << y << endl;
#define see3(x, y, z) cout << x << " " << y << " " << z << endl;
#define bit(x, y) (((x) >> (y)) & 1)
#define bpt(x) (__builtin_popcount(x))
#define bptl(x) (__builtin_popcountll(x))
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rloop(i, a, b) for (int i = a; i >= b; i--)
#define N 2000010
using namespace std;
// using namespace __gnu_pbds;
// typedef priority_queue<int> maxHeap;
// typedef priority_queue<int,vector<int>,greater<int>()) minHeap;
// typedef
// tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
// ordered_set;
// find_by_order(index) -> value at given index or Kth smallest element in set
// order_of_key(X) -> number of elements strictly less than X
// typedef tree<pii , null_type, less<pii>, rb_tree_tag,
// tree_order_statistics_node_update> OST;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : " << arg1 << endl;
// use cerr if u want to display at the bottom
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
ll dp[3001][3001];
void solve(string &s, int n) {
dp[n][0] = (s[n - 2] == '>') ? 1 : 0;
dp[n][1] = (s[n - 2] == '<') ? 1 : 0;
rloop(i, n - 1, 2) {
int total = n - i + 1;
loop(g, 0, total + 1) {
if (g == 0) {
if (i == n)
continue;
dp[i][g] = 0;
if (s[i - 2] == '<')
continue;
loop(j, 1, total + 1) {
dp[i][g] = (dp[i][g] + dp[i + 1][total - j]) % hell;
}
} else {
if (s[i - 2] == '>') {
dp[i][g] = (dp[i][g - 1] - dp[i + 1][g - 1]) % hell;
} else {
dp[i][g] = (dp[i][g - 1] + dp[i + 1][g - 1]) % hell;
}
}
}
}
}
void solution() {
int n;
string s;
cin >> n;
cin >> s;
ll ans = 0;
solve(s, n);
rloop(gr, n - 1, 0) ans = (ans + dp[2][gr]) % hell;
cout << ans << endl;
}
signed main() {
fastio
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r" , stdin);
// freopen("output.txt", "w", stdout);
// #endif
ll t = 1;
// cin>>t;
loop(i, 1, t + 1) {
// cout<<"Case #"<<i<<": ";
solution();
}
}
| // Vivek Rai
// Blazer_007
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/detail/standard_policies.hpp>
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define inf 0x3f3f3f3f
//#define INF 0x3f3f3f3f3f3f3f3fLL
#define ll long long
#define pb push_back
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pii>
#define mi map<ll, ll>
#define mii map<pii, ll>
#define ppi pair<ll, pii>
#define all(a) (a).begin(), (a).end()
#define FF first
#define SS second
#define sz(x) (int)x.size()
#define endl '\n'
#define hell 1000000007
#define see(x) cout << x << endl;
#define see2(x, y) cout << x << " " << y << endl;
#define see3(x, y, z) cout << x << " " << y << " " << z << endl;
#define bit(x, y) (((x) >> (y)) & 1)
#define bpt(x) (__builtin_popcount(x))
#define bptl(x) (__builtin_popcountll(x))
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rloop(i, a, b) for (int i = a; i >= b; i--)
#define N 2000010
using namespace std;
// using namespace __gnu_pbds;
// typedef priority_queue<int> maxHeap;
// typedef priority_queue<int,vector<int>,greater<int>()) minHeap;
// typedef
// tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
// ordered_set;
// find_by_order(index) -> value at given index or Kth smallest element in set
// order_of_key(X) -> number of elements strictly less than X
// typedef tree<pii , null_type, less<pii>, rb_tree_tag,
// tree_order_statistics_node_update> OST;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : " << arg1 << endl;
// use cerr if u want to display at the bottom
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
ll dp[3001][3001];
void solve(string &s, int n) {
dp[n][0] = (s[n - 2] == '>') ? 1 : 0;
dp[n][1] = (s[n - 2] == '<') ? 1 : 0;
rloop(i, n - 1, 2) {
int total = n - i + 1;
loop(g, 0, total + 1) {
if (g == 0) {
if (i == n)
continue;
dp[i][g] = 0;
if (s[i - 2] == '<')
continue;
loop(j, 1, total + 1) {
dp[i][g] = (dp[i][g] + dp[i + 1][total - j]) % hell;
}
} else {
if (s[i - 2] == '>') {
dp[i][g] = (dp[i][g - 1] - dp[i + 1][g - 1] + hell) % hell;
} else {
dp[i][g] = (dp[i][g - 1] + dp[i + 1][g - 1]) % hell;
}
}
}
}
}
void solution() {
int n;
string s;
cin >> n;
cin >> s;
ll ans = 0;
solve(s, n);
rloop(gr, n - 1, 0) ans = (ans + dp[2][gr]) % hell;
cout << ans << endl;
}
signed main() {
fastio
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r" , stdin);
// freopen("output.txt", "w", stdout);
// #endif
ll t = 1;
// cin>>t;
loop(i, 1, t + 1) {
// cout<<"Case #"<<i<<": ";
solution();
}
}
| [
"assignment.change"
] | 986,081 | 986,082 | u956259660 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define N 3001
const int mod = 1e9 + 7;
int n;
string s;
int dp[N][N];
void solve() {
dp[n][0] = (s[n - 2] == '>') ? 1 : 0;
dp[n][1] = (s[n - 2] == '<') ? 1 : 0;
for (int i = n - 1; i >= 2; i--) {
int total = n - i + 1;
for (int g = 0; g <= total; g++) {
if (g == 0) {
dp[i][g] = 0;
if (s[i - 2] == '<')
continue;
for (int j = 1; j <= total; j++)
dp[i][g] = (dp[i][g] + dp[i + 1][total - j]) % mod;
} else {
if (s[i - 2] == '<')
dp[i][g] = (dp[i][g - 1] + dp[i + 1][g - 1]) % mod;
else
dp[i][g] = (dp[i][g - 1] - dp[i + 1][g - 1]) % mod;
}
}
}
}
int32_t main() {
cin >> n;
cin >> s;
solve();
int ans = 0;
for (int i = n - 1; i >= 0; i--)
ans = (ans + dp[2][i]) % mod;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define N 3001
const int mod = 1e9 + 7;
int n;
string s;
int dp[N][N];
void solve() {
dp[n][0] = (s[n - 2] == '>') ? 1 : 0;
dp[n][1] = (s[n - 2] == '<') ? 1 : 0;
for (int i = n - 1; i >= 2; i--) {
int total = n - i + 1;
for (int g = 0; g <= total; g++) {
if (g == 0) {
dp[i][g] = 0;
if (s[i - 2] == '<')
continue;
for (int j = 1; j <= total; j++)
dp[i][g] = (dp[i][g] + dp[i + 1][total - j]) % mod;
} else {
if (s[i - 2] == '<')
dp[i][g] = (dp[i][g - 1] + dp[i + 1][g - 1]) % mod;
else
dp[i][g] = (mod + dp[i][g - 1] - dp[i + 1][g - 1]) % mod;
}
}
}
}
int32_t main() {
cin >> n;
cin >> s;
solve();
int ans = 0;
for (int i = n - 1; i >= 0; i--)
ans = (ans + dp[2][i]) % mod;
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 986,083 | 986,084 | u772652557 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
using vi = vector<ll>;
using vvi = vector<vi>;
template <class T> using max_heap = priority_queue<T>;
template <class T> using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
#define rep(i, j) for (int i = 0; i < j; i++)
#define all(obj) (obj).begin(), (obj).end()
#define rall(obj) (obj).rbegin(), (obj).rend()
#define debug(x) cerr << #x << ": " << x << endl;
#define int ll
const ll mod = 1e9 + 7;
const ll inf = (1LL << 50);
int dp[3030][3030];
void solve(long long N, std::string s) {
memset(dp, 0, 3030 * 3030 * sizeof(dp[0][0]));
rep(i, N) dp[0][i] = 1;
rep(i, s.size()) {
vi cum(N + 1);
rep(j, N) {
cum[j + 1] = dp[i][j] + cum[j];
cum[j + 1] %= mod;
}
if (s[i] == '<') {
rep(j, N - i) {
// for (int k = j + 1; k < N - i; k++) {
// dp[i + 1][j] = (dp[i + 1][j] + dp[i][k]) % mod;
// }
dp[i + 1][j] = (dp[i + 1][j] + cum[N - i] - cum[j + 1]) % mod;
}
} else {
rep(j, N - i) {
// for (int k = 0; k < j + 1; k++) {
// dp[i + 1][j] = (dp[i + 1][j] + dp[i][k]) % mod;
// }
dp[i + 1][j] = (dp[i + 1][j] + cum[j + 1] - cum[0]) % mod;
}
}
}
// rep(i, N) rep(j, N) {
// cout << i << " " << j << " " << dp[i][j] << endl;
// }
cout << dp[s.size()][0] << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
long long N;
cin >> N;
std::string s;
std::cin >> s;
solve(N, s);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
using vi = vector<ll>;
using vvi = vector<vi>;
template <class T> using max_heap = priority_queue<T>;
template <class T> using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
#define rep(i, j) for (int i = 0; i < j; i++)
#define all(obj) (obj).begin(), (obj).end()
#define rall(obj) (obj).rbegin(), (obj).rend()
#define debug(x) cerr << #x << ": " << x << endl;
#define int ll
const ll mod = 1e9 + 7;
const ll inf = (1LL << 50);
int dp[3030][3030];
void solve(long long N, std::string s) {
memset(dp, 0, 3030 * 3030 * sizeof(dp[0][0]));
rep(i, N) dp[0][i] = 1;
rep(i, s.size()) {
vi cum(N + 1);
rep(j, N) {
cum[j + 1] = dp[i][j] + cum[j];
cum[j + 1] %= mod;
}
if (s[i] == '<') {
rep(j, N - i) {
// for (int k = j + 1; k < N - i; k++) {
// dp[i + 1][j] = (dp[i + 1][j] + dp[i][k]) % mod;
// }
dp[i + 1][j] = (dp[i + 1][j] + cum[N - i] - cum[j + 1] + mod) % mod;
}
} else {
rep(j, N - i) {
// for (int k = 0; k < j + 1; k++) {
// dp[i + 1][j] = (dp[i + 1][j] + dp[i][k]) % mod;
// }
dp[i + 1][j] = (dp[i + 1][j] + cum[j + 1] - cum[0] + mod) % mod;
}
}
}
cout << dp[s.size()][0] << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
long long N;
cin >> N;
std::string s;
std::cin >> s;
solve(N, s);
return 0;
}
| [
"assignment.change"
] | 986,087 | 986,088 | u463697306 | cpp |
p03179 | /*
author: kartik8800
*/
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define fr(a, b) for (ll i = a; i < b; i++)
#define mod 1000000007
#define inf (1LL << 60)
#define all(x) (x).begin(), (x).end()
#define prDouble(x) cout << fixed << setprecision(10) << x
#define triplet pair<ll, pair<ll, ll>>
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
using namespace std;
ll dp[3001][3001];
void solve(string &s, int n) {
dp[n][0] = (s[n - 2] == '>') ? 1 : 0;
dp[n][1] = (s[n - 2] == '<') ? 1 : 0;
for (int i = n - 1; i >= 2; i--) {
int total = n - i + 1;
for (int g = 0; g <= total; g++) {
if (g == 0) {
if (i == n)
continue;
dp[i][g] = 0;
if (s[i - 2] == '<')
continue;
for (int j = 1; j <= total; j++) {
dp[i][g] = (dp[i][g] + dp[i + 1][total - j]) % mod;
}
} else {
if (s[i - 2] == '>')
dp[i][g] = (dp[i][g - 1] - dp[i + 1][g - 1]) % mod;
else
dp[i][g] = (dp[i][g - 1] + dp[i + 1][g - 1]) % mod;
}
}
}
}
int main() {
int n;
string s;
cin >> n;
cin >> s;
ll ans = 0;
solve(s, n);
for (int gr = n - 1; gr >= 0; gr--)
ans = (ans + dp[2][gr]) % mod;
cout << ans;
return 0;
}
| /*
author: kartik8800
*/
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define fr(a, b) for (ll i = a; i < b; i++)
#define mod 1000000007
#define inf (1LL << 60)
#define all(x) (x).begin(), (x).end()
#define prDouble(x) cout << fixed << setprecision(10) << x
#define triplet pair<ll, pair<ll, ll>>
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
using namespace std;
ll dp[3001][3001];
void solve(string &s, int n) {
dp[n][0] = (s[n - 2] == '>') ? 1 : 0;
dp[n][1] = (s[n - 2] == '<') ? 1 : 0;
for (int i = n - 1; i >= 2; i--) {
int total = n - i + 1;
for (int g = 0; g <= total; g++) {
if (g == 0) {
if (i == n)
continue;
dp[i][g] = 0;
if (s[i - 2] == '<')
continue;
for (int j = 1; j <= total; j++) {
dp[i][g] = (dp[i][g] + dp[i + 1][total - j]) % mod;
}
} else {
if (s[i - 2] == '>')
dp[i][g] = (mod + dp[i][g - 1] - dp[i + 1][g - 1]) % mod;
else
dp[i][g] = (dp[i][g - 1] + dp[i + 1][g - 1]) % mod;
}
}
}
}
int main() {
int n;
string s;
cin >> n;
cin >> s;
ll ans = 0;
solve(s, n);
for (int gr = n - 1; gr >= 0; gr--)
ans = (ans + dp[2][gr]) % mod;
cout << ans;
return 0;
}
| [
"assignment.change"
] | 986,089 | 986,090 | u212789054 | cpp |
p03179 | #include <iostream>
#include <vector>
using namespace std;
// Finite field Z/pZ
class ModInt {
private:
long long val;
static const int default_mod = 1e9 + 7;
static int mod;
public:
ModInt(long long val) {
this->val = val % getMod();
if (this->val < 0) {
this->val += getMod();
}
}
ModInt() : ModInt(0) {}
static void setMod(int mod) {
if (ModInt::mod != 0) {
throw "The modulo is already set.";
}
ModInt::mod = mod;
}
inline static int getMod() {
if (mod == 0) {
mod = default_mod;
}
return mod;
}
inline long long getVal() const { return val; }
ModInt &operator+=(const ModInt &);
ModInt &operator-=(const ModInt &);
ModInt &operator*=(const ModInt &);
ModInt &operator/=(const ModInt &);
ModInt pow(long long exponent) const {
exponent %= getMod() - 1;
long long pow_val = this->val;
long long ret_val = 1;
while (exponent > 0) {
if (exponent % 2 == 1) {
ret_val = (ret_val * pow_val) % getMod();
}
pow_val = (pow_val * pow_val) % getMod();
exponent /= 2;
}
return ModInt(ret_val);
}
ModInt inv() const { return this->pow(getMod() - 2); }
friend ostream &operator<<(ostream &os, const ModInt &modint) {
os << modint.val;
return os;
}
friend istream &operator>>(istream &is, ModInt &modint) {
long long val;
is >> val;
modint.val = val % modint.getMod();
return is;
}
};
int ModInt::mod = 0;
const ModInt operator+(const ModInt &lhs, const ModInt &rhs) {
return ModInt(lhs.getVal() + rhs.getVal());
}
const ModInt operator-(const ModInt &lhs, const ModInt &rhs) {
return ModInt(lhs.getVal() + rhs.getVal());
}
const ModInt operator*(const ModInt &lhs, const ModInt &rhs) {
return ModInt(lhs.getVal() * rhs.getVal());
}
const ModInt operator/(const ModInt &lhs, const ModInt &rhs) {
return lhs.getVal() * rhs.inv();
}
ModInt &ModInt::operator+=(const ModInt &rhs) {
(*this) = (*this) + rhs;
return *this;
}
ModInt &ModInt::operator-=(const ModInt &rhs) {
(*this) = (*this) - rhs;
return *this;
}
ModInt &ModInt::operator*=(const ModInt &rhs) {
(*this) = (*this) * rhs;
return *this;
}
ModInt &ModInt::operator/=(const ModInt &rhs) {
(*this) = (*this) / rhs;
return *this;
}
class ModIntComb {
private:
vector<ModInt> facts;
vector<ModInt> fact_invs;
int n_max;
public:
ModIntComb(int n_max) : n_max(n_max) {
facts.push_back(1);
for (int i = 1; i <= n_max; i++) {
facts.push_back(facts[i - 1] * i);
}
fact_invs = vector<ModInt>(n_max + 1);
fact_invs[n_max] = facts[n_max].inv();
for (int i = n_max - 1; i >= 0; i--) {
fact_invs[i] = fact_invs[i + 1] * (i + 1);
}
}
int getNMax() { return n_max; }
ModInt fact(int n) { return facts[n]; }
ModInt fact_inv(int n) { return fact_invs[n]; }
ModInt comb(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
return facts[n] * fact_invs[k] * fact_invs[n - k];
}
};
int main() {
int N;
cin >> N;
string s;
cin >> s;
vector<vector<ModInt>> dp(N, vector<ModInt>(N));
for (int j = 0; j < N; j++) {
dp[0][j] = 1;
}
for (int i = 1; i < N; i++) {
vector<ModInt> dp_sum(N - (i - 1) + 1);
for (int j = 1; j <= N - (i - 1); j++) {
dp_sum[j] = dp_sum[j - 1] + dp[i - 1][j - 1];
}
for (int j = 0; j < N - i; j++) {
if (s[i - 1] == '<') {
dp[i][j] = dp_sum[j + 1];
} else {
dp[i][j] = dp_sum[N - (i - 1)] - dp_sum[j + 1];
}
}
}
cout << dp[N - 1][0] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
// Finite field Z/pZ
class ModInt {
private:
long long val;
static const int default_mod = 1e9 + 7;
static int mod;
public:
ModInt(long long val) {
this->val = val % getMod();
if (this->val < 0) {
this->val += getMod();
}
}
ModInt() : ModInt(0) {}
static void setMod(int mod) {
if (ModInt::mod != 0) {
throw "The modulo is already set.";
}
ModInt::mod = mod;
}
inline static int getMod() {
if (mod == 0) {
mod = default_mod;
}
return mod;
}
inline long long getVal() const { return val; }
ModInt &operator+=(const ModInt &);
ModInt &operator-=(const ModInt &);
ModInt &operator*=(const ModInt &);
ModInt &operator/=(const ModInt &);
ModInt pow(long long exponent) const {
exponent %= getMod() - 1;
long long pow_val = this->val;
long long ret_val = 1;
while (exponent > 0) {
if (exponent % 2 == 1) {
ret_val = (ret_val * pow_val) % getMod();
}
pow_val = (pow_val * pow_val) % getMod();
exponent /= 2;
}
return ModInt(ret_val);
}
ModInt inv() const { return this->pow(getMod() - 2); }
friend ostream &operator<<(ostream &os, const ModInt &modint) {
os << modint.val;
return os;
}
friend istream &operator>>(istream &is, ModInt &modint) {
long long val;
is >> val;
modint.val = val % modint.getMod();
return is;
}
};
int ModInt::mod = 0;
const ModInt operator+(const ModInt &lhs, const ModInt &rhs) {
return ModInt(lhs.getVal() + rhs.getVal());
}
const ModInt operator-(const ModInt &lhs, const ModInt &rhs) {
return ModInt(lhs.getVal() - rhs.getVal());
}
const ModInt operator*(const ModInt &lhs, const ModInt &rhs) {
return ModInt(lhs.getVal() * rhs.getVal());
}
const ModInt operator/(const ModInt &lhs, const ModInt &rhs) {
return lhs.getVal() * rhs.inv();
}
ModInt &ModInt::operator+=(const ModInt &rhs) {
(*this) = (*this) + rhs;
return *this;
}
ModInt &ModInt::operator-=(const ModInt &rhs) {
(*this) = (*this) - rhs;
return *this;
}
ModInt &ModInt::operator*=(const ModInt &rhs) {
(*this) = (*this) * rhs;
return *this;
}
ModInt &ModInt::operator/=(const ModInt &rhs) {
(*this) = (*this) / rhs;
return *this;
}
class ModIntComb {
private:
vector<ModInt> facts;
vector<ModInt> fact_invs;
int n_max;
public:
ModIntComb(int n_max) : n_max(n_max) {
facts.push_back(1);
for (int i = 1; i <= n_max; i++) {
facts.push_back(facts[i - 1] * i);
}
fact_invs = vector<ModInt>(n_max + 1);
fact_invs[n_max] = facts[n_max].inv();
for (int i = n_max - 1; i >= 0; i--) {
fact_invs[i] = fact_invs[i + 1] * (i + 1);
}
}
int getNMax() { return n_max; }
ModInt fact(int n) { return facts[n]; }
ModInt fact_inv(int n) { return fact_invs[n]; }
ModInt comb(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
return facts[n] * fact_invs[k] * fact_invs[n - k];
}
};
int main() {
int N;
cin >> N;
string s;
cin >> s;
vector<vector<ModInt>> dp(N, vector<ModInt>(N));
for (int j = 0; j < N; j++) {
dp[0][j] = 1;
}
for (int i = 1; i < N; i++) {
vector<ModInt> dp_sum(N - (i - 1) + 1);
for (int j = 1; j <= N - (i - 1); j++) {
dp_sum[j] = dp_sum[j - 1] + dp[i - 1][j - 1];
}
for (int j = 0; j < N - i; j++) {
if (s[i - 1] == '<') {
dp[i][j] = dp_sum[j + 1];
} else {
dp[i][j] = dp_sum[N - (i - 1)] - dp_sum[j + 1];
}
}
}
cout << dp[N - 1][0] << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 986,093 | 986,094 | u425351967 | cpp |
p03179 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int main() {
ll n;
cin >> n;
string s;
cin >> s;
ll dp[n + 1][n + 1] = {{0}};
/* for(ll i=0;i<n;i++)
{
for(ll j=0;j<=n;j++)
cout<<dp[i][j]<<" ";
cout<<endl;
}*/
for (ll i = 0; i < n; i++)
dp[0][i] = 1;
ll m = 1000000007;
for (ll i = 1; i < n; i++) {
if (s.at(i - 1) == '>') {
ll r = 0;
for (ll j = n - i; j >= 0; j--) {
r = (r + dp[i - 1][j + 1]) % m;
dp[i][j] = (dp[i][j] + r) % m;
}
} else {
ll r = 0;
for (ll j = 0; j < n - i; j++) {
r = (r + dp[i - 1][j]) % m;
dp[i][j] = (dp[i][j] + r) % m;
}
}
}
cout << dp[n - 1][0] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int main() {
ll n;
cin >> n;
string s;
cin >> s;
ll dp[n + 1][n + 1] = {{0}};
/* for(ll i=0;i<n;i++)
{
for(ll j=0;j<=n;j++)
cout<<dp[i][j]<<" ";
cout<<endl;
}*/
for (ll i = 0; i < n; i++)
dp[0][i] = 1;
ll m = 1000000007;
for (ll i = 1; i < n; i++) {
if (s.at(i - 1) == '>') {
ll r = 0;
for (ll j = n - i - 1; j >= 0; j--) {
r = (r + dp[i - 1][j + 1]) % m;
// cout<<"nh "<<dp[i-1][j+1]<<endl;
// cout<<j<<" hjh "<<r<<endl;
dp[i][j] = (dp[i][j] + r) % m;
}
} else {
ll r = 0;
for (ll j = 0; j < n - i; j++) {
r = (r + dp[i - 1][j]) % m;
// cout<<"no "<<dp[i-1][j]<<endl;
// cout<<j<<" yjh "<<r<<endl;
dp[i][j] = (dp[i][j] + r) % m;
}
}
}
// for(ll i=0;i<n;i++)
//{
// for(ll j=0;j<n-i;j++)
// {
// cout<<i<<" "<<j<<" "<<dp[i][j]<<endl;
//}
//}
cout << dp[n - 1][0] << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 986,095 | 986,096 | u340961961 | cpp |
p03179 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int main() {
ll n;
cin >> n;
string s;
cin >> s;
ll dp[n + 1][n + 1] = {{0}};
for (ll i = 0; i < n; i++)
dp[0][i] = 1;
ll m = 1000000007;
for (ll i = 1; i < n; i++) {
if (s.at(i - 1) == '>') {
ll r = 0;
for (ll j = n - i; j >= 0; j--) {
r = (r + dp[i - 1][j + 1]) % m;
dp[i][j] = (dp[i][j] + r) % m;
}
} else {
ll r = 0;
for (ll j = 0; j < n - i; j++) {
r = (r + dp[i - 1][j]) % m;
dp[i][j] = (dp[i][j] + r) % m;
}
}
}
cout << dp[n - 1][0] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int main() {
ll n;
cin >> n;
string s;
cin >> s;
ll dp[n + 1][n + 1] = {{0}};
/* for(ll i=0;i<n;i++)
{
for(ll j=0;j<=n;j++)
cout<<dp[i][j]<<" ";
cout<<endl;
}*/
for (ll i = 0; i < n; i++)
dp[0][i] = 1;
ll m = 1000000007;
for (ll i = 1; i < n; i++) {
if (s.at(i - 1) == '>') {
ll r = 0;
for (ll j = n - i - 1; j >= 0; j--) {
r = (r + dp[i - 1][j + 1]) % m;
// cout<<"nh "<<dp[i-1][j+1]<<endl;
// cout<<j<<" hjh "<<r<<endl;
dp[i][j] = (dp[i][j] + r) % m;
}
} else {
ll r = 0;
for (ll j = 0; j < n - i; j++) {
r = (r + dp[i - 1][j]) % m;
// cout<<"no "<<dp[i-1][j]<<endl;
// cout<<j<<" yjh "<<r<<endl;
dp[i][j] = (dp[i][j] + r) % m;
}
}
}
// for(ll i=0;i<n;i++)
//{
// for(ll j=0;j<n-i;j++)
// {
// cout<<i<<" "<<j<<" "<<dp[i][j]<<endl;
//}
//}
cout << dp[n - 1][0] << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 986,097 | 986,096 | u340961961 | cpp |
p03179 | #include <bits/stdc++.h>
//#pragma once
using namespace std;
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
typedef long long ll;
typedef long double lb;
#define int long long
#define double long double
typedef pair<double, double> P;
const ll INF = 1e16;
const int MOD = 998244353;
const double EPS = 1e-10;
const double PI = 3.141592653589793;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const pair<int, int> fd[] = {make_pair(1, 0), make_pair(-1, 0), make_pair(0, 1),
make_pair(0, -1)};
///////////////////////___modpow___////////////////////
ll modpow(ll a, ll n, const ll &MOD = MOD) {
ll ret = n == 0 ? 1 : modpow(a, n / 2, MOD);
(ret *= ret) %= MOD;
if (n % 2)
((ret *= a) %= MOD);
return ret;
}
///////////////////////___modinv___////////////////////
ll modinv(ll d, const ll &MOD = MOD) { return modpow(d, MOD - 2, MOD); }
///////////////////////___combination___////////////////////
vector<ll> fac, finv, inv;
void COMinit(const int MAX = 5000000, const ll &MOD = MOD) {
fac.resize(MAX);
finv.resize(MAX);
inv.resize(MAX);
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1;
repd(i, 2, MAX) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll 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;
}
//////////////////////////////////////////////////////
class union_find {
int N;
vector<int> par;
public:
union_find(int n) {
N = n;
par.resize(N);
rep(i, N) par[i] = -1;
}
int find(int x) {
if (par[x] < 0)
return x;
else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
par[y] += par[x];
par[x] = y;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -par[find(x)]; }
};
//////////////////////////////////////////////////////
///////////////////////___inPrime___////////////////////
bool isPrime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
///////////////////////___divisor___////////////////////
vector<int> divisor(int n) {
vector<int> ret;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (n / i != i)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
return ret;
}
///////////////////////___prime_factor___////////////////////
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1) {
ret[n] = 1;
}
return ret;
}
///////////////////////___sieve___////////////////////////////
vector<int> primes;
vector<bool> is_prime;
int sieve(int n) {
int p = 0;
primes.resize(n);
is_prime.resize(n + 1);
rep(i, n + 1) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
repd(i, 2, n + 1) {
if (is_prime[i]) {
primes[p++] = i;
for (int j = 2; j <= n; j += i)
is_prime[j * i] = false;
}
}
return p;
}
/////////////////////////////////////////////////////////////////
struct SegmentTree {
private:
int N, uni = 0;
vector<int> node;
public:
SegmentTree() {}
int look(int x, int y) { return max(x, y); }
void init(vector<int> v) {
int sz = v.size();
N = 1;
while (N < sz)
N *= 2;
node.resize(2 * N - 1, uni);
rep(i, sz) node[i + N - 1] = v[i]; //最下段に値を入れる
for (int i = N - 2; i >= 0; i--)
node[i] = look(node[2 * i + 1], node[2 * i + 2]); //上げていく
}
void update(int x, int val) {
x += (N - 1); //最下段へ
node[x] = val;
while (x > 0) { //上げていく
x = (x - 1) / 2;
node[x] = look(node[2 * x + 1], node[2 * x + 2]);
}
}
int get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = N;
if (r <= a || b <= l)
return uni;
if (a <= l && r <= b)
return node[k];
int vl = get(a, b, 2 * k + 1, l, (l + r) / 2);
int vr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return look(vl, vr);
}
};
////////////////////////////////////////////////////////////////////
int n;
string s;
int dp[3100][3100], r[3100];
signed main() {
cin >> n >> s;
rep(i, n) dp[0][i] = 1;
repd(i, 1, n + 1) r[i] = r[i - 1] + dp[0][i - 1];
repd(i, 1, n) {
if (s[i - 1] == '<') {
rep(j, n - i) { dp[i][j] = (r[n] + MOD - r[j + 1]) % MOD; }
} else {
rep(j, n - i) { dp[i][j] = (r[j + 1] + MOD - r[0]) % MOD; }
}
repd(j, 1, n + 1) r[j] = (r[j - 1] + dp[i][j - 1]) % MOD;
}
cout << dp[n - 1][0] << endl;
}
| #include <bits/stdc++.h>
//#pragma once
using namespace std;
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
typedef long long ll;
typedef long double lb;
#define int long long
#define double long double
typedef pair<double, double> P;
const ll INF = 1e16;
const int MOD = 1000000007;
const double EPS = 1e-10;
const double PI = 3.141592653589793;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const pair<int, int> fd[] = {make_pair(1, 0), make_pair(-1, 0), make_pair(0, 1),
make_pair(0, -1)};
///////////////////////___modpow___////////////////////
ll modpow(ll a, ll n, const ll &MOD = MOD) {
ll ret = n == 0 ? 1 : modpow(a, n / 2, MOD);
(ret *= ret) %= MOD;
if (n % 2)
((ret *= a) %= MOD);
return ret;
}
///////////////////////___modinv___////////////////////
ll modinv(ll d, const ll &MOD = MOD) { return modpow(d, MOD - 2, MOD); }
///////////////////////___combination___////////////////////
vector<ll> fac, finv, inv;
void COMinit(const int MAX = 5000000, const ll &MOD = MOD) {
fac.resize(MAX);
finv.resize(MAX);
inv.resize(MAX);
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1;
repd(i, 2, MAX) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll 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;
}
//////////////////////////////////////////////////////
class union_find {
int N;
vector<int> par;
public:
union_find(int n) {
N = n;
par.resize(N);
rep(i, N) par[i] = -1;
}
int find(int x) {
if (par[x] < 0)
return x;
else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
par[y] += par[x];
par[x] = y;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -par[find(x)]; }
};
//////////////////////////////////////////////////////
///////////////////////___inPrime___////////////////////
bool isPrime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
///////////////////////___divisor___////////////////////
vector<int> divisor(int n) {
vector<int> ret;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (n / i != i)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
return ret;
}
///////////////////////___prime_factor___////////////////////
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1) {
ret[n] = 1;
}
return ret;
}
///////////////////////___sieve___////////////////////////////
vector<int> primes;
vector<bool> is_prime;
int sieve(int n) {
int p = 0;
primes.resize(n);
is_prime.resize(n + 1);
rep(i, n + 1) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
repd(i, 2, n + 1) {
if (is_prime[i]) {
primes[p++] = i;
for (int j = 2; j <= n; j += i)
is_prime[j * i] = false;
}
}
return p;
}
/////////////////////////////////////////////////////////////////
struct SegmentTree {
private:
int N, uni = 0;
vector<int> node;
public:
SegmentTree() {}
int look(int x, int y) { return max(x, y); }
void init(vector<int> v) {
int sz = v.size();
N = 1;
while (N < sz)
N *= 2;
node.resize(2 * N - 1, uni);
rep(i, sz) node[i + N - 1] = v[i]; //最下段に値を入れる
for (int i = N - 2; i >= 0; i--)
node[i] = look(node[2 * i + 1], node[2 * i + 2]); //上げていく
}
void update(int x, int val) {
x += (N - 1); //最下段へ
node[x] = val;
while (x > 0) { //上げていく
x = (x - 1) / 2;
node[x] = look(node[2 * x + 1], node[2 * x + 2]);
}
}
int get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = N;
if (r <= a || b <= l)
return uni;
if (a <= l && r <= b)
return node[k];
int vl = get(a, b, 2 * k + 1, l, (l + r) / 2);
int vr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return look(vl, vr);
}
};
////////////////////////////////////////////////////////////////////
int n;
string s;
int dp[3100][3100], r[3100];
signed main() {
cin >> n >> s;
rep(i, n) dp[0][i] = 1;
repd(i, 1, n + 1) r[i] = r[i - 1] + dp[0][i - 1];
repd(i, 1, n) {
if (s[i - 1] == '<') {
rep(j, n - i) { dp[i][j] = (r[n] + MOD - r[j + 1]) % MOD; }
} else {
rep(j, n - i) { dp[i][j] = (r[j + 1] + MOD - r[0]) % MOD; }
}
repd(j, 1, n + 1) r[j] = (r[j - 1] + dp[i][j - 1]) % MOD;
}
cout << dp[n - 1][0] << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 986,098 | 986,099 | u317754719 | cpp |
p03179 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define revrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
/*
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll max3(ll a, ll b, ll c){return max(a, max(b, c));};
ll min3(ll a, ll b, ll c){return min(a, min(b, c));};
ll max4(ll a, ll b, ll c, ll d){return max(max(a, b), min(c, d));};
ll min4(ll a, ll b, ll c, ll d){return min(min(a, b), min(c, d));};
ll max5(ll a, ll b, ll c, ll d, ll e){return max(max(a, b), max3(c, d, e));};
ll min5(ll a, ll b, ll c, ll d, ll e){return min(min(a, b), min3(c, d, e));};
*/
const ll INFL = 1LL << 60; // 10^18 = 2^60
const int INF = 1 << 30; // 10^9
ll MOD = 1000000007;
// ll MOD = 998244353;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
//デバッグ
void BinarySay(ll x, ll y = 60) {
rep(i, y) cout << (x >> (y - 1 - i) & 1);
cout << endl;
}
ll pow_long(ll x, ll k) {
ll res = 1;
while (k > 0) {
if (k % 2)
res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k) {
ll res = 1;
while (k > 0) {
if (k % 2) {
res *= x;
res %= MOD;
}
x *= x;
x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x) { return pow_mod(x, MOD - 2); };
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; };
ll kai_mod(ll x) {
if (x == 0)
return 1;
return x * kai_mod(x - 1) % MOD;
}
//コンビネーション
const int MAXcomb = 200010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
// facはn!,finvは1/n!
// invは逆元
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAXcomb; 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;
}
}
ll comb(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[k] % MOD * finv[n - k] % MOD;
}
ll dp[3010][3010];
int main() {
ll N;
string S;
cin >> N >> S;
rep(i, N) dp[0][i] = 1;
for (ll i = 1; i < N; i++) {
vector<ll> sum(N, 0);
sum[0] = dp[i - 1][0];
for (ll j = 1; j < N; j++) {
sum[j] = sum[j - 1] + dp[i - 1][j];
sum[j] %= MOD;
}
if (S[i - 1] == '<') {
rep(j, N) { dp[i][j] += sum[j]; }
} else {
rep(j, N) {
dp[i][j] += sum[N - i] - sum[j];
dp[i][j] %= MOD;
}
}
}
cout << dp[N - 1][0] << endl;
}
| #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define revrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
/*
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll max3(ll a, ll b, ll c){return max(a, max(b, c));};
ll min3(ll a, ll b, ll c){return min(a, min(b, c));};
ll max4(ll a, ll b, ll c, ll d){return max(max(a, b), min(c, d));};
ll min4(ll a, ll b, ll c, ll d){return min(min(a, b), min(c, d));};
ll max5(ll a, ll b, ll c, ll d, ll e){return max(max(a, b), max3(c, d, e));};
ll min5(ll a, ll b, ll c, ll d, ll e){return min(min(a, b), min3(c, d, e));};
*/
const ll INFL = 1LL << 60; // 10^18 = 2^60
const int INF = 1 << 30; // 10^9
ll MOD = 1000000007;
// ll MOD = 998244353;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
//デバッグ
void BinarySay(ll x, ll y = 60) {
rep(i, y) cout << (x >> (y - 1 - i) & 1);
cout << endl;
}
ll pow_long(ll x, ll k) {
ll res = 1;
while (k > 0) {
if (k % 2)
res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k) {
ll res = 1;
while (k > 0) {
if (k % 2) {
res *= x;
res %= MOD;
}
x *= x;
x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x) { return pow_mod(x, MOD - 2); };
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; };
ll kai_mod(ll x) {
if (x == 0)
return 1;
return x * kai_mod(x - 1) % MOD;
}
//コンビネーション
const int MAXcomb = 200010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
// facはn!,finvは1/n!
// invは逆元
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAXcomb; 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;
}
}
ll comb(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[k] % MOD * finv[n - k] % MOD;
}
ll dp[3010][3010];
int main() {
ll N;
string S;
cin >> N >> S;
rep(i, N) dp[0][i] = 1;
for (ll i = 1; i < N; i++) {
vector<ll> sum(N, 0);
sum[0] = dp[i - 1][0];
for (ll j = 1; j < N; j++) {
sum[j] = sum[j - 1] + dp[i - 1][j];
sum[j] %= MOD;
}
if (S[i - 1] == '<') {
rep(j, N) { dp[i][j] += sum[j]; }
} else {
rep(j, N) {
dp[i][j] += sum[N - i] - sum[j] + MOD;
dp[i][j] %= MOD;
}
}
}
cout << dp[N - 1][0] << endl;
}
| [
"assignment.change"
] | 986,102 | 986,103 | u633284019 | cpp |
p03179 | #include <iostream>
using namespace std;
const int MAXN = 3000 + 10;
const int mod = 1000000007;
int dp[MAXN][MAXN];
long long n, ans;
string s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> s;
s = ' ' + s;
s = ' ' + s;
dp[1][1] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '<') {
for (int k = 2; k <= i; k++) {
dp[i][k] = dp[i - 1][k - 1] + dp[i][k - 1];
dp[i][k] %= mod;
}
}
if (s[i] == '>') {
for (int k = i; k >= 0; k--) {
dp[i][k] = dp[i][k + 1] + dp[i - 1][k];
dp[i][k] %= mod;
}
}
}
for (int i = 1; i <= n; i++) {
ans += dp[n][i];
}
cout << ans;
return 0;
} | #include <iostream>
using namespace std;
const int MAXN = 3000 + 10;
const int mod = 1000000007;
int dp[MAXN][MAXN];
long long n, ans;
string s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> s;
s = ' ' + s;
s = ' ' + s;
dp[1][1] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '<') {
for (int k = 2; k <= i; k++) {
dp[i][k] = dp[i - 1][k - 1] + dp[i][k - 1];
dp[i][k] %= mod;
}
}
if (s[i] == '>') {
for (int k = i; k >= 0; k--) {
dp[i][k] = dp[i][k + 1] + dp[i - 1][k];
dp[i][k] %= mod;
}
}
}
for (int i = 1; i <= n; i++) {
ans += dp[n][i];
ans %= mod;
}
cout << ans;
return 0;
} | [
"assignment.add"
] | 986,104 | 986,105 | u803932112 | cpp |
p03179 | #include <iostream>
using namespace std;
const int MAXN = 3000 + 10;
const int mod = 1000000007;
int dp[MAXN][MAXN];
int n, ans;
string s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> s;
s = ' ' + s;
s = ' ' + s;
dp[1][1] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '<') {
for (int k = 1; k <= i; k++) {
dp[i][k] = dp[i - 1][k - 1] + dp[i][k - 1];
dp[i][k] %= mod;
}
}
if (s[i] == '>') {
for (int k = i; k >= 0; k--) {
dp[i][k] = dp[i][k + 1] + dp[i - 1][k];
dp[i][k] %= mod;
}
}
}
for (int i = 1; i <= n; i++) {
ans += dp[n][i];
ans %= mod;
}
cout << ans;
return 0;
} | #include <iostream>
using namespace std;
const int MAXN = 3000 + 10;
const int mod = 1000000007;
int dp[MAXN][MAXN];
long long n, ans;
string s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> s;
s = ' ' + s;
s = ' ' + s;
dp[1][1] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '<') {
for (int k = 2; k <= i; k++) {
dp[i][k] = dp[i - 1][k - 1] + dp[i][k - 1];
dp[i][k] %= mod;
}
}
if (s[i] == '>') {
for (int k = i; k >= 0; k--) {
dp[i][k] = dp[i][k + 1] + dp[i - 1][k];
dp[i][k] %= mod;
}
}
}
for (int i = 1; i <= n; i++) {
ans += dp[n][i];
ans %= mod;
}
cout << ans;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 986,106 | 986,105 | u803932112 | cpp |
p03179 | //
// ROIGold.cpp
// Main calisma
//
// Created by Rakhman on 05/02/2019.
// Copyright © 2019 Rakhman. All rights reserved.
//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
#define ios ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
#define S second
#define F first
#define pb push_back
#define nl '\n'
#define NL cout << '\n';
#define EX exit(0)
#define all(s) s.begin(), s.end()
#define no_answer return cout << 0, 0;
#define FOR(i, start, finish, k) for (llong i = start; i <= finish; i += k)
const long long MXN = 1e6 + 200;
const long long MNN = 1e4 + 520;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long long OO = 1e9 + 500;
typedef long long llong;
typedef unsigned long long ullong;
using namespace std;
int n;
llong dp[3100][3100];
string s;
int main() {
ios;
cin >> n;
cin >> s;
s = "##" + s;
dp[1][1] = 1;
for (int pr = 2; pr <= n; pr++) {
vector<int> v(pr + 1, 0);
for (int j = 1; j <= pr - 1; j++) {
v[j] = (v[j - 1] + dp[pr - 1][j]) % MOD;
}
for (int b = 1; b <= pr; b++) {
int l, r;
if (s[pr] == '<') {
l = b, r = pr - 1;
} else {
l = 1, r = b - 1;
}
dp[pr][b] = (dp[pr][b] + v[r] - v[l - 1]) % MOD;
}
}
llong ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + dp[n][i]) % MOD;
cout << ans;
}
| //
// ROIGold.cpp
// Main calisma
//
// Created by Rakhman on 05/02/2019.
// Copyright © 2019 Rakhman. All rights reserved.
//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
#define ios ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
#define S second
#define F first
#define pb push_back
#define nl '\n'
#define NL cout << '\n';
#define EX exit(0)
#define all(s) s.begin(), s.end()
#define no_answer return cout << 0, 0;
#define FOR(i, start, finish, k) for (llong i = start; i <= finish; i += k)
const long long MXN = 1e6 + 200;
const long long MNN = 1e4 + 520;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long long OO = 1e9 + 500;
typedef long long llong;
typedef unsigned long long ullong;
using namespace std;
int n;
llong dp[3100][3100];
string s;
int main() {
ios;
cin >> n;
cin >> s;
s = "##" + s;
dp[1][1] = 1;
for (int pr = 2; pr <= n; pr++) {
vector<int> v(pr + 1, 0);
for (int j = 1; j <= pr - 1; j++) {
v[j] = (v[j - 1] + dp[pr - 1][j]) % MOD;
}
for (int b = 1; b <= pr; b++) {
int l, r;
if (s[pr] == '<') {
l = b, r = pr - 1;
} else {
l = 1, r = b - 1;
}
dp[pr][b] = (dp[pr][b] + v[r] - v[l - 1] + MOD) % MOD;
}
}
llong ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + dp[n][i]) % MOD;
cout << ans;
}
| [
"assignment.change"
] | 986,113 | 986,114 | u796195598 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
template <long long mod> class Mod {
long long value;
void set_value(const long long x) { this->value = x % mod; }
public:
Mod() { set_value(0ll); }
template <typename T> Mod(T x = 0) { set_value((long long)x); }
friend istream &operator>>(istream &is, Mod &x) {
long long tmp;
is >> tmp;
x.set_value(tmp);
return is;
}
friend ostream &operator<<(ostream &os, const Mod &x) {
os << x.value;
return os;
}
operator long long() const { return this->value; }
template <typename T> bool operator<(const T x) {
return this->value < (long long)x;
}
template <typename T> bool operator<=(const T x) {
return this->value <= (long long)x;
}
template <typename T> bool operator>(const T x) {
return this->value > (long long)x;
}
template <typename T> bool operator>=(const T x) {
return this->value >= (long long)x;
}
template <typename T> bool operator==(const T x) {
return this->value == (long long)x;
}
template <typename T> Mod &operator=(const T x) {
set_value((long long)x);
return *this;
}
template <typename T> Mod &operator&=(const T x) {
set_value(this->value & (long long)x);
return *this;
}
template <typename T> Mod &operator|=(const T x) {
set_value(this->value | (long long)x);
return *this;
}
template <typename T> Mod &operator^=(const T x) {
set_value(this->value ^ (long long)x);
return *this;
}
template <typename T> Mod &operator<<=(const T x) {
set_value(this->value << (long long)x);
return *this;
}
template <typename T> Mod &operator>>=(const T x) {
set_value(this->value >> (long long)x);
return *this;
}
template <typename T> Mod &operator+=(const T x) {
set_value(this->value + (long long)x);
return *this;
}
template <typename T> Mod &operator-=(const T x) {
set_value(this->value - (long long)x + mod);
return *this;
}
template <typename T> Mod &operator*=(const T x) {
set_value(this->value * (long long)x);
return *this;
}
template <typename T> Mod &operator/=(const T x) {
long long a = (long long)x;
long long b = mod;
long long u = 1;
long long v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
*this *= Mod(u);
return *this;
}
template <typename T> Mod operator&(const T x) const {
return Mod(*this) &= x;
}
template <typename T> Mod operator|(const T x) const {
return Mod(*this) |= x;
}
template <typename T> Mod operator^(const T x) const {
return Mod(*this) ^= x;
}
template <typename T> Mod operator<<(const T x) const {
return Mod(*this) <<= x;
}
template <typename T> Mod operator>>(const T x) const {
return Mod(*this) >>= x;
}
template <typename T> Mod operator+(const T x) const {
return Mod(*this) += x;
}
template <typename T> Mod operator-(const T x) const {
return Mod(*this) -= x;
}
template <typename T> Mod operator*(const T x) const {
return Mod(*this) *= x;
}
template <typename T> Mod operator/(const T x) const {
return Mod(*this) /= x;
}
Mod &operator++() {
*this += 1;
return *this;
}
Mod &operator--() {
this->set_value(--this->value);
return *this;
}
Mod operator++(auto) {
Mod ret(*this);
++*this;
return ret;
}
Mod operator--(auto) {
Mod ret(*this);
--*this;
return ret;
}
};
int main() {
const long long MOD = 1'000'000'007;
int N;
string s;
cin >> N >> s;
vector<vector<Mod<MOD>>> dp(N + 1, vector<Mod<MOD>>(N + 1, 0));
dp[1][1] = 1;
for (int i = 2; i <= N; i++) {
if (s[i - 2] == '<') {
for (int j = 1; j <= i; j++) {
dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
}
} else {
for (int j = i; j >= 1; j--) {
dp[i][j] = dp[i][j + 1] + dp[i - 1][j];
}
}
}
// for (int i = 0; i <= N; i++)
// {
// for (int j = 0; j <= N; j++)
// {
// cout << dp[i][j] << " ";
// }
// cout << endl;
// }
Mod<MOD> ans = 0;
for (Mod<MOD> value : dp.back()) {
ans += value;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
template <long long mod> class Mod {
long long value;
void set_value(const long long x) { this->value = x % mod; }
public:
Mod() { set_value(0ll); }
template <typename T> Mod(T x = 0) { set_value((long long)x); }
friend istream &operator>>(istream &is, Mod &x) {
long long tmp;
is >> tmp;
x.set_value(tmp);
return is;
}
friend ostream &operator<<(ostream &os, const Mod &x) {
os << x.value;
return os;
}
operator long long() const { return this->value; }
template <typename T> bool operator<(const T x) {
return this->value < (long long)x;
}
template <typename T> bool operator<=(const T x) {
return this->value <= (long long)x;
}
template <typename T> bool operator>(const T x) {
return this->value > (long long)x;
}
template <typename T> bool operator>=(const T x) {
return this->value >= (long long)x;
}
template <typename T> bool operator==(const T x) {
return this->value == (long long)x;
}
template <typename T> Mod &operator=(const T x) {
set_value((long long)x);
return *this;
}
template <typename T> Mod &operator&=(const T x) {
set_value(this->value & (long long)x);
return *this;
}
template <typename T> Mod &operator|=(const T x) {
set_value(this->value | (long long)x);
return *this;
}
template <typename T> Mod &operator^=(const T x) {
set_value(this->value ^ (long long)x);
return *this;
}
template <typename T> Mod &operator<<=(const T x) {
set_value(this->value << (long long)x);
return *this;
}
template <typename T> Mod &operator>>=(const T x) {
set_value(this->value >> (long long)x);
return *this;
}
template <typename T> Mod &operator+=(const T x) {
set_value(this->value + (long long)x);
return *this;
}
template <typename T> Mod &operator-=(const T x) {
set_value(this->value - (long long)x + mod);
return *this;
}
template <typename T> Mod &operator*=(const T x) {
set_value(this->value * (long long)x);
return *this;
}
template <typename T> Mod &operator/=(const T x) {
long long a = (long long)x;
long long b = mod;
long long u = 1;
long long v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
*this *= Mod(u);
return *this;
}
template <typename T> Mod operator&(const T x) const {
return Mod(*this) &= x;
}
template <typename T> Mod operator|(const T x) const {
return Mod(*this) |= x;
}
template <typename T> Mod operator^(const T x) const {
return Mod(*this) ^= x;
}
template <typename T> Mod operator<<(const T x) const {
return Mod(*this) <<= x;
}
template <typename T> Mod operator>>(const T x) const {
return Mod(*this) >>= x;
}
template <typename T> Mod operator+(const T x) const {
return Mod(*this) += x;
}
template <typename T> Mod operator-(const T x) const {
return Mod(*this) -= x;
}
template <typename T> Mod operator*(const T x) const {
return Mod(*this) *= x;
}
template <typename T> Mod operator/(const T x) const {
return Mod(*this) /= x;
}
Mod &operator++() {
*this += 1;
return *this;
}
Mod &operator--() {
this->set_value(--this->value);
return *this;
}
Mod operator++(auto) {
Mod ret(*this);
++*this;
return ret;
}
Mod operator--(auto) {
Mod ret(*this);
--*this;
return ret;
}
};
int main() {
const long long MOD = 1'000'000'007;
int N;
string s;
cin >> N >> s;
vector<vector<Mod<MOD>>> dp(N + 1, vector<Mod<MOD>>(N + 1, 0));
dp[1][1] = 1;
for (int i = 2; i <= N; i++) {
if (s[i - 2] == '<') {
for (int j = 2; j <= i; j++) {
dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
}
} else {
for (int j = i - 1; j >= 1; j--) {
dp[i][j] = dp[i][j + 1] + dp[i - 1][j];
}
}
}
Mod<MOD> ans = 0;
for (Mod<MOD> value : dp.back()) {
ans += value;
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 986,125 | 986,126 | u618697411 | cpp |
p03179 |
/* monkukui 競技プログラミング用のテンプレート (ここから) */
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using lint = long long int;
using ll = long long int;
using lnt = long long int;
using graph = vector<vector<int>>;
using wgraph = vector<vector<pair<int, long long int>>>;
long long int INF = 1001001001001001LL;
int inf = 100100100;
long long int MOD = 1000000007LL;
double PI = 3.1415926535897932;
long long int di[] = {-1, 0, 1, 0, -1, 1, 1, -1};
long long int dj[] = {0, 1, 0, -1, 1, 1, -1, -1};
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;
}
inline void yes() { cout << "yes" << endl; }
inline void Yes() { cout << "Yes" << endl; }
inline void YES() { cout << "YES" << endl; }
inline void no() { cout << "no" << endl; }
inline void No() { cout << "No" << endl; }
inline void NO() { cout << "NO" << endl; }
inline void possible() { cout << "possible" << endl; }
inline void Possible() { cout << "Possible" << endl; }
inline void POSSIBLE() { cout << "POSSIBLE" << endl; }
inline void impossible() { cout << "impossible" << endl; }
inline void Impossible() { cout << "Impossible" << endl; }
inline void IMPOSSIBLE() { cout << "IMPOSSIBLE" << endl; }
#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 all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
/* monkukui 競技プログラミング用のテンプレート (ここまで)*/
// 抽象累積和
// 構築 O(n), get O(1)
template <typename T> struct CumSum {
private:
size_t n;
vector<T> dat;
public:
CumSum(const vector<T> &v) {
n = v.size();
dat.resize(n + 1, 0);
for (size_t i = 0; i < n; i++) {
dat[i + 1] = (dat[i] + v[i]) % MOD;
}
}
T get(size_t r) const { // 0-indexed, [0. r)
return dat[r] % MOD;
}
T get(size_t l, size_t r) { // 0-indexed, [l, r)
return (dat[r] - dat[l] + MOD) % MOD;
}
};
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<vector<lint>> dp(n + 1, vector<lint>(n + 1, 0));
// 区間和のみ取得できれば良い
// 累積和でいいんじゃね
for (int j = 0; j < n; j++)
dp[0][j] = 1;
for (int i = 1; i < n; i++) {
// 累積和を構築
CumSum<lint> cs(dp[i - 1]);
if (s[i - 1] == '<') {
for (int j = 0; j <= n; j++) {
int r = n - i + 1;
int l = j + 1;
lint sum = cs.get(l, r);
dp[i][j] += sum;
dp[i][j] %= MOD;
}
} else {
for (int j = 0; j < i; j++) {
int r = j + 1;
int l = 0;
lint sum = cs.get(l, r);
dp[i][j] += sum;
dp[i][j] %= MOD;
}
}
}
/*
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= n; j++) {
cout << dp[i][j] << " ";
}
cout << endl;
}*/
cout << dp[n - 1][0] % MOD << endl;
return 0;
}
|
/* monkukui 競技プログラミング用のテンプレート (ここから) */
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using lint = long long int;
using ll = long long int;
using lnt = long long int;
using graph = vector<vector<int>>;
using wgraph = vector<vector<pair<int, long long int>>>;
long long int INF = 1001001001001001LL;
int inf = 100100100;
long long int MOD = 1000000007LL;
double PI = 3.1415926535897932;
long long int di[] = {-1, 0, 1, 0, -1, 1, 1, -1};
long long int dj[] = {0, 1, 0, -1, 1, 1, -1, -1};
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;
}
inline void yes() { cout << "yes" << endl; }
inline void Yes() { cout << "Yes" << endl; }
inline void YES() { cout << "YES" << endl; }
inline void no() { cout << "no" << endl; }
inline void No() { cout << "No" << endl; }
inline void NO() { cout << "NO" << endl; }
inline void possible() { cout << "possible" << endl; }
inline void Possible() { cout << "Possible" << endl; }
inline void POSSIBLE() { cout << "POSSIBLE" << endl; }
inline void impossible() { cout << "impossible" << endl; }
inline void Impossible() { cout << "Impossible" << endl; }
inline void IMPOSSIBLE() { cout << "IMPOSSIBLE" << endl; }
#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 all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
/* monkukui 競技プログラミング用のテンプレート (ここまで)*/
// 抽象累積和
// 構築 O(n), get O(1)
template <typename T> struct CumSum {
private:
size_t n;
vector<T> dat;
public:
CumSum(const vector<T> &v) {
n = v.size();
dat.resize(n + 1, 0);
for (size_t i = 0; i < n; i++) {
dat[i + 1] = (dat[i] + v[i]) % MOD;
}
}
T get(size_t r) const { // 0-indexed, [0. r)
return dat[r] % MOD;
}
T get(size_t l, size_t r) { // 0-indexed, [l, r)
return (dat[r] - dat[l] + MOD) % MOD;
}
};
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<vector<lint>> dp(n + 1, vector<lint>(n + 1, 0));
// 区間和のみ取得できれば良い
// 累積和でいいんじゃね
for (int j = 0; j < n; j++)
dp[0][j] = 1;
for (int i = 1; i < n; i++) {
// 累積和を構築
CumSum<lint> cs(dp[i - 1]);
if (s[i - 1] == '<') {
for (int j = 0; j <= n - i; j++) {
int r = n - i + 1;
int l = j + 1;
lint sum = cs.get(l, r);
dp[i][j] += sum;
dp[i][j] %= MOD;
}
} else {
for (int j = 0; j < n - i; j++) {
int r = j + 1;
int l = 0;
lint sum = cs.get(l, r);
dp[i][j] += sum;
dp[i][j] %= MOD;
}
}
}
/*
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= n; j++) {
cout << dp[i][j] << " ";
}
cout << endl;
}*/
cout << dp[n - 1][0] % MOD << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 986,129 | 986,130 | u212904724 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
long long int dp[n + 1][n + 1], x = pow(10, 9) + 7;
if (s[0] == '<') {
dp[2][1] = 0;
dp[2][2] = 1;
} else {
dp[2][1] = 1;
dp[2][2] = 0;
}
for (int i = 3; i <= n; i++) {
if (s[i - 2] == '<') {
dp[i][1] = 0;
for (int j = 2; j <= i; j++) {
dp[i][j] = ((dp[i][j - 1] % x) + (dp[i - 1][j - 1] % x)) % x;
}
} else {
dp[i][i] = 0;
for (int j = i - 1; j >= 1; j--) {
dp[i][j] = ((dp[i][j + 1] % x) + (dp[i - 1][j] % x)) % x;
}
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
ans = ((ans % x) + (dp[n][i] % x));
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
long long int dp[n + 1][n + 1], x = pow(10, 9) + 7;
if (s[0] == '<') {
dp[2][1] = 0;
dp[2][2] = 1;
} else {
dp[2][1] = 1;
dp[2][2] = 0;
}
for (int i = 3; i <= n; i++) {
if (s[i - 2] == '<') {
dp[i][1] = 0;
for (int j = 2; j <= i; j++) {
dp[i][j] = ((dp[i][j - 1] % x) + (dp[i - 1][j - 1] % x)) % x;
}
} else {
dp[i][i] = 0;
for (int j = i - 1; j >= 1; j--) {
dp[i][j] = ((dp[i][j + 1] % x) + (dp[i - 1][j] % x)) % x;
}
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
ans = ((ans % x) + (dp[n][i] % x)) % x;
}
cout << ans;
} | [
"assignment.change"
] | 986,135 | 986,136 | u547420959 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> mp;
ll inf = 1e9;
ll mod = 1e9 + 7;
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<ll> sum(n + 3, 0);
vector<vector<ll>> dp(n + 1, vector<ll>(n + 3, 0));
for (int i = 0; i <= n; i++)
dp[1][i] = 1;
for (int i = 2; i <= n; i++) {
sum[0] = 0;
for (int j = 1; j < n - i + 3; j++)
sum[j] = (sum[j - 1] + dp[i - 1][j]) % mod;
if (s[i - 2] == '<') {
// for(int j=0;j<n-i+1;j++)for(int
// k=j+1;k<n-i+2;k++)dp[i][j]=(dp[i][j]+dp[i-1][k])%mod;
for (int j = 0; j < n - i + 1; j++)
dp[i][j] = (sum[n - i + 2] - sum[j + 2] + mod) % mod;
} else {
// for(int j=0;j<n-i+1;j++)for(int
// k=0;k<j+1;k++)dp[i][j]=(dp[i][j]+dp[i-1][k])%mod;
for (int j = 0; j < n - i + 1; j++)
dp[i][j] = sum[j + 1];
}
}
cout << dp[n][0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> mp;
ll inf = 1e9;
ll mod = 1e9 + 7;
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<ll> sum(n + 3, 0);
vector<vector<ll>> dp(n + 1, vector<ll>(n + 3, 0));
for (int i = 0; i <= n; i++)
dp[1][i] = 1;
for (int i = 2; i <= n; i++) {
sum[0] = 0;
for (int j = 1; j < n - i + 3; j++)
sum[j] = (sum[j - 1] + dp[i - 1][j - 1]) % mod;
if (s[i - 2] == '<') {
// for(int j=0;j<n-i+1;j++)for(int
// k=j+1;k<n-i+2;k++)dp[i][j]=(dp[i][j]+dp[i-1][k])%mod;
for (int j = 0; j < n - i + 1; j++)
dp[i][j] = (sum[n - i + 2] - sum[j + 1] + mod) % mod;
} else {
// for(int j=0;j<n-i+1;j++)for(int
// k=0;k<j+1;k++)dp[i][j]=(dp[i][j]+dp[i-1][k])%mod;
for (int j = 0; j < n - i + 1; j++)
dp[i][j] = sum[j + 1];
}
}
cout << dp[n][0] << endl;
return 0;
}
| [
"assignment.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 986,139 | 986,140 | u410943667 | cpp |
p03179 | #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define INF 2140000000
const long long MOD = 1000000007;
using namespace std;
char str[3005];
ll dp[3005];
ll sdp[3005];
int main(int argc, char *argv[]) {
int n;
scanf("%d", &n);
scanf("%s", str);
int i, j;
int curr = 0;
int prev = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i; j++) {
if (i == 0) {
dp[j] = 1;
} else if (str[i - 1] == '<') {
dp[j] = sdp[j + 1];
} else {
dp[j] = sdp[n - i + 1] - sdp[j + 1];
}
}
sdp[0] = 0;
for (j = 0; j < n - i; j++) {
sdp[j + 1] = (sdp[j] + dp[j]) % MOD;
}
}
printf("%lld\n", dp[0]);
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define INF 2140000000
const long long MOD = 1000000007;
using namespace std;
char str[3005];
ll dp[3005];
ll sdp[3005];
int main(int argc, char *argv[]) {
int n;
scanf("%d", &n);
scanf("%s", str);
int i, j;
int curr = 0;
int prev = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i; j++) {
if (i == 0) {
dp[j] = 1;
} else if (str[i - 1] == '<') {
dp[j] = sdp[j + 1];
} else {
dp[j] = (sdp[n - i + 1] - sdp[j + 1] + MOD) % MOD;
}
}
sdp[0] = 0;
for (j = 0; j < n - i; j++) {
sdp[j + 1] = (sdp[j] + dp[j]) % MOD;
}
}
printf("%lld\n", dp[0]);
return 0;
}
| [
"assignment.change"
] | 986,143 | 986,144 | u209713918 | cpp |
p03179 | #include <bits/stdc++.h>
#define FAST std::ios::sync_with_stdio(0);
#define FOUT freopen(".out", "w", stdout);
#define FIN freopen(".in", "r", stdin);
#define MOD 1000000007
#define KKK 1073741824
#define pb push_back
#define mp make_pair
#define PB pop_back
#define S second
#define SZ size
#define F first
using namespace std;
long long dp[3333][3333];
int n, i, j;
string s;
int main() {
FAST;
cin >> n;
cin >> s;
s = " " + s;
dp[1][1] = 1;
for (i = 2; i <= n; i++) {
for (j = 1; j <= i; j++) {
if (s[i - 1] == '<')
dp[i][j] = (dp[i - 1][j - 1] + dp[i][j - 1]) % MOD;
else
dp[i][j] = (dp[i - 1][i - 1] - dp[i - 1][j - 1] + dp[i][j - 1]) % MOD;
}
}
cout << dp[n][n] << endl;
return 0;
} | #include <bits/stdc++.h>
#define FAST std::ios::sync_with_stdio(0);
#define FOUT freopen(".out", "w", stdout);
#define FIN freopen(".in", "r", stdin);
#define MOD 1000000007
#define KKK 1073741824
#define pb push_back
#define mp make_pair
#define PB pop_back
#define S second
#define SZ size
#define F first
using namespace std;
long long dp[3333][3333];
int n, i, j;
string s;
int main() {
FAST;
cin >> n;
cin >> s;
s = " " + s;
dp[1][1] = 1;
for (i = 2; i <= n; i++) {
for (j = 1; j <= i; j++) {
if (s[i - 1] == '<')
dp[i][j] = (dp[i - 1][j - 1] + dp[i][j - 1]) % MOD;
else
dp[i][j] =
(dp[i - 1][i - 1] - dp[i - 1][j - 1] + dp[i][j - 1] + MOD) % MOD;
}
}
cout << dp[n][n] << endl;
return 0;
} | [
"assignment.change"
] | 986,147 | 986,148 | u722097283 | cpp |
p03179 | #include <bits/stdc++.h>
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define IFOR(i, m, n) for (int i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const int MOD = 1000000007;
/* テンプレートここまで */
/* 二項係数 C(n,k) mod p を計算 */
const int MAX = 100010;
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;
}
int main() {
int N;
cin >> N;
string s;
cin >> s;
vector<vector<ll>> dp(N + 1, vector<ll>(N + 1));
FOR(j, 1, N + 1) { dp[1][j] = 1; }
vector<vector<ll>> sum(N + 1, vector<ll>(N + 1, 0));
FOR(j, 1, N + 1) { sum[1][j] = j; }
FOR(i, 2, N + 1) {
FOR(j, 1, N - i + 2) {
if (s[i - 2] == '<') {
dp[i][j] += sum[i - 1][j] % MOD;
} else {
dp[i][j] += sum[i - 1][N - i + 2] - sum[i - 1][j] + MOD % MOD;
dp[i][j] %= MOD;
}
sum[i][j] += sum[i][j - 1] + dp[i][j] % MOD;
sum[i][j] %= MOD;
}
}
cout << dp[N][1] % MOD << endl;
} | #include <bits/stdc++.h>
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define IFOR(i, m, n) for (int i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const int MOD = 1000000007;
/* テンプレートここまで */
/* 二項係数 C(n,k) mod p を計算 */
const int MAX = 100010;
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;
}
int main() {
int N;
cin >> N;
string s;
cin >> s;
vector<vector<ll>> dp(N + 1, vector<ll>(N + 1));
FOR(j, 1, N + 1) { dp[1][j] = 1; }
vector<vector<ll>> sum(N + 1, vector<ll>(N + 1, 0));
FOR(j, 1, N + 1) { sum[1][j] = j; }
FOR(i, 2, N + 1) {
FOR(j, 1, N - i + 2) {
if (s[i - 2] == '<') {
dp[i][j] = sum[i - 1][j] % MOD;
} else {
dp[i][j] = (sum[i - 1][N - i + 2] - sum[i - 1][j] + MOD) % MOD;
dp[i][j] %= MOD;
}
sum[i][j] = sum[i][j - 1] + dp[i][j] % MOD;
sum[i][j] %= MOD;
}
}
cout << dp[N][1] % MOD << endl;
} | [
"assignment.value.change"
] | 986,149 | 986,150 | u708550576 | cpp |
p03179 | #include <bits/stdc++.h>
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define IFOR(i, m, n) for (int i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const int MOD = 1000000007;
/* テンプレートここまで */
/* 二項係数 C(n,k) mod p を計算 */
const int MAX = 100010;
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;
}
int main() {
int N;
cin >> N;
string s;
cin >> s;
vector<vector<ll>> dp(N + 1, vector<ll>(N + 1));
FOR(j, 1, N + 1) { dp[1][j] = 1; }
vector<vector<ll>> sum(N + 1, vector<ll>(N + 1, 0));
FOR(j, 1, N + 1) { sum[1][j] = j; }
FOR(i, 2, N + 1) {
FOR(j, 1, N - i + 2) {
if (s[i - 2] == '<') {
dp[i][j] = sum[i - 1][j] % MOD;
} else {
dp[i][j] = sum[i - 1][N - i + 2] - sum[i - 1][j] + MOD % MOD;
dp[i][j] %= MOD;
}
sum[i][j] = sum[i][j - 1] + dp[i][j] % MOD;
sum[i][j] %= MOD;
}
}
cout << dp[N][1] % MOD << endl;
} | #include <bits/stdc++.h>
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define IFOR(i, m, n) for (int i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const int MOD = 1000000007;
/* テンプレートここまで */
/* 二項係数 C(n,k) mod p を計算 */
const int MAX = 100010;
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;
}
int main() {
int N;
cin >> N;
string s;
cin >> s;
vector<vector<ll>> dp(N + 1, vector<ll>(N + 1));
FOR(j, 1, N + 1) { dp[1][j] = 1; }
vector<vector<ll>> sum(N + 1, vector<ll>(N + 1, 0));
FOR(j, 1, N + 1) { sum[1][j] = j; }
FOR(i, 2, N + 1) {
FOR(j, 1, N - i + 2) {
if (s[i - 2] == '<') {
dp[i][j] = sum[i - 1][j] % MOD;
} else {
dp[i][j] = (sum[i - 1][N - i + 2] - sum[i - 1][j] + MOD) % MOD;
dp[i][j] %= MOD;
}
sum[i][j] = sum[i][j - 1] + dp[i][j] % MOD;
sum[i][j] %= MOD;
}
}
cout << dp[N][1] % MOD << endl;
} | [] | 986,151 | 986,150 | u708550576 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int v[3005][3005];
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++)
v[1][i] = 1;
for (int i = 2; i <= n; i++) {
int a = 0;
if (s[i - 2] == '<')
for (int j = 0; j <= n - i; j++)
a = (a + v[i - 1][j]) % mod, v[i][j] = (v[i][j] + a) % mod;
else
for (int j = n - i; j >= 0; j--)
a = (a + v[i - 1][j + 1]) % mod, v[i][j] = (v[i][j] + a) % mod;
}
cout << v[n - 1][0];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int v[3005][3005];
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++)
v[1][i] = 1;
for (int i = 2; i <= n; i++) {
int a = 0;
if (s[i - 2] == '<')
for (int j = 0; j <= n - i; j++)
a = (a + v[i - 1][j]) % mod, v[i][j] = (v[i][j] + a) % mod;
else
for (int j = n - i; j >= 0; j--)
a = (a + v[i - 1][j + 1]) % mod, v[i][j] = (v[i][j] + a) % mod;
}
cout << v[n][0];
return 0;
}
| [
"expression.operation.binary.remove"
] | 986,152 | 986,153 | u308555207 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int v[3005][3005];
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++)
v[1][i] = 1;
for (int i = 2; i < n; i++) {
int a = 0;
if (s[i - 2] == '<')
for (int j = 0; j <= n - i; j++)
a = (a + v[i - 1][j]) % mod, v[i][j] = (v[i][j] + a) % mod;
else
for (int j = n - i; j >= 0; j--)
a = (a + v[i - 1][j + 1]) % mod, v[i][j] = (v[i][j] + a) % mod;
}
cout << v[n - 1][0];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int v[3005][3005];
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++)
v[1][i] = 1;
for (int i = 2; i <= n; i++) {
int a = 0;
if (s[i - 2] == '<')
for (int j = 0; j <= n - i; j++)
a = (a + v[i - 1][j]) % mod, v[i][j] = (v[i][j] + a) % mod;
else
for (int j = n - i; j >= 0; j--)
a = (a + v[i - 1][j + 1]) % mod, v[i][j] = (v[i][j] + a) % mod;
}
cout << v[n][0];
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 986,154 | 986,153 | u308555207 | cpp |
p03179 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
typedef unsigned long long ull;
typedef signed long long sll;
using namespace std;
#define INF 0x7FFFFFFFFFFFFFFF
#define BIG_PRIME 1000000007
int main() {
string s;
ull i, j, N, sum;
cin >> N >> s;
vector<vector<ull>> dp(N);
dp[0].resize(1, 1);
for (i = 1; i < N; ++i) {
dp[i].resize(i + 1, 0);
if (s[i - 1] == '<') {
for (j = 1; j <= i; ++j) {
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j - 1]) % BIG_PRIME;
}
} else {
for (j = 1; j <= i; ++j) {
dp[i][i - j] = (dp[i][i - j + 1] + dp[i - 1][i - j]) % BIG_PRIME;
}
}
}
sum = 0;
for (j = 0; j <= N; ++j) {
sum = (sum + dp[N - 1][j]) % BIG_PRIME;
}
cout << sum;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
typedef unsigned long long ull;
typedef signed long long sll;
using namespace std;
#define INF 0x7FFFFFFFFFFFFFFF
#define BIG_PRIME 1000000007
int main() {
string s;
ull i, j, N, sum;
cin >> N >> s;
vector<vector<ull>> dp(N);
dp[0].resize(1, 1);
for (i = 1; i < N; ++i) {
dp[i].resize(i + 1, 0);
if (s[i - 1] == '<') {
for (j = 1; j <= i; ++j) {
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j - 1]) % BIG_PRIME;
}
} else {
for (j = 1; j <= i; ++j) {
dp[i][i - j] = (dp[i][i - j + 1] + dp[i - 1][i - j]) % BIG_PRIME;
}
}
}
sum = 0;
for (j = 0; j < N; ++j) {
sum = (sum + dp[N - 1][j]) % BIG_PRIME;
}
cout << sum;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 986,155 | 986,156 | u659371255 | cpp |
p03179 | /*
[dp] T - Permutation
*/
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
const int MAX_N = 3000;
const ll MOD = 1e9 + 7;
int N;
string s;
ll dp[MAX_N][MAX_N];
ll solve() {
for (int j = 0; j < N; j++) {
dp[0][j] = 1;
}
for (int i = 1; i < N; i++) {
for (int j = 0; j <= N - i; j++) {
if (s[i - 1] == '<') {
(dp[i][j] += dp[i - 1][j]) %= MOD;
(dp[i][N - i] -= dp[i - 1][j]) %= MOD;
} else {
(dp[i][0] += dp[i - 1][j]) %= MOD;
(dp[i][j] -= dp[i - 1][j]) %= MOD;
}
}
for (int j = 1; j <= N - i; j++) {
(dp[i][j] += dp[i][j - 1]) %= MOD;
}
}
return dp[N - 1][0];
}
int main() {
cin >> N;
cin >> s;
cout << solve() << endl;
return 0;
}
| /*
[dp] T - Permutation
*/
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
const int MAX_N = 3000;
const ll MOD = 1e9 + 7;
int N;
string s;
ll dp[MAX_N][MAX_N];
ll solve() {
for (int j = 0; j < N; j++) {
dp[0][j] = 1;
}
for (int i = 1; i < N; i++) {
for (int j = 0; j <= N - i; j++) {
if (s[i - 1] == '<') {
(dp[i][j] += dp[i - 1][j]) %= MOD;
(dp[i][N - i] += MOD - dp[i - 1][j]) %= MOD;
} else {
(dp[i][0] += dp[i - 1][j]) %= MOD;
(dp[i][j] += MOD - dp[i - 1][j]) %= MOD;
}
}
for (int j = 1; j <= N - i; j++) {
(dp[i][j] += dp[i][j - 1]) %= MOD;
}
}
return dp[N - 1][0];
}
int main() {
cin >> N;
cin >> s;
cout << solve() << endl;
return 0;
}
| [
"expression.operator.change",
"assignment.change"
] | 986,157 | 986,158 | u302149106 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
typedef tuple<int, int, int> tp;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> pii;
typedef pair<int, LL> pil;
typedef pair<LL, int> pli;
typedef pair<LL, LL> pll;
typedef pair<pii, int> piipi;
typedef pair<int, pii> pipii;
typedef pair<pii, pii> piipii;
typedef pair<LL, pii> plpii;
typedef pair<LD, LD> pdd;
typedef pair<LD, int> pdi;
typedef pair<LD, LL> pdl;
typedef pair<int, LD> pid;
typedef pair<LL, LD> pld;
const int mod = 1e9 + 7;
const int hf = 999983;
const int N = 1e6;
char s[3005];
int dp[3005][3005];
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (i == 1) {
for (int j = 1; j <= n; j++)
dp[i][j] = 1;
} else {
int num = n - i + 1, sum = 0;
if (s[i - 1] == '>') {
for (int j = 1; j <= num + 1; j++)
sum = (sum + dp[i - 1][j]) % mod;
for (int j = 1; j <= num; j++) {
sum = (sum - dp[i - 1][j]) % mod;
dp[i][j] = sum;
}
} else {
for (int j = 1; j <= num; j++) {
sum = (sum + dp[i - 1][j]) % mod;
dp[i][j] = sum;
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + dp[n][i]) % mod;
printf("%d\n", ans);
}
| #include <bits/stdc++.h>
using namespace std;
typedef tuple<int, int, int> tp;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> pii;
typedef pair<int, LL> pil;
typedef pair<LL, int> pli;
typedef pair<LL, LL> pll;
typedef pair<pii, int> piipi;
typedef pair<int, pii> pipii;
typedef pair<pii, pii> piipii;
typedef pair<LL, pii> plpii;
typedef pair<LD, LD> pdd;
typedef pair<LD, int> pdi;
typedef pair<LD, LL> pdl;
typedef pair<int, LD> pid;
typedef pair<LL, LD> pld;
const int mod = 1e9 + 7;
const int hf = 999983;
const int N = 1e6;
char s[3005];
int dp[3005][3005];
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (i == 1) {
for (int j = 1; j <= n; j++)
dp[i][j] = 1;
} else {
int num = n - i + 1, sum = 0;
if (s[i - 1] == '>') {
for (int j = 1; j <= num + 1; j++)
sum = (sum + dp[i - 1][j]) % mod;
for (int j = 1; j <= num; j++) {
sum = (sum - dp[i - 1][j] + mod) % mod;
dp[i][j] = sum;
}
} else {
for (int j = 1; j <= num; j++) {
sum = (sum + dp[i - 1][j]) % mod;
dp[i][j] = sum;
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + dp[n][i]) % mod;
printf("%d\n", ans);
}
| [
"assignment.change"
] | 986,159 | 986,160 | u596311662 | cpp |
p03179 | #include <bits/stdc++.h>
#define MAXN 3030
#define pii pair<int, int>
#define pb push_back
typedef long long ll;
using namespace std;
ll n, dp[MAXN][MAXN], pre[MAXN][MAXN], mod = 1e9 + 7;
string s;
ll go(int x, int y) {
// y good options, filling in the rhs of the xth symbol
if (dp[x][y] != -1)
return dp[x][y];
if (y == 0) {
dp[x][y] = 0;
pre[x][y] = 0;
return 0;
}
if (x == n - 1) {
dp[x][y] = y == 1;
pre[x][y] = dp[x][y] + pre[x][y - 1];
pre[x][y] %= mod;
return y == 1;
}
ll a = 0;
int t = n - x;
if (s[x] == '<') {
if (s[x + 1] == '<')
a += pre[x + 1][y - 1];
else
a += pre[x + 1][t - 1] - pre[x + 1][t - y] + dp[x + 1][t - y];
} else {
if (s[x + 1] == '<')
a += pre[x + 1][t - 1] - pre[x + 1][t - y] + dp[x + 1][t - y];
else
a += pre[x + 1][y - 1];
}
dp[x][y] = a % mod;
pre[x][y] = dp[x][y] + pre[x][y - 1];
pre[x][y] %= mod;
return dp[x][y];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof(dp));
cin >> n >> s;
s = "<" + s;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= n; j++) {
go(i, j);
}
}
cout << go(0, n);
} | #include <bits/stdc++.h>
#define MAXN 3030
#define pii pair<int, int>
#define pb push_back
typedef long long ll;
using namespace std;
ll n, dp[MAXN][MAXN], pre[MAXN][MAXN], mod = 1e9 + 7;
string s;
ll go(int x, int y) {
// y good options, filling in the rhs of the xth symbol
if (dp[x][y] != -1)
return dp[x][y];
if (y == 0) {
dp[x][y] = 0;
pre[x][y] = 0;
return 0;
}
if (x == n - 1) {
dp[x][y] = y == 1;
pre[x][y] = dp[x][y] + pre[x][y - 1];
pre[x][y] %= mod;
return y == 1;
}
ll a = mod;
int t = n - x;
if (s[x] == '<') {
if (s[x + 1] == '<')
a += pre[x + 1][y - 1];
else
a += pre[x + 1][t - 1] - pre[x + 1][t - y] + dp[x + 1][t - y];
} else {
if (s[x + 1] == '<')
a += pre[x + 1][t - 1] - pre[x + 1][t - y] + dp[x + 1][t - y];
else
a += pre[x + 1][y - 1];
}
dp[x][y] = a % mod;
pre[x][y] = dp[x][y] + pre[x][y - 1];
pre[x][y] %= mod;
return dp[x][y];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof(dp));
cin >> n >> s;
s = "<" + s;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= n; j++) {
go(i, j);
}
}
cout << go(0, n);
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 986,168 | 986,169 | u190314045 | cpp |
p03179 |
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(10)
using namespace std;
typedef pair<int, int> P;
int dp[3005][3005]; // i: 何番目 j: 前の桁より少ない数が何個あるか
string s;
int N;
int mod = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
struct BIT {
int n;
vector<int> bit; // 1-indexd
BIT(int sz) {
bit.resize(sz + 1);
n = sz;
}
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
s %= mod;
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
bit[i] %= mod;
i += i & -i;
}
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> N;
cin >> s;
REP(j, N) dp[0][j] = 1;
FOR(i, 1, N - 1) {
BIT bit(N + 10);
REP(j, N - i + 1) bit.add(j + 1, dp[i - 1][j]);
REP(j, N - i) {
if (s[i - 1] == '<') {
dp[i][j] = bit.sum(j + 1);
} else {
dp[i][j] = bit.sum(N) - bit.sum(j + 1);
}
}
}
cout << dp[N - 1][0] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(10)
using namespace std;
typedef pair<int, int> P;
int dp[3005][3005]; // i: 何番目 j: 前の桁より少ない数が何個あるか
string s;
int N;
int mod = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
struct BIT {
int n;
vector<int> bit; // 1-indexd
BIT(int sz) {
bit.resize(sz + 1);
n = sz;
}
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
s %= mod;
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
bit[i] %= mod;
i += i & -i;
}
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> N;
cin >> s;
REP(j, N) dp[0][j] = 1;
FOR(i, 1, N - 1) {
BIT bit(N + 10);
REP(j, N - i + 1) bit.add(j + 1, dp[i - 1][j]);
REP(j, N - i) {
if (s[i - 1] == '<') {
dp[i][j] = bit.sum(j + 1);
} else {
dp[i][j] = (bit.sum(N) - bit.sum(j + 1) + mod) % mod;
}
}
}
cout << dp[N - 1][0] << endl;
return 0;
}
| [
"assignment.change"
] | 986,174 | 986,175 | u516353059 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
#define M 1000000007
#define MM 998244353
#define ll long long
#define pb push_back
#define mem0(a) memset(a, 0, sizeof(a))
#define mem1(a) memset(a, -1, sizeof(a))
#define memf(a) memset(a, false, sizeof(a))
#define all(v) v.begin(), v.end()
#define sz(a) (ll) a.size()
#define F first
#define S second
#define PI 3.1415926536
#define INF 2000000000000000000
#define endl "\n"
#define _time_ 1.0 * clock() / CLOCKS_PER_SEC
// RNG based on mersenne_twister
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
ll power(ll b, ll e, ll m) {
if (e == 0)
return 1;
if (e & 1)
return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
ll power(ll b, ll e) {
if (e == 0)
return 1;
if (e & 1)
return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U> static inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> static inline void amax(T &x, U y) {
if (x < y)
x = y;
}
const int N = 16;
ll a[20][20], n;
ll dp[1 << N], dp2[1 << N];
int _runtimeTerror_() {
mem1(dp);
ll i, j, k, l;
cin >> n;
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < n; ++j)
cin >> a[i][j];
}
ll sub = (1 << n);
for (i = 1; i < sub; ++i) {
dp2[i] = 0;
vector<ll> v;
for (j = n - 1; j >= 0; --j)
if (i & (1 << j))
v.pb(j);
ll ss = sz(v);
for (ll k = 0; k < ss; ++k) {
for (ll l = k; l < ss; ++l)
dp2[i] += a[v[k]][v[l]];
}
}
dp[0] = 0;
for (i = 1; i < sub; ++i) {
for (j = n - 1; j >= 0; --j) {
if (i & (1 << j))
break;
}
dp[i] = dp[i & (~(1 << j))];
vector<ll> v;
for (k = j - 1; k >= 0; --k)
if (i & (1 << k))
v.pb(k);
ll x = (1 << sz(v));
for (l = 1; l < x; ++l) {
ll num = 0, val = 0, ff = 0;
ff += 1 << j;
for (k = 0; k < sz(v); ++k) {
if (l & (1 << k)) {
ff += 1 << k;
} else
num += 1 << v[k];
}
amax(dp[i], dp[num] + dp2[ff]);
}
}
// cout<<dp[5]<<endl;
cout << dp[sub - 1] << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef runSieve
sieve();
#endif
#ifdef NCR
initialize();
#endif
int TESTS = 1;
// cin>>TESTS;
while (TESTS--)
_runtimeTerror_();
cerr << "\n" << _time_;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define M 1000000007
#define MM 998244353
#define ll long long
#define pb push_back
#define mem0(a) memset(a, 0, sizeof(a))
#define mem1(a) memset(a, -1, sizeof(a))
#define memf(a) memset(a, false, sizeof(a))
#define all(v) v.begin(), v.end()
#define sz(a) (ll) a.size()
#define F first
#define S second
#define PI 3.1415926536
#define INF 2000000000000000000
#define endl "\n"
#define _time_ 1.0 * clock() / CLOCKS_PER_SEC
// RNG based on mersenne_twister
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
ll power(ll b, ll e, ll m) {
if (e == 0)
return 1;
if (e & 1)
return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
ll power(ll b, ll e) {
if (e == 0)
return 1;
if (e & 1)
return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U> static inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> static inline void amax(T &x, U y) {
if (x < y)
x = y;
}
const int N = 17;
ll a[20][20], n;
ll dp[1 << N], dp2[1 << N];
int _runtimeTerror_() {
mem1(dp);
ll i, j, k, l;
cin >> n;
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < n; ++j)
cin >> a[i][j];
}
ll sub = (1 << n);
for (i = 1; i < sub; ++i) {
dp2[i] = 0;
vector<ll> v;
for (j = n - 1; j >= 0; --j)
if (i & (1 << j))
v.pb(j);
ll ss = sz(v);
for (ll k = 0; k < ss; ++k) {
for (ll l = k; l < ss; ++l)
dp2[i] += a[v[k]][v[l]];
}
}
dp[0] = 0;
for (i = 1; i < sub; ++i) {
for (j = n - 1; j >= 0; --j) {
if (i & (1 << j))
break;
}
dp[i] = dp[i & (~(1 << j))];
vector<ll> v;
for (k = j - 1; k >= 0; --k)
if (i & (1 << k))
v.pb(k);
ll x = (1 << sz(v));
for (l = 1; l < x; ++l) {
ll num = 0, val = 0, ff = 0;
ff += 1 << j;
for (k = 0; k < sz(v); ++k) {
if (l & (1 << k)) {
ff += 1 << v[k];
} else
num += 1 << v[k];
}
amax(dp[i], dp[num] + dp2[ff]);
}
}
// cout<<dp[5]<<endl;
cout << dp[sub - 1] << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef runSieve
sieve();
#endif
#ifdef NCR
initialize();
#endif
int TESTS = 1;
// cin>>TESTS;
while (TESTS--)
_runtimeTerror_();
cerr << "\n" << _time_;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 986,180 | 986,181 | u675249209 | cpp |
p03180 | #include <iostream>
#include <vector>
#define endl '\n'
using namespace std;
const int MAXN = 16;
long long points[MAXN][MAXN], dp[(1 << MAXN) + 3], total[(1 << MAXN) + 3];
void calc_dp(int mask, int curr, int ind, vector<int> missing) {
if (ind == (int)missing.size()) {
int new_mask = (mask | curr);
dp[new_mask] = max(dp[new_mask], dp[mask] + total[curr]);
return;
}
calc_dp(mask, curr, ind + 1, missing);
calc_dp(mask, (curr | (1 << missing[ind])), ind + 1, missing);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
for (int i2 = 0; i2 < n; ++i2) {
cin >> points[i][i2];
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = 0; i < n; ++i) {
for (int i2 = i + 1; i2 < n; ++i2) {
if ((mask & (1 << i)) and (mask & (1 << i2))) {
total[mask] += points[i][i2];
}
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
vector<int> missing;
for (int i = 0; i < n; ++i) {
if (!(mask & (1 << i))) {
missing.push_back(i);
}
}
calc_dp(mask, 0, 0, missing);
}
cout << dp[(1 << n) - 1] << endl;
return 0;
} | #include <iostream>
#include <vector>
#define endl '\n'
using namespace std;
const int MAXN = 16;
long long points[MAXN][MAXN], dp[(1 << MAXN) + 3], total[(1 << MAXN) + 3];
void calc_dp(int mask, int curr, int ind, const vector<int> &missing) {
if (ind == (int)missing.size()) {
int new_mask = (mask | curr);
dp[new_mask] = max(dp[new_mask], dp[mask] + total[curr]);
return;
}
calc_dp(mask, curr, ind + 1, missing);
calc_dp(mask, (curr | (1 << missing[ind])), ind + 1, missing);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
for (int i2 = 0; i2 < n; ++i2) {
cin >> points[i][i2];
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = 0; i < n; ++i) {
for (int i2 = i + 1; i2 < n; ++i2) {
if ((mask & (1 << i)) and (mask & (1 << i2))) {
total[mask] += points[i][i2];
}
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
vector<int> missing;
for (int i = 0; i < n; ++i) {
if (!(mask & (1 << i))) {
missing.push_back(i);
}
}
calc_dp(mask, 0, 0, missing);
}
cout << dp[(1 << n) - 1] << endl;
return 0;
} | [] | 986,184 | 986,185 | u099203212 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define P pair<int, int>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pb push_back
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
constexpr int INF = 1000000000000000000;
constexpr int mod = 1000000007;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int kaijo[2000010];
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool prime(int a) {
if (a == 1)
return false;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
void init_fact() {
kaijo[0] = 1;
for (int i = 1; i <= 2000000; i++) {
kaijo[i] = kaijo[i - 1] * i;
kaijo[i] %= mod;
}
}
int modpow(int a, int b) {
if (b == 0)
return 1;
if (b % 2)
return modpow(a, b - 1) * a % mod;
int memo = modpow(a, b / 2);
return memo * memo % mod;
}
int comb(int a, int b) {
if (!kaijo[0])
init_fact();
return kaijo[a] * modpow(kaijo[a - b], mod - 2) % mod *
modpow(kaijo[b], mod - 2) % mod;
}
int inv(int x) {
x = modpow(x, mod - 2);
return x;
}
bool kosa(double ax, double ay, double bx, double by, double cx, double cy,
double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return tc * td < 0 && ta * tb < 0;
}
int n, a[16][16], dp[(1 << 16)], memo[(1 << 16)];
signed main() {
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(i, (1 << n)) {
rep(j, n) {
if ((i >> j) & 1) {
rep(k, n) {
if (j < k) {
if ((i >> k) & 1) {
memo[i] += a[j][k];
}
}
}
}
}
}
rep(i, (1 << n)) {
for (int j = (i - 1) & i; j > 0; j = (j - 1) & i) {
chmax(dp[i], dp[i - j] + memo[j]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define P pair<int, int>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pb push_back
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
constexpr int INF = 1000000000000000000;
constexpr int mod = 1000000007;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int kaijo[2000010];
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool prime(int a) {
if (a == 1)
return false;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
void init_fact() {
kaijo[0] = 1;
for (int i = 1; i <= 2000000; i++) {
kaijo[i] = kaijo[i - 1] * i;
kaijo[i] %= mod;
}
}
int modpow(int a, int b) {
if (b == 0)
return 1;
if (b % 2)
return modpow(a, b - 1) * a % mod;
int memo = modpow(a, b / 2);
return memo * memo % mod;
}
int comb(int a, int b) {
if (!kaijo[0])
init_fact();
return kaijo[a] * modpow(kaijo[a - b], mod - 2) % mod *
modpow(kaijo[b], mod - 2) % mod;
}
int inv(int x) {
x = modpow(x, mod - 2);
return x;
}
bool kosa(double ax, double ay, double bx, double by, double cx, double cy,
double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return tc * td < 0 && ta * tb < 0;
}
int n, a[16][16], dp[(1 << 16)], memo[(1 << 16)];
signed main() {
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(i, (1 << n)) {
rep(j, n) {
if ((i >> j) & 1) {
rep(k, n) {
if (j < k) {
if ((i >> k) & 1) {
memo[i] += a[j][k];
}
}
}
}
}
}
rep(i, (1 << n)) {
for (int j = i; j > 0; j = (j - 1) & i) {
chmax(dp[i], dp[i - j] + memo[j]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove"
] | 986,186 | 986,187 | u006686215 | cpp |
p03180 | #include <bits/stdc++.h>
#define ll long long
#define ss second
#define ff first
#define pb push_back
using namespace std;
const int N = 1e6 + 69;
int n;
ll A[20][20], cost[(1 << 20)], dp[(1 << 20)];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> A[i][j];
}
}
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((mask & (1 << i)) && (mask & (1 << j)))
cost[mask] += A[i][j];
}
}
}
for (int mask = (1 << n) - 1; mask > 0; mask--) {
for (int mask1 = mask; mask1 > 0; mask1 &= (mask1 - 1)) {
dp[mask ^ mask1] = max(dp[mask ^ mask1], dp[mask] + cost[mask1]);
}
}
cout << dp[0] << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define ss second
#define ff first
#define pb push_back
using namespace std;
const int N = 1e6 + 69;
int n;
ll A[20][20], cost[(1 << 20)], dp[(1 << 20)];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> A[i][j];
}
}
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((mask & (1 << i)) && (mask & (1 << j)))
cost[mask] += A[i][j];
}
}
}
for (int mask = (1 << n) - 1; mask > 0; mask--) {
for (int mask1 = mask; mask1 > 0; mask1 = mask & (mask1 - 1)) {
dp[mask ^ mask1] = max(dp[mask ^ mask1], dp[mask] + cost[mask1]);
}
}
cout << dp[0] << endl;
}
| [
"assignment.value.change",
"control_flow.loop.for.update.change",
"assignment.change"
] | 986,188 | 986,189 | u954494895 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n;
ll a[25][25];
ll power[(1 << 16)];
ll dp[(1 << 16)], ans[(1 << 16)];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
power[(1 << i)] = i;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i < (1 << n); ++i) {
ll lb = (i & (-i)), x = power[lb], st = i ^ lb;
dp[i] = dp[st];
for (int j = 0; j < n; ++j) {
if ((1 << j) & st) {
dp[i] += a[j][x];
}
}
}
for (int i = 1; i < (1 << n); ++i) {
for (int j = i; j; j = ((j - 1) & i)) {
ans[i] = max(ans[i], dp[j] + dp[i ^ j]);
}
}
cout << ans[(1 << n) - 1] << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n;
ll a[25][25];
ll power[(1 << 16)];
ll dp[(1 << 16)], ans[(1 << 16)];
int main() {
cin >> n;
for (ll i = 0; i < n; ++i) {
power[(1 << i)] = i;
}
for (ll i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
for (ll i = 1; i < (1 << n); ++i) {
ll lb = (i & (-i)), x = power[lb], st = i ^ lb;
dp[i] = dp[st];
for (int j = 0; j < n; ++j) {
if ((1 << j) & st) {
dp[i] += a[j][x];
}
}
}
for (ll i = 1; i < (1 << n); ++i) {
for (ll j = i; j; j = ((j - 1) & i)) {
ans[i] = max(ans[i], dp[j] + ans[i ^ j]);
}
}
cout << ans[(1 << n) - 1] << '\n';
return 0;
} | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 986,190 | 986,191 | u734192058 | cpp |
p03180 | #include <bits/stdc++.h>
#define ll long long
#define int ll
#define mod 1000000007
#define pb push_back
#define pob pop_back
#define f1 first
#define s2 second
#define N 50
#define K 100005
#define bol (int)ceil((say - 1) / 2.0)
#define PII pair<int, int>
#define PIII pair<int, PII>
#define PIIII pair<PII, PII>
#define PIIIII pair<PIII, PII>
#define PIIIIII pair<PIII, PIII>
using namespace std;
int n;
int dizi[N][N];
int dp[N][K];
int fun(int crr, int mask, int local, int ans, ll gcrr);
int dpf(int crr, int mask) {
if (crr >= (n + 1)) {
return 0;
}
if (dp[crr][mask] != -1)
return dp[crr][mask];
if (mask & (1 << crr))
return dpf(crr + 1, mask);
dp[crr][mask] = fun(crr, mask, (1 << crr), 0, crr);
return dp[crr][mask];
}
int fun(int crr, int mask, int local, int ans, int gcrr) {
int mx = 0, top;
mx = max(mx, ans + dpf(gcrr + 1, mask | local));
for (int i = (crr + 1); i <= (n); i++) {
if (mask & (1 << i))
continue;
top = 0;
for (int j = 1; j <= n; j++) {
if (local & (1 << j)) {
top += dizi[i][j];
}
}
mx = max(mx, fun(i, mask, local | (1 << i), ans + top, gcrr));
}
// printf("%lld\n",mx );
return mx;
}
int32_t main() {
// freopen("a.gir","r",stdin);
// freopen("a.cik","w",stdout);
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%lld", &dizi[i][j]);
}
}
memset(dp, -1, sizeof(dp));
printf("a%lld\n", dpf(1, 0));
}
| #include <bits/stdc++.h>
#define ll long long
#define int ll
#define mod 1000000007
#define pb push_back
#define pob pop_back
#define f1 first
#define s2 second
#define N 50
#define K 100005
#define bol (int)ceil((say - 1) / 2.0)
#define PII pair<int, int>
#define PIII pair<int, PII>
#define PIIII pair<PII, PII>
#define PIIIII pair<PIII, PII>
#define PIIIIII pair<PIII, PIII>
using namespace std;
int n;
int dizi[N][N];
int dp[N][K];
int fun(int crr, int mask, int local, int ans, ll gcrr);
int dpf(int crr, int mask) {
if (crr >= (n + 1)) {
return 0;
}
if (dp[crr][mask] != -1)
return dp[crr][mask];
if (mask & (1 << crr))
return dpf(crr + 1, mask);
dp[crr][mask] = fun(crr, mask, (1 << crr), 0, crr);
return dp[crr][mask];
}
int fun(int crr, int mask, int local, int ans, int gcrr) {
int mx = 0, top;
mx = max(mx, ans + dpf(gcrr + 1, mask | local));
for (int i = (crr + 1); i <= (n); i++) {
if (mask & (1 << i))
continue;
top = 0;
for (int j = 1; j <= n; j++) {
if (local & (1 << j)) {
top += dizi[i][j];
}
}
mx = max(mx, fun(i, mask, local | (1 << i), ans + top, gcrr));
}
// printf("%lld\n",mx );
return mx;
}
int32_t main() {
// freopen("a.gir","r",stdin);
// freopen("a.cik","w",stdout);
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%lld", &dizi[i][j]);
}
}
memset(dp, -1, sizeof(dp));
printf("%lld\n", dpf(1, 0));
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 986,194 | 986,195 | u368885250 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
const int MXN = (1 << 4) + 2;
int n, in[MXN][MXN];
long long dp[1 << MXN], pp[1 << MXN];
void npt() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> in[i][j];
}
}
}
void rec(int i, vector<int> nt, long long sc, int msk, int gp) {
if (i == (int)nt.size()) {
dp[msk] = max(dp[msk], sc + pp[gp]);
return;
}
rec(i + 1, nt, sc, msk, gp);
rec(i + 1, nt, sc, msk ^ (1 << nt[i]), gp ^ (1 << nt[i]));
}
void slv() {
for (int i = 1; i <= n; i++)
dp[i] = INT_MIN;
dp[0] = 0;
for (int msk = 0; msk < (1 << n); msk++)
for (int i = 0; i < n; i++)
if (msk & (1 << i))
for (int j = i + 1; j < n; j++)
if (msk & (1 << j))
pp[msk] += in[i][j];
for (int msk = 0; msk < (1 << n); msk++) {
vector<int> nt;
for (int i = 0; i < n; i++)
if (!(msk & (1 << i)))
nt.push_back(i);
rec(0, nt, dp[msk], msk, 0);
}
}
void tpt() { cout << dp[(1 << n) - 1] << endl; }
int main() {
npt();
slv();
tpt();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MXN = (1 << 4);
int n, in[MXN][MXN];
long long dp[1 << MXN], pp[1 << MXN];
void npt() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> in[i][j];
}
}
}
void rec(int i, const vector<int> &nt, long long sc, int msk, int gp) {
if (i == (int)nt.size()) {
dp[msk] = max(dp[msk], sc + pp[gp]);
return;
}
rec(i + 1, nt, sc, msk, gp);
rec(i + 1, nt, sc, msk ^ (1 << nt[i]), gp ^ (1 << nt[i]));
}
void slv() {
for (int i = 1; i <= n; i++)
dp[i] = INT_MIN;
dp[0] = 0;
for (int msk = 0; msk < (1 << n); msk++)
for (int i = 0; i < n; i++)
if (msk & (1 << i))
for (int j = i + 1; j < n; j++)
if (msk & (1 << j))
pp[msk] += in[i][j];
for (int msk = 0; msk < (1 << n); msk++) {
vector<int> nt;
for (int i = 0; i < n; i++)
if (!(msk & (1 << i)))
nt.push_back(i);
rec(0, nt, dp[msk], msk, 0);
}
}
void tpt() { cout << dp[(1 << n) - 1] << endl; }
int main() {
npt();
slv();
tpt();
return 0;
}
| [
"expression.operation.binary.remove"
] | 986,196 | 986,197 | u134058207 | cpp |
p03180 | #include <cstdio>
int n;
long long v[20][20];
long long cost[1 << 17];
long long dp[1 << 17];
long long best;
inline int max(int a, int b) { return a > b ? a : b; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%lld", &v[i][j]);
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (i & (1 << j) && i & (1 << k))
cost[i] += v[j][k];
}
}
}
for (int i = 1; i < (1 << n); i++) {
for (int j = i; j > 0; j = (j - 1) & i) {
dp[i] = max(dp[i], cost[j] / 2 + dp[i ^ j]);
best = max(best, dp[i]);
}
}
printf("%lld", best);
}
| #include <cstdio>
int n;
long long v[20][20];
long long cost[1 << 17];
long long dp[1 << 17];
long long best;
inline long long max(long long a, long long b) { return a > b ? a : b; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%lld", &v[i][j]);
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (i & (1 << j) && i & (1 << k))
cost[i] += v[j][k];
}
}
}
for (int i = 1; i < (1 << n); i++) {
for (int j = i; j > 0; j = (j - 1) & i) {
dp[i] = max(dp[i], cost[j] / 2 + dp[i ^ j]);
best = max(best, dp[i]);
}
}
printf("%lld", best);
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 986,198 | 986,199 | u427697910 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
#define mod 1000000007
#define INF (1LL << 60)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, a, n) for (int i = (a), i##_len = (n); i < i##_len; ++i)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define YES puts("YES")
#define Yes puts("Yes")
#define NO puts("NO")
#define No puts("No")
#define ALL(v) (v).begin(), (v).end()
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#if 1
//-------------
// DUMPマクロ
// https://www.creativ.xyz/dump-cpp-652/
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
#endif
int N;
int a[16][16];
int dp[(1 << 16) - 1];
int cost[(1 << 16) - 1];
void solve() {
cin >> N;
rep(i, N) rep(j, N) cin >> a[i][j];
rep(i, (1LL << N) - 1) {
rep(j, N) rep1(k, j + 1, N) {
if ((i & (1LL << j)) && (i & (1LL << k)))
cost[i] += a[j][k];
}
}
for (int used = 0; used < (1 << N); used++) { // 使用済みのビット
int unused = used ^ ((1 << N) - 1); // 未使用のビット
for (int use = unused; use > 0;
use = (use - 1) & unused) { // unusedの部分集合を列挙
if (use <= used)
continue;
// dp遷移を書く
dp[used | use] = max(dp[used | use], dp[used] + cost[use]);
}
}
cout << dp[(1 << N) - 1] << endl;
}
signed main() {
cout << fixed << setprecision(18) << endl;
cerr << fixed << setprecision(18) << endl;
solve();
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
#define mod 1000000007
#define INF (1LL << 60)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, a, n) for (int i = (a), i##_len = (n); i < i##_len; ++i)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define YES puts("YES")
#define Yes puts("Yes")
#define NO puts("NO")
#define No puts("No")
#define ALL(v) (v).begin(), (v).end()
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#if 1
//-------------
// DUMPマクロ
// https://www.creativ.xyz/dump-cpp-652/
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
#endif
int N;
int a[16][16];
int dp[(1 << 16) - 1];
int cost[(1 << 16) - 1];
void solve() {
cin >> N;
rep(i, N) rep(j, N) cin >> a[i][j];
rep(i, (1LL << N)) {
rep(j, N) rep1(k, j, N) {
if ((i & (1LL << j)) && (i & (1LL << k)))
cost[i] += a[j][k];
}
}
for (int used = 0; used < (1 << N); used++) { // 使用済みのビット
int unused = used ^ ((1 << N) - 1); // 未使用のビット
for (int use = unused; use > 0;
use = (use - 1) & unused) { // unusedの部分集合を列挙
if (use <= used)
continue;
// dp遷移を書く
dp[used | use] = max(dp[used | use], dp[used] + cost[use]);
}
}
cout << dp[(1 << N) - 1] << endl;
}
signed main() {
cout << fixed << setprecision(18) << endl;
cerr << fixed << setprecision(18) << endl;
solve();
}
| [
"expression.operation.binary.remove"
] | 986,200 | 986,201 | u592610268 | cpp |
p03180 | #define fast ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#include <bits/stdc++.h>
using namespace std;
#define sqr 340
#define mid (l + r) / 2
#define pb push_back
#define ppb pop_back
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define ins insert
#define era erase
#define C continue
#define mem(dp, i) memset(dp, i, sizeof(dp))
#define mset multiset
typedef long long ll;
typedef short int si;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
const ll mod = 1000000007;
const ll inf = 1e18;
const ld pai = acos(-1);
ll n;
ll a[19][19];
ll dp[(1 << 16) + 9];
ll cost[(1 << 16) + 9];
ll calc(ll mask) {
ll sum = 0;
for (ll i = 0; i < n; i++) {
for (ll j = i + 1; j < n; j++) {
if ((mask & (1 << i)) && (mask & (1 << j))) {
sum += a[i][j];
}
}
}
return sum;
}
int main() {
cin >> n;
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (ll i = 0; i < (1 << n); i++)
cost[i] = calc(i);
for (ll i = 1; i < (1 << n); i++) {
for (ll j = i; j; j = (j - 1) & i) {
dp[i] = max(dp[i], dp[j] + cost[i ^ j]);
}
}
cout << dp[(1 << n) - 1] << endl;
}
| #define fast ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#include <bits/stdc++.h>
using namespace std;
#define sqr 340
#define mid (l + r) / 2
#define pb push_back
#define ppb pop_back
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define ins insert
#define era erase
#define C continue
#define mem(dp, i) memset(dp, i, sizeof(dp))
#define mset multiset
typedef long long ll;
typedef short int si;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
const ll mod = 1000000007;
const ll inf = 1e18;
const ld pai = acos(-1);
ll n;
ll a[19][19];
ll dp[(1 << 16) + 9];
ll cost[(1 << 16) + 9];
ll calc(ll mask) {
ll sum = 0;
for (ll i = 0; i < n; i++) {
for (ll j = i + 1; j < n; j++) {
if ((mask & (1 << i)) && (mask & (1 << j))) {
sum += a[i][j];
}
}
}
return sum;
}
int main() {
cin >> n;
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (ll i = 0; i < (1 << n); i++)
cost[i] = calc(i);
for (ll i = 1; i < (1 << n); i++) {
for (ll j = i; j; j = (j - 1) & i) {
dp[i] = max(dp[i], dp[i ^ j] + cost[j]);
}
}
cout << dp[(1 << n) - 1] << endl;
}
| [
"assignment.change",
"expression.operation.binary.remove"
] | 986,202 | 986,203 | u600501848 | cpp |
p03180 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<pair<ll, ll>, pair<ll, ll>>
#define pll pair<ll, ll>
#define vii vector<int>
#define vll vector<ll>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep2(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define ERASE(v) v.erase(unique(v.begin(), v.end()), v.end())
// #define int ll
using namespace std;
const ll INF = (1 << 30) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n, a[100][100];
ll dp[1 << 20];
ll use[1 << 20];
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(bit, (1 << n)) {
rep(i, n) {
rep2(j, i, n) {
if ((bit & (1 << i)) && (bit & (1 << j)))
use[bit] += a[i][j];
}
}
}
/*
rep(bit,(1<<n)){
for(ll mask=bit;mask>0;mask=(mask-1)&bit){
dp[bit]=max(dp[bit],dp[bit-mask]+use[mask]);
}
}
*/
rep(bit, (1 << n)) {
ll unused = bit ^ ((1 << n) - 1);
for (ll mask = unused; mask > 0; mask = (mask - 1) & unused) {
dp[bit | unused] = max(dp[bit | unused], dp[bit] + use[mask]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<pair<ll, ll>, pair<ll, ll>>
#define pll pair<ll, ll>
#define vii vector<int>
#define vll vector<ll>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep2(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define ERASE(v) v.erase(unique(v.begin(), v.end()), v.end())
// #define int ll
using namespace std;
const ll INF = (1 << 30) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n, a[100][100];
ll dp[1 << 17];
ll use[1 << 17];
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(bit, (1 << n)) {
rep(i, n) {
rep2(j, i, n) {
if ((bit & (1 << i)) && (bit & (1 << j)))
use[bit] += a[i][j];
}
}
}
/*
rep(bit,(1<<n)){
for(ll mask=bit;mask>0;mask=(mask-1)&bit){
dp[bit]=max(dp[bit],dp[bit-mask]+use[mask]);
}
}
*/
rep(bit, (1 << n)) {
ll unused = bit ^ ((1 << n) - 1);
for (ll mask = unused; mask > 0; mask = (mask - 1) & unused) {
dp[bit | mask] = max(dp[bit | mask], dp[bit] + use[mask]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 986,212 | 986,213 | u241367243 | cpp |
p03180 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<pair<ll, ll>, pair<ll, ll>>
#define pll pair<ll, ll>
#define vii vector<int>
#define vll vector<ll>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep2(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define ERASE(v) v.erase(unique(v.begin(), v.end()), v.end())
// #define int ll
using namespace std;
const ll INF = (1 << 30) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n, a[100][100];
ll dp[1 << 17];
ll use[1 << 17];
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(bit, (1 << n)) {
rep(i, n) {
rep2(j, i, n) {
if ((bit & (1 << i)) && (bit & (1 << j)))
use[bit] += a[i][j];
}
}
}
/*
rep(bit,(1<<n)){
for(ll mask=bit;mask>0;mask=(mask-1)&bit){
dp[bit]=max(dp[bit],dp[bit-mask]+use[mask]);
}
}
*/
rep(bit, (1 << n)) {
ll unused = bit ^ ((1 << n) - 1);
for (ll mask = unused; mask > 0; mask = (mask - 1) & unused) {
dp[bit | unused] = max(dp[bit | unused], dp[bit] + use[mask]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<pair<ll, ll>, pair<ll, ll>>
#define pll pair<ll, ll>
#define vii vector<int>
#define vll vector<ll>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep2(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define ERASE(v) v.erase(unique(v.begin(), v.end()), v.end())
// #define int ll
using namespace std;
const ll INF = (1 << 30) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n, a[100][100];
ll dp[1 << 17];
ll use[1 << 17];
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(bit, (1 << n)) {
rep(i, n) {
rep2(j, i, n) {
if ((bit & (1 << i)) && (bit & (1 << j)))
use[bit] += a[i][j];
}
}
}
/*
rep(bit,(1<<n)){
for(ll mask=bit;mask>0;mask=(mask-1)&bit){
dp[bit]=max(dp[bit],dp[bit-mask]+use[mask]);
}
}
*/
rep(bit, (1 << n)) {
ll unused = bit ^ ((1 << n) - 1);
for (ll mask = unused; mask > 0; mask = (mask - 1) & unused) {
dp[bit | mask] = max(dp[bit | mask], dp[bit] + use[mask]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.value.change",
"call.arguments.change"
] | 986,214 | 986,213 | u241367243 | cpp |
p03180 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<pair<ll, ll>, pair<ll, ll>>
#define pll pair<ll, ll>
#define vii vector<int>
#define vll vector<ll>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep2(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define ERASE(v) v.erase(unique(v.begin(), v.end()), v.end())
// #define int ll
using namespace std;
const ll INF = (1 << 30) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n, a[100][100];
ll dp[1 << 16];
ll use[1 << 16];
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(bit, (1 << n)) {
rep(i, n) {
rep2(j, i, n) {
if ((bit & (1 << i)) && (bit & (1 << j)))
use[bit] += a[i][j];
}
}
}
rep(bit, (1 << n)) {
for (ll mask = bit; mask > 0; mask = (mask - 1) & bit) {
dp[bit] = max(dp[bit], dp[bit - mask] + use[mask]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<pair<ll, ll>, pair<ll, ll>>
#define pll pair<ll, ll>
#define vii vector<int>
#define vll vector<ll>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep2(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define ERASE(v) v.erase(unique(v.begin(), v.end()), v.end())
// #define int ll
using namespace std;
const ll INF = (1 << 30) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n, a[100][100];
ll dp[1 << 17];
ll use[1 << 17];
cin >> n;
rep(i, n) {
rep(j, n) { cin >> a[i][j]; }
}
rep(bit, (1 << n)) {
rep(i, n) {
rep2(j, i, n) {
if ((bit & (1 << i)) && (bit & (1 << j)))
use[bit] += a[i][j];
}
}
}
rep(bit, (1 << n)) {
for (ll mask = bit; mask > 0; mask = (mask - 1) & bit) {
dp[bit] = max(dp[bit], dp[bit - mask] + use[mask]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 986,218 | 986,217 | u241367243 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b) {
double ax = a.first, ay = a.second, bx = b.first, by = b.second;
return atan2(by - ay, bx - ax);
}
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
int N;
vector<vector<ll>> a;
vector<ll> memo(1 << 18, 0);
vector<bool> flg(1 << 18, false);
ll rec(int S) {
if (flg[S])
return memo[S];
ll tmp = 0;
rep(i, N) repr(j, i + 1, N) if (S & 1 << i && S & 1 << j) tmp += a[i][j];
for (int T = S - 1; T > 0; T = (T - 1) & S) {
chmax(tmp, rec(T) + rec(S ^ T));
}
flg[S] = true;
return memo[S] = tmp;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> N;
a.resize(N, vector<ll>(N, 0));
rep(i, N) rep(j, N) cin >> a[i][j];
cout << rec((1 << N) - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b) {
double ax = a.first, ay = a.second, bx = b.first, by = b.second;
return atan2(by - ay, bx - ax);
}
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
int N;
vector<vector<ll>> a;
vector<ll> memo(1 << 18, 0);
vector<bool> flg(1 << 18, false);
ll rec(int S) {
if (flg[S])
return memo[S];
ll tmp = 0;
rep(i, N) repr(j, i + 1, N) if (S & 1 << i && S & 1 << j) tmp += a[i][j];
for (int T = (S - 1) & S; T > 0; T = (T - 1) & S) {
chmax(tmp, rec(T) + rec(S ^ T));
}
flg[S] = true;
return memo[S] = tmp;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> N;
a.resize(N, vector<ll>(N, 0));
rep(i, N) rep(j, N) cin >> a[i][j];
cout << rec((1 << N) - 1) << endl;
} | [
"control_flow.loop.for.initializer.change"
] | 986,220 | 986,221 | u052332717 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
int n;
vector<ll> memo(1 << 20, 0);
vector<bool> flg(1 << 20, false);
vector<vector<ll>> a(20, vector<ll>(20, 0));
ll f(int S) {
if (flg[S])
return memo[S];
flg[S] = true;
ll tmp = 0;
rep(i, n) repr(j, i + 1, n) if (S & 1 << i && S & 1 << j) tmp += a[i][j];
for (int T = S; T > 0; T = (T - 1) & S)
chmax(tmp, f(T) + f(S ^ T));
return tmp;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) rep(j, n) cin >> a[i][j];
cout << f((1 << n) - 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
int n;
vector<ll> memo(1 << 20, 0);
vector<bool> flg(1 << 20, false);
vector<vector<ll>> a(20, vector<ll>(20, 0));
ll f(int S) {
if (flg[S])
return memo[S];
flg[S] = true;
ll tmp = 0;
rep(i, n) repr(j, i + 1, n) if (S & 1 << i && S & 1 << j) tmp += a[i][j];
for (int T = S; T > 0; T = (T - 1) & S)
chmax(tmp, f(T) + f(S ^ T));
return memo[S] = tmp;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) rep(j, n) cin >> a[i][j];
cout << f((1 << n) - 1) << endl;
return 0;
}
| [
"assignment.change"
] | 986,222 | 986,223 | u052332717 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef pair<pii, ll> piii;
typedef pair<ll, pii> ipii;
#define MOD 1000000007
#define mod(a) ((a) % MOD)
#define pb push_back
#define ft first
#define sd second
#define mp make_pair
#define dbg(x) cerr << #x << " = " << x << "\n"
#define dbg2(x, y) cerr << #x << " = " << x << " , " << #y << " = " << y << "\n"
#define dbg3(x, y, z) \
cerr << #x << " = " << x << " , " << #y << " = " << y << " , " << #z \
<< " = " << z << "\n"
#define INF (1LL << 60)
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef
tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>
ordered_set;*/
#define sync \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define all(v) v.begin(), v.end()
#define endl '\n'
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll powm(ll base, ll exp, ll mod = MOD) {
base %= mod;
ll ans = 1;
while (exp) {
if (exp & 1LL)
ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
#define N (1LL << 16)
int a[16][16];
int dp[N];
int dp1[N];
int main() {
sync;
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> a[i][j];
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = 0; j < 16; j++) {
if ((i & (1 << j))) {
dp[i] = dp[i ^ (1 << j)];
for (int k = j + 1; k < 16; k++) {
if ((i & (1 << k)))
dp[i] += a[j][k];
}
break;
}
}
}
for (int i = 1; i < N; i++) {
dp1[i] = dp[i];
for (int j = (i - 1) & i; j > 0; j = (j - 1) & i) {
int mask = i ^ j;
dp1[i] = max(dp1[i], dp1[j] + dp[mask]);
}
}
cout << dp1[N - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef pair<pii, ll> piii;
typedef pair<ll, pii> ipii;
#define MOD 1000000007
#define mod(a) ((a) % MOD)
#define pb push_back
#define ft first
#define sd second
#define mp make_pair
#define dbg(x) cerr << #x << " = " << x << "\n"
#define dbg2(x, y) cerr << #x << " = " << x << " , " << #y << " = " << y << "\n"
#define dbg3(x, y, z) \
cerr << #x << " = " << x << " , " << #y << " = " << y << " , " << #z \
<< " = " << z << "\n"
#define INF (1LL << 60)
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef
tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>
ordered_set;*/
#define sync \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define all(v) v.begin(), v.end()
#define endl '\n'
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll powm(ll base, ll exp, ll mod = MOD) {
base %= mod;
ll ans = 1;
while (exp) {
if (exp & 1LL)
ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
#define N (1LL << 16)
ll a[16][16];
ll dp[N];
ll dp1[N];
int main() {
sync;
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> a[i][j];
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = 0; j < 16; j++) {
if ((i & (1 << j))) {
dp[i] = dp[i ^ (1 << j)];
for (int k = j + 1; k < 16; k++) {
if ((i & (1 << k)))
dp[i] += a[j][k];
}
break;
}
}
}
for (int i = 1; i < N; i++) {
dp1[i] = dp[i];
for (int j = (i - 1) & i; j > 0; j = (j - 1) & i) {
int mask = i ^ j;
dp1[i] = max(dp1[i], dp1[j] + dp[mask]);
}
}
cout << dp1[N - 1] << endl;
} | [
"variable_declaration.type.change"
] | 986,224 | 986,225 | u906162718 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
const ll mod = 1000000007;
ll dp[3005][3005]; // dp[i][j]: a[i]まで条件を満たすうち,
// a[i]より大きい未使用のvalがj個
int main() {
// cout.precision(10);
ll n;
string s;
cin >> n >> s;
s = "##" + s;
for (int i = 0; i < n; i++) {
dp[1][i] = 1;
}
for (int index = 2; index <= n; index++) {
for (int before = 0; before < n; before++) {
if (s[index] == '>') {
dp[index][before] = (dp[index][before] + dp[index - 1][before]) % mod;
dp[index][n - index + 1] =
(dp[index][n - index + 1] - dp[index - 1][before] + mod) % mod;
/*
for(int after = before; after <= n - index; after++){
dp[index][after] = (dp[index][after] + dp[index - 1][before]) % mod;
}
continue;
*/
} else {
dp[index][0] = (dp[index][0] + dp[index - 1][before]) % mod;
dp[index][before] =
(dp[index][before] - dp[index - 1][before] % mod) % mod;
/*
for(int after = 0; after < before; after++){
dp[index][after] = (dp[index][after] + dp[index - 1][before]) % mod;
}
*/
}
}
for (int i = 0; i <= n; i++) {
dp[index][i + 1] = (dp[index][i + 1] + dp[index][i]) % mod;
}
}
cout << dp[n][0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
const ll mod = 1000000007;
ll dp[3005][3005]; // dp[i][j]: a[i]まで条件を満たすうち,
// a[i]より大きい未使用のvalがj個
int main() {
// cout.precision(10);
ll n;
string s;
cin >> n >> s;
s = "##" + s;
for (int i = 0; i < n; i++) {
dp[1][i] = 1;
}
for (int index = 2; index <= n; index++) {
for (int before = 0; before < n; before++) {
if (s[index] == '>') {
dp[index][before] = (dp[index][before] + dp[index - 1][before]) % mod;
dp[index][n - index + 1] =
(dp[index][n - index + 1] - dp[index - 1][before] + mod) % mod;
/*
for(int after = before; after <= n - index; after++){
dp[index][after] = (dp[index][after] + dp[index - 1][before]) % mod;
}
continue;
*/
} else {
dp[index][0] = (dp[index][0] + dp[index - 1][before]) % mod;
dp[index][before] =
(dp[index][before] - dp[index - 1][before] + mod) % mod;
/*
for(int after = 0; after < before; after++){
dp[index][after] = (dp[index][after] + dp[index - 1][before]) % mod;
}
*/
}
}
for (int i = 0; i <= n; i++) {
dp[index][i + 1] = (dp[index][i + 1] + dp[index][i]) % mod;
}
}
cout << dp[n][0] << endl;
return 0;
}
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 986,230 | 986,231 | u980655160 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using tpl = tuple<int, int, int>;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
const int mod = 1000000000 + 7;
int N;
string S;
ll dp[3010][3010];
ll sums[3010];
int main() {
cin >> N;
cin >> S;
for (int pos = N - 1; pos >= 0; pos--) {
for (int upper = 0; upper <= N; upper++) {
ll ans = 0;
if (pos == N - 1) {
ans = 1;
} else {
// int pos = N - (lower + upper) - 1;
// より大きい
if (S[pos] == '<') {
if (upper > 0) {
(ans += (sums[upper] - sums[0])) %= mod;
}
// // いくつめのupperを利用するか
// for(int i = 1; i <= upper; i++){
// (ans += dp[pos + 1][upper - i]) %= mod;
// }
}
// より小さい
else {
int lower = N - ((pos + 1) + upper);
if (lower > 0) {
(ans += (sums[upper + lower] - sums[upper])) %= mod;
}
// // いくつめのlowerを利用するか
// for(int i = 1; i <= lower; i++){
// (ans += dp[pos + 1][upper + (i - 1)]) %= mod;
// }
}
}
dp[pos][upper] = ans;
}
sums[0] = 0;
for (int i = 0; i <= N; i++) {
sums[i + 1] = (sums[i] + dp[pos][i]) % mod;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
(ans += dp[0][N - i - 1]) %= mod;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using tpl = tuple<int, int, int>;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
const int mod = 1000000000 + 7;
int N;
string S;
ll dp[3010][3010];
ll sums[3010];
int main() {
cin >> N;
cin >> S;
for (int pos = N - 1; pos >= 0; pos--) {
for (int upper = 0; upper <= N; upper++) {
ll ans = 0;
if (pos == N - 1) {
ans = 1;
} else {
// int pos = N - (lower + upper) - 1;
// より大きい
if (S[pos] == '<') {
if (upper > 0) {
(ans += (sums[upper] - sums[0] + mod)) %= mod;
}
// // いくつめのupperを利用するか
// for(int i = 1; i <= upper; i++){
// (ans += dp[pos + 1][upper - i]) %= mod;
// }
}
// より小さい
else {
int lower = N - ((pos + 1) + upper);
if (lower > 0) {
(ans += (sums[upper + lower] - sums[upper] + mod)) %= mod;
}
// // いくつめのlowerを利用するか
// for(int i = 1; i <= lower; i++){
// (ans += dp[pos + 1][upper + (i - 1)]) %= mod;
// }
}
}
dp[pos][upper] = ans;
}
sums[0] = 0;
for (int i = 0; i <= N; i++) {
sums[i + 1] = (sums[i] + dp[pos][i]) % mod;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
(ans += dp[0][N - i - 1]) %= mod;
}
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 986,232 | 986,233 | u489053642 | cpp |
p03179 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, dp[3333][3333], sum[3333][3333];
char s[3333];
bool f[3333]; // 0:< 1:>
int main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n - 1; i++) {
if (s[i] == '<')
f[i + 2] = 0;
else
f[i + 2] = 1;
}
dp[1][1] = 1;
sum[1][1] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i; j++) {
if (f[i])
dp[i][j] = sum[i - 1][j - 1];
else
dp[i][j] = (sum[i - 1][i - 1] - sum[i - 1][j - 1]) % mod;
}
for (int j = 1; j <= i; j++)
sum[i][j] = (sum[i][j - 1] + dp[i][j]) % mod;
}
printf("%d\n", sum[n][n]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, dp[3333][3333], sum[3333][3333];
char s[3333];
bool f[3333]; // 0:< 1:>
int main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n - 1; i++) {
if (s[i] == '<')
f[i + 2] = 0;
else
f[i + 2] = 1;
}
dp[1][1] = 1;
sum[1][1] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i; j++) {
if (f[i])
dp[i][j] = sum[i - 1][j - 1];
else
dp[i][j] = (sum[i - 1][i - 1] - sum[i - 1][j - 1]) % mod;
}
for (int j = 1; j <= i; j++)
sum[i][j] = (sum[i][j - 1] + dp[i][j]) % mod;
}
printf("%d\n", (sum[n][n] + mod) % mod);
return 0;
} | [
"call.arguments.change"
] | 986,234 | 986,235 | u900309151 | cpp |
p03179 | #ifndef ___CLASS_MODINT
#define ___CLASS_MODINT
#include <cstdint>
template <std::uint32_t mod> class modint {
private:
std::uint32_t n;
public:
modint() : n(0){};
modint(std::uint64_t n_) : n(n_ % mod){};
bool operator==(const modint &m) const { return n == m.n; }
bool operator!=(const modint &m) const { return n != m.n; }
std::uint32_t get() const { return n; }
modint &operator+=(const modint &m) {
n += m.n;
n = (n < mod ? n : n - mod);
return *this;
}
modint &operator-=(const modint &m) {
n += mod - m.n;
n = (n < mod ? n : n - mod);
return *this;
}
modint &operator*=(const modint &m) {
n = std::uint64_t(n) * m.n % mod;
return *this;
}
modint operator+(const modint &m) const { return modint(*this) += m; }
modint operator-(const modint &m) const { return modint(*this) -= m; }
modint operator*(const modint &m) const { return modint(*this) *= m; }
modint binpow(std::uint64_t b) const {
modint ans = 1, m = modint(*this);
while (b) {
if (b & 1)
ans *= m;
m *= m;
b >>= 1;
}
return ans;
}
modint inv() { return (*this).binpow(mod - 2); }
};
#endif // ___CLASS_MODINT
using modulo = modint<1000000007>;
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
string S;
cin >> N >> S;
vector<vector<modulo>> dp(N);
dp[0].push_back(modulo(1));
for (int i = 1; i < N; ++i) {
dp[i].resize(i + 1, modulo(0));
if (S[i] == '<') {
for (int j = 1; j <= i; ++j) {
dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
}
} else {
for (int j = i - 1; j >= 0; --j) {
dp[i][j] = dp[i][j + 1] + dp[i - 1][j];
}
}
}
modulo ans = 0;
for (int i = 0; i < N; ++i) {
ans += dp[N - 1][i];
}
cout << ans.get() << '\n';
return 0;
} | #ifndef ___CLASS_MODINT
#define ___CLASS_MODINT
#include <cstdint>
template <std::uint32_t mod> class modint {
private:
std::uint32_t n;
public:
modint() : n(0){};
modint(std::uint64_t n_) : n(n_ % mod){};
bool operator==(const modint &m) const { return n == m.n; }
bool operator!=(const modint &m) const { return n != m.n; }
std::uint32_t get() const { return n; }
modint &operator+=(const modint &m) {
n += m.n;
n = (n < mod ? n : n - mod);
return *this;
}
modint &operator-=(const modint &m) {
n += mod - m.n;
n = (n < mod ? n : n - mod);
return *this;
}
modint &operator*=(const modint &m) {
n = std::uint64_t(n) * m.n % mod;
return *this;
}
modint operator+(const modint &m) const { return modint(*this) += m; }
modint operator-(const modint &m) const { return modint(*this) -= m; }
modint operator*(const modint &m) const { return modint(*this) *= m; }
modint binpow(std::uint64_t b) const {
modint ans = 1, m = modint(*this);
while (b) {
if (b & 1)
ans *= m;
m *= m;
b >>= 1;
}
return ans;
}
modint inv() { return (*this).binpow(mod - 2); }
};
#endif // ___CLASS_MODINT
using modulo = modint<1000000007>;
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
string S;
cin >> N >> S;
vector<vector<modulo>> dp(N);
dp[0].push_back(modulo(1));
for (int i = 1; i < N; ++i) {
dp[i].resize(i + 1, modulo(0));
if (S[i - 1] == '<') {
for (int j = 1; j <= i; ++j) {
dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
}
} else {
for (int j = i - 1; j >= 0; --j) {
dp[i][j] = dp[i][j + 1] + dp[i - 1][j];
}
}
}
modulo ans = 0;
for (int i = 0; i < N; ++i) {
ans += dp[N - 1][i];
}
cout << ans.get() << '\n';
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 986,242 | 986,243 | u837745858 | cpp |
p03180 | #include "bits/stdc++.h"
#include <bits/stdc++.h>
using namespace std;
// #define int long long
#ifndef bhupixb
#define var(...)
#define stl(...)
#endif
#define rep(i, a, b) for (int i = a; i <= (int)b; ++i)
#define f first
#define s second
#define single_test
int dp[1 << 16];
void solve() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(n));
for (auto &it : a) {
for (int &x : it) {
cin >> x;
}
}
// var(n);
// return;
const int mx = 1 << n;
var(mx);
// return;
for (int mask = 0; mask < mx; mask++) {
bitset<16> ok(mask);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (ok[i] && ok[j]) {
dp[mask] += a[i][j];
}
}
}
}
for (int mask = 0; mask < mx; ++mask) {
for (int s = mask; s > 0; s = (s - 1) & mask) {
dp[mask] = max(dp[mask], dp[s] + dp[s ^ mask]);
}
}
cout << dp[(1 << n) - 1] << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
#ifndef single_test
cin >> t;
#endif
for (int i = 1; i <= t; ++i) {
// cout << "Case #" << i << ": ";
solve();
}
return 0;
} | #include "bits/stdc++.h"
#include <bits/stdc++.h>
using namespace std;
#define int long long
#ifndef bhupixb
#define var(...)
#define stl(...)
#endif
#define rep(i, a, b) for (int i = a; i <= (int)b; ++i)
#define f first
#define s second
#define single_test
int dp[1 << 16];
void solve() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(n));
for (auto &it : a) {
for (int &x : it) {
cin >> x;
}
}
// var(n);
// return;
const int mx = 1 << n;
var(mx);
// return;
for (int mask = 0; mask < mx; mask++) {
bitset<16> ok(mask);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (ok[i] && ok[j]) {
dp[mask] += a[i][j];
}
}
}
}
for (int mask = 0; mask < mx; ++mask) {
for (int s = mask; s > 0; s = (s - 1) & mask) {
dp[mask] = max(dp[mask], dp[s] + dp[s ^ mask]);
}
}
cout << dp[(1 << n) - 1] << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
#ifndef single_test
cin >> t;
#endif
for (int i = 1; i <= t; ++i) {
// cout << "Case #" << i << ": ";
solve();
}
return 0;
} | [] | 986,250 | 986,251 | u450009898 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
#define _USE_MATH_DEFINES
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// DON'T USE THESE MACROS DURING ICPC PRACTICE
#define For(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define Down(i, n) for (int i = n - 1; i >= 0; i--)
#define DOWN(i, a, b) for (int i = b; i >= a; i--)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef complex<ld> pt;
typedef vector<pt> pol;
typedef vector<int> vi;
const char nl = '\n';
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll MOD = 1e9 + 7;
const ld EPS = 1e-10;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int n;
cin >> n;
int adj[n][n];
For(i, n) {
For(j, n) { cin >> adj[i][j]; }
}
ll cost[1 << n], dp[1 << n];
for (int bm = 1; bm < 1 << n; bm++) {
cost[bm] = 0;
for (int i = 0; i < n; i++) {
if (bm & 1 << i) {
for (int j = 0; j < i; j++) {
if (bm & 1 << j) {
cost[bm] += adj[i][j];
}
}
}
}
dp[bm] = 0;
for (int sm = (bm - 1) & bm; sm > 0; sm = (sm - 1) & bm) {
dp[bm] = max(dp[bm], dp[sm] + cost[sm ^ bm]);
}
}
cout << dp[(1 << n) - 1] << nl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define _USE_MATH_DEFINES
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// DON'T USE THESE MACROS DURING ICPC PRACTICE
#define For(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define Down(i, n) for (int i = n - 1; i >= 0; i--)
#define DOWN(i, a, b) for (int i = b; i >= a; i--)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef complex<ld> pt;
typedef vector<pt> pol;
typedef vector<int> vi;
const char nl = '\n';
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll MOD = 1e9 + 7;
const ld EPS = 1e-10;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int n;
cin >> n;
int adj[n][n];
For(i, n) {
For(j, n) { cin >> adj[i][j]; }
}
ll cost[1 << n], dp[1 << n];
for (int bm = 1; bm < 1 << n; bm++) {
cost[bm] = 0;
for (int i = 0; i < n; i++) {
if (bm & 1 << i) {
for (int j = 0; j < i; j++) {
if (bm & 1 << j) {
cost[bm] += adj[i][j];
}
}
}
}
dp[bm] = cost[bm];
for (int sm = (bm - 1) & bm; sm > 0; sm = (sm - 1) & bm) {
dp[bm] = max(dp[bm], dp[sm] + cost[sm ^ bm]);
}
}
cout << dp[(1 << n) - 1] << nl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 986,264 | 986,265 | u645327277 | cpp |
p03180 | #define D(x) cout << #x " = " << x << endl
#define DD(x, y) cout << "(" #x ", " #y ") = (" << x << ", " << y << ")" << endl
#define DDD(x, y, z) \
cout << "(" #x ", " #y ", " #z ") = (" << x << ", " << y << ", " << z << ")" \
<< endl
#define DV(v) \
for (auto __macro_vi : v) { \
cout << __macro_vi << " "; \
} \
cout << endl;
#define DA(a, n) \
for (int __macro_i = 0; __macro_i < n; ++__macro_i) { \
cout << a[__macro_i] << " "; \
} \
cout << endl;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define ALL(v) (v).begin(), (v).end()
#include <cassert>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int cost[1 << 16];
ll dp[1 << 16];
int n;
int a[16][16];
int main() {
cin >> n;
REP(i, n) REP(j, n) cin >> a[i][j];
REP(mask, 1 << n) {
ll tmp = 0;
REP(i, n) {
for (int j = i + 1; j < n; ++j) {
if (((mask >> i) & 1) == 0)
continue;
if (((mask >> j) & 1) == 0)
continue;
tmp += a[i][j];
}
}
cost[mask] = tmp;
}
for (int mask = 0; mask < (1 << n); ++mask) {
dp[mask] = 0;
for (int mask2 = mask; mask2 > 0; mask2 = (mask2 - 1) & mask) {
dp[mask] = max(dp[mask], dp[mask ^ mask2] + cost[mask2]);
}
// DD(mask, dp[mask]);
}
cout << dp[(1 << n) - 1] << endl;
}
| #define D(x) cout << #x " = " << x << endl
#define DD(x, y) cout << "(" #x ", " #y ") = (" << x << ", " << y << ")" << endl
#define DDD(x, y, z) \
cout << "(" #x ", " #y ", " #z ") = (" << x << ", " << y << ", " << z << ")" \
<< endl
#define DV(v) \
for (auto __macro_vi : v) { \
cout << __macro_vi << " "; \
} \
cout << endl;
#define DA(a, n) \
for (int __macro_i = 0; __macro_i < n; ++__macro_i) { \
cout << a[__macro_i] << " "; \
} \
cout << endl;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define ALL(v) (v).begin(), (v).end()
#include <cassert>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
ll cost[1 << 16];
ll dp[1 << 16];
int n;
int a[16][16];
int main() {
cin >> n;
REP(i, n) REP(j, n) cin >> a[i][j];
REP(mask, 1 << n) {
ll tmp = 0;
REP(i, n) {
for (int j = i + 1; j < n; ++j) {
if (((mask >> i) & 1) == 0)
continue;
if (((mask >> j) & 1) == 0)
continue;
tmp += a[i][j];
}
}
cost[mask] = tmp;
}
for (int mask = 0; mask < (1 << n); ++mask) {
dp[mask] = 0;
for (int mask2 = mask; mask2 > 0; mask2 = (mask2 - 1) & mask) {
dp[mask] = max(dp[mask], dp[mask ^ mask2] + cost[mask2]);
}
// DD(mask, dp[mask]);
}
cout << dp[(1 << n) - 1] << endl;
}
| [
"variable_declaration.type.change"
] | 986,266 | 986,267 | u652737716 | cpp |
p03180 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define all(x) x.begin(), x.end()
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef long long ll;
typedef long double ld;
const int mod = 1e9 + 7;
const ll inf = 3e18 + 5;
int add(int a, int b) { return (a += b) < mod ? a : a - mod; }
int mul(int a, int b) { return 1LL * a * b % mod; }
int sub(int a, int b) { return (a -= b) < 0 ? a + mod : a; }
int n, a[17][17], cost[1 << 16];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> a[i][j];
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((mask & (1 << i)) && (mask & (1 << j)))
cost[mask] += a[i][j];
}
}
}
for (int mask = 0; mask < (1 << n); mask++) {
for (int sbmask = mask; sbmask > 0; sbmask = (sbmask - 1) & mask) {
cost[mask] = max(cost[mask], cost[sbmask] + cost[mask ^ sbmask]);
}
}
cout << cost[(1 << n) - 1];
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define all(x) x.begin(), x.end()
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef long long ll;
typedef long double ld;
const int mod = 1e9 + 7;
const ll inf = 3e18 + 5;
int add(int a, int b) { return (a += b) < mod ? a : a - mod; }
int mul(int a, int b) { return 1LL * a * b % mod; }
int sub(int a, int b) { return (a -= b) < 0 ? a + mod : a; }
int n, a[17][17];
ll cost[1 << 16];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> a[i][j];
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((mask & (1 << i)) && (mask & (1 << j)))
cost[mask] += a[i][j];
}
}
}
for (int mask = 0; mask < (1 << n); mask++) {
for (int sbmask = mask; sbmask > 0; sbmask = (sbmask - 1) & mask) {
cost[mask] = max(cost[mask], cost[sbmask] + cost[mask ^ sbmask]);
}
}
cout << cost[(1 << n) - 1];
} | [] | 986,272 | 986,273 | u975336337 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const int MaxN = 16;
int dp[1 << MaxN];
int a[MaxN][MaxN];
int n;
long long gc[1 << MaxN];
long long groupCost(int mask) {
long long ans = 0;
for (int i1 = 0; i1 < n; ++i1)
if (mask & (1 << i1))
for (int i2 = i1 + 1; i2 < n; ++i2)
if (mask & (1 << i2))
ans += a[i1][i2];
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("input.txt", "r", stdin);
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
cin >> a[i][j];
for (int mask = 1; mask < (1 << n); ++mask)
gc[mask] = dp[mask] = groupCost(mask);
for (int mask = 1; mask < (1 << n); ++mask) {
for (int subMask = (mask & (mask - 1)); subMask;
subMask = mask & (subMask - 1)) {
dp[mask] = max(dp[mask], dp[subMask] + dp[mask ^ subMask]);
}
}
cout << dp[(1 << n) - 1] << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const int MaxN = 16;
long long dp[1 << MaxN];
int a[MaxN][MaxN];
int n;
long long gc[1 << MaxN];
long long groupCost(int mask) {
long long ans = 0;
for (int i1 = 0; i1 < n; ++i1)
if (mask & (1 << i1))
for (int i2 = i1 + 1; i2 < n; ++i2)
if (mask & (1 << i2))
ans += a[i1][i2];
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("input.txt", "r", stdin);
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
cin >> a[i][j];
for (int mask = 1; mask < (1 << n); ++mask)
gc[mask] = dp[mask] = groupCost(mask);
for (int mask = 1; mask < (1 << n); ++mask) {
for (int subMask = (mask & (mask - 1)); subMask;
subMask = mask & (subMask - 1)) {
dp[mask] = max(dp[mask], dp[subMask] + dp[mask ^ subMask]);
}
}
cout << dp[(1 << n) - 1] << '\n';
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 986,274 | 986,275 | u784576081 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int N = 100001;
int n;
int arr[16][16];
int cost[(1 << 16)];
int LG[(1 << 16) + 1];
int dp[1 << 16];
int solve(int msk) {
if (msk == (1 << n) - 1)
return 0;
int rem = ~msk & ((1 << n) - 1);
int &res = dp[msk];
if (res != -1)
return res;
res = -1e9;
for (int x = rem; x; x = (x - 1) & rem)
res = max(res, solve(msk | x) + cost[x]);
return res;
}
string to_bin(int x) {
string res;
for (int i = 0; i < n; i++) {
res += (x & 1) + '0';
x /= 2;
}
reverse(res.begin(), res.end());
return res;
}
int main() {
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
for (int i = 0; i < 16; i++)
LG[(1 << i)] = i;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> arr[i][j];
for (int i = 0; i < (1 << n); i++) {
vector<int> v;
int x = i;
while (x) {
v.push_back(LG[x & -x]);
// cout << (x & -x) << endl;
x &= x - 1;
}
for (int j = 0; j < v.size(); j++) {
for (int k = 0; k < j; k++) {
cost[i] += arr[v[j]][v[k]];
}
}
// cout << i << ' ' << to_bin(i) << ' ' << cost[i] << endl;
}
memset(dp, -1, sizeof(dp));
cout << solve(0);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int N = 100001;
int n;
int arr[16][16];
ll cost[(1 << 16)];
int LG[(1 << 16) + 1];
ll dp[1 << 16];
ll solve(int msk) {
if (msk == (1 << n) - 1)
return 0;
int rem = ~msk & ((1 << n) - 1);
ll &res = dp[msk];
if (res != -1)
return res;
res = -1e9;
for (int x = rem; x; x = (x - 1) & rem)
res = max(res, solve(msk | x) + cost[x]);
return res;
}
string to_bin(int x) {
string res;
for (int i = 0; i < n; i++) {
res += (x & 1) + '0';
x /= 2;
}
reverse(res.begin(), res.end());
return res;
}
int main() {
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
for (int i = 0; i < 16; i++)
LG[(1 << i)] = i;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> arr[i][j];
for (int i = 0; i < (1 << n); i++) {
vector<int> v;
int x = i;
while (x) {
v.push_back(LG[x & -x]);
// cout << (x & -x) << endl;
x &= x - 1;
}
for (int j = 0; j < v.size(); j++) {
for (int k = 0; k < j; k++) {
cost[i] += arr[v[j]][v[k]];
}
}
// cout << i << ' ' << to_bin(i) << ' ' << cost[i] << endl;
}
memset(dp, -1, sizeof(dp));
cout << solve(0);
return 0;
}
| [
"variable_declaration.type.change"
] | 986,276 | 986,277 | u945097761 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 17;
int dp[(1 << MAXN)];
int main() {
#ifdef BLAT
freopen("input", "r", stdin);
#endif
int n;
cin >> n;
vector<vector<int>> v(n + 1, vector<int>(n + 1));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
cin >> v[i][j];
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int mask = 0; mask < (1 << n); ++mask) {
if ((mask & (1 << i)) && (mask & (1 << j)))
dp[mask] += v[i][j];
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
for (int m = mask; m; --m &= mask) {
dp[mask] = max(dp[mask], dp[m] + dp[mask - m]);
}
}
cout << dp[(1 << n) - 1] << '\n';
} | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 17;
long long dp[(1 << MAXN)];
int main() {
#ifdef BLAT
freopen("input", "r", stdin);
#endif
int n;
cin >> n;
vector<vector<int>> v(n + 1, vector<int>(n + 1));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
cin >> v[i][j];
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int mask = 0; mask < (1 << n); ++mask) {
if ((mask & (1 << i)) && (mask & (1 << j)))
dp[mask] += v[i][j];
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
for (int m = mask; m; --m &= mask) {
dp[mask] = max(dp[mask], dp[m] + dp[mask - m]);
}
}
cout << dp[(1 << n) - 1] << '\n';
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 986,283 | 986,284 | u745428834 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 16;
int dp[(1 << MAXN)];
int main() {
#ifdef BLAT
freopen("input", "r", stdin);
#endif
int n;
cin >> n;
vector<vector<int>> v(n + 1, vector<int>(n + 1));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
cin >> v[i][j];
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int mask = 0; mask < (1 << n); ++mask) {
if ((mask & (1 << i)) && (mask & (1 << j)))
dp[mask] += v[i][j];
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
for (int m = mask; m; --m &= mask) {
dp[mask] = max(dp[mask], dp[m] + dp[mask - m]);
}
}
cout << dp[(1 << n) - 1] << '\n';
} | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 17;
long long dp[(1 << MAXN)];
int main() {
#ifdef BLAT
freopen("input", "r", stdin);
#endif
int n;
cin >> n;
vector<vector<int>> v(n + 1, vector<int>(n + 1));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
cin >> v[i][j];
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int mask = 0; mask < (1 << n); ++mask) {
if ((mask & (1 << i)) && (mask & (1 << j)))
dp[mask] += v[i][j];
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
for (int m = mask; m; --m &= mask) {
dp[mask] = max(dp[mask], dp[m] + dp[mask - m]);
}
}
cout << dp[(1 << n) - 1] << '\n';
} | [
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 986,285 | 986,284 | u745428834 | cpp |
p03180 | // by xxj
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define lowbit(x) x & -x
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-10;
const ll linf = 1e18 + 7;
const ll hh = 523;
// const int mod=;
ll dp[(1 << 17)];
int a[17][17];
int n;
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
// cout<<i<<' '<<j<<' '<<a[i][j]<<endl;
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
continue;
}
// cout<<i<<' '<<j<<endl;
for (int k = j + 1; k < n; k++) {
if (i & (1 << k)) {
// cout<<i<<' '<<j<<' '<<k<<endl;
dp[i] += a[j][k];
}
}
}
}
// cout<<dp[(1<<n)-1]<<endl;
for (int i = 0; i < (1 << n); i++) {
for (int j = i; j; j = (j - 1) & i) {
// cout<<j<<' '<<i<<' '<<j-i<<endl;
dp[i] = max(dp[i], dp[j] + dp[i ^ j]);
}
}
printf("%I64d\n", dp[(1 << n) - 1]);
return 0;
}
/*
input:
*/ | // by xxj
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define lowbit(x) x & -x
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-10;
const ll linf = 1e18 + 7;
const ll hh = 523;
// const int mod=;
ll dp[(1 << 17)];
int a[17][17];
int n;
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
// cout<<i<<' '<<j<<' '<<a[i][j]<<endl;
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
continue;
}
// cout<<i<<' '<<j<<endl;
for (int k = j + 1; k < n; k++) {
if (i & (1 << k)) {
// cout<<i<<' '<<j<<' '<<k<<endl;
dp[i] += a[j][k];
}
}
}
}
// cout<<dp[(1<<n)-1]<<endl;
for (int i = 0; i < (1 << n); i++) {
for (int j = i; j; j = (j - 1) & i) {
// cout<<(i-j)<<' '<<(i^j)<<endl;
dp[i] = max(dp[i], dp[j] + dp[i ^ j]);
}
}
printf("%lld\n", dp[(1 << n) - 1]);
return 0;
}
/*
input:
*/ | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 986,288 | 986,289 | u776618439 | cpp |
p03180 | // by xxj
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define lowbit(x) x & -x
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-10;
const ll linf = 1e18 + 7;
const ll hh = 523;
// const int mod=;
ll dp[(1 << 17)];
int a[17][17];
int n;
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
// cout<<i<<' '<<j<<' '<<a[i][j]<<endl;
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
continue;
}
// cout<<i<<' '<<j<<endl;
for (int k = j + 1; k < n; k++) {
if (i & (1 << k)) {
// cout<<i<<' '<<j<<' '<<k<<endl;
dp[i] += a[j][k];
}
}
}
}
// cout<<dp[(1<<n)-1]<<endl;
for (int i = 0; i < (1 << n); i++) {
for (int j = i; j; j = (j - 1) & i) {
// cout<<j<<' '<<i<<' '<<j-i<<endl;
dp[i] = max(dp[i], dp[j] + dp[i ^ j]);
}
}
printf("%I64d\n", dp[(1 << n) - 1]);
return 0;
}
/*
input:
*/ | // by xxj
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define lowbit(x) x & -x
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-10;
const ll linf = 1e18 + 7;
const ll hh = 523;
// const int mod=;
ll dp[(1 << 17)];
int a[17][17];
int n;
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
// cout<<i<<' '<<j<<' '<<a[i][j]<<endl;
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
continue;
}
// cout<<i<<' '<<j<<endl;
for (int k = j + 1; k < n; k++) {
if (i & (1 << k)) {
// cout<<i<<' '<<j<<' '<<k<<endl;
dp[i] += a[j][k];
}
}
}
}
// cout<<dp[(1<<n)-1]<<endl;
for (int i = 0; i < (1 << n); i++) {
for (int j = i; j; j = (j - 1) & i) {
// cout<<j<<' '<<i<<' '<<j-i<<endl;
dp[i] = max(dp[i], dp[j] + dp[i ^ j]);
}
}
printf("%lld\n", dp[(1 << n) - 1]);
return 0;
}
/*
input:
*/ | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 986,288 | 986,290 | u776618439 | cpp |
p03180 | #include <iostream>
#include <vector>
using namespace std;
int dp[(1 << 16) + 7], v[17][17];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
cin >> v[i][j];
for (int i = 0; i < (1 << n); ++i) {
for (int j = 0; j < n; ++j) {
if ((i & (1 << j)) == 0)
continue;
for (int k = j + 1; k < n; ++k) {
if ((i & (1 << k)) == 0)
continue;
dp[i] += v[k][j];
}
}
for (int sm = ((i - 1) & i); sm > 0; sm = ((sm - 1) & i))
dp[i] = max(dp[i], dp[sm] + dp[i ^ sm]);
}
cout << dp[(1 << n) - 1];
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
long long dp[(1 << 16) + 7];
int v[17][17];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
cin >> v[i][j];
for (int i = 0; i < (1 << n); ++i) {
for (int j = 0; j < n; ++j) {
if ((i & (1 << j)) == 0)
continue;
for (int k = j + 1; k < n; ++k) {
if ((i & (1 << k)) == 0)
continue;
dp[i] += v[k][j];
}
}
for (int sm = ((i - 1) & i); sm > 0; sm = ((sm - 1) & i))
dp[i] = max(dp[i], dp[sm] + dp[i ^ sm]);
}
cout << dp[(1 << n) - 1];
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 986,291 | 986,292 | u084202355 | cpp |
p03180 | #include <bits/stdc++.h>
using namespace std;
int N;
long long arr[20][20];
long long pre[1 << 20];
long long dp[1 << 20];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < (1 << N); i++) {
for (int j = 0; j < N; j++) {
if (i & (1 << j)) {
for (int k = 0; k < N; k++) {
if (i & (1 << k)) {
dp[i] += arr[j][k];
}
}
}
}
dp[i] /= 2;
}
for (int i = 0; i < 1 << N; i++) {
for (int j = ((j - 1) & i); j > 0; j = ((j - 1) & i)) {
dp[i] = max(dp[i], dp[j] + dp[j ^ i]);
}
}
cout << dp[(1 << N) - 1] / 2 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int N;
long long arr[20][20];
long long pre[1 << 20];
long long dp[1 << 20];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < (1 << N); i++) {
for (int j = 0; j < N; j++) {
if (i & (1 << j)) {
for (int k = 0; k < N; k++) {
if (i & (1 << k)) {
dp[i] += arr[j][k];
}
}
}
}
dp[i] /= 2;
}
for (int i = 0; i < 1 << N; i++) {
for (int j = ((j - 1) & i); j > 0; j = ((j - 1) & i)) {
dp[i] = max(dp[i], dp[j] + dp[j ^ i]);
}
}
cout << dp[(1 << N) - 1] << endl;
}
| [
"expression.operation.binary.remove"
] | 986,293 | 986,294 | u937063359 | cpp |
p03181 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define maxn 100005
int n, m;
vector<int> tree[maxn];
int vis[maxn];
ll dp1[100005];
ll dp2[100005];
void solve2(ll par_ans, int src) {
vis[src] = 1;
dp2[src] = ((1 + par_ans) * dp1[src]) % m;
// cout<<src<<" "<<dp2[src]<<"\n";
vector<ll> prefix;
vector<ll> suffix;
for (auto child : tree[src]) {
if (!vis[child]) {
prefix.push_back(1 + dp1[child]);
suffix.push_back(1 + dp1[child]);
}
}
for (int i = 1; i < prefix.size(); i++)
prefix[i] = (prefix[i - 1] * prefix[i]) % m;
for (int i = suffix.size() - 2; i >= 0; i--)
suffix[i] = (suffix[i + 1] * suffix[i]) % m;
int cnt = 0;
for (auto child : tree[src]) {
if (!vis[child]) {
ll ways = (1 + par_ans);
ways = (cnt > 0) ? (ways * prefix[cnt - 1]) % m : ways;
ways = (cnt < suffix.size() - 1) ? (ways * suffix[cnt + 1]) % m : ways;
// cout<<ways<<"\n";
solve2(ways, child);
}
}
}
void solve1(int src) {
vis[src] = 1;
dp1[src] = 1;
for (auto child : tree[src]) {
if (!vis[child]) {
solve1(child);
dp1[src] = (dp1[src] * (1 + dp1[child])) % m;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
memset(dp1, 0, sizeof dp1);
memset(dp2, 0, sizeof dp2);
memset(vis, 0, sizeof vis);
solve1(1);
memset(vis, 0, sizeof vis);
solve2(0, 1);
for (int i = 1; i <= n; i++) {
cout << dp2[i] << "\n";
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define maxn 100005
int n, m;
vector<int> tree[maxn];
int vis[maxn];
ll dp1[100005];
ll dp2[100005];
void solve2(ll par_ans, int src) {
vis[src] = 1;
dp2[src] = ((1 + par_ans) * dp1[src]) % m;
// cout<<src<<" "<<dp2[src]<<"\n";
vector<ll> prefix;
vector<ll> suffix;
for (auto child : tree[src]) {
if (!vis[child]) {
prefix.push_back(1 + dp1[child]);
suffix.push_back(1 + dp1[child]);
}
}
for (int i = 1; i < prefix.size(); i++)
prefix[i] = (prefix[i - 1] * prefix[i]) % m;
for (int i = suffix.size() - 2; i >= 0; i--)
suffix[i] = (suffix[i + 1] * suffix[i]) % m;
int cnt = 0;
for (auto child : tree[src]) {
if (!vis[child]) {
ll ways = (1 + par_ans);
ways = (cnt > 0) ? (ways * prefix[cnt - 1]) % m : ways;
ways = (cnt < suffix.size() - 1) ? (ways * suffix[cnt + 1]) % m : ways;
// cout<<ways<<"\n";
solve2(ways, child);
cnt++;
}
}
}
void solve1(int src) {
vis[src] = 1;
dp1[src] = 1;
for (auto child : tree[src]) {
if (!vis[child]) {
solve1(child);
dp1[src] = (dp1[src] * (1 + dp1[child])) % m;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
memset(dp1, 0, sizeof dp1);
memset(dp2, 0, sizeof dp2);
memset(vis, 0, sizeof vis);
solve1(1);
memset(vis, 0, sizeof vis);
solve2(0, 1);
for (int i = 1; i <= n; i++) {
cout << dp2[i] << "\n";
}
}
| [
"expression.unary.arithmetic.add"
] | 986,581 | 986,584 | u412624159 | cpp |
p03181 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define ll long long
#define pi pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define INF 1000000000000000LL
using namespace std;
#define MAXN 110000
ll dp1[MAXN];
ll dp2[MAXN];
ll ans[MAXN];
ll n, m;
vector<vector<int>> edges(MAXN);
void dfs1(int now = 1, int p = -1) {
dp1[now] = 1;
for (auto c : edges[now]) {
if (c == p)
continue;
dfs1(c, now);
dp1[now] *= dp1[c];
dp1[now] %= m;
}
dp1[now]++;
}
void dfs2(int now = 1, int p = -1) {
if (p == -1)
dp2[now] = 1;
int ec = edges[now].size();
vector<ll> lprod(ec, 1);
rep(i, ec) {
int c = edges[now][i];
if (i)
lprod[i] *= lprod[i - 1];
if (c == p)
continue;
lprod[i] *= dp1[c];
lprod[i] %= m;
}
vector<ll> rprod(ec, 1);
rrep(i, ec) {
int c = edges[now][i];
if (i < ec - 1)
rprod[i] *= rprod[i + 1];
if (c == p)
continue;
rprod[i] *= dp1[c];
rprod[i] %= m;
}
rep(i, ec) {
int c = edges[now][i];
if (c == p)
continue;
dp2[c] = dp2[now];
if (i)
dp2[c] = dp2[c] * lprod[i - 1] % m;
if (i < ec - 1)
dp2[c] = dp2[c] * rprod[i + 1] % m;
dp2[c]++;
dfs2(c, now);
}
}
void dfs3(int now = 1, int p = -1) {
ans[now] = dp2[now];
for (auto c : edges[now]) {
if (c == p)
continue;
ans[now] *= dp1[c];
ans[now] %= m;
dfs3(c, now);
}
}
int main() {
cin >> n >> m;
rep(i, n - 1) {
int x, y;
cin >> x >> y;
edges[x].push_back(y);
edges[y].push_back(x);
}
dfs1();
dfs2();
dfs3();
rep1(i, n) cout << ans[i] << endl;
return 0;
rep1(i, n) cout << dp1[i] << ' ';
cout << endl;
rep1(i, n) cout << dp2[i] << ' ';
cout << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define ll long long
#define pi pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define INF 1000000000000000LL
using namespace std;
#define MAXN 110000
ll dp1[MAXN];
ll dp2[MAXN];
ll ans[MAXN];
ll n, m;
vector<vector<int>> edges(MAXN);
void dfs1(int now = 1, int p = -1) {
dp1[now] = 1;
for (auto c : edges[now]) {
if (c == p)
continue;
dfs1(c, now);
dp1[now] *= dp1[c];
dp1[now] %= m;
}
dp1[now]++;
}
void dfs2(int now = 1, int p = -1) {
if (p == -1)
dp2[now] = 1;
int ec = edges[now].size();
vector<ll> lprod(ec, 1);
rep(i, ec) {
int c = edges[now][i];
if (i)
lprod[i] *= lprod[i - 1];
if (c == p)
continue;
lprod[i] *= dp1[c];
lprod[i] %= m;
}
vector<ll> rprod(ec, 1);
rrep(i, ec) {
int c = edges[now][i];
if (i < ec - 1)
rprod[i] *= rprod[i + 1];
if (c == p)
continue;
rprod[i] *= dp1[c];
rprod[i] %= m;
}
rep(i, ec) {
int c = edges[now][i];
if (c == p)
continue;
dp2[c] = dp2[now];
if (i)
dp2[c] = dp2[c] * lprod[i - 1] % m;
if (i < ec - 1)
dp2[c] = dp2[c] * rprod[i + 1] % m;
dp2[c]++;
dfs2(c, now);
}
}
void dfs3(int now = 1, int p = -1) {
ans[now] = dp2[now];
for (auto c : edges[now]) {
if (c == p)
continue;
ans[now] *= dp1[c];
ans[now] %= m;
dfs3(c, now);
}
}
int main() {
cin >> n >> m;
rep(i, n - 1) {
int x, y;
cin >> x >> y;
edges[x].push_back(y);
edges[y].push_back(x);
}
dfs1();
dfs2();
dfs3();
rep1(i, n) cout << ans[i] % m << endl;
return 0;
rep1(i, n) cout << dp1[i] << ' ';
cout << endl;
rep1(i, n) cout << dp2[i] << ' ';
cout << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 986,591 | 986,592 | u021358975 | cpp |
p03181 | #include <bits/stdc++.h>
using namespace std;
#pragma region Macros
#define ll long long
#define ld long double
#define FOR(i, l, r) for (int i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for (int i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define pb push_back
#define eb emplace_back
#define SZ(x) ((ll)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T = ll> using V = vector<T>;
template <class T = ll> using VV = V<V<T>>;
using P = pair<ll, ll>;
#define VEC(type, name, size) \
V<type> name(size); \
IN(name)
#define VVEC(type, name, h, w) \
VV<type> name(h, V<type>(w)); \
IN(name)
#define INT(...) \
int __VA_ARGS__; \
IN(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
IN(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
IN(__VA_ARGS__)
#define CHAR(...) \
char __VA_ARGS__; \
IN(__VA_ARGS__)
#define DOUBLE(...) \
DOUBLE __VA_ARGS__; \
IN(__VA_ARGS__)
#define LD(...) \
LD __VA_ARGS__; \
IN(__VA_ARGS__)
template <class T> void scan(T a) { cin >> a; }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string &a) { cin >> a; }
template <class T> void scan(V<T> &);
template <class T, class L> void scan(pair<T, L> &);
template <class T> void scan(V<T> &a) {
for (auto &i : a)
scan(i);
}
template <class T, class L> void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
template <class T> inline void print(T x) { cout << x << '\n'; }
struct inputoutputfaster {
inputoutputfaster() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
}
} inputoutputfaster_;
template <class T> V<T> press(V<T> &x) {
V<T> res = x;
sort(all(res));
res.erase(unique(all(res)), res.end());
REP(i, SZ(x)) { x[i] = lower_bound(all(res), x[i]) - res.begin(); }
return res;
}
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;
}
inline void Yes(bool b = true) { cout << (b ? "Yes" : "No") << '\n'; }
inline void YES(bool b = true) { cout << (b ? "YES" : "NO") << '\n'; }
inline void err(bool b = true) {
if (b) {
cout << -1 << '\n';
exit(0);
}
}
template <class T> inline void fin(bool b = true, T e = 0) {
if (b) {
cout << e << '\n';
exit(0);
}
}
template <class T> T divup(T x, T y) { return (x + (y - 1)) / y; }
template <typename T> T pow(T a, long long n, T e = 1) {
T ret = e;
while (n) {
if (n & 1)
ret *= a;
a *= a;
n >>= 1;
}
return ret;
}
const ll INF = 1e18;
#pragma endregion
// Graph Template
struct Edge {
ll to, cost;
Edge(ll to, ll cost) : to(to), cost(cost) {}
bool operator<(const Edge &a) const { return cost < a.cost; }
};
using Graph = VV<>;
using WGraph = VV<Edge>;
void Read_Graph(Graph &g, int m, bool directed = false) {
REP(i, m) {
LL(u, v);
u--;
v--;
g[u].pb(v);
if (!directed)
g[v].pb(u);
}
}
void Read_Tree(Graph &g, bool directed = false) {
Read_Graph(g, SZ(g) - 1, directed);
}
void Read_Graph(WGraph &g, int m, bool directed = false) {
REP(i, m) {
LL(u, v, c);
u--;
v--;
g[u].pb({v, c});
if (!directed)
g[v].pb({u, c});
}
}
void Read_Tree(WGraph &g, bool directed = false) {
Read_Graph(g, SZ(g) - 1, directed);
}
template <typename T> struct ReRooting {
private:
using F = function<T(T, int)>;
using F2 = function<T(T, T)>;
int n;
Graph G;
VV<T> dp;
F f, g;
F2 merge;
T ide;
T dfs1(int p, int k) {
T res = ide;
int cnt = -1;
REP(i, SZ(G[k])) {
if (G[k][i] == p)
continue;
dp[k][i] = dfs1(k, G[k][i]);
res = merge(res, f(dp[k][i], G[k][i]));
}
return g(res, k);
}
void dfs2(int p, int k, T add) {
REP(i, SZ(G[k])) {
if (G[k][i] == p) {
dp[k][i] = add;
break;
}
}
V<T> pL(SZ(G[k]) + 1), pR(SZ(G[k]) + 1);
pL[0] = ide;
REP(i, SZ(G[k])) pL[i + 1] = merge(pL[i], f(dp[k][i], G[k][i]));
pR[SZ(G[k])] = 1;
RREP(i, SZ(G[k])) pR[i] = merge(pR[i + 1], f(dp[k][i], G[k][i]));
REP(i, SZ(G[k])) {
if (G[k][i] == p)
continue;
T val = merge(pL[i], pR[i + 1]);
dfs2(k, G[k][i], g(val, k));
}
}
void build(int root) {
REP(i, n) dp[i].resize(SZ(G[i]));
dfs1(-1, root);
dfs2(-1, root, ide);
}
public:
ReRooting(
Graph G_, F f_, F2 merge_, T ide_, F g_ = [](T a, int b) { return a; })
: G(G_), f(f_), merge(merge_), ide(ide_), g(g_) {
n = SZ(G);
dp.resize(n);
}
V<T> solve(int root = 0) {
V<T> vec(n);
REP(k, n) {
T res = ide;
REP(i, SZ(G[k])) res = merge(res, f(dp[k][i], G[k][i]));
vec[k] = g(res, k);
}
return vec;
}
};
int main() {
INT(n, m);
Graph G(n);
Read_Tree(G);
auto f = [&](ll a, int v) { return (a + 1) % m; };
auto merge = [&](ll a, ll b) { return a * b % m; };
ReRooting<ll> Re(G, f, merge, 1);
auto res = Re.solve();
for (auto v : res)
print(v);
} | #include <bits/stdc++.h>
using namespace std;
#pragma region Macros
#define ll long long
#define ld long double
#define FOR(i, l, r) for (int i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for (int i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define pb push_back
#define eb emplace_back
#define SZ(x) ((ll)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T = ll> using V = vector<T>;
template <class T = ll> using VV = V<V<T>>;
using P = pair<ll, ll>;
#define VEC(type, name, size) \
V<type> name(size); \
IN(name)
#define VVEC(type, name, h, w) \
VV<type> name(h, V<type>(w)); \
IN(name)
#define INT(...) \
int __VA_ARGS__; \
IN(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
IN(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
IN(__VA_ARGS__)
#define CHAR(...) \
char __VA_ARGS__; \
IN(__VA_ARGS__)
#define DOUBLE(...) \
DOUBLE __VA_ARGS__; \
IN(__VA_ARGS__)
#define LD(...) \
LD __VA_ARGS__; \
IN(__VA_ARGS__)
template <class T> void scan(T a) { cin >> a; }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string &a) { cin >> a; }
template <class T> void scan(V<T> &);
template <class T, class L> void scan(pair<T, L> &);
template <class T> void scan(V<T> &a) {
for (auto &i : a)
scan(i);
}
template <class T, class L> void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
template <class T> inline void print(T x) { cout << x << '\n'; }
struct inputoutputfaster {
inputoutputfaster() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
}
} inputoutputfaster_;
template <class T> V<T> press(V<T> &x) {
V<T> res = x;
sort(all(res));
res.erase(unique(all(res)), res.end());
REP(i, SZ(x)) { x[i] = lower_bound(all(res), x[i]) - res.begin(); }
return res;
}
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;
}
inline void Yes(bool b = true) { cout << (b ? "Yes" : "No") << '\n'; }
inline void YES(bool b = true) { cout << (b ? "YES" : "NO") << '\n'; }
inline void err(bool b = true) {
if (b) {
cout << -1 << '\n';
exit(0);
}
}
template <class T> inline void fin(bool b = true, T e = 0) {
if (b) {
cout << e << '\n';
exit(0);
}
}
template <class T> T divup(T x, T y) { return (x + (y - 1)) / y; }
template <typename T> T pow(T a, long long n, T e = 1) {
T ret = e;
while (n) {
if (n & 1)
ret *= a;
a *= a;
n >>= 1;
}
return ret;
}
const ll INF = 1e18;
#pragma endregion
// Graph Template
struct Edge {
ll to, cost;
Edge(ll to, ll cost) : to(to), cost(cost) {}
bool operator<(const Edge &a) const { return cost < a.cost; }
};
using Graph = VV<>;
using WGraph = VV<Edge>;
void Read_Graph(Graph &g, int m, bool directed = false) {
REP(i, m) {
LL(u, v);
u--;
v--;
g[u].pb(v);
if (!directed)
g[v].pb(u);
}
}
void Read_Tree(Graph &g, bool directed = false) {
Read_Graph(g, SZ(g) - 1, directed);
}
void Read_Graph(WGraph &g, int m, bool directed = false) {
REP(i, m) {
LL(u, v, c);
u--;
v--;
g[u].pb({v, c});
if (!directed)
g[v].pb({u, c});
}
}
void Read_Tree(WGraph &g, bool directed = false) {
Read_Graph(g, SZ(g) - 1, directed);
}
template <typename T> struct ReRooting {
private:
using F = function<T(T, int)>;
using F2 = function<T(T, T)>;
int n;
Graph G;
VV<T> dp;
F f, g;
F2 merge;
T ide;
T dfs1(int p, int k) {
T res = ide;
int cnt = -1;
REP(i, SZ(G[k])) {
if (G[k][i] == p)
continue;
dp[k][i] = dfs1(k, G[k][i]);
res = merge(res, f(dp[k][i], G[k][i]));
}
return g(res, k);
}
void dfs2(int p, int k, T add) {
REP(i, SZ(G[k])) {
if (G[k][i] == p) {
dp[k][i] = add;
break;
}
}
V<T> pL(SZ(G[k]) + 1), pR(SZ(G[k]) + 1);
pL[0] = ide;
REP(i, SZ(G[k])) pL[i + 1] = merge(pL[i], f(dp[k][i], G[k][i]));
pR[SZ(G[k])] = 1;
RREP(i, SZ(G[k])) pR[i] = merge(pR[i + 1], f(dp[k][i], G[k][i]));
REP(i, SZ(G[k])) {
if (G[k][i] == p)
continue;
T val = merge(pL[i], pR[i + 1]);
dfs2(k, G[k][i], g(val, k));
}
}
void build(int root) {
REP(i, n) dp[i].resize(SZ(G[i]));
dfs1(-1, root);
dfs2(-1, root, ide);
}
public:
ReRooting(
Graph G_, F f_, F2 merge_, T ide_, F g_ = [](T a, int b) { return a; })
: G(G_), f(f_), merge(merge_), ide(ide_), g(g_) {
n = SZ(G);
dp.resize(n);
}
V<T> solve(int root = 0) {
build(root);
V<T> vec(n);
REP(k, n) {
T res = ide;
REP(i, SZ(G[k])) res = merge(res, f(dp[k][i], G[k][i]));
vec[k] = g(res, k);
}
return vec;
}
};
int main() {
INT(n, m);
Graph G(n);
Read_Tree(G);
auto f = [&](ll a, int v) { return (a + 1) % m; };
auto merge = [&](ll a, ll b) { return a * b % m; };
ReRooting<ll> Re(G, f, merge, 1);
auto res = Re.solve();
for (auto v : res)
print(v);
} | [
"call.add"
] | 986,593 | 986,594 | u342075214 | cpp |
p03181 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll dp1[1000001];
ll dp2[1000001];
vector<ll> tree[100001];
ll m;
void solve2(ll source, bool vis[], ll parent_ans) {
vis[source] = 1;
dp2[source] = ((1 + parent_ans) * dp1[source]) % m;
vector<ll> prefix;
vector<ll> suffix;
for (ll child : tree[source]) {
if (!vis[child]) {
prefix.push_back(1 + dp1[child]);
suffix.push_back(1 + dp1[child]);
}
}
for (ll z = suffix.size() - 2; z >= 0; z--) {
suffix[z] = (suffix[z] * suffix[z + 1]) % m;
}
for (ll z = 1; z < prefix.size(); z++) {
prefix[z] = (prefix[z] * prefix[z - 1]) % m;
}
ll child_number = 0;
for (ll child : tree[source]) {
if (!vis[child]) {
ll ways = (1 + parent_ans);
ways =
(child_number > 0) ? (ways * (prefix[child_number - 1])) % m : ways;
ways = (child_number < (suffix.size() - 1))
? (ways * (suffix[child_number + 1])) % m
: ways;
solve2(child, vis, ways);
child_number++;
}
}
}
void solve1(ll source, bool vis[]) {
vis[source] = 1;
dp1[source] = 1;
for (ll child : tree[source]) {
if (!vis[child]) {
solve1(child, vis);
dp1[source] = (dp1[source] * (1 + dp1[child])) % m;
}
}
}
int main() {
ll n;
cin >> n >> m;
ll edge = n - 1;
while (edge--) {
ll u, v;
cin >> u >> v;
tree[u].push_back(v);
tree[v].push_back(u);
}
bool vis[n + 1];
memset(vis, 0, sizeof(vis));
solve1(1, vis);
memset(vis, 0, sizeof(vis));
solve2(1, vis, 0);
for (ll p = 1; p <= n; p++)
cout << dp2[p];
cout << endl;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll dp1[1000001];
ll dp2[1000001];
vector<ll> tree[100001];
ll m;
void solve2(ll source, bool vis[], ll parent_ans) {
vis[source] = 1;
dp2[source] = ((1 + parent_ans) * dp1[source]) % m;
vector<ll> prefix;
vector<ll> suffix;
for (ll child : tree[source]) {
if (!vis[child]) {
prefix.push_back(1 + dp1[child]);
suffix.push_back(1 + dp1[child]);
}
}
for (int z = suffix.size() - 2; z >= 0; z--) {
suffix[z] = (suffix[z] * suffix[z + 1]) % m;
}
for (int z = 1; z < prefix.size(); z++) {
prefix[z] = (prefix[z] * prefix[z - 1]) % m;
}
ll child_number = 0;
for (ll child : tree[source]) {
if (!vis[child]) {
ll ways = (1 + parent_ans);
ways =
(child_number > 0) ? (ways * (prefix[child_number - 1])) % m : ways;
ways = (child_number < (suffix.size() - 1))
? (ways * (suffix[child_number + 1])) % m
: ways;
solve2(child, vis, ways);
child_number++;
}
}
}
void solve1(ll source, bool vis[]) {
vis[source] = 1;
dp1[source] = 1;
for (ll child : tree[source]) {
if (!vis[child]) {
solve1(child, vis);
dp1[source] = (dp1[source] * (1 + dp1[child])) % m;
}
}
}
int main() {
ll n;
cin >> n >> m;
ll edge = n - 1;
while (edge--) {
ll u, v;
cin >> u >> v;
tree[u].push_back(v);
tree[v].push_back(u);
}
bool vis[n + 1];
memset(vis, false, sizeof(vis));
solve1(1, vis);
memset(vis, false, sizeof(vis));
solve2(1, vis, 0);
for (ll p = 1; p <= n; p++)
cout << dp2[p] << endl;
} | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"call.arguments.change"
] | 986,601 | 986,602 | u158107532 | cpp |
p03181 | #include <bits/stdc++.h>
#define M_PI 3.14159265358979323846 // pi
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> VI;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> t3;
typedef tuple<ll, ll, ll, ll> t4;
typedef tuple<ll, ll, ll, ll, ll> t5;
#define rep(a, n) for (ll a = 0; a < n; a++)
#define repi(a, b, n) for (ll a = b; a < n; a++)
using namespace std;
static const ll INF = 1e15;
template <typename T> static inline void chmax(T &ref, const T value) {
if (ref < value)
ref = value;
}
const ll mod = 1000000007;
ll m = 1e9 + 7;
class modint {
using u64 = std::int_fast64_t;
public:
u64 a;
modint(const u64 x = 0) noexcept : a(x % m) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= m) {
a -= m;
}
return *this;
}
modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += m;
}
a -= rhs.a;
return *this;
}
modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % m;
return *this;
}
};
ostream &operator<<(ostream &stream, const modint &data) {
stream << data.a;
return stream;
}
ll n;
vector<vector<int>> g;
vector<map<int, modint>> children;
modint dfs(int current, int prev) {
//頂点current が黒である組み合わせ
modint i = 1;
for (auto c : g[current]) {
if (c == prev)
continue;
modint t = dfs(c, current) + 1;
children[current][c] = t;
i *= t;
}
return i;
}
vector<modint> dp1;
void dfs2(int current, int parent, modint pValue) {
//親ノードの情報マージ
auto &child = children[current];
if (parent != -1) {
child[parent] = pValue + 1;
}
modint &ans = dp1[current];
ans = 1;
for (auto p : child) {
ans *= p.second;
}
// publish
auto csize = child.size();
if (csize <= 1)
return;
vector<int> next;
for (auto p : child) {
next.push_back(p.first);
}
auto b = child.begin();
auto rb = child.rbegin();
vector<modint> pos(csize);
vector<modint> neg(csize);
pos[0] = b->second;
neg[csize - 1] = rb->second;
for (int i = 1; i < csize; i++) {
b++;
rb++;
pos[i] = pos[i - 1] * b->second;
neg[csize - 1 - i] = neg[csize - i] * rb->second;
}
for (int i = 0; i < csize; i++) {
if (next[i] == parent)
continue;
modint p = 1;
if (i > 0) {
p *= pos[i - 1];
}
if (i < csize - 1) {
p *= neg[i + 1];
}
dfs2(next[i], current, p);
}
}
int main() {
cin >> n >> m;
g.resize(n);
dp1.resize(n);
children.resize(n);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0, -1);
dfs2(0, -1, 0);
rep(i, n) { cout << dp1[i] << endl; }
return 0;
}
| #include <bits/stdc++.h>
#define M_PI 3.14159265358979323846 // pi
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> VI;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> t3;
typedef tuple<ll, ll, ll, ll> t4;
typedef tuple<ll, ll, ll, ll, ll> t5;
#define rep(a, n) for (ll a = 0; a < n; a++)
#define repi(a, b, n) for (ll a = b; a < n; a++)
using namespace std;
static const ll INF = 1e15;
template <typename T> static inline void chmax(T &ref, const T value) {
if (ref < value)
ref = value;
}
const ll mod = 1000000007;
ll m = 1e9 + 7;
class modint {
using u64 = std::int_fast64_t;
public:
u64 a;
modint(const u64 x = 0) noexcept : a(x % m) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= m) {
a -= m;
}
return *this;
}
modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += m;
}
a -= rhs.a;
return *this;
}
modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % m;
return *this;
}
};
ostream &operator<<(ostream &stream, const modint &data) {
stream << data.a;
return stream;
}
ll n;
vector<vector<int>> g;
vector<map<int, modint>> children;
modint dfs(int current, int prev) {
//頂点current が黒である組み合わせ
modint i = 1;
for (auto c : g[current]) {
if (c == prev)
continue;
modint t = dfs(c, current) + 1;
children[current][c] = t;
i *= t;
}
return i;
}
vector<modint> dp1;
void dfs2(int current, int parent, modint pValue) {
//親ノードの情報マージ
auto &child = children[current];
if (parent != -1) {
child[parent] = pValue + 1;
}
modint &ans = dp1[current];
ans = 1;
for (auto p : child) {
ans *= p.second;
}
// publish
auto csize = child.size();
if (csize <= 0)
return;
vector<int> next;
for (auto p : child) {
next.push_back(p.first);
}
auto b = child.begin();
auto rb = child.rbegin();
vector<modint> pos(csize);
vector<modint> neg(csize);
pos[0] = b->second;
neg[csize - 1] = rb->second;
for (int i = 1; i < csize; i++) {
b++;
rb++;
pos[i] = pos[i - 1] * b->second;
neg[csize - 1 - i] = neg[csize - i] * rb->second;
}
for (int i = 0; i < csize; i++) {
if (next[i] == parent)
continue;
modint p = 1;
if (i > 0) {
p *= pos[i - 1];
}
if (i < csize - 1) {
p *= neg[i + 1];
}
dfs2(next[i], current, p);
}
}
int main() {
cin >> n >> m;
g.resize(n);
dp1.resize(n);
children.resize(n);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0, -1);
dfs2(0, -1, 0);
rep(i, n) { cout << dp1[i] << endl; }
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 986,610 | 986,611 | u834771741 | cpp |
p03181 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
// #define mod 1000000007
#define int long long int
#define double long double
#define inf (int)(1e15)
#define all(x) (x).begin(), (x).end()
#define pair pair<int, int>
typedef vector<int> vi; // Vector of long long
typedef vector<vi> vvi; // Vector of vi
typedef vector<pair> vii; // Vector of pairs
typedef vector<vii> vvii; // Vector of Vector of pairs
typedef vector<bool> vb; // Vector of bool
#define pq \
priority_queue // Max heap (To convert to min heap, use negative sign before
// every value)
#define ff first // For pairs
#define ss second
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, -1, 0, 1};
const int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1},
dy8[] = {1, -1, 1, 0, -1, 1, -0, -1};
#define testcases(t) \
int(t); \
cin >> (t); \
while ((t)--)
vi f, g;
vvi adj, prefix, suffix, tree;
vector<map<int, int>> pos;
int n, mod, u, v;
void dfs(int v, int p) {
f[v] = 1;
for (auto it : adj[v]) {
if (it == p)
continue;
tree[v].pb(it);
dfs(it, v);
f[v] *= (1 + f[it]);
f[v] %= mod;
}
for (int i = 0; i < tree[v].size(); i++) {
if (i == 0)
prefix[v].pb(1 + f[tree[v][i]]);
else
prefix[v].pb(prefix[v].back() * (1 + f[tree[v][i]]));
prefix[v].back() %= mod;
}
for (int i = (int)tree[v].size() - 1; i >= 0; i--) {
if (i == (tree[v].size() - 1))
suffix[v].pb(1 + f[tree[v][i]]);
else
suffix[v].pb(suffix[v].back() * (1 + f[tree[v][i]]));
suffix[v].back() %= mod;
}
return;
}
void dfs2(int v, int p) {
for (int i = 0; i < tree[v].size(); i++) {
int next = tree[v][i];
g[next] = f[next];
if (i > 0)
g[next] *= prefix[v][i - 1];
g[next] %= mod;
if (i < (tree[v].size() - 1))
g[next] *= suffix[v][tree[v].size() - i - 2];
g[next]++;
g[next] %= mod;
dfs2(next, v);
}
return;
}
signed main() {
cin >> n >> mod;
f.resize(n + 1, 1);
g.resize(n + 1, 1);
adj.resize(n + 1);
prefix.resize(n + 1);
suffix.resize(n + 1);
pos.resize(n + 1);
tree.resize(n + 1);
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].pb(v);
adj[v].pb(u);
}
dfs(1, 1);
g[1] = 1;
dfs2(1, 1);
for (int i = 1; i <= n; i++)
cout << ((f[i] * g[i]) % mod) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
// #define mod 1000000007
#define int long long int
#define double long double
#define inf (int)(1e15)
#define all(x) (x).begin(), (x).end()
#define pair pair<int, int>
typedef vector<int> vi; // Vector of long long
typedef vector<vi> vvi; // Vector of vi
typedef vector<pair> vii; // Vector of pairs
typedef vector<vii> vvii; // Vector of Vector of pairs
typedef vector<bool> vb; // Vector of bool
#define pq \
priority_queue // Max heap (To convert to min heap, use negative sign before
// every value)
#define ff first // For pairs
#define ss second
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, -1, 0, 1};
const int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1},
dy8[] = {1, -1, 1, 0, -1, 1, -0, -1};
#define testcases(t) \
int(t); \
cin >> (t); \
while ((t)--)
vi f, g;
vvi adj, prefix, suffix, tree;
vector<map<int, int>> pos;
int n, mod, u, v;
void dfs(int v, int p) {
f[v] = 1;
for (auto it : adj[v]) {
if (it == p)
continue;
tree[v].pb(it);
dfs(it, v);
f[v] *= (1 + f[it]);
f[v] %= mod;
}
for (int i = 0; i < tree[v].size(); i++) {
if (i == 0)
prefix[v].pb(1 + f[tree[v][i]]);
else
prefix[v].pb(prefix[v].back() * (1 + f[tree[v][i]]));
prefix[v].back() %= mod;
}
for (int i = (int)tree[v].size() - 1; i >= 0; i--) {
if (i == (tree[v].size() - 1))
suffix[v].pb(1 + f[tree[v][i]]);
else
suffix[v].pb(suffix[v].back() * (1 + f[tree[v][i]]));
suffix[v].back() %= mod;
}
return;
}
void dfs2(int v, int p) {
for (int i = 0; i < tree[v].size(); i++) {
int next = tree[v][i];
g[next] = g[v];
if (i > 0)
g[next] *= prefix[v][i - 1];
g[next] %= mod;
if (i < (tree[v].size() - 1))
g[next] *= suffix[v][tree[v].size() - i - 2];
g[next]++;
g[next] %= mod;
dfs2(next, v);
}
return;
}
signed main() {
cin >> n >> mod;
f.resize(n + 1, 1);
g.resize(n + 1, 1);
adj.resize(n + 1);
prefix.resize(n + 1);
suffix.resize(n + 1);
pos.resize(n + 1);
tree.resize(n + 1);
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].pb(v);
adj[v].pb(u);
}
dfs(1, 1);
g[1] = 1;
dfs2(1, 1);
for (int i = 1; i <= n; i++)
cout << ((f[i] * g[i]) % mod) << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 986,618 | 986,619 | u124676202 | cpp |
p03181 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
// #define mod 1000000007
#define int long long int
#define double long double
#define inf (int)(1e15)
#define all(x) (x).begin(), (x).end()
#define pair pair<int, int>
typedef vector<int> vi; // Vector of long long
typedef vector<vi> vvi; // Vector of vi
typedef vector<pair> vii; // Vector of pairs
typedef vector<vii> vvii; // Vector of Vector of pairs
typedef vector<bool> vb; // Vector of bool
#define pq \
priority_queue // Max heap (To convert to min heap, use negative sign before
// every value)
#define ff first // For pairs
#define ss second
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, -1, 0, 1};
const int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1},
dy8[] = {1, -1, 1, 0, -1, 1, -0, -1};
#define testcases(t) \
int(t); \
cin >> (t); \
while ((t)--)
vi f, g;
vvi adj, prefix, suffix, tree;
vector<map<int, int>> pos;
int n, mod, u, v;
void dfs(int v, int p) {
f[v] = 1;
for (auto it : adj[v]) {
if (it == p)
continue;
tree[v].pb(it);
dfs(it, v);
f[v] *= (1 + f[it]);
f[v] %= mod;
}
for (int i = 0; i < tree[v].size(); i++) {
if (i == 0)
prefix[v].pb(1 + f[tree[v][i]]);
else
prefix[v].pb(prefix[v].back() * (1 + f[tree[v][i]]));
prefix[v].back() %= mod;
}
for (int i = (int)tree[v].size() - 1; i >= 0; i--) {
if (i == (tree[v].size() - 1))
suffix[v].pb(1 + f[tree[v][i]]);
else
suffix[v].pb(suffix[v].back() * (1 + f[tree[v][i]]));
suffix[v].back() %= mod;
}
return;
}
void dfs2(int v, int p) {
for (int i = 0; i < tree[v].size(); i++) {
int next = tree[v][i];
g[next] = f[next];
if (i > 0)
g[next] *= prefix[v][i - 1];
g[next] %= mod;
if (i < (adj[v].size() - 1))
g[next] *= suffix[v][tree[v].size() - i - 2];
g[next]++;
g[next] %= mod;
dfs2(next, v);
}
return;
}
signed main() {
cin >> n >> mod;
f.resize(n + 1, 1);
g.resize(n + 1, 1);
adj.resize(n + 1);
prefix.resize(n + 1);
suffix.resize(n + 1);
pos.resize(n + 1);
tree.resize(n + 1);
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].pb(v);
adj[v].pb(u);
}
dfs(1, 1);
g[1] = 1;
dfs2(1, 1);
for (int i = 1; i <= n; i++)
cout << ((f[i] * g[i]) % mod) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
// #define mod 1000000007
#define int long long int
#define double long double
#define inf (int)(1e15)
#define all(x) (x).begin(), (x).end()
#define pair pair<int, int>
typedef vector<int> vi; // Vector of long long
typedef vector<vi> vvi; // Vector of vi
typedef vector<pair> vii; // Vector of pairs
typedef vector<vii> vvii; // Vector of Vector of pairs
typedef vector<bool> vb; // Vector of bool
#define pq \
priority_queue // Max heap (To convert to min heap, use negative sign before
// every value)
#define ff first // For pairs
#define ss second
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, -1, 0, 1};
const int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1},
dy8[] = {1, -1, 1, 0, -1, 1, -0, -1};
#define testcases(t) \
int(t); \
cin >> (t); \
while ((t)--)
vi f, g;
vvi adj, prefix, suffix, tree;
vector<map<int, int>> pos;
int n, mod, u, v;
void dfs(int v, int p) {
f[v] = 1;
for (auto it : adj[v]) {
if (it == p)
continue;
tree[v].pb(it);
dfs(it, v);
f[v] *= (1 + f[it]);
f[v] %= mod;
}
for (int i = 0; i < tree[v].size(); i++) {
if (i == 0)
prefix[v].pb(1 + f[tree[v][i]]);
else
prefix[v].pb(prefix[v].back() * (1 + f[tree[v][i]]));
prefix[v].back() %= mod;
}
for (int i = (int)tree[v].size() - 1; i >= 0; i--) {
if (i == (tree[v].size() - 1))
suffix[v].pb(1 + f[tree[v][i]]);
else
suffix[v].pb(suffix[v].back() * (1 + f[tree[v][i]]));
suffix[v].back() %= mod;
}
return;
}
void dfs2(int v, int p) {
for (int i = 0; i < tree[v].size(); i++) {
int next = tree[v][i];
g[next] = g[v];
if (i > 0)
g[next] *= prefix[v][i - 1];
g[next] %= mod;
if (i < (tree[v].size() - 1))
g[next] *= suffix[v][tree[v].size() - i - 2];
g[next]++;
g[next] %= mod;
dfs2(next, v);
}
return;
}
signed main() {
cin >> n >> mod;
f.resize(n + 1, 1);
g.resize(n + 1, 1);
adj.resize(n + 1);
prefix.resize(n + 1);
suffix.resize(n + 1);
pos.resize(n + 1);
tree.resize(n + 1);
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].pb(v);
adj[v].pb(u);
}
dfs(1, 1);
g[1] = 1;
dfs2(1, 1);
for (int i = 1; i <= n; i++)
cout << ((f[i] * g[i]) % mod) << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 986,620 | 986,619 | u124676202 | cpp |
p03181 | #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<long>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvb = vector<vector<bool>>;
using vvc = vector<vector<char>>;
using vvl = vector<vector<long>>;
using pii = pair<int, int>;
using pil = pair<int, long>;
using pll = pair<long, long>;
#define fix20 cout << fixed << setprecision(20)
#define YES cout << "Yes" << endl
#define NO cout << "No" << endl
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, s, t) for (int i = s; i < t; i++)
#define RNG(i, s, t, u) for (int i = s; i < t; i += u)
#define MOD 1000000007
#define all(vec) vec.begin(), vec.end()
struct Edge {
int from;
int to;
long cost;
};
vl dp(100010, -1);
vector<vector<Edge>> Graph(100010);
vl ans(100010, -1);
long dfs(int v, int pv, long m) {
if (dp[v] != -1)
return dp[v];
dp[v] = 1;
for (Edge ed : Graph[v]) {
int nv = ed.to;
if (nv == pv)
continue;
dp[v] = (dp[v] * (dfs(nv, v, m) + 1)) % m;
}
return dp[v];
}
void dfs2(int v, int pv, long rec, long m) {
int s = Graph.at(v).size();
vl acm(s + 1, 1);
vl rev(s + 1, 1);
rep(i, s) {
if (Graph.at(v).at(i).to != pv) {
acm.at(i + 1) = (acm.at(i) * (dp[Graph.at(v).at(i).to] + 1)) % m;
} else {
acm.at(i + 1) = (acm.at(i) * (rec + 1)) % m;
}
if (Graph.at(v).at(m - 1 - i).to != pv) {
rev.at(s - 1 - i) =
(rev.at(s - i) * (dp[Graph.at(v).at(s - 1 - i).to] + 1)) % m;
} else {
rev.at(s - 1 - i) = (rev.at(s - i) * (rec + 1)) % m;
}
}
ans[v] = acm[s];
rep(i, s) {
int nv = Graph.at(v).at(i).to;
if (nv == pv)
continue;
long r = acm[i] * rev[i + 1] % m;
dfs2(nv, v, r, m);
}
}
int main() {
long n, m;
cin >> n >> m;
rep(i, n - 1) {
int x, y;
cin >> x >> y;
x--;
y--;
Graph.at(x).push_back({x, y, 1});
Graph.at(y).push_back({y, x, 1});
}
ans[0] = dfs(0, -1, m);
dfs2(0, -1, 1, m);
rep(i, n) { cout << ans[i] << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<long>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvb = vector<vector<bool>>;
using vvc = vector<vector<char>>;
using vvl = vector<vector<long>>;
using pii = pair<int, int>;
using pil = pair<int, long>;
using pll = pair<long, long>;
#define fix20 cout << fixed << setprecision(20)
#define YES cout << "Yes" << endl
#define NO cout << "No" << endl
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, s, t) for (int i = s; i < t; i++)
#define RNG(i, s, t, u) for (int i = s; i < t; i += u)
#define MOD 1000000007
#define all(vec) vec.begin(), vec.end()
struct Edge {
int from;
int to;
long cost;
};
vl dp(100010, -1);
vector<vector<Edge>> Graph(100010);
vl ans(100010, -1);
long dfs(int v, int pv, long m) {
if (dp[v] != -1)
return dp[v];
dp[v] = 1;
for (Edge ed : Graph[v]) {
int nv = ed.to;
if (nv == pv)
continue;
dp[v] = (dp[v] * (dfs(nv, v, m) + 1)) % m;
}
return dp[v];
}
void dfs2(int v, int pv, long rec, long m) {
int s = Graph.at(v).size();
vl acm(s + 1, 1);
vl rev(s + 1, 1);
rep(i, s) {
if (Graph.at(v).at(i).to != pv) {
acm.at(i + 1) = (acm.at(i) * (dp[Graph.at(v).at(i).to] + 1)) % m;
} else {
acm.at(i + 1) = (acm.at(i) * (rec + 1)) % m;
}
if (Graph.at(v).at(s - 1 - i).to != pv) {
rev.at(s - 1 - i) =
(rev.at(s - i) * (dp[Graph.at(v).at(s - 1 - i).to] + 1)) % m;
} else {
rev.at(s - 1 - i) = (rev.at(s - i) * (rec + 1)) % m;
}
}
ans[v] = acm[s];
rep(i, s) {
int nv = Graph.at(v).at(i).to;
if (nv == pv)
continue;
long r = acm[i] * rev[i + 1] % m;
dfs2(nv, v, r, m);
}
}
int main() {
long n, m;
cin >> n >> m;
rep(i, n - 1) {
int x, y;
cin >> x >> y;
x--;
y--;
Graph.at(x).push_back({x, y, 1});
Graph.at(y).push_back({y, x, 1});
}
ans[0] = dfs(0, -1, m);
dfs2(0, -1, 1, m);
rep(i, n) { cout << ans[i] << endl; }
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 986,637 | 986,638 | u184335045 | cpp |
p03181 |
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define INF 1e9
#define LINF (ll) INF *INF
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (n); i++)
#define loop(i, a, n) for (int i = a; i < (n); i++)
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
const double PI = acos(-1);
const double EPS = 1e-9; //うまくいかなかったらゆるめる
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef pair<int, pii> pip;
typedef vector<pii> vp;
typedef vector<vi> vvi;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
struct edge {
int to, cost;
};
vector<vector<edge>> g;
vector<int> d;
int m;
void dfs(int now, int par) {
int ret = 1;
for (auto e : g[now])
if (e.to != par) {
dfs(e.to, now);
ret *= d[e.to] + 1;
ret %= m;
}
d[now] = ret;
}
void dfs2(int now, int d_par, int par) {
vi d_child;
for (auto e : g[now]) {
if (e.to == par) {
d_child.push_back(d_par + 1);
} else {
d_child.push_back(d[e.to] + 1);
}
}
vi d_child_rev = d_child;
rep(i, d_child.size() - 1) {
d_child[i + 1] *= d_child[i];
d_child[i + 1] %= m;
d_child_rev[d_child.size() - i - 2] *= d_child_rev[d_child.size() - i - 1];
d_child_rev[d_child.size() - i - 2] %= m;
}
d[now] = d_child.back();
rep(i, g[now].size()) if (g[now][i].to != par) {
edge e = g[now][i];
int d_next = 1;
if (i)
d_next *= d_child[i - 1];
if (i + 1 < g[now].size())
d_next *= d_child_rev[i + 1];
d_next %= m;
dfs2(e.to, d_next, now);
}
}
signed main(void) {
int n;
cin >> n >> m;
g.resize(n);
d = vi(n, 0);
rep(i, n - 1) {
int a, b, c;
cin >> a >> b;
a--, b--;
edge e1 = {b, 1};
g[a].push_back(e1);
edge e2 = {a, 1};
g[b].push_back(e2);
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
dfs(0, -1);
// rep(i,n)cout << d[i] << endl;
dfs2(0, 0, -1);
// rep(i,n)cout << d[i] << endl;
rep(i, n) { cout << d[i] << endl; }
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define INF 1e9
#define LINF (ll) INF *INF
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (n); i++)
#define loop(i, a, n) for (int i = a; i < (n); i++)
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
const double PI = acos(-1);
const double EPS = 1e-9; //うまくいかなかったらゆるめる
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef pair<int, pii> pip;
typedef vector<pii> vp;
typedef vector<vi> vvi;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
struct edge {
int to, cost;
};
vector<vector<edge>> g;
vector<int> d;
int m;
void dfs(int now, int par) {
int ret = 1;
for (auto e : g[now])
if (e.to != par) {
dfs(e.to, now);
ret *= d[e.to] + 1;
ret %= m;
}
d[now] = ret;
}
void dfs2(int now, int d_par, int par) {
vi d_child;
for (auto e : g[now]) {
if (e.to == par) {
d_child.push_back(d_par + 1);
} else {
d_child.push_back(d[e.to] + 1);
}
}
vi d_child_rev = d_child;
rep(i, d_child.size() - 1) {
d_child[i + 1] *= d_child[i];
d_child[i + 1] %= m;
d_child_rev[d_child.size() - i - 2] *= d_child_rev[d_child.size() - i - 1];
d_child_rev[d_child.size() - i - 2] %= m;
}
d[now] = d_child.back() % m;
rep(i, g[now].size()) if (g[now][i].to != par) {
edge e = g[now][i];
int d_next = 1;
if (i)
d_next *= d_child[i - 1];
if (i + 1 < g[now].size())
d_next *= d_child_rev[i + 1];
d_next %= m;
dfs2(e.to, d_next, now);
}
}
signed main(void) {
int n;
cin >> n >> m;
g.resize(n);
d = vi(n, 0);
rep(i, n - 1) {
int a, b, c;
cin >> a >> b;
a--, b--;
edge e1 = {b, 1};
g[a].push_back(e1);
edge e2 = {a, 1};
g[b].push_back(e2);
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
dfs(0, -1);
// rep(i,n)cout << d[i] << endl;
dfs2(0, 0, -1);
// rep(i,n)cout << d[i] << endl;
rep(i, n) { cout << d[i] << endl; }
}
| [
"assignment.change"
] | 986,641 | 986,642 | u471289663 | cpp |
p03181 | #include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define rSort(v) sort(v.rbegin(), v.rend())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
/* Macros reg. ends here */
const ll INF = 1LL << 50;
ll n, m;
vvll to;
vll ans, ans2;
void dfs(ll u, ll pa) {
ll add = 1;
for (ll v : to[u]) {
if (v == pa)
continue;
dfs(v, u);
add = (add * (1 + ans[v])) % m;
}
ans[u] = add;
}
void dfs2(ll u, ll pa, ll pav) {
ll add = (1 + pav);
vll chl;
for (ll v : to[u]) {
if (v == pa)
continue;
chl.push_back(v);
}
ll nc = chl.size();
assert(u == 0 || nc == (ll)to[u].size() - 1);
vll lefm(nc, 1), rigm(nc, 1);
repLRE(i, 1, nc - 1) lefm[i] =
(lefm[i - 1] * ((1 + ans[chl[i - 1]]) % m)) % m;
rrepLRE(i, nc - 2, 0) rigm[i] =
(rigm[i + 1] * ((1 + ans[chl[i + 1]]) % m)) % m;
map<ll, ll> uv;
rep(i, nc) { uv[chl[i]] = (((lefm[i] * rigm[i]) % m) * (1 + pav)) % m; }
for (ll v : to[u]) {
if (v == pa)
continue;
dfs2(v, u, uv[v]);
add = (add * (1 + ans[v])) % m;
}
ans2[u] = add;
}
int main() {
// ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
cin >> n >> m;
to.resize(n);
ans.assign(n, 0);
rep(i, n - 1) {
ll x, y;
cin >> x >> y;
x--, y--;
to[x].push_back(y);
to[y].push_back(x);
}
dfs(0, -1);
ans2.assign(n, 0);
dfs2(0, -1, 0);
rep(i, n) cout << ans2[i] << endl;
return 0;
}
| #include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define rSort(v) sort(v.rbegin(), v.rend())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
/* Macros reg. ends here */
const ll INF = 1LL << 50;
ll n, m;
vvll to;
vll ans, ans2;
void dfs(ll u, ll pa) {
ll add = 1;
for (ll v : to[u]) {
if (v == pa)
continue;
dfs(v, u);
add = (add * (1 + ans[v])) % m;
}
ans[u] = add;
}
void dfs2(ll u, ll pa, ll pav) {
ll add = (1 + pav);
vll chl;
for (ll v : to[u]) {
if (v == pa)
continue;
chl.push_back(v);
}
ll nc = chl.size();
assert(u == 0 || nc == (ll)to[u].size() - 1);
vll lefm(nc, 1), rigm(nc, 1);
repLRE(i, 1, nc - 1) lefm[i] =
(lefm[i - 1] * ((1 + ans[chl[i - 1]]) % m)) % m;
rrepLRE(i, nc - 2, 0) rigm[i] =
(rigm[i + 1] * ((1 + ans[chl[i + 1]]) % m)) % m;
map<ll, ll> uv;
rep(i, nc) { uv[chl[i]] = (((lefm[i] * rigm[i]) % m) * (1 + pav)) % m; }
for (ll v : to[u]) {
if (v == pa)
continue;
dfs2(v, u, uv[v]);
add = (add * (1 + ans[v])) % m;
}
ans2[u] = add;
}
int main() {
// ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
cin >> n >> m;
to.resize(n);
ans.assign(n, 0);
rep(i, n - 1) {
ll x, y;
cin >> x >> y;
x--, y--;
to[x].push_back(y);
to[y].push_back(x);
}
dfs(0, -1);
ans2.assign(n, 0);
dfs2(0, -1, 0);
rep(i, n) cout << ans2[i] % m << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 986,645 | 986,646 | u714724786 | cpp |
p03181 | #include <bits/stdc++.h>
#define N 100001
typedef long long ll;
using namespace std;
int n, m;
vector<int> g[N];
vector<int> tree[N];
ll in[N];
ll out[N];
void dfs1(int u, int p) {
in[u] = 1;
for (int v : g[u]) {
if (v == p)
continue;
tree[u].push_back(v);
dfs1(v, u);
in[u] = (in[u] * ((1 + in[v]) % m)) % m;
}
}
void dfs2(int u, int p) {
int len = tree[u].size();
ll left[len], right[len];
for (int i = 0; i < len; i++) {
int v = tree[u][i];
left[i] =
(i == 0) ? ((1 + in[v]) % m) : ((left[i - 1] * ((1 + in[v]) % m)) % m);
}
for (int i = len - 1; i >= 0; i--) {
int v = tree[u][i];
right[i] = (i == len - 1) ? ((1 + in[v]) % m)
: ((((1 + in[v]) % m) * right[i + 1]) % m);
}
// cout << u << " " << len << endl;
for (int i = 0; i < len; i++) {
int v = tree[u][i];
// cout << len << " ";
// cout << ((i == 0 ? 1 : (1 + left[i - 1])) * ((i == len - 1 ? 1 : (1 +
// right[i + 1])) * (1 + out[p]))) << endl;
out[v] =
(1 +
((((i == 0 ? 1 : left[i - 1]) * (i == len - 1 ? 1 : right[i + 1])) %
m) *
(1 + out[u]) % m) %
m) %
m;
dfs2(v, u);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
out[1] = 1;
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
// cout << in[i] << " " << out[i] << " ";
cout << (in[i] * out[i]) % m << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define N 100001
typedef long long ll;
using namespace std;
int n, m;
vector<int> g[N];
vector<int> tree[N];
ll in[N];
ll out[N];
void dfs1(int u, int p) {
in[u] = 1;
for (int v : g[u]) {
if (v == p)
continue;
tree[u].push_back(v);
dfs1(v, u);
in[u] = (in[u] * ((1 + in[v]) % m)) % m;
}
}
void dfs2(int u, int p) {
int len = tree[u].size();
ll left[len], right[len];
for (int i = 0; i < len; i++) {
int v = tree[u][i];
left[i] =
(i == 0) ? ((1 + in[v]) % m) : ((left[i - 1] * ((1 + in[v]) % m)) % m);
}
for (int i = len - 1; i >= 0; i--) {
int v = tree[u][i];
right[i] = (i == len - 1) ? ((1 + in[v]) % m)
: ((((1 + in[v]) % m) * right[i + 1]) % m);
}
// cout << u << " " << len << endl;
for (int i = 0; i < len; i++) {
int v = tree[u][i];
// cout << len << " ";
// cout << ((i == 0 ? 1 : (1 + left[i - 1])) * ((i == len - 1 ? 1 : (1 +
// right[i + 1])) * (1 + out[p]))) << endl;
out[v] =
(1 +
((((i == 0 ? 1 : left[i - 1]) * (i == len - 1 ? 1 : right[i + 1])) %
m) *
(out[u]) % m) %
m) %
m;
dfs2(v, u);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
out[1] = 1;
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
// cout << in[i] << " " << out[i] << " ";
cout << (in[i] * out[i]) % m << endl;
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 986,653 | 986,654 | u894611946 | cpp |
p03181 | #include <bits/stdc++.h>
#define N 100001
typedef long long ll;
using namespace std;
int n, m;
vector<int> g[N];
vector<int> tree[N];
ll in[N];
ll out[N];
void dfs1(int u, int p) {
in[u] = 1;
for (int v : g[u]) {
if (v == p)
continue;
tree[u].push_back(v);
dfs1(v, u);
in[u] = (in[u] * ((1 + in[v]) % m)) % m;
}
}
void dfs2(int u, int p) {
int len = tree[u].size();
ll left[len], right[len];
for (int i = 0; i < len; i++) {
int v = tree[u][i];
left[i] =
(i == 0) ? ((1 + in[v]) % m) : ((left[i - 1] * ((1 + in[v]) % m)) % m);
}
for (int i = len - 1; i >= 0; i--) {
int v = tree[u][i];
right[i] = (i == len - 1) ? ((1 + in[v]) % m)
: ((((1 + in[v]) % m) * right[i + 1]) % m);
}
// cout << u << " " << len << endl;
for (int i = 0; i < len; i++) {
int v = tree[u][i];
// cout << len << " ";
// cout << ((i == 0 ? 1 : (1 + left[i - 1])) * ((i == len - 1 ? 1 : (1 +
// right[i + 1])) * (1 + out[p]))) << endl;
out[v] =
(1 +
((((i == 0 ? 1 : left[i - 1]) * (i == len - 1 ? 1 : right[i + 1])) %
m) *
(1 + out[p]) % m) %
m) %
m;
dfs2(v, u);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
out[1] = 1;
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
// cout << in[i] << " " << out[i] << " ";
cout << (in[i] * out[i]) % m << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define N 100001
typedef long long ll;
using namespace std;
int n, m;
vector<int> g[N];
vector<int> tree[N];
ll in[N];
ll out[N];
void dfs1(int u, int p) {
in[u] = 1;
for (int v : g[u]) {
if (v == p)
continue;
tree[u].push_back(v);
dfs1(v, u);
in[u] = (in[u] * ((1 + in[v]) % m)) % m;
}
}
void dfs2(int u, int p) {
int len = tree[u].size();
ll left[len], right[len];
for (int i = 0; i < len; i++) {
int v = tree[u][i];
left[i] =
(i == 0) ? ((1 + in[v]) % m) : ((left[i - 1] * ((1 + in[v]) % m)) % m);
}
for (int i = len - 1; i >= 0; i--) {
int v = tree[u][i];
right[i] = (i == len - 1) ? ((1 + in[v]) % m)
: ((((1 + in[v]) % m) * right[i + 1]) % m);
}
// cout << u << " " << len << endl;
for (int i = 0; i < len; i++) {
int v = tree[u][i];
// cout << len << " ";
// cout << ((i == 0 ? 1 : (1 + left[i - 1])) * ((i == len - 1 ? 1 : (1 +
// right[i + 1])) * (1 + out[p]))) << endl;
out[v] =
(1 +
((((i == 0 ? 1 : left[i - 1]) * (i == len - 1 ? 1 : right[i + 1])) %
m) *
(out[u]) % m) %
m) %
m;
dfs2(v, u);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
out[1] = 1;
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
// cout << in[i] << " " << out[i] << " ";
cout << (in[i] * out[i]) % m << endl;
}
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.value.change",
"expression.operation.binary.change"
] | 986,655 | 986,654 | u894611946 | cpp |
p03181 | #include <bits/stdc++.h>
#define N 100001
typedef long long ll;
using namespace std;
int n, m;
vector<int> g[N];
vector<int> tree[N];
ll in[N];
ll out[N];
void dfs1(int u, int p) {
in[u] = 1;
for (int v : g[u]) {
if (v == p)
continue;
tree[u].push_back(v);
dfs1(v, u);
in[u] = (in[u] * ((1 + in[v]) % m)) % m;
}
}
void dfs2(int u, int p) {
int len = tree[u].size();
ll left[len], right[len];
for (int i = 0; i < len; i++) {
int v = tree[u][i];
left[i] =
(i == 0) ? ((1 + in[v]) % m) : ((left[i - 1] * ((1 + in[v]) % m)) % m);
}
for (int i = len - 1; i >= 0; i--) {
int v = tree[u][i];
right[i] = (i == len - 1) ? ((1 + in[v]) % m)
: ((((1 + in[v]) % m) * right[i + 1]) % m);
}
// cout << u << " " << len << endl;
for (int i = 0; i < len; i++) {
int v = tree[u][i];
// cout << len << " ";
// cout << ((i == 0 ? 1 : (1 + left[i - 1])) * ((i == len - 1 ? 1 : (1 +
// right[i + 1])) * (1 + out[p]))) << endl;
out[v] =
(1 +
((((i == 0 ? 1 : left[i - 1]) * (i == len - 1 ? 1 : right[i + 1])) %
m) *
(1 + out[p])) %
m) %
m;
dfs2(v, u);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
out[1] = 1;
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
// cout << in[i] << " " << out[i] << " ";
cout << (in[i] * out[i]) % m << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define N 100001
typedef long long ll;
using namespace std;
int n, m;
vector<int> g[N];
vector<int> tree[N];
ll in[N];
ll out[N];
void dfs1(int u, int p) {
in[u] = 1;
for (int v : g[u]) {
if (v == p)
continue;
tree[u].push_back(v);
dfs1(v, u);
in[u] = (in[u] * ((1 + in[v]) % m)) % m;
}
}
void dfs2(int u, int p) {
int len = tree[u].size();
ll left[len], right[len];
for (int i = 0; i < len; i++) {
int v = tree[u][i];
left[i] =
(i == 0) ? ((1 + in[v]) % m) : ((left[i - 1] * ((1 + in[v]) % m)) % m);
}
for (int i = len - 1; i >= 0; i--) {
int v = tree[u][i];
right[i] = (i == len - 1) ? ((1 + in[v]) % m)
: ((((1 + in[v]) % m) * right[i + 1]) % m);
}
// cout << u << " " << len << endl;
for (int i = 0; i < len; i++) {
int v = tree[u][i];
// cout << len << " ";
// cout << ((i == 0 ? 1 : (1 + left[i - 1])) * ((i == len - 1 ? 1 : (1 +
// right[i + 1])) * (1 + out[p]))) << endl;
out[v] =
(1 +
((((i == 0 ? 1 : left[i - 1]) * (i == len - 1 ? 1 : right[i + 1])) %
m) *
(out[u]) % m) %
m) %
m;
dfs2(v, u);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1, 0);
out[1] = 1;
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
// cout << in[i] << " " << out[i] << " ";
cout << (in[i] * out[i]) % m << endl;
}
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.value.change",
"expression.operation.binary.change",
"assignment.change"
] | 986,656 | 986,654 | u894611946 | cpp |
p03181 | #include "bits/stdc++.h"
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(a) (a).begin(), (a).end()
typedef pair<int, int> P;
int mod;
const int maxN = 200000;
vector<int> G[200006];
int kj[200006];
int dp1[200006];
int modpow(int a, int x) {
int res = 1;
while (x) {
if (x & 1)
res = res * a % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
void setkj() {
kj[0] = 1;
for (int i = 1; i <= maxN; i++)
kj[i] = kj[i - 1] * i % mod;
}
void dfs1(int now, int par) {
dp1[now] = 1;
for (int e : G[now]) {
if (e == par)
continue;
dfs1(e, now);
dp1[now] *= dp1[e] + 1;
dp1[now] %= mod;
}
}
void dfs2(int now, int par, int nowdp = 0) {
int N = G[now].size();
vector<int> dpl(N), dpr(N);
rep(i, N) {
int u = G[now][i];
if (u == par) {
dpl[i] = dpr[i] = (nowdp + 1) % mod;
dp1[now] *= nowdp + 1;
dp1[now] %= mod;
} else {
dpl[i] = dpr[i] = (dp1[now] + 1) % mod;
}
}
rep(i, N - 1) dpl[i + 1] = dpl[i + 1] * dpl[i] % mod;
for (int i = N - 1; i > 0; i--)
dpr[i - 1] = dpr[i - 1] * dpr[i] % mod;
rep(i, N) {
int u = G[now][i];
if (u == par)
continue;
int na = 1, nb = 1;
if (i)
na = dpl[i - 1];
if (i != N - 1)
nb = dpr[i + 1];
dfs2(u, now, na * nb % mod);
}
}
signed main() {
int n;
cin >> n >> mod;
setkj();
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs1(0, -1);
dfs2(0, -1);
rep(i, n) cout << dp1[i] << endl;
}
| #include "bits/stdc++.h"
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(a) (a).begin(), (a).end()
typedef pair<int, int> P;
int mod;
const int maxN = 200000;
vector<int> G[200006];
int kj[200006];
int dp1[200006];
int modpow(int a, int x) {
int res = 1;
while (x) {
if (x & 1)
res = res * a % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
void setkj() {
kj[0] = 1;
for (int i = 1; i <= maxN; i++)
kj[i] = kj[i - 1] * i % mod;
}
void dfs1(int now, int par) {
dp1[now] = 1;
for (int e : G[now]) {
if (e == par)
continue;
dfs1(e, now);
dp1[now] *= dp1[e] + 1;
dp1[now] %= mod;
}
}
void dfs2(int now, int par, int nowdp = 0) {
int N = G[now].size();
vector<int> dpl(N), dpr(N);
rep(i, N) {
int u = G[now][i];
if (u == par) {
dpl[i] = dpr[i] = (nowdp + 1) % mod;
dp1[now] *= nowdp + 1;
dp1[now] %= mod;
} else {
dpl[i] = dpr[i] = (dp1[u] + 1) % mod;
}
}
rep(i, N - 1) dpl[i + 1] = dpl[i + 1] * dpl[i] % mod;
for (int i = N - 1; i > 0; i--)
dpr[i - 1] = dpr[i - 1] * dpr[i] % mod;
rep(i, N) {
int u = G[now][i];
if (u == par)
continue;
int na = 1, nb = 1;
if (i)
na = dpl[i - 1];
if (i != N - 1)
nb = dpr[i + 1];
dfs2(u, now, na * nb % mod);
}
}
signed main() {
int n;
cin >> n >> mod;
setkj();
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs1(0, -1);
dfs2(0, -1);
rep(i, n) cout << dp1[i] << endl;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 986,657 | 986,658 | u722628899 | cpp |
p03181 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <utility>
#include <vector>
#define fir first
#define sec second
#define sz(s) (s).size()
#define pb push_back
#define get(n) scanf("%d", &n);
#define gets(s) \
string s; \
cin >> (s);
#define prfi(n) printf("%d", &n);
#define prfd(n) printf("%lf", &n);
#define All(s) (s).begin(), (s).end()
#define rep(i, j) for (int(i) = 0; (i) < (j); (i)++)
#define For(i, j, k) for (int(i) = (j); (i) < (k); (i)++)
#define drep(i, j) for (int(i) = (j); (i) >= 0; (i)--)
#define Ford(i, j, k) for (int(i) = (j); i >= (k); i--)
#define fore(c, v) for (auto(c) : (v))
#define lp for (int i = 0; i < n; i++)
#define mem(a, b) memset(a, b, sizeof(a));
#define dump(x) std::cout << #x << " = " << (x) << std::endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using ull = unsigned long long int;
using ll = long long;
using ld = long double;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vd = std::vector<double>;
using vvd = std::vector<vd>;
using qi = std::queue<int>;
using vpii = std::vector<std::pair<int, int>>;
using vpll = std::vector<pll>;
using namespace std;
const int Mod = (1e9) + 7;
const int INF = 1e9 + 19;
const ll INFL = 1e18 + 19;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int dx2[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int dy2[] = {1, 0, -1, 1, 0, -1, 1, 0, -1};
const double EPS = 1e-10;
//_____________________________________Templates_________________________________________//
template <class T1, class T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> inline void pri(T a) { cout << a << endl; }
template <class Z> using vec = vector<Z>;
template <class T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
// mainly use for dynamic prog
template <class T1, class T2> void update(T1 &a, T2 b) {
a += b;
if (a > Mod)
a %= Mod;
}
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
bool pairsort(pll pl, pll pr) {
if (pl.first == pr.first)
return pl.second > pr.second;
return pl.first < pr.first;
}
int cntbit(ll a, int n, int j) {
int res = 0;
For(i, j, n) {
if (a >> i & 1) {
res++;
}
}
return res;
}
vector<int> make_bit(int a) {
vector<int> res;
for (int i = 31; i >= 0; i--)
if (a & (1 << i))
res.pb(i);
return res;
}
bool stdbit(int a, int b) { return a & (1 << b); }
int GCD(int a, int b) {
if (b > a)
return GCD(b, a);
if (a % b == 0)
return b;
else
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int roundup(int a, int b) {
if (a % b == 0)
return a / b;
else
return (a + b) / b;
}
int rounddown(int a, int b) {
if (a % b == 0)
return a / b;
else {
return (a - b) / b;
}
}
ll pow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res *= a;
a *= a;
n = n >> 1;
}
return res;
}
ll GetDiviserCount(ll N) //約数の個数
{
ll res = 1;
For(i, 2, sqrt(N) + 1) {
ll cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
res *= (cnt + 1);
if (N == 1)
break;
}
if (N != 1)
res *= 2;
return res;
}
vll GetDivisor(ll N) //約数列挙
{
vll res;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
res.pb(i);
if (i * i != N)
res.pb(N / i);
}
}
sort(All(res));
return res;
}
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;
}
friend ostream &operator<<(ostream &os, const mint &a);
};
ostream &operator<<(ostream &os, const mint &a) {
os << a.x;
return os;
}
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];
}
};
template <class Z> struct Matrix {
using mat = Matrix<Z>;
vector<vector<Z>> m_dat;
int m_h;
int m_w;
Matrix(int h, int w) : m_h(h), m_w(w), m_dat(h, vector<Z>(w)) {}
vector<Z> &operator[](int idx) { return m_dat[idx]; }
mat Multiple(mat &a) {
mat C(m_h, a.m_w);
for (int i = 0; i < m_h; i++) {
for (int j = 0; j < a.m_w; j++) {
for (int k = 0; k < m_w; k++) {
C[i][j] += m_dat[i][k] * a[k][j];
}
}
}
return C;
}
mat Pow(ll x) {
mat B(m_h, m_w);
for (int i = 0; i < m_h; i++) {
B[i][i] = 1;
}
mat A = *this;
while (x > 0) {
if (x & 1)
B = B.Multiple(A);
A = A.Multiple(A);
x = x >> 1;
}
return B;
}
friend ostream &operator<<(ostream &os, const mat &A);
};
template <class Z> ostream &operator<<(ostream &os, Matrix<Z> &A) {
for (int i = 0; i < A.m_h; i++) {
for (int j = 0; j < A.m_w; j++) {
os << A[i][j] << " ";
}
os << endl;
}
return os;
}
//_____________________ following sorce code_________________________//
const int max_n = 3 * (1e5) + 1;
const int max_m = 83 * (1e5) + 1;
int n;
ll m;
ll N;
int h, w;
vvi tree;
string S;
int a, b, c;
vi v;
int ans;
double x, y, z;
vll dp[1010101];
ll dfs(int v, int u = -1) {
ll res = 1;
rep(i, tree[v].size()) {
int e = tree[v][i];
if (e == u)
continue;
dp[v][i] = dfs(e, v) % m;
(res *= (1 + dp[v][i]) % m) %= m;
}
return res % m;
}
void dfs2(int v, int u = -1, ll p = 0) {
if (u != -1) {
rep(i, sz(tree[v])) {
int e = tree[v][i];
if (e == u) {
dp[v][i] = p;
break;
}
}
}
vll L(tree[v].size(), 1);
vll R(tree[v].size(), 1);
For(i, 1, tree[v].size()) { (L[i] = (L[i - 1] * (1 + dp[v][i])) % m) %= m; }
drep(i, tree[v].size() - 1) {
if (i != (tree[v].size() - 1))
(R[i] = (R[i + 1] * (1 + dp[v][i + 1])) % m) % m;
ll tot = L[i] % m * R[i] % m;
tot %= m;
int e = tree[v][i];
if (e == u)
continue;
dfs2(e, v, tot);
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
IN(n, m);
tree = vvi(n);
rep(i, n - 1) {
IN(a, b);
a--;
b--;
tree[a].emplace_back(b);
tree[b].emplace_back(a);
}
rep(i, n) { dp[i] = vll(tree[i].size()); }
dfs(0);
dfs2(0);
rep(i, n) {
ll ans = 1;
fore(e, dp[i]) { (ans *= (1 + e) % m) %= m; }
cout << ans << endl;
}
// for(auto c : ans){cout << c << endl;}
// cout << fixed << setprecision(15) << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <utility>
#include <vector>
#define fir first
#define sec second
#define sz(s) (s).size()
#define pb push_back
#define get(n) scanf("%d", &n);
#define gets(s) \
string s; \
cin >> (s);
#define prfi(n) printf("%d", &n);
#define prfd(n) printf("%lf", &n);
#define All(s) (s).begin(), (s).end()
#define rep(i, j) for (int(i) = 0; (i) < (j); (i)++)
#define For(i, j, k) for (int(i) = (j); (i) < (k); (i)++)
#define drep(i, j) for (int(i) = (j); (i) >= 0; (i)--)
#define Ford(i, j, k) for (int(i) = (j); i >= (k); i--)
#define fore(c, v) for (auto(c) : (v))
#define lp for (int i = 0; i < n; i++)
#define mem(a, b) memset(a, b, sizeof(a));
#define dump(x) std::cout << #x << " = " << (x) << std::endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using ull = unsigned long long int;
using ll = long long;
using ld = long double;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vd = std::vector<double>;
using vvd = std::vector<vd>;
using qi = std::queue<int>;
using vpii = std::vector<std::pair<int, int>>;
using vpll = std::vector<pll>;
using namespace std;
const int Mod = (1e9) + 7;
const int INF = 1e9 + 19;
const ll INFL = 1e18 + 19;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int dx2[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int dy2[] = {1, 0, -1, 1, 0, -1, 1, 0, -1};
const double EPS = 1e-10;
//_____________________________________Templates_________________________________________//
template <class T1, class T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> inline void pri(T a) { cout << a << endl; }
template <class Z> using vec = vector<Z>;
template <class T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
// mainly use for dynamic prog
template <class T1, class T2> void update(T1 &a, T2 b) {
a += b;
if (a > Mod)
a %= Mod;
}
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
bool pairsort(pll pl, pll pr) {
if (pl.first == pr.first)
return pl.second > pr.second;
return pl.first < pr.first;
}
int cntbit(ll a, int n, int j) {
int res = 0;
For(i, j, n) {
if (a >> i & 1) {
res++;
}
}
return res;
}
vector<int> make_bit(int a) {
vector<int> res;
for (int i = 31; i >= 0; i--)
if (a & (1 << i))
res.pb(i);
return res;
}
bool stdbit(int a, int b) { return a & (1 << b); }
int GCD(int a, int b) {
if (b > a)
return GCD(b, a);
if (a % b == 0)
return b;
else
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int roundup(int a, int b) {
if (a % b == 0)
return a / b;
else
return (a + b) / b;
}
int rounddown(int a, int b) {
if (a % b == 0)
return a / b;
else {
return (a - b) / b;
}
}
ll pow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res *= a;
a *= a;
n = n >> 1;
}
return res;
}
ll GetDiviserCount(ll N) //約数の個数
{
ll res = 1;
For(i, 2, sqrt(N) + 1) {
ll cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
res *= (cnt + 1);
if (N == 1)
break;
}
if (N != 1)
res *= 2;
return res;
}
vll GetDivisor(ll N) //約数列挙
{
vll res;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
res.pb(i);
if (i * i != N)
res.pb(N / i);
}
}
sort(All(res));
return res;
}
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;
}
friend ostream &operator<<(ostream &os, const mint &a);
};
ostream &operator<<(ostream &os, const mint &a) {
os << a.x;
return os;
}
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];
}
};
template <class Z> struct Matrix {
using mat = Matrix<Z>;
vector<vector<Z>> m_dat;
int m_h;
int m_w;
Matrix(int h, int w) : m_h(h), m_w(w), m_dat(h, vector<Z>(w)) {}
vector<Z> &operator[](int idx) { return m_dat[idx]; }
mat Multiple(mat &a) {
mat C(m_h, a.m_w);
for (int i = 0; i < m_h; i++) {
for (int j = 0; j < a.m_w; j++) {
for (int k = 0; k < m_w; k++) {
C[i][j] += m_dat[i][k] * a[k][j];
}
}
}
return C;
}
mat Pow(ll x) {
mat B(m_h, m_w);
for (int i = 0; i < m_h; i++) {
B[i][i] = 1;
}
mat A = *this;
while (x > 0) {
if (x & 1)
B = B.Multiple(A);
A = A.Multiple(A);
x = x >> 1;
}
return B;
}
friend ostream &operator<<(ostream &os, const mat &A);
};
template <class Z> ostream &operator<<(ostream &os, Matrix<Z> &A) {
for (int i = 0; i < A.m_h; i++) {
for (int j = 0; j < A.m_w; j++) {
os << A[i][j] << " ";
}
os << endl;
}
return os;
}
//_____________________ following sorce code_________________________//
const int max_n = 3 * (1e5) + 1;
const int max_m = 83 * (1e5) + 1;
int n;
ll m;
ll N;
int h, w;
vvi tree;
string S;
int a, b, c;
vi v;
int ans;
double x, y, z;
vll dp[1010101];
ll dfs(int v, int u = -1) {
ll res = 1;
rep(i, tree[v].size()) {
int e = tree[v][i];
if (e == u)
continue;
dp[v][i] = dfs(e, v) % m;
(res *= (1 + dp[v][i]) % m) %= m;
}
return res % m;
}
void dfs2(int v, int u = -1, ll p = 0) {
if (u != -1) {
rep(i, sz(tree[v])) {
int e = tree[v][i];
if (e == u) {
dp[v][i] = p;
break;
}
}
}
vll L(tree[v].size(), 1);
vll R(tree[v].size(), 1);
For(i, 1, tree[v].size()) {
(L[i] = (L[i - 1] * (1 + dp[v][i - 1])) % m) %= m;
}
drep(i, tree[v].size() - 1) {
if (i != (tree[v].size() - 1))
(R[i] = (R[i + 1] * (1 + dp[v][i + 1])) % m) % m;
ll tot = L[i] % m * R[i] % m;
tot %= m;
int e = tree[v][i];
if (e == u)
continue;
dfs2(e, v, tot);
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
IN(n, m);
tree = vvi(n);
rep(i, n - 1) {
IN(a, b);
a--;
b--;
tree[a].emplace_back(b);
tree[b].emplace_back(a);
}
rep(i, n) { dp[i] = vll(tree[i].size()); }
dfs(0);
dfs2(0);
rep(i, n) {
ll ans = 1;
fore(e, dp[i]) { (ans *= (1 + e) % m) %= m; }
cout << ans << endl;
}
// for(auto c : ans){cout << c << endl;}
// cout << fixed << setprecision(15) << ans << endl;
return 0;
} | [
"assignment.change"
] | 986,667 | 986,668 | u264405855 | cpp |
p03181 | /*input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
*/
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
const int MOD = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
ll m;
vector<vector<int>> adj;
vector<vector<ll>> pre;
vector<vector<ll>> suf;
vector<ll> dp;
void dfs1(int v, int p) {
if (adj[v].empty())
return; // special case: only one node in the graph
for (int i = 0; i < adj[v].size(); i++)
if (adj[v][i] != p) {
dfs1(adj[v][i], v);
dp[v] = (dp[v] * ((1 + dp[adj[v][i]]) % m)) % m;
}
pre[v].resize(adj[v].size());
suf[v].resize(adj[v].size());
pre[v][0] = ((adj[v][0] == p) ? 1 : (1 + dp[adj[v][0]]) % m);
suf[v][adj[v].size() - 1] = ((adj[v][adj[v].size() - 1] == p)
? 1
: (1 + dp[adj[v][adj[v].size() - 1]]) % m);
for (int i = 1; i < adj[v].size(); i++) {
if (adj[v][i] == p)
pre[v][i] = pre[v][i - 1];
else
pre[v][i] = (pre[v][i - 1] * ((1 + dp[adj[v][i]]) % m)) % m;
}
for (int i = adj[v].size() - 2; i > -1; i--) {
if (adj[v][i] == p)
suf[v][i] = suf[v][i + 1];
else
suf[v][i] = (suf[v][i + 1] * ((1 + dp[adj[v][i]]) % m)) % m;
}
}
void dfs2(int v, int p, int i) {
if (v) // dp[v] *= (1 + dp[p]/(1 + dp[v]));
{
int j = 0;
ll temp;
if (adj[p].size() == 1)
temp = 1;
else if (i - 1 == -1)
temp = suf[p][i + 1];
else if (i + 1 == adj[p].size())
temp = pre[p][i - 1];
else
temp = (pre[p][i - 1] * suf[p][i + 1]) % m;
dp[v] = (dp[v] * ((1 + temp) % m));
// from here we update pre and suf
while (adj[v][j] != p)
j++;
pre[v][j] = (!j ? (1 + temp) % m : (pre[v][j - 1] * ((1 + temp) % m)) % m);
suf[v][j] = (j == adj[v].size() ? (1 + temp) % m
: (suf[v][j + 1] * ((1 + temp) % m)) % m);
int jj = j + 1;
while (jj < adj[v].size()) {
pre[v][jj] = (pre[v][jj - 1] * ((1 + dp[adj[v][jj]]) % m)) % m;
jj++;
}
jj = j - 1;
while (jj > -1) {
suf[v][jj] = (suf[v][jj + 1] * ((1 + dp[adj[v][jj]]) % m)) % m;
jj--;
}
}
for (int i = 0; i < adj[v].size(); i++)
if (adj[v][i] != p)
dfs2(adj[v][i], v, i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n >> m;
adj.resize(n);
dp.resize(n);
pre.resize(n);
suf.resize(n);
for (int i = 0; i < n; i++)
dp[i] = 1;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs1(0, -1);
dfs2(0, -1, -1);
for (int i = 0; i < n; i++)
cout << dp[i] << endl;
return 0;
} | /*input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
*/
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
const int MOD = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
ll m;
vector<vector<int>> adj;
vector<vector<ll>> pre;
vector<vector<ll>> suf;
vector<ll> dp;
void dfs1(int v, int p) {
if (adj[v].empty())
return; // special case: only one node in the graph
for (int i = 0; i < adj[v].size(); i++)
if (adj[v][i] != p) {
dfs1(adj[v][i], v);
dp[v] = (dp[v] * ((1 + dp[adj[v][i]]) % m)) % m;
}
pre[v].resize(adj[v].size());
suf[v].resize(adj[v].size());
pre[v][0] = ((adj[v][0] == p) ? 1 : (1 + dp[adj[v][0]]) % m);
suf[v][adj[v].size() - 1] = ((adj[v][adj[v].size() - 1] == p)
? 1
: (1 + dp[adj[v][adj[v].size() - 1]]) % m);
for (int i = 1; i < adj[v].size(); i++) {
if (adj[v][i] == p)
pre[v][i] = pre[v][i - 1];
else
pre[v][i] = (pre[v][i - 1] * ((1 + dp[adj[v][i]]) % m)) % m;
}
for (int i = adj[v].size() - 2; i > -1; i--) {
if (adj[v][i] == p)
suf[v][i] = suf[v][i + 1];
else
suf[v][i] = (suf[v][i + 1] * ((1 + dp[adj[v][i]]) % m)) % m;
}
}
void dfs2(int v, int p, int i) {
if (v) // dp[v] *= (1 + dp[p]/(1 + dp[v]));
{
int j = 0;
ll temp;
if (adj[p].size() == 1)
temp = 1;
else if (i - 1 == -1)
temp = suf[p][i + 1];
else if (i + 1 == adj[p].size())
temp = pre[p][i - 1];
else
temp = (pre[p][i - 1] * suf[p][i + 1]) % m;
dp[v] = (dp[v] * ((1 + temp) % m)) % m;
// from here we update pre and suf
while (adj[v][j] != p)
j++;
pre[v][j] = (!j ? (1 + temp) % m : (pre[v][j - 1] * ((1 + temp) % m)) % m);
suf[v][j] =
(j == adj[v].size() - 1 ? (1 + temp) % m
: (suf[v][j + 1] * ((1 + temp) % m)) % m);
int jj = j + 1;
while (jj < adj[v].size()) {
pre[v][jj] = (pre[v][jj - 1] * ((1 + dp[adj[v][jj]]) % m)) % m;
jj++;
}
jj = j - 1;
while (jj > -1) {
suf[v][jj] = (suf[v][jj + 1] * ((1 + dp[adj[v][jj]]) % m)) % m;
jj--;
}
}
for (int i = 0; i < adj[v].size(); i++)
if (adj[v][i] != p)
dfs2(adj[v][i], v, i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n >> m;
adj.resize(n);
dp.resize(n);
pre.resize(n);
suf.resize(n);
for (int i = 0; i < n; i++)
dp[i] = 1;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs1(0, -1);
dfs2(0, -1, -1);
for (int i = 0; i < n; i++)
cout << dp[i] << endl;
return 0;
} | [
"assignment.change",
"control_flow.branch.if.condition.change"
] | 986,671 | 986,670 | u117615163 | cpp |
p03181 | #include <bits/stdc++.h>
#define inp_out_work \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define testCase \
int T; \
cin >> T; \
while (T--)
#define endl '\n'
#define debug(P) cout << #P << " = " << P << endl;
#define FILE freopen("input.txt", "r", stdin)
using namespace std;
const int MAXN = 100001;
const int mod = 1000000007;
typedef long long ll;
int n, m;
vector<int> adj[MAXN];
ll dp1[MAXN];
ll dp2[MAXN];
void dfs1(int x, int p) {
dp1[x] = 1;
for (int c : adj[x]) {
if (c != p) {
dfs1(c, x);
dp1[x] = dp1[x] * (dp1[c] + 1) % m;
}
}
}
void dfs2(int x, int p) {
vector<ll> sf;
ll mul = 1;
sf.push_back(mul);
for (int i = adj[x].size() - 1; i >= 0; --i) {
if (adj[x][i] != p) {
mul = (mul * (1 + dp1[adj[x][i]])) % m;
sf.push_back(mul);
}
}
mul = 1;
for (int c : adj[x]) {
if (c != p) {
ll tt = (mul * sf[sf.size() - 2]) % m;
dp2[c] = (tt * dp2[x] + 1) % m;
mul = mul * (1 + dp1[c] % m);
sf.pop_back();
dfs2(c, x);
}
}
}
int main() {
FILE;
cin >> n >> m;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dp2[1] = 1;
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; ++i) {
cout << dp1[i] * dp2[i] % m << endl;
}
} | #include <bits/stdc++.h>
#define inp_out_work \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define testCase \
int T; \
cin >> T; \
while (T--)
#define endl '\n'
#define debug(P) cout << #P << " = " << P << endl;
#define FILE freopen("input.txt", "r", stdin)
using namespace std;
const int MAXN = 100001;
const int mod = 1000000007;
typedef long long ll;
int n, m;
vector<int> adj[MAXN];
ll dp1[MAXN];
ll dp2[MAXN];
void dfs1(int x, int p) {
dp1[x] = 1;
for (int c : adj[x]) {
if (c != p) {
dfs1(c, x);
dp1[x] = dp1[x] * (dp1[c] + 1) % m;
}
}
}
void dfs2(int x, int p) {
vector<ll> sf;
ll mul = 1;
sf.push_back(mul);
for (int i = adj[x].size() - 1; i >= 0; --i) {
if (adj[x][i] != p) {
mul = (mul * (1 + dp1[adj[x][i]])) % m;
sf.push_back(mul);
}
}
mul = 1;
for (int c : adj[x]) {
if (c != p) {
ll tt = (mul * sf[sf.size() - 2]) % m;
dp2[c] = (tt * dp2[x] + 1) % m;
mul = mul * (1 + dp1[c]) % m;
sf.pop_back();
dfs2(c, x);
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dp2[1] = 1;
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; ++i) {
cout << dp1[i] * dp2[i] % m << endl;
}
} | [] | 986,676 | 986,675 | u302702755 | cpp |
p03181 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace __gnu_pbds;
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<long long, long long> ii;
typedef complex<long double> com;
const ll mod = 1e9 + 7;
ll m;
vector<vector<ll>> graph;
vector<ll> dp;
vector<vector<ll>> pre;
vector<vector<ll>> suf;
vector<ll> ans;
void dfs(ll u = 1, ll p = 0) {
dp[u] = 1;
for (ll v : graph[u]) {
if (v == p)
continue;
dfs(v, u);
dp[u] *= (dp[v] + 1);
dp[u] %= m;
}
}
void dfs1(ll u, ll p, ll v) {
ans[u] = (dp[u] * (v + 1)) % m;
pre[u].resize(graph[u].size() + 1, 1);
suf[u].resize(graph[u].size() + 1, 1);
for (int z = 0; z < graph[u].size(); z++) {
if (graph[u][z] == p) {
if (z != 0)
pre[u][z] = pre[u][z - 1];
} else if (z == 0)
pre[u][z] = dp[graph[u][z]] + 1;
else
pre[u][z] = pre[u][z - 1] * (dp[graph[u][z]] + 1);
pre[u][z] %= m;
}
for (int z = graph[u].size() - 1; z >= 0; z--) {
if (graph[u][z] == p) {
if (z != graph[u].size() - 1)
suf[u][z] = suf[u][z + 1];
}
if (z == graph[u].size() - 1)
suf[u][z] = dp[graph[u][z]] + 1;
else
suf[u][z] = suf[u][z + 1] * (dp[graph[u][z]] + 1);
suf[u][z] %= m;
}
for (int z = 0; z < graph[u].size(); z++) {
if (graph[u][z] == p)
continue;
ll value = 1;
if (z > 0)
value *= pre[u][z - 1];
value %= m;
if (z < graph[u].size() - 1)
value *= suf[u][z + 1];
value %= m;
dfs1(graph[u][z], u, (value * (v + 1)) % m);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n >> m;
graph.resize(n + 1);
for (int z = 0; z < n - 1; z++) {
ll u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
dp.resize(n + 1);
ans.resize(n + 1);
pre.resize(n + 1);
suf.resize(n + 1);
dfs();
ans[1] = dp[1];
pre[1].resize(graph[1].size() + 1, 1);
suf[1].resize(graph[1].size() + 1, 1);
for (int z = 0; z < graph[1].size(); z++) {
if (z == 0)
pre[1][z] = dp[graph[1][z]] + 1;
else
pre[1][z] = pre[1][z - 1] * (dp[graph[1][z]] + 1);
pre[1][z] %= m;
}
for (int z = graph[1].size() - 1; z >= 0; z--) {
if (z == graph[1].size() - 1)
suf[1][z] = dp[graph[1][z]] + 1;
else
suf[1][z] = suf[1][z + 1] * (dp[graph[1][z]] + 1);
suf[1][z] %= m;
}
for (int z = 0; z < graph[1].size(); z++) {
ll value = 1;
if (z > 0)
value *= pre[1][z - 1];
value %= m;
if (z < graph[1].size() - 1)
value *= suf[1][z + 1];
value %= m;
dfs1(graph[1][z], 1, value);
}
for (int z = 1; z <= n; z++) {
cout << (ans[z]) % m << endl;
}
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace __gnu_pbds;
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<long long, long long> ii;
typedef complex<long double> com;
const ll mod = 1e9 + 7;
ll m;
vector<vector<ll>> graph;
vector<ll> dp;
vector<vector<ll>> pre;
vector<vector<ll>> suf;
vector<ll> ans;
void dfs(ll u = 1, ll p = 0) {
dp[u] = 1;
for (ll v : graph[u]) {
if (v == p)
continue;
dfs(v, u);
dp[u] *= (dp[v] + 1);
dp[u] %= m;
}
}
void dfs1(ll u, ll p, ll v) {
ans[u] = (dp[u] * (v + 1)) % m;
pre[u].resize(graph[u].size() + 1, 1);
suf[u].resize(graph[u].size() + 1, 1);
for (int z = 0; z < graph[u].size(); z++) {
if (graph[u][z] == p) {
if (z != 0)
pre[u][z] = pre[u][z - 1];
continue;
} else if (z == 0)
pre[u][z] = dp[graph[u][z]] + 1;
else
pre[u][z] = pre[u][z - 1] * (dp[graph[u][z]] + 1);
pre[u][z] %= m;
}
for (int z = graph[u].size() - 1; z >= 0; z--) {
if (graph[u][z] == p) {
if (z != graph[u].size() - 1)
suf[u][z] = suf[u][z + 1];
continue;
}
if (z == graph[u].size() - 1)
suf[u][z] = dp[graph[u][z]] + 1;
else
suf[u][z] = suf[u][z + 1] * (dp[graph[u][z]] + 1);
suf[u][z] %= m;
}
for (int z = 0; z < graph[u].size(); z++) {
if (graph[u][z] == p)
continue;
ll value = 1;
if (z > 0)
value *= pre[u][z - 1];
value %= m;
if (z < graph[u].size() - 1)
value *= suf[u][z + 1];
value %= m;
dfs1(graph[u][z], u, (value * (v + 1)) % m);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n >> m;
graph.resize(n + 1);
for (int z = 0; z < n - 1; z++) {
ll u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
dp.resize(n + 1);
ans.resize(n + 1);
pre.resize(n + 1);
suf.resize(n + 1);
dfs();
ans[1] = dp[1];
pre[1].resize(graph[1].size() + 1, 1);
suf[1].resize(graph[1].size() + 1, 1);
for (int z = 0; z < graph[1].size(); z++) {
if (z == 0)
pre[1][z] = dp[graph[1][z]] + 1;
else
pre[1][z] = pre[1][z - 1] * (dp[graph[1][z]] + 1);
pre[1][z] %= m;
}
for (int z = graph[1].size() - 1; z >= 0; z--) {
if (z == graph[1].size() - 1)
suf[1][z] = dp[graph[1][z]] + 1;
else
suf[1][z] = suf[1][z + 1] * (dp[graph[1][z]] + 1);
suf[1][z] %= m;
}
for (int z = 0; z < graph[1].size(); z++) {
ll value = 1;
if (z > 0)
value *= pre[1][z - 1];
value %= m;
if (z < graph[1].size() - 1)
value *= suf[1][z + 1];
value %= m;
dfs1(graph[1][z], 1, value);
}
for (int z = 1; z <= n; z++) {
cout << (ans[z]) % m << endl;
}
}
| [] | 986,677 | 986,678 | u553927381 | cpp |
p03181 | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pii pair<int, int>
#define F first
#define S second
#define pb push_back
const int N = 101010;
using namespace std;
vector<int> g[N];
vector<ll> v[N], be[N], en[N];
ll dp[N], ans[N];
int n, M;
ll dfs1(int i, int p) {
dp[i] = 1;
for (int j : g[i]) {
if (j != p) {
ll tmp = (dfs1(j, i) + 1) % M;
v[i].pb(tmp);
dp[i] = (dp[i] * tmp) % M;
} else
v[i].pb(-1);
}
return dp[i];
}
void dfs2(int i, int p, ll a) {
int z = v[i].size();
if (z) {
be[i].resize(z);
en[i].resize(z);
be[i][0] = 1;
en[i][z - 1] = 1;
}
for (int j = 1; j < z; j++) {
if (v[i][j - 1] < 0)
be[i][j] = (be[i][j - 1] * a) % M;
else
be[i][j] = (be[i][j - 1] * v[i][j - 1]) % M;
}
for (int j = z - 2; j >= 0; j--) {
if (v[i][j] < 0)
en[i][j] = (en[i][j + 1] * a) % M;
else
en[i][j] = (en[i][j + 1] * v[i][j + 1]) % M;
}
ans[i] = 1;
for (int j = 0; j < z; j++) {
if (v[i][j] < 0) {
ans[i] = (ans[i] * a) % M;
continue;
} else
ans[i] = (ans[i] * v[i][j]) % M;
int k = g[i][j];
dfs2(k, i, (be[i][j] * en[i][j] + 1) % M);
}
}
int main() {
cin >> n >> M;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a].pb(b);
g[b].pb(a);
}
dfs1(1, 0);
dfs2(1, 0, 1);
for (int i = 1; i <= n; i++)
cout << ans[i] << '\n';
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pii pair<int, int>
#define F first
#define S second
#define pb push_back
const int N = 101010;
using namespace std;
vector<int> g[N];
vector<ll> v[N], be[N], en[N];
ll dp[N], ans[N];
int n, M;
ll dfs1(int i, int p) {
dp[i] = 1;
for (int j : g[i]) {
if (j != p) {
ll tmp = (dfs1(j, i) + 1) % M;
v[i].pb(tmp);
dp[i] = (dp[i] * tmp) % M;
} else
v[i].pb(-1);
}
return dp[i];
}
void dfs2(int i, int p, ll a) {
int z = v[i].size();
if (z) {
be[i].resize(z);
en[i].resize(z);
be[i][0] = 1;
en[i][z - 1] = 1;
}
for (int j = 1; j < z; j++) {
if (v[i][j - 1] < 0)
be[i][j] = (be[i][j - 1] * a) % M;
else
be[i][j] = (be[i][j - 1] * v[i][j - 1]) % M;
}
for (int j = z - 2; j >= 0; j--) {
if (v[i][j + 1] < 0)
en[i][j] = (en[i][j + 1] * a) % M;
else
en[i][j] = (en[i][j + 1] * v[i][j + 1]) % M;
}
ans[i] = 1;
for (int j = 0; j < z; j++) {
if (v[i][j] < 0) {
ans[i] = (ans[i] * a) % M;
continue;
} else
ans[i] = (ans[i] * v[i][j]) % M;
int k = g[i][j];
dfs2(k, i, (be[i][j] * en[i][j] + 1) % M);
}
}
int main() {
cin >> n >> M;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a].pb(b);
g[b].pb(a);
}
dfs1(1, 0);
dfs2(1, 0, 1);
for (int i = 1; i <= n; i++)
cout << ans[i] << '\n';
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 986,679 | 986,680 | u143741615 | cpp |
p03181 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX = 1e5;
ll m;
vector<int> G[MAX], H[MAX];
vector<int> color(MAX, 0);
vector<ll>
dp1(MAX); // dp1[i]:頂点iを根とした木で, 頂点iを黒く塗る方法の数(mod m)
void dfs1(int v) {
color[v] = 1;
ll keep = 1;
for (int i = 0; i < G[v].size(); i++) {
if (color[G[v][i]] == 0) {
dfs1(G[v][i]);
H[v].emplace_back(G[v][i]);
}
keep *= dp1[G[v][i]] + 1;
keep %= m;
}
color[v] = 2;
dp1[v] = keep;
return;
}
vector<ll> dp2(MAX); // dp2[i]:頂点iから親方向に見たsubtreeで,
// 頂点iを黒く塗る方法の数(mod m)
void dfs2(int v) {
vector<ll> l(H[v].size()), r(H[v].size()); // 左右からの累積積
for (int i = 0; i < H[v].size(); i++) {
l.at(i) = dp1[H[v][i]] + 1;
if (i > 0)
l.at(i) *= l.at(i - 1);
l.at(i) %= m;
}
for (int i = H[v].size() - 1; i >= 0; i--) {
r.at(i) = dp1[H[v][i]] + 1;
if (i < H[v].size() - 1)
r.at(i) *= r.at(i + 1);
r.at(i) %= m;
}
ll keep = 1;
if (v != 0)
keep *= dp2[v] + 1;
keep %= m;
for (int i = 0; i < H[v].size(); i++) {
ll pro = 1;
if (i > 0)
pro *= l.at(i - 1);
pro %= m;
if (i < H[v].size() - 1)
pro *= r.at(i + 1);
pro %= m;
dp2[H[v][i]] = (keep * pro + 1) % m;
dfs2(H[v][i]);
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// 無向(有向)グラフの隣接リスト
int n; // n:頂点数
cin >> n >> m;
// vector<int> G[n]; // G:頂点数がnのグラフを表す隣接リスト
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].emplace_back(v);
G[v].emplace_back(u); // 有向グラフではこの行をコメントアウト
}
dfs1(0);
dfs2(0);
for (int i = 0; i < n; i++) {
if (i == 0)
cout << dp1[i] << '\n';
else
cout << (dp1[i] * dp2[i]) % m << '\n';
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX = 1e5;
ll m;
vector<int> G[MAX], H[MAX];
vector<int> color(MAX, 0);
vector<ll>
dp1(MAX); // dp1[i]:頂点iを根とした木で, 頂点iを黒く塗る方法の数(mod m)
void dfs1(int v) {
color[v] = 1;
ll keep = 1;
for (int i = 0; i < G[v].size(); i++) {
if (color[G[v][i]] == 0) {
dfs1(G[v][i]);
H[v].emplace_back(G[v][i]);
}
keep *= dp1[G[v][i]] + 1;
keep %= m;
}
color[v] = 2;
dp1[v] = keep;
return;
}
vector<ll> dp2(MAX); // dp2[i]:頂点iから親方向に見たsubtreeで,
// 頂点iを黒く塗る方法の数(mod m)
void dfs2(int v) {
vector<ll> l(H[v].size()), r(H[v].size()); // 左右からの累積積
for (int i = 0; i < H[v].size(); i++) {
l.at(i) = dp1[H[v][i]] + 1;
if (i > 0)
l.at(i) *= l.at(i - 1);
l.at(i) %= m;
}
for (int i = H[v].size() - 1; i >= 0; i--) {
r.at(i) = dp1[H[v][i]] + 1;
if (i < H[v].size() - 1)
r.at(i) *= r.at(i + 1);
r.at(i) %= m;
}
ll keep = 1;
if (v != 0)
keep *= dp2[v];
keep %= m;
for (int i = 0; i < H[v].size(); i++) {
ll pro = 1;
if (i > 0)
pro *= l.at(i - 1);
pro %= m;
if (i < H[v].size() - 1)
pro *= r.at(i + 1);
pro %= m;
dp2[H[v][i]] = (keep * pro + 1) % m;
dfs2(H[v][i]);
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// 無向(有向)グラフの隣接リスト
int n; // n:頂点数
cin >> n >> m;
// vector<int> G[n]; // G:頂点数がnのグラフを表す隣接リスト
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].emplace_back(v);
G[v].emplace_back(u); // 有向グラフではこの行をコメントアウト
}
dfs1(0);
dfs2(0);
for (int i = 0; i < n; i++) {
if (i == 0)
cout << dp1[i] << '\n';
else
cout << (dp1[i] * dp2[i]) % m << '\n';
}
} | [
"expression.operation.binary.remove"
] | 986,689 | 986,690 | u979163294 | cpp |
p03178 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
LL MOD = 1000000007;
int main() {
string K;
int D;
cin >> K >> D;
int N = K.size();
vector<vector<LL>> dp(N + 1, vector<LL>(D, 0));
dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
for (int j = 0; j < D; j++) {
for (int k = 0; k < 10; k++) {
int to = (j + k) % D;
dp[i][to] += dp[i - 1][j];
dp[i][to] %= MOD;
}
}
}
/*
for(int i=0; i<N; i++, cout << endl)
for(int j=0; j<D; j++) {
cout << dp[i][j] << " ";
}
*/
int sum = 0;
LL ans = MOD - 1;
for (int i = 0; i < N; i++) {
int digit = (K[i] - '0');
for (int j = 0; j < digit; j++) {
int ind = ((0 - sum - j) + 10 * D) % D;
ans += dp[N - i - 1][ind];
ans %= MOD;
}
sum += digit;
sum %= MOD;
}
// cout << sum << endl;
if (sum % D == 0)
ans++;
cout << ans % MOD << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
LL MOD = 1000000007;
int main() {
string K;
int D;
cin >> K >> D;
int N = K.size();
vector<vector<LL>> dp(N + 1, vector<LL>(D, 0));
dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
for (int j = 0; j < D; j++) {
for (int k = 0; k < 10; k++) {
int to = (j + k) % D;
dp[i][to] += dp[i - 1][j];
dp[i][to] %= MOD;
}
}
}
/*
for(int i=0; i<N; i++, cout << endl)
for(int j=0; j<D; j++) {
cout << dp[i][j] << " ";
}
*/
int sum = 0;
LL ans = MOD - 1;
for (int i = 0; i < N; i++) {
int digit = (K[i] - '0');
for (int j = 0; j < digit; j++) {
int ind = ((0 - sum - j) + 10 * D) % D;
ans += dp[N - i - 1][ind];
ans %= MOD;
}
sum += digit;
sum %= D;
}
// cout << sum << endl;
if (sum % D == 0)
ans++;
cout << ans % MOD << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 986,310 | 986,311 | u806201407 | cpp |
p03178 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = (1 << 30);
const ll inf = (1LL << 60LL);
const int maxn = 1e4 + 10;
const ll MOD = 1e9 + 7;
string s;
int D, n;
int dp[10005][105][3];
int rek(int at, int modulo, int is_bigger) {
if (at == n) {
if (modulo == 0) {
return 1;
}
return 0;
}
if (dp[at][modulo][is_bigger] != -1) {
return dp[at][modulo][is_bigger];
}
int ret = 0;
int till;
if (is_bigger == 0) {
till = (s[at] - '0');
} else {
till = 9;
}
for (int i = 0; i <= till; i++) {
int new_modulo = modulo;
new_modulo += i;
new_modulo %= D;
int big_tmp = is_bigger;
if (is_bigger == 0 and i < (s[at] - '0')) {
big_tmp = 1;
}
ret += rek(at + 1, new_modulo, big_tmp);
if (ret >= MOD) {
ret -= MOD;
}
}
return dp[at][modulo][is_bigger] = ret;
}
int main(int argc, const char *argv[]) {
ios_base::sync_with_stdio(false);
cin >> s >> D;
n = (int)s.length();
memset(dp, -1, sizeof dp);
int ret = rek(0, 0, 1);
ret -= 1;
if (ret < 0) {
ret += MOD;
}
cout << ret << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = (1 << 30);
const ll inf = (1LL << 60LL);
const int maxn = 1e4 + 10;
const ll MOD = 1e9 + 7;
string s;
int D, n;
int dp[10005][105][3];
int rek(int at, int modulo, int is_bigger) {
if (at == n) {
if (modulo == 0) {
return 1;
}
return 0;
}
if (dp[at][modulo][is_bigger] != -1) {
return dp[at][modulo][is_bigger];
}
int ret = 0;
int till;
if (is_bigger == 0) {
till = (s[at] - '0');
} else {
till = 9;
}
for (int i = 0; i <= till; i++) {
int new_modulo = modulo;
new_modulo += i;
new_modulo %= D;
int big_tmp = is_bigger;
if (is_bigger == 0 and i < (s[at] - '0')) {
big_tmp = 1;
}
ret += rek(at + 1, new_modulo, big_tmp);
if (ret >= MOD) {
ret -= MOD;
}
}
return dp[at][modulo][is_bigger] = ret;
}
int main(int argc, const char *argv[]) {
ios_base::sync_with_stdio(false);
cin >> s >> D;
n = (int)s.length();
memset(dp, -1, sizeof dp);
int ret = rek(0, 0, 0);
ret -= 1;
if (ret < 0) {
ret += MOD;
}
cout << ret << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 986,338 | 986,339 | u694083533 | cpp |
p03178 | #include <bits/stdc++.h>
using namespace std;
int i, j, ans = 0, n, m, d, l, f[10001][101][2];
char a[10001];
int main() {
scanf("%s", a);
scanf("%d", &d);
n = strlen(a);
f[0][0][1] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < d; j++) {
for (l = 0; l <= 9; l++) {
f[i + 1][(j + l) % d][0] =
(f[i + 1][(j + l) % d][0] + f[i][j][0]) % 1000000007;
}
for (l = 0; l <= a[i] - '0'; l++) {
if (l == a[i] - '0')
f[i + 1][(j + l) % d][1] =
(f[i][j][1] + f[i + 1][(j + l) % d][1]) % 1000000007;
else
f[i + 1][(j + l) % d][0] =
(f[i + 1][(j + l) % d][0] + f[i][j][1]) % 1000000007;
}
}
}
printf("%d", (f[n][0][0] + f[n][0][1] + 1000000007 - 1) % 100000007);
} | #include <bits/stdc++.h>
using namespace std;
int i, j, ans = 0, n, m, d, l, f[10001][101][2];
char a[10001];
int main() {
scanf("%s", a);
scanf("%d", &d);
n = strlen(a);
f[0][0][1] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < d; j++) {
for (l = 0; l <= 9; l++) {
f[i + 1][(j + l) % d][0] =
(f[i + 1][(j + l) % d][0] + f[i][j][0]) % 1000000007;
}
for (l = 0; l <= a[i] - '0'; l++) {
if (l == a[i] - '0')
f[i + 1][(j + l) % d][1] =
(f[i][j][1] + f[i + 1][(j + l) % d][1]) % 1000000007;
else
f[i + 1][(j + l) % d][0] =
(f[i + 1][(j + l) % d][0] + f[i][j][1]) % 1000000007;
}
}
}
printf("%d", (f[n][0][0] + f[n][0][1] + 1000000007 - 1) % 1000000007);
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 986,350 | 986,351 | u806074801 | cpp |
p03178 | #include <bits/stdc++.h>
using namespace std;
long long f[101], tmp[101];
char k[10001];
int main() {
int l, i, d, a = 0, b, j, ans = 0;
scanf("%s", k);
scanf("%d", &d);
l = strlen(k);
for (i = 0; i < l; i++)
a += k[i] - '0';
f[0] = 1;
a %= d;
if (a == 0)
ans++;
l--;
while (l >= 0) {
if (k[l] != '0') {
b = k[l] - '0';
a -= b;
while (a < 0)
a += d;
if (a)
j = d - a;
else
j = 0;
for (i = 0; i < b; i++) {
ans += f[j--];
if (j < 0)
j += d;
}
ans %= 1000000007;
}
tmp[0] = 0;
j = d - 1;
for (i = 0; i < 9; i++) {
tmp[0] += f[j--];
if (j < 0)
j += d;
tmp[0] %= 1000000007;
}
for (i = 1; i < d; i++) {
j++;
tmp[i] = tmp[i - 1] + f[i - 1] - f[j % d];
}
for (i = 0; i < d; i++) {
f[i] = f[i] + tmp[i];
f[i] %= 1000000007;
f[i] += 1000000007;
f[i] %= 1000000007;
}
l--;
}
ans--;
if (ans < 0)
ans += 1000000007;
printf("%d", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long f[101], tmp[101];
char k[10001];
int main() {
int l, i, d, a = 0, b, j;
long long ans = 0;
scanf("%s", k);
scanf("%d", &d);
l = strlen(k);
for (i = 0; i < l; i++)
a += k[i] - '0';
f[0] = 1;
a %= d;
if (a == 0)
ans++;
l--;
while (l >= 0) {
if (k[l] != '0') {
b = k[l] - '0';
a -= b;
while (a < 0)
a += d;
if (a)
j = d - a;
else
j = 0;
for (i = 0; i < b; i++) {
ans += f[j--];
if (j < 0)
j += d;
}
ans %= 1000000007;
}
tmp[0] = 0;
j = d - 1;
for (i = 0; i < 9; i++) {
tmp[0] += f[j--];
if (j < 0)
j += d;
tmp[0] %= 1000000007;
}
for (i = 1; i < d; i++) {
j++;
tmp[i] = tmp[i - 1] + f[i - 1] - f[j % d];
}
for (i = 0; i < d; i++) {
f[i] = f[i] + tmp[i];
f[i] %= 1000000007;
f[i] += 1000000007;
f[i] %= 1000000007;
}
l--;
}
ans--;
if (ans < 0)
ans += 1000000007;
printf("%d", ans);
return 0;
} | [
"variable_declaration.type.widen.change"
] | 986,356 | 986,357 | u314499126 | cpp |
p03178 | #include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const int Mod = 1000000007;
const int maxn = 1e4 + 10;
ll dp[maxn][105];
int d;
char str[maxn];
int a[maxn];
ll dfs(int pos, int left, bool limit) {
if (pos == -1)
return (left == 0);
if (!limit && dp[pos][left] != -1)
return dp[pos][left];
int up = limit ? a[pos] : 9;
ll tmp = 0;
for (int i = 0; i <= up; i++) {
tmp = (tmp + dfs(pos - 1, (left - i + d) % d, limit && i == a[pos])) % Mod;
}
if (!limit)
dp[pos][left] = tmp;
return tmp;
}
ll solve() {
int len = strlen(str);
int pos = 0;
for (int i = len - 1; i >= 0; i--)
a[pos++] = str[i] - '0';
return dfs(pos - 1, 0, true);
}
int main() {
scanf("%s%d", str, &d);
memset(dp, -1, sizeof(dp));
printf("%lld\n", (solve() - 1 + Mod) % Mod);
return 0;
}
| #include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const int Mod = 1000000007;
const int maxn = 1e4 + 10;
ll dp[maxn][105];
int d;
char str[maxn];
int a[maxn];
ll dfs(int pos, int left, bool limit) {
if (pos == -1)
return (left == 0);
if (!limit && dp[pos][left] != -1)
return dp[pos][left];
int up = limit ? a[pos] : 9;
ll tmp = 0;
for (int i = 0; i <= up; i++) {
tmp = (tmp + dfs(pos - 1, (left - i % d + d) % d, limit && i == a[pos])) %
Mod;
}
if (!limit)
dp[pos][left] = tmp;
return tmp;
}
ll solve() {
int len = strlen(str);
int pos = 0;
for (int i = len - 1; i >= 0; i--)
a[pos++] = str[i] - '0';
return dfs(pos - 1, 0, true);
}
int main() {
scanf("%s%d", str, &d);
memset(dp, -1, sizeof(dp));
printf("%lld\n", (solve() - 1 + Mod) % Mod);
return 0;
}
| [
"assignment.change"
] | 986,385 | 986,386 | u937339263 | cpp |
p03178 | #include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define PB push_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
const int MAXD = 105;
const int MAXN = 10005;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int LOG = 18;
const double EPS = 1e-9;
const double PI = 3.1415926535;
int dp[MAXN][MAXD];
int add(const int &a, const int &b) {
if (a + b >= MOD)
return (a + b - MOD);
return (a + b);
}
int subt(const int &a, const int &b) {
if (a - b < 0)
return (a - b + MOD);
return (a - b);
}
int main() {
int D, ans;
string K;
cin >> K >> D;
int sz = K.size();
for (int i = 0; i <= K[0] - '0' - 1; i++)
dp[0][i] = 1;
int sum_of_max = (K[0] - '0') % D;
for (int i = 0; i < sz - 1; i++) {
int next_znam = K[i + 1] - '0';
for (int j = 0; j < D; j++)
for (int znam = 0; znam <= 9; znam++)
dp[i + 1][(j + znam) % D] = add(dp[i + 1][(j + znam) % D], dp[i][j]);
for (int znam = 0; znam <= next_znam - 1; znam++)
dp[i + 1][(sum_of_max + znam) % D] =
add(dp[i + 1][(sum_of_max + znam) % D], 1);
sum_of_max = (sum_of_max + next_znam) % D;
}
if (sum_of_max == 0)
cout << dp[sz - 1][0] << endl;
else
cout << subt(dp[sz - 1][0], 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define PB push_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
const int MAXD = 105;
const int MAXN = 10005;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int LOG = 18;
const double EPS = 1e-9;
const double PI = 3.1415926535;
int dp[MAXN][MAXD];
int add(const int &a, const int &b) {
if (a + b >= MOD)
return (a + b - MOD);
return (a + b);
}
int subt(const int &a, const int &b) {
if (a - b < 0)
return (a - b + MOD);
return (a - b);
}
int main() {
int D, ans;
string K;
cin >> K >> D;
int sz = K.size();
for (int i = 0; i <= K[0] - '0' - 1; i++)
dp[0][i % D] += 1;
int sum_of_max = (K[0] - '0') % D;
for (int i = 0; i < sz - 1; i++) {
int next_znam = K[i + 1] - '0';
for (int j = 0; j < D; j++)
for (int znam = 0; znam <= 9; znam++)
dp[i + 1][(j + znam) % D] = add(dp[i + 1][(j + znam) % D], dp[i][j]);
for (int znam = 0; znam <= next_znam - 1; znam++)
dp[i + 1][(sum_of_max + znam) % D] =
add(dp[i + 1][(sum_of_max + znam) % D], 1);
sum_of_max = (sum_of_max + next_znam) % D;
}
if (sum_of_max == 0)
cout << dp[sz - 1][0] << endl;
else
cout << subt(dp[sz - 1][0], 1) << endl;
return 0;
}
| [
"assignment.change",
"assignment.value.change"
] | 986,389 | 986,390 | u215554660 | cpp |
p03178 | // MLEが動かない
//セグフォは関数内で要素のでかい配列を定義しているから
// todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
//現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define double long double
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
struct Tri {
int f, s, t;
Tri() { f = -1, s = -1, t = -1; }
Tri(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const Tri &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const Tri &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
int operator[](int i) {
assert(i < 3);
switch (i) {
case 0:
return f;
break;
case 1:
return s;
break;
default:
return t;
break;
}
}
};
//別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vd = vector<double>;
#define vvd(a, b, c) vec<vd> a(b, vd(c))
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
// using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using vt = vector<Tri>;
#define vvt(a, b, c) vec<vt> a(b, vt(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define mmap multimap
#define F first
#define S second
//定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
//配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
//コンテナ
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
//繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
//入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add2(a, b, n) rep(i, n) a.pb(in()), b.pb(in());
#define add2d(a, b, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1);
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define add3d(a, b, c, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addn(a, n) \
a.resize(n); \
na(a, n);
#define addnd(a, n) \
a.resize(n); \
na(a, n); \
rep(i, n) a[i]--;
//出力
template <class T> void out(vector<T> x) {
for (auto &&v : x)
cout << v << " ";
cout << "" << endl;
}
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
//デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
//よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
//順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
//単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; 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;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
//便利関数
void OLE() {
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void TLE() {
int a = 1;
while (a)
cout << a << endl;
}
void RE() {
int a = 1 / (x4[0] / MOD);
cout << a << endl;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
OLE();
return -1;
} else
return (a + b - 1) / b;
}
ll sqrt(ll a) {
if (a < 0)
OLE();
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
int keta(int v) {
int cou = 0;
while (v) {
cou++;
v %= 10;
}
return cou;
}
//変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(vector<T> a) { return *min_element(all(a)); }
template <class T> T max(vector<T> a) { return *max_element(all(a)); }
template <class T> T min(T a[]) {
T res = a[0];
rep(i, sz(a)) chmin(res, a[i]);
return res;
}
template <class T> T max(T a[]) {
T res = a[0];
rep(i, sz(a)) chmax(res, a[i]);
return res;
}
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
///要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
//初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; //最下位の1
ll y = mask + x; //連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoal(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
int ctoi(char c) { return c - '0'; }
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
//要素が見つからなかったときに困る
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n, root = -1;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
bool isleaf(int v) {
assert(root != -1);
return g[v].size() == 1 && g[v][0].from != root;
}
vector<edge<T>> operator[](int i) { return g[i]; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
if (!(0 <= s && s < g.n))
OLE();
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
//たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
//機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
//閉路がなければtrue
bool topo(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.to] == 0) st.push(e.to);
}
return res.size() == n;
}
//辞書順最小 トポロジカルソート
bool topos(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
set<int> st;
rep(i, n) if (nyu[i] == 0) st.insert(i);
while (st.size()) {
int i = *st.begin();
st.erase(st.begin());
res.pb(i);
fora(e, g[i]) if (--nyu[e.to] == 0) st.insert(e.to);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
int n, k, m, h, w, x, y, q, r;
vi a, b, c;
int d;
string s;
v3i(dp, k5, 121, 2);
int ds(int i, int m, bool ti) {
if (dp[i][m][ti] >= 0)
return dp[i][m][ti];
if (i == n)
return m == 0;
int lim = (ti ? ctoi(s[i]) : 9);
mint res;
rep(j, lim + 1) { res += ds(i + 1, (m + j) % d, ti && j == lim); }
return dp[i][m][ti] = res;
}
signed main() {
cin >> s >> d;
n = s.length();
fill(dp, -1);
setMod();
cout << ds(0, 0, 1) - 1 << endl;
return 0;
}
| // MLEが動かない
//セグフォは関数内で要素のでかい配列を定義しているから
// todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
//現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define double long double
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
struct Tri {
int f, s, t;
Tri() { f = -1, s = -1, t = -1; }
Tri(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const Tri &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const Tri &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
int operator[](int i) {
assert(i < 3);
switch (i) {
case 0:
return f;
break;
case 1:
return s;
break;
default:
return t;
break;
}
}
};
//別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vd = vector<double>;
#define vvd(a, b, c) vec<vd> a(b, vd(c))
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
// using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using vt = vector<Tri>;
#define vvt(a, b, c) vec<vt> a(b, vt(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define mmap multimap
#define F first
#define S second
//定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
//配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
//コンテナ
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
//繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
//入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add2(a, b, n) rep(i, n) a.pb(in()), b.pb(in());
#define add2d(a, b, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1);
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define add3d(a, b, c, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addn(a, n) \
a.resize(n); \
na(a, n);
#define addnd(a, n) \
a.resize(n); \
na(a, n); \
rep(i, n) a[i]--;
//出力
template <class T> void out(vector<T> x) {
for (auto &&v : x)
cout << v << " ";
cout << "" << endl;
}
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
//デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
//よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
//順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
//単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; 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;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
//便利関数
void OLE() {
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void TLE() {
int a = 1;
while (a)
cout << a << endl;
}
void RE() {
int a = 1 / (x4[0] / MOD);
cout << a << endl;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
OLE();
return -1;
} else
return (a + b - 1) / b;
}
ll sqrt(ll a) {
if (a < 0)
OLE();
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
int keta(int v) {
int cou = 0;
while (v) {
cou++;
v %= 10;
}
return cou;
}
//変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(vector<T> a) { return *min_element(all(a)); }
template <class T> T max(vector<T> a) { return *max_element(all(a)); }
template <class T> T min(T a[]) {
T res = a[0];
rep(i, sz(a)) chmin(res, a[i]);
return res;
}
template <class T> T max(T a[]) {
T res = a[0];
rep(i, sz(a)) chmax(res, a[i]);
return res;
}
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
///要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
//初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; //最下位の1
ll y = mask + x; //連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoal(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
int ctoi(char c) { return c - '0'; }
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
//要素が見つからなかったときに困る
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n, root = -1;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
bool isleaf(int v) {
assert(root != -1);
return g[v].size() == 1 && g[v][0].from != root;
}
vector<edge<T>> operator[](int i) { return g[i]; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
if (!(0 <= s && s < g.n))
OLE();
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
//たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
//機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
//閉路がなければtrue
bool topo(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.to] == 0) st.push(e.to);
}
return res.size() == n;
}
//辞書順最小 トポロジカルソート
bool topos(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
set<int> st;
rep(i, n) if (nyu[i] == 0) st.insert(i);
while (st.size()) {
int i = *st.begin();
st.erase(st.begin());
res.pb(i);
fora(e, g[i]) if (--nyu[e.to] == 0) st.insert(e.to);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
int n, k, m, h, w, x, y, q, r;
vi a, b, c;
int d;
string s;
v3i(dp, k4, 121, 2);
mint ds(int i, int m, bool ti) {
if (dp[i][m][ti] >= 0)
return dp[i][m][ti];
if (i == n)
return m == 0;
int lim = (ti ? ctoi(s[i]) : 9);
mint res;
rep(j, lim + 1) { res += ds(i + 1, (m + j) % d, ti && j == lim); }
return dp[i][m][ti] = res;
}
signed main() {
cin >> s >> d;
n = s.length();
fill(dp, -1);
setMod();
cout << ds(0, 0, 1) - 1 << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 986,393 | 986,394 | u986437843 | cpp |
p03178 | // MLEが動かない
//セグフォは関数内で要素のでかい配列を定義しているから
// todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
//現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define double long double
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
struct Tri {
int f, s, t;
Tri() { f = -1, s = -1, t = -1; }
Tri(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const Tri &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const Tri &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
int operator[](int i) {
assert(i < 3);
switch (i) {
case 0:
return f;
break;
case 1:
return s;
break;
default:
return t;
break;
}
}
};
//別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vd = vector<double>;
#define vvd(a, b, c) vec<vd> a(b, vd(c))
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
// using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using vt = vector<Tri>;
#define vvt(a, b, c) vec<vt> a(b, vt(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define mmap multimap
#define F first
#define S second
//定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
//配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
//コンテナ
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
//繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
//入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add2(a, b, n) rep(i, n) a.pb(in()), b.pb(in());
#define add2d(a, b, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1);
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define add3d(a, b, c, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addn(a, n) \
a.resize(n); \
na(a, n);
#define addnd(a, n) \
a.resize(n); \
na(a, n); \
rep(i, n) a[i]--;
//出力
template <class T> void out(vector<T> x) {
for (auto &&v : x)
cout << v << " ";
cout << "" << endl;
}
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
//デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
//よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
//順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
//単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; 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;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
//便利関数
void OLE() {
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void TLE() {
int a = 1;
while (a)
cout << a << endl;
}
void RE() {
int a = 1 / (x4[0] / MOD);
cout << a << endl;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
OLE();
return -1;
} else
return (a + b - 1) / b;
}
ll sqrt(ll a) {
if (a < 0)
OLE();
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
int keta(int v) {
int cou = 0;
while (v) {
cou++;
v %= 10;
}
return cou;
}
//変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(vector<T> a) { return *min_element(all(a)); }
template <class T> T max(vector<T> a) { return *max_element(all(a)); }
template <class T> T min(T a[]) {
T res = a[0];
rep(i, sz(a)) chmin(res, a[i]);
return res;
}
template <class T> T max(T a[]) {
T res = a[0];
rep(i, sz(a)) chmax(res, a[i]);
return res;
}
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
///要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
//初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; //最下位の1
ll y = mask + x; //連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoal(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
int ctoi(char c) { return c - '0'; }
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
//要素が見つからなかったときに困る
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n, root = -1;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
bool isleaf(int v) {
assert(root != -1);
return g[v].size() == 1 && g[v][0].from != root;
}
vector<edge<T>> operator[](int i) { return g[i]; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
if (!(0 <= s && s < g.n))
OLE();
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
//たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
//機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
//閉路がなければtrue
bool topo(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.to] == 0) st.push(e.to);
}
return res.size() == n;
}
//辞書順最小 トポロジカルソート
bool topos(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
set<int> st;
rep(i, n) if (nyu[i] == 0) st.insert(i);
while (st.size()) {
int i = *st.begin();
st.erase(st.begin());
res.pb(i);
fora(e, g[i]) if (--nyu[e.to] == 0) st.insert(e.to);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
int n, k, m, h, w, x, y, q, r;
vi a, b, c;
int d;
string s;
v3i(dp, k5, 121, 2);
int ds(int i, int m, bool ti) {
if (dp[i][m][ti] >= 0)
return dp[i][m][ti];
if (i == n)
return m == 0;
int lim = (ti ? ctoi(s[i]) : 9);
mint res;
rep(j, lim + 1) { res += ds(i + 1, (m + j) % d, ti && j == lim); }
return dp[i][m][ti] = res;
}
signed main() {
cin >> s >> d;
n = s.length();
fill(dp, -1);
cout << ds(0, 0, 1) - 1 << endl;
return 0;
}
| // MLEが動かない
//セグフォは関数内で要素のでかい配列を定義しているから
// todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
//現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define double long double
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
struct Tri {
int f, s, t;
Tri() { f = -1, s = -1, t = -1; }
Tri(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const Tri &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const Tri &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
int operator[](int i) {
assert(i < 3);
switch (i) {
case 0:
return f;
break;
case 1:
return s;
break;
default:
return t;
break;
}
}
};
//別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vd = vector<double>;
#define vvd(a, b, c) vec<vd> a(b, vd(c))
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
// using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using vt = vector<Tri>;
#define vvt(a, b, c) vec<vt> a(b, vt(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define mmap multimap
#define F first
#define S second
//定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
//配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
//コンテナ
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
//繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
//入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add2(a, b, n) rep(i, n) a.pb(in()), b.pb(in());
#define add2d(a, b, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1);
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define add3d(a, b, c, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addn(a, n) \
a.resize(n); \
na(a, n);
#define addnd(a, n) \
a.resize(n); \
na(a, n); \
rep(i, n) a[i]--;
//出力
template <class T> void out(vector<T> x) {
for (auto &&v : x)
cout << v << " ";
cout << "" << endl;
}
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
//デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
//よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
//順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
//単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; 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;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
//便利関数
void OLE() {
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void TLE() {
int a = 1;
while (a)
cout << a << endl;
}
void RE() {
int a = 1 / (x4[0] / MOD);
cout << a << endl;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
OLE();
return -1;
} else
return (a + b - 1) / b;
}
ll sqrt(ll a) {
if (a < 0)
OLE();
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
int keta(int v) {
int cou = 0;
while (v) {
cou++;
v %= 10;
}
return cou;
}
//変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(vector<T> a) { return *min_element(all(a)); }
template <class T> T max(vector<T> a) { return *max_element(all(a)); }
template <class T> T min(T a[]) {
T res = a[0];
rep(i, sz(a)) chmin(res, a[i]);
return res;
}
template <class T> T max(T a[]) {
T res = a[0];
rep(i, sz(a)) chmax(res, a[i]);
return res;
}
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
///要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
//初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; //最下位の1
ll y = mask + x; //連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoal(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
int ctoi(char c) { return c - '0'; }
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
//要素が見つからなかったときに困る
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n, root = -1;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
bool isleaf(int v) {
assert(root != -1);
return g[v].size() == 1 && g[v][0].from != root;
}
vector<edge<T>> operator[](int i) { return g[i]; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
if (!(0 <= s && s < g.n))
OLE();
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
//たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
//機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
//閉路がなければtrue
bool topo(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.to] == 0) st.push(e.to);
}
return res.size() == n;
}
//辞書順最小 トポロジカルソート
bool topos(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
set<int> st;
rep(i, n) if (nyu[i] == 0) st.insert(i);
while (st.size()) {
int i = *st.begin();
st.erase(st.begin());
res.pb(i);
fora(e, g[i]) if (--nyu[e.to] == 0) st.insert(e.to);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
int n, k, m, h, w, x, y, q, r;
vi a, b, c;
int d;
string s;
v3i(dp, k4, 121, 2);
mint ds(int i, int m, bool ti) {
if (dp[i][m][ti] >= 0)
return dp[i][m][ti];
if (i == n)
return m == 0;
int lim = (ti ? ctoi(s[i]) : 9);
mint res;
rep(j, lim + 1) { res += ds(i + 1, (m + j) % d, ti && j == lim); }
return dp[i][m][ti] = res;
}
signed main() {
cin >> s >> d;
n = s.length();
fill(dp, -1);
setMod();
cout << ds(0, 0, 1) - 1 << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"call.add"
] | 986,395 | 986,394 | u986437843 | cpp |
p03178 | // finish date: 2019/2/28
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 1000000007;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
//足し算
int add(int a, int b) { return (int)(((ll)a + b + bigmod) % bigmod); }
//引き算
int sub(int a, int b) { return (int)(((ll)a - b + bigmod) % bigmod); }
int main() {
string K;
int D;
cin >> K >> D;
vvvi dp(K.length(), vvi(2, vi(D, 0)));
rep(i, K[0] - '0') dp[0][0][i % D] = 1;
dp[0][1][(K[0] - '0') % D] = 1;
rep(i, K.length() - 1) {
// dp[][0][]の場合
rep(k, D) {
rep(j, 10) {
dp[i + 1][0][(k + j) % D] = add(dp[i + 1][0][(k + j) % D], dp[i][0][k]);
}
}
// dp[][1][]の場合
rep(k, D) {
rep(j, K[i + 1] - '0') {
dp[i + 1][0][(k + j) % D] = add(dp[i + 1][0][(k + j) % D], dp[i][1][k]);
}
dp[i + 1][1][(k + (K[i + 1] - '0')) % D] =
add(dp[i + 1][1][(k + (K[i + 1] - '0')) % D], dp[i][1][k]);
}
}
cout << sub(add(dp[K.length() - 1][0][0], dp[K.length() - 1][1][0]), 1)
<< endl;
return 0;
} | // finish date: 2019/2/28
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 1000000007;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
//足し算
int add(int a, int b) { return (int)(((ll)a + b + bigmod) % bigmod); }
//引き算
int sub(int a, int b) { return (int)(((ll)a - b + bigmod) % bigmod); }
int main() {
string K;
int D;
cin >> K >> D;
vvvi dp(K.length(), vvi(2, vi(D, 0)));
rep(i, K[0] - '0') dp[0][0][i % D] += 1;
dp[0][1][(K[0] - '0') % D] += 1;
rep(i, K.length() - 1) {
// dp[][0][]の場合
rep(k, D) {
rep(j, 10) {
dp[i + 1][0][(k + j) % D] = add(dp[i + 1][0][(k + j) % D], dp[i][0][k]);
}
}
// dp[][1][]の場合
rep(k, D) {
rep(j, K[i + 1] - '0') {
dp[i + 1][0][(k + j) % D] = add(dp[i + 1][0][(k + j) % D], dp[i][1][k]);
}
dp[i + 1][1][(k + (K[i + 1] - '0')) % D] =
add(dp[i + 1][1][(k + (K[i + 1] - '0')) % D], dp[i][1][k]);
}
}
cout << sub(add(dp[K.length() - 1][0][0], dp[K.length() - 1][1][0]), 1)
<< endl;
return 0;
} | [
"assignment.value.change"
] | 986,400 | 986,401 | u285660186 | cpp |
p03178 | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const int MaxN = 1e4 + 14;
const int MaxD = 100;
int dp[MaxN][MaxD][2];
void up(int &x, int y) {
x += y;
if (x >= MOD)
x -= MOD;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("input.txt", "r", stdin);
string s;
cin >> s;
int D;
cin >> D;
for (int i = 0; i < s[0] - '0'; ++i)
dp[1][i % D][0] = 1;
dp[1][(s[0] - '0') % D][1] = 1;
for (int i = 2; i <= s.size(); ++i) {
int curD = s[i - 1] - '0';
for (int prevSum = 0; prevSum < D; ++prevSum)
for (int nextD = 0; nextD < 10; ++nextD) {
int nextSum = (prevSum + nextD) % D;
if (nextD < curD) {
up(dp[i][nextSum][0], dp[i - 1][prevSum][0]);
up(dp[i][nextSum][0], dp[i - 1][prevSum][1]);
} else if (nextD == curD) {
up(dp[i][nextSum][0], dp[i - 1][prevSum][0]);
up(dp[i][nextSum][1], dp[i - 1][prevSum][1]);
} else {
up(dp[i][nextSum][0], dp[i - 1][prevSum][0]);
}
}
}
int ans = MOD - 1;
up(ans, dp[s.size()][0][0]);
up(ans, dp[s.size()][0][1]);
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const int MaxN = 1e4 + 14;
const int MaxD = 100;
int dp[MaxN][MaxD][2];
void up(int &x, int y) {
x += y;
if (x >= MOD)
x -= MOD;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// freopen("input.txt", "r", stdin);
string s;
cin >> s;
int D;
cin >> D;
for (int i = 0; i < s[0] - '0'; ++i)
dp[1][i % D][0] += 1;
dp[1][(s[0] - '0') % D][1] += 1;
for (int i = 2; i <= s.size(); ++i) {
int curD = s[i - 1] - '0';
for (int prevSum = 0; prevSum < D; ++prevSum)
for (int nextD = 0; nextD < 10; ++nextD) {
int nextSum = (prevSum + nextD) % D;
if (nextD < curD) {
up(dp[i][nextSum][0], dp[i - 1][prevSum][0]);
up(dp[i][nextSum][0], dp[i - 1][prevSum][1]);
} else if (nextD == curD) {
up(dp[i][nextSum][0], dp[i - 1][prevSum][0]);
up(dp[i][nextSum][1], dp[i - 1][prevSum][1]);
} else {
up(dp[i][nextSum][0], dp[i - 1][prevSum][0]);
}
}
}
int ans = MOD - 1;
up(ans, dp[s.size()][0][0]);
up(ans, dp[s.size()][0][1]);
cout << ans << '\n';
return 0;
}
| [
"assignment.value.change"
] | 986,412 | 986,413 | u784576081 | cpp |
p03178 | #include <bits/stdc++.h>
#define FLASH \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false);
#define pb push_back
#define int long long
#define fr(i, a, b) for (int i = a; i < b; i++)
#define mod 1000000007
#define FILEIO \
freopen("/home/aman/Desktop/Kachda/input.txt", "r", stdin); \
freopen("/home/aman/Desktop/Kachda/output.txt", "w", stdout);
using namespace std;
string s;
int d;
int dp[10001][101][2];
int pwr[10001] = {1};
signed main() {
FLASH
cin >> s >> d;
fr(i, 1, 10001) pwr[i] = (10 * pwr[i - 1]) % d;
int l = s.size();
reverse(s.begin(), s.end());
dp[0][0][0] = dp[0][0][1] = 1;
fr(i, 1, l + 1) {
int dig = s[i - 1] - '0';
fr(j, 0, d) {
fr(k, 0, dig) {
dp[i][j][0] += dp[i - 1][(j - k + d) % d][1];
dp[i][j][0] %= mod;
}
dp[i][j][0] += dp[i - 1][(j - dig + d) % d][0];
dp[i][j][0] %= mod;
fr(k, 0, 10) {
dp[i][j][1] += dp[i - 1][(j - k + d) % d][1];
dp[i][j][1] %= mod;
}
}
}
int ans = (dp[l][0][0] - 1 + mod) % mod;
while (ans >= mod)
ans -= mod;
while (ans < 0)
ans += mod;
cout << ans << '\n';
} | #include <bits/stdc++.h>
#define FLASH \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false);
#define pb push_back
#define int long long
#define fr(i, a, b) for (int i = a; i < b; i++)
#define mod 1000000007
#define FILEIO \
freopen("/home/aman/Desktop/Kachda/input.txt", "r", stdin); \
freopen("/home/aman/Desktop/Kachda/output.txt", "w", stdout);
using namespace std;
string s;
int d;
int dp[10001][101][2];
int pwr[10001] = {1};
signed main() {
FLASH
cin >> s >> d;
fr(i, 1, 10001) pwr[i] = (10 * pwr[i - 1]) % d;
int l = s.size();
reverse(s.begin(), s.end());
dp[0][0][0] = dp[0][0][1] = 1;
fr(i, 1, l + 1) {
int dig = s[i - 1] - '0';
fr(j, 0, d) {
fr(k, 0, dig) {
dp[i][j][0] += dp[i - 1][(j - k + mod * d) % d][1];
dp[i][j][0] %= mod;
}
dp[i][j][0] += dp[i - 1][(j - dig + mod * d) % d][0];
dp[i][j][0] %= mod;
fr(k, 0, 10) {
dp[i][j][1] += dp[i - 1][(j - k + mod * d) % d][1];
dp[i][j][1] %= mod;
}
}
}
int ans = (dp[l][0][0] - 1 + mod) % mod;
while (ans >= mod)
ans -= mod;
while (ans < 0)
ans += mod;
cout << ans << '\n';
}
| [
"assignment.change"
] | 986,423 | 986,424 | u955177919 | cpp |
p03178 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define scanVec(vec, n) \
for (int i = 0; i < n; i++) { \
cin >> vec[i]; \
}
#define printVec(vec, n) \
for (int i = 0; i < n; i++) { \
cout << vec[i] << " "; \
}
#define S second
#define F first
const int MOD = 1e9 + 7;
const int N = 1005;
ll dp[N][105][2];
string K;
int d, n;
ll rec(int ind, int s, int less) {
if (ind == n)
return s == 0;
ll res = dp[ind][s][less], k;
if (res != -1)
return res;
res = 0;
for (int i = 0; i <= 9; i++) {
if (less) {
res += rec(ind + 1, (s + i) % d, 1);
} else {
if (i > K[ind] - '0')
break;
if (i == K[ind] - '0')
res += rec(ind + 1, (s + i) % d, 0);
if (i < K[ind] - '0')
res += rec(ind + 1, (s + i) % d, 1);
res %= MOD;
}
}
dp[ind][s][less] = res;
return res;
}
// a d f j k l ;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> K >> d;
n = K.size();
memset(dp, -1, sizeof(dp));
cout << (rec(0, 0, 0) - 1 + MOD) % MOD << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define scanVec(vec, n) \
for (int i = 0; i < n; i++) { \
cin >> vec[i]; \
}
#define printVec(vec, n) \
for (int i = 0; i < n; i++) { \
cout << vec[i] << " "; \
}
#define S second
#define F first
const int MOD = 1e9 + 7;
const int N = 10005;
ll dp[N][105][2];
string K;
int d, n;
ll rec(int ind, int s, int less) {
if (ind == n)
return s == 0;
ll res = dp[ind][s][less], k;
if (res != -1)
return res;
res = 0;
for (int i = 0; i <= 9; i++) {
if (less) {
res += rec(ind + 1, (s + i) % d, 1);
} else {
if (i > K[ind] - '0')
break;
if (i == K[ind] - '0')
res += rec(ind + 1, (s + i) % d, 0);
if (i < K[ind] - '0')
res += rec(ind + 1, (s + i) % d, 1);
}
res %= MOD;
}
dp[ind][s][less] = res;
return res;
}
// a d f j k l ;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> K >> d;
n = K.size();
memset(dp, -1, sizeof(dp));
cout << (rec(0, 0, 0) - 1 + MOD) % MOD << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 986,430 | 986,429 | u319322407 | cpp |
p03178 | // In the Name of Allah. Ya Ali!
#include <bits/stdc++.h>
#define bp __builtin_popcount
typedef long long ll;
const ll MAX_N = 1e4 + 10;
const ll MAX_K = 105;
const ll MOD = 1e9 + 7;
using namespace std;
ll dp[MAX_N][MAX_K];
int a[MAX_N];
int m, n;
int main() {
string k;
cin >> k >> m;
n = k.length();
reverse(k.begin(), k.end());
for (int i = 1; i <= n; ++i)
a[i] = (k[i - 1] - '0');
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < m; ++j) {
for (int t = 0; t <= 9; ++t) {
dp[i][j] += dp[i - 1][(j - t + m) % m];
dp[i][j] %= MOD;
}
}
}
ll ans = 0;
int now = 0;
for (int i = n; i >= 1; --i) {
for (int j = 0; j < a[i]; ++j)
ans += dp[i - 1][(m - ((now + j) % m)) % m], ans %= MOD;
now += a[i];
now %= m;
}
if (!now)
ans++;
ans += MOD - 1;
ans %= MOD;
cout << ans;
return 0;
}
| // In the Name of Allah. Ya Ali!
#include <bits/stdc++.h>
#define bp __builtin_popcount
typedef long long ll;
const ll MAX_N = 1e4 + 10;
const ll MAX_K = 105;
const ll MOD = 1e9 + 7;
using namespace std;
ll dp[MAX_N][MAX_K];
int a[MAX_N];
int m, n;
int main() {
string k;
cin >> k >> m;
n = k.length();
reverse(k.begin(), k.end());
for (int i = 1; i <= n; ++i)
a[i] = (k[i - 1] - '0');
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < m; ++j) {
for (int t = 0; t <= 9; ++t) {
dp[i][j] += dp[i - 1][(j - (t % m) + m) % m];
dp[i][j] %= MOD;
}
}
}
ll ans = 0;
int now = 0;
for (int i = n; i >= 1; --i) {
for (int j = 0; j < a[i]; ++j)
ans += dp[i - 1][(m - ((now + j) % m)) % m], ans %= MOD;
now += a[i];
now %= m;
}
if (!now)
ans++;
ans += MOD - 1;
ans %= MOD;
cout << ans;
return 0;
}
| [
"assignment.change"
] | 986,431 | 986,432 | u509226403 | cpp |
p03178 | #include <algorithm>
#include <assert.h>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <memory.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define VA_NUM_ARGS(...) VA_NUM_ARGS_IMPL_((0, __VA_ARGS__, 6, 5, 4, 3, 2, 1))
#define VA_NUM_ARGS_IMPL_(tuple) VA_NUM_ARGS_IMPL tuple
#define VA_NUM_ARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, N, ...) N
#define macro_dispatcher(macro, ...) \
macro_dispatcher_(macro, VA_NUM_ARGS(__VA_ARGS__))
#define macro_dispatcher_(macro, nargs) macro_dispatcher__(macro, nargs)
#define macro_dispatcher__(macro, nargs) macro_dispatcher___(macro, nargs)
#define macro_dispatcher___(macro, nargs) macro##nargs
#define Debug1(a) cout << #a << "=" << (a) << "\n"
#define Debug2(a, b) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << "\n"
#define Debug3(a, b, c) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << "\n"
#define Debug4(a, b, c, d) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << ", " << #d << "=" << (d) << "\n"
#define Debug5(a, b, c, d, e) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << ", " << #d << "=" << (d) << ", " << #e << "=" << (e) << "\n"
#define Debug6(a, b, c, d, e, f) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << ", " << #d << "=" << (d) << ", " << #e << "=" << (e) << ", " \
<< #f << "=" << (f) << "\n"
#define Debug(...) macro_dispatcher(Debug, __VA_ARGS__)(__VA_ARGS__)
#define DA(a, n) \
cout << #a << "=["; \
printarray(a, n); \
cout << "]\n"
#define DAR(a, n, s) \
cout << #a << "[" << s << "-" << n - 1 << "]=["; \
printarray(a, n, s); \
cout << "]\n"
#define TT1 template <class T>
#define TT1T2 template <class T1, class T2>
#define TT1T2T3 template <class T1, class T2, class T3>
template <class T, size_t N>
ostream &operator<<(ostream &os, const array<T, N> &v);
TT1T2 ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
TT1 ostream &operator<<(ostream &os, const vector<T> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
template <class T, size_t N>
ostream &operator<<(ostream &os, const array<T, N> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, const set<T1, T2> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, const multiset<T1, T2> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
TT1T2T3 ostream &operator<<(ostream &os, const map<T1, T2, T3> &v) {
bool f = 1;
os << "[";
for (auto &ii : v) {
if (!f)
os << ", ";
os << "(" << ii.first << " -> " << ii.second << ") ";
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, const multimap<T1, T2> &v) {
bool f = 1;
os << "[";
for (auto &ii : v) {
if (!f)
os << ", ";
os << "(" << ii.first << " -> " << ii.second << ") ";
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, priority_queue<T1, T2> v) {
bool f = 1;
os << "[";
while (!v.empty()) {
auto x = v.top();
v.pop();
if (!f)
os << ", ";
f = 0;
os << x;
}
return os << "]";
}
TT1T2 void printarray(const T1 &a, T2 sz, T2 beg = 0) {
for (T2 i = beg; i < sz; i++)
cout << a[i] << " ";
cout << endl;
}
void cio() {
ios::sync_with_stdio(false);
cin.tie(NULL);
}
#define tt() printf("%.4f sec\n", (double)clock() / CLOCKS_PER_SEC)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define Fi first
#define Se second
#define pb(x) push_back(x)
#define sz(x) (int)x.size()
#define rep(i, n) for (int i = 0; i < n; i++)
#define repp(i, n) for (int i = 1; i <= n; i++)
#define all(x) x.begin(), x.end()
#define geti1(X) cin >> X
#define geti2(X, Y) cin >> X >> Y
#define geti3(X, Y, Z) cin >> X >> Y >> Z
#define geti4(X, Y, Z, W) cin >> X >> Y >> Z >> W
#define GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define geti(...) \
GET_MACRO(__VA_ARGS__, geti4, geti3, geti2, geti1)(__VA_ARGS__)
#define endl '\n'
typedef tuple<int, int, int> t3;
typedef tuple<int, int, int, int> t4;
void die() {
printf("-1\n");
exit(0);
}
int xx[4] = {1, -1, 0, 0}, yy[4] = {0, 0, 1, -1};
const ll mod = 1e9 + 7;
ll N, D;
char s[100500];
ll dp[100500][120][2];
ll upd(ll &a, ll b) { a = (a + b) % mod; }
int main() {
scanf("%s", s + 1);
N = strlen(s + 1);
scanf("%lld", &D);
dp[0][0][0] = 1;
ll sum = 0;
for (int i = 1; i <= N; i++) {
sum = sum + (s[i] - '0');
sum %= D;
dp[i][sum][0] = 1;
}
for (int i = 1; i <= N; i++) {
for (int j = 0; j < D; j++) {
for (int k = 0; k < s[i] - '0'; k++) {
upd(dp[i][j][1], dp[i - 1][(j - k + D) % D][0]);
}
for (int k = 0; k < 10; k++) {
upd(dp[i][j][1], dp[i - 1][(j - k + D * 10) % D][1]);
}
}
}
// Debug(dp[N][0][0], dp[N][0][1]);
printf("%lld\n", (dp[N][0][0] + dp[N][0][1] - 1 + mod) % mod);
}
| #include <algorithm>
#include <assert.h>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <memory.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define VA_NUM_ARGS(...) VA_NUM_ARGS_IMPL_((0, __VA_ARGS__, 6, 5, 4, 3, 2, 1))
#define VA_NUM_ARGS_IMPL_(tuple) VA_NUM_ARGS_IMPL tuple
#define VA_NUM_ARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, N, ...) N
#define macro_dispatcher(macro, ...) \
macro_dispatcher_(macro, VA_NUM_ARGS(__VA_ARGS__))
#define macro_dispatcher_(macro, nargs) macro_dispatcher__(macro, nargs)
#define macro_dispatcher__(macro, nargs) macro_dispatcher___(macro, nargs)
#define macro_dispatcher___(macro, nargs) macro##nargs
#define Debug1(a) cout << #a << "=" << (a) << "\n"
#define Debug2(a, b) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << "\n"
#define Debug3(a, b, c) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << "\n"
#define Debug4(a, b, c, d) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << ", " << #d << "=" << (d) << "\n"
#define Debug5(a, b, c, d, e) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << ", " << #d << "=" << (d) << ", " << #e << "=" << (e) << "\n"
#define Debug6(a, b, c, d, e, f) \
cout << #a << "=" << (a) << ", " << #b << "=" << (b) << ", " << #c << "=" \
<< (c) << ", " << #d << "=" << (d) << ", " << #e << "=" << (e) << ", " \
<< #f << "=" << (f) << "\n"
#define Debug(...) macro_dispatcher(Debug, __VA_ARGS__)(__VA_ARGS__)
#define DA(a, n) \
cout << #a << "=["; \
printarray(a, n); \
cout << "]\n"
#define DAR(a, n, s) \
cout << #a << "[" << s << "-" << n - 1 << "]=["; \
printarray(a, n, s); \
cout << "]\n"
#define TT1 template <class T>
#define TT1T2 template <class T1, class T2>
#define TT1T2T3 template <class T1, class T2, class T3>
template <class T, size_t N>
ostream &operator<<(ostream &os, const array<T, N> &v);
TT1T2 ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
TT1 ostream &operator<<(ostream &os, const vector<T> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
template <class T, size_t N>
ostream &operator<<(ostream &os, const array<T, N> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, const set<T1, T2> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, const multiset<T1, T2> &v) {
bool f = 1;
os << "[";
for (auto &i : v) {
if (!f)
os << ", ";
os << i;
f = 0;
}
return os << "]";
}
TT1T2T3 ostream &operator<<(ostream &os, const map<T1, T2, T3> &v) {
bool f = 1;
os << "[";
for (auto &ii : v) {
if (!f)
os << ", ";
os << "(" << ii.first << " -> " << ii.second << ") ";
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, const multimap<T1, T2> &v) {
bool f = 1;
os << "[";
for (auto &ii : v) {
if (!f)
os << ", ";
os << "(" << ii.first << " -> " << ii.second << ") ";
f = 0;
}
return os << "]";
}
TT1T2 ostream &operator<<(ostream &os, priority_queue<T1, T2> v) {
bool f = 1;
os << "[";
while (!v.empty()) {
auto x = v.top();
v.pop();
if (!f)
os << ", ";
f = 0;
os << x;
}
return os << "]";
}
TT1T2 void printarray(const T1 &a, T2 sz, T2 beg = 0) {
for (T2 i = beg; i < sz; i++)
cout << a[i] << " ";
cout << endl;
}
void cio() {
ios::sync_with_stdio(false);
cin.tie(NULL);
}
#define tt() printf("%.4f sec\n", (double)clock() / CLOCKS_PER_SEC)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define Fi first
#define Se second
#define pb(x) push_back(x)
#define sz(x) (int)x.size()
#define rep(i, n) for (int i = 0; i < n; i++)
#define repp(i, n) for (int i = 1; i <= n; i++)
#define all(x) x.begin(), x.end()
#define geti1(X) cin >> X
#define geti2(X, Y) cin >> X >> Y
#define geti3(X, Y, Z) cin >> X >> Y >> Z
#define geti4(X, Y, Z, W) cin >> X >> Y >> Z >> W
#define GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define geti(...) \
GET_MACRO(__VA_ARGS__, geti4, geti3, geti2, geti1)(__VA_ARGS__)
#define endl '\n'
typedef tuple<int, int, int> t3;
typedef tuple<int, int, int, int> t4;
void die() {
printf("-1\n");
exit(0);
}
int xx[4] = {1, -1, 0, 0}, yy[4] = {0, 0, 1, -1};
const ll mod = 1e9 + 7;
ll N, D;
char s[100500];
ll dp[100500][120][2];
ll upd(ll &a, ll b) { a = (a + b) % mod; }
int main() {
scanf("%s", s + 1);
N = strlen(s + 1);
scanf("%lld", &D);
dp[0][0][0] = 1;
ll sum = 0;
for (int i = 1; i <= N; i++) {
sum = sum + (s[i] - '0');
sum %= D;
dp[i][sum][0] = 1;
}
for (int i = 1; i <= N; i++) {
for (int j = 0; j < D; j++) {
for (int k = 0; k < s[i] - '0'; k++) {
upd(dp[i][j][1], dp[i - 1][(j - k + D * 10) % D][0]);
}
for (int k = 0; k < 10; k++) {
upd(dp[i][j][1], dp[i - 1][(j - k + D * 10) % D][1]);
}
}
}
// Debug(dp[N][0][0], dp[N][0][1]);
printf("%lld\n", (dp[N][0][0] + dp[N][0][1] - 1 + mod) % mod);
}
| [
"expression.operation.binary.add"
] | 986,433 | 986,434 | u903951856 | cpp |
p03178 | #include <algorithm>
#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>;
ll dp[10005][2][100];
ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int d;
cin >> d;
dp[0][0][0] = 1;
rep(i, s.size()) {
rep(j, d) {
for (int k = 0; k < s[i] - '0'; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][0][j]) % mod;
}
dp[i + 1][0][(j + s[i] - '0') % d] =
(dp[i + 1][0][(j + s[i] - '0')] + dp[i][0][j]) % mod;
for (int k = 0; k <= 9; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][1][j]) % mod;
}
}
}
cout << (dp[s.size()][0][0] + dp[s.size()][1][0] - 1 + mod) % mod << endl;
} | #include <algorithm>
#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>;
ll dp[10005][2][100];
ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int d;
cin >> d;
dp[0][0][0] = 1;
rep(i, s.size()) {
rep(j, d) {
for (int k = 0; k < s[i] - '0'; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][0][j]) % mod;
}
dp[i + 1][0][(j + s[i] - '0') % d] =
(dp[i + 1][0][(j + s[i] - '0') % d] + dp[i][0][j]) % mod;
for (int k = 0; k <= 9; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][1][j]) % mod;
}
}
}
cout << (dp[s.size()][0][0] + dp[s.size()][1][0] - 1 + mod) % mod << endl;
} | [
"assignment.change"
] | 986,449 | 986,450 | u628047647 | cpp |
p03178 | #include <algorithm>
#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>;
ll dp[100005][2][100];
ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int d;
cin >> d;
dp[0][0][0] = 1;
rep(i, s.size()) {
rep(j, d) {
for (int k = 0; k < s[i] - '0'; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][0][j]) % mod;
}
dp[i + 1][0][(j + s[i] - '0') % d] =
(dp[i + 1][0][(j + s[i] - '0')] + dp[i][0][j]) % mod;
for (int k = 0; k <= 9; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][1][j]) % mod;
}
}
}
cout << (dp[s.size()][0][0] + dp[s.size()][1][0] - 1 + mod) % mod << endl;
} | #include <algorithm>
#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>;
ll dp[10005][2][100];
ll mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int d;
cin >> d;
dp[0][0][0] = 1;
rep(i, s.size()) {
rep(j, d) {
for (int k = 0; k < s[i] - '0'; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][0][j]) % mod;
}
dp[i + 1][0][(j + s[i] - '0') % d] =
(dp[i + 1][0][(j + s[i] - '0') % d] + dp[i][0][j]) % mod;
for (int k = 0; k <= 9; k++) {
dp[i + 1][1][(j + k) % d] =
(dp[i + 1][1][(j + k) % d] + dp[i][1][j]) % mod;
}
}
}
cout << (dp[s.size()][0][0] + dp[s.size()][1][0] - 1 + mod) % mod << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.change"
] | 986,451 | 986,450 | u628047647 | cpp |
p03178 | #include <bits/stdc++.h>
#define N 1000000007
using namespace std;
string s;
int d;
//桁番号、less、あまり
// 1はs以下確定、0は未確定
long long dp[10001][2][100] = {0};
int main() {
cin >> d >> s;
dp[0][0][0] = 1;
for (int i = 1; i <= s.size(); ++i) {
for (int j = 0; j < d; ++j) {
for (int k = 0; k < 10; ++k) {
// i桁目の数字をkにしたときに、それが指定された数字のi桁目の数字
//より大きいか小さいか
if (k < s[i - 1] - '0')
dp[i][1][(j + k) % d] += (dp[i - 1][1][j] + dp[i - 1][0][j]) % N;
else if (k == s[i - 1] - '0') {
dp[i][1][(j + k) % d] += dp[i - 1][1][j];
dp[i][0][(j + k) % d] += dp[i - 1][0][j];
} else
dp[i][1][(j + k) % d] += dp[i - 1][1][j];
dp[i][1][(j + k) % d] %= N;
dp[i][0][(j + k) % d] %= N;
}
}
}
// 0が含まれているので０を排除
cout << (dp[s.size()][1][0] + dp[s.size()][0][0] - 1) % N << endl;
return 0;
}
| #include <bits/stdc++.h>
#define N 1000000007
using namespace std;
string s;
int d;
//桁番号、less、あまり
// 1はs以下確定、0は未確定
long long dp[10001][2][100] = {0};
int main() {
cin >> s >> d;
dp[0][0][0] = 1;
for (int i = 1; i <= s.size(); ++i) {
for (int j = 0; j < d; ++j) {
for (int k = 0; k < 10; ++k) {
// i桁目の数字をkにしたときに、それが指定された数字のi桁目の数字
//より大きいか小さいか
if (k < s[i - 1] - '0')
dp[i][1][(j + k) % d] += (dp[i - 1][1][j] + dp[i - 1][0][j]) % N;
else if (k == s[i - 1] - '0') {
dp[i][1][(j + k) % d] += dp[i - 1][1][j];
dp[i][0][(j + k) % d] += dp[i - 1][0][j];
} else
dp[i][1][(j + k) % d] += dp[i - 1][1][j];
dp[i][1][(j + k) % d] %= N;
dp[i][0][(j + k) % d] %= N;
}
}
}
// 0が含まれているので０を排除
cout << (N + dp[s.size()][1][0] + dp[s.size()][0][0] - 1) % N << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 986,460 | 986,459 | u269963329 | cpp |
p03178 | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
// using namespace __gnu_pbds;
typedef long double ld;
typedef long long ll;
#define int ll
#define endl "\n"
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(c) c.begin(), c.end()
#define vi vector<int>
#define pii pair<int, int>
#define For(i, s, e) for (ll i = (s); i < (e); i++)
#define initialize(arr, elem) memset(arr, elem, sizeof(arr))
#define sz size
const int MOD = 1e9 + 7;
const int MAX_SZ = 2e5 + 9;
const int INF = 1e18 + 9;
// typedef tree< int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> ordered_set;
int n, d;
string s;
int dp[10003][101][2];
void rand_shuff(vi &arr) {
random_device rd;
mt19937 g(rd());
shuffle(all(arr), g);
}
int solve(int k, int su, int check) {
if (k <= 0)
return 0;
if (dp[k][su][check] != -1)
return dp[k][su][check];
int cur = s[n - k] - '0';
if (k == 1) {
if (check) {
int res = 0;
For(i, 0, 10) {
if (i % d == su)
res++;
}
return dp[k][su][check] = res % MOD;
} else {
int res = 0;
For(i, 0, cur + 1) {
if (i % d == su)
res++;
}
return dp[k][su][check] = res % MOD;
}
}
if (check) {
int res = 0;
For(i, 0, 10) {
res += solve(k - 1, (su - i + d) % d, check);
res %= MOD;
}
return dp[k][su][check] = res % MOD;
} else {
int res = 0;
// cout<<"in\n";
res += solve(k - 1, (su - cur + d) % d, 0);
res %= MOD;
For(i, 0, cur) {
res += solve(k - 1, (su - i + d) % d, 1);
res %= MOD;
}
return dp[k][su][check] = res % MOD;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s >> d;
n = s.sz();
initialize(dp, -1);
cout << (solve(n, 0, 0) - 1 + MOD) % MOD << endl;
return 0;
}
| #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
// using namespace __gnu_pbds;
typedef long double ld;
typedef long long ll;
#define int ll
#define endl "\n"
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(c) c.begin(), c.end()
#define vi vector<int>
#define pii pair<int, int>
#define For(i, s, e) for (ll i = (s); i < (e); i++)
#define initialize(arr, elem) memset(arr, elem, sizeof(arr))
#define sz size
const int MOD = 1e9 + 7;
const int MAX_SZ = 2e5 + 9;
const int INF = 1e18 + 9;
// typedef tree< int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> ordered_set;
int n, d;
string s;
int dp[10003][101][2];
void rand_shuff(vi &arr) {
random_device rd;
mt19937 g(rd());
shuffle(all(arr), g);
}
int solve(int k, int su, int check) {
if (k <= 0)
return 0;
if (dp[k][su][check] != -1)
return dp[k][su][check];
int cur = s[n - k] - '0';
if (k == 1) {
if (check) {
int res = 0;
For(i, 0, 10) {
if (i % d == su)
res++;
}
return dp[k][su][check] = res % MOD;
} else {
int res = 0;
For(i, 0, cur + 1) {
if (i % d == su)
res++;
}
return dp[k][su][check] = res % MOD;
}
}
if (check) {
int res = 0;
For(i, 0, 10) {
res += solve(k - 1, (su - (i % d) + d) % d, check);
res %= MOD;
}
return dp[k][su][check] = res % MOD;
} else {
int res = 0;
// cout<<"in\n";
res += solve(k - 1, (su - cur + d) % d, 0);
res %= MOD;
For(i, 0, cur) {
res += solve(k - 1, (su - i + d) % d, 1);
res %= MOD;
}
return dp[k][su][check] = res % MOD;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
cin >> d;
n = s.sz();
initialize(dp, -1);
cout << (solve(n, 0, 0) - 1 + MOD) % MOD << endl;
return 0;
}
| [
"call.arguments.change"
] | 986,466 | 986,467 | u528153137 | cpp |
p03178 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long LL;
typedef unsigned int uii;
typedef pair<int, int> pii;
typedef unsigned long long uLL;
typedef vector<int> vii;
const int maxn = 1e4 + 5;
const int M = 1e9 + 7;
LL d[maxn][105];
int main(int argc, char const *argv[]) {
#ifndef ONLINE_JUDGE
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
string s;
int K;
cin >> s >> K;
reverse(all(s));
int n = (int)s.size();
d[0][0] = 1;
for (int i = 0; i < 10; ++i) {
++d[1][i % K];
}
for (int i = 2; i < n; ++i) {
for (int j = 0; j < K; ++j) {
for (int k = 0; k < 10; ++k) {
d[i][j] = (d[i][j] + d[i - 1][(j - k + 1000 * K) % K]) % M;
}
// cout << d[i][j] << ' ';
}
// cout << endl;
}
LL res = 0, num = 0;
for (int i = n - 1; i >= 0; --i) {
int x = s[i] - '0';
for (int j = 0; j < x; ++j) {
int t = (K - (num + j) % K) % K;
res = (res + d[i][t]) % M;
// cout << res << endl;
}
num += x;
}
res = (res - 1 + M) % M;
if (num % K == 0 && K != 1)
res = (res + 1) % M;
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long LL;
typedef unsigned int uii;
typedef pair<int, int> pii;
typedef unsigned long long uLL;
typedef vector<int> vii;
const int maxn = 1e4 + 5;
const int M = 1e9 + 7;
LL d[maxn][105];
int main(int argc, char const *argv[]) {
#ifndef ONLINE_JUDGE
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
string s;
int K;
cin >> s >> K;
reverse(all(s));
int n = (int)s.size();
d[0][0] = 1;
for (int i = 0; i < 10; ++i) {
++d[1][i % K];
}
for (int i = 2; i < n; ++i) {
for (int j = 0; j < K; ++j) {
for (int k = 0; k < 10; ++k) {
d[i][j] = (d[i][j] + d[i - 1][(j - k + 1000 * K) % K]) % M;
}
// cout << d[i][j] << ' ';
}
// cout << endl;
}
LL res = 0, num = 0;
for (int i = n - 1; i >= 0; --i) {
int x = s[i] - '0';
for (int j = 0; j < x; ++j) {
int t = (K - (num + j) % K) % K;
res = (res + d[i][t]) % M;
// cout << res << endl;
}
num += x;
}
res = (res - 1 + M) % M;
if (num % K == 0)
res = (res + 1) % M;
cout << res << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 986,470 | 986,471 | u778948914 | cpp |
p03178 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long LL;
typedef unsigned int uii;
typedef pair<int, int> pii;
typedef unsigned long long uLL;
typedef vector<int> vii;
const int maxn = 1e4 + 5;
const int M = 1e9 + 7;
LL d[maxn][105];
int main(int argc, char const *argv[]) {
#ifndef ONLINE_JUDGE
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
string s;
int K;
cin >> s >> K;
reverse(all(s));
int n = (int)s.size();
d[0][0] = 1;
for (int i = 0; i < 10; ++i) {
++d[1][i % K];
}
for (int i = 2; i < n; ++i) {
for (int j = 0; j < K; ++j) {
for (int k = 0; k < 10; ++k) {
d[i][j] = (d[i][j] + d[i - 1][(j - k + 10 * K) % K]) % M;
}
// cout << d[i][j] << ' ';
}
// cout << endl;
}
LL res = 0, num = 0;
for (int i = n - 1; i >= 0; --i) {
int x = s[i] - '0';
for (int j = 0; j < x; ++j) {
int t = (K - (num + j) % K) % K;
res = (res + d[i][t]) % M;
// cout << res << endl;
}
num += x;
}
res = (res - 1 + M) % M;
if (num % K == 0 && K != 1)
res = (res + 1) % M;
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long LL;
typedef unsigned int uii;
typedef pair<int, int> pii;
typedef unsigned long long uLL;
typedef vector<int> vii;
const int maxn = 1e4 + 5;
const int M = 1e9 + 7;
LL d[maxn][105];
int main(int argc, char const *argv[]) {
#ifndef ONLINE_JUDGE
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
string s;
int K;
cin >> s >> K;
reverse(all(s));
int n = (int)s.size();
d[0][0] = 1;
for (int i = 0; i < 10; ++i) {
++d[1][i % K];
}
for (int i = 2; i < n; ++i) {
for (int j = 0; j < K; ++j) {
for (int k = 0; k < 10; ++k) {
d[i][j] = (d[i][j] + d[i - 1][(j - k + 1000 * K) % K]) % M;
}
// cout << d[i][j] << ' ';
}
// cout << endl;
}
LL res = 0, num = 0;
for (int i = n - 1; i >= 0; --i) {
int x = s[i] - '0';
for (int j = 0; j < x; ++j) {
int t = (K - (num + j) % K) % K;
res = (res + d[i][t]) % M;
// cout << res << endl;
}
num += x;
}
res = (res - 1 + M) % M;
if (num % K == 0)
res = (res + 1) % M;
cout << res << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 986,472 | 986,471 | u778948914 | cpp |
p03178 | #include <bits/stdc++.h>
// S - Digit Sum
#define MOD 1000000007
using namespace std;
string K;
int dp[10005][105];
bool vis[10005];
int D, ans;
void solve2(int len) {
if (vis[len])
return;
vis[len] = true;
if (len == 0) {
dp[len][0] = 1;
return;
}
int i, j;
solve2(len - 1);
for (i = 0; i < D; i++) {
for (j = 0; j < 10; j++) {
dp[len][i] += dp[len - 1][(i - j + D) % D];
dp[len][i] %= MOD;
}
}
}
void solve1(int len, int rem) {
if (len == 0) {
if (rem == 0) {
ans++;
ans %= MOD;
}
return;
}
int i;
for (i = 0; i + '0' < K[K.size() - len]; i++) {
solve2(len - 1);
ans += dp[len - 1][((D << 5) - rem - i) % D];
ans %= MOD;
}
solve1(len - 1, (rem + K[K.size() - len] - '0') % D);
}
int main() {
cin >> K;
cin >> D;
ans = 0;
solve1((int)(K.size()), 0);
printf("%d\n", (ans - 1 + MOD) % MOD);
return 0;
}
| #include <bits/stdc++.h>
// S - Digit Sum
#define MOD 1000000007
using namespace std;
string K;
int dp[10005][105];
bool vis[10005];
int D, ans;
void solve2(int len) {
if (vis[len])
return;
vis[len] = true;
if (len == 0) {
dp[len][0] = 1;
return;
}
int i, j;
solve2(len - 1);
for (i = 0; i < D; i++) {
for (j = 0; j < 10; j++) {
dp[len][i] += dp[len - 1][(i - j + (D << 5)) % D];
dp[len][i] %= MOD;
}
}
}
void solve1(int len, int rem) {
if (len == 0) {
if (rem == 0) {
ans++;
ans %= MOD;
}
return;
}
int i;
for (i = 0; i + '0' < K[K.size() - len]; i++) {
solve2(len - 1);
ans += dp[len - 1][((D << 5) - rem - i) % D];
ans %= MOD;
}
solve1(len - 1, (rem + K[K.size() - len] - '0') % D);
}
int main() {
cin >> K;
cin >> D;
ans = 0;
solve1((int)(K.size()), 0);
printf("%d\n", (ans - 1 + MOD) % MOD);
return 0;
}
| [] | 986,477 | 986,478 | u530878476 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.