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 8
values |
|---|---|---|---|---|---|---|---|
p02937
|
#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <locale>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
#define FORN(i, m, n) for (int i = m; i < (n); i++)
#define PRINTVEC(v) \
FORN(i, 0, v.size()) cout << v[i] << " "; \
cout << endl
#define PRINTMAT(m) \
FORN(j, 0, m.size()) { PRINTVEC(m[j]); }
#define p_b(x) push_back(x)
#define m_p(a, b) make_pair(a, b)
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
vector<vector<int>> v(27);
FORN(i, 0, s.size()) v[s[i] - 'a'].p_b(i);
ll ans = 0, cur = -1;
FORN(i, 0, t.size()) {
int x = t[i] - 'a', pos;
if (v[x].empty()) {
cout << -1 << endl;
return 0;
}
pos = upper_bound(v[x].begin(), v[x].end(), cur) - v[x].begin();
if (pos == v[x].size()) {
pos = v[x][0];
ans++;
}
cur = v[x][pos];
}
ans = ans * s.size() + cur + 1;
cout << ans << endl;
}
|
#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <locale>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
#define FORN(i, m, n) for (int i = m; i < (n); i++)
#define PRINTVEC(v) \
FORN(i, 0, v.size()) cout << v[i] << " "; \
cout << endl
#define PRINTMAT(m) \
FORN(j, 0, m.size()) { PRINTVEC(m[j]); }
#define p_b(x) push_back(x)
#define m_p(a, b) make_pair(a, b)
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
vector<vector<int>> v(27);
FORN(i, 0, s.size()) v[s[i] - 'a'].p_b(i);
ll ans = 0, cur = -1;
FORN(i, 0, t.size()) {
int x = t[i] - 'a', pos;
if (v[x].empty()) {
cout << -1 << endl;
return 0;
}
pos = upper_bound(v[x].begin(), v[x].end(), cur) - v[x].begin();
if (pos == v[x].size()) {
pos = 0;
ans++;
}
cur = v[x][pos];
}
ans = ans * s.size() + cur + 1;
cout << ans << endl;
}
|
[] | 740,975
| 740,976
|
u585776323
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define __builtin_popcount __builtin_popcountll
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
int T, n, m;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
while (cin >> s >> t) {
n = s.size();
vector<vector<int>> tbl(26, vi(n, -1));
REP(i, n) { tbl[s[i] - 'a'][i] = i; }
REP(_, 2) {
RREP(i, n) {
REP(j, 26) {
if (tbl[j][i] == -1) {
tbl[j][i] = tbl[j][(i + 1) % n];
}
}
}
}
ll ans = 0, p = 0;
REP(i, t.size()) {
ll q = tbl[t[i] - 'a'][p];
if (q == -1) {
ans = -1;
break;
}
if (q < p)
ans += n;
ans += q - p + 1;
p = q + 1;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define __builtin_popcount __builtin_popcountll
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
int T, n, m;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
while (cin >> s >> t) {
n = s.size();
vector<vector<int>> tbl(26, vi(n, -1));
REP(i, n) { tbl[s[i] - 'a'][i] = i; }
REP(_, 2) {
RREP(i, n) {
REP(j, 26) {
if (tbl[j][i] == -1) {
tbl[j][i] = tbl[j][(i + 1) % n];
}
}
}
}
ll ans = 0, p = 0;
REP(i, t.size()) {
ll q = tbl[t[i] - 'a'][p];
if (q == -1) {
ans = -1;
break;
}
if (q < p)
ans += n;
ans += q - p + 1;
p = (q + 1) % n;
}
cout << ans << endl;
}
return 0;
}
|
[
"assignment.change"
] | 740,983
| 740,984
|
u557275893
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define __builtin_popcount __builtin_popcountll
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
int T, n, m;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
while (cin >> s >> t) {
n = s.size();
vector<vector<int>> tbl(26, vi(n, -1));
REP(i, n) { tbl[s[i] - 'a'][i] = i; }
REP(_, 2) {
RREP(i, n) {
REP(j, 26) {
if (tbl[j][i] == -1) {
tbl[j][i] = tbl[j][(i + 1) % n];
}
}
}
}
int ans = 0, p = 0;
REP(i, t.size()) {
int q = tbl[t[i] - 'a'][p];
if (q == -1) {
ans = -1;
break;
}
if (q < p)
ans += n;
ans += q - p + 1;
p = q + 1;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define __builtin_popcount __builtin_popcountll
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
os << "[";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "]";
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &t) {
os << "{";
FOR(it, t) {
if (it != t.begin())
os << ",";
os << *it;
}
os << "}";
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
int T, n, m;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
while (cin >> s >> t) {
n = s.size();
vector<vector<int>> tbl(26, vi(n, -1));
REP(i, n) { tbl[s[i] - 'a'][i] = i; }
REP(_, 2) {
RREP(i, n) {
REP(j, 26) {
if (tbl[j][i] == -1) {
tbl[j][i] = tbl[j][(i + 1) % n];
}
}
}
}
ll ans = 0, p = 0;
REP(i, t.size()) {
ll q = tbl[t[i] - 'a'][p];
if (q == -1) {
ans = -1;
break;
}
if (q < p)
ans += n;
ans += q - p + 1;
p = (q + 1) % n;
}
cout << ans << endl;
}
return 0;
}
|
[
"variable_declaration.type.change",
"assignment.change"
] | 740,985
| 740,984
|
u557275893
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
void fail() { cout << "-1" << endl; }
int main() {
string dict, target;
cin >> dict >> target;
unordered_map<char, vector<size_t>> idxs;
for (size_t i = 0; i < dict.size(); ++i) {
idxs[dict[i]].push_back(i);
}
uint64_t cnt = 0;
size_t last_pos = 0;
for (auto t_it = target.cbegin(); t_it != target.cend();) {
auto idx_it = idxs.find(*t_it);
if (idx_it == idxs.end()) {
fail();
return 0;
}
auto &pos = idx_it->second;
auto pos_it = lower_bound(pos.cbegin(), pos.cend(), last_pos);
if (pos_it != pos.cend()) {
last_pos = *pos_it;
++t_it;
} else {
last_pos = 0;
++cnt;
}
}
uint64_t result = cnt * dict.size() + last_pos + 1;
cout << result << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void fail() { cout << "-1" << endl; }
int main() {
string dict, target;
cin >> dict >> target;
unordered_map<char, vector<size_t>> idxs;
for (size_t i = 0; i < dict.size(); ++i) {
idxs[dict[i]].push_back(i + 1);
}
uint64_t cnt = 0;
size_t last_pos = 0;
for (auto t_it = target.cbegin(); t_it != target.cend();) {
auto idx_it = idxs.find(*t_it);
if (idx_it == idxs.end()) {
fail();
return 0;
}
auto &pos = idx_it->second;
auto pos_it = upper_bound(pos.cbegin(), pos.cend(), last_pos);
if (pos_it != pos.cend()) {
last_pos = *pos_it;
++t_it;
} else {
last_pos = 0;
++cnt;
}
}
uint64_t result = cnt * dict.size() + last_pos;
cout << result << endl;
}
|
[
"identifier.change",
"call.function.change",
"expression.operation.binary.remove"
] | 740,986
| 740,987
|
u072825550
|
cpp
|
p02937
|
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
#define INF 1000000021
#define MOD 1000000007
#define pb push_back
#define sqr(a) (a) * (a)
#define M(a, b) make_pair(a, b)
#define T(a, b, c) make_pair(a, make_pair(b, c))
#define F first
#define S second
#define all(x) (x.begin(), x.end())
#define deb(x) cerr << #x << " = " << x << '\n'
#define N 222222
using namespace std;
// using namespace __gnu_pbds;
typedef long double ld;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
// typedef tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
const ld pi = 2 * acos(0.0);
template <class T> bool umin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool umax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class TT> bool pal(T a, TT n) {
int k = 0;
for (int i = 0; i <= n / 2; i++) {
if (a[i] != a[n - i - 1]) {
k = 1;
break;
}
}
return k ? 0 : 1;
}
// int month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
vector<int> v[300];
int main() {
string t, s;
cin >> t >> s;
for (int i = 0; i < t.size(); i++)
v[t[i]].push_back(i);
ll cur = -1;
ll n = (ll)t.size();
ll ans = 0;
for (int i = 0; i < s.size(); i++) {
if (v[s[i]].empty())
return cout << -1, 0;
int id = upper_bound(v[s[i]].begin(), v[s[i]].end(), cur) - v[s[i]].begin();
if (id == v[s[i]].size()) {
ans += n;
cur = v[s[i]][0];
} else
cur = v[s[i]][0];
}
cout << ans + cur + 1;
getchar();
getchar();
return 0;
// ios::sync_with_stdio(false);
// cin.tie(0);
}
|
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
#define INF 1000000021
#define MOD 1000000007
#define pb push_back
#define sqr(a) (a) * (a)
#define M(a, b) make_pair(a, b)
#define T(a, b, c) make_pair(a, make_pair(b, c))
#define F first
#define S second
#define all(x) (x.begin(), x.end())
#define deb(x) cerr << #x << " = " << x << '\n'
#define N 222222
using namespace std;
// using namespace __gnu_pbds;
typedef long double ld;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
// typedef tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
const ld pi = 2 * acos(0.0);
template <class T> bool umin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool umax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class TT> bool pal(T a, TT n) {
int k = 0;
for (int i = 0; i <= n / 2; i++) {
if (a[i] != a[n - i - 1]) {
k = 1;
break;
}
}
return k ? 0 : 1;
}
// int month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
vector<int> v[300];
int main() {
string t, s;
cin >> t >> s;
for (int i = 0; i < t.size(); i++)
v[t[i]].push_back(i);
ll cur = -1;
ll n = (ll)t.size();
ll ans = 0;
for (int i = 0; i < s.size(); i++) {
if (v[s[i]].empty())
return cout << -1, 0;
// cerr << cur << '\n';
int id = upper_bound(v[s[i]].begin(), v[s[i]].end(), cur) - v[s[i]].begin();
// cerr << id << '\n';
if (id == v[s[i]].size()) {
ans += n;
cur = v[s[i]][0];
} else
cur = v[s[i]][id];
}
cout << ans + cur + 1;
getchar();
getchar();
return 0;
// ios::sync_with_stdio(false);
// cin.tie(0);
}
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 740,992
| 740,993
|
u101358413
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define reg register
#define M 200005
char s[M];
char t[M];
int n, m;
int Min[M][26];
LL Ans = 0;
int main() {
memset(Min, -1, sizeof(Min));
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1), m = strlen(t + 1);
for (int i = n + 1; i <= n * 2; ++i)
s[i] = s[i - n];
for (int i = n * 2; i >= 0; --i) {
if (i)
Min[i][s[i] - 'a'] = i;
for (int j = 0; j < 26; ++j)
if (j != s[i] - 'a')
Min[i][j] = Min[i + 1][j];
}
int Now = 0;
for (int i = 1; i <= m; ++i) {
if (Min[Now][t[i] - 'a'] == -1) {
puts("-1");
return 0;
}
Ans += Min[Now][t[i] - 'a'] - Now;
Now = Min[Now][t[i] - 'a'];
if (Now > n)
Now -= n;
}
printf("%lld", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define reg register
#define M 200005
char s[M];
char t[M];
int n, m;
int Min[M][26];
LL Ans = 0;
int main() {
memset(Min, -1, sizeof(Min));
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1), m = strlen(t + 1);
for (int i = n + 1; i <= n * 2; ++i)
s[i] = s[i - n];
for (int i = n * 2; i >= 0; --i) {
if (i)
Min[i][s[i] - 'a'] = i;
for (int j = 0; j < 26; ++j)
if (j != s[i] - 'a')
Min[i][j] = Min[i + 1][j];
}
int Now = 0;
for (int i = 1; i <= m; ++i) {
if (Min[Now + 1][t[i] - 'a'] == -1) {
puts("-1");
return 0;
}
Ans += Min[Now + 1][t[i] - 'a'] - Now;
Now = Min[Now + 1][t[i] - 'a'];
if (Now > n)
Now -= n;
}
printf("%lld", Ans);
}
|
[
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"assignment.change"
] | 740,994
| 740,995
|
u508834119
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#define prArr(Arr, n) \
for (int _ = 0; _ < n; _++) \
cout << (Arr)[_] << " ";
using namespace std;
const int INF = (int)1e9 + 10;
const int MOD = 998244353;
vector<vector<int>> idx(26);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long ptr = 0, cnt = 0;
string a, b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++)
idx[a[i] - 'a'].push_back(i);
for (int i = 0; i < b.size(); i++) {
if (idx[b[i] - 'a'].empty())
return cout << "-1", 0;
int x = upper_bound(idx[b[i] - 'a'].begin(), idx[b[i] - 'a'].end(), ptr) -
idx[b[i] - 'a'].begin();
if (x == idx[b[i] - 'a'].size())
cnt++, ptr = idx[b[i] - 'a'][0];
else
ptr = idx[b[i] - 'a'][x];
}
cout << cnt * a.size() + ptr + 1;
return 0;
}
|
#include <bits/stdc++.h>
#define prArr(Arr, n) \
for (int _ = 0; _ < n; _++) \
cout << (Arr)[_] << " ";
using namespace std;
const int INF = (int)1e9 + 10;
const int MOD = 998244353;
vector<vector<int>> idx(26);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long ptr = -1, cnt = 0;
string a, b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++)
idx[a[i] - 'a'].push_back(i);
for (int i = 0; i < b.size(); i++) {
if (idx[b[i] - 'a'].empty())
return cout << "-1", 0;
int x = upper_bound(idx[b[i] - 'a'].begin(), idx[b[i] - 'a'].end(), ptr) -
idx[b[i] - 'a'].begin();
if (x == idx[b[i] - 'a'].size())
cnt++, ptr = idx[b[i] - 'a'][0];
else
ptr = idx[b[i] - 'a'][x];
}
cout << cnt * a.size() + ptr + 1;
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 740,996
| 740,997
|
u327682315
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#define prArr(Arr, n) \
for (int _ = 0; _ < n; _++) \
cout << (Arr)[_] << " ";
using namespace std;
const int INF = (int)1e9 + 10;
const int MOD = 998244353;
vector<vector<int>> idx(26);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ptr = 0, cnt = 0;
string a, b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++)
idx[a[i] - 'a'].push_back(i);
for (int i = 0; i < b.size(); i++) {
if (idx[b[i] - 'a'].empty())
return cout << "-1", 0;
int x = upper_bound(idx[b[i] - 'a'].begin(), idx[b[i] - 'a'].end(), ptr) -
idx[b[i] - 'a'].begin();
if (x == idx[b[i] - 'a'].size())
cnt++, ptr = idx[b[i] - 'a'][0];
else
ptr = idx[b[i] - 'a'][x];
}
cout << cnt * a.size() + ptr + 1;
return 0;
}
|
#include <bits/stdc++.h>
#define prArr(Arr, n) \
for (int _ = 0; _ < n; _++) \
cout << (Arr)[_] << " ";
using namespace std;
const int INF = (int)1e9 + 10;
const int MOD = 998244353;
vector<vector<int>> idx(26);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long ptr = -1, cnt = 0;
string a, b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++)
idx[a[i] - 'a'].push_back(i);
for (int i = 0; i < b.size(); i++) {
if (idx[b[i] - 'a'].empty())
return cout << "-1", 0;
int x = upper_bound(idx[b[i] - 'a'].begin(), idx[b[i] - 'a'].end(), ptr) -
idx[b[i] - 'a'].begin();
if (x == idx[b[i] - 'a'].size())
cnt++, ptr = idx[b[i] - 'a'][0];
else
ptr = idx[b[i] - 'a'][x];
}
cout << cnt * a.size() + ptr + 1;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"variable_declaration.value.change"
] | 740,998
| 740,997
|
u327682315
|
cpp
|
p02937
|
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
constexpr ll INF = 1'000'000'000'000'000'000;
namespace utils {
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;
template <class T> bool min_update(T &X, const T &A) {
if (X > A) {
X = A;
return true;
}
return false;
}
template <class T> bool max_update(T &X, const T &A) {
if (X < A) {
X = A;
return true;
}
return false;
}
using V_Set = unordered_set<int>;
using E_Set = unordered_map<int, V_Set>;
ll operator"" _64(unsigned long long x) { return ll(x); }
ull operator"" _64u(unsigned long long x) { return ull(x); }
#define ALL(x) begin(x), end(x)
#define rALL(x) rbegin(x), rend(x)
} // namespace utils
using namespace utils;
void sub_main(istream &is) {
string S, T;
is >> S >> T;
if (!is)
return;
unordered_map<char, vector<int>> spt;
for (int i = 0; i < S.size(); ++i) {
spt[S[i]].push_back(i);
} // end i
ll N = S.size();
ll now = -1;
ll ans = 0;
for (auto &&t : T) {
if (spt.count(t) == 0) {
ans = -1;
break;
}
auto p = lower_bound(ALL(spt[t]), now);
if (p == spt[t].end()) {
ans += spt[t][0] + N - now;
now = spt[t][0];
} else {
ans += *p - now;
now = *p;
}
} // end t
cout << ans << endl;
}
int main(int argc, char *argv[]) {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(16) << scientific;
#ifdef DEBUG
string test_cases = "test_E.txt";
cerr << "DEBUG MODE" << endl;
cerr << test_cases << " -->" << endl;
auto fs = fstream(test_cases, fstream::in);
int lp = 0;
while (fs) {
lp++;
cout << lp << "#------\n";
sub_main(fs);
}
cout << "------#" << endl;
if (lp <= 1)
sub_main(cin);
#else
sub_main(cin);
#endif
return 0;
}
|
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
constexpr ll INF = 1'000'000'000'000'000'000;
namespace utils {
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;
template <class T> bool min_update(T &X, const T &A) {
if (X > A) {
X = A;
return true;
}
return false;
}
template <class T> bool max_update(T &X, const T &A) {
if (X < A) {
X = A;
return true;
}
return false;
}
using V_Set = unordered_set<int>;
using E_Set = unordered_map<int, V_Set>;
ll operator"" _64(unsigned long long x) { return ll(x); }
ull operator"" _64u(unsigned long long x) { return ull(x); }
#define ALL(x) begin(x), end(x)
#define rALL(x) rbegin(x), rend(x)
} // namespace utils
using namespace utils;
void sub_main(istream &is) {
string S, T;
is >> S >> T;
if (!is)
return;
unordered_map<char, vector<int>> spt;
for (int i = 0; i < S.size(); ++i) {
spt[S[i]].push_back(i);
} // end i
ll N = S.size();
ll now = -1;
ll ans = 0;
for (auto &&t : T) {
if (spt.count(t) == 0) {
ans = -1;
break;
}
auto p = lower_bound(ALL(spt[t]), now + 1);
if (p == spt[t].end()) {
ans += spt[t][0] + N - now;
now = spt[t][0];
} else {
ans += *p - now;
now = *p;
}
} // end t
cout << ans << endl;
}
int main(int argc, char *argv[]) {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(16) << scientific;
#ifdef DEBUG
string test_cases = "test_E.txt";
cerr << "DEBUG MODE" << endl;
cerr << test_cases << " -->" << endl;
auto fs = fstream(test_cases, fstream::in);
int lp = 0;
while (fs) {
lp++;
cout << lp << "#------\n";
sub_main(fs);
}
cout << "------#" << endl;
if (lp <= 1)
sub_main(cin);
#else
sub_main(cin);
#endif
return 0;
}
|
[
"assignment.change"
] | 741,001
| 741,002
|
u896838289
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> bool cmax(T &a, U b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T, class U> bool cmin(T &a, U b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
ll n = s.size();
ll m = t.size();
vector<vector<ll>> pos(32);
rep(i, n) { pos[s[i] - 'a'].push_back(i); }
ll ans = 0;
rep(i, m) {
if (pos[t[i] - 'a'].size() == 0) {
cout << -1 << endl;
return 0;
}
}
rep(i, m) {
auto it = upper_bound(all(pos[t[i] - 'a']), ans % n);
if (it == pos[t[i] - 'a'].end()) {
ans += n - ans % n;
ans += pos[t[i] - 'a'][0];
} else {
ans += *it - ans % n;
}
}
cout << ans + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> bool cmax(T &a, U b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T, class U> bool cmin(T &a, U b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
ll n = s.size();
ll m = t.size();
vector<vector<ll>> pos(32);
rep(i, n) { pos[s[i] - 'a'].push_back(i); }
ll ans = n - 1;
rep(i, m) {
if (pos[t[i] - 'a'].size() == 0) {
cout << -1 << endl;
return 0;
}
}
rep(i, m) {
auto it = upper_bound(all(pos[t[i] - 'a']), ans % n);
if (it == pos[t[i] - 'a'].end()) {
ans += n - ans % n;
ans += pos[t[i] - 'a'][0];
} else {
ans += *it - ans % n;
}
}
cout << ans - n + 1 << endl;
}
|
[
"identifier.replace.add",
"literal.replace.remove"
] | 741,005
| 741,006
|
u366644013
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <iomanip>
#define FAST \
std::ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define DECIMAL(n) \
std::cout << std::fixed; \
std::cout << std::setprecision(n);
#define hell 1000000007
#define narak 998244353
#define PI 3.14159265358979323844
#define mp make_pair
#define eb emplace_back
#define pb push_back
#define fi first
#define se second
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define endl "\n"
#define maxc(v) *max_element(ALL(v))
#define minc(v) *min_element(ALL(v))
#define sqr(a) (a) * (a)
#define GCD(m, n) __gcd(m, n)
#define LCM(m, n) m *(n / GCD(m, n))
#define inputarr(a, n) \
for (int xxx = 0; xxx < n; ++xxx) \
cin >> a[xxx]
#define initarr(a, n, x) \
for (int xxx = 0; xxx < n; ++xxx) \
a[xxx] = x
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define trav(a, x) for (auto &a : x)
#define sz(a) (int)a.size()
#define sl(a) (int)a.length()
#define invect(data, n, commands) \
for (int xxx = 0; xxx < n; xxx++) { \
int tmp; \
cin >> tmp; \
data.pb(tmp); \
commands \
}
#define inset(data, n, commands) \
for (int xxx = 0; xxx < n; xxx++) { \
int tmp; \
cin >> tmp; \
data.insert(tmp); \
commands \
}
#define display(x) \
trav(a, x) cout << a << " "; \
cout << endl
#define debug cerr << "bhau" << endl
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
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;
}
std::mt19937_64
rng(std::chrono::steady_clock::now().time_since_epoch().count());
#define ll long long
#define ld long double
#define pii std::pair<int, int>
#define pll std::pair<ll, ll>
#define vi vector<int>
#define vvi vector<vi>
#define vii vector<pii>
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
/*----------------------Graph Moves----------------*/
// const int fx[]={+1,-1,+0,+0};
// const int fy[]={+0,+0,+1,-1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
// const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
// const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*------------------------------------------------*/
// primes for hashing 937,991,1013,1409,1741
pii operator+(pii a, pii b) { return {a.fi + b.fi, a.se + b.se}; }
pll operator+(pll a, pll b) { return {a.fi + b.fi, a.se + b.se}; }
std::ostream &operator<<(std::ostream &out, pii a) {
out << a.fi << " " << a.se << endl;
return out;
}
std::ostream &operator<<(std::ostream &out, pll a) {
out << a.fi << " " << a.se << endl;
return out;
}
std::istream &operator>>(std::istream &in, pii &a) {
in >> a.fi >> a.se;
return in;
}
std::istream &operator>>(std::istream &in, pll &a) {
in >> a.fi >> a.se;
return in;
}
using namespace std;
using namespace __gnu_pbds;
void meowmeow321() {
string s, t;
cin >> s >> t;
vi cs(26, 0), ct(26, 0);
vi idx[26];
for (int i = 0; i < sl(s); ++i) {
cs[s[i] - 'a']++;
idx[s[i] - 'a'].pb(i);
}
for (int i = 0; i < sl(t); ++i) {
ct[t[i] - 'a']++;
}
for (int i = 0; i < 26; ++i) {
if (ct[i] != 0 && cs[i] == 0) {
cout << -1;
return;
}
}
ll cur = 0;
for (int i = 0; i < sl(t); ++i) {
auto it = upper_bound(ALL(idx[t[i] - 'a']), cur % sl(s));
if (it == idx[t[i] - 'a'].end()) {
cur += sl(s) - (cur % sl(s));
cur += idx[t[i] - 'a'][0];
} else {
cur += (*it) % sl(s) - cur % sl(s);
}
}
cout << cur + 1;
}
int main() {
FAST;
int testcases = 1;
// cin>>testcases;
for (int i = 0; i < testcases; ++i) {
meowmeow321();
}
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <iomanip>
#define FAST \
std::ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define DECIMAL(n) \
std::cout << std::fixed; \
std::cout << std::setprecision(n);
#define hell 1000000007
#define narak 998244353
#define PI 3.14159265358979323844
#define mp make_pair
#define eb emplace_back
#define pb push_back
#define fi first
#define se second
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define endl "\n"
#define maxc(v) *max_element(ALL(v))
#define minc(v) *min_element(ALL(v))
#define sqr(a) (a) * (a)
#define GCD(m, n) __gcd(m, n)
#define LCM(m, n) m *(n / GCD(m, n))
#define inputarr(a, n) \
for (int xxx = 0; xxx < n; ++xxx) \
cin >> a[xxx]
#define initarr(a, n, x) \
for (int xxx = 0; xxx < n; ++xxx) \
a[xxx] = x
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define trav(a, x) for (auto &a : x)
#define sz(a) (int)a.size()
#define sl(a) (int)a.length()
#define invect(data, n, commands) \
for (int xxx = 0; xxx < n; xxx++) { \
int tmp; \
cin >> tmp; \
data.pb(tmp); \
commands \
}
#define inset(data, n, commands) \
for (int xxx = 0; xxx < n; xxx++) { \
int tmp; \
cin >> tmp; \
data.insert(tmp); \
commands \
}
#define display(x) \
trav(a, x) cout << a << " "; \
cout << endl
#define debug cerr << "bhau" << endl
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
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;
}
std::mt19937_64
rng(std::chrono::steady_clock::now().time_since_epoch().count());
#define ll long long
#define ld long double
#define pii std::pair<int, int>
#define pll std::pair<ll, ll>
#define vi vector<int>
#define vvi vector<vi>
#define vii vector<pii>
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
/*----------------------Graph Moves----------------*/
// const int fx[]={+1,-1,+0,+0};
// const int fy[]={+0,+0,+1,-1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
// const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
// const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*------------------------------------------------*/
// primes for hashing 937,991,1013,1409,1741
pii operator+(pii a, pii b) { return {a.fi + b.fi, a.se + b.se}; }
pll operator+(pll a, pll b) { return {a.fi + b.fi, a.se + b.se}; }
std::ostream &operator<<(std::ostream &out, pii a) {
out << a.fi << " " << a.se << endl;
return out;
}
std::ostream &operator<<(std::ostream &out, pll a) {
out << a.fi << " " << a.se << endl;
return out;
}
std::istream &operator>>(std::istream &in, pii &a) {
in >> a.fi >> a.se;
return in;
}
std::istream &operator>>(std::istream &in, pll &a) {
in >> a.fi >> a.se;
return in;
}
using namespace std;
using namespace __gnu_pbds;
void meowmeow321() {
string s, t;
cin >> s >> t;
vi cs(26, 0), ct(26, 0);
vi idx[26];
for (int i = 0; i < sl(s); ++i) {
cs[s[i] - 'a']++;
idx[s[i] - 'a'].pb(i);
}
for (int i = 0; i < sl(t); ++i) {
ct[t[i] - 'a']++;
}
for (int i = 0; i < 26; ++i) {
if (ct[i] != 0 && cs[i] == 0) {
cout << -1;
return;
}
}
ll cur = -1;
for (int i = 0; i < sl(t); ++i) {
auto it = upper_bound(ALL(idx[t[i] - 'a']), cur % sl(s));
if (it == idx[t[i] - 'a'].end()) {
cur += sl(s) - (cur % sl(s));
cur += idx[t[i] - 'a'][0];
} else {
cur += (*it) % sl(s) - cur % sl(s);
}
}
cout << cur + 1;
}
int main() {
FAST;
int testcases = 1;
// cin>>testcases;
for (int i = 0; i < testcases; ++i) {
meowmeow321();
}
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,007
| 741,008
|
u198590292
|
cpp
|
p02937
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
vector<unsigned long long> p[26];
for (int i = 0; i < s.size(); i++) {
p[s[i] - 'a'].push_back(i + 1);
}
unsigned long long ans = 0;
string t;
cin >> t;
for (auto &&i : t) {
if (p[i - 'a'].empty()) {
cout << "-1\n";
return 0;
}
auto point =
lower_bound(begin(p[i - 'a']), end(p[i - 'a']), ans % s.size());
if (point == end(p[i - 'a'])) {
point = lower_bound(begin(p[i - 'a']), end(p[i - 'a']), 0);
ans += s.size();
}
ans /= s.size();
ans *= s.size();
ans += *point;
}
cout << ans << "\n";
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
vector<unsigned long long> p[26];
for (int i = 0; i < s.size(); i++) {
p[s[i] - 'a'].push_back(i + 1);
}
unsigned long long ans = 0;
string t;
cin >> t;
for (auto &&i : t) {
if (p[i - 'a'].empty()) {
cout << "-1\n";
return 0;
}
auto point =
upper_bound(begin(p[i - 'a']), end(p[i - 'a']), ans % s.size());
if (point == end(p[i - 'a'])) {
point = upper_bound(begin(p[i - 'a']), end(p[i - 'a']), 0);
ans += s.size();
}
ans /= s.size();
ans *= s.size();
ans += *point;
}
cout << ans << "\n";
}
|
[
"identifier.change",
"call.function.change",
"assignment.value.change"
] | 741,009
| 741,010
|
u752074356
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
vector<vector<int>> ms(26);
for (int i = 0; i < s.size(); ++i) {
ms[s[i] - 'a'].emplace_back(i);
}
int ind = 0;
long long ans = 0;
int sind = -1;
while (ind < t.size()) {
sind = -1;
while (ind < t.size()) {
if (ms[t[ind] - 'a'].size() == 0) {
cout << -1 << endl;
return 0;
}
auto itu =
upper_bound(ms[t[ind] - 'a'].begin(), ms[t[ind] - 'a'].end(), sind);
if (itu == ms[t[ind] - 'a'].end())
break;
else {
++ind;
sind = *itu;
}
}
if (ind < t.size() - 1)
++ans;
}
cout << s.size() * ans + sind + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
vector<vector<int>> ms(26);
for (int i = 0; i < s.size(); ++i) {
ms[s[i] - 'a'].emplace_back(i);
}
int ind = 0;
long long ans = 0;
long long sind = -1;
while (ind < t.size()) {
sind = -1;
while (ind < t.size()) {
if (ms[t[ind] - 'a'].size() == 0) {
cout << -1 << endl;
return 0;
}
auto itu =
upper_bound(ms[t[ind] - 'a'].begin(), ms[t[ind] - 'a'].end(), sind);
if (itu == ms[t[ind] - 'a'].end())
break;
else {
++ind;
sind = *itu;
}
}
if (ind < t.size())
++ans;
}
cout << s.size() * ans + sind + 1 << endl;
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operation.binary.remove"
] | 741,017
| 741,018
|
u604693716
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9 + 7)
#define all(x) (x).begin(), (x).end()
#define dbg(x) cerr << #x << ": " << x << endl
template <class T> void show_2d_vector(const vector<vector<T>> &v) {
for (auto v1 : v) {
for (auto v2 : v1) {
cout << v2 << " ";
}
cout << endl;
}
}
int main() {
string s, t;
cin >> s >> t;
vector<vector<ll>> pos(26);
for (int i = 0; i < s.size(); i++) {
pos[(int)(s[i] - 'a')].push_back(i + 1);
}
ll num = 0;
ll ans = 0;
for (int i = 0; i < t.size(); i++) {
if (pos[(int)(t[i] - 'a')].size() == 0) {
cout << -1 << endl;
return 0;
}
auto itr = lower_bound(all(pos[(int)(t[i] - 'a')]), num);
if (itr == pos[(int)(t[i] - 'a')].end()) {
ans += (ll)(s.size());
num = pos[(int)(t[i] - 'a')][0];
} else {
num = *itr;
}
}
ans += (ll)(num);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9 + 7)
#define all(x) (x).begin(), (x).end()
#define dbg(x) cerr << #x << ": " << x << endl
template <class T> void show_2d_vector(const vector<vector<T>> &v) {
for (auto v1 : v) {
for (auto v2 : v1) {
cout << v2 << " ";
}
cout << endl;
}
}
int main() {
string s, t;
cin >> s >> t;
vector<vector<ll>> pos(26);
for (int i = 0; i < s.size(); i++) {
pos[(int)(s[i] - 'a')].push_back(i + 1);
}
ll num = -1;
ll ans = 0;
for (int i = 0; i < t.size(); i++) {
if (pos[(int)(t[i] - 'a')].size() == 0) {
cout << -1 << endl;
return 0;
}
auto itr = lower_bound(all(pos[(int)(t[i] - 'a')]), num + 1);
if (itr == pos[(int)(t[i] - 'a')].end()) {
ans += (ll)(s.size());
num = pos[(int)(t[i] - 'a')][0];
} else {
num = *itr;
}
}
ans += (ll)(num);
cout << ans << endl;
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,021
| 741,022
|
u677421794
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
const long INF = 1000000000000000;
void bfs(long p, vector<vector<long>> &edge, vector<long> &cost,
vector<long> &ans) {
for (int i = 0; i < edge.at(p).size(); i++) {
if (ans.at(edge.at(p).at(i)) == -1) {
ans.at(edge.at(p).at(i)) = ans.at(p) + cost.at(edge.at(p).at(i));
bfs(edge.at(p).at(i), edge, cost, ans);
}
}
}
int main() {
string s, t;
cin >> s >> t;
long N = s.size();
vector<set<long>> alpc(26, set<long>());
for (int i = 0; i < N; i++) {
alpc.at(s.at(i) - 'a').insert(i);
alpc.at(s.at(i) - 'a').insert(N + i);
}
long ans = 1, point = 0;
for (int i = 0; i < t.size(); i++) {
if (alpc.at(t.at(i) - 'a').size() == 0) {
cout << -1 << endl;
return 0;
} else {
auto ite = alpc.at(t.at(i) - 'a').upper_bound(point);
ans += (*ite) - point;
point = (*ite) % N;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long INF = 1000000000000000;
void bfs(long p, vector<vector<long>> &edge, vector<long> &cost,
vector<long> &ans) {
for (int i = 0; i < edge.at(p).size(); i++) {
if (ans.at(edge.at(p).at(i)) == -1) {
ans.at(edge.at(p).at(i)) = ans.at(p) + cost.at(edge.at(p).at(i));
bfs(edge.at(p).at(i), edge, cost, ans);
}
}
}
int main() {
string s, t;
cin >> s >> t;
long N = s.size();
vector<set<long>> alpc(26, set<long>());
for (int i = 0; i < N; i++) {
alpc.at(s.at(i) - 'a').insert(i);
alpc.at(s.at(i) - 'a').insert(N + i);
}
long ans = 0, point = -1;
for (int i = 0; i < t.size(); i++) {
// cout<<point<<endl;
if (alpc.at(t.at(i) - 'a').size() == 0) {
cout << -1 << endl;
return 0;
} else {
auto ite = alpc.at(t.at(i) - 'a').upper_bound(point);
ans += (*ite) - point;
// cout<<(*ite)-point<<endl;
point = (*ite) % N;
}
}
cout << ans << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,025
| 741,026
|
u968365254
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
// Common DS shorteners
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T> using vec = vector<T>;
template <typename K, typename V> using mp = unordered_map<K, V>;
template <typename K> using us = unordered_set<K>;
using vi = vec<int>;
using vl = vec<ll>;
using vpi = vec<pii>;
using vpl = vec<pll>;
// Shorthand Macros
#define INF 0x3f3f3f3f
#define LLINF 0x3f3f3f3f3f3f3f3f
#define mpr make_pair
#define pb push_back
// Shorthand Functions
template <typename T> inline void maxa(T &st, T v) { st = max(st, v); }
template <typename T> inline void mina(T &st, T v) { st = min(st, v); }
// Out operators and printing for arrays and vectors
template <typename T> ostream &operator<<(ostream &out, vector<T> iter) {
out << "[";
for (auto t : iter) {
out << t << ", ";
}
out << "]";
return out;
}
template <typename T> void printDebug(T *arr, int sz) {
cout << "[";
for (int i = 0; i < sz; i++) {
cout << arr[i] << ", ";
}
cout << "]\n";
}
template <typename T> void printArray(T *arr, int sz) {
for (int i = 0; i < sz; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
#define OUT_OPERATOR(type, propa, propb) \
ostream &operator<<(ostream &out, type obj) { \
out << "(" << #propa << "=" << obj.propa << ", " << #propb << "=" \
<< obj.propb << ")"; \
return out; \
}
// I/O Operations
inline void scan() {}
template <typename F, typename... R> inline void scan(F &f, R &...r) {
cin >> f;
scan(r...);
}
inline void println() { cout << "\n"; }
template <typename F, typename... R> inline void println(F f, R... r) {
cout << f << " ";
println(r...);
}
inline void print() {}
template <typename F, typename... R> inline void print(F f, R... r) {
cout << f;
print(r...);
}
// Debugging
int di_;
string dnms_, co_ = ",";
void debug_() { cout << endl; }
template <typename F, typename... R> void debug_(F f, R... r) {
int bc = 0;
while (bc != 0 || dnms_[di_] != ',') {
if (dnms_[di_] == '(') {
bc++;
} else if (dnms_[di_] == ')') {
bc--;
}
cout << dnms_[di_++];
}
di_++;
cout << ": " << f << ",";
debug_(r...);
}
#define debug(...) \
do { \
dnms_ = #__VA_ARGS__ + co_, di_ = 0, debug_(__VA_ARGS__); \
} while (0)
struct ed {
int v, w = INF;
bool operator<(const ed &o) const { return w < o.w; }
};
inline int let(char c) { return c - 'a'; }
const int MN = 1e5 + 1, LS = 26;
int n, m;
vi idxOf[LS];
ed g[MN][LS];
string s, t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
scan(s, t);
n = s.length();
m = t.length();
for (int i = 0; i < n; i++)
idxOf[let(s[i])].pb(i);
set<pii> used;
for (int i = 1; i < m; i++) {
int a = let(t[i - 1]), b = let(t[i]);
auto p = mpr(a, b);
if (used.find(p) != used.end())
continue;
used.insert(p);
if (idxOf[a].empty()) {
println(-1);
return 0;
}
for (int id : idxOf[a]) {
auto nxtPtr = upper_bound(idxOf[b].begin(), idxOf[b].end(), id);
if (nxtPtr == idxOf[b].end())
mina(g[id][b], {idxOf[b][0], n - id + idxOf[b][0]});
else
mina(g[id][b], {*nxtPtr, *nxtPtr - id});
}
}
if (idxOf[let(t[0])].empty()) {
println(-1);
return 0;
}
ll ans = idxOf[let(t[0])][0], id = ans;
for (int i = 1; i < m; i++) {
int clet = let(t[i]);
if (g[id][clet].w == INF) {
println(-1);
return 0;
}
auto edge = g[id][clet];
id = edge.v;
ans += edge.w;
}
println(ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
// Common DS shorteners
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T> using vec = vector<T>;
template <typename K, typename V> using mp = unordered_map<K, V>;
template <typename K> using us = unordered_set<K>;
using vi = vec<int>;
using vl = vec<ll>;
using vpi = vec<pii>;
using vpl = vec<pll>;
// Shorthand Macros
#define INF 0x3f3f3f3f
#define LLINF 0x3f3f3f3f3f3f3f3f
#define mpr make_pair
#define pb push_back
// Shorthand Functions
template <typename T> inline void maxa(T &st, T v) { st = max(st, v); }
template <typename T> inline void mina(T &st, T v) { st = min(st, v); }
// Out operators and printing for arrays and vectors
template <typename T> ostream &operator<<(ostream &out, vector<T> iter) {
out << "[";
for (auto t : iter) {
out << t << ", ";
}
out << "]";
return out;
}
template <typename T> void printDebug(T *arr, int sz) {
cout << "[";
for (int i = 0; i < sz; i++) {
cout << arr[i] << ", ";
}
cout << "]\n";
}
template <typename T> void printArray(T *arr, int sz) {
for (int i = 0; i < sz; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
#define OUT_OPERATOR(type, propa, propb) \
ostream &operator<<(ostream &out, type obj) { \
out << "(" << #propa << "=" << obj.propa << ", " << #propb << "=" \
<< obj.propb << ")"; \
return out; \
}
// I/O Operations
inline void scan() {}
template <typename F, typename... R> inline void scan(F &f, R &...r) {
cin >> f;
scan(r...);
}
inline void println() { cout << "\n"; }
template <typename F, typename... R> inline void println(F f, R... r) {
cout << f << " ";
println(r...);
}
inline void print() {}
template <typename F, typename... R> inline void print(F f, R... r) {
cout << f;
print(r...);
}
// Debugging
int di_;
string dnms_, co_ = ",";
void debug_() { cout << endl; }
template <typename F, typename... R> void debug_(F f, R... r) {
int bc = 0;
while (bc != 0 || dnms_[di_] != ',') {
if (dnms_[di_] == '(') {
bc++;
} else if (dnms_[di_] == ')') {
bc--;
}
cout << dnms_[di_++];
}
di_++;
cout << ": " << f << ",";
debug_(r...);
}
#define debug(...) \
do { \
dnms_ = #__VA_ARGS__ + co_, di_ = 0, debug_(__VA_ARGS__); \
} while (0)
struct ed {
int v, w = INF;
bool operator<(const ed &o) const { return w < o.w; }
};
inline int let(char c) { return c - 'a'; }
const int MN = 2e5 + 1, LS = 26;
int n, m;
vi idxOf[LS];
ed g[MN][LS];
string s, t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
scan(s, t);
n = s.length();
m = t.length();
for (int i = 0; i < n; i++)
idxOf[let(s[i])].pb(i);
set<pii> used;
for (int i = 1; i < m; i++) {
int a = let(t[i - 1]), b = let(t[i]);
auto p = mpr(a, b);
if (used.find(p) != used.end())
continue;
used.insert(p);
if (idxOf[b].empty()) {
println(-1);
return 0;
}
for (int id : idxOf[a]) {
auto nxtPtr = upper_bound(idxOf[b].begin(), idxOf[b].end(), id);
if (nxtPtr == idxOf[b].end())
mina(g[id][b], {idxOf[b][0], n - id + idxOf[b][0]});
else
mina(g[id][b], {*nxtPtr, *nxtPtr - id});
}
}
if (idxOf[let(t[0])].empty()) {
println(-1);
return 0;
}
ll ans = idxOf[let(t[0])][0], id = ans;
for (int i = 1; i < m; i++) {
int clet = let(t[i]);
if (g[id][clet].w == INF) {
println(-1);
return 0;
}
auto edge = g[id][clet];
id = edge.v;
ans += edge.w;
}
println(ans + 1);
return 0;
}
|
[
"literal.number.change",
"expression.operation.binary.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 741,027
| 741,028
|
u386030504
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if (!(p))
#define until(p) while (!(p))
using ll = std::int64_t;
using P = std::tuple<int, int>;
std::string S, T;
int memS, memT;
std::vector<int> v[26];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> S >> T;
int N = S.size(), M = T.size();
for (int i = 0; i < N; ++i) {
char c = S[i];
memS = memS | (1 << (c - 'a'));
v[c - 'a'].emplace_back(i);
}
for (int i = 0; i < M; ++i) {
char c = T[i];
memT = memT | (1 << (c - 'a'));
}
for (int i = 0; i < 26; ++i) {
unless(!(memT >> i & 1) || (memS >> i & 1)) {
std::cout << "-1" << std::endl;
return 0;
}
}
ll pos = 0, res = 1;
for (int i = 0; i < M; ++i) {
char c = T[i];
int j = c - 'a';
int nxt = std::upper_bound(v[j].begin(), v[j].end(), pos) - v[j].begin();
if (nxt < v[j].size()) {
nxt = v[j][nxt];
res += nxt - pos;
pos = nxt;
} else {
nxt = v[j][0];
res += nxt + N - pos;
pos = nxt;
}
}
std::cout << res << std::endl;
}
|
#include <bits/stdc++.h>
#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if (!(p))
#define until(p) while (!(p))
using ll = std::int64_t;
using P = std::tuple<int, int>;
std::string S, T;
int memS, memT;
std::vector<int> v[26];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> S >> T;
int N = S.size(), M = T.size();
for (int i = 0; i < N; ++i) {
char c = S[i];
memS = memS | (1 << (c - 'a'));
v[c - 'a'].emplace_back(i);
}
for (int i = 0; i < M; ++i) {
char c = T[i];
memT = memT | (1 << (c - 'a'));
}
for (int i = 0; i < 26; ++i) {
unless(!(memT >> i & 1) || (memS >> i & 1)) {
std::cout << "-1" << std::endl;
return 0;
}
}
ll pos = -1, res = 0;
for (int i = 0; i < M; ++i) {
char c = T[i];
int j = c - 'a';
int nxt = std::upper_bound(v[j].begin(), v[j].end(), pos) - v[j].begin();
if (nxt < v[j].size()) {
nxt = v[j][nxt];
res += nxt - pos;
pos = nxt;
} else {
nxt = v[j][0];
res += nxt + N - pos;
pos = nxt;
}
}
std::cout << res << std::endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,029
| 741,030
|
u764058295
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if (!(p))
#define until(p) while (!(p))
using ll = std::int64_t;
using P = std::tuple<int, int>;
std::string S, T;
int memS, memT;
std::vector<int> v[26];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> S >> T;
int N = S.size(), M = T.size();
for (int i = 0; i < N; ++i) {
char c = S[i];
memS = memS | (1 << (c - 'a'));
v[c - 'a'].emplace_back(i);
}
for (int i = 0; i < M; ++i) {
char c = T[i];
memT = memT | (1 << (c - 'a'));
}
for (int i = 0; i < 26; ++i) {
unless(!(memT >> i & 1) || (memS >> i & 1)) {
std::cout << "-1" << std::endl;
return 0;
}
}
ll pos = 0, res = 1;
for (int i = 0; i < M; ++i) {
char c = T[i];
int j = c - 'a';
int nxt = std::lower_bound(v[j].begin(), v[j].end(), pos) - v[j].begin();
if (nxt < v[j].size()) {
nxt = v[j][nxt];
res += nxt - pos;
pos = nxt;
} else {
nxt = v[j][0];
res += nxt + N - pos;
pos = nxt;
}
}
std::cout << res << std::endl;
}
|
#include <bits/stdc++.h>
#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if (!(p))
#define until(p) while (!(p))
using ll = std::int64_t;
using P = std::tuple<int, int>;
std::string S, T;
int memS, memT;
std::vector<int> v[26];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> S >> T;
int N = S.size(), M = T.size();
for (int i = 0; i < N; ++i) {
char c = S[i];
memS = memS | (1 << (c - 'a'));
v[c - 'a'].emplace_back(i);
}
for (int i = 0; i < M; ++i) {
char c = T[i];
memT = memT | (1 << (c - 'a'));
}
for (int i = 0; i < 26; ++i) {
unless(!(memT >> i & 1) || (memS >> i & 1)) {
std::cout << "-1" << std::endl;
return 0;
}
}
ll pos = -1, res = 0;
for (int i = 0; i < M; ++i) {
char c = T[i];
int j = c - 'a';
int nxt = std::upper_bound(v[j].begin(), v[j].end(), pos) - v[j].begin();
if (nxt < v[j].size()) {
nxt = v[j][nxt];
res += nxt - pos;
pos = nxt;
} else {
nxt = v[j][0];
res += nxt + N - pos;
pos = nxt;
}
}
std::cout << res << std::endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 741,031
| 741,030
|
u764058295
|
cpp
|
p02937
|
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
using namespace std;
#define Ms(s, n) memset(s, n, sizeof(s))
#define Rp(i, l, m) for (int i = l; i < m; ++i)
#define Rpd(i, l, m) for (int i = l; i >= m; --i)
#define Rpp(i, l, m) for (int i = l; i <= m; i++)
#define RpAll(it, a) \
for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define All(a) (a).begin(), (a).end()
#define Fi first
#define Se second
#define Pb push_back
#define Pf push_front
#define Is insert
#define Sz(a) int((a).size())
#define ooi INT_MAX
#define ool LLONG_MAX
typedef long long ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
const int MOD = (int)1e9 + 7;
const ld PI = acos((ld)-1);
inline ll gcd(ll a, ll b) {
ll r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline ll fpow(ll n, ll k) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % MOD;
n = n * n % MOD;
}
return r;
}
const int base = 311;
const int N = 1e5 + 5;
ll n, m, k, test, a[N];
vector<int> v[140];
void Solve() {
string s, t;
cin >> s >> t;
n = Sz(s);
m = Sz(t);
for (int i = 0; i < n; i++) {
v[s[i]].Pb(i);
}
k = -1;
int cnt = 0, d = 0;
for (int i = 96; i < 130; i++)
v[i].Pb(ooi);
for (int i = 0; i < m; i++) {
char c = t[i];
d = int(upper_bound(v[c].begin(), v[c].end(), k) - v[c].begin());
if (v[c][d] == ooi) {
k = -1;
int d = int(upper_bound(v[c].begin(), v[c].end(), k) - v[c].begin());
if (v[c][d] == ooi)
cout << -1, exit(0);
else {
k = v[c][d];
cnt++;
}
} else {
k = v[c][d];
}
}
cout << n * cnt + v[t[m - 1]][d] + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
Solve();
return 0;
}
|
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
using namespace std;
#define Ms(s, n) memset(s, n, sizeof(s))
#define Rp(i, l, m) for (int i = l; i < m; ++i)
#define Rpd(i, l, m) for (int i = l; i >= m; --i)
#define Rpp(i, l, m) for (int i = l; i <= m; i++)
#define RpAll(it, a) \
for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define All(a) (a).begin(), (a).end()
#define Fi first
#define Se second
#define Pb push_back
#define Pf push_front
#define Is insert
#define Sz(a) int((a).size())
#define ooi INT_MAX
#define ool LLONG_MAX
typedef long long ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
const int MOD = (int)1e9 + 7;
const ld PI = acos((ld)-1);
inline ll gcd(ll a, ll b) {
ll r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline ll fpow(ll n, ll k) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % MOD;
n = n * n % MOD;
}
return r;
}
const int base = 311;
const int N = 1e5 + 5;
ll n, m, k, test, a[N];
vector<int> v[140];
void Solve() {
string s, t;
cin >> s >> t;
n = Sz(s);
m = Sz(t);
for (int i = 0; i < n; i++) {
v[s[i]].Pb(i);
}
k = -1;
int cnt = 0, d = 0;
for (int i = 96; i < 130; i++)
v[i].Pb(ooi);
for (int i = 0; i < m; i++) {
char c = t[i];
d = int(upper_bound(v[c].begin(), v[c].end(), k) - v[c].begin());
if (v[c][d] == ooi) {
k = -1;
d = int(upper_bound(v[c].begin(), v[c].end(), k) - v[c].begin());
if (v[c][d] == ooi)
cout << -1, exit(0);
else {
k = v[c][d];
cnt++;
}
} else {
k = v[c][d];
}
}
cout << n * cnt + v[t[m - 1]][d] + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
Solve();
return 0;
}
|
[] | 741,036
| 741,037
|
u671291651
|
cpp
|
p02937
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define Endl endl
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define over(A) \
{ \
cout << A << endl; \
exit(0); \
}
#define all(A) A.begin(), A.end()
#define ceil(a, b) ((a - 1) / b + 1)
#define srand() \
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define rand(l, r) uniform_int_distribution<int>(l, r)(rng)
typedef unsigned long long ull;
const int inf = 1039074182;
using namespace std;
char str[100005];
char c[100005];
int n;
int k;
bool have[256];
int nxt[100005][26];
int main() {
// freopen("input.txt","r",stdin);
scanf("%s", str);
scanf("%s", c);
n = strlen(str);
k = strlen(c);
for (int i = 0; i < n; i++) {
have[str[i]] = true;
for (int j = 0; j < 26; j++) {
nxt[i][j] = -1;
}
}
for (int j = 0; j < 26; j++) {
nxt[n][j] = -1;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
if (str[i] - 'a' == j) {
nxt[i][j] = i;
} else {
nxt[i][j] = nxt[i + 1][j];
}
}
}
for (int i = 0; i < k; i++) {
if (!have[c[i]])
over("-1");
}
int res = 0;
int cur = 0;
for (int i = 0; i < k; i++) {
// cout<<i<<' '<<cur<<' '<<nxt[cur][c[i]-'a']<<endl;
if (nxt[cur][c[i] - 'a'] == -1) {
cur = 0;
res++;
}
cur = nxt[cur][c[i] - 'a'];
// cout<<cur<<endl;
}
// cout<<res<<endl;
cout << 1LL * res * n + cur + 1 << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define Endl endl
#define mp make_pair
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define over(A) \
{ \
cout << A << endl; \
exit(0); \
}
#define all(A) A.begin(), A.end()
#define ceil(a, b) ((a - 1) / b + 1)
#define srand() \
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define rand(l, r) uniform_int_distribution<int>(l, r)(rng)
typedef unsigned long long ull;
const int inf = 1039074182;
using namespace std;
char str[100005];
char c[100005];
int n;
int k;
bool have[256];
int nxt[100005][26];
int main() {
// freopen("input.txt","r",stdin);
scanf("%s", str);
scanf("%s", c);
n = strlen(str);
k = strlen(c);
for (int i = 0; i < n; i++) {
have[str[i]] = true;
for (int j = 0; j < 26; j++) {
nxt[i][j] = -1;
}
}
for (int j = 0; j < 26; j++) {
nxt[n][j] = -1;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
if (str[i] - 'a' == j) {
nxt[i][j] = i;
} else {
nxt[i][j] = nxt[i + 1][j];
}
}
}
for (int i = 0; i < k; i++) {
if (!have[c[i]])
over("-1");
}
int res = 0;
int cur = 0;
for (int i = 0; i < k; i++) {
if (nxt[cur][c[i] - 'a'] == -1) {
cur = 0;
res++;
}
cur = nxt[cur][c[i] - 'a'] + 1;
}
cout << 1LL * res * n + cur << endl;
return 0;
}
|
[
"assignment.change",
"expression.operation.binary.remove"
] | 741,038
| 741,039
|
u303964289
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
void solve() {
string s, t;
cin >> s >> t;
int N = s.size();
int M = t.size();
s += s;
vector<vector<int>> next(s.size(), vector<int>(26, 0));
vector<int> cur_next(26, -1);
for (int i = s.size() - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
next[i][j] = cur_next[j];
}
cur_next[s[i] - 'a'] = i;
}
vector<vector<ll>> add(N, vector<ll>(26, -1));
for (int i = 0; i < N; i++) {
for (int c = 0; c < 26; c++) {
if (next[i][c] == -1)
continue;
add[i][c] = next[i][c] - i;
}
}
ll ans = 0;
int now = 0;
for (int j = 0; j < M; j++) {
if (add[now][t[j] - 'a'] == -1) {
cout << -1 << endl;
return;
}
ans += add[now][t[j] - 'a'];
now += add[now][t[j] - 'a'];
now %= N;
}
cout << ans + 1 << endl;
}
int main() {
#ifdef LOCAL_ENV
cin.exceptions(ios::failbit);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
void solve() {
string s, t;
cin >> s >> t;
int N = s.size();
int M = t.size();
s += s;
vector<vector<int>> next(s.size(), vector<int>(26, 0));
vector<int> cur_next(26, -1);
for (int i = s.size() - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
next[i][j] = cur_next[j];
}
cur_next[s[i] - 'a'] = i;
}
vector<vector<ll>> add(N, vector<ll>(26, -1));
for (int i = 0; i < N; i++) {
for (int c = 0; c < 26; c++) {
if (next[i][c] == -1)
continue;
add[i][c] = next[i][c] - i;
}
}
ll ans = 0;
int now = N - 1;
for (int j = 0; j < M; j++) {
if (add[now][t[j] - 'a'] == -1) {
cout << -1 << endl;
return;
}
ans += add[now][t[j] - 'a'];
now += add[now][t[j] - 'a'];
now %= N;
}
cout << ans << endl;
}
int main() {
#ifdef LOCAL_ENV
cin.exceptions(ios::failbit);
#endif
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
}
|
[
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.remove"
] | 741,045
| 741,046
|
u745250049
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T, typename K> using ump = unordered_map<T, K>;
const ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007;
const ll inf = ll(1e9);
const ll e5 = ll(1e5);
const ll ll_inf = ll(1e9) * ll(1e9);
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define repone(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define each(i, mp) for (auto &i : mp)
#define eb emplace_back
#define F first
#define S second
#define all(obj) (obj).begin(), (obj).end()
template <class T> void dump_debug(T list) {
#ifdef MY_DEBUG
each(e, list) cout << e << " ";
printf("\n");
#endif
}
/* ------------- ANSWER ------------- */
/* ---------------------------------- */
int main() {
#ifdef MY_DEBUG
while (true) {
#endif
string s;
string t;
cin >> s >> t;
ll ns = s.size(), nt = t.size();
unordered_map<char, vector<ll>> mp;
rep(i, ns) { mp[s[i]].eb(i); }
ll rev = 0;
ll c = 0;
ll now = -1;
rep(i, nt) {
if (mp[t[i]].empty()) {
cout << -1 << endl;
return 0;
}
auto itr = upper_bound(all(mp[t[i]]), now);
if (itr == mp[t[i]].end()) {
rev++;
now = mp[t[i]][0];
c = 0;
} else {
now = *itr;
c = now + 1;
}
}
cout << rev * ns + c << endl;
#ifdef MY_DEBUG
}
#endif
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T, typename K> using ump = unordered_map<T, K>;
const ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007;
const ll inf = ll(1e9);
const ll e5 = ll(1e5);
const ll ll_inf = ll(1e9) * ll(1e9);
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n - 1; i >= 0; i--)
#define repone(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define each(i, mp) for (auto &i : mp)
#define eb emplace_back
#define F first
#define S second
#define all(obj) (obj).begin(), (obj).end()
template <class T> void dump_debug(T list) {
#ifdef MY_DEBUG
each(e, list) cout << e << " ";
printf("\n");
#endif
}
/* ------------- ANSWER ------------- */
/* ---------------------------------- */
int main() {
#ifdef MY_DEBUG
while (true) {
#endif
string s;
string t;
cin >> s >> t;
ll ns = s.size(), nt = t.size();
unordered_map<char, vector<ll>> mp;
rep(i, ns) { mp[s[i]].eb(i); }
ll rev = 0;
ll c = 0;
ll now = -1;
rep(i, nt) {
if (mp[t[i]].empty()) {
cout << -1 << endl;
return 0;
}
auto itr = upper_bound(all(mp[t[i]]), now);
if (itr == mp[t[i]].end()) {
rev++;
now = mp[t[i]][0];
c = now + 1;
} else {
now = *itr;
c = now + 1;
}
}
cout << rev * ns + c << endl;
#ifdef MY_DEBUG
}
#endif
return 0;
}
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"assignment.change"
] | 741,047
| 741,048
|
u136378781
|
cpp
|
p02937
|
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define MOD (1000000007l)
#define rep(i, n) for (long i = 0; i < (n); i++)
using namespace std;
unordered_map<char, vector<long>> positions;
void solve() {
string s, t;
cin >> s >> t;
rep(i, s.size()) { positions[s[i]].push_back(i); }
long count = 0;
long current = 0;
for (char c : t) {
if (positions[c].size() == 0) {
cout << -1 << endl;
return;
}
current += 1;
count += current / s.size();
current %= s.size();
auto it = lower_bound(positions[c].begin(), positions[c].end(), current);
if (it == positions[c].end()) {
count += 1;
current = positions[c][0];
} else {
current = *it;
}
}
long result = count * s.size() + current + 1;
cout << result << endl;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(12);
solve();
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define MOD (1000000007l)
#define rep(i, n) for (long i = 0; i < (n); i++)
using namespace std;
unordered_map<char, vector<long>> positions;
void solve() {
string s, t;
cin >> s >> t;
rep(i, s.size()) { positions[s[i]].push_back(i); }
long count = 0;
long current = -1;
for (char c : t) {
if (positions[c].size() == 0) {
cout << -1 << endl;
return;
}
current += 1;
count += current / s.size();
current %= s.size();
auto it = lower_bound(positions[c].begin(), positions[c].end(), current);
if (it == positions[c].end()) {
count += 1;
current = positions[c][0];
} else {
current = *it;
}
}
long result = count * s.size() + current + 1;
cout << result << endl;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(12);
solve();
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,051
| 741,052
|
u995792346
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
string S, T;
vector<int> X[26];
typedef long long ll;
ll solve() {
ll q = 0, r = 0;
for (int i = 0; i < T.size(); ++i) {
int c = T[i] - 'a';
if (X[c].empty()) {
return -1;
}
int k = upper_bound(X[c].begin(), X[c].end(), r) - X[c].begin();
if (k == X[c].size()) {
++q;
r = X[c][0];
} else {
r = X[c][k];
}
}
return q * S.size() + r + 1;
}
int main() {
cin >> S >> T;
for (int i = 0; i < S.size(); ++i) {
X[S[i] - 'a'].push_back(i);
}
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string S, T;
vector<int> X[26];
typedef long long ll;
ll solve() {
ll q = 0, r = -1;
for (int i = 0; i < T.size(); ++i) {
int c = T[i] - 'a';
if (X[c].empty()) {
return -1;
}
int k = upper_bound(X[c].begin(), X[c].end(), r) - X[c].begin();
if (k == X[c].size()) {
++q;
r = X[c][0];
} else {
r = X[c][k];
}
}
return q * S.size() + r + 1;
}
int main() {
cin >> S >> T;
for (int i = 0; i < S.size(); ++i) {
X[S[i] - 'a'].push_back(i);
}
cout << solve() << endl;
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,055
| 741,056
|
u637938292
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
char A[100005], B[100005];
int a, b, n, ne[100005][30], Ne[30], now, H[30], an, Next;
long long ans;
int main() {
scanf("%s", A + 1);
scanf("%s", B + 1);
a = strlen(A + 1);
b = strlen(B + 1);
for (int i = 1; i <= a; i++)
H[A[i] - 'a'] = 1;
an = 0;
for (int i = 1; i <= b; i++)
an |= (H[B[i] - 'a'] == 0);
if (an)
return puts("-1"), 0;
for (int i = a; i; i--)
Ne[A[i] - 'a'] = i;
for (int i = a; i; i--) {
for (int j = 0; j < 26; j++)
ne[i][j] = Ne[j];
Ne[A[i] - 'a'] = i;
}
now = Ne[B[1] - 'a'], ans = now;
for (int i = 2; i <= b; i++) {
Next = ne[now][B[i] - 'a'];
ans += Next < now ? Next - now + a : Next - now;
now = Next;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char A[100005], B[100005];
long long a, b, n, ne[100005][30], Ne[30], now, H[30], an, Next;
long long ans;
int main() {
scanf("%s", A + 1);
scanf("%s", B + 1);
a = strlen(A + 1);
b = strlen(B + 1);
for (int i = 1; i <= a; i++)
H[A[i] - 'a'] = 1;
an = 0;
for (int i = 1; i <= b; i++)
an |= (H[B[i] - 'a'] == 0);
if (an)
return puts("-1"), 0;
for (int i = a; i; i--)
Ne[A[i] - 'a'] = i;
for (int i = a; i; i--) {
for (int j = 0; j < 26; j++)
ne[i][j] = Ne[j];
Ne[A[i] - 'a'] = i;
}
now = Ne[B[1] - 'a'], ans = now;
for (int i = 2; i <= b; i++) {
Next = ne[now][B[i] - 'a'];
ans += Next <= now ? Next - now + a : Next - now;
now = Next;
}
printf("%lld\n", ans);
return 0;
}
|
[
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operator.compare.change",
"assignment.value.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 741,061
| 741,062
|
u867285555
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
int a[26][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
int slen = s.size();
for (int i = 1; i <= slen; ++i) {
int tmp = s[i - 1] - 'a';
a[tmp][++a[tmp][0]] = i;
}
ll ans = 0;
int cur = 0;
for (auto i : t) {
int I = i - 'a';
if (!a[I][0]) {
cout << -1;
return 0;
}
int p = lower_bound(a[I] + 1, a[I] + a[I][0] + 1, cur) - a[I];
if (p > a[I][0]) {
ans += slen - cur + a[I][1];
cur = a[I][1];
} else {
ans += a[I][p] - cur;
cur = a[I][p];
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
int a[26][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
int slen = s.size();
for (int i = 1; i <= slen; ++i) {
int tmp = s[i - 1] - 'a';
a[tmp][++a[tmp][0]] = i;
}
ll ans = 0;
int cur = 0;
for (auto i : t) {
int I = i - 'a';
if (!a[I][0]) {
cout << -1;
return 0;
}
int p = upper_bound(a[I] + 1, a[I] + a[I][0] + 1, cur) - a[I];
if (p > a[I][0]) {
ans += slen - cur + a[I][1];
cur = a[I][1];
} else {
ans += a[I][p] - cur;
cur = a[I][p];
}
}
cout << ans;
}
|
[
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 741,065
| 741,066
|
u049421539
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "-1" << endl; \
return 0
#define MM << " " <<
#define Endl endl
signed main() {
string S, T;
cin >> S >> T;
int N = S.size(), M = T.size();
int judge[26] = {};
REP(i, N) { judge[S[i] - 'a']++; }
REP(i, M) {
if (judge[T[i] - 'a'] == 0) {
GOODBYE;
}
}
vector<int> G[26];
REP(i, N) { G[S[i] - 'a'].push_back(i); }
int Ans = 0;
int preit = -1;
REP(i, M) {
int a = (int)(T[i] - 'a');
int pos =
distance(G[a].begin(), lower_bound(G[a].begin(), G[a].end(), preit));
// cout << T[i] MM pos << endl;
if (pos == G[a].size()) {
Ans++;
preit = G[a][0];
} else {
preit = G[a][pos];
}
}
cout << Ans * N + preit + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "-1" << endl; \
return 0
#define MM << " " <<
#define Endl endl
signed main() {
string S, T;
cin >> S >> T;
int N = S.size(), M = T.size();
int judge[26] = {};
REP(i, N) { judge[S[i] - 'a']++; }
REP(i, M) {
if (judge[T[i] - 'a'] == 0) {
GOODBYE;
}
}
vector<int> G[26];
REP(i, N) { G[S[i] - 'a'].push_back(i); }
int Ans = 0;
int preit = -1;
REP(i, M) {
int a = (int)(T[i] - 'a');
int pos = distance(G[a].begin(),
lower_bound(G[a].begin(), G[a].end(), preit + 1));
// cout << T[i] MM pos << endl;
if (pos == G[a].size()) {
Ans++;
preit = G[a][0];
} else {
preit = G[a][pos];
}
}
cout << Ans * N + preit + 1 << endl;
return 0;
}
|
[
"assignment.change"
] | 741,067
| 741,068
|
u554953477
|
cpp
|
p02937
|
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD=998244353;
const long long LINF = 1e18;
using namespace std;
#define int long long
void fin(int n) {
cout << n << endl;
exit(0);
}
// template
// main
signed main() {
string s, t;
cin >> s >> t;
int N = s.size(), M = t.size();
std::vector<int> v(26, 0), w(26, 0);
for (int i = 0; i < N; i++)
v[s[i] - 'a']++;
for (int i = 0; i < M; i++)
w[t[i] - 'a']++;
for (int i = 0; i < 26; i++)
if (v[i] == 0 && w[i])
fin(-1);
std::vector<int> edge[26];
for (int i = 0; i < N; i++)
edge[s[i] - 'a'].push_back(i);
int ans = 0, now = -1;
for (int i = 0; i < M; i++) {
int a = t[i] - 'a';
int l = -1, r = edge[a].size() - 1;
if (edge[a][r] < now) {
ans++;
now = edge[a][0];
continue;
}
while (r - l > 1) {
int m = (l + r) / 2;
if (edge[a][m] > now)
r = m;
else
l = m;
}
now = edge[a][r];
// cout<<ans<<" "<<now<<endl;
}
cout << ans * N + now + 1 << endl;
}
|
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD=998244353;
const long long LINF = 1e18;
using namespace std;
#define int long long
void fin(int n) {
cout << n << endl;
exit(0);
}
// template
// main
signed main() {
string s, t;
cin >> s >> t;
int N = s.size(), M = t.size();
std::vector<int> v(26, 0), w(26, 0);
for (int i = 0; i < N; i++)
v[s[i] - 'a']++;
for (int i = 0; i < M; i++)
w[t[i] - 'a']++;
for (int i = 0; i < 26; i++)
if (v[i] == 0 && w[i])
fin(-1);
std::vector<int> edge[26];
for (int i = 0; i < N; i++)
edge[s[i] - 'a'].push_back(i);
int ans = 0, now = -1;
for (int i = 0; i < M; i++) {
int a = t[i] - 'a';
int l = -1, r = edge[a].size() - 1;
if (edge[a][r] <= now) {
ans++;
now = edge[a][0];
continue;
}
while (r - l > 1) {
int m = (l + r) / 2;
if (edge[a][m] > now)
r = m;
else
l = m;
}
now = edge[a][r];
// cout<<ans<<" "<<now<<endl;
}
cout << ans * N + now + 1 << endl;
}
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,069
| 741,070
|
u942774736
|
cpp
|
p02937
|
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD=998244353;
const long long LINF = 1e18;
using namespace std;
#define int long long
void fin(int n) {
cout << n << endl;
exit(0);
}
// template
// main
signed main() {
string s, t;
cin >> s >> t;
int N = s.size(), M = t.size();
std::vector<int> v(26, 0), w(26, 0);
for (int i = 0; i < N; i++)
v[s[i] - 'a']++;
for (int i = 0; i < M; i++)
w[t[i] - 'a']++;
for (int i = 0; i < 26; i++)
if (v[i] == 0 && w[i])
fin(-1);
std::vector<int> edge[26];
for (int i = 0; i < N; i++)
edge[s[i] - 'a'].push_back(i);
int ans = 0, now = 0;
for (int i = 0; i < M; i++) {
int a = t[i] - 'a';
int l = -1, r = edge[a].size() - 1;
if (edge[a][r] < now) {
ans++;
now = edge[a][0];
continue;
}
while (r - l > 1) {
int m = (l + r) / 2;
if (edge[a][m] > now)
r = m;
else
l = m;
}
now = edge[a][r];
// cout<<ans<<" "<<now<<endl;
}
cout << ans * N + now + 1 << endl;
}
|
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD=998244353;
const long long LINF = 1e18;
using namespace std;
#define int long long
void fin(int n) {
cout << n << endl;
exit(0);
}
// template
// main
signed main() {
string s, t;
cin >> s >> t;
int N = s.size(), M = t.size();
std::vector<int> v(26, 0), w(26, 0);
for (int i = 0; i < N; i++)
v[s[i] - 'a']++;
for (int i = 0; i < M; i++)
w[t[i] - 'a']++;
for (int i = 0; i < 26; i++)
if (v[i] == 0 && w[i])
fin(-1);
std::vector<int> edge[26];
for (int i = 0; i < N; i++)
edge[s[i] - 'a'].push_back(i);
int ans = 0, now = -1;
for (int i = 0; i < M; i++) {
int a = t[i] - 'a';
int l = -1, r = edge[a].size() - 1;
if (edge[a][r] <= now) {
ans++;
now = edge[a][0];
continue;
}
while (r - l > 1) {
int m = (l + r) / 2;
if (edge[a][m] > now)
r = m;
else
l = m;
}
now = edge[a][r];
// cout<<ans<<" "<<now<<endl;
}
cout << ans * N + now + 1 << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,071
| 741,070
|
u942774736
|
cpp
|
p02937
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;
template <class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
vector<vector<int>> calcNext(const string &S) {
int n = (int)S.size();
vector<vector<int>> res(n + 1, vector<int>(26, -1));
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j)
res[i][j] = res[i + 1][j];
res[i][S[i] - 'a'] = i;
}
return res;
}
int main() {
string s, t;
cin >> s >> t;
int n = s.size();
s += s;
s += s;
auto p = calcNext(s);
ll ans = 0, cur = 0;
for (auto &&i : t) {
int curr = p[cur + 1][i - 'a'];
if (curr == -1) {
puts("-1");
return 0;
}
ans += curr - cur;
cur = (curr) % n;
}
cout << ans + 1 << "\n";
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;
template <class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
vector<vector<int>> calcNext(const string &S) {
int n = (int)S.size();
vector<vector<int>> res(n + 1, vector<int>(26, -1));
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j)
res[i][j] = res[i + 1][j];
res[i][S[i] - 'a'] = i;
}
return res;
}
int main() {
string s, t;
cin >> s >> t;
int n = s.size();
s += s;
s += s;
auto p = calcNext(s);
ll ans = 0, cur = -1;
for (auto &&i : t) {
int curr = p[cur + 1][i - 'a'];
if (curr == -1) {
puts("-1");
return 0;
}
ans += curr - cur;
cur = (curr) % n;
}
cout << ans << "\n";
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.remove"
] | 741,072
| 741,073
|
u915020369
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define str string
#define fi first
#define se second
#define pb push_back
#define SET(a, b) memset(a, b, sizeof(a))
#define eps 1e-6
#define pi atan(1) * 4
#define mod 1000000007
#define inf 1000000000
#define llinf 1000000000000000000
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
#define FORl(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORDl(i, a, b) for (ll i = (a); i >= (b); i--)
using namespace std;
int nxt[100005][26];
int tmp[26];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string S, T;
cin >> S >> T;
int s = S.length(), t = T.length();
S = "?" + S;
FORD(i, s, 1) {
memcpy(nxt[i], tmp, sizeof(tmp));
int x = S[i] - 'a';
tmp[x] = i;
}
FOR(i, 1, s) FOR(j, 0, 25) if (!nxt[i][j]) nxt[i][j] = tmp[j];
ll cnt = 0;
int p = 0;
FOR(i, 0, t - 1) {
int x = T[i] - 'a';
if (!i)
p = tmp[x], cnt += p;
else {
int np = nxt[p][x];
if (np < p)
cnt += s - p + np;
else
cnt += np - p;
p = np;
}
if (!p) {
printf("-1\n");
return 0;
}
}
printf("%lld\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define str string
#define fi first
#define se second
#define pb push_back
#define SET(a, b) memset(a, b, sizeof(a))
#define eps 1e-6
#define pi atan(1) * 4
#define mod 1000000007
#define inf 1000000000
#define llinf 1000000000000000000
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
#define FORl(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORDl(i, a, b) for (ll i = (a); i >= (b); i--)
using namespace std;
int nxt[100005][26];
int tmp[26];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string S, T;
cin >> S >> T;
int s = S.length(), t = T.length();
S = "?" + S;
FORD(i, s, 1) {
memcpy(nxt[i], tmp, sizeof(tmp));
int x = S[i] - 'a';
tmp[x] = i;
}
FOR(i, 1, s) FOR(j, 0, 25) if (!nxt[i][j]) nxt[i][j] = tmp[j];
ll cnt = 0;
int p = 0;
FOR(i, 0, t - 1) {
int x = T[i] - 'a';
if (!i)
p = tmp[x], cnt += p;
else {
int np = nxt[p][x];
if (np <= p)
cnt += s - p + np;
else
cnt += np - p;
p = np;
}
if (!p) {
printf("-1\n");
return 0;
}
}
printf("%lld\n", cnt);
return 0;
}
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,078
| 741,079
|
u603167288
|
cpp
|
p02937
|
/*
░░░░░░░░░░░░░░░░▄▄█▀▀██▄▄░░░░░░░
░░░░░░░░░░░░░▄█▀▀░░░░░░░▀█░░░░░░
░░░░░░░░░░░▄▀░░░░░░░░░░░░░█░░░░░
░░░░░░░░░▄█░░░░░░░░░░░░░░░█░░░░░
░░░░░░░██▀░░░░░░░▄▄▄░░▄░█▄█▄░░░░
░░░░░▄▀░░░░░░░░░░████░█▄██░▀▄░░░
░░░░█▀░░░░░░░░▄▄██▀░░█████░██░░░
░░░█▀░░░░░░░░░▀█░▀█▀█▀▀▄██▄█▀░░░
░░░██░░░░░░░░░░█░░█░█░░▀▀▄█▀░░░░
░░░░█░░░░░█░░░▀█░░░░▄░░░░░▄█░░░░
░░░░▀█░░░░███▄░█░░░░░░▄▄▄▄█▀█▄░░
░░░░░▀██░░█▄▀▀██░░░░░░░░▄▄█░░▀▄░
░░░░░░▀▀█▄░▀▄▄░▄░░░░░░░███▀░░▄██
░░░░░░░░░▀▀▀███▀█▄░░░░░█▀░▀░░░▀█
░░░░░░░░░░░░▄▀░░░▀█▄░░░░░▄▄░░▄█▀
░░░▄▄▄▀▀▀▀▀█▀░░░░░█▄▀▄▄▄▄▄▄█▀▀░░
░▄█░░░▄██▀░░░░░░░░░█▄░░░░░░░░░░░
█▀▀░▄█░░░░░░░░░░░░░░▀▀█▄░░░░░░░░
█░░░█░░░░░░░░░░░░░░░░░░█▄░░░░░░░*/
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define dbg(x) cout << #x << '=' << x << '\n';
#define ll long long
#define x first
#define y second
#define pi pair<int, int>
#define vi vector<int>
#define L nod << 1
#define R ((nod << 1) | 1)
#define mp make_pair
const ll mod = 1000000007;
const ll nmax = 2525 * 1001;
#define int ll
int n, q;
string s, t;
vi v[30];
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
v[s[i] - 'a'].pb(i);
}
int rotations = 0, last = -1;
for (int i = 0; i < t.size(); i++) {
int c = t[i] - 'a';
if (v[c].empty())
return cout << -1, 0;
auto it = lower_bound(v[c].begin(), v[c].end(), last);
if (it == v[c].end())
rotations++, last = v[c][0];
else
last = *it;
}
cout << rotations * s.size() + last + 1;
}
|
/*
░░░░░░░░░░░░░░░░▄▄█▀▀██▄▄░░░░░░░
░░░░░░░░░░░░░▄█▀▀░░░░░░░▀█░░░░░░
░░░░░░░░░░░▄▀░░░░░░░░░░░░░█░░░░░
░░░░░░░░░▄█░░░░░░░░░░░░░░░█░░░░░
░░░░░░░██▀░░░░░░░▄▄▄░░▄░█▄█▄░░░░
░░░░░▄▀░░░░░░░░░░████░█▄██░▀▄░░░
░░░░█▀░░░░░░░░▄▄██▀░░█████░██░░░
░░░█▀░░░░░░░░░▀█░▀█▀█▀▀▄██▄█▀░░░
░░░██░░░░░░░░░░█░░█░█░░▀▀▄█▀░░░░
░░░░█░░░░░█░░░▀█░░░░▄░░░░░▄█░░░░
░░░░▀█░░░░███▄░█░░░░░░▄▄▄▄█▀█▄░░
░░░░░▀██░░█▄▀▀██░░░░░░░░▄▄█░░▀▄░
░░░░░░▀▀█▄░▀▄▄░▄░░░░░░░███▀░░▄██
░░░░░░░░░▀▀▀███▀█▄░░░░░█▀░▀░░░▀█
░░░░░░░░░░░░▄▀░░░▀█▄░░░░░▄▄░░▄█▀
░░░▄▄▄▀▀▀▀▀█▀░░░░░█▄▀▄▄▄▄▄▄█▀▀░░
░▄█░░░▄██▀░░░░░░░░░█▄░░░░░░░░░░░
█▀▀░▄█░░░░░░░░░░░░░░▀▀█▄░░░░░░░░
█░░░█░░░░░░░░░░░░░░░░░░█▄░░░░░░░*/
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define dbg(x) cout << #x << '=' << x << '\n';
#define ll long long
#define x first
#define y second
#define pi pair<int, int>
#define vi vector<int>
#define L nod << 1
#define R ((nod << 1) | 1)
#define mp make_pair
const ll mod = 1000000007;
const ll nmax = 2525 * 1001;
#define int ll
int n, q;
string s, t;
vi v[30];
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
v[s[i] - 'a'].pb(i);
}
int rotations = 0, last = -1;
for (int i = 0; i < t.size(); i++) {
int c = t[i] - 'a';
if (v[c].empty())
return cout << -1, 0;
auto it = upper_bound(v[c].begin(), v[c].end(), last);
if (it == v[c].end())
rotations++, last = v[c][0];
else
last = *it;
}
cout << rotations * s.size() + last + 1;
}
|
[
"identifier.change",
"call.function.change"
] | 741,082
| 741,083
|
u392848063
|
cpp
|
p02937
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define For(i, a, b) for (int i = a; i <= b; i++)
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define sz(x) ((int)x.size())
#define MOD (ll)(INF)
#define INF 1e17
#define int ll
#define EPS (1e-6)
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int fpow(int b, int p) {
if (p == 0)
return 1;
int h = fpow(b, p / 2);
if (p % 2)
return h * b % MOD * h % MOD;
return h * h % MOD;
}
int find(vector<int> &v, int t) {
int hi = sz(v), lo = -1;
while (hi - lo > 1) {
int m = (hi + lo) / 2;
if (v[m] > t)
hi = m;
else
lo = m;
}
if (hi == sz(v))
return INF;
return v[hi];
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
vector<vector<int>> cnt(26);
For(i, 0, sz(s) - 1) { cnt[s[i] - 'a'].emplace_back(i); }
for (auto &i : cnt)
sort(all(i));
if (sz(cnt[t[0] - 'a']) == 0) {
cout << "-1\n";
return 0;
}
int i = find(cnt[t[0] - 'a'], -1), now = i;
For(j, 1, sz(t) - 1) {
if (sz(cnt[t[j] - 'a']) == 0) {
cout << "-1\n";
return 0;
}
int pos = find(cnt[t[j] - 'a'], i);
if (pos == INF)
pos = cnt[t[j] - 'a'][0];
if (pos < i) {
now += pos + (sz(s) - i);
i = pos;
} else {
now += pos - i;
i = pos;
}
}
cout << now + 1 << "\n";
return 0;
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define For(i, a, b) for (int i = a; i <= b; i++)
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define sz(x) ((int)x.size())
#define MOD (ll)(INF)
#define INF 1e17
#define int ll
#define EPS (1e-6)
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int fpow(int b, int p) {
if (p == 0)
return 1;
int h = fpow(b, p / 2);
if (p % 2)
return h * b % MOD * h % MOD;
return h * h % MOD;
}
int find(vector<int> &v, int t) {
int hi = sz(v), lo = -1;
while (hi - lo > 1) {
int m = (hi + lo) / 2;
if (v[m] > t)
hi = m;
else
lo = m;
}
if (hi == sz(v))
return INF;
return v[hi];
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
vector<vector<int>> cnt(26);
For(i, 0, sz(s) - 1) { cnt[s[i] - 'a'].emplace_back(i); }
for (auto &i : cnt)
sort(all(i));
if (sz(cnt[t[0] - 'a']) == 0) {
cout << "-1\n";
return 0;
}
int i = find(cnt[t[0] - 'a'], -1), now = i;
For(j, 1, sz(t) - 1) {
if (sz(cnt[t[j] - 'a']) == 0) {
cout << "-1\n";
return 0;
}
int pos = find(cnt[t[j] - 'a'], i);
if (pos == INF)
pos = cnt[t[j] - 'a'][0];
if (pos <= i) {
now += pos + (sz(s) - i);
i = pos;
} else {
now += pos - i;
i = pos;
}
}
cout << now + 1 << "\n";
return 0;
}
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,088
| 741,089
|
u055148700
|
cpp
|
p02937
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define Maxn 100000
#define ll long long
char s[Maxn + 5], t[Maxn + 5];
vector<int> id[30];
int n, m;
int num;
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
while (s[++n] != '\0')
;
n--;
while (t[++m] != '\0')
;
m--;
for (int i = 1; i <= n; i++) {
id[s[i] - 'a'].push_back(i);
}
for (int i = 1; i <= m; i++) {
if (id[t[i] - 'a'].empty()) {
puts("-1");
return 0;
}
}
int last = 0;
int x;
for (int i = 1; i <= m; i++) {
if (last > id[t[i] - 'a'].back()) {
num++;
last = id[t[i] - 'a'].front();
continue;
}
x = upper_bound(id[t[i] - 'a'].begin(), id[t[i] - 'a'].end(), last) -
id[t[i] - 'a'].begin();
last = id[t[i] - 'a'][x];
}
cout << 1ll * num * n + last << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define Maxn 100000
#define ll long long
char s[Maxn + 5], t[Maxn + 5];
vector<int> id[30];
int n, m;
int num;
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
while (s[++n] != '\0')
;
n--;
while (t[++m] != '\0')
;
m--;
for (int i = 1; i <= n; i++) {
id[s[i] - 'a'].push_back(i);
}
for (int i = 1; i <= m; i++) {
if (id[t[i] - 'a'].empty()) {
puts("-1");
return 0;
}
}
int last = 0;
int x;
for (int i = 1; i <= m; i++) {
if (last >= id[t[i] - 'a'].back()) {
num++;
last = id[t[i] - 'a'].front();
continue;
}
x = upper_bound(id[t[i] - 'a'].begin(), id[t[i] - 'a'].end(), last) -
id[t[i] - 'a'].begin();
last = id[t[i] - 'a'][x];
}
cout << 1ll * num * n + last << endl;
return 0;
}
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,090
| 741,091
|
u410132794
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
// template {{{ 0
// using {{{ 1
using ll = long long int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
// }}} 1
// definition {{{ 1
// scaning {{{ 2
#define Scd(x) scanf("%d", &x)
#define Scd2(x, y) scanf("%d%d", &x, &y)
#define Scd3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define Scll(x) scanf("%lld", &x)
#define Scll2(x, y) scanf("%lld%lld", &x, &y)
#define Scll3(x, y, z) scanf("%lld%lld%lld", &x, &y, &z)
#define Scc(c) scanf("%c", &c);
#define Scs(s) scanf("%s", s);
#define Scstr(s) scanf("%s", &s);
// }}} 2
// constants {{{ 2
#define EPS (1e-7)
#define INF (2e9)
#define PI (acos(-1))
// }}} 2
// systems {{{ 2
#define Repe(x, y, z) for (ll x = z; x < y; x++)
#define Rep(x, y) Repe(x, y, 0)
#define RRepe(x, y, z) for (ll x = y - z - 1; x >= 0; x--)
#define RRep(x, y) RRepe(x, y, 0)
// }}} 2
// output {{{ 2
#define YesNo(a) (a) ? printf("Yes\n") : printf("No\n")
#define YESNO(a) (a) ? printf("YES\n") : printf("NO\n")
// }}} 2
// }}} 1
// input {{{ 1
// }}} 1
// }}} 0
int main() {
char s[130203];
char t[130203];
Scs(s);
Scs(t);
int N = strlen(s);
int M = strlen(t);
vector<set<int>> ss(2566);
Rep(i, N) { ss[s[i]].insert(i); }
int tmp = 0;
ll ans = 0;
Rep(i, M) {
char tt = t[i];
// printf ("%c\n", tt );
auto it = ss[tt].upper_bound(tmp - 1);
// printf ("%d\n", *it );
if (it == ss[tt].end()) {
it = ss[tt].upper_bound(-1);
ans += N;
if (it == ss[tt].end()) {
ans = -1;
break;
}
}
tmp = *it;
tmp++;
}
printf("%lld\n", ans + tmp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
// template {{{ 0
// using {{{ 1
using ll = long long int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
// }}} 1
// definition {{{ 1
// scaning {{{ 2
#define Scd(x) scanf("%d", &x)
#define Scd2(x, y) scanf("%d%d", &x, &y)
#define Scd3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define Scll(x) scanf("%lld", &x)
#define Scll2(x, y) scanf("%lld%lld", &x, &y)
#define Scll3(x, y, z) scanf("%lld%lld%lld", &x, &y, &z)
#define Scc(c) scanf("%c", &c);
#define Scs(s) scanf("%s", s);
#define Scstr(s) scanf("%s", &s);
// }}} 2
// constants {{{ 2
#define EPS (1e-7)
#define INF (2e9)
#define PI (acos(-1))
// }}} 2
// systems {{{ 2
#define Repe(x, y, z) for (ll x = z; x < y; x++)
#define Rep(x, y) Repe(x, y, 0)
#define RRepe(x, y, z) for (ll x = y - z - 1; x >= 0; x--)
#define RRep(x, y) RRepe(x, y, 0)
// }}} 2
// output {{{ 2
#define YesNo(a) (a) ? printf("Yes\n") : printf("No\n")
#define YESNO(a) (a) ? printf("YES\n") : printf("NO\n")
// }}} 2
// }}} 1
// input {{{ 1
// }}} 1
// }}} 0
int main() {
char s[130203];
char t[130203];
Scs(s);
Scs(t);
int N = strlen(s);
int M = strlen(t);
vector<set<int>> ss(2566);
Rep(i, N) { ss[s[i]].insert(i); }
int tmp = 0;
ll ans = 0;
Rep(i, M) {
char tt = t[i];
// printf ("%c\n", tt );
auto it = ss[tt].upper_bound(tmp - 1);
// printf ("%d\n", *it );
if (it == ss[tt].end()) {
it = ss[tt].upper_bound(-1);
ans += N;
if (it == ss[tt].end()) {
ans = -1;
tmp = 0;
break;
}
}
tmp = *it;
tmp++;
}
printf("%lld\n", ans + tmp);
return 0;
}
|
[
"assignment.add"
] | 741,094
| 741,095
|
u550398291
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reverse(x) reverse(all(x))
#define PQ priority_queue
#define NP(x) next_permutation(all(x))
#define M_PI 3.14159265358979323846
#define popcount __builtin_popcount
using namespace std;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef unsigned long long ull;
typedef vector<ull> vu;
typedef vector<vu> vvu;
typedef double dbl;
typedef vector<dbl> vd;
typedef vector<vd> vvd;
typedef string str;
typedef vector<str> vs;
typedef vector<vs> vvs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef map<int, int> mii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef map<ll, ll> mll;
typedef pair<dbl, dbl> pdd;
typedef vector<pdd> vpdd;
typedef map<dbl, dbl> mdd;
typedef pair<str, str> pss;
typedef vector<pss> vpss;
typedef map<str, str> mss;
typedef pair<int, ll> pil;
typedef vector<pil> vpil;
typedef map<int, ll> mil;
typedef pair<ll, int> pli;
typedef vector<pli> vpli;
typedef map<ll, int> mli;
typedef pair<dbl, int> pdi;
typedef vector<pdi> vpdi;
typedef map<dbl, int> mdi;
template <typename T> vector<T> &operator<<(vector<T> &v, const T t) {
v.push_back(t);
return v;
}
template <typename T> multiset<T> &operator<<(multiset<T> &m, const T t) {
m.insert(t);
return m;
}
template <typename T> set<T> &operator<<(set<T> &s, const T t) {
s.insert(t);
return s;
}
template <typename T> stack<T> &operator<<(stack<T> &s, const T t) {
s.push(t);
return s;
}
template <typename T> stack<T> &operator>>(stack<T> &s, T &t) {
t = s.top();
s.pop();
return s;
}
template <typename T> queue<T> &operator<<(queue<T> &q, const T t) {
q.push(t);
return q;
}
template <typename T> queue<T> &operator>>(queue<T> &q, T &t) {
t = q.front();
q.pop();
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator<<(PQ<T, vector<T>, U> &q, const T t) {
q.push(t);
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator>>(PQ<T, vector<T>, U> &q, T &t) {
t = q.top();
q.pop();
return q;
}
template <typename T, typename U>
istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
istream &operator>>(istream &s, _Bit_reference b) {
int a;
s >> a;
assert(a == 0 || a == 1);
b = a;
return s;
}
template <typename T> istream &operator>>(istream &s, vector<T> &v) {
fr(i, v.size()) { s >> v[i]; }
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
// template<typename T>ostream&operator<<(ostream&s,const vector<T>v){for(auto
// a:v){s<<a<<"\n";}return s;}
template <typename T> ostream &operator<<(ostream &s, const vector<T> v) {
fr(i, v.size()) { i ? s << " " << v[i] : s << v[i]; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const deque<T> d) {
fr(i, d.size()) { i ? s << " " << d[i] : s << d[i]; }
return s;
}
template <typename T> _Bit_reference operator&=(_Bit_reference b, T t) {
return b = b & t;
}
template <typename T> _Bit_reference operator^=(_Bit_reference b, T t) {
return b = b ^ t;
}
template <typename T> _Bit_reference operator|=(_Bit_reference b, T t) {
return b = b | t;
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <typename T, typename U>
pair<T, U> &operator+=(pair<T, U> &a, pair<T, U> b) {
return a = a + b;
}
template <typename T, typename U>
pair<T, U> &operator-=(pair<T, U> &a, pair<T, U> b) {
return a = a - b;
}
void print(void) { cout << "\n"; }
void Print(void) { cout << endl; }
template <typename T> void print(T t) { cout << t << "\n"; }
template <typename T> void Print(T t) { cout << t << endl; }
template <typename T, typename... U> void print(T &&t, U &&...u) {
cout << t << " ";
print(forward<U>(u)...);
}
template <typename T, typename... U> void Print(T &&t, U &&...u) {
cout << t << " ";
Print(forward<U>(u)...);
}
bool YN(bool b) {
print(b ? "YES" : "NO");
return b;
}
bool PI(bool b) {
print(b ? "POSSIBLE" : "IMPOSSIBLE");
return b;
}
bool Yn(bool b) {
print(b ? "Yes" : "No");
return b;
}
bool Pi(bool b) {
print(b ? "Possible" : "Impossible");
return b;
}
bool yn(bool b) {
print(b ? "yes" : "no");
return b;
}
bool pi(bool b) {
print(b ? "possible" : "impossible");
return b;
}
const int e5 = 1e5;
const int e9 = 1e9;
const int MD = 1e9 + 7;
const ll e18 = 1e18;
template <typename T> str to_string(const T &n) {
ostringstream s;
s << n;
return s.str();
}
template <typename T> T &chmax(T &a, T b) { return a = max(a, b); }
template <typename T> T &chmin(T &a, T b) { return a = min(a, b); }
template <typename T, typename U>
vector<pair<T, U>> dijkstra(const vector<vector<pair<T, U>>> &E, const U s,
const T inf) {
using P = pair<T, U>;
vector<P> d;
fr(i, E.size()) { d << P{inf, i}; }
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
template <typename T, typename U>
map<U, pair<T, U>> dijkstra(map<U, vector<pair<T, U>>> E, const U s,
const T inf) {
using P = pair<T, U>;
map<U, P> d;
for (pair<U, vector<P>> e : E) {
d[e.first] = P{inf, e.first};
}
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
ll maxflow(vector<mil> &E, int s, int t) {
ll z = 0;
vi b(E.size(), -1);
for (int i = 0;; ++i) {
static auto dfs = [&](int v, ll f, auto &dfs) -> ll {
if (v == t)
return f;
b[v] = i;
for (auto &p : E[v]) {
if (b[p.first] < i && p.second) {
if (ll r = dfs(p.first, min(f, p.second), dfs)) {
p.second -= r;
E[p.first][v] += r;
return r;
}
}
}
return 0;
};
ll x = dfs(s, ll(1e18), dfs);
z += x;
if (x == 0)
return z;
}
}
template <typename T> T distsq(pair<T, T> a, pair<T, T> b) {
return (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
}
template <typename T> T max(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = max(m, e);
}
return m;
}
template <typename T> T min(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = min(m, e);
}
return m;
}
template <typename T> T gcd(const T a, const T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T> T gcd(const vector<T> a) {
T g = a[0];
for (T e : a) {
g = gcd(g, e);
}
return g;
}
template <typename T> vector<T> LIS(const vector<T> A) {
vector<T> B;
for (T a : A) {
auto it = lower_bound(all(B), a);
if (it == B.end()) {
B << a;
} else {
*it = a;
}
}
return B;
}
template <typename T> vector<T> LCS(vector<T> A, vector<T> B) {
int N = A.size(), M = B.size();
vector<vector<pair<int, pii>>> d(N + 1, vector<pair<int, pii>>(M + 1));
fr(i, N) {
fr(j, M) {
if (A[i] == B[j]) {
d[i + 1][j + 1] = {d[i][j].first + 1, {i, j}};
} else {
d[i + 1][j + 1] = max(d[i][j + 1], d[i + 1][j]);
}
}
}
vector<T> r;
for (pii p = {N, M}; d[p.first][p.second].first;
p = d[p.first][p.second].second) {
r << A[d[p.first][p.second].second.first];
}
Reverse(r);
return r;
}
str LCS(str S, str T) {
vector<char> s =
LCS(vector<char>(S.begin(), S.end()), vector<char>(T.begin(), T.end()));
return str(s.begin(), s.end());
}
template <typename T> vector<pair<T, T>> ConvexHull(vector<pair<T, T>> V) {
if (V.size() <= 3) {
return V;
}
Sort(V);
rf(i, V.size() - 1) V << V[i];
vector<pair<T, T>> r;
for (pair<T, T> p : V) {
int s = r.size();
while (s >= 2 &&
(p.second - r[s - 1].second) * (p.first - r[s - 2].first) <
(p.second - r[s - 2].second) * (p.first - r[s - 1].first)) {
r.pop_back();
--s;
}
r << p;
}
r.pop_back();
return r;
}
class UnionFind {
vi p, s;
void extend(int N) {
foor(i, p.size(), N) {
p << i;
s << 1;
}
}
public:
UnionFind(void) {}
UnionFind(int N) { extend(N - 1); }
int find(int i) {
extend(i);
return p[i] = p[i] == i ? i : find(p[i]);
}
void unite(int a, int b) {
extend(a);
extend(b);
if ((a = find(a)) != (b = find(b))) {
if (s[a] > s[b]) {
swap(a, b);
}
s[b] += s[a];
p[a] = b;
}
}
void unite(pii p) { return unite(p.first, p.second); }
bool same(int a, int b) {
extend(a);
extend(b);
return find(a) == find(b);
}
bool same(pii p) { return same(p.first, p.second); }
int size(int x) {
extend(x);
return s[find(x)];
}
};
ll MST(vector<pair<ll, pii>> &E) {
Sort(E);
UnionFind uf;
ll z = 0;
for (auto &e : E) {
if (!uf.same(e.second)) {
z += e.first;
uf.unite(e.second);
}
}
return z;
}
ll strmod(const str &s, const int m) {
ll x = 0;
fr(i, s.size()) { x = (x * 10 + s[i] - 48) % m; }
return x;
}
vvl mul(const vvl &A, const vvl &B, const int m) {
vvl C;
fr(y, A.size()) { C << vl(B[y].size()); }
fr(y, C.size()) {
fr(x, C[y].size()) {
fr(i, A[0].size()) { (C[y][x] += A[y][i] * B[i][x]) %= m; }
}
}
return C;
}
vvl pow(const vvl &A, const ll n, const int m) {
vvl B;
fr(y, A.size()) { B << vl(A.size()); }
if (n == 0) {
fr(i, B.size()) { B[i][i] = 1; }
}
elsif(n % 2) { B = mul(A, pow(A, n - 1, m), m); }
else {
vvl C = pow(A, n / 2, m);
B = mul(C, C, m);
}
return B;
}
ll pow(const ll a, const ll n, const int m) {
ll t;
return n ? (n & 1 ? a >= 0 ? a % m : (m - (-a % m)) % m : 1) *
(t = pow(a, n >> 1, m), t * t % m) % m
: !!a;
}
ll inv(const ll x, const int p) {
assert(x != 0);
return pow(x, p - 2, p);
}
ll inv(const ll x) { return inv(x, MD); }
vpll fact(const int n, const int p) {
assert(n < p);
vpll v(n + 1);
v[0].first = 1;
foor(i, 1, n) { v[i].first = v[i - 1].first * i % p; }
v[n].second = inv(v[n].first, p);
roof(i, n, 1) { v[i - 1].second = v[i].second * i % p; }
return v;
}
class Combination {
const vpll f;
const int M;
public:
Combination(int n, int m) : f(fact(n, m)), M(m) {}
Combination(int n) : Combination(n, MD) {}
ll P(int n, int k) {
return n < 0 || k < 0 || n < k ? 0ll : f[n].first * f[n - k].second % M;
}
ll C(int n, int k) { return k < 0 ? 0 : P(n, k) * f[k].second % M; }
ll H(int n, int k) { return n == 0 && k == 0 ? 1ll : C(n + k - 1, k); }
ll F(int n) { return n < 0 ? 0 : f[n].first; }
};
ll C2(const int n) { return (ll)n * ~-n / 2; }
ll sum(const vi a) {
ll s = 0;
for (int e : a) {
s += e;
}
return s;
}
ll sum(const vl a) {
ll s = 0;
for (ll e : a) {
s += e;
}
return s;
}
template <typename T> int MSB(T N) {
int r = -1;
for (; N > 0; N /= 2) {
++r;
}
return r;
}
template <typename T> class SegmentTree {
vector<T> S;
T (*const op)(T a, T b);
const T zero;
const int B;
public:
SegmentTree(int N, T (*f)(T a, T b), const T zero)
: S(1 << MSB(N - 1) + 2, zero), op(f), zero(zero),
B(1 << MSB(N - 1) + 1) {}
SegmentTree(vector<T> v, T (*f)(T a, T b), const T zero)
: SegmentTree(v.size(), f, zero) {
fr(i, v.size()) { S[S.size() / 2 + i] = v[i]; }
roof(i, S.size() / 2 - 1, 1) { S[i] = op(S[i * 2], S[i * 2 + 1]); }
}
T calc(int l, int r) {
l += B;
r += B;
if (l > r) {
return zero;
}
if (l == r) {
return S[l];
}
T L = S[l], R = S[r];
for (; l / 2 < r / 2; l /= 2, r /= 2) {
if (l % 2 == 0) {
L = op(L, S[l + 1]);
}
if (r % 2 == 1) {
R = op(S[r - 1], R);
}
}
return op(L, R);
}
void replace(int i, T x) {
for (S[i += B] = x; i != 1; i /= 2) {
if (i % 2) {
S[i / 2] = op(S[i - 1], S[i]);
} else {
S[i / 2] = op(S[i], S[i + 1]);
}
}
}
void add(int i, T x) { replace(i, op(S[B + i], x)); }
T top() { return S[1]; }
};
ll BITsum(vl &B, int i) {
ll z = 0;
while (i > 0) {
z += B[i];
i -= i & -i;
}
return z;
}
void BITadd(vl &B, int i, ll x) {
while (i < B.size()) {
B[i] += x;
i += i & -i;
}
}
ll fib(const ll n, const int m) {
ll a, b, c, d, A, B, C, D;
a = 1;
b = 0;
c = 0;
d = 1;
rf(i, 63) {
A = a * a + b * c;
B = a * b + b * d;
C = c * a + d * c;
D = c * b + d * d;
if (n >> i & 1) {
a = A;
b = B;
c = C;
d = D;
A = a + b;
B = a;
C = c + d;
D = c;
}
a = A % m;
b = B % m;
c = C % m;
d = D % m;
}
return b;
}
vi primes(int n) {
vb b(n + 1);
vi p;
foor(i, 2, n) {
if (!b[i]) {
p << i;
for (int j = 2 * i; j <= n; j += i) {
b[j] = true;
}
}
}
return p;
}
vb isprime(const int n) {
vb v(n + 1, true);
v[0] = v[1] = false;
foor(i, 2, n) {
if (v[i]) {
for (int j = 2 * i; j <= n; j += i) {
v[j] = false;
}
}
}
return v;
}
class LCA {
vvi par;
vi dep;
public:
LCA(vvi &E, int root) : par(MSB(E.size()) + 1, vi(E.size())), dep(E.size()) {
function<void(int, int)> dfs = [&](int i, int p) {
for (int j : E[i])
if (j != p) {
par[0][j] = i;
dep[j] = dep[i] + 1;
dfs(j, i);
}
};
par[0][root] = root;
dfs(root, root);
fr(i, par.size() - 1) {
fr(j, par[0].size()) { par[i + 1][j] = par[i][par[i][j]]; }
}
}
int operator()(int a, int b) {
if (dep[a] > dep[b])
swap(a, b);
for (int t = dep[b] - dep[a], i = 0; t; t >>= 1, ++i) {
if (t & 1) {
b = par[i][b];
}
}
if (a == b)
return a;
rf(i, par.size()) {
if (par[i][a] != par[i][b]) {
a = par[i][a];
b = par[i][b];
}
}
return par[0][a];
}
};
vpii factor(int N) {
vpii r;
for (int i = 2; i * i <= N; ++i) {
if (N % i == 0) {
r << pii{i, 0};
while (N % i == 0) {
N /= i;
++r.back().second;
}
}
}
if (N > 1) {
r << pii{N, 1};
}
return r;
}
vl divisors(ll n) {
vl r;
ll m = sqrt(n);
foor(i, 1, m) if (n % i == 0) r << ll(i);
rf(i, r.size() - (m * m == n)) r << n / r[i];
return r;
}
vi SuffixArray(str S) {
int N = S.size();
vi rank(N + 1), tmp(N + 1), sa(N + 1);
fr(i, N) {
sa[i] = i;
rank[i] = S[i];
}
sa[N] = N;
rank[N] = -1;
int k;
auto cmp = [&](int &a, int &b) -> bool {
if (rank[a] != rank[b])
return rank[a] < rank[b];
return (a + k <= N ? rank[a + k] : -1) < (b + k <= N ? rank[b + k] : -1);
};
for (k = 1; k <= N; k *= 2) {
sort(all(sa), cmp);
tmp[sa[0]] = 0;
foor(i, 1, N) { tmp[sa[i]] = tmp[sa[i - 1]] + cmp(sa[i - 1], sa[i]); }
rank = tmp;
}
return sa;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
str S, T;
cin >> S >> T;
vb us(256), ut(256);
vvi I(256);
fr(i, S.size()) {
us[S[i]] = true;
I[S[i]] << i;
}
for (auto c : T) {
ut[c] = true;
}
fr(i, 256) {
if (ut[i] && !us[i]) {
print(-1);
return 0;
}
}
int k = 0;
ll z = 0;
for (auto c : T) {
auto it = upper_bound(all(I[c]), k);
if (it == I[c].end()) {
k = I[c][0];
z += S.size();
} else {
k = *it;
}
}
print(z + k + 1);
return 0;
}
|
#include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reverse(x) reverse(all(x))
#define PQ priority_queue
#define NP(x) next_permutation(all(x))
#define M_PI 3.14159265358979323846
#define popcount __builtin_popcount
using namespace std;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef unsigned long long ull;
typedef vector<ull> vu;
typedef vector<vu> vvu;
typedef double dbl;
typedef vector<dbl> vd;
typedef vector<vd> vvd;
typedef string str;
typedef vector<str> vs;
typedef vector<vs> vvs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef map<int, int> mii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef map<ll, ll> mll;
typedef pair<dbl, dbl> pdd;
typedef vector<pdd> vpdd;
typedef map<dbl, dbl> mdd;
typedef pair<str, str> pss;
typedef vector<pss> vpss;
typedef map<str, str> mss;
typedef pair<int, ll> pil;
typedef vector<pil> vpil;
typedef map<int, ll> mil;
typedef pair<ll, int> pli;
typedef vector<pli> vpli;
typedef map<ll, int> mli;
typedef pair<dbl, int> pdi;
typedef vector<pdi> vpdi;
typedef map<dbl, int> mdi;
template <typename T> vector<T> &operator<<(vector<T> &v, const T t) {
v.push_back(t);
return v;
}
template <typename T> multiset<T> &operator<<(multiset<T> &m, const T t) {
m.insert(t);
return m;
}
template <typename T> set<T> &operator<<(set<T> &s, const T t) {
s.insert(t);
return s;
}
template <typename T> stack<T> &operator<<(stack<T> &s, const T t) {
s.push(t);
return s;
}
template <typename T> stack<T> &operator>>(stack<T> &s, T &t) {
t = s.top();
s.pop();
return s;
}
template <typename T> queue<T> &operator<<(queue<T> &q, const T t) {
q.push(t);
return q;
}
template <typename T> queue<T> &operator>>(queue<T> &q, T &t) {
t = q.front();
q.pop();
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator<<(PQ<T, vector<T>, U> &q, const T t) {
q.push(t);
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator>>(PQ<T, vector<T>, U> &q, T &t) {
t = q.top();
q.pop();
return q;
}
template <typename T, typename U>
istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
istream &operator>>(istream &s, _Bit_reference b) {
int a;
s >> a;
assert(a == 0 || a == 1);
b = a;
return s;
}
template <typename T> istream &operator>>(istream &s, vector<T> &v) {
fr(i, v.size()) { s >> v[i]; }
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
// template<typename T>ostream&operator<<(ostream&s,const vector<T>v){for(auto
// a:v){s<<a<<"\n";}return s;}
template <typename T> ostream &operator<<(ostream &s, const vector<T> v) {
fr(i, v.size()) { i ? s << " " << v[i] : s << v[i]; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const deque<T> d) {
fr(i, d.size()) { i ? s << " " << d[i] : s << d[i]; }
return s;
}
template <typename T> _Bit_reference operator&=(_Bit_reference b, T t) {
return b = b & t;
}
template <typename T> _Bit_reference operator^=(_Bit_reference b, T t) {
return b = b ^ t;
}
template <typename T> _Bit_reference operator|=(_Bit_reference b, T t) {
return b = b | t;
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <typename T, typename U>
pair<T, U> &operator+=(pair<T, U> &a, pair<T, U> b) {
return a = a + b;
}
template <typename T, typename U>
pair<T, U> &operator-=(pair<T, U> &a, pair<T, U> b) {
return a = a - b;
}
void print(void) { cout << "\n"; }
void Print(void) { cout << endl; }
template <typename T> void print(T t) { cout << t << "\n"; }
template <typename T> void Print(T t) { cout << t << endl; }
template <typename T, typename... U> void print(T &&t, U &&...u) {
cout << t << " ";
print(forward<U>(u)...);
}
template <typename T, typename... U> void Print(T &&t, U &&...u) {
cout << t << " ";
Print(forward<U>(u)...);
}
bool YN(bool b) {
print(b ? "YES" : "NO");
return b;
}
bool PI(bool b) {
print(b ? "POSSIBLE" : "IMPOSSIBLE");
return b;
}
bool Yn(bool b) {
print(b ? "Yes" : "No");
return b;
}
bool Pi(bool b) {
print(b ? "Possible" : "Impossible");
return b;
}
bool yn(bool b) {
print(b ? "yes" : "no");
return b;
}
bool pi(bool b) {
print(b ? "possible" : "impossible");
return b;
}
const int e5 = 1e5;
const int e9 = 1e9;
const int MD = 1e9 + 7;
const ll e18 = 1e18;
template <typename T> str to_string(const T &n) {
ostringstream s;
s << n;
return s.str();
}
template <typename T> T &chmax(T &a, T b) { return a = max(a, b); }
template <typename T> T &chmin(T &a, T b) { return a = min(a, b); }
template <typename T, typename U>
vector<pair<T, U>> dijkstra(const vector<vector<pair<T, U>>> &E, const U s,
const T inf) {
using P = pair<T, U>;
vector<P> d;
fr(i, E.size()) { d << P{inf, i}; }
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
template <typename T, typename U>
map<U, pair<T, U>> dijkstra(map<U, vector<pair<T, U>>> E, const U s,
const T inf) {
using P = pair<T, U>;
map<U, P> d;
for (pair<U, vector<P>> e : E) {
d[e.first] = P{inf, e.first};
}
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
ll maxflow(vector<mil> &E, int s, int t) {
ll z = 0;
vi b(E.size(), -1);
for (int i = 0;; ++i) {
static auto dfs = [&](int v, ll f, auto &dfs) -> ll {
if (v == t)
return f;
b[v] = i;
for (auto &p : E[v]) {
if (b[p.first] < i && p.second) {
if (ll r = dfs(p.first, min(f, p.second), dfs)) {
p.second -= r;
E[p.first][v] += r;
return r;
}
}
}
return 0;
};
ll x = dfs(s, ll(1e18), dfs);
z += x;
if (x == 0)
return z;
}
}
template <typename T> T distsq(pair<T, T> a, pair<T, T> b) {
return (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
}
template <typename T> T max(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = max(m, e);
}
return m;
}
template <typename T> T min(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = min(m, e);
}
return m;
}
template <typename T> T gcd(const T a, const T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T> T gcd(const vector<T> a) {
T g = a[0];
for (T e : a) {
g = gcd(g, e);
}
return g;
}
template <typename T> vector<T> LIS(const vector<T> A) {
vector<T> B;
for (T a : A) {
auto it = lower_bound(all(B), a);
if (it == B.end()) {
B << a;
} else {
*it = a;
}
}
return B;
}
template <typename T> vector<T> LCS(vector<T> A, vector<T> B) {
int N = A.size(), M = B.size();
vector<vector<pair<int, pii>>> d(N + 1, vector<pair<int, pii>>(M + 1));
fr(i, N) {
fr(j, M) {
if (A[i] == B[j]) {
d[i + 1][j + 1] = {d[i][j].first + 1, {i, j}};
} else {
d[i + 1][j + 1] = max(d[i][j + 1], d[i + 1][j]);
}
}
}
vector<T> r;
for (pii p = {N, M}; d[p.first][p.second].first;
p = d[p.first][p.second].second) {
r << A[d[p.first][p.second].second.first];
}
Reverse(r);
return r;
}
str LCS(str S, str T) {
vector<char> s =
LCS(vector<char>(S.begin(), S.end()), vector<char>(T.begin(), T.end()));
return str(s.begin(), s.end());
}
template <typename T> vector<pair<T, T>> ConvexHull(vector<pair<T, T>> V) {
if (V.size() <= 3) {
return V;
}
Sort(V);
rf(i, V.size() - 1) V << V[i];
vector<pair<T, T>> r;
for (pair<T, T> p : V) {
int s = r.size();
while (s >= 2 &&
(p.second - r[s - 1].second) * (p.first - r[s - 2].first) <
(p.second - r[s - 2].second) * (p.first - r[s - 1].first)) {
r.pop_back();
--s;
}
r << p;
}
r.pop_back();
return r;
}
class UnionFind {
vi p, s;
void extend(int N) {
foor(i, p.size(), N) {
p << i;
s << 1;
}
}
public:
UnionFind(void) {}
UnionFind(int N) { extend(N - 1); }
int find(int i) {
extend(i);
return p[i] = p[i] == i ? i : find(p[i]);
}
void unite(int a, int b) {
extend(a);
extend(b);
if ((a = find(a)) != (b = find(b))) {
if (s[a] > s[b]) {
swap(a, b);
}
s[b] += s[a];
p[a] = b;
}
}
void unite(pii p) { return unite(p.first, p.second); }
bool same(int a, int b) {
extend(a);
extend(b);
return find(a) == find(b);
}
bool same(pii p) { return same(p.first, p.second); }
int size(int x) {
extend(x);
return s[find(x)];
}
};
ll MST(vector<pair<ll, pii>> &E) {
Sort(E);
UnionFind uf;
ll z = 0;
for (auto &e : E) {
if (!uf.same(e.second)) {
z += e.first;
uf.unite(e.second);
}
}
return z;
}
ll strmod(const str &s, const int m) {
ll x = 0;
fr(i, s.size()) { x = (x * 10 + s[i] - 48) % m; }
return x;
}
vvl mul(const vvl &A, const vvl &B, const int m) {
vvl C;
fr(y, A.size()) { C << vl(B[y].size()); }
fr(y, C.size()) {
fr(x, C[y].size()) {
fr(i, A[0].size()) { (C[y][x] += A[y][i] * B[i][x]) %= m; }
}
}
return C;
}
vvl pow(const vvl &A, const ll n, const int m) {
vvl B;
fr(y, A.size()) { B << vl(A.size()); }
if (n == 0) {
fr(i, B.size()) { B[i][i] = 1; }
}
elsif(n % 2) { B = mul(A, pow(A, n - 1, m), m); }
else {
vvl C = pow(A, n / 2, m);
B = mul(C, C, m);
}
return B;
}
ll pow(const ll a, const ll n, const int m) {
ll t;
return n ? (n & 1 ? a >= 0 ? a % m : (m - (-a % m)) % m : 1) *
(t = pow(a, n >> 1, m), t * t % m) % m
: !!a;
}
ll inv(const ll x, const int p) {
assert(x != 0);
return pow(x, p - 2, p);
}
ll inv(const ll x) { return inv(x, MD); }
vpll fact(const int n, const int p) {
assert(n < p);
vpll v(n + 1);
v[0].first = 1;
foor(i, 1, n) { v[i].first = v[i - 1].first * i % p; }
v[n].second = inv(v[n].first, p);
roof(i, n, 1) { v[i - 1].second = v[i].second * i % p; }
return v;
}
class Combination {
const vpll f;
const int M;
public:
Combination(int n, int m) : f(fact(n, m)), M(m) {}
Combination(int n) : Combination(n, MD) {}
ll P(int n, int k) {
return n < 0 || k < 0 || n < k ? 0ll : f[n].first * f[n - k].second % M;
}
ll C(int n, int k) { return k < 0 ? 0 : P(n, k) * f[k].second % M; }
ll H(int n, int k) { return n == 0 && k == 0 ? 1ll : C(n + k - 1, k); }
ll F(int n) { return n < 0 ? 0 : f[n].first; }
};
ll C2(const int n) { return (ll)n * ~-n / 2; }
ll sum(const vi a) {
ll s = 0;
for (int e : a) {
s += e;
}
return s;
}
ll sum(const vl a) {
ll s = 0;
for (ll e : a) {
s += e;
}
return s;
}
template <typename T> int MSB(T N) {
int r = -1;
for (; N > 0; N /= 2) {
++r;
}
return r;
}
template <typename T> class SegmentTree {
vector<T> S;
T (*const op)(T a, T b);
const T zero;
const int B;
public:
SegmentTree(int N, T (*f)(T a, T b), const T zero)
: S(1 << MSB(N - 1) + 2, zero), op(f), zero(zero),
B(1 << MSB(N - 1) + 1) {}
SegmentTree(vector<T> v, T (*f)(T a, T b), const T zero)
: SegmentTree(v.size(), f, zero) {
fr(i, v.size()) { S[S.size() / 2 + i] = v[i]; }
roof(i, S.size() / 2 - 1, 1) { S[i] = op(S[i * 2], S[i * 2 + 1]); }
}
T calc(int l, int r) {
l += B;
r += B;
if (l > r) {
return zero;
}
if (l == r) {
return S[l];
}
T L = S[l], R = S[r];
for (; l / 2 < r / 2; l /= 2, r /= 2) {
if (l % 2 == 0) {
L = op(L, S[l + 1]);
}
if (r % 2 == 1) {
R = op(S[r - 1], R);
}
}
return op(L, R);
}
void replace(int i, T x) {
for (S[i += B] = x; i != 1; i /= 2) {
if (i % 2) {
S[i / 2] = op(S[i - 1], S[i]);
} else {
S[i / 2] = op(S[i], S[i + 1]);
}
}
}
void add(int i, T x) { replace(i, op(S[B + i], x)); }
T top() { return S[1]; }
};
ll BITsum(vl &B, int i) {
ll z = 0;
while (i > 0) {
z += B[i];
i -= i & -i;
}
return z;
}
void BITadd(vl &B, int i, ll x) {
while (i < B.size()) {
B[i] += x;
i += i & -i;
}
}
ll fib(const ll n, const int m) {
ll a, b, c, d, A, B, C, D;
a = 1;
b = 0;
c = 0;
d = 1;
rf(i, 63) {
A = a * a + b * c;
B = a * b + b * d;
C = c * a + d * c;
D = c * b + d * d;
if (n >> i & 1) {
a = A;
b = B;
c = C;
d = D;
A = a + b;
B = a;
C = c + d;
D = c;
}
a = A % m;
b = B % m;
c = C % m;
d = D % m;
}
return b;
}
vi primes(int n) {
vb b(n + 1);
vi p;
foor(i, 2, n) {
if (!b[i]) {
p << i;
for (int j = 2 * i; j <= n; j += i) {
b[j] = true;
}
}
}
return p;
}
vb isprime(const int n) {
vb v(n + 1, true);
v[0] = v[1] = false;
foor(i, 2, n) {
if (v[i]) {
for (int j = 2 * i; j <= n; j += i) {
v[j] = false;
}
}
}
return v;
}
class LCA {
vvi par;
vi dep;
public:
LCA(vvi &E, int root) : par(MSB(E.size()) + 1, vi(E.size())), dep(E.size()) {
function<void(int, int)> dfs = [&](int i, int p) {
for (int j : E[i])
if (j != p) {
par[0][j] = i;
dep[j] = dep[i] + 1;
dfs(j, i);
}
};
par[0][root] = root;
dfs(root, root);
fr(i, par.size() - 1) {
fr(j, par[0].size()) { par[i + 1][j] = par[i][par[i][j]]; }
}
}
int operator()(int a, int b) {
if (dep[a] > dep[b])
swap(a, b);
for (int t = dep[b] - dep[a], i = 0; t; t >>= 1, ++i) {
if (t & 1) {
b = par[i][b];
}
}
if (a == b)
return a;
rf(i, par.size()) {
if (par[i][a] != par[i][b]) {
a = par[i][a];
b = par[i][b];
}
}
return par[0][a];
}
};
vpii factor(int N) {
vpii r;
for (int i = 2; i * i <= N; ++i) {
if (N % i == 0) {
r << pii{i, 0};
while (N % i == 0) {
N /= i;
++r.back().second;
}
}
}
if (N > 1) {
r << pii{N, 1};
}
return r;
}
vl divisors(ll n) {
vl r;
ll m = sqrt(n);
foor(i, 1, m) if (n % i == 0) r << ll(i);
rf(i, r.size() - (m * m == n)) r << n / r[i];
return r;
}
vi SuffixArray(str S) {
int N = S.size();
vi rank(N + 1), tmp(N + 1), sa(N + 1);
fr(i, N) {
sa[i] = i;
rank[i] = S[i];
}
sa[N] = N;
rank[N] = -1;
int k;
auto cmp = [&](int &a, int &b) -> bool {
if (rank[a] != rank[b])
return rank[a] < rank[b];
return (a + k <= N ? rank[a + k] : -1) < (b + k <= N ? rank[b + k] : -1);
};
for (k = 1; k <= N; k *= 2) {
sort(all(sa), cmp);
tmp[sa[0]] = 0;
foor(i, 1, N) { tmp[sa[i]] = tmp[sa[i - 1]] + cmp(sa[i - 1], sa[i]); }
rank = tmp;
}
return sa;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
str S, T;
cin >> S >> T;
vb us(256), ut(256);
vvi I(256);
fr(i, S.size()) {
us[S[i]] = true;
I[S[i]] << i;
}
for (auto c : T) {
ut[c] = true;
}
fr(i, 256) {
if (ut[i] && !us[i]) {
print(-1);
return 0;
}
}
int k = -1;
ll z = 0;
for (auto c : T) {
auto it = upper_bound(all(I[c]), k);
if (it == I[c].end()) {
k = I[c][0];
z += S.size();
} else {
k = *it;
}
}
print(z + k + 1);
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,101
| 741,102
|
u283869437
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define repm(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define sperase(v, n) (v).erase(remove(all(v), n), (v).end())
#define vdelete(v) (v).erase(unique(all(v)), (v).end())
#define pb(n) push_back(n)
#define mp make_pair
#define MOD 1000000007
#define INF LONG_LONG_MAX
int ans, now = 0;
string s, t;
vector<int> v[30];
map<char, bool> m;
signed main() {
cin >> s >> t;
rep(i, s.size()) m[s[i]] = true;
rep(i, t.size()) if (!m[t[i]]) {
cout << -1 << endl;
return 0;
}
rep(i, s.size()) v[s[i] - 'a'].pb(i + 1);
rep(i, 30) v[i].pb(INF);
rep(i, t.size()) {
auto itr = lower_bound(all(v[t[i] - 'a']), now);
if (*itr == INF) {
ans += s.size();
now = v[t[i] - 'a'][0];
} else {
now = *itr;
}
if (now == s.size())
now = 0, ans += s.size();
}
ans += now;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define repm(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define sperase(v, n) (v).erase(remove(all(v), n), (v).end())
#define vdelete(v) (v).erase(unique(all(v)), (v).end())
#define pb(n) push_back(n)
#define mp make_pair
#define MOD 1000000007
#define INF LONG_LONG_MAX
int ans, now = 0;
string s, t;
vector<int> v[30];
map<char, bool> m;
signed main() {
cin >> s >> t;
rep(i, s.size()) m[s[i]] = true;
rep(i, t.size()) if (!m[t[i]]) {
cout << -1 << endl;
return 0;
}
rep(i, s.size()) v[s[i] - 'a'].pb(i + 1);
rep(i, 30) v[i].pb(INF);
rep(i, t.size()) {
auto itr = upper_bound(all(v[t[i] - 'a']), now);
if (*itr == INF) {
ans += s.size();
now = v[t[i] - 'a'][0];
} else {
now = *itr;
}
if (now == s.size())
now = 0, ans += s.size();
}
ans += now;
cout << ans << endl;
}
|
[
"identifier.change",
"call.function.change"
] | 741,109
| 741,110
|
u721367699
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define repi(i, a, b) for (int i = (a); i > (b); i--)
#define db(x) (cerr << #x << ": " << (x) << '\n')
#define sync ios_base::sync_with_stdio(false), cin.tie(NULL)
#define tests(t) \
int t; \
cin >> t; \
while (t--)
#define iceil(n, x) (((n) + (x)-1) / (x))
#define ll long long
#define gcd __gcd
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define sz size()
#define all(v) (v).begin(), (v).end()
#define uni(v) \
sort(all(v)); \
(v).erase(unique(all(v)), (v).end())
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define fi first
#define se second
#define pqueue priority_queue
#define bitcount(x) __builtin_popcount(x)
#define cps CLOCKS_PER_SEC
#define PI acos(-1.0)
#define EPS 1e-9
#define mod 1000000007
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.fi << ", " << p.se << ')';
}
template <typename T> void printv(const T &v) {
for (auto i : v)
cerr << i << ' ';
cerr << '\n';
}
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using maxpq = priority_queue<T>;
// All indexing is 0-based
using namespace __gnu_pbds;
template <class key, class cmp = std::less<key>>
using ordered_set =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// methods: find_by_order(k); & order_of_key(k);
// To make it an ordered_multiset, use pairs of (value, time_of_insertion)
// to distinguish values which are similar
template <class key, class value, class cmp = std::less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// Returns no. of values x for which ceil(n / x) == y (y must be > 1).
inline ll CC(ll n, ll y) { return iceil(n, y - 1) - iceil(n, y); }
// Returns no. of values x for which floor(n / x) == y
inline ll FF(ll n, ll y) { return n / y - n / (y + 1); }
// a and b are assumed to be taken modulo p
inline int add(int a, int b, int p = mod) {
int c = a + b;
if (c >= p)
c -= p;
return c;
}
inline int sub(int a, int b, int p = mod) {
int c = a - b;
if (c < 0)
c += p;
return c;
}
inline int mul(int a, int b, int p = mod) { return (a * 1ll * b) % p; }
#define N 200005
#define int ll
// #define trace(...) 42
vi adj[N];
int freq[N];
main() {
#ifdef CP
freopen("/home/tarun/Desktop/input.txt", "r", stdin);
// freopen("/home/tarun/Desktop/output.txt", "w", stdout);
#endif
sync;
clock_t clk = clock();
cerr << "I will return...\n";
string s, t;
cin >> s >> t;
int n, m;
n = s.sz, m = t.sz;
rep(i, 0, n) {
adj[s[i]].pb(i);
freq[s[i]]++;
}
rep(i, 'a', 'z' + 1) {
if (adj[i].sz) {
adj[i].pb(adj[i][0] + n);
}
}
bool ok = 1;
for (char c : t) {
ok &= !!freq[c];
}
if (!ok) {
cout << -1;
return 0;
}
int x = 0;
for (char c : t) {
int j = *upper_bound(all(adj[c]), x % n);
x = (x / n) * n + j;
}
cout << x + 1 << '\n';
cerr << "...don't you ever hang your head.\n";
cerr << "Time (in ms): " << (double)(clock() - clk) * 1000.0 / cps << '\n';
}
// Compile using:
// g++ -o filename.exe --std=c++11 filename.cpp
// Use -D CP for defining a macro CP in the local environment
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define repi(i, a, b) for (int i = (a); i > (b); i--)
#define db(x) (cerr << #x << ": " << (x) << '\n')
#define sync ios_base::sync_with_stdio(false), cin.tie(NULL)
#define tests(t) \
int t; \
cin >> t; \
while (t--)
#define iceil(n, x) (((n) + (x)-1) / (x))
#define ll long long
#define gcd __gcd
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define sz size()
#define all(v) (v).begin(), (v).end()
#define uni(v) \
sort(all(v)); \
(v).erase(unique(all(v)), (v).end())
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define fi first
#define se second
#define pqueue priority_queue
#define bitcount(x) __builtin_popcount(x)
#define cps CLOCKS_PER_SEC
#define PI acos(-1.0)
#define EPS 1e-9
#define mod 1000000007
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.fi << ", " << p.se << ')';
}
template <typename T> void printv(const T &v) {
for (auto i : v)
cerr << i << ' ';
cerr << '\n';
}
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using maxpq = priority_queue<T>;
// All indexing is 0-based
using namespace __gnu_pbds;
template <class key, class cmp = std::less<key>>
using ordered_set =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// methods: find_by_order(k); & order_of_key(k);
// To make it an ordered_multiset, use pairs of (value, time_of_insertion)
// to distinguish values which are similar
template <class key, class value, class cmp = std::less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// Returns no. of values x for which ceil(n / x) == y (y must be > 1).
inline ll CC(ll n, ll y) { return iceil(n, y - 1) - iceil(n, y); }
// Returns no. of values x for which floor(n / x) == y
inline ll FF(ll n, ll y) { return n / y - n / (y + 1); }
// a and b are assumed to be taken modulo p
inline int add(int a, int b, int p = mod) {
int c = a + b;
if (c >= p)
c -= p;
return c;
}
inline int sub(int a, int b, int p = mod) {
int c = a - b;
if (c < 0)
c += p;
return c;
}
inline int mul(int a, int b, int p = mod) { return (a * 1ll * b) % p; }
#define N 200005
#define int ll
// #define trace(...) 42
vi adj[N];
int freq[N];
main() {
#ifdef CP
freopen("/home/tarun/Desktop/input.txt", "r", stdin);
// freopen("/home/tarun/Desktop/output.txt", "w", stdout);
#endif
sync;
clock_t clk = clock();
cerr << "I will return...\n";
string s, t;
cin >> s >> t;
int n, m;
n = s.sz, m = t.sz;
rep(i, 0, n) {
adj[s[i]].pb(i);
freq[s[i]]++;
}
rep(i, 'a', 'z' + 1) {
if (adj[i].sz) {
adj[i].pb(adj[i][0] + n);
}
}
bool ok = 1;
for (char c : t) {
ok &= !!freq[c];
}
if (!ok) {
cout << -1;
return 0;
}
int x = -1;
for (char c : t) {
int j = *upper_bound(all(adj[c]), x % n);
x = (x / n) * n + j;
}
cout << x + 1 << '\n';
cerr << "...don't you ever hang your head.\n";
cerr << "Time (in ms): " << (double)(clock() - clk) * 1000.0 / cps << '\n';
}
// Compile using:
// g++ -o filename.exe --std=c++11 filename.cpp
// Use -D CP for defining a macro CP in the local environment
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,111
| 741,112
|
u567489994
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define repi(i, a, b) for (int i = (a); i > (b); i--)
#define db(x) (cerr << #x << ": " << (x) << '\n')
#define sync ios_base::sync_with_stdio(false), cin.tie(NULL)
#define tests(t) \
int t; \
cin >> t; \
while (t--)
#define iceil(n, x) (((n) + (x)-1) / (x))
#define ll long long
#define gcd __gcd
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define sz size()
#define all(v) (v).begin(), (v).end()
#define uni(v) \
sort(all(v)); \
(v).erase(unique(all(v)), (v).end())
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define fi first
#define se second
#define pqueue priority_queue
#define bitcount(x) __builtin_popcount(x)
#define cps CLOCKS_PER_SEC
#define PI acos(-1.0)
#define EPS 1e-9
#define mod 1000000007
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.fi << ", " << p.se << ')';
}
template <typename T> void printv(const T &v) {
for (auto i : v)
cerr << i << ' ';
cerr << '\n';
}
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using maxpq = priority_queue<T>;
// All indexing is 0-based
using namespace __gnu_pbds;
template <class key, class cmp = std::less<key>>
using ordered_set =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// methods: find_by_order(k); & order_of_key(k);
// To make it an ordered_multiset, use pairs of (value, time_of_insertion)
// to distinguish values which are similar
template <class key, class value, class cmp = std::less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// Returns no. of values x for which ceil(n / x) == y (y must be > 1).
inline ll CC(ll n, ll y) { return iceil(n, y - 1) - iceil(n, y); }
// Returns no. of values x for which floor(n / x) == y
inline ll FF(ll n, ll y) { return n / y - n / (y + 1); }
// a and b are assumed to be taken modulo p
inline int add(int a, int b, int p = mod) {
int c = a + b;
if (c >= p)
c -= p;
return c;
}
inline int sub(int a, int b, int p = mod) {
int c = a - b;
if (c < 0)
c += p;
return c;
}
inline int mul(int a, int b, int p = mod) { return (a * 1ll * b) % p; }
#define N 200005
#define int ll
// #define trace(...) 42
vi adj[N];
int freq[N];
main() {
#ifdef CP
freopen("/home/tarun/Desktop/input.txt", "r", stdin);
// freopen("/home/tarun/Desktop/output.txt", "w", stdout);
#endif
sync;
clock_t clk = clock();
cerr << "I will return...\n";
string s, t;
cin >> s >> t;
int n, m;
n = s.sz, m = t.sz;
rep(i, 0, n) {
adj[s[i]].pb(i);
freq[s[i]]++;
}
rep(i, 'a', 'z' + 1) {
if (adj[i].sz) {
adj[i].pb(adj[i][0] + n);
}
}
bool ok = 1;
for (char c : t) {
ok &= !!freq[c];
}
if (!ok) {
cout << -1;
return 0;
}
int x = 0;
for (char c : t) {
int j = *lower_bound(all(adj[c]), x % n);
x = (x / n) * n + j;
}
cout << x + 1 << '\n';
cerr << "...don't you ever hang your head.\n";
cerr << "Time (in ms): " << (double)(clock() - clk) * 1000.0 / cps << '\n';
}
// Compile using:
// g++ -o filename.exe --std=c++11 filename.cpp
// Use -D CP for defining a macro CP in the local environment
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define repi(i, a, b) for (int i = (a); i > (b); i--)
#define db(x) (cerr << #x << ": " << (x) << '\n')
#define sync ios_base::sync_with_stdio(false), cin.tie(NULL)
#define tests(t) \
int t; \
cin >> t; \
while (t--)
#define iceil(n, x) (((n) + (x)-1) / (x))
#define ll long long
#define gcd __gcd
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define sz size()
#define all(v) (v).begin(), (v).end()
#define uni(v) \
sort(all(v)); \
(v).erase(unique(all(v)), (v).end())
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define fi first
#define se second
#define pqueue priority_queue
#define bitcount(x) __builtin_popcount(x)
#define cps CLOCKS_PER_SEC
#define PI acos(-1.0)
#define EPS 1e-9
#define mod 1000000007
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.fi << ", " << p.se << ')';
}
template <typename T> void printv(const T &v) {
for (auto i : v)
cerr << i << ' ';
cerr << '\n';
}
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using maxpq = priority_queue<T>;
// All indexing is 0-based
using namespace __gnu_pbds;
template <class key, class cmp = std::less<key>>
using ordered_set =
tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// methods: find_by_order(k); & order_of_key(k);
// To make it an ordered_multiset, use pairs of (value, time_of_insertion)
// to distinguish values which are similar
template <class key, class value, class cmp = std::less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// Returns no. of values x for which ceil(n / x) == y (y must be > 1).
inline ll CC(ll n, ll y) { return iceil(n, y - 1) - iceil(n, y); }
// Returns no. of values x for which floor(n / x) == y
inline ll FF(ll n, ll y) { return n / y - n / (y + 1); }
// a and b are assumed to be taken modulo p
inline int add(int a, int b, int p = mod) {
int c = a + b;
if (c >= p)
c -= p;
return c;
}
inline int sub(int a, int b, int p = mod) {
int c = a - b;
if (c < 0)
c += p;
return c;
}
inline int mul(int a, int b, int p = mod) { return (a * 1ll * b) % p; }
#define N 200005
#define int ll
// #define trace(...) 42
vi adj[N];
int freq[N];
main() {
#ifdef CP
freopen("/home/tarun/Desktop/input.txt", "r", stdin);
// freopen("/home/tarun/Desktop/output.txt", "w", stdout);
#endif
sync;
clock_t clk = clock();
cerr << "I will return...\n";
string s, t;
cin >> s >> t;
int n, m;
n = s.sz, m = t.sz;
rep(i, 0, n) {
adj[s[i]].pb(i);
freq[s[i]]++;
}
rep(i, 'a', 'z' + 1) {
if (adj[i].sz) {
adj[i].pb(adj[i][0] + n);
}
}
bool ok = 1;
for (char c : t) {
ok &= !!freq[c];
}
if (!ok) {
cout << -1;
return 0;
}
int x = -1;
for (char c : t) {
int j = *upper_bound(all(adj[c]), x % n);
x = (x / n) * n + j;
}
cout << x + 1 << '\n';
cerr << "...don't you ever hang your head.\n";
cerr << "Time (in ms): " << (double)(clock() - clk) * 1000.0 / cps << '\n';
}
// Compile using:
// g++ -o filename.exe --std=c++11 filename.cpp
// Use -D CP for defining a macro CP in the local environment
|
[
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"call.function.change"
] | 741,113
| 741,112
|
u567489994
|
cpp
|
p02937
|
#include <bits/stdtr1c++.h>
using namespace std;
#define INP "solve"
#define OUT "solve"
const int QQ = 3e5 + 10;
const int maxN = 3e5 + 10;
const int maxM = 3e5 + 10;
const int oo = 1e9;
const int module = 1e9 + 7;
const long double du = 1e-9;
void doc() {
freopen(INP ".inp", "r", stdin);
freopen(OUT ".out", "w", stdout);
}
vector<int> a[26];
int Next(int c, int pos) {
if ((int)a[c].size() == 0)
return -1;
auto VT = lower_bound(a[c].begin(), a[c].end(), pos + 1);
if (VT == a[c].end())
return *a[c].begin();
return *VT;
}
long long Check(string S, string T) {
int L = -1;
int n = (int)S.size();
long long Res = 0;
for (int i = 0; i < n; i++)
a[S[i] - 'a'].push_back(i);
for (char c : T) {
int newL = Next(c - 'a', L);
if (newL == -1)
return -1;
if (newL < L)
Res += n;
L = newL;
}
Res += L + 1;
return Res;
}
void solve() {
string s, t;
cin >> s >> t;
cout << Check(s, t);
}
int main(int argc, char *argv[]) {
// srand(time(nullptr));
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
// doc();
solve();
}
|
#include <bits/stdtr1c++.h>
using namespace std;
#define INP "solve"
#define OUT "solve"
const int QQ = 3e5 + 10;
const int maxN = 3e5 + 10;
const int maxM = 3e5 + 10;
const int oo = 1e9;
const int module = 1e9 + 7;
const long double du = 1e-9;
void doc() {
freopen(INP ".inp", "r", stdin);
freopen(OUT ".out", "w", stdout);
}
vector<int> a[26];
int Next(int c, int pos) {
if ((int)a[c].size() == 0)
return -1;
auto VT = lower_bound(a[c].begin(), a[c].end(), pos + 1);
if (VT == a[c].end())
return *a[c].begin();
return *VT;
}
long long Check(string S, string T) {
int L = -1;
int n = (int)S.size();
long long Res = 0;
for (int i = 0; i < n; i++)
a[S[i] - 'a'].push_back(i);
for (char c : T) {
int newL = Next(c - 'a', L);
if (newL == -1)
return -1;
if (newL <= L)
Res += n;
L = newL;
}
Res += L + 1;
return Res;
}
void solve() {
string s, t;
cin >> s >> t;
cout << Check(s, t);
}
int main(int argc, char *argv[]) {
// srand(time(nullptr));
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
// doc();
solve();
}
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,119
| 741,120
|
u521455622
|
cpp
|
p02937
|
#include <bits/stdtr1c++.h>
using namespace std;
#define INP "solve"
#define OUT "solve"
const int QQ = 3e5 + 10;
const int maxN = 3e5 + 10;
const int maxM = 3e5 + 10;
const int oo = 1e9;
const int module = 1e9 + 7;
const long double du = 1e-9;
void doc() {
freopen(INP ".inp", "r", stdin);
freopen(OUT ".out", "w", stdout);
}
vector<int> a[26];
int Next(int c, int pos) {
if ((int)a[c].size() == 0)
return -1;
auto VT = lower_bound(a[c].begin(), a[c].end(), pos);
if (VT == a[c].end())
return *a[c].begin();
return *VT;
}
long long Check(string S, string T) {
int L = 0;
int n = (int)S.size();
long long Res = 0;
for (int i = 0; i < n; i++)
a[S[i] - 'a'].push_back(i);
for (char c : T) {
int newL = Next(c - 'a', L);
if (newL == -1)
return -1;
if (newL < L)
Res += n;
L = newL;
}
Res += L + 1;
return Res;
}
void solve() {
string s, t;
cin >> s >> t;
cout << Check(s, t);
}
int main(int argc, char *argv[]) {
// srand(time(nullptr));
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
// doc();
solve();
}
|
#include <bits/stdtr1c++.h>
using namespace std;
#define INP "solve"
#define OUT "solve"
const int QQ = 3e5 + 10;
const int maxN = 3e5 + 10;
const int maxM = 3e5 + 10;
const int oo = 1e9;
const int module = 1e9 + 7;
const long double du = 1e-9;
void doc() {
freopen(INP ".inp", "r", stdin);
freopen(OUT ".out", "w", stdout);
}
vector<int> a[26];
int Next(int c, int pos) {
if ((int)a[c].size() == 0)
return -1;
auto VT = lower_bound(a[c].begin(), a[c].end(), pos + 1);
if (VT == a[c].end())
return *a[c].begin();
return *VT;
}
long long Check(string S, string T) {
int L = -1;
int n = (int)S.size();
long long Res = 0;
for (int i = 0; i < n; i++)
a[S[i] - 'a'].push_back(i);
for (char c : T) {
int newL = Next(c - 'a', L);
if (newL == -1)
return -1;
if (newL <= L)
Res += n;
L = newL;
}
Res += L + 1;
return Res;
}
void solve() {
string s, t;
cin >> s >> t;
cout << Check(s, t);
}
int main(int argc, char *argv[]) {
// srand(time(nullptr));
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
// doc();
solve();
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,121
| 741,120
|
u521455622
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#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;
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 long double ld;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
vector<ll> alp(26, 0);
vector<vector<ll>> alpha(26);
for (int z = 0; z < s.size(); z++) {
alp[s[z] - 'a']++;
alpha[s[z] - 'a'].push_back(z);
}
for (int z = 0; z < t.size(); z++) {
if (alp[t[z] - 'a'] == 0) {
cout << -1 << endl;
return 0;
}
}
ll c = 0;
ll ans = 0;
ll loop = 0;
for (int z = 0; z < t.size(); z++) {
ll i = t[z] - 'a';
auto it = lower_bound(alpha[i].begin(), alpha[i].end(), c);
if (it == alpha[i].end()) {
it = alpha[i].begin();
loop++;
c = *it;
ans = *it;
} else {
c = *it;
ans = *it;
}
}
cout << loop * ll(s.size()) + ans + 1 << endl;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#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;
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 long double ld;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
vector<ll> alp(26, 0);
vector<vector<ll>> alpha(26);
for (int z = 0; z < s.size(); z++) {
alp[s[z] - 'a']++;
alpha[s[z] - 'a'].push_back(z);
}
for (int z = 0; z < t.size(); z++) {
if (alp[t[z] - 'a'] == 0) {
cout << -1 << endl;
return 0;
}
}
ll c = 0;
ll ans = 0;
ll loop = 0;
for (int z = 0; z < t.size(); z++) {
ll i = t[z] - 'a';
auto it = lower_bound(alpha[i].begin(), alpha[i].end(), c);
if (it == alpha[i].end()) {
it = alpha[i].begin();
loop++;
c = *it + 1;
ans = *it;
} else {
c = *it + 1;
ans = *it;
}
}
cout << loop * ll(s.size()) + ans + 1 << endl;
}
|
[
"assignment.change"
] | 741,124
| 741,125
|
u553927381
|
cpp
|
p02937
|
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <thread>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = (ll)1000000007;
const ll inf = (ll)1e18;
const long double eps = 0.0000001;
struct th {
ll first = -1, second = -1;
ll third = -1;
};
vector<vector<pair<ll, ll>>> g;
vector<ll> vert;
void dfs(int v, int par) {
for (auto &i : g[v]) {
if (i.first != par) {
vert[i.first] += vert[v];
dfs(i.first, v);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(30);
#ifdef _DEBUG
/*freopen("sorting.in", "r", stdin);
freopen("sorting.out", "w", stdout);*/
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
string s, t;
cin >> s >> t;
vector<set<int>> alp(30);
for (int i = 0; i < s.size(); ++i) {
alp[s[i] - 'a'].insert(i);
}
bool ok = true;
for (auto i : t) {
if (alp[i - 'a'].empty()) {
ok = false;
break;
}
}
if (!ok) {
cout << -1;
return 0;
}
ll ans = 0;
int cur = 0;
for (auto i : t) {
auto it = alp[i - 'a'].lower_bound(cur + 1);
if (it == alp[i - 'a'].end()) {
cur = *((alp[i - 'a']).begin());
++ans;
} else {
cur = (*it);
}
}
cout << ans * (ll)s.size() + cur + 1;
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <thread>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = (ll)1000000007;
const ll inf = (ll)1e18;
const long double eps = 0.0000001;
struct th {
ll first = -1, second = -1;
ll third = -1;
};
vector<vector<pair<ll, ll>>> g;
vector<ll> vert;
void dfs(int v, int par) {
for (auto &i : g[v]) {
if (i.first != par) {
vert[i.first] += vert[v];
dfs(i.first, v);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(30);
#ifdef _DEBUG
/*freopen("sorting.in", "r", stdin);
freopen("sorting.out", "w", stdout);*/
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
string s, t;
cin >> s >> t;
vector<set<int>> alp(30);
for (int i = 0; i < s.size(); ++i) {
alp[s[i] - 'a'].insert(i);
}
bool ok = true;
for (auto i : t) {
if (alp[i - 'a'].empty()) {
ok = false;
break;
}
}
if (!ok) {
cout << -1;
return 0;
}
ll ans = 0;
int cur = -1;
for (auto i : t) {
auto it = alp[i - 'a'].lower_bound(cur + 1);
if (it == alp[i - 'a'].end()) {
cur = *((alp[i - 'a']).begin());
++ans;
} else {
cur = (*it);
}
}
cout << ans * (ll)s.size() + cur + 1;
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,126
| 741,127
|
u113106094
|
cpp
|
p02937
|
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <thread>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = (ll)1000000007;
const ll inf = (ll)1e18;
const long double eps = 0.0000001;
struct th {
ll first = -1, second = -1;
ll third = -1;
};
vector<vector<pair<ll, ll>>> g;
vector<ll> vert;
void dfs(int v, int par) {
for (auto &i : g[v]) {
if (i.first != par) {
vert[i.first] += vert[v];
dfs(i.first, v);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(30);
#ifdef _DEBUG
/*freopen("sorting.in", "r", stdin);
freopen("sorting.out", "w", stdout);*/
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
string s, t;
cin >> s >> t;
vector<set<int>> alp(30);
for (int i = 0; i < s.size(); ++i) {
alp[s[i] - 'a'].insert(i);
}
bool ok = true;
for (auto i : t) {
if (alp[i - 'a'].empty()) {
ok = false;
break;
}
}
if (!ok) {
cout << -1;
return 0;
}
ll ans = 0;
int cur = 0;
for (auto i : t) {
auto it = alp[i - 'a'].lower_bound(cur);
if (it == alp[i - 'a'].end()) {
cur = *((alp[i - 'a']).begin());
++ans;
} else {
cur = (*it);
}
}
cout << ans * (ll)s.size() + cur + 1;
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <thread>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = (ll)1000000007;
const ll inf = (ll)1e18;
const long double eps = 0.0000001;
struct th {
ll first = -1, second = -1;
ll third = -1;
};
vector<vector<pair<ll, ll>>> g;
vector<ll> vert;
void dfs(int v, int par) {
for (auto &i : g[v]) {
if (i.first != par) {
vert[i.first] += vert[v];
dfs(i.first, v);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(30);
#ifdef _DEBUG
/*freopen("sorting.in", "r", stdin);
freopen("sorting.out", "w", stdout);*/
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
string s, t;
cin >> s >> t;
vector<set<int>> alp(30);
for (int i = 0; i < s.size(); ++i) {
alp[s[i] - 'a'].insert(i);
}
bool ok = true;
for (auto i : t) {
if (alp[i - 'a'].empty()) {
ok = false;
break;
}
}
if (!ok) {
cout << -1;
return 0;
}
ll ans = 0;
int cur = -1;
for (auto i : t) {
auto it = alp[i - 'a'].lower_bound(cur + 1);
if (it == alp[i - 'a'].end()) {
cur = *((alp[i - 'a']).begin());
++ans;
} else {
cur = (*it);
}
}
cout << ans * (ll)s.size() + cur + 1;
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,128
| 741,127
|
u113106094
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define h1 7897897897897897
#define h2 7897466719774591
#define b1 98762051
#define b2 98765431
#define inf 1000000000
#define pi 3.1415926535897932384626
#define LMAX 9223372036854775807
#define ll long long
#define fi first
#define se second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define vp vector<pii>
#define SET(a, b) memset(a, b, sizeof(a));
#define all(x) (x).begin(), (x).end()
#define flush fflush(stdout)
#define debug printf("Hello\n")
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
int n, m, k, x, y, sum, cnt;
char s[100005], t[100005];
ll ans;
vi v[30];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
scanf("%s %s", s, t);
n = strlen(s);
m = strlen(t);
FOR(i, 0, n - 1) { v[s[i] - 'a'].pb(i); }
int p = -1;
FOR(i, 0, m - 1) {
if (v[t[i] - 'a'].empty()) {
printf("-1\n");
return 0;
}
auto it = lower_bound(v[t[i] - 'a'].begin(), v[t[i] - 'a'].end(), p);
if (it == v[t[i] - 'a'].end()) {
int newp = *v[t[i] - 'a'].begin();
ans += n - 1 - p;
ans += newp + 1;
p = newp;
} else {
int newp = *it;
ans += newp - p;
p = newp;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define h1 7897897897897897
#define h2 7897466719774591
#define b1 98762051
#define b2 98765431
#define inf 1000000000
#define pi 3.1415926535897932384626
#define LMAX 9223372036854775807
#define ll long long
#define fi first
#define se second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define vp vector<pii>
#define SET(a, b) memset(a, b, sizeof(a));
#define all(x) (x).begin(), (x).end()
#define flush fflush(stdout)
#define debug printf("Hello\n")
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
int n, m, k, x, y, sum, cnt;
char s[100005], t[100005];
ll ans;
vi v[30];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
scanf("%s %s", s, t);
n = strlen(s);
m = strlen(t);
FOR(i, 0, n - 1) { v[s[i] - 'a'].pb(i); }
int p = -1;
FOR(i, 0, m - 1) {
if (v[t[i] - 'a'].empty()) {
printf("-1\n");
return 0;
}
auto it = upper_bound(v[t[i] - 'a'].begin(), v[t[i] - 'a'].end(), p);
if (it == v[t[i] - 'a'].end()) {
int newp = *v[t[i] - 'a'].begin();
ans += n - 1 - p;
ans += newp + 1;
p = newp;
} else {
int newp = *it;
ans += newp - p;
p = newp;
}
}
printf("%lld\n", ans);
return 0;
}
|
[
"identifier.change",
"call.function.change"
] | 741,131
| 741,132
|
u072550332
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i, a, b) for (int i = a, i##end = b; i <= i##end; ++i)
#define drep(i, a, b) for (int i = a, i##end = b; i >= i##end; --i)
char IO;
int rd() {
int s = 0, f = 0;
while (!isdigit(IO = getchar()))
if (IO == '-')
f = 1;
do
s = (s << 1) + (s << 3) + (IO ^ '0');
while (isdigit(IO = getchar()));
return f ? -s : s;
}
const int N = 1e5;
const int z[5][4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int n, m;
char s[N], p[N];
int c[N];
int nxt[N][26];
int main() {
scanf("%s%s", s + 1, p + 1);
n = strlen(s + 1), m = strlen(p + 1);
rep(i, 1, n) c[s[i] - 'a']++;
rep(i, 1, m) if (!c[p[i] - 'a']) return puts("-1"), 0;
memset(nxt, 10, sizeof nxt);
drep(i, n, 1) {
int x = s[i] - 'a';
rep(j, 0, 26) {
if (x == j)
nxt[i][j] = i;
else
nxt[i][j] = nxt[i + 1][j];
}
}
ll now = 0;
rep(i, 1, m) {
ll x = p[i] - 'a';
ll t;
if (now % n == 0)
t = n + 1;
else
t = now % n;
if (nxt[t][x] <= n) {
now = now / n * n + nxt[t][x];
} else {
now = (now + n - 1) / n * n + nxt[1][x];
}
// cout<<now<<endl;
}
printf("%lld\n", now);
}
|
#include <bits/stdc++.h>
using namespace std;
#define reg register
typedef long long ll;
#define rep(i, a, b) for (int i = a, i##end = b; i <= i##end; ++i)
#define drep(i, a, b) for (int i = a, i##end = b; i >= i##end; --i)
char IO;
int rd() {
int s = 0, f = 0;
while (!isdigit(IO = getchar()))
if (IO == '-')
f = 1;
do
s = (s << 1) + (s << 3) + (IO ^ '0');
while (isdigit(IO = getchar()));
return f ? -s : s;
}
const int N = 1e5 + 10;
const int z[5][4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int n, m;
char s[N], p[N];
int c[N];
int nxt[N][26];
int main() {
scanf("%s%s", s + 1, p + 1);
n = strlen(s + 1), m = strlen(p + 1);
rep(i, 1, n) c[s[i] - 'a']++;
rep(i, 1, m) if (!c[p[i] - 'a']) return puts("-1"), 0;
memset(nxt, 10, sizeof nxt);
drep(i, n, 1) {
int x = s[i] - 'a';
rep(j, 0, 25) {
if (x == j)
nxt[i][j] = i;
else
nxt[i][j] = nxt[i + 1][j];
}
}
ll now = 0;
rep(i, 1, m) {
ll x = p[i] - 'a';
ll t;
if (now % n == 0)
t = n + 1;
else
t = now % n + 1;
if (nxt[t][x] <= n) {
now = now / n * n + nxt[t][x];
} else {
now = (now + n - 1) / n * n + nxt[1][x];
}
// cout<<now<<endl;
}
printf("%lld\n", now);
}
|
[
"literal.number.change",
"call.arguments.change",
"assignment.change"
] | 741,135
| 741,134
|
u891465773
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
bool notok(const string &s, const string &t) {
set<char> ss;
for (char c : s)
ss.insert(c);
for (int c : s) {
if (ss.count(c) == 0) {
return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
if (notok(s, t)) {
cout << -1 << endl;
return 0;
}
vector<vector<int>> pos(26);
int n = s.size();
for (int i = 0; i < n; i++) {
pos[s[i] - 'a'].push_back(i);
}
auto get = [&](int cur, char c) -> int {
auto it = lower_bound(pos[c - 'a'].begin(), pos[c - 'a'].end(), cur);
if (it == pos[c - 'a'].end())
return -1;
return *it + 1;
};
long long ans = 0;
int cur = 0;
for (char c : t) {
// cur以降で最初のc
int nxt = get(cur, c);
if (nxt == -1) {
ans += n - cur;
cur = 0;
nxt = get(cur, c);
}
ans += nxt - cur;
cur = nxt;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool notok(const string &s, const string &t) {
set<char> ss;
for (char c : s)
ss.insert(c);
for (int c : t) {
if (ss.count(c) == 0) {
return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
if (notok(s, t)) {
cout << -1 << endl;
return 0;
}
vector<vector<int>> pos(26);
int n = s.size();
for (int i = 0; i < n; i++) {
pos[s[i] - 'a'].push_back(i);
}
auto get = [&](int cur, char c) -> int {
auto it = lower_bound(pos[c - 'a'].begin(), pos[c - 'a'].end(), cur);
if (it == pos[c - 'a'].end())
return -1;
return *it + 1;
};
long long ans = 0;
int cur = 0;
for (char c : t) {
// cur以降で最初のc
int nxt = get(cur, c);
if (nxt == -1) {
ans += n - cur;
cur = 0;
nxt = get(cur, c);
}
ans += nxt - cur;
cur = nxt;
}
cout << ans << endl;
}
|
[
"identifier.change"
] | 741,138
| 741,139
|
u210718367
|
cpp
|
p02937
|
#include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
// template<typename key, typename val>
// using ordered_tree =
// tree<key, val, greater<>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int64;
typedef complex<double> comp;
const double pi = 3.14159265358979323846;
const int inf = (int)1e+9 + 2;
const int64 inf64 = (int64)1e+18 + 2;
const double dinf = 1e+20;
const int mod = 1'000'000'007; // 998244353;
const int base = 2187;
const double eps = 1e-8;
const int N = 300'000;
const int LOGN = 19;
int n, m, k;
int go[N][26];
void solve(int test) {
string s, t;
cin >> s >> t;
int n = (int)s.size();
memset(go, -1, sizeof(go));
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) {
if (s[i] - 'a' == j) {
go[i][j] = i;
} else {
go[i][j] = go[i + 1][j];
}
}
}
int ans = 0;
int pos = 0;
for (char c : t) {
c -= 'a';
if (go[pos][c] == -1) {
++ans;
pos = 0;
}
if (go[pos][c] == -1) {
ans = -1;
break;
}
pos = go[pos][c];
}
if (ans == -1) {
cout << ans << '\n';
} else {
cout << ans * 1ll * s.size() + pos + 1 << '\n';
}
}
void precalc() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
precalc();
int test = 1;
// cin >> test;
// auto start = chrono::high_resolution_clock::now();
for (int i = 1; i <= test; ++i)
solve(i);
// cerr <<
// chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now()
// - start).count() << '\n';
return 0;
}
|
#include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
// template<typename key, typename val>
// using ordered_tree =
// tree<key, val, greater<>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int64;
typedef complex<double> comp;
const double pi = 3.14159265358979323846;
const int inf = (int)1e+9 + 2;
const int64 inf64 = (int64)1e+18 + 2;
const double dinf = 1e+20;
const int mod = 1'000'000'007; // 998244353;
const int base = 2187;
const double eps = 1e-8;
const int N = 300'000;
const int LOGN = 19;
int n, m, k;
int go[N][26];
void solve(int test) {
string s, t;
cin >> s >> t;
int n = (int)s.size();
memset(go, -1, sizeof(go));
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) {
if (s[i] - 'a' == j) {
go[i][j] = i;
} else {
go[i][j] = go[i + 1][j];
}
}
}
int ans = 0;
int pos = 0;
for (char c : t) {
c -= 'a';
if (go[pos][c] == -1) {
++ans;
pos = 0;
}
if (go[pos][c] == -1) {
ans = -1;
break;
}
pos = go[pos][c] + 1;
}
if (ans == -1) {
cout << ans << '\n';
} else {
cout << ans * 1ll * s.size() + pos << '\n';
}
}
void precalc() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
precalc();
int test = 1;
// cin >> test;
// auto start = chrono::high_resolution_clock::now();
for (int i = 1; i <= test; ++i)
solve(i);
// cerr <<
// chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now()
// - start).count() << '\n';
return 0;
}
|
[
"assignment.change",
"expression.operation.binary.remove"
] | 741,142
| 741,143
|
u432090061
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 200003, INF = 1 << 30;
int main() {
string S, T;
cin >> S >> T;
vector<int> when[26];
for (int i = 0; i < S.size(); i++) {
when[S[i] - 'a'].push_back(i);
}
bool ok = true;
ll cnt = 0;
for (int i = 0; i < T.size(); i++) {
int a = T[i] - 'a';
if (when[a].size() == 0) {
ok = false;
break;
}
auto it = upper_bound(all(when[a]), cnt % ll(S.size()));
if (it == when[a].end()) {
int b = when[a][0];
cnt = (cnt / ll(S.size()) + 1) * ll(S.size()) + b;
} else {
cnt = cnt / ll(S.size()) * ll(S.size()) + *it;
}
}
if (ok)
cout << cnt + 1 << endl;
else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 200003, INF = 1 << 30;
int main() {
string S, T;
cin >> S >> T;
vector<int> when[26];
for (int i = 0; i < S.size(); i++) {
when[S[i] - 'a'].push_back(i);
}
bool ok = true;
ll cnt = -1;
for (int i = 0; i < T.size(); i++) {
int a = T[i] - 'a';
if (when[a].size() == 0) {
ok = false;
break;
}
auto it = upper_bound(all(when[a]), cnt % ll(S.size()));
if (it == when[a].end()) {
int b = when[a][0];
cnt = (cnt / ll(S.size()) + 1) * ll(S.size()) + b;
} else {
cnt = cnt / ll(S.size()) * ll(S.size()) + *it;
}
}
if (ok)
cout << cnt + 1 << endl;
else
cout << -1 << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,144
| 741,145
|
u133391510
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
#define let auto const
int main() {
string s, t;
cin >> s >> t;
set<i64> st[30];
auto num = [](i64 c) { return (i64)(c) - 'a'; };
i64 n = s.size();
i64 m = t.size();
vector<i64> A(n), B(m);
rep(i, 0, n) A[i] = num(s[i]);
rep(i, 0, m) B[i] = num(t[i]);
rep(i, 0, n) {
st[A[i]].insert(i);
st[A[i]].insert(i + n);
}
i64 ans = 0;
i64 now = 0;
rep(i, 0, m) {
i64 b = B[i];
auto iter = st[b].lower_bound(now);
if (iter == st[b].end()) {
cout << -1 << endl;
return 0;
}
now = *iter + 1;
if (now >= n) {
now -= n;
ans += n;
}
}
cout << ans + now + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
#define let auto const
int main() {
string s, t;
cin >> s >> t;
set<i64> st[30];
auto num = [](i64 c) { return (i64)(c) - 'a'; };
i64 n = s.size();
i64 m = t.size();
vector<i64> A(n), B(m);
rep(i, 0, n) A[i] = num(s[i]);
rep(i, 0, m) B[i] = num(t[i]);
rep(i, 0, n) {
st[A[i]].insert(i);
st[A[i]].insert(i + n);
}
i64 ans = 0;
i64 now = 0;
rep(i, 0, m) {
i64 b = B[i];
auto iter = st[b].lower_bound(now);
if (iter == st[b].end()) {
cout << -1 << endl;
return 0;
}
now = *iter + 1;
while (now >= n) {
now -= n;
ans += n;
}
}
cout << ans + now << endl;
}
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"expression.operation.binary.remove"
] | 741,146
| 741,147
|
u852585808
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
#define let auto const
int main() {
string s, t;
cin >> s >> t;
set<i64> st[30];
auto num = [](i64 c) { return (i64)(c) - 'a'; };
i64 n = s.size();
i64 m = t.size();
vector<i64> A(n), B(m);
rep(i, 0, n) A[i] = num(s[i]);
rep(i, 0, m) B[i] = num(t[i]);
rep(i, 0, n) {
st[A[i]].insert(i);
st[A[i]].insert(i + n);
}
i64 ans = 0;
i64 now = 0;
rep(i, 0, m) {
i64 b = B[i];
auto iter = st[b].lower_bound(now);
if (iter == st[b].end()) {
cout << -1 << endl;
return 0;
}
now = *iter;
if (now >= n) {
now -= n;
ans += n;
}
}
cout << ans + now + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
#define let auto const
int main() {
string s, t;
cin >> s >> t;
set<i64> st[30];
auto num = [](i64 c) { return (i64)(c) - 'a'; };
i64 n = s.size();
i64 m = t.size();
vector<i64> A(n), B(m);
rep(i, 0, n) A[i] = num(s[i]);
rep(i, 0, m) B[i] = num(t[i]);
rep(i, 0, n) {
st[A[i]].insert(i);
st[A[i]].insert(i + n);
}
i64 ans = 0;
i64 now = 0;
rep(i, 0, m) {
i64 b = B[i];
auto iter = st[b].lower_bound(now);
if (iter == st[b].end()) {
cout << -1 << endl;
return 0;
}
now = *iter + 1;
while (now >= n) {
now -= n;
ans += n;
}
}
cout << ans + now << endl;
}
|
[
"assignment.change",
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"expression.operation.binary.remove"
] | 741,148
| 741,147
|
u852585808
|
cpp
|
p02937
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (i = 0; i < n; i++)
#define int long long
using namespace std;
string s;
string t;
bool existS[26];
bool existT[26];
vector<int> poss[26];
signed main() {
int i;
cin >> s >> t;
rep(i, s.length()) existS[s[i] - 'a'] = true;
rep(i, t.length()) existT[t[i] - 'a'] = true;
rep(i, 26) {
if (existT[i] && !existS[i]) {
cout << -1 << endl;
return 0;
}
}
rep(i, s.length()) poss[s[i] - 'a'].push_back(i);
rep(i, s.length()) poss[s[i] - 'a'].push_back(s.length() + i);
int pos = 0;
int ans = 0;
rep(i, t.length()) {
int id = t[i] - 'a';
int iter =
lower_bound(poss[id].begin(), poss[id].end(), pos) - poss[id].begin();
ans += poss[id][iter] - pos;
pos = poss[id][iter] % s.length();
}
cout << ans + 1 << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (i = 0; i < n; i++)
#define int long long
using namespace std;
string s;
string t;
bool existS[26];
bool existT[26];
vector<int> poss[26];
signed main() {
int i;
cin >> s >> t;
rep(i, s.length()) existS[s[i] - 'a'] = true;
rep(i, t.length()) existT[t[i] - 'a'] = true;
rep(i, 26) {
if (existT[i] && !existS[i]) {
cout << -1 << endl;
return 0;
}
}
rep(i, s.length()) poss[s[i] - 'a'].push_back(i);
rep(i, s.length()) poss[s[i] - 'a'].push_back(s.length() + i);
int pos = -1;
int ans = 0;
rep(i, t.length()) {
int id = t[i] - 'a';
int iter =
upper_bound(poss[id].begin(), poss[id].end(), pos) - poss[id].begin();
ans += poss[id][iter] - pos;
pos = poss[id][iter] % s.length();
}
cout << ans << endl;
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 741,151
| 741,152
|
u610441939
|
cpp
|
p02937
|
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <time.h>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define repf(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define repr(i, a, b) for (ll i = (ll)a; i > (ll)b; i--)
#define all(v) (v).begin(), (v).end()
#define mp(a, b) make_pair(a, b)
#define pb(x) push_back(x)
#define eb(x) emplace_back(x)
#define F first
#define S second
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<int> vii;
typedef vector<vii> vvii;
const ll mod = 1e9 + 7;
const int infi = 1147483600;
const ll infl = 1e18 + 5;
const char ENDL = '\n';
// cout << fixed << setprecision(17) << res << endl;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s, t;
cin >> s >> t;
vector<multiset<int>> idx(26);
int n = s.size(), m = t.size();
rep(i, n) { idx[s[i] - 'a'].insert(i); }
int cnt = 0;
int now = 0;
rep(i, m) {
int j = t[i] - 'a';
auto itr = idx[j].lower_bound(now + 1);
if (idx[j].empty()) {
cout << -1 << ENDL;
return 0;
}
if (itr == idx[j].end()) {
cnt++;
now = *idx[j].begin();
} else {
now = *itr;
}
}
cout << (ll)n * (ll)cnt + (ll)now + 1ll << ENDL;
}
|
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <time.h>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define repf(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define repr(i, a, b) for (ll i = (ll)a; i > (ll)b; i--)
#define all(v) (v).begin(), (v).end()
#define mp(a, b) make_pair(a, b)
#define pb(x) push_back(x)
#define eb(x) emplace_back(x)
#define F first
#define S second
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<int> vii;
typedef vector<vii> vvii;
const ll mod = 1e9 + 7;
const int infi = 1147483600;
const ll infl = 1e18 + 5;
const char ENDL = '\n';
// cout << fixed << setprecision(17) << res << endl;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s, t;
cin >> s >> t;
vector<multiset<int>> idx(26);
int n = s.size(), m = t.size();
rep(i, n) { idx[s[i] - 'a'].insert(i); }
int cnt = 0;
int now = -1;
rep(i, m) {
int j = t[i] - 'a';
auto itr = idx[j].lower_bound(now + 1);
if (idx[j].empty()) {
cout << -1 << ENDL;
return 0;
}
if (itr == idx[j].end()) {
cnt++;
now = *idx[j].begin();
} else {
now = *itr;
}
}
cout << (ll)n * (ll)cnt + (ll)now + 1ll << ENDL;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,155
| 741,156
|
u171366497
|
cpp
|
p02937
|
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define int long long
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
int nxt[200010][26];
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
int tmp[26] = {};
rep(i, 0, 26) tmp[i] = -1;
string ss = s + s;
for (int i = ss.size() - 1; i >= 0; i--) {
tmp[ss[i] - 'a'] = i;
rep(j, 0, 26) { nxt[i][j] = tmp[j]; }
}
int cnt = 0;
int prv = 0;
for (int i = 0; i < t.size(); i++) {
int idx = nxt[prv + 1][t[i] - 'a'];
if (idx == -1) {
cout << -1 << endl;
return 0;
}
if (idx >= s.size()) {
cnt++;
idx %= s.size();
}
prv = idx;
}
cout << cnt * (s.size()) + prv + 1 << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define int long long
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
int nxt[200010][26];
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
int tmp[26] = {};
rep(i, 0, 26) tmp[i] = -1;
string ss = s + s;
for (int i = ss.size() - 1; i >= 0; i--) {
tmp[ss[i] - 'a'] = i;
rep(j, 0, 26) { nxt[i][j] = tmp[j]; }
}
int cnt = 0;
int prv = -1;
for (int i = 0; i < t.size(); i++) {
int idx = nxt[prv + 1][t[i] - 'a'];
if (idx == -1) {
cout << -1 << endl;
return 0;
}
if (idx >= s.size()) {
cnt++;
idx %= s.size();
}
prv = idx;
}
cout << cnt * (s.size()) + prv + 1 << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,157
| 741,158
|
u984730891
|
cpp
|
p02937
|
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
#define ten(n) ((int)1e##n)
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <typename...> static inline int getchar_unlocked(void) {
return getchar();
}
template <typename...> static inline void putchar_unlocked(int c) {
putchar(c);
}
#define mygc(c) (c) = getchar_unlocked()
#define mypc(c) putchar_unlocked(c)
void reader(int &x) {
int k, m = 0;
x = 0;
for (;;) {
mygc(k);
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
mygc(k);
if (k < '0' || k > '9')
break;
x = x * 10 + k - '0';
}
if (m)
x = -x;
}
void reader(ll &x) {
int k, m = 0;
x = 0;
for (;;) {
mygc(k);
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
mygc(k);
if (k < '0' || k > '9')
break;
x = x * 10 + k - '0';
}
if (m)
x = -x;
}
int reader(char c[]) {
int i, s = 0;
for (;;) {
mygc(i);
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF)
break;
}
c[s++] = i;
for (;;) {
mygc(i);
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF)
break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
int reader(string &c) {
int i;
for (;;) {
mygc(i);
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF)
break;
}
c.push_back(i);
for (;;) {
mygc(i);
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF)
break;
c.push_back(i);
};
return sz(c);
}
template <class T, class S> void reader(T &x, S &y) {
reader(x);
reader(y);
}
template <class T, class S, class U> void reader(T &x, S &y, U &z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T &x, S &y, U &z, V &w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0)
m = 1, x = -x;
while (x)
f[s++] = x % 10, x /= 10;
if (!s)
f[s++] = 0;
if (m)
mypc('-');
while (s--)
mypc(f[s] + '0');
mypc(c);
}
void writer(ll x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0)
m = 1, x = -x;
while (x)
f[s++] = x % 10, x /= 10;
if (!s)
f[s++] = 0;
if (m)
mypc('-');
while (s--)
mypc(f[s] + '0');
mypc(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++)
mypc(c[i]);
}
void writer(const string &x, char c) {
int i;
for (i = 0; x[i] != '\0'; i++)
mypc(x[i]);
mypc(c);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++)
mypc(x[i]);
mypc(c);
}
template <class T> void writerLn(T x) { writer(x, '\n'); }
template <class T, class S> void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U> void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T, class S, class U, class V>
void writerLn(T x, S y, U z, V v) {
writer(x, ' ');
writer(y, ' ');
writer(z, ' ');
writer(v, '\n');
}
template <class T> void writerArr(T x[], int n) {
if (!n) {
mypc('\n');
return;
}
FOR(i, n - 1) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
template <class T> void writerArr(vector<T> &x) {
writerArr(x.data(), (int)x.size());
}
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
ll mod_pow(ll a, ll n, ll mod) {
ll ret = 1;
ll p = a % mod;
while (n) {
if (n & 1)
ret = ret * p % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
template <class T> T extgcd(T a, T b, T &x, T &y) {
for (T u = y = 1, v = x = 0; a;) {
T q = b / a;
swap(x -= q * u, u);
swap(y -= q * v, v);
swap(b -= q * a, a);
}
return b;
}
ll mod_inv(ll a, ll m) {
ll x, y;
extgcd<ll>(a, m, x, y);
return (m + x % m) % m;
}
#ifdef _MSC_VER
// #ifdef _DEBUG
template <typename... Args>
void debugPrintf(const char *format, Args const &...args) {
fprintf(stderr, format, args...);
fflush(stderr);
}
#else
#define debugPrintf(...)
#endif
vector<int> memo[26];
int main() {
string s, t;
reader(s, t);
FOR(i, sz(s)) { memo[s[i] - 'a'].push_back(i); }
ll ans = (ll)1e12;
for (auto x : t) {
if (memo[x - 'a'].size() == 0) {
ans = -1;
break;
}
}
if (ans == -1) {
puts("-1");
return 0;
}
ans = 0;
for (auto c : t) {
int cur = ans % sz(s);
auto &tr = memo[c - 'a'];
auto it = lower_bound(tr.begin(), tr.end(), cur + 1);
if (it != tr.end()) {
ans = (ans / sz(s) * sz(s)) + *it;
} else {
ans = (ans / sz(s) * sz(s)) + sz(s);
ans += tr[0];
}
}
writerLn(ans + 1);
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
#define ten(n) ((int)1e##n)
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <typename...> static inline int getchar_unlocked(void) {
return getchar();
}
template <typename...> static inline void putchar_unlocked(int c) {
putchar(c);
}
#define mygc(c) (c) = getchar_unlocked()
#define mypc(c) putchar_unlocked(c)
void reader(int &x) {
int k, m = 0;
x = 0;
for (;;) {
mygc(k);
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
mygc(k);
if (k < '0' || k > '9')
break;
x = x * 10 + k - '0';
}
if (m)
x = -x;
}
void reader(ll &x) {
int k, m = 0;
x = 0;
for (;;) {
mygc(k);
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
mygc(k);
if (k < '0' || k > '9')
break;
x = x * 10 + k - '0';
}
if (m)
x = -x;
}
int reader(char c[]) {
int i, s = 0;
for (;;) {
mygc(i);
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF)
break;
}
c[s++] = i;
for (;;) {
mygc(i);
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF)
break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
int reader(string &c) {
int i;
for (;;) {
mygc(i);
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF)
break;
}
c.push_back(i);
for (;;) {
mygc(i);
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF)
break;
c.push_back(i);
};
return sz(c);
}
template <class T, class S> void reader(T &x, S &y) {
reader(x);
reader(y);
}
template <class T, class S, class U> void reader(T &x, S &y, U &z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T &x, S &y, U &z, V &w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0)
m = 1, x = -x;
while (x)
f[s++] = x % 10, x /= 10;
if (!s)
f[s++] = 0;
if (m)
mypc('-');
while (s--)
mypc(f[s] + '0');
mypc(c);
}
void writer(ll x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0)
m = 1, x = -x;
while (x)
f[s++] = x % 10, x /= 10;
if (!s)
f[s++] = 0;
if (m)
mypc('-');
while (s--)
mypc(f[s] + '0');
mypc(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++)
mypc(c[i]);
}
void writer(const string &x, char c) {
int i;
for (i = 0; x[i] != '\0'; i++)
mypc(x[i]);
mypc(c);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++)
mypc(x[i]);
mypc(c);
}
template <class T> void writerLn(T x) { writer(x, '\n'); }
template <class T, class S> void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U> void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T, class S, class U, class V>
void writerLn(T x, S y, U z, V v) {
writer(x, ' ');
writer(y, ' ');
writer(z, ' ');
writer(v, '\n');
}
template <class T> void writerArr(T x[], int n) {
if (!n) {
mypc('\n');
return;
}
FOR(i, n - 1) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
template <class T> void writerArr(vector<T> &x) {
writerArr(x.data(), (int)x.size());
}
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
ll mod_pow(ll a, ll n, ll mod) {
ll ret = 1;
ll p = a % mod;
while (n) {
if (n & 1)
ret = ret * p % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
template <class T> T extgcd(T a, T b, T &x, T &y) {
for (T u = y = 1, v = x = 0; a;) {
T q = b / a;
swap(x -= q * u, u);
swap(y -= q * v, v);
swap(b -= q * a, a);
}
return b;
}
ll mod_inv(ll a, ll m) {
ll x, y;
extgcd<ll>(a, m, x, y);
return (m + x % m) % m;
}
#ifdef _MSC_VER
// #ifdef _DEBUG
template <typename... Args>
void debugPrintf(const char *format, Args const &...args) {
fprintf(stderr, format, args...);
fflush(stderr);
}
#else
#define debugPrintf(...)
#endif
vector<int> memo[26];
int main() {
string s, t;
reader(s, t);
FOR(i, sz(s)) { memo[s[i] - 'a'].push_back(i); }
ll ans = (ll)1e12;
for (auto x : t) {
if (memo[x - 'a'].size() == 0) {
ans = -1;
break;
}
}
if (ans == -1) {
puts("-1");
return 0;
}
ans = -1;
for (auto c : t) {
int cur = ans % sz(s);
auto &tr = memo[c - 'a'];
auto it = lower_bound(tr.begin(), tr.end(), cur + 1);
if (it != tr.end()) {
ans = (ans / sz(s) * sz(s)) + *it;
} else {
ans = (ans / sz(s) * sz(s)) + sz(s);
ans += tr[0];
}
}
writerLn(ans + 1);
return 0;
}
|
[
"literal.number.change",
"assignment.value.change"
] | 741,159
| 741,160
|
u279196402
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#if DEBUG && !ONLINE_JUDGE
#include "header.h"
#else
#define debug(args...)
#endif
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef long long lli;
typedef long double ld;
#define pb push_back
#define all(x) x.begin(), x.end()
#define SZ(x) (int)(x).size()
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define rep(i, a, b) for (auto i = (a); i < b; i++)
#define INF (int)1e9
#define EPS 1e-9
#define MOD 1000000007
void preprocess(void) { return; }
int nxt[(int)1e5 + 100][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
preprocess();
string s, t;
cin >> s >> t;
int n1 = (int)s.length(), n2 = (int)t.length();
memset(nxt, -1, sizeof nxt);
for (int i = n1 - 1; i >= 0; i--) {
rep(j, 0, 26) {
if (s[i] == (char)('a' + j)) {
nxt[i][j] = i;
} else {
if (i < n1 - 1)
nxt[i][j] = nxt[i + 1][j];
}
}
}
int p = 0;
lli ans = 0;
int pos;
rep(i, 0, n2) {
pos = nxt[p][t[i] - 'a'];
if (pos == -1) {
p = 0;
pos = nxt[p][t[i] - 'a'];
ans += n1;
if (pos == -1) {
cout << -1 << endl;
return 0;
}
}
p = pos + 1;
if (p == n1) {
p = 0;
ans += n1;
}
}
cout << ans + pos + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#if DEBUG && !ONLINE_JUDGE
#include "header.h"
#else
#define debug(args...)
#endif
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef long long lli;
typedef long double ld;
#define pb push_back
#define all(x) x.begin(), x.end()
#define SZ(x) (int)(x).size()
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define rep(i, a, b) for (auto i = (a); i < b; i++)
#define INF (int)1e9
#define EPS 1e-9
#define MOD 1000000007
void preprocess(void) { return; }
int nxt[(int)1e5 + 100][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
preprocess();
string s, t;
cin >> s >> t;
int n1 = (int)s.length(), n2 = (int)t.length();
memset(nxt, -1, sizeof nxt);
for (int i = n1 - 1; i >= 0; i--) {
rep(j, 0, 26) {
if (s[i] == (char)('a' + j)) {
nxt[i][j] = i;
} else {
if (i < n1 - 1)
nxt[i][j] = nxt[i + 1][j];
}
}
}
int p = 0;
lli ans = 0;
int pos;
rep(i, 0, n2) {
pos = nxt[p][t[i] - 'a'];
if (pos == -1) {
p = 0;
pos = nxt[p][t[i] - 'a'];
ans += n1;
if (pos == -1) {
cout << -1 << endl;
return 0;
}
}
p = pos + 1;
if (p == n1) {
p = 0;
pos = -1;
ans += n1;
}
}
cout << ans + pos + 1 << endl;
}
|
[
"assignment.add"
] | 741,161
| 741,162
|
u447708702
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#if DEBUG && !ONLINE_JUDGE
#include "header.h"
#else
#define debug(args...)
#endif
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef long long lli;
typedef long double ld;
#define pb push_back
#define all(x) x.begin(), x.end()
#define SZ(x) (int)(x).size()
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define rep(i, a, b) for (auto i = (a); i < b; i++)
#define INF (int)1e9
#define EPS 1e-9
#define MOD 1000000007
void preprocess(void) { return; }
int nxt[(int)1e5 + 100][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
preprocess();
string s, t;
cin >> s >> t;
int n1 = (int)s.length(), n2 = (int)t.length();
memset(nxt, -1, sizeof nxt);
for (int i = n1 - 1; i >= 0; i--) {
rep(j, 0, 26) {
if (s[i] == (char)('a' + j)) {
nxt[i][j] = i;
} else {
if (i < n1 - 1)
nxt[i][j] = nxt[i + 1][j];
}
}
}
int p = 0;
int ans = 0;
int pos;
rep(i, 0, n2) {
pos = nxt[p][t[i] - 'a'];
if (pos == -1) {
p = 0;
pos = nxt[p][t[i] - 'a'];
ans += n1;
if (pos == -1) {
cout << -1 << endl;
return 0;
}
}
p = pos + 1;
if (p == n1) {
p = 0;
ans += n1;
}
}
cout << ans + pos + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#if DEBUG && !ONLINE_JUDGE
#include "header.h"
#else
#define debug(args...)
#endif
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef long long lli;
typedef long double ld;
#define pb push_back
#define all(x) x.begin(), x.end()
#define SZ(x) (int)(x).size()
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define rep(i, a, b) for (auto i = (a); i < b; i++)
#define INF (int)1e9
#define EPS 1e-9
#define MOD 1000000007
void preprocess(void) { return; }
int nxt[(int)1e5 + 100][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
preprocess();
string s, t;
cin >> s >> t;
int n1 = (int)s.length(), n2 = (int)t.length();
memset(nxt, -1, sizeof nxt);
for (int i = n1 - 1; i >= 0; i--) {
rep(j, 0, 26) {
if (s[i] == (char)('a' + j)) {
nxt[i][j] = i;
} else {
if (i < n1 - 1)
nxt[i][j] = nxt[i + 1][j];
}
}
}
int p = 0;
lli ans = 0;
int pos;
rep(i, 0, n2) {
pos = nxt[p][t[i] - 'a'];
if (pos == -1) {
p = 0;
pos = nxt[p][t[i] - 'a'];
ans += n1;
if (pos == -1) {
cout << -1 << endl;
return 0;
}
}
p = pos + 1;
if (p == n1) {
p = 0;
pos = -1;
ans += n1;
}
}
cout << ans + pos + 1 << endl;
}
|
[
"variable_declaration.type.change",
"assignment.add"
] | 741,163
| 741,162
|
u447708702
|
cpp
|
p02937
|
#include <bits/stdc++.h>
// ios::sync_with_stdio(false);
// cin.tie(0);
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> ppll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll mod3 = 1000003;
ll inf = 1000000000000000000;
double pi = 2 * acos(0);
#define rep(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
int dh[4] = {1, -1, 0, 0};
int dw[4] = {0, 0, 1, -1};
int ddh[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int ddw[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
ll lmax(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll lmin(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll Pow(ll n, ll k) {
ll ret = 1;
ll now = n;
while (k > 0) {
if (k & 1)
ret *= now;
now *= now;
k /= 2;
}
return ret;
}
int main() {
string s, t;
cin >> s >> t;
int cnt[26];
fill(cnt, cnt + 26, 0);
vector<ll> v[26];
rep(i, 0, s.size()) {
cnt[s[i] - 'a']++;
v[s[i] - 'a'].push_back(i);
}
rep(i, 0, t.size()) {
if (cnt[t[i] - 'a'] == 0) {
cout << -1 << endl;
return 0;
}
}
ll moji = 0;
ll now = 0;
ll kai = 0;
for (;;) {
int y = t[moji] - 'a';
int r = lower_bound(v[y].begin(), v[y].end(), now) - v[y].begin();
if (r == v[y].size()) {
kai++;
now = v[y][0];
} else {
now = v[y][r];
}
moji++;
if (moji == t.size())
break;
}
cout << kai * s.size() + now + 1 << endl;
}
|
#include <bits/stdc++.h>
// ios::sync_with_stdio(false);
// cin.tie(0);
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> ppll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll mod3 = 1000003;
ll inf = 1000000000000000000;
double pi = 2 * acos(0);
#define rep(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
int dh[4] = {1, -1, 0, 0};
int dw[4] = {0, 0, 1, -1};
int ddh[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int ddw[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
ll lmax(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll lmin(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll Pow(ll n, ll k) {
ll ret = 1;
ll now = n;
while (k > 0) {
if (k & 1)
ret *= now;
now *= now;
k /= 2;
}
return ret;
}
int main() {
string s, t;
cin >> s >> t;
int cnt[26];
fill(cnt, cnt + 26, 0);
vector<ll> v[26];
rep(i, 0, s.size()) {
cnt[s[i] - 'a']++;
v[s[i] - 'a'].push_back(i);
}
rep(i, 0, t.size()) {
if (cnt[t[i] - 'a'] == 0) {
cout << -1 << endl;
return 0;
}
}
ll moji = 0;
ll now = -1;
ll kai = 0;
for (;;) {
int y = t[moji] - 'a';
int r = upper_bound(v[y].begin(), v[y].end(), now) - v[y].begin();
if (r == v[y].size()) {
kai++;
now = v[y][0];
} else {
now = v[y][r];
}
moji++;
if (moji == t.size())
break;
}
cout << kai * s.size() + now + 1 << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 741,164
| 741,165
|
u357265888
|
cpp
|
p02937
|
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define R cin >>
#define Z class
#define ll long long
#define ln cout << '\n'
#define in(a) insert(a)
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n", a)
#define mem(a) memset(a, 0, sizeof(a))
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define rrep(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define REP(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define tr(it, c) for (iter(c) it = (c).begin(); it != (c).end(); it++)
template <Z A> void pr(A a) {
cout << a;
ln;
}
template <Z A, Z B> void pr(A a, B b) {
cout << a << ' ';
pr(b);
}
template <Z A, Z B, Z C> void pr(A a, B b, C c) {
cout << a << ' ';
pr(b, c);
}
template <Z A, Z B, Z C, Z D> void pr(A a, B b, C c, D d) {
cout << a << ' ';
pr(b, c, d);
}
template <Z A> void PR(A a, ll n) {
rep(i, n) {
if (i)
cout << ' ';
cout << a[i];
}
ln;
}
ll check(ll n, ll m, ll x, ll y) { return x >= 0 && x < n && y >= 0 && y < m; }
const ll MAX = 1e9 + 7, MAXL = 1LL << 61, dx[4] = {-1, 0, 1, 0},
dy[4] = {0, 1, 0, -1};
typedef pair<ll, ll> P;
class RMQ {
public:
int n;
P dat[555555];
void init(int _n) {
n = 1;
while (n < _n)
n *= 2;
rep(i, 2 * n) dat[i] = P(MAX, -1);
}
void update(int k, P a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
P query(int a, int b) { return query(a, b, 0, 0, n); }
P query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return P(MAX, -1);
if (a <= l && r <= b)
return dat[k];
P vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
P vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
RMQ r[26];
void Main() {
string s, t;
cin >> s >> t;
rep(i, 26) r[i].init(s.size() * 2);
rep(i, s.size()) {
r[s[i] - 'a'].update(i, P(0, i));
r[s[i] - 'a'].update(i + s.size(), P(0, i + s.size()));
}
ll k = -1, ans = 0;
rep(i, t.size()) {
P p = r[t[i] - 'a'].query(k, s.size() * 2);
if (p.F == MAX) {
pr(-1);
return;
}
ans += p.S - k;
k = p.S % s.size();
}
pr(ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define R cin >>
#define Z class
#define ll long long
#define ln cout << '\n'
#define in(a) insert(a)
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n", a)
#define mem(a) memset(a, 0, sizeof(a))
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define rrep(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define REP(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define tr(it, c) for (iter(c) it = (c).begin(); it != (c).end(); it++)
template <Z A> void pr(A a) {
cout << a;
ln;
}
template <Z A, Z B> void pr(A a, B b) {
cout << a << ' ';
pr(b);
}
template <Z A, Z B, Z C> void pr(A a, B b, C c) {
cout << a << ' ';
pr(b, c);
}
template <Z A, Z B, Z C, Z D> void pr(A a, B b, C c, D d) {
cout << a << ' ';
pr(b, c, d);
}
template <Z A> void PR(A a, ll n) {
rep(i, n) {
if (i)
cout << ' ';
cout << a[i];
}
ln;
}
ll check(ll n, ll m, ll x, ll y) { return x >= 0 && x < n && y >= 0 && y < m; }
const ll MAX = 1e9 + 7, MAXL = 1LL << 61, dx[4] = {-1, 0, 1, 0},
dy[4] = {0, 1, 0, -1};
typedef pair<ll, ll> P;
class RMQ {
public:
int n;
P dat[555555];
void init(int _n) {
n = 1;
while (n < _n)
n *= 2;
rep(i, 2 * n) dat[i] = P(MAX, -1);
}
void update(int k, P a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
P query(int a, int b) { return query(a, b, 0, 0, n); }
P query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return P(MAX, -1);
if (a <= l && r <= b)
return dat[k];
P vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
P vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
RMQ r[26];
void Main() {
string s, t;
cin >> s >> t;
rep(i, 26) r[i].init(s.size() * 2);
rep(i, s.size()) {
r[s[i] - 'a'].update(i, P(0, i));
r[s[i] - 'a'].update(i + s.size(), P(0, i + s.size()));
}
ll k = -1, ans = 0;
rep(i, t.size()) {
P p = r[t[i] - 'a'].query(k + 1, s.size() * 2);
if (p.F == MAX) {
pr(-1);
return;
}
ans += p.S - k;
k = p.S % s.size();
}
pr(ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Main();
return 0;
}
|
[
"assignment.change"
] | 741,166
| 741,167
|
u287015418
|
cpp
|
p02937
|
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD = 1000000000 + 7;
constexpr long long INF = numeric_limits<LL>::max() / 2;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourd;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Rrep(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> edges;
// vector<Pll>v;
map<Pll, Pll> ma;
set<LL> st;
LL h, w, n, m, k, t, s, p, q, last, cnt, sum, ans, a[210000], b[210000];
string str, ss;
bool f[200][200];
char c;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
vector<LL> v[26];
int main() {
cin >> str;
cin >> ss;
rep(i, str.size()) { v[str[i] - 'a'].push_back(i); }
rep(i, str.size()) { v[str[i] - 'a'].push_back(str.size() + i); }
rep(i, 26) v[i].push_back(INF);
LL cur = 0;
for (LL i = 0; i < ss.size(); i++) {
auto it =
lower_bound(v[ss[i] - 'a'].begin(), v[ss[i] - 'a'].end(), cur + 1) -
v[ss[i] - 'a'].begin();
if (v[ss[i] - 'a'][it] == INF) {
cout << -1 << endl;
return 0;
}
ans += v[ss[i] - 'a'][it] - cur;
cur = v[ss[i] - 'a'][it] % str.size();
}
cout << ans + 1 << endl;
return 0;
}
|
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD = 1000000000 + 7;
constexpr long long INF = numeric_limits<LL>::max() / 2;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourd;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Rrep(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> edges;
// vector<Pll>v;
map<Pll, Pll> ma;
set<LL> st;
LL h, w, n, m, k, t, s, p, q, last, cnt, sum, ans, a[210000], b[210000];
string str, ss;
bool f[200][200];
char c;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
vector<LL> v[26];
int main() {
cin >> str;
cin >> ss;
rep(i, str.size()) { v[str[i] - 'a'].push_back(i); }
rep(i, str.size()) { v[str[i] - 'a'].push_back(str.size() + i); }
rep(i, 26) v[i].push_back(INF);
LL cur = -1;
for (LL i = 0; i < ss.size(); i++) {
auto it =
lower_bound(v[ss[i] - 'a'].begin(), v[ss[i] - 'a'].end(), cur + 1) -
v[ss[i] - 'a'].begin();
if (v[ss[i] - 'a'][it] == INF) {
cout << -1 << endl;
return 0;
}
ans += v[ss[i] - 'a'][it] - cur;
cur = v[ss[i] - 'a'][it] % str.size();
}
cout << ans << endl;
return 0;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.remove"
] | 741,176
| 741,177
|
u202928696
|
cpp
|
p02938
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#include <cstdint>
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
using mint = modint<1000000007>;
ll L, R;
/*
2進数で
x = 0aaa
y = 1bbb
→ y^x = 1ccc これは y mod x より大きい
x = 1aaa
y = 0bbb
→ x <= y にならない
x = 1aaa
y = 1bbb
→ y^x = 0ccc の形になり x<=y なら y mod x = y - x
aaa^bbb = bbb-aaa
aaa & ~bbb = 0 であればよい
2^k <= x <= y <= 2^k+r < 2^(k+1)
y = 1ddddeeeeeeee で d が固定の場合
*/
mint maskbitnum_to_count[60];
string llstr(ll x) {
string s(" ");
for (int i = 0; i < 16; i++) {
s += (x & (1LL << (15 - i))) ? "1" : "0";
}
return s;
}
ll call_ct = 0;
ll call_1 = 0;
ll call_0 = 0;
ll call_n = 0;
ll count(ll xpattern, ll ypattern, ll mask, ll maskbitnum) {
call_ct++;
if (ypattern + mask < L || xpattern + mask < L || R < xpattern ||
R < ypattern) {
call_0++;
return 0;
}
if (maskbitnum == 0) {
// cout << "count 1 : " << xpattern << " " << ypattern << endl;
call_1++;
return 1;
}
if (L <= xpattern && ypattern + mask <= R) {
// cout << "count " << maskbitnum_to_count[maskbitnum].value() << " : " <<
// xpattern << "," << ypattern << " / " << llstr(xpattern) << llstr(ypattern)
// << llstr(mask) << endl;
call_n++;
return maskbitnum_to_count[maskbitnum].value();
} else {
ll mask2 = mask >> 1;
ll b = mask ^ mask2;
ll ct = 0;
if (L <= xpattern) {
ct += count(xpattern, ypattern, mask2, maskbitnum - 1);
ct += 2 * count(xpattern, ypattern | b, mask2, maskbitnum - 1);
} else if (ypattern + mask2 <= R) {
ct += 2 * count(xpattern, ypattern, mask2, maskbitnum - 1);
ct += count(xpattern | b, ypattern | b, mask2, maskbitnum - 1);
} else {
ct += count(xpattern, ypattern, mask2, maskbitnum - 1);
ct += count(xpattern, ypattern | b, mask2, maskbitnum - 1);
ct += count(xpattern | b, ypattern | b, mask2, maskbitnum - 1);
}
return ct % 1000000007;
}
}
int main() {
cin >> L >> R;
mint a = 1;
for (int i = 0; i < 60; i++) {
maskbitnum_to_count[i] = a;
a *= 3;
}
ll ct = 0;
for (int i = 0; i < 60; i++) {
ct += count(1LL << i, 1LL << i, (1LL << i) - 1, i);
}
// cout << call_ct << "/ 0:" << call_0 << " 1:" << call_1 << " n:" << call_n
// << endl;
cout << (ct % 1000000007) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#include <cstdint>
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
using mint = modint<1000000007>;
ll L, R;
/*
2進数で
x = 0aaa
y = 1bbb
→ y^x = 1ccc これは y mod x より大きい
x = 1aaa
y = 0bbb
→ x <= y にならない
x = 1aaa
y = 1bbb
→ y^x = 0ccc の形になり x<=y なら y mod x = y - x
aaa^bbb = bbb-aaa
aaa & ~bbb = 0 であればよい
2^k <= x <= y <= 2^k+r < 2^(k+1)
y = 1ddddeeeeeeee で d が固定の場合
*/
mint maskbitnum_to_count[60];
string llstr(ll x) {
string s(" ");
for (int i = 0; i < 16; i++) {
s += (x & (1LL << (15 - i))) ? "1" : "0";
}
return s;
}
ll call_ct = 0;
ll call_1 = 0;
ll call_0 = 0;
ll call_n = 0;
ll count(ll xpattern, ll ypattern, ll mask, ll maskbitnum) {
call_ct++;
if (ypattern + mask < L || xpattern + mask < L || R < xpattern ||
R < ypattern) {
call_0++;
return 0;
}
if (maskbitnum == 0) {
// cout << "count 1 : " << xpattern << " " << ypattern << endl;
call_1++;
return 1;
}
if (L <= xpattern && ypattern + mask <= R) {
// cout << "count " << maskbitnum_to_count[maskbitnum].value() << " : " <<
// xpattern << "," << ypattern << " / " << llstr(xpattern) << llstr(ypattern)
// << llstr(mask) << endl;
call_n++;
return maskbitnum_to_count[maskbitnum].value();
} else {
ll mask2 = mask >> 1;
ll b = mask ^ mask2;
ll ct = 0;
if (L <= xpattern) {
ct += count(xpattern, ypattern, mask2, maskbitnum - 1);
ct += 2 * count(xpattern, ypattern | b, mask2, maskbitnum - 1);
} else if ((ypattern | b) + mask2 <= R) {
ct += 2 * count(xpattern, ypattern, mask2, maskbitnum - 1);
ct += count(xpattern | b, ypattern | b, mask2, maskbitnum - 1);
} else {
ct += count(xpattern, ypattern, mask2, maskbitnum - 1);
ct += count(xpattern, ypattern | b, mask2, maskbitnum - 1);
ct += count(xpattern | b, ypattern | b, mask2, maskbitnum - 1);
}
return ct % 1000000007;
}
}
int main() {
cin >> L >> R;
mint a = 1;
for (int i = 0; i < 60; i++) {
maskbitnum_to_count[i] = a;
a *= 3;
}
ll ct = 0;
for (int i = 0; i < 60; i++) {
ct += count(1LL << i, 1LL << i, (1LL << i) - 1, i);
}
// cout << call_ct << "/ 0:" << call_0 << " 1:" << call_1 << " n:" << call_n
// << endl;
cout << (ct % 1000000007) << endl;
return 0;
}
|
[
"control_flow.branch.if.condition.change"
] | 741,182
| 741,183
|
u336517845
|
cpp
|
p02938
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9;
long long dp[61][2][2][2];
int main() {
long long l, r;
cin >> l >> r;
// dp[桁(i)][L(j)][R(k)][最上位(s)]
dp[60][0][0][0] = 1;
for (int i = 59; i >= 0; i--) {
int lb = (l >> i) & 1;
int rb = (r >> i) & 1;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int s = 0; s < 2; s++) {
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
if (x && !y)
continue;
int nj = j;
int nk = k;
int ns = s;
if (!s && x != y)
continue;
if (x && y)
ns = 1;
if (!j && lb && !x)
continue;
if (!lb && x)
nj = 1;
if (!k && !rb && y)
continue;
if (rb && !y)
nk = 1;
dp[i][nj][nk][ns] += dp[i + 1][j][k][s];
dp[i][nj][nk][ns] %= mod;
}
}
}
}
}
}
long long ans = 0;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int s = 0; s < 2; s++) {
ans += dp[0][j][k][s];
ans %= mod;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
long long dp[61][2][2][2];
int main() {
long long l, r;
cin >> l >> r;
// dp[桁(i)][L(j)][R(k)][最上位(s)]
dp[60][0][0][0] = 1;
for (int i = 59; i >= 0; i--) {
int lb = (l >> i) & 1;
int rb = (r >> i) & 1;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int s = 0; s < 2; s++) {
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
if (x && !y)
continue;
int nj = j;
int nk = k;
int ns = s;
if (!s && x != y)
continue;
if (x && y)
ns = 1;
if (!j && lb && !x)
continue;
if (!lb && x)
nj = 1;
if (!k && !rb && y)
continue;
if (rb && !y)
nk = 1;
dp[i][nj][nk][ns] += dp[i + 1][j][k][s];
dp[i][nj][nk][ns] %= mod;
}
}
}
}
}
}
long long ans = 0;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int s = 0; s < 2; s++) {
ans += dp[0][j][k][s];
ans %= mod;
}
}
}
cout << ans << endl;
}
|
[
"assignment.change"
] | 741,186
| 741,187
|
u013408661
|
cpp
|
p02938
|
const int mod1 = 1000000007, mod2 = 998244353;
const int mod = mod1;
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
// Andrew He's modular-arithmetic class
template <int MOD_> struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return modnum(*this); }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
friend modnum pow(modnum x, size_t n) {
modnum res = 1;
while (n) {
if (n & 1)
res *= x;
x *= x;
n /= 2;
}
return res;
}
};
struct Modnum {
private:
static int MOD; // declaration, not definition
using ll = long long;
using modnum = Modnum;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
Modnum() : v(0) {}
Modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
static void set_mod(const int &m) {
assert(m > 0);
MOD = m;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return *this; }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
};
int Modnum::MOD = 1; // definition
#define sq(x) (x) * (x) // square
#define FAST_READ \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#ifdef LOCAL
#define see(x) cout << "<DBG> " << #x << ": " << (x) << endl
#endif
#ifndef LOCAL
#define see(x)
#endif
#define LSON(x) ((x)*2)
#define RSON(x) ((x)*2 + 1)
template <typename A, typename B> void Min(A &a, const B &b) {
if (b < a)
a = b;
}
template <typename A, typename B> void Max(A &a, const B &b) {
if (b > a)
a = b;
}
int cas;
ostream &kase() { return cout << "Case #" << ++cas << ": "; }
#if __cplusplus < 201402L
template <class Iterator>
std::reverse_iterator<Iterator> make_reverse_iterator(Iterator it) {
return std::reverse_iterator<Iterator>(it);
}
#endif
template <typename iter_t> struct iter_pair {
iter_t _beg, _end;
iter_t begin() { return _beg; }
iter_t end() { return _end; }
};
template <class cont>
iter_pair<reverse_iterator<decltype(begin(declval<cont>()))>>
reverse(cont &&r) {
return {make_reverse_iterator(end(r)), make_reverse_iterator(begin(r))};
}
template <typename T> void dprintln(const T &t) {
cout << t << endl;
} // for debug use
template <typename T, typename... Args>
void dprintln(const T &t, const Args &...rest) {
cout << t << ' ';
dprintln(rest...);
}
template <typename T> void println(const T &t) { cout << t << '\n'; }
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
cout << t << ' ';
println(rest...);
}
template <typename T> void println(const vector<T> &vec) {
if (!vec.empty()) {
cout << vec[0];
for (size_t i = 1; i < vec.size(); ++i)
cout << ' ' << vec[i];
}
cout << endl;
}
template <typename T> void print(const T &t) { cout << t << ' '; }
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
cout << t << ' ';
print(rest...);
}
// this overload is chosen when there's only one argument
template <class T> void scan(T &t) { cin >> t; }
template <class T, class... Args> void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
template <typename T> void scan(vector<T> &vec) {
for (T &x : vec)
scan(x);
}
using ull = unsigned long long;
using ll = long long;
using ul = unsigned long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int, int>;
using pip = pair<int, pii>;
using pll = pair<ll, ll>;
using vb = vector<bool>;
using vpii = vector<pii>;
using ldb = long double;
template <typename int_t> inline int_t lowbit(int_t x) { return x & -x; }
#define rng(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define up(i, a, b) for (int i = int(a); i <= int(b); ++i)
#define down(i, b, a) for (int i = int(b); i >= int(a); i--)
#define rep(n) for (int i##n = 0, _##n = (int)n; i##n < _##n; i##n++)
#define stp(i, a, b, c) for (int i = (a); i < (b); i += (c))
#define FOR(x, cont) for (const auto &x : cont)
#define INC(init, x, y) for (init; x <= y; ++x)
#define For(x, cont) for (auto &x : cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define SZ(x) (int)(x).size()
#define UP(i, l, r) for (i = decltype(i)(l); i <= decltype(i)(r); ++i)
#define DOWN(i, r, l) for (i = decltype(i)(r); i >= decltype(i)(l); --i)
#define Dec(a, b) for (; a >= b; --a)
template <typename T, typename Comp = less<T>>
using pq = priority_queue<T, vector<T>, Comp>;
#define popcnt(x) __builtin_popcountll((x))
#define SET(arr, v) memset(arr, (v), sizeof(arr))
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define UB(cont, x) int(upper_bound(all(cont), x) - begin(cont))
#define AI(name, n, m) vv<int> name(n, vi(m));
#define AL(name, n, m) vv<ll> name(size_t(n), vl(size_t(m)));
#define set0(arr) memset(arr, 0, sizeof arr)
#define set1(arr) memset(arr, -1, sizeof arr)
#define AT(T, n, m, a) vector<vector<T>> a(n, vector<T>(m))
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
auto bet = [](const ll x, const ll y, const ll i) { return x <= i && i <= y; };
template <typename T1, typename T2>
T1 ceil(T1 x, T2 y) { // y >= 1，是整数。需要注意 x + y - 1 是否会溢出
return (x + y - 1) / y;
}
inline int h_bit(unsigned long long x) {
return sizeof(unsigned long long) * 8 - 1 - __builtin_clzll(x);
}
int pow2(int x) { // power of 2
return 1 << (h_bit((ull)x) + (x != lowbit(x)));
}
template <typename T> struct bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(bin_op), init(init) {
a.assign(n + 1, init);
}
T prefix(T x) {
auto res = init;
while (x) {
res = bin_op(a[x], res);
x -= x & -x;
}
return res;
}
void modify(int x, T v) {
while (x < (int)a.size()) {
a[x] = bin_op(a[x], v);
x += x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
template <typename T> struct r_bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit r_bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(move(bin_op)), init(init) {
a.ssign(n + 1, init);
}
T suffix(int x) {
T res = init;
while (x < SZ(a)) {
res = bin_op(res, a[x]);
x += x & -x;
}
return res;
}
void modify(int x, T v) {
while (x > 0) {
a[x] = bin_op(a[x], v);
x -= x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
vi get_prime(int n) {
vi minp((ul)n + 1), p;
for (int i = 2; i <= n; i++) {
if (!minp[i]) {
minp[i] = i;
p.pb(i);
}
FOR(x, p) {
if (x <= minp[i] && x * i <= n)
minp[x * i] = x;
else
break;
}
}
return p;
}
// alias templates
template <typename T> using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1> using vp = vector<pair<T1, T2>>;
template <typename T, int n> using va = vector<array<T, n>>;
// order_of_key (k) : Number of items strictly smaller than k .
// find_by_order(k) : K-th element in a set (counting from zero).
#ifdef __GNUC__
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <typename T>
using rank_tree =
__gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update>;
#endif
// union-find 并查集
struct UF {
vi par, sz;
int n_tree;
explicit UF(int n) { // 0-indexed
par.assign(n, 0);
sz.assign(n, 1);
rng(i, 0, n) par[i] = i;
n_tree = n;
}
int n_cluster() const { return n_tree; }
int size(int x) { return sz[root(x)]; }
int root(int x) { return x == par[x] ? x : par[x] = root(par[x]); }
bool unite(int x, int y) {
int rx = root(x), ry = root(y);
if (rx != ry) {
par[rx] = ry;
--n_tree;
sz[ry] += sz[rx];
return true;
}
return false;
}
};
template <typename T, typename Compare = std::less<T>> struct SparseTable {
size_t n{}; // 0-indexed
vv<T> a;
template <typename ptr_t> SparseTable(ptr_t beg, ptr_t end) : n(end - beg) {
a.resize((size_t)h_bit(n) + 1); // 注意：不能写成 h_bit(n)
a[0].assign(beg, end);
rng(i, 0, SZ(a) - 1) {
a[i + 1].resize(n);
rng(j, 0, n - (1u << i)) {
a[i + 1][j] = min(a[i][j], a[i][j + (1u << i)], Compare());
}
rng(j, n - (1u << i), n) { a[i + 1][j] = a[i][j]; }
}
}
using idx_t = long;
T query(idx_t l, idx_t r) { // l <= r
int i = h_bit(r - l + 1ul);
return min(a[i][l], a[i][r + 1 - (1u << i)], Compare());
}
};
vi get_popcnt(int n) {
vi res((ul)n + 1);
rng(i, 0, n) {
if (i * 2 <= n)
res[i * 2] = res[i];
if ((i & 1) == 0)
res[i + 1] = res[i] + 1;
}
return res;
}
vi get_mu(int n) {
assert(n > 0);
vi mu(n + 1);
vi min_p(n + 1);
vi prime;
mu[1] = 1;
rng(i, 2, n + 1) {
if (!min_p[i]) {
prime.pb(i);
min_p[i] = i;
mu[i] = -1;
}
FOR(p, prime) {
if (p > min_p[i]) {
break;
}
int t = p * i;
if (t > n)
break;
min_p[t] = p;
mu[t] = p == min_p[i] ? 0 : -mu[i];
}
}
return mu;
}
template <typename num> num fp(num x, ll n) { // fast power: hat off to quailty
if (n < 0) {
x = fp(x, mod - 2);
n = -n;
}
num ans = 1;
while (n) {
if (n & 1)
ans *= x;
n /= 2;
x *= x;
}
return ans;
}
template <typename num> void bit_reverse_swap(vector<num> &a) {
int n = SZ(a);
for (int i = 1, j = n >> 1, k; i < n - 1; i++) {
if (i < j)
swap(a[i], a[j]);
// tricky
for (k = n >> 1; j >= k; j -= k, k >>= 1)
; // inspect the highest "1"
j += k;
}
}
template <typename num> void FFT(vector<num> &a, int type) {
bit_reverse_swap(a);
int n = SZ(a);
for (int i = 2; i <= n; i *= 2) {
const auto wi = fp(3, type * (mod - 1) / i); // i次单位根
for (int j = 0; j < n; j += i) {
num w(1);
for (int k = j, h = i >> 1; k < j + h; k++) {
auto t = w * a[k + h], u = a[k];
a[k] = u + t;
a[k + h] = u - t;
w *= wi;
}
}
}
const auto inv = num(n).inv();
if (type == -1)
for (auto &x : a)
x *= inv;
}
template <typename num> void fp(vector<num> &a, const int n) {
a.resize((ul)pow2((SZ(a) - 1) * n + 1));
FFT(a, 1);
for (auto &x : a)
x = fp(x, n);
FFT(a, -1);
}
// DEBUG code by tourist
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// end DEBUG
// minimal geometry classes
struct point {
int x, y;
void read() { scan(x, y); }
ll cross(const point &b) const { return 1LL * x * b.y - 1LL * y * b.x; }
point operator-(const point &b) const { return {x - b.x, y - b.y}; }
bool para(const point &b) const { // parallel
return 1LL * x * b.y == 1LL * y * b.x;
}
bool operator<(const point &b) const { return cross(b) < 0; }
};
struct segment {
point p, dir;
bool on_same_line(const segment &other) const {
return dir.para(other.dir) && (p - other.p).para(dir);
}
bool para(const segment &b) const { return dir.para(b.dir); }
bool operator==(const segment &b) const { return this->on_same_line(b); }
};
struct fraction {
int n, d;
bool operator<(const fraction &that) const {
return 1LL * n * that.d < 1LL * that.n * d;
}
bool operator==(const fraction &that) const {
return n == that.n && d == that.d;
}
bool operator>=(const fraction &that) const { return !(*this < that); }
bool operator>(const fraction &that) const {
return 1LL * n * that.d > 1LL * that.n * d;
}
fraction inverse() const { return n < 0 ? fraction{-d, -n} : fraction{d, n}; }
fraction(int n, int d) {
if (d < 0)
n = -n, d = -d;
int g = __gcd(abs(n), d);
n /= g, d /= g;
this->n = n, this->d = d;
}
explicit fraction(int x) : n(x), d(1) {}
fraction operator+(const fraction &that) const {
return fraction{n * that.d + that.n * d, d * that.d};
}
fraction operator-(const fraction &that) const {
return fraction{n * that.d - that.n * d, d * that.d};
}
fraction floor() const {
if (d == 0)
return *this;
return fraction((n < 0 ? n - (d - 1) : n) / d);
}
friend ostream &operator<<(ostream &out, const fraction &f) {
return out << "(" << f.n << ',' << f.d << ')';
}
pii to_pair() const { return {n, d}; }
};
using Num = modnum<mod>;
struct comb {
vector<Num> f;
explicit comb(int n) {
f.resize(n + 1);
f[0] = 1;
up(i, 1, n) f[i] = f[i - 1] * i;
}
Num get(int x, int y) const {
assert(x <= SZ(f) - 1);
assert(x >= 0 && y >= 0);
if (x < y)
return 0;
return f[x] / f[y] / f[x - y];
}
};
// BEGIN 树剖模板
namespace HLD {
const int max_V = 1e5 + 5;
vi g[max_V]; // vertices are 1-indexed
int fa[max_V];
int sz[max_V];
int heavy_son[max_V];
int dep[max_V];
void dfs(int u, int f) {
fa[u] = f;
sz[u] = 1;
dep[u] = dep[f] + 1;
int hson = 0;
FOR(v, g[u]) {
if (v != f) {
dfs(v, u);
sz[u] += sz[v];
if (sz[v] > sz[hson])
hson = v;
}
}
heavy_son[u] = hson;
}
int top[max_V];
int pos[max_V]; // 0-indexed
// https://codeforces.com/blog/entry/22072
void init(int n) { // 很好的写法！
int idx = 0;
rng(i, 1, n + 1) {
if (i != heavy_son[fa[i]]) {
for (int j = i; j != 0; j = heavy_son[j]) {
top[j] = i;
pos[j] = idx++;
}
}
}
}
// 两种情况：1.修改路径上的边 2.修改路径上的点。
bool VALUE_ON_EDGE = true;
// BinOpr: binary operator
template <class BinOpr> void process_path(int u, int v, BinOpr op) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]])
swap(u, v);
op(pos[top[u]], pos[u]);
u = fa[top[u]];
}
if (dep[u] > dep[v])
swap(u, v);
op(pos[u] + VALUE_ON_EDGE, pos[v]);
}
} // namespace HLD
// END 树剖模板
template <typename T> T get_mid(T l, T r) {
assert(l <= r);
return l + (r - l) / 2;
}
//////////////////^"^///////////////////////////////////
int p[60];
// l = 0, r = x 的情形。
// 高于 y 的位上都是0
int calc(ll x, int y) {
int ans = 0;
int prod = 1;
down(i, y, 0) {
if (x & 1ULL << i) {
ans += (ll)prod * p[i] % mod;
ans %= mod;
prod *= 2;
prod %= mod;
}
}
return (ans + prod) % mod;
}
map<pair<ll, ll>, ll> mem;
ll solve(ll l, ll r, int i) {
// (x, y) x >= l && y <= r && x <= y && (y ^ x) == y - x
if (l == r)
return 1;
if (l == 0)
return calc(r, i);
// l < r
// 1,1
if (l & 1ULL << i) {
return solve(l - (1ULL << i), r - (1ULL << i), i - 1);
}
// 0,0
if ((r & 1ULL << i) == 0) { // 亦可写成 if (r < (1 << i))
return solve(l, r, i - 1);
}
auto iter = mem.find({l, r});
if (iter != mem.end()) {
return iter->second;
}
// 1,0
ll mask = (1ULL << i) - 1;
ll res = 0;
if (l <= (r & mask))
res += solve(l, r & mask, i - 1);
res += solve(l, mask, i - 1);
res += solve(0, r & mask, i - 1);
res %= mod;
mem[{l, r}] = res;
return res;
}
int main() {
FAST_READ
cout << fixed << setprecision(10);
#ifdef LOCAL
ifstream in("main.in");
cin.rdbuf(in.rdbuf());
// ofstream out("main.out");
// cout.rdbuf(out.rdbuf());
#endif
p[0] = 1;
for (int i = 1; i < 60; i++) {
p[i] = p[i - 1] * 3 % mod;
}
ll l, r;
scan(l, r);
ll ans = 0;
down(i, 59, 0) {
ll L = 1LL << i, R = 2 * L - 1;
L = max(L, l);
R = min(R, r);
if (L > R)
continue;
ans += solve(L, R, i);
ans %= mod;
}
println(ans);
#ifdef LOCAL
cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
const int mod1 = 1000000007, mod2 = 998244353;
const int mod = mod1;
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
// Andrew He's modular-arithmetic class
template <int MOD_> struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return modnum(*this); }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
friend modnum pow(modnum x, size_t n) {
modnum res = 1;
while (n) {
if (n & 1)
res *= x;
x *= x;
n /= 2;
}
return res;
}
};
struct Modnum {
private:
static int MOD; // declaration, not definition
using ll = long long;
using modnum = Modnum;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
Modnum() : v(0) {}
Modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
static void set_mod(const int &m) {
assert(m > 0);
MOD = m;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return *this; }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
};
int Modnum::MOD = 1; // definition
#define sq(x) (x) * (x) // square
#define FAST_READ \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#ifdef LOCAL
#define see(x) cout << "<DBG> " << #x << ": " << (x) << endl
#endif
#ifndef LOCAL
#define see(x)
#endif
#define LSON(x) ((x)*2)
#define RSON(x) ((x)*2 + 1)
template <typename A, typename B> void Min(A &a, const B &b) {
if (b < a)
a = b;
}
template <typename A, typename B> void Max(A &a, const B &b) {
if (b > a)
a = b;
}
int cas;
ostream &kase() { return cout << "Case #" << ++cas << ": "; }
#if __cplusplus < 201402L
template <class Iterator>
std::reverse_iterator<Iterator> make_reverse_iterator(Iterator it) {
return std::reverse_iterator<Iterator>(it);
}
#endif
template <typename iter_t> struct iter_pair {
iter_t _beg, _end;
iter_t begin() { return _beg; }
iter_t end() { return _end; }
};
template <class cont>
iter_pair<reverse_iterator<decltype(begin(declval<cont>()))>>
reverse(cont &&r) {
return {make_reverse_iterator(end(r)), make_reverse_iterator(begin(r))};
}
template <typename T> void dprintln(const T &t) {
cout << t << endl;
} // for debug use
template <typename T, typename... Args>
void dprintln(const T &t, const Args &...rest) {
cout << t << ' ';
dprintln(rest...);
}
template <typename T> void println(const T &t) { cout << t << '\n'; }
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
cout << t << ' ';
println(rest...);
}
template <typename T> void println(const vector<T> &vec) {
if (!vec.empty()) {
cout << vec[0];
for (size_t i = 1; i < vec.size(); ++i)
cout << ' ' << vec[i];
}
cout << endl;
}
template <typename T> void print(const T &t) { cout << t << ' '; }
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
cout << t << ' ';
print(rest...);
}
// this overload is chosen when there's only one argument
template <class T> void scan(T &t) { cin >> t; }
template <class T, class... Args> void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
template <typename T> void scan(vector<T> &vec) {
for (T &x : vec)
scan(x);
}
using ull = unsigned long long;
using ll = long long;
using ul = unsigned long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int, int>;
using pip = pair<int, pii>;
using pll = pair<ll, ll>;
using vb = vector<bool>;
using vpii = vector<pii>;
using ldb = long double;
template <typename int_t> inline int_t lowbit(int_t x) { return x & -x; }
#define rng(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define up(i, a, b) for (int i = int(a); i <= int(b); ++i)
#define down(i, b, a) for (int i = int(b); i >= int(a); i--)
#define rep(n) for (int i##n = 0, _##n = (int)n; i##n < _##n; i##n++)
#define stp(i, a, b, c) for (int i = (a); i < (b); i += (c))
#define FOR(x, cont) for (const auto &x : cont)
#define INC(init, x, y) for (init; x <= y; ++x)
#define For(x, cont) for (auto &x : cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define SZ(x) (int)(x).size()
#define UP(i, l, r) for (i = decltype(i)(l); i <= decltype(i)(r); ++i)
#define DOWN(i, r, l) for (i = decltype(i)(r); i >= decltype(i)(l); --i)
#define Dec(a, b) for (; a >= b; --a)
template <typename T, typename Comp = less<T>>
using pq = priority_queue<T, vector<T>, Comp>;
#define popcnt(x) __builtin_popcountll((x))
#define SET(arr, v) memset(arr, (v), sizeof(arr))
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define UB(cont, x) int(upper_bound(all(cont), x) - begin(cont))
#define AI(name, n, m) vv<int> name(n, vi(m));
#define AL(name, n, m) vv<ll> name(size_t(n), vl(size_t(m)));
#define set0(arr) memset(arr, 0, sizeof arr)
#define set1(arr) memset(arr, -1, sizeof arr)
#define AT(T, n, m, a) vector<vector<T>> a(n, vector<T>(m))
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
auto bet = [](const ll x, const ll y, const ll i) { return x <= i && i <= y; };
template <typename T1, typename T2>
T1 ceil(T1 x, T2 y) { // y >= 1，是整数。需要注意 x + y - 1 是否会溢出
return (x + y - 1) / y;
}
inline int h_bit(unsigned long long x) {
return sizeof(unsigned long long) * 8 - 1 - __builtin_clzll(x);
}
int pow2(int x) { // power of 2
return 1 << (h_bit((ull)x) + (x != lowbit(x)));
}
template <typename T> struct bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(bin_op), init(init) {
a.assign(n + 1, init);
}
T prefix(T x) {
auto res = init;
while (x) {
res = bin_op(a[x], res);
x -= x & -x;
}
return res;
}
void modify(int x, T v) {
while (x < (int)a.size()) {
a[x] = bin_op(a[x], v);
x += x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
template <typename T> struct r_bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit r_bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(move(bin_op)), init(init) {
a.ssign(n + 1, init);
}
T suffix(int x) {
T res = init;
while (x < SZ(a)) {
res = bin_op(res, a[x]);
x += x & -x;
}
return res;
}
void modify(int x, T v) {
while (x > 0) {
a[x] = bin_op(a[x], v);
x -= x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
vi get_prime(int n) {
vi minp((ul)n + 1), p;
for (int i = 2; i <= n; i++) {
if (!minp[i]) {
minp[i] = i;
p.pb(i);
}
FOR(x, p) {
if (x <= minp[i] && x * i <= n)
minp[x * i] = x;
else
break;
}
}
return p;
}
// alias templates
template <typename T> using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1> using vp = vector<pair<T1, T2>>;
template <typename T, int n> using va = vector<array<T, n>>;
// order_of_key (k) : Number of items strictly smaller than k .
// find_by_order(k) : K-th element in a set (counting from zero).
#ifdef __GNUC__
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <typename T>
using rank_tree =
__gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update>;
#endif
// union-find 并查集
struct UF {
vi par, sz;
int n_tree;
explicit UF(int n) { // 0-indexed
par.assign(n, 0);
sz.assign(n, 1);
rng(i, 0, n) par[i] = i;
n_tree = n;
}
int n_cluster() const { return n_tree; }
int size(int x) { return sz[root(x)]; }
int root(int x) { return x == par[x] ? x : par[x] = root(par[x]); }
bool unite(int x, int y) {
int rx = root(x), ry = root(y);
if (rx != ry) {
par[rx] = ry;
--n_tree;
sz[ry] += sz[rx];
return true;
}
return false;
}
};
template <typename T, typename Compare = std::less<T>> struct SparseTable {
size_t n{}; // 0-indexed
vv<T> a;
template <typename ptr_t> SparseTable(ptr_t beg, ptr_t end) : n(end - beg) {
a.resize((size_t)h_bit(n) + 1); // 注意：不能写成 h_bit(n)
a[0].assign(beg, end);
rng(i, 0, SZ(a) - 1) {
a[i + 1].resize(n);
rng(j, 0, n - (1u << i)) {
a[i + 1][j] = min(a[i][j], a[i][j + (1u << i)], Compare());
}
rng(j, n - (1u << i), n) { a[i + 1][j] = a[i][j]; }
}
}
using idx_t = long;
T query(idx_t l, idx_t r) { // l <= r
int i = h_bit(r - l + 1ul);
return min(a[i][l], a[i][r + 1 - (1u << i)], Compare());
}
};
vi get_popcnt(int n) {
vi res((ul)n + 1);
rng(i, 0, n) {
if (i * 2 <= n)
res[i * 2] = res[i];
if ((i & 1) == 0)
res[i + 1] = res[i] + 1;
}
return res;
}
vi get_mu(int n) {
assert(n > 0);
vi mu(n + 1);
vi min_p(n + 1);
vi prime;
mu[1] = 1;
rng(i, 2, n + 1) {
if (!min_p[i]) {
prime.pb(i);
min_p[i] = i;
mu[i] = -1;
}
FOR(p, prime) {
if (p > min_p[i]) {
break;
}
int t = p * i;
if (t > n)
break;
min_p[t] = p;
mu[t] = p == min_p[i] ? 0 : -mu[i];
}
}
return mu;
}
template <typename num> num fp(num x, ll n) { // fast power: hat off to quailty
if (n < 0) {
x = fp(x, mod - 2);
n = -n;
}
num ans = 1;
while (n) {
if (n & 1)
ans *= x;
n /= 2;
x *= x;
}
return ans;
}
template <typename num> void bit_reverse_swap(vector<num> &a) {
int n = SZ(a);
for (int i = 1, j = n >> 1, k; i < n - 1; i++) {
if (i < j)
swap(a[i], a[j]);
// tricky
for (k = n >> 1; j >= k; j -= k, k >>= 1)
; // inspect the highest "1"
j += k;
}
}
template <typename num> void FFT(vector<num> &a, int type) {
bit_reverse_swap(a);
int n = SZ(a);
for (int i = 2; i <= n; i *= 2) {
const auto wi = fp(3, type * (mod - 1) / i); // i次单位根
for (int j = 0; j < n; j += i) {
num w(1);
for (int k = j, h = i >> 1; k < j + h; k++) {
auto t = w * a[k + h], u = a[k];
a[k] = u + t;
a[k + h] = u - t;
w *= wi;
}
}
}
const auto inv = num(n).inv();
if (type == -1)
for (auto &x : a)
x *= inv;
}
template <typename num> void fp(vector<num> &a, const int n) {
a.resize((ul)pow2((SZ(a) - 1) * n + 1));
FFT(a, 1);
for (auto &x : a)
x = fp(x, n);
FFT(a, -1);
}
// DEBUG code by tourist
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// end DEBUG
// minimal geometry classes
struct point {
int x, y;
void read() { scan(x, y); }
ll cross(const point &b) const { return 1LL * x * b.y - 1LL * y * b.x; }
point operator-(const point &b) const { return {x - b.x, y - b.y}; }
bool para(const point &b) const { // parallel
return 1LL * x * b.y == 1LL * y * b.x;
}
bool operator<(const point &b) const { return cross(b) < 0; }
};
struct segment {
point p, dir;
bool on_same_line(const segment &other) const {
return dir.para(other.dir) && (p - other.p).para(dir);
}
bool para(const segment &b) const { return dir.para(b.dir); }
bool operator==(const segment &b) const { return this->on_same_line(b); }
};
struct fraction {
int n, d;
bool operator<(const fraction &that) const {
return 1LL * n * that.d < 1LL * that.n * d;
}
bool operator==(const fraction &that) const {
return n == that.n && d == that.d;
}
bool operator>=(const fraction &that) const { return !(*this < that); }
bool operator>(const fraction &that) const {
return 1LL * n * that.d > 1LL * that.n * d;
}
fraction inverse() const { return n < 0 ? fraction{-d, -n} : fraction{d, n}; }
fraction(int n, int d) {
if (d < 0)
n = -n, d = -d;
int g = __gcd(abs(n), d);
n /= g, d /= g;
this->n = n, this->d = d;
}
explicit fraction(int x) : n(x), d(1) {}
fraction operator+(const fraction &that) const {
return fraction{n * that.d + that.n * d, d * that.d};
}
fraction operator-(const fraction &that) const {
return fraction{n * that.d - that.n * d, d * that.d};
}
fraction floor() const {
if (d == 0)
return *this;
return fraction((n < 0 ? n - (d - 1) : n) / d);
}
friend ostream &operator<<(ostream &out, const fraction &f) {
return out << "(" << f.n << ',' << f.d << ')';
}
pii to_pair() const { return {n, d}; }
};
using Num = modnum<mod>;
struct comb {
vector<Num> f;
explicit comb(int n) {
f.resize(n + 1);
f[0] = 1;
up(i, 1, n) f[i] = f[i - 1] * i;
}
Num get(int x, int y) const {
assert(x <= SZ(f) - 1);
assert(x >= 0 && y >= 0);
if (x < y)
return 0;
return f[x] / f[y] / f[x - y];
}
};
// BEGIN 树剖模板
namespace HLD {
const int max_V = 1e5 + 5;
vi g[max_V]; // vertices are 1-indexed
int fa[max_V];
int sz[max_V];
int heavy_son[max_V];
int dep[max_V];
void dfs(int u, int f) {
fa[u] = f;
sz[u] = 1;
dep[u] = dep[f] + 1;
int hson = 0;
FOR(v, g[u]) {
if (v != f) {
dfs(v, u);
sz[u] += sz[v];
if (sz[v] > sz[hson])
hson = v;
}
}
heavy_son[u] = hson;
}
int top[max_V];
int pos[max_V]; // 0-indexed
// https://codeforces.com/blog/entry/22072
void init(int n) { // 很好的写法！
int idx = 0;
rng(i, 1, n + 1) {
if (i != heavy_son[fa[i]]) {
for (int j = i; j != 0; j = heavy_son[j]) {
top[j] = i;
pos[j] = idx++;
}
}
}
}
// 两种情况：1.修改路径上的边 2.修改路径上的点。
bool VALUE_ON_EDGE = true;
// BinOpr: binary operator
template <class BinOpr> void process_path(int u, int v, BinOpr op) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]])
swap(u, v);
op(pos[top[u]], pos[u]);
u = fa[top[u]];
}
if (dep[u] > dep[v])
swap(u, v);
op(pos[u] + VALUE_ON_EDGE, pos[v]);
}
} // namespace HLD
// END 树剖模板
template <typename T> T get_mid(T l, T r) {
assert(l <= r);
return l + (r - l) / 2;
}
//////////////////^"^///////////////////////////////////
int p[60];
// l = 0, r = x 的情形。
// 高于 y 的位上都是0
int calc(ll x, int y) {
int ans = 0;
int prod = 1;
down(i, y, 0) {
if (x & 1ULL << i) {
ans += (ll)prod * p[i] % mod;
ans %= mod;
prod *= 2;
prod %= mod;
}
}
return (ans + prod) % mod;
}
map<pair<ll, ll>, ll> mem;
ll solve(ll l, ll r, int i) {
// (x, y) x >= l && y <= r && x <= y && (y ^ x) == y - x
if (l == r)
return 1;
if (l == 0)
return calc(r, i);
// l < r
// 1,1
if (l & 1ULL << i) {
return solve(l - (1ULL << i), r - (1ULL << i), i - 1);
}
// 0,0
if ((r & 1ULL << i) == 0) { // 亦可写成 if (r < (1 << i))
return solve(l, r, i - 1);
}
auto iter = mem.find({l, r});
if (iter != mem.end()) {
return iter->second;
}
// 1,0
ll mask = (1ULL << i) - 1;
ll res = 0;
if (l <= (r & mask))
res += solve(l, r & mask, i - 1);
res += solve(l, mask, i - 1);
res += solve(0, r & mask, i - 1);
res %= mod;
mem[{l, r}] = res;
return res;
}
int main() {
FAST_READ
cout << fixed << setprecision(10);
#ifdef LOCAL
ifstream in("main.in");
cin.rdbuf(in.rdbuf());
// ofstream out("main.out");
// cout.rdbuf(out.rdbuf());
#endif
p[0] = 1;
for (int i = 1; i < 60; i++) {
p[i] = p[i - 1] * 3LL % mod;
}
ll l, r;
scan(l, r);
ll ans = 0;
down(i, 59, 0) {
ll L = 1LL << i, R = 2 * L - 1;
L = max(L, l);
R = min(R, r);
if (L > R)
continue;
ans += solve(L, R, i);
ans %= mod;
}
println(ans);
#ifdef LOCAL
cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
[
"literal.number.type.widen.change"
] | 741,190
| 741,191
|
u799051262
|
cpp
|
p02938
|
const int mod1 = 1000000007, mod2 = 998244353;
const int mod = mod1;
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
// Andrew He's modular-arithmetic class
template <int MOD_> struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return modnum(*this); }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
friend modnum pow(modnum x, size_t n) {
modnum res = 1;
while (n) {
if (n & 1)
res *= x;
x *= x;
n /= 2;
}
return res;
}
};
struct Modnum {
private:
static int MOD; // declaration, not definition
using ll = long long;
using modnum = Modnum;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
Modnum() : v(0) {}
Modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
static void set_mod(const int &m) {
assert(m > 0);
MOD = m;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return *this; }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
};
int Modnum::MOD = 1; // definition
#define sq(x) (x) * (x) // square
#define FAST_READ \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#ifdef LOCAL
#define see(x) cout << "<DBG> " << #x << ": " << (x) << endl
#endif
#ifndef LOCAL
#define see(x)
#endif
#define LSON(x) ((x)*2)
#define RSON(x) ((x)*2 + 1)
template <typename A, typename B> void Min(A &a, const B &b) {
if (b < a)
a = b;
}
template <typename A, typename B> void Max(A &a, const B &b) {
if (b > a)
a = b;
}
int cas;
ostream &kase() { return cout << "Case #" << ++cas << ": "; }
#if __cplusplus < 201402L
template <class Iterator>
std::reverse_iterator<Iterator> make_reverse_iterator(Iterator it) {
return std::reverse_iterator<Iterator>(it);
}
#endif
template <typename iter_t> struct iter_pair {
iter_t _beg, _end;
iter_t begin() { return _beg; }
iter_t end() { return _end; }
};
template <class cont>
iter_pair<reverse_iterator<decltype(begin(declval<cont>()))>>
reverse(cont &&r) {
return {make_reverse_iterator(end(r)), make_reverse_iterator(begin(r))};
}
template <typename T> void dprintln(const T &t) {
cout << t << endl;
} // for debug use
template <typename T, typename... Args>
void dprintln(const T &t, const Args &...rest) {
cout << t << ' ';
dprintln(rest...);
}
template <typename T> void println(const T &t) { cout << t << '\n'; }
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
cout << t << ' ';
println(rest...);
}
template <typename T> void println(const vector<T> &vec) {
if (!vec.empty()) {
cout << vec[0];
for (size_t i = 1; i < vec.size(); ++i)
cout << ' ' << vec[i];
}
cout << endl;
}
template <typename T> void print(const T &t) { cout << t << ' '; }
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
cout << t << ' ';
print(rest...);
}
// this overload is chosen when there's only one argument
template <class T> void scan(T &t) { cin >> t; }
template <class T, class... Args> void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
template <typename T> void scan(vector<T> &vec) {
for (T &x : vec)
scan(x);
}
using ull = unsigned long long;
using ll = long long;
using ul = unsigned long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int, int>;
using pip = pair<int, pii>;
using pll = pair<ll, ll>;
using vb = vector<bool>;
using vpii = vector<pii>;
using ldb = long double;
template <typename int_t> inline int_t lowbit(int_t x) { return x & -x; }
#define rng(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define up(i, a, b) for (int i = int(a); i <= int(b); ++i)
#define down(i, b, a) for (int i = int(b); i >= int(a); i--)
#define rep(n) for (int i##n = 0, _##n = (int)n; i##n < _##n; i##n++)
#define stp(i, a, b, c) for (int i = (a); i < (b); i += (c))
#define FOR(x, cont) for (const auto &x : cont)
#define INC(init, x, y) for (init; x <= y; ++x)
#define For(x, cont) for (auto &x : cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define SZ(x) (int)(x).size()
#define UP(i, l, r) for (i = decltype(i)(l); i <= decltype(i)(r); ++i)
#define DOWN(i, r, l) for (i = decltype(i)(r); i >= decltype(i)(l); --i)
#define Dec(a, b) for (; a >= b; --a)
template <typename T, typename Comp = less<T>>
using pq = priority_queue<T, vector<T>, Comp>;
#define popcnt(x) __builtin_popcountll((x))
#define SET(arr, v) memset(arr, (v), sizeof(arr))
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define UB(cont, x) int(upper_bound(all(cont), x) - begin(cont))
#define AI(name, n, m) vv<int> name(n, vi(m));
#define AL(name, n, m) vv<ll> name(size_t(n), vl(size_t(m)));
#define set0(arr) memset(arr, 0, sizeof arr)
#define set1(arr) memset(arr, -1, sizeof arr)
#define AT(T, n, m, a) vector<vector<T>> a(n, vector<T>(m))
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
auto bet = [](const ll x, const ll y, const ll i) { return x <= i && i <= y; };
template <typename T1, typename T2>
T1 ceil(T1 x, T2 y) { // y >= 1，是整数。需要注意 x + y - 1 是否会溢出
return (x + y - 1) / y;
}
inline int h_bit(unsigned long long x) {
return sizeof(unsigned long long) * 8 - 1 - __builtin_clzll(x);
}
int pow2(int x) { // power of 2
return 1 << (h_bit((ull)x) + (x != lowbit(x)));
}
template <typename T> struct bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(bin_op), init(init) {
a.assign(n + 1, init);
}
T prefix(T x) {
auto res = init;
while (x) {
res = bin_op(a[x], res);
x -= x & -x;
}
return res;
}
void modify(int x, T v) {
while (x < (int)a.size()) {
a[x] = bin_op(a[x], v);
x += x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
template <typename T> struct r_bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit r_bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(move(bin_op)), init(init) {
a.ssign(n + 1, init);
}
T suffix(int x) {
T res = init;
while (x < SZ(a)) {
res = bin_op(res, a[x]);
x += x & -x;
}
return res;
}
void modify(int x, T v) {
while (x > 0) {
a[x] = bin_op(a[x], v);
x -= x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
vi get_prime(int n) {
vi minp((ul)n + 1), p;
for (int i = 2; i <= n; i++) {
if (!minp[i]) {
minp[i] = i;
p.pb(i);
}
FOR(x, p) {
if (x <= minp[i] && x * i <= n)
minp[x * i] = x;
else
break;
}
}
return p;
}
// alias templates
template <typename T> using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1> using vp = vector<pair<T1, T2>>;
template <typename T, int n> using va = vector<array<T, n>>;
// order_of_key (k) : Number of items strictly smaller than k .
// find_by_order(k) : K-th element in a set (counting from zero).
#ifdef __GNUC__
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <typename T>
using rank_tree =
__gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update>;
#endif
// union-find 并查集
struct UF {
vi par, sz;
int n_tree;
explicit UF(int n) { // 0-indexed
par.assign(n, 0);
sz.assign(n, 1);
rng(i, 0, n) par[i] = i;
n_tree = n;
}
int n_cluster() const { return n_tree; }
int size(int x) { return sz[root(x)]; }
int root(int x) { return x == par[x] ? x : par[x] = root(par[x]); }
bool unite(int x, int y) {
int rx = root(x), ry = root(y);
if (rx != ry) {
par[rx] = ry;
--n_tree;
sz[ry] += sz[rx];
return true;
}
return false;
}
};
template <typename T, typename Compare = std::less<T>> struct SparseTable {
size_t n{}; // 0-indexed
vv<T> a;
template <typename ptr_t> SparseTable(ptr_t beg, ptr_t end) : n(end - beg) {
a.resize((size_t)h_bit(n) + 1); // 注意：不能写成 h_bit(n)
a[0].assign(beg, end);
rng(i, 0, SZ(a) - 1) {
a[i + 1].resize(n);
rng(j, 0, n - (1u << i)) {
a[i + 1][j] = min(a[i][j], a[i][j + (1u << i)], Compare());
}
rng(j, n - (1u << i), n) { a[i + 1][j] = a[i][j]; }
}
}
using idx_t = long;
T query(idx_t l, idx_t r) { // l <= r
int i = h_bit(r - l + 1ul);
return min(a[i][l], a[i][r + 1 - (1u << i)], Compare());
}
};
vi get_popcnt(int n) {
vi res((ul)n + 1);
rng(i, 0, n) {
if (i * 2 <= n)
res[i * 2] = res[i];
if ((i & 1) == 0)
res[i + 1] = res[i] + 1;
}
return res;
}
vi get_mu(int n) {
assert(n > 0);
vi mu(n + 1);
vi min_p(n + 1);
vi prime;
mu[1] = 1;
rng(i, 2, n + 1) {
if (!min_p[i]) {
prime.pb(i);
min_p[i] = i;
mu[i] = -1;
}
FOR(p, prime) {
if (p > min_p[i]) {
break;
}
int t = p * i;
if (t > n)
break;
min_p[t] = p;
mu[t] = p == min_p[i] ? 0 : -mu[i];
}
}
return mu;
}
template <typename num> num fp(num x, ll n) { // fast power: hat off to quailty
if (n < 0) {
x = fp(x, mod - 2);
n = -n;
}
num ans = 1;
while (n) {
if (n & 1)
ans *= x;
n /= 2;
x *= x;
}
return ans;
}
template <typename num> void bit_reverse_swap(vector<num> &a) {
int n = SZ(a);
for (int i = 1, j = n >> 1, k; i < n - 1; i++) {
if (i < j)
swap(a[i], a[j]);
// tricky
for (k = n >> 1; j >= k; j -= k, k >>= 1)
; // inspect the highest "1"
j += k;
}
}
template <typename num> void FFT(vector<num> &a, int type) {
bit_reverse_swap(a);
int n = SZ(a);
for (int i = 2; i <= n; i *= 2) {
const auto wi = fp(3, type * (mod - 1) / i); // i次单位根
for (int j = 0; j < n; j += i) {
num w(1);
for (int k = j, h = i >> 1; k < j + h; k++) {
auto t = w * a[k + h], u = a[k];
a[k] = u + t;
a[k + h] = u - t;
w *= wi;
}
}
}
const auto inv = num(n).inv();
if (type == -1)
for (auto &x : a)
x *= inv;
}
template <typename num> void fp(vector<num> &a, const int n) {
a.resize((ul)pow2((SZ(a) - 1) * n + 1));
FFT(a, 1);
for (auto &x : a)
x = fp(x, n);
FFT(a, -1);
}
// DEBUG code by tourist
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// end DEBUG
// minimal geometry classes
struct point {
int x, y;
void read() { scan(x, y); }
ll cross(const point &b) const { return 1LL * x * b.y - 1LL * y * b.x; }
point operator-(const point &b) const { return {x - b.x, y - b.y}; }
bool para(const point &b) const { // parallel
return 1LL * x * b.y == 1LL * y * b.x;
}
bool operator<(const point &b) const { return cross(b) < 0; }
};
struct segment {
point p, dir;
bool on_same_line(const segment &other) const {
return dir.para(other.dir) && (p - other.p).para(dir);
}
bool para(const segment &b) const { return dir.para(b.dir); }
bool operator==(const segment &b) const { return this->on_same_line(b); }
};
struct fraction {
int n, d;
bool operator<(const fraction &that) const {
return 1LL * n * that.d < 1LL * that.n * d;
}
bool operator==(const fraction &that) const {
return n == that.n && d == that.d;
}
bool operator>=(const fraction &that) const { return !(*this < that); }
bool operator>(const fraction &that) const {
return 1LL * n * that.d > 1LL * that.n * d;
}
fraction inverse() const { return n < 0 ? fraction{-d, -n} : fraction{d, n}; }
fraction(int n, int d) {
if (d < 0)
n = -n, d = -d;
int g = __gcd(abs(n), d);
n /= g, d /= g;
this->n = n, this->d = d;
}
explicit fraction(int x) : n(x), d(1) {}
fraction operator+(const fraction &that) const {
return fraction{n * that.d + that.n * d, d * that.d};
}
fraction operator-(const fraction &that) const {
return fraction{n * that.d - that.n * d, d * that.d};
}
fraction floor() const {
if (d == 0)
return *this;
return fraction((n < 0 ? n - (d - 1) : n) / d);
}
friend ostream &operator<<(ostream &out, const fraction &f) {
return out << "(" << f.n << ',' << f.d << ')';
}
pii to_pair() const { return {n, d}; }
};
using Num = modnum<mod>;
struct comb {
vector<Num> f;
explicit comb(int n) {
f.resize(n + 1);
f[0] = 1;
up(i, 1, n) f[i] = f[i - 1] * i;
}
Num get(int x, int y) const {
assert(x <= SZ(f) - 1);
assert(x >= 0 && y >= 0);
if (x < y)
return 0;
return f[x] / f[y] / f[x - y];
}
};
// BEGIN 树剖模板
namespace HLD {
const int max_V = 1e5 + 5;
vi g[max_V]; // vertices are 1-indexed
int fa[max_V];
int sz[max_V];
int heavy_son[max_V];
int dep[max_V];
void dfs(int u, int f) {
fa[u] = f;
sz[u] = 1;
dep[u] = dep[f] + 1;
int hson = 0;
FOR(v, g[u]) {
if (v != f) {
dfs(v, u);
sz[u] += sz[v];
if (sz[v] > sz[hson])
hson = v;
}
}
heavy_son[u] = hson;
}
int top[max_V];
int pos[max_V]; // 0-indexed
// https://codeforces.com/blog/entry/22072
void init(int n) { // 很好的写法！
int idx = 0;
rng(i, 1, n + 1) {
if (i != heavy_son[fa[i]]) {
for (int j = i; j != 0; j = heavy_son[j]) {
top[j] = i;
pos[j] = idx++;
}
}
}
}
// 两种情况：1.修改路径上的边 2.修改路径上的点。
bool VALUE_ON_EDGE = true;
// BinOpr: binary operator
template <class BinOpr> void process_path(int u, int v, BinOpr op) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]])
swap(u, v);
op(pos[top[u]], pos[u]);
u = fa[top[u]];
}
if (dep[u] > dep[v])
swap(u, v);
op(pos[u] + VALUE_ON_EDGE, pos[v]);
}
} // namespace HLD
// END 树剖模板
template <typename T> T get_mid(T l, T r) {
assert(l <= r);
return l + (r - l) / 2;
}
//////////////////^"^///////////////////////////////////
int p[60];
// l = 0, r = x 的情形。
// 高于 y 的位上都是0
int calc(ll x, int y) {
int ans = 0;
int prod = 1;
down(i, y, 0) {
if (x & 1ULL << i) {
ans += prod * p[i] % mod;
ans %= mod;
prod *= 2;
prod %= mod;
}
}
return (ans + prod) % mod;
}
map<pair<ll, ll>, ll> mem;
ll solve(ll l, ll r, int i) {
// (x, y) x >= l && y <= r && x <= y && (y ^ x) == y - x
if (l == r)
return 1;
if (l == 0)
return calc(r, i);
// l < r
// 1,1
if (l & 1ULL << i) {
return solve(l - (1ULL << i), r - (1ULL << i), i - 1);
}
// 0,0
if ((r & 1ULL << i) == 0) { // 亦可写成 if (r < (1 << i))
return solve(l, r, i - 1);
}
auto iter = mem.find({l, r});
if (iter != mem.end()) {
return iter->second;
}
// 1,0
ll mask = (1ULL << i) - 1;
ll res = 0;
if (l <= (r & mask))
res += solve(l, r & mask, i - 1);
res += solve(l, mask, i - 1);
res += solve(0, r & mask, i - 1);
res %= mod;
mem[{l, r}] = res;
return res;
}
int main() {
FAST_READ
cout << fixed << setprecision(10);
#ifdef LOCAL
ifstream in("main.in");
cin.rdbuf(in.rdbuf());
// ofstream out("main.out");
// cout.rdbuf(out.rdbuf());
#endif
p[0] = 1;
for (int i = 1; i < 60; i++) {
p[i] = p[i - 1] * 3 % mod;
}
ll l, r;
scan(l, r);
ll ans = 0;
down(i, 59, 0) {
ll L = 1LL << i, R = 2 * L - 1;
L = max(L, l);
R = min(R, r);
if (L > R)
continue;
ans += solve(L, R, i);
ans %= mod;
}
println(ans);
#ifdef LOCAL
cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
const int mod1 = 1000000007, mod2 = 998244353;
const int mod = mod1;
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
// Andrew He's modular-arithmetic class
template <int MOD_> struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return modnum(*this); }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
friend modnum pow(modnum x, size_t n) {
modnum res = 1;
while (n) {
if (n & 1)
res *= x;
x *= x;
n /= 2;
}
return res;
}
};
struct Modnum {
private:
static int MOD; // declaration, not definition
using ll = long long;
using modnum = Modnum;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
Modnum() : v(0) {}
Modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0)
v += MOD;
}
static void set_mod(const int &m) {
assert(m > 0);
MOD = m;
}
explicit operator int() const { return v; }
friend std::ostream &operator<<(std::ostream &out, const modnum &n) {
return out << int(n);
}
friend std::istream &operator>>(std::istream &in, modnum &n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum &a, const modnum &b) {
return a.v == b.v;
}
friend bool operator!=(const modnum &a, const modnum &b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return *this; }
modnum &operator++() {
v++;
if (v == MOD)
v = 0;
return *this;
}
modnum &operator--() {
if (v == 0)
v = MOD;
v--;
return *this;
}
modnum &operator+=(const modnum &o) {
v += o.v;
if (v >= MOD)
v -= MOD;
return *this;
}
modnum &operator-=(const modnum &o) {
v -= o.v;
if (v < 0)
v += MOD;
return *this;
}
modnum &operator*=(const modnum &o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum &operator/=(const modnum &o) { return *this *= o.inv(); }
friend modnum operator++(modnum &a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum &a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum &a, const modnum &b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum &a, const modnum &b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum &a, const modnum &b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum &a, const modnum &b) {
return modnum(a) /= b;
}
};
int Modnum::MOD = 1; // definition
#define sq(x) (x) * (x) // square
#define FAST_READ \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#ifdef LOCAL
#define see(x) cout << "<DBG> " << #x << ": " << (x) << endl
#endif
#ifndef LOCAL
#define see(x)
#endif
#define LSON(x) ((x)*2)
#define RSON(x) ((x)*2 + 1)
template <typename A, typename B> void Min(A &a, const B &b) {
if (b < a)
a = b;
}
template <typename A, typename B> void Max(A &a, const B &b) {
if (b > a)
a = b;
}
int cas;
ostream &kase() { return cout << "Case #" << ++cas << ": "; }
#if __cplusplus < 201402L
template <class Iterator>
std::reverse_iterator<Iterator> make_reverse_iterator(Iterator it) {
return std::reverse_iterator<Iterator>(it);
}
#endif
template <typename iter_t> struct iter_pair {
iter_t _beg, _end;
iter_t begin() { return _beg; }
iter_t end() { return _end; }
};
template <class cont>
iter_pair<reverse_iterator<decltype(begin(declval<cont>()))>>
reverse(cont &&r) {
return {make_reverse_iterator(end(r)), make_reverse_iterator(begin(r))};
}
template <typename T> void dprintln(const T &t) {
cout << t << endl;
} // for debug use
template <typename T, typename... Args>
void dprintln(const T &t, const Args &...rest) {
cout << t << ' ';
dprintln(rest...);
}
template <typename T> void println(const T &t) { cout << t << '\n'; }
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
cout << t << ' ';
println(rest...);
}
template <typename T> void println(const vector<T> &vec) {
if (!vec.empty()) {
cout << vec[0];
for (size_t i = 1; i < vec.size(); ++i)
cout << ' ' << vec[i];
}
cout << endl;
}
template <typename T> void print(const T &t) { cout << t << ' '; }
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
cout << t << ' ';
print(rest...);
}
// this overload is chosen when there's only one argument
template <class T> void scan(T &t) { cin >> t; }
template <class T, class... Args> void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
template <typename T> void scan(vector<T> &vec) {
for (T &x : vec)
scan(x);
}
using ull = unsigned long long;
using ll = long long;
using ul = unsigned long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int, int>;
using pip = pair<int, pii>;
using pll = pair<ll, ll>;
using vb = vector<bool>;
using vpii = vector<pii>;
using ldb = long double;
template <typename int_t> inline int_t lowbit(int_t x) { return x & -x; }
#define rng(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define up(i, a, b) for (int i = int(a); i <= int(b); ++i)
#define down(i, b, a) for (int i = int(b); i >= int(a); i--)
#define rep(n) for (int i##n = 0, _##n = (int)n; i##n < _##n; i##n++)
#define stp(i, a, b, c) for (int i = (a); i < (b); i += (c))
#define FOR(x, cont) for (const auto &x : cont)
#define INC(init, x, y) for (init; x <= y; ++x)
#define For(x, cont) for (auto &x : cont)
#define all(x) begin(x), end(x)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define SZ(x) (int)(x).size()
#define UP(i, l, r) for (i = decltype(i)(l); i <= decltype(i)(r); ++i)
#define DOWN(i, r, l) for (i = decltype(i)(r); i >= decltype(i)(l); --i)
#define Dec(a, b) for (; a >= b; --a)
template <typename T, typename Comp = less<T>>
using pq = priority_queue<T, vector<T>, Comp>;
#define popcnt(x) __builtin_popcountll((x))
#define SET(arr, v) memset(arr, (v), sizeof(arr))
#define UNIQ(vec) (vec).erase(unique(all(vec)), end(vec))
#define LB(cont, x) int(lower_bound(all(cont), x) - begin(cont))
#define UB(cont, x) int(upper_bound(all(cont), x) - begin(cont))
#define AI(name, n, m) vv<int> name(n, vi(m));
#define AL(name, n, m) vv<ll> name(size_t(n), vl(size_t(m)));
#define set0(arr) memset(arr, 0, sizeof arr)
#define set1(arr) memset(arr, -1, sizeof arr)
#define AT(T, n, m, a) vector<vector<T>> a(n, vector<T>(m))
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
auto bet = [](const ll x, const ll y, const ll i) { return x <= i && i <= y; };
template <typename T1, typename T2>
T1 ceil(T1 x, T2 y) { // y >= 1，是整数。需要注意 x + y - 1 是否会溢出
return (x + y - 1) / y;
}
inline int h_bit(unsigned long long x) {
return sizeof(unsigned long long) * 8 - 1 - __builtin_clzll(x);
}
int pow2(int x) { // power of 2
return 1 << (h_bit((ull)x) + (x != lowbit(x)));
}
template <typename T> struct bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(bin_op), init(init) {
a.assign(n + 1, init);
}
T prefix(T x) {
auto res = init;
while (x) {
res = bin_op(a[x], res);
x -= x & -x;
}
return res;
}
void modify(int x, T v) {
while (x < (int)a.size()) {
a[x] = bin_op(a[x], v);
x += x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
template <typename T> struct r_bit {
vector<T> a;
function<T(T, T)> bin_op;
const T init;
explicit r_bit(int n, function<T(T, T)> bin_op, T init)
: bin_op(move(bin_op)), init(init) {
a.ssign(n + 1, init);
}
T suffix(int x) {
T res = init;
while (x < SZ(a)) {
res = bin_op(res, a[x]);
x += x & -x;
}
return res;
}
void modify(int x, T v) {
while (x > 0) {
a[x] = bin_op(a[x], v);
x -= x & -x;
}
}
void clear() { fill(a.begin(), a.end(), init); }
};
vi get_prime(int n) {
vi minp((ul)n + 1), p;
for (int i = 2; i <= n; i++) {
if (!minp[i]) {
minp[i] = i;
p.pb(i);
}
FOR(x, p) {
if (x <= minp[i] && x * i <= n)
minp[x * i] = x;
else
break;
}
}
return p;
}
// alias templates
template <typename T> using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1> using vp = vector<pair<T1, T2>>;
template <typename T, int n> using va = vector<array<T, n>>;
// order_of_key (k) : Number of items strictly smaller than k .
// find_by_order(k) : K-th element in a set (counting from zero).
#ifdef __GNUC__
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <typename T>
using rank_tree =
__gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update>;
#endif
// union-find 并查集
struct UF {
vi par, sz;
int n_tree;
explicit UF(int n) { // 0-indexed
par.assign(n, 0);
sz.assign(n, 1);
rng(i, 0, n) par[i] = i;
n_tree = n;
}
int n_cluster() const { return n_tree; }
int size(int x) { return sz[root(x)]; }
int root(int x) { return x == par[x] ? x : par[x] = root(par[x]); }
bool unite(int x, int y) {
int rx = root(x), ry = root(y);
if (rx != ry) {
par[rx] = ry;
--n_tree;
sz[ry] += sz[rx];
return true;
}
return false;
}
};
template <typename T, typename Compare = std::less<T>> struct SparseTable {
size_t n{}; // 0-indexed
vv<T> a;
template <typename ptr_t> SparseTable(ptr_t beg, ptr_t end) : n(end - beg) {
a.resize((size_t)h_bit(n) + 1); // 注意：不能写成 h_bit(n)
a[0].assign(beg, end);
rng(i, 0, SZ(a) - 1) {
a[i + 1].resize(n);
rng(j, 0, n - (1u << i)) {
a[i + 1][j] = min(a[i][j], a[i][j + (1u << i)], Compare());
}
rng(j, n - (1u << i), n) { a[i + 1][j] = a[i][j]; }
}
}
using idx_t = long;
T query(idx_t l, idx_t r) { // l <= r
int i = h_bit(r - l + 1ul);
return min(a[i][l], a[i][r + 1 - (1u << i)], Compare());
}
};
vi get_popcnt(int n) {
vi res((ul)n + 1);
rng(i, 0, n) {
if (i * 2 <= n)
res[i * 2] = res[i];
if ((i & 1) == 0)
res[i + 1] = res[i] + 1;
}
return res;
}
vi get_mu(int n) {
assert(n > 0);
vi mu(n + 1);
vi min_p(n + 1);
vi prime;
mu[1] = 1;
rng(i, 2, n + 1) {
if (!min_p[i]) {
prime.pb(i);
min_p[i] = i;
mu[i] = -1;
}
FOR(p, prime) {
if (p > min_p[i]) {
break;
}
int t = p * i;
if (t > n)
break;
min_p[t] = p;
mu[t] = p == min_p[i] ? 0 : -mu[i];
}
}
return mu;
}
template <typename num> num fp(num x, ll n) { // fast power: hat off to quailty
if (n < 0) {
x = fp(x, mod - 2);
n = -n;
}
num ans = 1;
while (n) {
if (n & 1)
ans *= x;
n /= 2;
x *= x;
}
return ans;
}
template <typename num> void bit_reverse_swap(vector<num> &a) {
int n = SZ(a);
for (int i = 1, j = n >> 1, k; i < n - 1; i++) {
if (i < j)
swap(a[i], a[j]);
// tricky
for (k = n >> 1; j >= k; j -= k, k >>= 1)
; // inspect the highest "1"
j += k;
}
}
template <typename num> void FFT(vector<num> &a, int type) {
bit_reverse_swap(a);
int n = SZ(a);
for (int i = 2; i <= n; i *= 2) {
const auto wi = fp(3, type * (mod - 1) / i); // i次单位根
for (int j = 0; j < n; j += i) {
num w(1);
for (int k = j, h = i >> 1; k < j + h; k++) {
auto t = w * a[k + h], u = a[k];
a[k] = u + t;
a[k + h] = u - t;
w *= wi;
}
}
}
const auto inv = num(n).inv();
if (type == -1)
for (auto &x : a)
x *= inv;
}
template <typename num> void fp(vector<num> &a, const int n) {
a.resize((ul)pow2((SZ(a) - 1) * n + 1));
FFT(a, 1);
for (auto &x : a)
x = fp(x, n);
FFT(a, -1);
}
// DEBUG code by tourist
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// end DEBUG
// minimal geometry classes
struct point {
int x, y;
void read() { scan(x, y); }
ll cross(const point &b) const { return 1LL * x * b.y - 1LL * y * b.x; }
point operator-(const point &b) const { return {x - b.x, y - b.y}; }
bool para(const point &b) const { // parallel
return 1LL * x * b.y == 1LL * y * b.x;
}
bool operator<(const point &b) const { return cross(b) < 0; }
};
struct segment {
point p, dir;
bool on_same_line(const segment &other) const {
return dir.para(other.dir) && (p - other.p).para(dir);
}
bool para(const segment &b) const { return dir.para(b.dir); }
bool operator==(const segment &b) const { return this->on_same_line(b); }
};
struct fraction {
int n, d;
bool operator<(const fraction &that) const {
return 1LL * n * that.d < 1LL * that.n * d;
}
bool operator==(const fraction &that) const {
return n == that.n && d == that.d;
}
bool operator>=(const fraction &that) const { return !(*this < that); }
bool operator>(const fraction &that) const {
return 1LL * n * that.d > 1LL * that.n * d;
}
fraction inverse() const { return n < 0 ? fraction{-d, -n} : fraction{d, n}; }
fraction(int n, int d) {
if (d < 0)
n = -n, d = -d;
int g = __gcd(abs(n), d);
n /= g, d /= g;
this->n = n, this->d = d;
}
explicit fraction(int x) : n(x), d(1) {}
fraction operator+(const fraction &that) const {
return fraction{n * that.d + that.n * d, d * that.d};
}
fraction operator-(const fraction &that) const {
return fraction{n * that.d - that.n * d, d * that.d};
}
fraction floor() const {
if (d == 0)
return *this;
return fraction((n < 0 ? n - (d - 1) : n) / d);
}
friend ostream &operator<<(ostream &out, const fraction &f) {
return out << "(" << f.n << ',' << f.d << ')';
}
pii to_pair() const { return {n, d}; }
};
using Num = modnum<mod>;
struct comb {
vector<Num> f;
explicit comb(int n) {
f.resize(n + 1);
f[0] = 1;
up(i, 1, n) f[i] = f[i - 1] * i;
}
Num get(int x, int y) const {
assert(x <= SZ(f) - 1);
assert(x >= 0 && y >= 0);
if (x < y)
return 0;
return f[x] / f[y] / f[x - y];
}
};
// BEGIN 树剖模板
namespace HLD {
const int max_V = 1e5 + 5;
vi g[max_V]; // vertices are 1-indexed
int fa[max_V];
int sz[max_V];
int heavy_son[max_V];
int dep[max_V];
void dfs(int u, int f) {
fa[u] = f;
sz[u] = 1;
dep[u] = dep[f] + 1;
int hson = 0;
FOR(v, g[u]) {
if (v != f) {
dfs(v, u);
sz[u] += sz[v];
if (sz[v] > sz[hson])
hson = v;
}
}
heavy_son[u] = hson;
}
int top[max_V];
int pos[max_V]; // 0-indexed
// https://codeforces.com/blog/entry/22072
void init(int n) { // 很好的写法！
int idx = 0;
rng(i, 1, n + 1) {
if (i != heavy_son[fa[i]]) {
for (int j = i; j != 0; j = heavy_son[j]) {
top[j] = i;
pos[j] = idx++;
}
}
}
}
// 两种情况：1.修改路径上的边 2.修改路径上的点。
bool VALUE_ON_EDGE = true;
// BinOpr: binary operator
template <class BinOpr> void process_path(int u, int v, BinOpr op) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]])
swap(u, v);
op(pos[top[u]], pos[u]);
u = fa[top[u]];
}
if (dep[u] > dep[v])
swap(u, v);
op(pos[u] + VALUE_ON_EDGE, pos[v]);
}
} // namespace HLD
// END 树剖模板
template <typename T> T get_mid(T l, T r) {
assert(l <= r);
return l + (r - l) / 2;
}
//////////////////^"^///////////////////////////////////
int p[60];
// l = 0, r = x 的情形。
// 高于 y 的位上都是0
int calc(ll x, int y) {
int ans = 0;
int prod = 1;
down(i, y, 0) {
if (x & 1ULL << i) {
ans += (ll)prod * p[i] % mod;
ans %= mod;
prod *= 2;
prod %= mod;
}
}
return (ans + prod) % mod;
}
map<pair<ll, ll>, ll> mem;
ll solve(ll l, ll r, int i) {
// (x, y) x >= l && y <= r && x <= y && (y ^ x) == y - x
if (l == r)
return 1;
if (l == 0)
return calc(r, i);
// l < r
// 1,1
if (l & 1ULL << i) {
return solve(l - (1ULL << i), r - (1ULL << i), i - 1);
}
// 0,0
if ((r & 1ULL << i) == 0) { // 亦可写成 if (r < (1 << i))
return solve(l, r, i - 1);
}
auto iter = mem.find({l, r});
if (iter != mem.end()) {
return iter->second;
}
// 1,0
ll mask = (1ULL << i) - 1;
ll res = 0;
if (l <= (r & mask))
res += solve(l, r & mask, i - 1);
res += solve(l, mask, i - 1);
res += solve(0, r & mask, i - 1);
res %= mod;
mem[{l, r}] = res;
return res;
}
int main() {
FAST_READ
cout << fixed << setprecision(10);
#ifdef LOCAL
ifstream in("main.in");
cin.rdbuf(in.rdbuf());
// ofstream out("main.out");
// cout.rdbuf(out.rdbuf());
#endif
p[0] = 1;
for (int i = 1; i < 60; i++) {
p[i] = p[i - 1] * 3LL % mod;
}
ll l, r;
scan(l, r);
ll ans = 0;
down(i, 59, 0) {
ll L = 1LL << i, R = 2 * L - 1;
L = max(L, l);
R = min(R, r);
if (L > R)
continue;
ans += solve(L, R, i);
ans %= mod;
}
println(ans);
#ifdef LOCAL
cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
[
"literal.number.type.widen.change"
] | 741,192
| 741,191
|
u799051262
|
cpp
|
p02938
|
#include <iostream>
#include <vector>
using lli = long long int;
const lli mod = 1000000007;
struct ds {
lli data[4];
ds() : data{} {}
lli get(bool y, bool x) { return data[y * 2 + x]; }
};
int main() {
lli L, R;
std::cin >> L >> R;
lli dp[62][4] = {};
lli di = 1LL << 60;
bool t0 = true, t1 = true;
for (int i = 60; i >= 0; i--) {
if (t0) {
if (R & di) {
t0 = false;
if (L & di) {
t1 = false;
dp[i][0] += 1;
} else {
dp[i][1] += 1;
}
}
di >>= 1;
continue;
}
if (t1) {
if (L & di) {
t1 = false;
dp[i][2] += 1;
} else {
dp[i][3] += 1;
}
}
dp[i][1] += dp[i + 1][1];
dp[i][2] += dp[i + 1][2];
dp[i][3] += 3 * dp[i + 1][3];
if (R & di) {
dp[i][1] += dp[i + 1][1];
dp[i][3] += dp[i + 1][1];
}
if ((L & di) == 0) {
dp[i][2] += dp[i + 1][2];
dp[i][3] += dp[i + 1][2];
}
if ((R & di) && (L & di) == 0) {
dp[i][1] += dp[i + 1][0];
dp[i][2] += dp[i + 1][0];
}
if ((R & di) || (L & di) == 0) {
dp[i][0] += dp[i + 1][0];
}
dp[i][0] %= mod;
dp[i][1] %= mod;
dp[i][2] %= mod;
dp[i][3] %= mod;
di >>= 1;
}
std::cout << dp[0][0] + dp[0][1] + dp[0][2] + dp[0][3] << std::endl;
return 0;
}
|
#include <iostream>
#include <vector>
using lli = long long int;
const lli mod = 1000000007;
struct ds {
lli data[4];
ds() : data{} {}
lli get(bool y, bool x) { return data[y * 2 + x]; }
};
int main() {
lli L, R;
std::cin >> L >> R;
lli dp[62][4] = {};
lli di = 1LL << 60;
bool t0 = true, t1 = true;
for (int i = 60; i >= 0; i--) {
if (t0) {
if (R & di) {
t0 = false;
if (L & di) {
t1 = false;
dp[i][0] += 1;
} else {
dp[i][1] += 1;
}
}
di >>= 1;
continue;
}
if (t1) {
if (L & di) {
t1 = false;
dp[i][2] += 1;
} else {
dp[i][3] += 1;
}
}
dp[i][1] += dp[i + 1][1];
dp[i][2] += dp[i + 1][2];
dp[i][3] += 3 * dp[i + 1][3];
if (R & di) {
dp[i][1] += dp[i + 1][1];
dp[i][3] += dp[i + 1][1];
}
if ((L & di) == 0) {
dp[i][2] += dp[i + 1][2];
dp[i][3] += dp[i + 1][2];
}
if ((R & di) && (L & di) == 0) {
dp[i][1] += dp[i + 1][0];
dp[i][2] += dp[i + 1][0];
}
if ((R & di) || (L & di) == 0) {
dp[i][0] += dp[i + 1][0];
}
dp[i][0] %= mod;
dp[i][1] %= mod;
dp[i][2] %= mod;
dp[i][3] %= mod;
di >>= 1;
}
std::cout << (dp[0][0] + dp[0][1] + dp[0][2] + dp[0][3]) % mod << std::endl;
return 0;
}
|
[
"expression.operation.binary.add"
] | 741,193
| 741,194
|
u301030835
|
cpp
|
p02938
|
// #include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
#define NIL -1
using namespace std;
typedef long long ll;
typedef long long int lli;
static const int MOD = 10000007;
static const int MAX = 100005;
// static const int NMAX = 5005;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
// typedef priority_queue<int, greater<int>> RevQ;
ll l, r;
// vector<ll> a(MAX);
mint dp[61][2][2][2];
int main() {
cin >> l >> r;
dp[60][0][0][0] = 1;
for (int i = 59; i >= 0; --i) {
int lb = (l >> i & 1);
int rb = (r >> i & 1);
rep(j, 2) rep(k, 2) rep(s, 2) {
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) {
int ns = s, nj = j, nk = k;
if (x && !y)
continue; // x = 1 && y = 0
if (x && y) { // x = y = 1 => ns =1
ns = 1; // s setting
}
if (!lb && x)
nj = 1;
if (!rb && y)
nk = 1;
if (!s && !x && y)
continue;
if (!j && !x && lb)
continue;
if (!k && y && !rb)
continue;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
}
/* standard input
19
strangexyxxorangexx
*/
|
// #include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
#define NIL -1
using namespace std;
typedef long long ll;
typedef long long int lli;
static const int MOD = 10000007;
static const int MAX = 100005;
// static const int NMAX = 5005;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
// typedef priority_queue<int, greater<int>> RevQ;
ll l, r;
// vector<ll> a(MAX);
mint dp[61][2][2][2];
int main() {
cin >> l >> r;
dp[60][0][0][0] = 1;
for (int i = 59; i >= 0; --i) {
int lb = (l >> i & 1);
int rb = (r >> i & 1);
rep(j, 2) rep(k, 2) rep(s, 2) {
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) {
int ns = s, nj = j, nk = k;
if (x && !y)
continue; // x = 1 && y = 0
if (x && y) { // x = y = 1 => ns =1
ns = 1; // s setting
}
if (!lb && x)
nj = 1; // x > L
if (rb && !y)
nk = 1; // y < R
if (!s && !x && y)
continue; // top like x = 0, y = 1
if (!j && !x && lb)
continue; // it turns out that x < L
if (!k && y && !rb)
continue; // it turns out that y > R
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
}
/* standard input
19
strangexyxxorangexx
*/
|
[
"expression.operation.unary.logical.remove",
"control_flow.branch.if.condition.change",
"expression.operation.unary.add"
] | 741,195
| 741,196
|
u833515223
|
cpp
|
p02938
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
mint dp[61][2][2][2];
int main() {
ll l, r;
cin >> l >> r;
dp[60][0][0][0] = 1;
// 10^^18は60桁くらい
for (int i = 59; i >= 0; i--) {
// 1桁目を取り出す
int lb = l >> i & 1;
int rb = r >> i & 1;
rep(j, 2) rep(k, 2) rep(s, 2) { // preの状態
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) {
if (x && !y)
continue; // x = 1, y = 0
int nj = j, nk = k, ns = ns; // nextの状態
if (!s && x != y)
continue;
if (x && y)
ns = 1;
// j: L <= X
if (!j && !x && lb)
continue;
if (x && !lb)
nj = 1;
// k: Y <= R
if (!k && y && !rb)
continue;
if (!y && rb)
nk = 1;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
mint dp[61][2][2][2];
int main() {
ll l, r;
cin >> l >> r;
dp[60][0][0][0] = 1;
// 10^^18は60桁くらい
for (int i = 59; i >= 0; i--) {
// 1桁目を取り出す
int lb = l >> i & 1;
int rb = r >> i & 1;
rep(j, 2) rep(k, 2) rep(s, 2) { // preの状態
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) {
if (x && !y)
continue; // x = 1, y = 0
int nj = j, nk = k, ns = s; // nextの状態
if (!s && x != y)
continue;
if (x && y)
ns = 1;
// j: L <= X
if (!j && !x && lb)
continue;
if (x && !lb)
nj = 1;
// k: Y <= R
if (!k && y && !rb)
continue;
if (!y && rb)
nk = 1;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
}
|
[
"variable_declaration.value.change",
"identifier.change"
] | 741,197
| 741,198
|
u455366471
|
cpp
|
p02938
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
mint dp[61][2][2][2];
int main() {
ll l, r;
cin >> l >> r;
dp[60][0][0][0] = 1;
// 10^^18は60桁くらい
for (int i = 59; i >= 0; i--) {
// 1桁目を取り出す
int lb = l >> i & 1;
int rb = r >> i & 1;
rep(j, 2) rep(k, 2) rep(s, 2) { // preの状態
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) {
if (x && !y)
continue; // x = 1, y = 0
int nj = j, nk = k, ns = ns; // nextの状態
if (!s && x != y)
continue;
if (x && y)
ns = 1;
// j: L <= X
if (!j && !x && lb == 1)
continue;
if (x && !lb)
nj = 1;
// k: Y <= R
if (!k && y && !rb)
continue;
if (!y && rb)
nk = 1;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
mint dp[61][2][2][2];
int main() {
ll l, r;
cin >> l >> r;
dp[60][0][0][0] = 1;
// 10^^18は60桁くらい
for (int i = 59; i >= 0; i--) {
// 1桁目を取り出す
int lb = l >> i & 1;
int rb = r >> i & 1;
rep(j, 2) rep(k, 2) rep(s, 2) { // preの状態
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) {
if (x && !y)
continue; // x = 1, y = 0
int nj = j, nk = k, ns = s; // nextの状態
if (!s && x != y)
continue;
if (x && y)
ns = 1;
// j: L <= X
if (!j && !x && lb)
continue;
if (x && !lb)
nj = 1;
// k: Y <= R
if (!k && y && !rb)
continue;
if (!y && rb)
nk = 1;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
}
|
[
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 741,199
| 741,198
|
u455366471
|
cpp
|
p02938
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
mint dp[61][2][2][2];
int main() {
ll l, r;
cin >> l >> r;
dp[60][0][0][0] = 1;
// 10^^18は60桁くらい
for (int i = 59; i >= 0; i--) {
// 1桁目を取り出す
int lb = l >> i & 1;
int rb = r >> i & 1;
rep(j, 2) rep(k, 2) rep(s, 2) { // preの状態
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) {
if (x && !y)
continue; // x = 1, y = 0
int nj = j, nk = k, ns = ns; // nextの状態
if (!s && x != y)
continue;
if (x && y)
ns = 1;
// j: L <= X
if (!j && !x && lb)
continue;
if (x && !lb)
nj = 1;
// k: Y <= R
if (!k && y && !rb)
continue;
if (!y && rb)
nk = 1;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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;
}
};
mint dp[61][2][2][2];
int main() {
ll l, r;
cin >> l >> r;
dp[60][0][0][0] = 1;
for (int i = 59; i >= 0; i--) {
int lb = l >> i & 1;
int rb = r >> i & 1;
rep(j, 2) rep(k, 2) rep(s, 2) { // mae no joutai
mint pre = dp[i + 1][j][k][s];
rep(x, 2) rep(y, 2) { // senni
if (x && !y)
continue; // x = 1, y = 0
int nj = j, nk = k, ns = s; // next no joutai
// tsugi dou naru?
if (!s && x != y)
continue;
if (x && y)
ns = 1;
// j: L <= X
if (!j && !x && lb)
continue;
if (x && !lb)
nj = 1;
// k: Y <= R
if (!k && y && !rb)
continue;
if (!y && rb)
nk = 1;
//
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
rep(j, 2) rep(k, 2) rep(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
return 0;
}
|
[
"variable_declaration.value.change",
"identifier.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 741,197
| 741,200
|
u455366471
|
cpp
|
p02938
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*
cout<<setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
*/
const llint mod = 1000000000;
const llint big = 2.19e15 + 1;
const long double pai = 3.141592653589793238462643383279502884197;
const long double eps = 1e-15;
template <class T, class U> bool mineq(T &a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool maxeq(T &a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
llint gcd(llint a, llint b) {
if (a % b == 0) {
return b;
} else
return gcd(b, a % b);
}
llint lcm(llint a, llint b) {
if (a == 0) {
return b;
}
return a / gcd(a, b) * b;
}
template <class T> void SO(T &ve) { sort(ve.begin(), ve.end()); }
template <class T> void REV(T &ve) { reverse(ve.begin(), ve.end()); }
template <class T> llint LBI(vector<T> &ar, T in) {
return lower_bound(ar.begin(), ar.end(), in) - ar.begin();
}
template <class T> llint UBI(vector<T> &ar, T in) {
return upper_bound(ar.begin(), ar.end(), in) - ar.begin();
}
#define ptr shared_ptr
// class some;
/*class hai{
public:
int siz;
ptr<some> num;
ptr<hai> hi,mg;
//sizはその要素のサイズを表す
//numはsizが1の時に入っている要素を表す
};*/
vector<string> codelines = {
"let next (@a (+ a 1))", "let prev (@a (- a 1))",
"let ha (@x (/ x 2 ))",
//"let ddde (ha 57)",
//"woutn ddde",
"let inclbit (@x @y "
"if y ("
"if ( > ( % x 2) ( % y 2 ) ) 0"
"( inclbit ( ha x )( ha y ) )"
") 1"
")",
"let stand (@x @y (% (/ x y) 2))", "winn L", "winn R",
"let count (@x @y @fxb @fyb "
"(% "
"(if ( max fxb fyb )( "
"if ( < fxb fyb ) ("
"* ( - 2 ( stand x fyb ) )"
"( count x y fxb (ha fyb) )"
")("
"if ( > fxb fyb ) "
"( "
"* ( + 1 ( stand y fxb ) ) "
"( count x y (ha fxb) fyb )"
")"
"(* 3 ( count x y (ha fxb) (ha fyb) ))"
")"
")( 1 ))"
" 1000000007)"
")",
"let countin (@x @y @fxb @fyb "
"if ("
"(@aa (inclbit (/ x aa) (/ y aa)))"
"(max (max (* x 2) (* y 2)) 1)"
") (count x y fxb fyb) 0"
")",
"let ikouone (@x @fb "
"if fb ("
"if (stand x fb)"
"(ikouone x (ha fb))"
"0"
") 1"
")",
"let countR (@x @y @fxb @fyb "
"if (ikouone y fyb) (countin x y fxb fyb)"
"("
"+"
"(if (stand y fyb) (countin x (- y fyb) fxb (ha fyb)) 0)"
"(countR x y fxb (ha fyb))"
")"
")",
"let ikouzro (@x @fb "
"if fb ("
"if (stand x fb)"
"0"
"(ikouzro x (ha fb))"
") 1"
")",
"let countLR (@x @y @fxb @fyb "
"if (ikouzro x fxb) (countR x y fxb fyb)"
"("
"+"
"(if (stand x fxb) 0 (countR (+ x fxb) y (ha fxb) fyb))"
"(countLR x y (ha fxb) fyb)"
")"
")",
"let solve (@x @y @now "
"if (< y now) 0 ("
"+("
"if (< x (* now 2))"
"(countLR (max x now) (min y (prev(* now 2))) (ha now) (ha now))"
"(0)"
")(solve x y (* 2 now))"
")"
")",
"let ans (% (solve L R 1) 1000000007)", "woutn ans"};
class some {
public:
char enz; //どの演算を行いますか?
ptr<some> hi, mg;
llint ban;
bool syu;
bool ramukan; //ラムダの完結
some(void) {
ramukan = false;
syu = false;
enz = 'Q';
ban = 0;
}
// syukuがtrueなら縮約済み!やった!
};
ptr<some> hairead(ptr<some> in, int soe) {
ptr<some> gen = in->hi;
while (gen->enz == 'H') {
if (soe < gen->ban) {
gen = gen->hi;
} else {
soe -= gen->ban;
gen = gen->mg;
}
}
return gen;
}
ptr<some> haiwrite(ptr<some> in, int soe, ptr<some> suu) {
ptr<some> ata(new some());
ptr<some> gen(new some());
(*ata) = (*in);
(*gen) = (*(in->hi));
ata->hi = gen;
if (gen->enz != 'H') {
ata->hi = suu;
return ata;
}
while (-1) {
ptr<some> iti(new some());
if (soe < gen->ban) {
if (gen->hi->enz != 'H') {
gen->hi = suu;
return ata;
}
(*iti) = (*(gen->hi));
gen->hi = iti;
gen = iti;
} else {
if (gen->mg->enz != 'H') {
gen->mg = suu;
return ata;
}
soe -= gen->ban;
(*iti) = (*(gen->mg));
gen->mg = iti;
gen = iti;
}
}
};
ptr<some> sai_hai(int soe, ptr<some> suu) {
if (soe == 1) {
return suu;
}
ptr<some> ans(new some());
ans->enz = 'H';
ans->ban = soe / 2;
ans->hi = sai_hai(soe / 2, suu);
ans->mg = sai_hai((soe + 1) / 2, suu);
return ans;
}
ptr<some> make_hai(int soe, ptr<some> suu) {
ptr<some> ans(new some());
ans->enz = 'h';
ans->ban = soe;
if (soe > 0) {
ans->hi = sai_hai(soe, suu);
}
return ans;
}
ptr<some> unite_hai(ptr<some> v, ptr<some> w) {
if (v->ban == 0) {
return w;
}
if (w->ban == 0) {
return v;
}
ptr<some> ans(new some());
ptr<some> tgi(new some());
ans->enz = 'h';
ans->ban = v->ban + w->ban;
ans->hi = tgi;
tgi->enz = 'H';
tgi->ban = v->ban;
tgi->hi = v->hi;
tgi->mg = w->hi;
return ans;
}
// let束縛
string str;
int hibas = 0;
map<llint, ptr<some>> letnames;
vector<string> atnames;
const llint itmo = 2.19e16 + 13;
llint roll(string in) {
// cerr<<in;
llint ans = 0;
for (auto it : in) {
ans *= 100;
ans += it;
ans %= itmo;
}
// cerr<<" "<<ans<<endl;
return ans;
}
bool vach(char c) {
return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || (c == '_');
}
ptr<some> pasa(void) {
// cerr<<"hibas="<<hibas<<endl;
int scopename = 0;
//ラムダのスコープを探している
do {
hibas++;
} while (str[hibas] == ' ' || str[hibas] == '\t' || str[hibas] == '\n');
ptr<some> kan(new some());
while (str[hibas] == '@') {
//ラムダ
// kan->enz='@';
do {
hibas++;
} while (str[hibas] == ' ');
string itna;
while (vach(str[hibas])) {
itna.pub(str[hibas]);
hibas++;
}
while (str[hibas] == ' ') {
hibas++;
}
atnames.pub(itna);
// cerr<<itna<<endl;
scopename++;
// kan->hi=ptr<some>(new some());
// kan=kan->hi;
// cerr<<"de";
}
// cerr<<"de";
while (str[hibas] != ')') {
ptr<some> gen;
if (str[hibas] == '(') {
gen = pasa();
} else {
gen = ptr<some>(new some());
//ここで大量の場合分け?
string itna;
while (str[hibas] != ' ' && str[hibas] != '(' && str[hibas] != ')') {
itna.pub(str[hibas]);
hibas++;
}
while (str[hibas] == ' ') {
hibas++;
}
//ここで、各条件は絶対に被らない
if ('0' <= itna[0] && itna[0] <= '9') {
gen->enz = 'n';
gen->ban = 0;
for (auto it : itna) {
gen->ban *= 10;
gen->ban += it - '0';
}
} else if (itna == "+") {
gen->enz = '+';
} else if (itna == "-") {
gen->enz = '-';
} else if (itna == "*") {
gen->enz = '*';
} else if (itna == "/") {
gen->enz = '/';
} else if (itna == "%") {
gen->enz = '%';
} else if (itna == "max") {
gen->enz = 'o';
} else if (itna == "min") {
gen->enz = 'c';
} else if (itna == "<") {
gen->enz = '<';
} else if (itna == ">") {
gen->enz = '>';
} else if (itna == "vec" || itna == "vector") {
gen->enz = 'v';
} else if (itna == "uni" || itna == "union") {
gen->enz = 'u';
} else if (itna == "if") {
gen->enz = 'i';
} else if (itna == "jf") {
gen->enz = 'j';
} else if (itna == "for" || itna == "while") {
gen->enz = 'f';
} else if (itna == "[r]") {
gen->enz = 'r';
} else if (itna == "[w]") {
gen->enz = 'w';
} else if (itna == "{}") {
gen->enz = 'h';
gen->ban = 0;
} else if (itna == "siz") {
gen->enz = 'z';
} else if (itna == "lef") {
gen->enz = 'l';
} else if (itna == "rig") {
gen->enz = 'm';
} else {
bool atta = 0;
for (int i = 0; i < atnames.size(); i++) {
if (atnames[i] == itna) {
atta = 1;
gen->enz = '&';
gen->ban = atnames.size() - 1 - i;
}
}
if (!atta) {
gen->enz = '$';
gen->ban = roll(itna);
} //どこにもないので未使用のletが確定する
}
// cerr<<"itna="<<itna;
}
if (kan->enz == 'Q') {
(*kan) = (*gen);
} else {
// cerr<<"de";
ptr<some> ata(new some());
ata->hi = kan;
ata->mg = gen;
ata->enz = '#';
kan = ata;
}
}
ptr<some> ans = kan;
while (scopename--) {
ptr<some> ata(new some());
ata->enz = '@';
ata->hi = ans;
ans = ata;
atnames.pob();
}
do {
hibas++;
} while (str[hibas] == ' ');
return ans;
}
void letkai(ptr<some> in, bool aaa = 1) {
if ((!aaa) && in->ramukan) {
return;
}
if (in->enz == '#' || in->enz == '@') {
if (in->hi->enz == '$') {
if (letnames.count(in->hi->ban) == 0) {
cerr << "missed name find" << in->hi->ban << endl;
} else {
in->hi = letnames[in->hi->ban];
}
} else {
letkai(in->hi, 0);
}
}
if (in->enz == '#') {
if (in->mg->enz == '$') {
if (letnames.count(in->mg->ban) == 0) {
cerr << "missed name find" << in->mg->ban << endl;
} else {
in->mg = letnames[in->mg->ban];
}
} else {
letkai(in->mg, 0);
}
}
}
int tabu = 0;
void TS(void) {
for (int i = 0; i < tabu; i++) {
cout << " ";
}
}
void syutu(const ptr<some> in) {
cout << "{\n"; //}
tabu++;
if (in->enz == '@') { //らむだ
TS();
cout << "enz:@\n";
// TS();cout<<"arg :"<<in->ban<<endl;
TS();
cout << "arg:";
syutu(in->hi);
} else if (in->enz == '#') { //えんざん
TS();
cout << "enz:#\n";
TS();
cout << "arg :";
syutu(in->hi);
TS();
cout << "body:";
syutu(in->mg);
} else if (in->enz == '&') { //即値
TS();
cout << "enz:&\n";
TS();
cout << "arg :" << in->ban << endl;
} else if (in->enz == 'n') {
TS();
cout << "nut=" << in->ban << endl;
} else {
TS();
cout << "enz=" << in->enz << endl;
}
tabu--;
TS();
cout << "}\n"; //{
}
bool isoy(ptr<some> tai) {
return (tai != nullptr && (!tai->syu) &&
(tai->enz == '#' || tai->enz == '@'));
}
bool daishi(ptr<some> &tai, int num, ptr<some> &xca) {
// cerr<<"dai";
// syutu(tai);
if (tai->syu) {
return 0;
}
if (tai->ramukan) {
return 0;
}
bool hen = 0;
ptr<some> moto = tai;
ptr<some> iti(new some());
(*iti) = (*tai);
tai = iti;
tai->syu = 0;
if (tai->enz == '&' && tai->ban == num) {
tai = xca;
hen = 1;
} else if (tai->enz == '&' && tai->ban > num) {
tai->ban--;
hen = 1;
} else if (tai->enz == '@') {
hen |= daishi(tai->hi, num + 1, xca);
} else if (tai->enz == '#') {
hen |= daishi(tai->hi, num, xca);
hen |= daishi(tai->mg, num, xca);
}
if (hen) {
tai->syu = 0;
} else {
tai = moto;
}
return hen;
}
// dainyu(0,0,...)
void WA_RE(int in = -1333) {
cerr << "RE" << in;
exit(0);
}
void keisan(ptr<some> in) {
// cerr<<"sai";
if (in == nullptr || in->syu || in->enz != '#') {
return;
}
if (in->hi != nullptr && in->hi->enz == '$') {
exit(0);
}
// cerr<<"de "<<in->enz;
// syutu(in);
if (isoy(in->hi)) {
keisan(in->hi);
}
if (in->hi->enz == '@') {
// cerr<<"ramu";
keisan(in->mg);
ptr<some> xca = in->mg;
// syutu(xca);
ptr<some> tai = in->hi->hi;
daishi(tai, 0, xca);
(*in) = (*tai);
keisan(in);
return;
}
if (in->hi->enz == '1') {
if (isoy(in->mg)) {
keisan(in->mg);
}
in->enz = '3';
return;
} else if (in->hi->enz == '2') {
in->syu = 1;
in->enz = '4';
return;
} else if (in->hi->enz == '3') {
(*in) = (*(in->hi->mg));
return;
} else if (in->hi->enz == '4') {
if (isoy(in->mg)) {
keisan(in->mg);
}
(*in) = (*(in->mg));
return;
} else if (isoy(in->mg)) {
keisan(in->mg);
}
char hiz = in->hi->enz, mgz = in->mg->enz;
// cerr<<"himg="<<hiz<<mgz<<endl;
if (hiz == '#' || hiz == '@' || hiz == '&') {
in->syu = 1;
return;
}
if (mgz == 'n') {
bool yatta = 1;
// if(in->hi->enz=='*'&&in->mg->ban==2){cerr<<"hyo";}
switch (hiz) {
case '+':
in->enz = 'P';
in->ban = in->mg->ban;
break;
case 'P':
in->enz = 'n';
in->ban = in->hi->ban + in->mg->ban;
break;
case '-':
in->enz = 'M';
in->ban = in->mg->ban;
break;
case 'M':
in->enz = 'n';
in->ban = in->hi->ban - in->mg->ban;
break;
case '*':
in->enz = 'T';
in->ban = in->mg->ban;
break;
case 'T':
in->enz = 'n';
in->ban = in->hi->ban * in->mg->ban;
break;
case '/':
in->enz = 'D';
in->ban = in->mg->ban;
break;
case 'D':
in->enz = 'n';
in->ban = in->hi->ban / in->mg->ban;
break;
case '%':
in->enz = 'A';
in->ban = in->mg->ban;
break;
case 'A':
in->enz = 'n';
in->ban = in->hi->ban % in->mg->ban;
break;
case 'o':
in->enz = 'O';
in->ban = in->mg->ban;
break;
case 'O':
in->enz = 'n';
in->ban = max(in->hi->ban, in->mg->ban);
break;
case 'c':
in->enz = 'C';
in->ban = in->mg->ban;
break;
case 'C':
in->enz = 'n';
in->ban = min(in->hi->ban, in->mg->ban);
break;
case '<':
in->enz = 'S';
in->ban = in->mg->ban;
break;
case 'S':
in->enz = 'n';
in->ban = ((in->hi->ban < in->mg->ban) ? 1 : 0);
break;
case '>':
in->enz = 'B';
in->ban = in->mg->ban;
break;
case 'B':
in->enz = 'n';
in->ban = ((in->hi->ban > in->mg->ban) ? 1 : 0);
break;
default:
yatta = 0;
}
if (yatta) {
// cerr<<"ya";
in->hi = nullptr;
in->mg = nullptr;
in->syu = 1;
return;
}
}
if (in->enz != '#') {
in->hi = nullptr;
in->mg = nullptr;
} //計算を行ったので
if (hiz == 'v' && mgz == 'n') {
in->enz = 'V';
in->ban = in->mg->ban;
}
if (hiz == 'V') {
(*in) = (*make_hai(in->hi->ban, in->mg));
}
if (hiz == 'u' && mgz == 'h') {
in->enz = 'U';
in->hi = in->mg;
}
if (hiz == 'z') {
in->enz = 'n';
in->ban = in->mg->ban;
}
if (hiz == 'l') {
in->enz = 'h';
in->ban = in->mg->hi->ban;
in->hi = in->mg->hi->hi;
}
if (hiz == 'm') {
in->enz = 'h';
in->ban = in->mg->ban - in->mg->hi->ban;
in->hi = in->mg->hi->mg;
}
if (hiz == 'U' && mgz == 'h') {
(*in) = (*unite_hai(in->hi->hi, in->mg));
}
if (hiz == 'h') {
ptr<some> ata(new some());
ata->ban = 1;
ata->enz = 'h';
ata->hi = in->mg;
(*in) = *unite_hai(in->hi, ata);
}
if (hiz == 'r' && mgz == 'h') {
in->enz = 'R';
in->hi = in->mg;
}
if (hiz == 'R' && mgz == 'n') {
(*in) = (*hairead(in->hi->hi, in->mg->ban));
}
if (hiz == 'w' && mgz == 'h') {
in->enz = 'W';
in->hi = in->mg;
}
if (hiz == 'W' && mgz == 'n') {
in->enz = '=';
in->hi = in->hi->hi;
in->ban = in->mg->ban;
}
if (hiz == '=') {
(*in) = (*haiwrite(in->hi->hi, in->hi->ban, in->mg));
}
if (hiz == 'i' && mgz == 'n') {
in->enz = ((in->mg->ban) ? '1' : '2');
}
if (hiz == 'j' && mgz == 'n') {
in->enz = ((in->mg->ban < 0) ? '1' : '2');
}
in->syu = 1;
return;
}
#include <sstream>
int main(void) {
for (auto code : codelines) {
std::istringstream stm(code);
string mei;
stm >> mei;
if (mei == "winn") {
string na;
stm >> na;
llint kaz;
cin >> kaz;
llint rollname = roll(na);
ptr<some> soku(new some());
soku->enz = 'n';
soku->ban = kaz;
letnames[rollname] = soku;
}
if (mei == "winh") {
string na;
stm >> na; //名前
string enu;
stm >> enu;
for (auto it : letnames) {
letkai(it.sec);
}
ptr<some> terget = letnames[roll(enu)];
keisan(terget);
llint size = 0;
if (terget->enz == 'n') {
size = terget->ban;
} else {
cout << "era-" << endl;
}
//ここで入力量を決める
ptr<some> zro(new some());
zro->enz = 'n';
zro->ban = 0;
ptr<some> haso(make_hai(size, zro));
for (int i = 0; i < size; i++) {
ptr<some> soku(new some());
soku->enz = 'n';
cin >> soku->ban;
haso = haiwrite(haso, i, soku);
}
letnames[roll(na)] = haso;
}
if (mei == "wins") {
string na;
stm >> na; //名前
string nyu;
cin >> nyu;
int size = nyu.size();
ptr<some> zro(new some());
zro->enz = 'n';
zro->ban = 0;
ptr<some> haso(make_hai(size, zro));
for (int i = 0; i < size; i++) {
ptr<some> soku(new some());
soku->enz = 'n';
soku->ban = nyu[i];
haso = haiwrite(haso, i, soku);
}
letnames[roll(na)] = haso;
}
if (mei == "let") {
string na;
stm >> na;
getline(stm, str);
hibas = 0;
while (str[hibas] == ' ') {
hibas++;
}
if (letnames.count(roll(na))) {
cout << "namaenosyoutotu" << endl;
}
letnames[roll(na)] = pasa();
letnames[roll(na)]->ramukan = 1;
}
if (mei == "woutn") {
string na;
stm >> na;
// let名前解決する
for (auto it : letnames) {
letkai(it.sec);
}
// syutu(letnames[roll(na)]);
ptr<some> terget = letnames[roll(na)];
keisan(terget);
if (terget->enz == 'n') {
cout << terget->ban << endl;
} else {
syutu(terget);
cerr << "erra-" << terget->enz << endl;
}
}
if (mei == "wouth") {
string na;
stm >> na;
for (auto it : letnames) {
letkai(it.sec);
}
ptr<some> terget = letnames[roll(na)];
keisan(terget);
if (terget->enz == 'h') {
for (int i = 0; i < terget->ban; i++) {
cout << hairead(terget, i)->ban << endl;
}
} else {
cerr << "ella-" << terget->enz << endl;
}
}
if (mei == "wouts") {
string na;
stm >> na;
for (auto it : letnames) {
letkai(it.sec);
}
ptr<some> terget = letnames[roll(na)];
keisan(terget);
if (terget->enz == 'h') {
for (int i = 0; i < terget->ban; i++) {
cout << (char)(hairead(terget, i)->ban);
}
cout << endl;
} else {
cerr << "ela-" << terget->enz << endl;
}
}
if (mei == "end") {
return 0;
}
}
return 0;
}
/*
2019
やりたいこと
高速化
わかりやすさ強化
関数一覧
(itna=="+"){gen->enz='+';}
else if(itna=="-"){gen->enz='-';}
else if(itna=="*"){gen->enz='*';}
else if(itna=="/"){gen->enz='/';}
else if(itna=="%"){gen->enz='%';}
else if(itna=="max"){gen->enz='o';}
else if(itna=="min"){gen->enz='c';}
else if(itna=="<"){gen->enz='<';}
else if(itna==">"){gen->enz='>';}
else if(itna=="vec"||itna=="vector"){gen->enz='v';}
else if(itna=="uni"||itna=="union"){gen->enz='u';}
else if(itna=="if"){gen->enz='i';}
else if(itna=="jf"){gen->enz='j';}
else if(itna=="for"||itna=="while"){gen->enz='f';}
else if(itna=="[r]"){gen->enz='r';}
else if(itna=="[w]"){gen->enz='w';}
else if(itna=="{}"){gen->enz='h';gen->ban=0;}
実装したいもの
double型の実装
nut @a @b (a(a(a(b))))//チャーチ数として処理する
やっぱり数字をプログラム中に入出力したい
3
2
3 4
1
2
4
3 4 5
このままだとこれみたいな入力形式に対応できない
ptinput @a (aはnut)入力を受け取る番号
doinput @a 内部のptinputが含まれる関数をすべて展開して、
実際に入力する 内部にptinputが含まれる関数は、関数を深く複製しなければいけない。
doinputによる入力は、一回しかされない。
doinputをしたら、ptinput関数が全て入力された値に置き換わる
let tukeru
let myin pic0
let watle ((ptoutput 1)(* 2 (ptinput 1)))
let in1 out1 (10 watle)
??よくわからん
vectorのnlognソートってできたっけ?
とりあえずクイックソート
winn n
winh hai
let next (@a (+ a 1))
let prev (@a (- a 1))
let aswap (@ary @a @b ([w] ([w] ary a ([r] ary b)) b ([r] ary a)))
let part (@ary @st @en
if (- st en)
(
if (< ([r] ary st) ([r] ary (pone st)))
(part (aswap ary (next st) en ) st (prev en))
(part (aswap ary st (next st) ) (next st) en)
)
({} ary st)
)
//パーティションして、tuple(ソート済みアレイ、最後の場所) を返します
let quick (@ary @st @en
if (-st en)
(
(@in (quick (quick ([w] in 0) st (prev([w] in 1)) ) (next ([w]
in 1)) en )) (part ary st en)
)
(ary)
)
let ans (quick hai 0 (prev n))
wouth ans
*/
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*
cout<<setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
*/
const llint mod = 1000000000;
const llint big = 2.19e15 + 1;
const long double pai = 3.141592653589793238462643383279502884197;
const long double eps = 1e-15;
template <class T, class U> bool mineq(T &a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool maxeq(T &a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
llint gcd(llint a, llint b) {
if (a % b == 0) {
return b;
} else
return gcd(b, a % b);
}
llint lcm(llint a, llint b) {
if (a == 0) {
return b;
}
return a / gcd(a, b) * b;
}
template <class T> void SO(T &ve) { sort(ve.begin(), ve.end()); }
template <class T> void REV(T &ve) { reverse(ve.begin(), ve.end()); }
template <class T> llint LBI(vector<T> &ar, T in) {
return lower_bound(ar.begin(), ar.end(), in) - ar.begin();
}
template <class T> llint UBI(vector<T> &ar, T in) {
return upper_bound(ar.begin(), ar.end(), in) - ar.begin();
}
#define ptr shared_ptr
// class some;
/*class hai{
public:
int siz;
ptr<some> num;
ptr<hai> hi,mg;
//sizはその要素のサイズを表す
//numはsizが1の時に入っている要素を表す
};*/
vector<string> codelines = {
"let next (@a (+ a 1))", "let prev (@a (- a 1))",
"let ha (@x (/ x 2 ))",
//"let ddde (ha 57)",
//"woutn ddde",
"let inclbit (@x @y "
"if y ("
"if ( > ( % x 2) ( % y 2 ) ) 0"
"( inclbit ( ha x )( ha y ) )"
") 1"
")",
"let stand (@x @y (% (/ x y) 2))", "winn L", "winn R",
"let count (@x @y @fxb @fyb "
"(% "
"(if ( max fxb fyb )( "
"if ( < fxb fyb ) ("
"* ( - 2 ( stand x fyb ) )"
"( count x y fxb (ha fyb) )"
")("
"if ( > fxb fyb ) "
"( "
"* ( + 1 ( stand y fxb ) ) "
"( count x y (ha fxb) fyb )"
")"
"(* 3 ( count x y (ha fxb) (ha fyb) ))"
")"
")( 1 ))"
" 1000000007)"
")",
"let countin (@x @y @fxb @fyb "
"if ("
"(@aa (inclbit (/ x aa) (/ y aa)))"
"(max (max (* fxb 2) (* fyb 2)) 1)"
") (count x y fxb fyb) 0"
")",
"let ikouone (@x @fb "
"if fb ("
"if (stand x fb)"
"(ikouone x (ha fb))"
"0"
") 1"
")",
"let countR (@x @y @fxb @fyb "
"if (ikouone y fyb) (countin x y fxb fyb)"
"("
"+"
"(if (stand y fyb) (countin x (- y fyb) fxb (ha fyb)) 0)"
"(countR x y fxb (ha fyb))"
")"
")",
"let ikouzro (@x @fb "
"if fb ("
"if (stand x fb)"
"0"
"(ikouzro x (ha fb))"
") 1"
")",
"let countLR (@x @y @fxb @fyb "
"if (ikouzro x fxb) (countR x y fxb fyb)"
"("
"+"
"(if (stand x fxb) 0 (countR (+ x fxb) y (ha fxb) fyb))"
"(countLR x y (ha fxb) fyb)"
")"
")",
"let solve (@x @y @now "
"if (< y now) 0 ("
"+("
"if (< x (* now 2))"
"(countLR (max x now) (min y (prev(* now 2))) (ha now) (ha now))"
"(0)"
")(solve x y (* 2 now))"
")"
")",
"let ans (% (solve L R 1) 1000000007)", "woutn ans"};
class some {
public:
char enz; //どの演算を行いますか?
ptr<some> hi, mg;
llint ban;
bool syu;
bool ramukan; //ラムダの完結
some(void) {
ramukan = false;
syu = false;
enz = 'Q';
ban = 0;
}
// syukuがtrueなら縮約済み!やった!
};
ptr<some> hairead(ptr<some> in, int soe) {
ptr<some> gen = in->hi;
while (gen->enz == 'H') {
if (soe < gen->ban) {
gen = gen->hi;
} else {
soe -= gen->ban;
gen = gen->mg;
}
}
return gen;
}
ptr<some> haiwrite(ptr<some> in, int soe, ptr<some> suu) {
ptr<some> ata(new some());
ptr<some> gen(new some());
(*ata) = (*in);
(*gen) = (*(in->hi));
ata->hi = gen;
if (gen->enz != 'H') {
ata->hi = suu;
return ata;
}
while (-1) {
ptr<some> iti(new some());
if (soe < gen->ban) {
if (gen->hi->enz != 'H') {
gen->hi = suu;
return ata;
}
(*iti) = (*(gen->hi));
gen->hi = iti;
gen = iti;
} else {
if (gen->mg->enz != 'H') {
gen->mg = suu;
return ata;
}
soe -= gen->ban;
(*iti) = (*(gen->mg));
gen->mg = iti;
gen = iti;
}
}
};
ptr<some> sai_hai(int soe, ptr<some> suu) {
if (soe == 1) {
return suu;
}
ptr<some> ans(new some());
ans->enz = 'H';
ans->ban = soe / 2;
ans->hi = sai_hai(soe / 2, suu);
ans->mg = sai_hai((soe + 1) / 2, suu);
return ans;
}
ptr<some> make_hai(int soe, ptr<some> suu) {
ptr<some> ans(new some());
ans->enz = 'h';
ans->ban = soe;
if (soe > 0) {
ans->hi = sai_hai(soe, suu);
}
return ans;
}
ptr<some> unite_hai(ptr<some> v, ptr<some> w) {
if (v->ban == 0) {
return w;
}
if (w->ban == 0) {
return v;
}
ptr<some> ans(new some());
ptr<some> tgi(new some());
ans->enz = 'h';
ans->ban = v->ban + w->ban;
ans->hi = tgi;
tgi->enz = 'H';
tgi->ban = v->ban;
tgi->hi = v->hi;
tgi->mg = w->hi;
return ans;
}
// let束縛
string str;
int hibas = 0;
map<llint, ptr<some>> letnames;
vector<string> atnames;
const llint itmo = 2.19e16 + 13;
llint roll(string in) {
// cerr<<in;
llint ans = 0;
for (auto it : in) {
ans *= 100;
ans += it;
ans %= itmo;
}
// cerr<<" "<<ans<<endl;
return ans;
}
bool vach(char c) {
return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || (c == '_');
}
ptr<some> pasa(void) {
// cerr<<"hibas="<<hibas<<endl;
int scopename = 0;
//ラムダのスコープを探している
do {
hibas++;
} while (str[hibas] == ' ' || str[hibas] == '\t' || str[hibas] == '\n');
ptr<some> kan(new some());
while (str[hibas] == '@') {
//ラムダ
// kan->enz='@';
do {
hibas++;
} while (str[hibas] == ' ');
string itna;
while (vach(str[hibas])) {
itna.pub(str[hibas]);
hibas++;
}
while (str[hibas] == ' ') {
hibas++;
}
atnames.pub(itna);
// cerr<<itna<<endl;
scopename++;
// kan->hi=ptr<some>(new some());
// kan=kan->hi;
// cerr<<"de";
}
// cerr<<"de";
while (str[hibas] != ')') {
ptr<some> gen;
if (str[hibas] == '(') {
gen = pasa();
} else {
gen = ptr<some>(new some());
//ここで大量の場合分け?
string itna;
while (str[hibas] != ' ' && str[hibas] != '(' && str[hibas] != ')') {
itna.pub(str[hibas]);
hibas++;
}
while (str[hibas] == ' ') {
hibas++;
}
//ここで、各条件は絶対に被らない
if ('0' <= itna[0] && itna[0] <= '9') {
gen->enz = 'n';
gen->ban = 0;
for (auto it : itna) {
gen->ban *= 10;
gen->ban += it - '0';
}
} else if (itna == "+") {
gen->enz = '+';
} else if (itna == "-") {
gen->enz = '-';
} else if (itna == "*") {
gen->enz = '*';
} else if (itna == "/") {
gen->enz = '/';
} else if (itna == "%") {
gen->enz = '%';
} else if (itna == "max") {
gen->enz = 'o';
} else if (itna == "min") {
gen->enz = 'c';
} else if (itna == "<") {
gen->enz = '<';
} else if (itna == ">") {
gen->enz = '>';
} else if (itna == "vec" || itna == "vector") {
gen->enz = 'v';
} else if (itna == "uni" || itna == "union") {
gen->enz = 'u';
} else if (itna == "if") {
gen->enz = 'i';
} else if (itna == "jf") {
gen->enz = 'j';
} else if (itna == "for" || itna == "while") {
gen->enz = 'f';
} else if (itna == "[r]") {
gen->enz = 'r';
} else if (itna == "[w]") {
gen->enz = 'w';
} else if (itna == "{}") {
gen->enz = 'h';
gen->ban = 0;
} else if (itna == "siz") {
gen->enz = 'z';
} else if (itna == "lef") {
gen->enz = 'l';
} else if (itna == "rig") {
gen->enz = 'm';
} else {
bool atta = 0;
for (int i = 0; i < atnames.size(); i++) {
if (atnames[i] == itna) {
atta = 1;
gen->enz = '&';
gen->ban = atnames.size() - 1 - i;
}
}
if (!atta) {
gen->enz = '$';
gen->ban = roll(itna);
} //どこにもないので未使用のletが確定する
}
// cerr<<"itna="<<itna;
}
if (kan->enz == 'Q') {
(*kan) = (*gen);
} else {
// cerr<<"de";
ptr<some> ata(new some());
ata->hi = kan;
ata->mg = gen;
ata->enz = '#';
kan = ata;
}
}
ptr<some> ans = kan;
while (scopename--) {
ptr<some> ata(new some());
ata->enz = '@';
ata->hi = ans;
ans = ata;
atnames.pob();
}
do {
hibas++;
} while (str[hibas] == ' ');
return ans;
}
void letkai(ptr<some> in, bool aaa = 1) {
if ((!aaa) && in->ramukan) {
return;
}
if (in->enz == '#' || in->enz == '@') {
if (in->hi->enz == '$') {
if (letnames.count(in->hi->ban) == 0) {
cerr << "missed name find" << in->hi->ban << endl;
} else {
in->hi = letnames[in->hi->ban];
}
} else {
letkai(in->hi, 0);
}
}
if (in->enz == '#') {
if (in->mg->enz == '$') {
if (letnames.count(in->mg->ban) == 0) {
cerr << "missed name find" << in->mg->ban << endl;
} else {
in->mg = letnames[in->mg->ban];
}
} else {
letkai(in->mg, 0);
}
}
}
int tabu = 0;
void TS(void) {
for (int i = 0; i < tabu; i++) {
cout << " ";
}
}
void syutu(const ptr<some> in) {
cout << "{\n"; //}
tabu++;
if (in->enz == '@') { //らむだ
TS();
cout << "enz:@\n";
// TS();cout<<"arg :"<<in->ban<<endl;
TS();
cout << "arg:";
syutu(in->hi);
} else if (in->enz == '#') { //えんざん
TS();
cout << "enz:#\n";
TS();
cout << "arg :";
syutu(in->hi);
TS();
cout << "body:";
syutu(in->mg);
} else if (in->enz == '&') { //即値
TS();
cout << "enz:&\n";
TS();
cout << "arg :" << in->ban << endl;
} else if (in->enz == 'n') {
TS();
cout << "nut=" << in->ban << endl;
} else {
TS();
cout << "enz=" << in->enz << endl;
}
tabu--;
TS();
cout << "}\n"; //{
}
bool isoy(ptr<some> tai) {
return (tai != nullptr && (!tai->syu) &&
(tai->enz == '#' || tai->enz == '@'));
}
bool daishi(ptr<some> &tai, int num, ptr<some> &xca) {
// cerr<<"dai";
// syutu(tai);
if (tai->syu) {
return 0;
}
if (tai->ramukan) {
return 0;
}
bool hen = 0;
ptr<some> moto = tai;
ptr<some> iti(new some());
(*iti) = (*tai);
tai = iti;
tai->syu = 0;
if (tai->enz == '&' && tai->ban == num) {
tai = xca;
hen = 1;
} else if (tai->enz == '&' && tai->ban > num) {
tai->ban--;
hen = 1;
} else if (tai->enz == '@') {
hen |= daishi(tai->hi, num + 1, xca);
} else if (tai->enz == '#') {
hen |= daishi(tai->hi, num, xca);
hen |= daishi(tai->mg, num, xca);
}
if (hen) {
tai->syu = 0;
} else {
tai = moto;
}
return hen;
}
// dainyu(0,0,...)
void WA_RE(int in = -1333) {
cerr << "RE" << in;
exit(0);
}
void keisan(ptr<some> in) {
// cerr<<"sai";
if (in == nullptr || in->syu || in->enz != '#') {
return;
}
if (in->hi != nullptr && in->hi->enz == '$') {
exit(0);
}
// cerr<<"de "<<in->enz;
// syutu(in);
if (isoy(in->hi)) {
keisan(in->hi);
}
if (in->hi->enz == '@') {
// cerr<<"ramu";
keisan(in->mg);
ptr<some> xca = in->mg;
// syutu(xca);
ptr<some> tai = in->hi->hi;
daishi(tai, 0, xca);
(*in) = (*tai);
keisan(in);
return;
}
if (in->hi->enz == '1') {
if (isoy(in->mg)) {
keisan(in->mg);
}
in->enz = '3';
return;
} else if (in->hi->enz == '2') {
in->syu = 1;
in->enz = '4';
return;
} else if (in->hi->enz == '3') {
(*in) = (*(in->hi->mg));
return;
} else if (in->hi->enz == '4') {
if (isoy(in->mg)) {
keisan(in->mg);
}
(*in) = (*(in->mg));
return;
} else if (isoy(in->mg)) {
keisan(in->mg);
}
char hiz = in->hi->enz, mgz = in->mg->enz;
// cerr<<"himg="<<hiz<<mgz<<endl;
if (hiz == '#' || hiz == '@' || hiz == '&') {
in->syu = 1;
return;
}
if (mgz == 'n') {
bool yatta = 1;
// if(in->hi->enz=='*'&&in->mg->ban==2){cerr<<"hyo";}
switch (hiz) {
case '+':
in->enz = 'P';
in->ban = in->mg->ban;
break;
case 'P':
in->enz = 'n';
in->ban = in->hi->ban + in->mg->ban;
break;
case '-':
in->enz = 'M';
in->ban = in->mg->ban;
break;
case 'M':
in->enz = 'n';
in->ban = in->hi->ban - in->mg->ban;
break;
case '*':
in->enz = 'T';
in->ban = in->mg->ban;
break;
case 'T':
in->enz = 'n';
in->ban = in->hi->ban * in->mg->ban;
break;
case '/':
in->enz = 'D';
in->ban = in->mg->ban;
break;
case 'D':
in->enz = 'n';
in->ban = in->hi->ban / in->mg->ban;
break;
case '%':
in->enz = 'A';
in->ban = in->mg->ban;
break;
case 'A':
in->enz = 'n';
in->ban = in->hi->ban % in->mg->ban;
break;
case 'o':
in->enz = 'O';
in->ban = in->mg->ban;
break;
case 'O':
in->enz = 'n';
in->ban = max(in->hi->ban, in->mg->ban);
break;
case 'c':
in->enz = 'C';
in->ban = in->mg->ban;
break;
case 'C':
in->enz = 'n';
in->ban = min(in->hi->ban, in->mg->ban);
break;
case '<':
in->enz = 'S';
in->ban = in->mg->ban;
break;
case 'S':
in->enz = 'n';
in->ban = ((in->hi->ban < in->mg->ban) ? 1 : 0);
break;
case '>':
in->enz = 'B';
in->ban = in->mg->ban;
break;
case 'B':
in->enz = 'n';
in->ban = ((in->hi->ban > in->mg->ban) ? 1 : 0);
break;
default:
yatta = 0;
}
if (yatta) {
// cerr<<"ya";
in->hi = nullptr;
in->mg = nullptr;
in->syu = 1;
return;
}
}
if (in->enz != '#') {
in->hi = nullptr;
in->mg = nullptr;
} //計算を行ったので
if (hiz == 'v' && mgz == 'n') {
in->enz = 'V';
in->ban = in->mg->ban;
}
if (hiz == 'V') {
(*in) = (*make_hai(in->hi->ban, in->mg));
}
if (hiz == 'u' && mgz == 'h') {
in->enz = 'U';
in->hi = in->mg;
}
if (hiz == 'z') {
in->enz = 'n';
in->ban = in->mg->ban;
}
if (hiz == 'l') {
in->enz = 'h';
in->ban = in->mg->hi->ban;
in->hi = in->mg->hi->hi;
}
if (hiz == 'm') {
in->enz = 'h';
in->ban = in->mg->ban - in->mg->hi->ban;
in->hi = in->mg->hi->mg;
}
if (hiz == 'U' && mgz == 'h') {
(*in) = (*unite_hai(in->hi->hi, in->mg));
}
if (hiz == 'h') {
ptr<some> ata(new some());
ata->ban = 1;
ata->enz = 'h';
ata->hi = in->mg;
(*in) = *unite_hai(in->hi, ata);
}
if (hiz == 'r' && mgz == 'h') {
in->enz = 'R';
in->hi = in->mg;
}
if (hiz == 'R' && mgz == 'n') {
(*in) = (*hairead(in->hi->hi, in->mg->ban));
}
if (hiz == 'w' && mgz == 'h') {
in->enz = 'W';
in->hi = in->mg;
}
if (hiz == 'W' && mgz == 'n') {
in->enz = '=';
in->hi = in->hi->hi;
in->ban = in->mg->ban;
}
if (hiz == '=') {
(*in) = (*haiwrite(in->hi->hi, in->hi->ban, in->mg));
}
if (hiz == 'i' && mgz == 'n') {
in->enz = ((in->mg->ban) ? '1' : '2');
}
if (hiz == 'j' && mgz == 'n') {
in->enz = ((in->mg->ban < 0) ? '1' : '2');
}
in->syu = 1;
return;
}
#include <sstream>
int main(void) {
for (auto code : codelines) {
std::istringstream stm(code);
string mei;
stm >> mei;
if (mei == "winn") {
string na;
stm >> na;
llint kaz;
cin >> kaz;
llint rollname = roll(na);
ptr<some> soku(new some());
soku->enz = 'n';
soku->ban = kaz;
letnames[rollname] = soku;
}
if (mei == "winh") {
string na;
stm >> na; //名前
string enu;
stm >> enu;
for (auto it : letnames) {
letkai(it.sec);
}
ptr<some> terget = letnames[roll(enu)];
keisan(terget);
llint size = 0;
if (terget->enz == 'n') {
size = terget->ban;
} else {
cout << "era-" << endl;
}
//ここで入力量を決める
ptr<some> zro(new some());
zro->enz = 'n';
zro->ban = 0;
ptr<some> haso(make_hai(size, zro));
for (int i = 0; i < size; i++) {
ptr<some> soku(new some());
soku->enz = 'n';
cin >> soku->ban;
haso = haiwrite(haso, i, soku);
}
letnames[roll(na)] = haso;
}
if (mei == "wins") {
string na;
stm >> na; //名前
string nyu;
cin >> nyu;
int size = nyu.size();
ptr<some> zro(new some());
zro->enz = 'n';
zro->ban = 0;
ptr<some> haso(make_hai(size, zro));
for (int i = 0; i < size; i++) {
ptr<some> soku(new some());
soku->enz = 'n';
soku->ban = nyu[i];
haso = haiwrite(haso, i, soku);
}
letnames[roll(na)] = haso;
}
if (mei == "let") {
string na;
stm >> na;
getline(stm, str);
hibas = 0;
while (str[hibas] == ' ') {
hibas++;
}
if (letnames.count(roll(na))) {
cout << "namaenosyoutotu" << endl;
}
letnames[roll(na)] = pasa();
letnames[roll(na)]->ramukan = 1;
}
if (mei == "woutn") {
string na;
stm >> na;
// let名前解決する
for (auto it : letnames) {
letkai(it.sec);
}
// syutu(letnames[roll(na)]);
ptr<some> terget = letnames[roll(na)];
keisan(terget);
if (terget->enz == 'n') {
cout << terget->ban << endl;
} else {
syutu(terget);
cerr << "erra-" << terget->enz << endl;
}
}
if (mei == "wouth") {
string na;
stm >> na;
for (auto it : letnames) {
letkai(it.sec);
}
ptr<some> terget = letnames[roll(na)];
keisan(terget);
if (terget->enz == 'h') {
for (int i = 0; i < terget->ban; i++) {
cout << hairead(terget, i)->ban << endl;
}
} else {
cerr << "ella-" << terget->enz << endl;
}
}
if (mei == "wouts") {
string na;
stm >> na;
for (auto it : letnames) {
letkai(it.sec);
}
ptr<some> terget = letnames[roll(na)];
keisan(terget);
if (terget->enz == 'h') {
for (int i = 0; i < terget->ban; i++) {
cout << (char)(hairead(terget, i)->ban);
}
cout << endl;
} else {
cerr << "ela-" << terget->enz << endl;
}
}
if (mei == "end") {
return 0;
}
}
return 0;
}
/*
2019
やりたいこと
高速化
わかりやすさ強化
関数一覧
(itna=="+"){gen->enz='+';}
else if(itna=="-"){gen->enz='-';}
else if(itna=="*"){gen->enz='*';}
else if(itna=="/"){gen->enz='/';}
else if(itna=="%"){gen->enz='%';}
else if(itna=="max"){gen->enz='o';}
else if(itna=="min"){gen->enz='c';}
else if(itna=="<"){gen->enz='<';}
else if(itna==">"){gen->enz='>';}
else if(itna=="vec"||itna=="vector"){gen->enz='v';}
else if(itna=="uni"||itna=="union"){gen->enz='u';}
else if(itna=="if"){gen->enz='i';}
else if(itna=="jf"){gen->enz='j';}
else if(itna=="for"||itna=="while"){gen->enz='f';}
else if(itna=="[r]"){gen->enz='r';}
else if(itna=="[w]"){gen->enz='w';}
else if(itna=="{}"){gen->enz='h';gen->ban=0;}
実装したいもの
double型の実装
nut @a @b (a(a(a(b))))//チャーチ数として処理する
やっぱり数字をプログラム中に入出力したい
3
2
3 4
1
2
4
3 4 5
このままだとこれみたいな入力形式に対応できない
ptinput @a (aはnut)入力を受け取る番号
doinput @a 内部のptinputが含まれる関数をすべて展開して、
実際に入力する 内部にptinputが含まれる関数は、関数を深く複製しなければいけない。
doinputによる入力は、一回しかされない。
doinputをしたら、ptinput関数が全て入力された値に置き換わる
let tukeru
let myin pic0
let watle ((ptoutput 1)(* 2 (ptinput 1)))
let in1 out1 (10 watle)
??よくわからん
vectorのnlognソートってできたっけ?
とりあえずクイックソート
winn n
winh hai
let next (@a (+ a 1))
let prev (@a (- a 1))
let aswap (@ary @a @b ([w] ([w] ary a ([r] ary b)) b ([r] ary a)))
let part (@ary @st @en
if (- st en)
(
if (< ([r] ary st) ([r] ary (pone st)))
(part (aswap ary (next st) en ) st (prev en))
(part (aswap ary st (next st) ) (next st) en)
)
({} ary st)
)
//パーティションして、tuple(ソート済みアレイ、最後の場所) を返します
let quick (@ary @st @en
if (-st en)
(
(@in (quick (quick ([w] in 0) st (prev([w] in 1)) ) (next ([w]
in 1)) en )) (part ary st en)
)
(ary)
)
let ans (quick hai 0 (prev n))
wouth ans
*/
|
[
"literal.string.change"
] | 741,209
| 741,210
|
u483814783
|
cpp
|
p02938
|
#include <bits/stdc++.h>
#define IO_OP \
std::ios::sync_with_stdio(0); \
std::cin.tie(0);
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define EB emplace_back
#define ALL(v) (v).begin(), (v).end()
#define endl '\n'
#define debug(x) cerr << #x << " is " << x << endl
#define int ll
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef vector<int> vi;
const int M = 1e9 + 7;
int dp[65][2][2][2];
int32_t main() {
IO_OP;
int L, R;
cin >> L >> R;
dp[60][0][0][0] = 1;
for (int i = 60; i > 0; i--) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
if (!dp[i][j][k][l])
continue;
// 0
// 0
if (R >> (i - 1) & 1) {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][1][1][l] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][1][k][l] += dp[i][j][k][l]) %= M;
}
} else {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][j][1][l] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][j][k][l] += dp[i][j][k][l]) %= M;
}
}
// 1
// 1
if (R >> (i - 1) & 1) {
if (L >> (i - 1) & 1) {
(dp[i - 1][j][k][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][j][1][1] += dp[i][j][k][l]) %= M;
}
} else if (j == 1) {
if (L >> (i - 1) & 1) {
(dp[i - 1][1][k][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][1][1][1] += dp[i][j][k][l]) %= M;
}
}
// 1
// 0
if (l == 1) {
if (R >> (i - 1) & 1) {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][j][1][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][j][k][1] += dp[i][j][k][l]) %= M;
}
} else if (j == 1) {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][1][1][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][1][k][1] += dp[i][j][k][l]) %= M;
}
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
ans += dp[0][i][j][1];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define IO_OP \
std::ios::sync_with_stdio(0); \
std::cin.tie(0);
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define EB emplace_back
#define ALL(v) (v).begin(), (v).end()
#define endl '\n'
#define debug(x) cerr << #x << " is " << x << endl
#define int ll
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef vector<int> vi;
const int M = 1e9 + 7;
int dp[65][2][2][2];
int32_t main() {
IO_OP;
int L, R;
cin >> L >> R;
dp[60][0][0][0] = 1;
for (int i = 60; i > 0; i--) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
if (!dp[i][j][k][l])
continue;
// 0
// 0
if (R >> (i - 1) & 1) {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][1][1][l] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][1][k][l] += dp[i][j][k][l]) %= M;
}
} else {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][j][1][l] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][j][k][l] += dp[i][j][k][l]) %= M;
}
}
// 1
// 1
if (R >> (i - 1) & 1) {
if (L >> (i - 1) & 1) {
(dp[i - 1][j][k][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][j][1][1] += dp[i][j][k][l]) %= M;
}
} else if (j == 1) {
if (L >> (i - 1) & 1) {
(dp[i - 1][1][k][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][1][1][1] += dp[i][j][k][l]) %= M;
}
}
// 1
// 0
if (l == 1) {
if (R >> (i - 1) & 1) {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][j][1][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][j][k][1] += dp[i][j][k][l]) %= M;
}
} else if (j == 1) {
if (L >> (i - 1) & 1) {
if (k == 1)
(dp[i - 1][1][1][1] += dp[i][j][k][l]) %= M;
} else {
(dp[i - 1][1][k][1] += dp[i][j][k][l]) %= M;
}
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
ans += dp[0][i][j][1];
cout << ans % M << endl;
}
|
[
"expression.operation.binary.add"
] | 741,213
| 741,214
|
u454290303
|
cpp
|
p02938
|
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
int main() {
long long l, r;
cin >> l >> r;
long long ans = 0;
// x ⊂ y
// (0, 0), (0, 1), (1, 1)
for (int k = 0; k < 62; k++) {
long long c = 1LL << k;
long long d = 1LL << (k + 1);
if (l >= d || c > r)
continue;
long long dp[k + 1][4];
// 0: l < curr && r > curr, 1: l <= curr, 2: r >= curr
memset(dp, 0, sizeof(dp));
int s = 0;
if (c <= l && l < d)
s += 1 << 0;
if (c <= r && r < d)
s += 1 << 1;
dp[k][s]++;
long long prev = ans;
for (int i = k - 1; i >= 0; i--) {
if (i < 0)
continue;
bool lb = l & (1LL << i);
bool rb = r & (1LL << i);
// dp[i+1][0]
dp[i][0] += dp[i + 1][0] * 3 % mod;
// dp[i+1][1]
if (lb) {
dp[i][1] += dp[i + 1][1];
} else {
dp[i][0] += dp[i + 1][1];
dp[i][1] += dp[i + 1][1] * 2 % mod;
}
// dp[i+1][2]
if (rb) {
dp[i][2] += dp[i + 1][2] * 2 % mod;
dp[i][0] += dp[i + 1][2];
} else {
dp[i][2] += dp[i + 1][2];
}
// dp[i+1][3]
if (lb == rb) {
dp[i][3] += dp[i + 1][3];
} else {
dp[i][1] += dp[i + 1][3];
dp[i][2] += dp[i + 1][3];
dp[i][3] += dp[i + 1][3];
}
}
for (int j = 0; j < 4; j++) {
ans = (ans + dp[0][j]) % mod;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
int main() {
long long l, r;
cin >> l >> r;
long long ans = 0;
// x ⊂ y
// (0, 0), (0, 1), (1, 1)
for (int k = 0; k < 62; k++) {
long long c = 1LL << k;
long long d = 1LL << (k + 1);
if (l >= d || c > r)
continue;
long long dp[k + 1][4];
// 0: l < curr && r > curr, 1: l <= curr, 2: r >= curr
memset(dp, 0, sizeof(dp));
int s = 0;
if (c <= l && l < d)
s += 1 << 0;
if (c <= r && r < d)
s += 1 << 1;
dp[k][s]++;
long long prev = ans;
for (int i = k - 1; i >= 0; i--) {
if (i < 0)
continue;
bool lb = l & (1LL << i);
bool rb = r & (1LL << i);
// dp[i+1][0]
dp[i][0] += dp[i + 1][0] * 3 % mod;
// dp[i+1][1]
if (lb) {
dp[i][1] += dp[i + 1][1];
} else {
dp[i][0] += dp[i + 1][1];
dp[i][1] += dp[i + 1][1] * 2 % mod;
}
// dp[i+1][2]
if (rb) {
dp[i][2] += dp[i + 1][2] * 2 % mod;
dp[i][0] += dp[i + 1][2];
} else {
dp[i][2] += dp[i + 1][2];
}
// dp[i+1][3]
if (lb == rb) {
dp[i][3] += dp[i + 1][3];
} else if (rb) {
dp[i][1] += dp[i + 1][3];
dp[i][2] += dp[i + 1][3];
dp[i][3] += dp[i + 1][3];
}
}
for (int j = 0; j < 4; j++) {
ans = (ans + dp[0][j]) % mod;
}
}
cout << ans << endl;
return 0;
}
|
[
"control_flow.branch.if.add"
] | 741,220
| 741,221
|
u521364030
|
cpp
|
p02938
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int dx[4] = {-1, 0, 0, 1};
const int dy[4] = {0, -1, 1, 0};
// Self settings
// clang-format off
#define MAX_N 100000
#define REP(i, N) for (int i = 0; i < (int)(N); ++i)
#define SLN(i,N) (i == N-1 ? "\n" : " ")
// clang-format on
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
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;
}
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;
}
};
mint dp[61][2][2][2];
ll l, r;
int main(void) {
cin >> l >> r;
dp[60][0][0][0] = 1;
for (int i = 59; i >= 0; i--) {
int lb = l >> i & 1;
int rb = r >> i & 1;
REP(j, 2) REP(k, 2) REP(s, 2) {
mint pre = dp[i + 1][j][k][s];
REP(x, 3) REP(y, 2) {
if (x && !y)
continue; // x= 1, y = 0
int nj = j, nk = k, ns = s;
if (!s && x != y)
continue;
if (x && y)
ns = 1;
if (!j && !x && lb)
continue;
if (x && !lb)
nj = 1;
if (!k && y && !rb)
continue;
if (y && rb)
nj = 1;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
REP(j, 2) REP(k, 2) REP(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int dx[4] = {-1, 0, 0, 1};
const int dy[4] = {0, -1, 1, 0};
// Self settings
// clang-format off
#define MAX_N 100000
#define REP(i, N) for (int i = 0; i < (int)(N); ++i)
#define SLN(i,N) (i == N-1 ? "\n" : " ")
// clang-format on
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
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;
}
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;
}
};
mint dp[61][2][2][2];
ll l, r;
int main(void) {
cin >> l >> r;
dp[60][0][0][0] = 1;
for (int i = 59; i >= 0; i--) {
int lb = l >> i & 1;
int rb = r >> i & 1;
REP(j, 2) REP(k, 2) REP(s, 2) {
mint pre = dp[i + 1][j][k][s];
REP(x, 2) REP(y, 2) {
if (x && !y)
continue; // x= 1, y = 0
int nj = j, nk = k, ns = s;
if (!s && x != y)
continue;
if (x && y)
ns = 1;
if (!j && !x && lb)
continue;
if (x && !lb)
nj = 1;
if (!k && y && !rb)
continue;
if (!y && rb)
nk = 1;
dp[i][nj][nk][ns] += pre;
}
}
}
mint ans;
REP(j, 2) REP(k, 2) REP(s, 2) ans += dp[0][j][k][s];
cout << ans.x << endl;
return 0;
}
|
[
"literal.number.change",
"call.arguments.change",
"expression.operation.unary.add",
"control_flow.branch.if.condition.change",
"assignment.variable.change",
"identifier.change"
] | 741,222
| 741,223
|
u621104964
|
cpp
|
p02938
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define MOD (long)(1e9 + 7)
#define MAX 1000000 // 階乗をいくつまで計算するか
class modlong;
void computeAll(long n);
modlong modComb(long n, long k);
modlong modFact(long n);
class modlong {
long val;
const long mod = MOD;
public:
// 初期化 値を引数に与えなかった場合はval=0としておく
modlong(long init = 0) {
while (init < 0)
init += mod; // 0以上であることを保証
val = init % mod;
}
// longへのキャスト operator long()で定義すると modlong +
// longとかができなくなる
long tol() { return this->val; }
// 代入
void operator=(const modlong &r) { this->val = r.val; }
void operator=(const long &r) {
long rr = r;
while (rr < 0)
rr += mod; // 0以上であることを保証
this->val = rr % mod;
}
//比較
bool operator<(const modlong &r) { return this->val < r.val; }
bool operator>(const modlong &r) { return this->val > r.val; }
bool operator==(const modlong &r) { return this->val == r.val; }
bool operator!=(const modlong &r) { return !(*this == r); }
bool operator<=(const modlong &r) { return !(*this > r); }
bool operator>=(const modlong &r) { return !(*this < r); }
// 足し算; 符号反転; 引き算
modlong operator+(const modlong &r) {
long aval = (this->val + r.val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-() {
long aval = (mod - this->val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-(const modlong &r) {
modlong rr = r;
return *this + (-rr);
}
//かけ算; 逆元; わり算
modlong operator*(const modlong &r) {
long aval = (this->val * r.val) % mod;
modlong ans(aval);
return ans;
}
modlong inv() {
if (*this == 1)
return modlong(1);
if (*this == 0)
cerr << "modlong warning: dividebyzero!!!" << '\n';
modlong p, q = *this, m(0), n(1), r, c;
p.val = mod; // p=modとかくとp.val=mod%mod=0となってしまう
while (q > 1) {
r = p.val % q.val; // r.val=p.val / q.val
// とかくよりもこのほうが代入時に%modされるので安全
c = m.val - n.val * (p.val / q.val);
p = q, q = r, m = n, n = c;
}
return n;
}
modlong operator/(const modlong &r) {
modlong rr = r;
return *this * rr.inv();
}
// ++ -- 前付きと後ろ付き
void operator++() { ++this->val; }
void operator++(int a) {
a = 0;
this->val++;
} // a使ってなくねっていうwarningをsilenceするためにaをいじってる
void operator--() { --this->val; }
void operator--(int a) {
a = 0;
this->val--;
}
// 四則演算&代入
void operator+=(const modlong &r) { *this = *this + r; }
void operator-=(const modlong &r) { *this = *this - r; }
void operator*=(const modlong &r) { *this = *this * r; }
void operator/=(const modlong &r) { *this = *this / r; }
// べき乗
modlong pow(long n) {
if (n < 0)
return inv().pow(-n); // 逆元の-n乗
else if (n == 0)
return modlong(1);
modlong half = pow(n / 2);
if (n % 2)
return *this * half * half;
else
return half * half;
}
// コンビネーション modCombは少し下に書いてある
modlong C(modlong k) { return modComb(this->val, k.val); }
modlong fact() { return modFact(this->val); }
friend ostream &operator<<(ostream &os, const modlong &out);
friend istream &operator>>(istream &is, modlong &out);
};
// cout、cerr、cin用の演算子たち
ostream &operator<<(ostream &os, const modlong &out) {
os << out.val;
return os;
}
istream &operator>>(istream &is, modlong &in) {
long inl;
is >> inl;
in.val = inl % MOD;
return is;
}
////// 階乗を全て求める -> 二項係数を求める
long invs[MAX], facts[MAX], finvs[MAX];
long listlen = 0; // invs, facts, finvsの配列長
void computeAll(long n) {
if (n >= MAX)
cerr << "modlong error: index out of range in computeAll" << '\n';
long i;
if (listlen == 0) {
invs[1] = 1;
facts[0] = 1;
facts[1] = 1;
finvs[0] = 1;
finvs[1] = 1;
i = 2;
} else {
i = listlen;
}
if (n < 2)
return;
for (; i <= n; i++) {
invs[i] = -invs[MOD % i] * (MOD / i) % MOD;
facts[i] = facts[i - 1] * i % MOD;
finvs[i] = finvs[i - 1] * invs[i] % MOD;
}
listlen = n + 1; // 次呼び出すときはn+1以降から再開すれば良い
}
// コンビネーション
modlong modComb(long n, long k) {
if (k < 0 || k > n)
return 0;
if (k == 0 || k == n)
return 1;
if (listlen <= n)
computeAll(n); // 毎回足りない分だけ補う
return modlong(facts[n]) * finvs[k] * finvs[n - k];
}
// 階乗
modlong modFact(long n) {
if (listlen <= n)
computeAll(n); // 毎回足りない分だけ補う
return modlong(facts[n]);
}
#define update(d, e, f, a, b, c) dp[i][a][b][c] += dp[i + 1][d][e][f]
int main() {
long l, r;
cin >> l >> r;
modlong dp[71][2][2][2] = {
{{{0}}}}; // 桁数,先頭bitが出たか,xとl,yとrが剥がれたか
dp[70][0][0][0] = 1;
for (int i = 69; i >= 0; i--) {
bool lb = l >> i & 1, rb = r >> i & 1;
update(1, 1, 1, 1, 1, 1) * 3;
if (lb) {
update(0, 0, 1, 1, 0, 1);
update(1, 0, 1, 1, 0, 1);
if (rb) {
update(0, 0, 0, 1, 0, 0);
update(1, 0, 0, 1, 0, 0);
update(1, 1, 0, 1, 1, 0) * 2;
update(1, 1, 0, 1, 1, 1);
} else {
update(1, 1, 0, 1, 1, 0);
}
} else {
update(0, 0, 1, 0, 0, 1);
update(0, 0, 1, 1, 1, 1);
update(1, 0, 1, 1, 0, 1) * 2;
update(1, 0, 1, 1, 1, 1);
if (rb) {
update(0, 0, 0, 0, 0, 1);
update(0, 0, 0, 1, 1, 0);
update(1, 0, 0, 1, 0, 0);
update(1, 0, 0, 1, 0, 1);
update(1, 0, 0, 1, 1, 0);
update(1, 1, 0, 1, 1, 0) * 2;
update(1, 1, 0, 1, 1, 1);
} else {
update(0, 0, 0, 0, 0, 0);
update(1, 0, 0, 1, 0, 0);
update(1, 1, 0, 1, 1, 0);
}
}
}
cout << dp[0][1][0][0] + dp[0][1][0][1] + dp[0][1][1][0] + dp[0][1][1][1]
<< '\n';
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define MOD (long)(1e9 + 7)
#define MAX 1000000 // 階乗をいくつまで計算するか
class modlong;
void computeAll(long n);
modlong modComb(long n, long k);
modlong modFact(long n);
class modlong {
long val;
const long mod = MOD;
public:
// 初期化 値を引数に与えなかった場合はval=0としておく
modlong(long init = 0) {
while (init < 0)
init += mod; // 0以上であることを保証
val = init % mod;
}
// longへのキャスト operator long()で定義すると modlong +
// longとかができなくなる
long tol() { return this->val; }
// 代入
void operator=(const modlong &r) { this->val = r.val; }
void operator=(const long &r) {
long rr = r;
while (rr < 0)
rr += mod; // 0以上であることを保証
this->val = rr % mod;
}
//比較
bool operator<(const modlong &r) { return this->val < r.val; }
bool operator>(const modlong &r) { return this->val > r.val; }
bool operator==(const modlong &r) { return this->val == r.val; }
bool operator!=(const modlong &r) { return !(*this == r); }
bool operator<=(const modlong &r) { return !(*this > r); }
bool operator>=(const modlong &r) { return !(*this < r); }
// 足し算; 符号反転; 引き算
modlong operator+(const modlong &r) {
long aval = (this->val + r.val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-() {
long aval = (mod - this->val) % mod;
modlong ans(aval);
return ans;
}
modlong operator-(const modlong &r) {
modlong rr = r;
return *this + (-rr);
}
//かけ算; 逆元; わり算
modlong operator*(const modlong &r) {
long aval = (this->val * r.val) % mod;
modlong ans(aval);
return ans;
}
modlong inv() {
if (*this == 1)
return modlong(1);
if (*this == 0)
cerr << "modlong warning: dividebyzero!!!" << '\n';
modlong p, q = *this, m(0), n(1), r, c;
p.val = mod; // p=modとかくとp.val=mod%mod=0となってしまう
while (q > 1) {
r = p.val % q.val; // r.val=p.val / q.val
// とかくよりもこのほうが代入時に%modされるので安全
c = m.val - n.val * (p.val / q.val);
p = q, q = r, m = n, n = c;
}
return n;
}
modlong operator/(const modlong &r) {
modlong rr = r;
return *this * rr.inv();
}
// ++ -- 前付きと後ろ付き
void operator++() { ++this->val; }
void operator++(int a) {
a = 0;
this->val++;
} // a使ってなくねっていうwarningをsilenceするためにaをいじってる
void operator--() { --this->val; }
void operator--(int a) {
a = 0;
this->val--;
}
// 四則演算&代入
void operator+=(const modlong &r) { *this = *this + r; }
void operator-=(const modlong &r) { *this = *this - r; }
void operator*=(const modlong &r) { *this = *this * r; }
void operator/=(const modlong &r) { *this = *this / r; }
// べき乗
modlong pow(long n) {
if (n < 0)
return inv().pow(-n); // 逆元の-n乗
else if (n == 0)
return modlong(1);
modlong half = pow(n / 2);
if (n % 2)
return *this * half * half;
else
return half * half;
}
// コンビネーション modCombは少し下に書いてある
modlong C(modlong k) { return modComb(this->val, k.val); }
modlong fact() { return modFact(this->val); }
friend ostream &operator<<(ostream &os, const modlong &out);
friend istream &operator>>(istream &is, modlong &out);
};
// cout、cerr、cin用の演算子たち
ostream &operator<<(ostream &os, const modlong &out) {
os << out.val;
return os;
}
istream &operator>>(istream &is, modlong &in) {
long inl;
is >> inl;
in.val = inl % MOD;
return is;
}
////// 階乗を全て求める -> 二項係数を求める
long invs[MAX], facts[MAX], finvs[MAX];
long listlen = 0; // invs, facts, finvsの配列長
void computeAll(long n) {
if (n >= MAX)
cerr << "modlong error: index out of range in computeAll" << '\n';
long i;
if (listlen == 0) {
invs[1] = 1;
facts[0] = 1;
facts[1] = 1;
finvs[0] = 1;
finvs[1] = 1;
i = 2;
} else {
i = listlen;
}
if (n < 2)
return;
for (; i <= n; i++) {
invs[i] = -invs[MOD % i] * (MOD / i) % MOD;
facts[i] = facts[i - 1] * i % MOD;
finvs[i] = finvs[i - 1] * invs[i] % MOD;
}
listlen = n + 1; // 次呼び出すときはn+1以降から再開すれば良い
}
// コンビネーション
modlong modComb(long n, long k) {
if (k < 0 || k > n)
return 0;
if (k == 0 || k == n)
return 1;
if (listlen <= n)
computeAll(n); // 毎回足りない分だけ補う
return modlong(facts[n]) * finvs[k] * finvs[n - k];
}
// 階乗
modlong modFact(long n) {
if (listlen <= n)
computeAll(n); // 毎回足りない分だけ補う
return modlong(facts[n]);
}
#define update(d, e, f, a, b, c) dp[i][a][b][c] += dp[i + 1][d][e][f]
int main() {
long l, r;
cin >> l >> r;
modlong dp[65][2][2][2] = {
{{{0}}}}; // 桁数,先頭bitが出たか,xとl,yとrが剥がれたか
dp[64][0][0][0] = 1;
for (int i = 63; i >= 0; i--) {
int lb = l >> i & 1, rb = r >> i & 1;
update(1, 1, 1, 1, 1, 1) * 3;
if (lb) {
update(0, 0, 1, 1, 0, 1);
update(1, 0, 1, 1, 0, 1);
if (rb) {
update(0, 0, 0, 1, 0, 0);
update(1, 0, 0, 1, 0, 0);
update(1, 1, 0, 1, 1, 0) * 2;
update(1, 1, 0, 1, 1, 1);
} else {
update(1, 1, 0, 1, 1, 0);
}
} else {
update(0, 0, 1, 0, 0, 1);
update(0, 0, 1, 1, 1, 1);
update(1, 0, 1, 1, 0, 1) * 2;
update(1, 0, 1, 1, 1, 1);
if (rb) {
update(0, 0, 0, 0, 0, 1);
update(0, 0, 0, 1, 1, 0);
update(1, 0, 0, 1, 0, 0);
update(1, 0, 0, 1, 0, 1);
update(1, 0, 0, 1, 1, 0);
update(1, 1, 0, 1, 1, 0) * 2;
update(1, 1, 0, 1, 1, 1);
} else {
update(0, 0, 0, 0, 0, 0);
update(1, 0, 0, 1, 0, 0);
update(1, 1, 0, 1, 1, 0);
}
}
}
cout << dp[0][1][0][0] + dp[0][1][0][1] + dp[0][1][1][0] + dp[0][1][1][1]
<< '\n';
return 0;
}
|
[
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change"
] | 741,226
| 741,227
|
u956758464
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define rrep(i, n, m) for (int i = n; i >= (m); i--)
using Graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll MOD = 1000000007;
#ifdef __DEBUG
#include "cpp-pyprint/pyprint.h"
#endif
int dp[200005][2];
void Main() {
string s;
cin >> s;
int n = s.size();
if (n == 1) {
cout << 1 << endl;
return;
}
if (s[0] == s[1]) {
dp[0][0] = 1;
dp[0][1] = 0;
dp[1][0] = 1;
dp[1][1] = 1;
} else {
dp[0][0] = 1;
dp[0][1] = 0;
dp[1][0] = 1;
dp[1][1] = 2;
}
rep2(i, 2, n) {
if (s[i - 1] == s[i]) {
dp[i][0] = dp[i - 1][1] + 1;
dp[i][1] = dp[i - 2][0] + 1;
} else {
dp[i][0] = dp[i - 1][0] + 1;
dp[i][1] = dp[i - 2][0] + 1;
}
}
cout << max(dp[n - 1][0], dp[n - 1][1]) << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define rrep(i, n, m) for (int i = n; i >= (m); i--)
using Graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll MOD = 1000000007;
#ifdef __DEBUG
#include "cpp-pyprint/pyprint.h"
#endif
int dp[200005][2];
void Main() {
string s;
cin >> s;
int n = s.size();
if (n == 1) {
cout << 1 << endl;
return;
}
if (s[0] == s[1]) {
dp[0][0] = 1;
dp[0][1] = 0;
dp[1][0] = 1;
dp[1][1] = 1;
} else {
dp[0][0] = 1;
dp[0][1] = 0;
dp[1][0] = 2;
dp[1][1] = 1;
}
rep2(i, 2, n) {
if (s[i - 1] == s[i]) {
dp[i][0] = dp[i - 1][1] + 1;
dp[i][1] = dp[i - 2][0] + 1;
} else {
dp[i][0] = dp[i - 1][0] + 1;
dp[i][1] = dp[i - 2][0] + 1;
}
}
cout << max(dp[n - 1][0], dp[n - 1][1]) << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
|
[
"literal.number.change",
"assignment.value.change"
] | 741,236
| 741,237
|
u427344224
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = 1; i <= (int)(n); i++)
#define drep(i, n) for (int i = (n)-1; i >= 0; i--)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// Mod int
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % mod + mod) % mod) {}
// mint(ll x):x(x){}
mint &fix() {
x = (x % mod + mod) % mod;
return *this;
}
mint operator-() const { return mint(0) - *this; }
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 { return mint(*this) += a; }
mint operator-(const mint &a) const { return mint(*this) -= a; }
mint operator*(const mint &a) const { return mint(*this) *= a; }
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
};
istream &operator>>(istream &i, mint &a) {
i >> a.x;
return i;
}
ostream &operator<<(ostream &o, const mint &a) {
o << a.x;
return o;
}
//
int main() {
string s;
cin >> s;
int ans = 1;
int n = s.size();
string t = "";
t += s[0];
string now = "";
for (int i = 2; i < n; i++) {
now += s[i];
if (now == t) {
continue;
} else {
ans++;
swap(t, now);
now = "";
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = 1; i <= (int)(n); i++)
#define drep(i, n) for (int i = (n)-1; i >= 0; i--)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// Mod int
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % mod + mod) % mod) {}
// mint(ll x):x(x){}
mint &fix() {
x = (x % mod + mod) % mod;
return *this;
}
mint operator-() const { return mint(0) - *this; }
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 { return mint(*this) += a; }
mint operator-(const mint &a) const { return mint(*this) -= a; }
mint operator*(const mint &a) const { return mint(*this) *= a; }
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
};
istream &operator>>(istream &i, mint &a) {
i >> a.x;
return i;
}
ostream &operator<<(ostream &o, const mint &a) {
o << a.x;
return o;
}
//
int main() {
string s;
cin >> s;
int ans = 1;
int n = s.size();
string t = "";
t += s[0];
string now = "";
for (int i = 1; i < n; i++) {
now += s[i];
if (now == t) {
continue;
} else {
ans++;
swap(t, now);
now = "";
}
}
cout << ans << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 741,238
| 741,239
|
u263000123
|
cpp
|
p02939
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define int long long
#define endl "\n"
#define fir first
#define sec second
#define fro front
#define m_p make_pair
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define vecin(v) \
for (int i = 0; i < (int)v.size(); i++) \
cin >> v[i];
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
int jousu(int x00, int y00) {
int z00 = 1;
for (int i = 0; i < y00; i++) {
z00 *= x00;
}
return z00;
}
int keta(int x00) {
int z00 = x00;
int w00 = 0;
while (z00 != 0) {
z00 /= 10;
w00++;
}
return w00;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int modpow(int a, int n) {
int res = 1;
while (n > 0) {
if (n & 1)
res *a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int gcd(int xx, int yy) {
int p = xx;
int q = yy;
if (q > p)
swap(p, q);
while (p % q != 0) {
p %= q;
swap(p, q);
}
return q;
}
int lcm(int xx, int yy) { return xx * yy / gcd(xx, yy); }
bool prime(int xx) {
int a = xx;
for (int i = 2; i * i <= xx; i++) {
if (xx % i == 0) {
return 0;
}
}
return 1;
}
int com(int xx, int yy) {
int zz = 1;
for (int i = xx; i > xx - yy; i--) {
zz *= i;
zz %= mod;
}
for (int i = 1; i <= yy; i++) {
zz *= modinv(i, mod);
zz %= mod;
}
return zz;
}
signed main() {
int i = 0, ans = 0;
string s;
char c = 'A';
cin >> s;
while (i < s.size()) {
if (s[i] != c) {
c = s[i];
i++;
ans++;
continue;
} else if (s[i] == c && i + 2 >= s.size()) {
break;
} else {
c = 'A';
i += 2;
ans++;
}
}
cout << ans << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define int long long
#define endl "\n"
#define fir first
#define sec second
#define fro front
#define m_p make_pair
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define vecin(v) \
for (int i = 0; i < (int)v.size(); i++) \
cin >> v[i];
using namespace std;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
int jousu(int x00, int y00) {
int z00 = 1;
for (int i = 0; i < y00; i++) {
z00 *= x00;
}
return z00;
}
int keta(int x00) {
int z00 = x00;
int w00 = 0;
while (z00 != 0) {
z00 /= 10;
w00++;
}
return w00;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int modpow(int a, int n) {
int res = 1;
while (n > 0) {
if (n & 1)
res *a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int gcd(int xx, int yy) {
int p = xx;
int q = yy;
if (q > p)
swap(p, q);
while (p % q != 0) {
p %= q;
swap(p, q);
}
return q;
}
int lcm(int xx, int yy) { return xx * yy / gcd(xx, yy); }
bool prime(int xx) {
int a = xx;
for (int i = 2; i * i <= xx; i++) {
if (xx % i == 0) {
return 0;
}
}
return 1;
}
int com(int xx, int yy) {
int zz = 1;
for (int i = xx; i > xx - yy; i--) {
zz *= i;
zz %= mod;
}
for (int i = 1; i <= yy; i++) {
zz *= modinv(i, mod);
zz %= mod;
}
return zz;
}
signed main() {
int i = 0, ans = 0;
string s;
char c = 'A';
cin >> s;
while (i < s.size()) {
if (s[i] != c) {
c = s[i];
i++;
ans++;
continue;
} else if (s[i] == c && i + 2 > s.size()) {
break;
} else {
c = 'A';
i += 2;
ans++;
}
}
cout << ans << endl;
}
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,240
| 741,241
|
u294700660
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
int main() {
string s;
cin >> s;
int ans = 1;
for (int i = 1; i < s.length(); i++) {
if (s[i] == s[i - 1] && i == s.length() - 1) {
continue;
}
if (s[i] == s[i - 1] && i == s.length() - 2) {
ans++;
continue;
}
if (s[i] == s[i - 1] && i != s.length() - 1) {
i += 2;
ans += 2;
continue;
}
ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
int main() {
string s;
cin >> s;
int ans = 1;
for (int i = 1; i < s.length(); i++) {
if (s[i] == s[i - 1] && i == s.length() - 1) {
continue;
}
if (s[i] == s[i - 1] && i == s.length() - 2) {
ans++;
break;
}
if (s[i] == s[i - 1] && i != s.length() - 1) {
i += 2;
ans += 2;
continue;
}
ans++;
}
cout << ans << endl;
}
|
[
"control_flow.continue.remove",
"control_flow.break.add"
] | 741,255
| 741,256
|
u818755983
|
cpp
|
p02939
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define str to_string
#define endl "\n"
#define PI 3.141592653589
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
// AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC
int main() {
string s;
char rem;
cin >> s;
int ans = 0;
bool skip = false;
for (int i = 0; i < s.size(); i++) {
if (skip) {
rem = s[i];
ans++;
skip = false;
continue;
}
if (i == 0) {
rem = s[0];
ans++;
} else {
if (rem == s[i]) {
skip = true;
} else {
rem = s[i];
ans++;
}
}
}
cout << ans << endl;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define str to_string
#define endl "\n"
#define PI 3.141592653589
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
// AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC
int main() {
string s;
char rem;
cin >> s;
int ans = 0;
bool skip = false;
for (int i = 0; i < s.size(); i++) {
if (skip) {
rem = 'A';
ans++;
skip = false;
continue;
}
if (i == 0) {
rem = s[0];
ans++;
} else {
if (rem == s[i]) {
skip = true;
} else {
rem = s[i];
ans++;
}
}
}
cout << ans << endl;
}
|
[] | 741,263
| 741,264
|
u926046014
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#define PI 3.141592653589
using namespace std;
using ll = long long;
template <typename T_char> T_char ToUpper(T_char cX) { return toupper(cX); }
int main() {
string s;
cin >> s;
int n = s.size();
int ans = 0;
bool flag = false;
int num = 0;
while (num < n) {
if (num == n - 2 && s[num] == s[num - 1]) {
ans++;
break;
}
if (flag && s[num] == s[num - 1]) {
ans++;
num += 2;
flag = false;
}
else {
ans++;
num++;
flag = true;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define PI 3.141592653589
using namespace std;
using ll = long long;
template <typename T_char> T_char ToUpper(T_char cX) { return toupper(cX); }
int main() {
string s;
cin >> s;
int n = s.size();
int ans = 0;
bool flag = false;
int num = 0;
while (num < n) {
if (num == n - 2 && s[num] == s[num + 1]) {
ans++;
break;
}
if (flag && s[num] == s[num - 1]) {
ans++;
num += 2;
flag = false;
} else {
ans++;
num++;
flag = true;
}
}
cout << ans << endl;
}
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 741,270
| 741,271
|
u145562832
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
string tmp = "";
int kotae = 0;
for (int i = 0; i < n; i++) {
int count = 1;
string a = s.substr(i, count);
if (tmp == a) {
while (tmp == a) {
count++;
a = s.substr(i, count);
i += count - 1;
}
}
if (i + 1 > n - 1)
break;
kotae++;
count = 1;
tmp = a;
}
cout << kotae << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
string tmp = "";
int kotae = 0;
for (int i = 0; i < n; i++) {
int count = 1;
string a = s.substr(i, count);
if (tmp == a) {
while (tmp == a) {
count++;
a = s.substr(i, count);
i += count - 1;
}
}
// cout<<a<<" ";
if (i + 1 > n)
break;
kotae++;
count = 1;
tmp = a;
}
cout << kotae << endl;
return 0;
}
|
[
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 741,296
| 741,297
|
u406647332
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define int long long
#define double long double
#define endl "\n"
#define pb push_back
#define PI 3.1415926535897932384626433832795l
#define F first
#define S second
#define mp make_pair
#define f(i, n) for (int i = 0; i < n; i++)
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define sort(v) sort((v).begin(), (v).end())
#define rsort(v) sort((v).rbegin(), (v).rend())
#define gcd(a, b) __gcd((a), (b))
#define minn(v) *min_element(v.begin(), v.end());
#define maxx(v) *max_element(v.begin(), v.end());
#define print(x) cout << (x) << endl;
#define sum(v) +x accumulate(v.begin(), v.end(), x);
typedef pair<int, int> pii;
typedef vector<int> vi;
// x.substr(start, length);
/*
// Create a vector containing n
//vectors of size m.
vector<vector<int> > vec( n , vector<int> (m, 0));
*/
struct type {
int k, i, j;
};
// to check if a no is prime or not?
bool isPrime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
// minimum subaaray sum of size k-sliding window approach
int findSubarray(int arr[], int n, int k) {
int window_sum = 0;
int min_window = INT_MAX;
int last = 0;
for (int i = 0; i < n; i++) {
window_sum += arr[i];
if (i + 1 >= k) {
if (min_window > window_sum) {
min_window = window_sum;
last = i;
}
window_sum -= arr[i + 1 - k];
}
}
int sum = 0;
for (int i = last - k + 1; i <= last; i++) {
sum += arr[i];
}
return sum;
}
// finds the next permutation to given sequence of nos
int nextpermutation(vi v) {
vi t = v;
sort(t);
int x = 0;
while (true) {
x++;
if (t == v) {
return x;
}
next_permutation(all(t));
}
}
signed main() {
fastio;
cout << fixed << setprecision(12);
string s;
cin >> s;
int n = s.length();
int ans = 0;
bool flag = true;
for (int i = 1; i < n; i++) {
if (flag and s[i] == s[i - 1]) {
if (i == n - 1)
break;
ans++;
i++;
flag = false;
} else {
ans++;
flag = true;
}
}
print(ans)
}
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define int long long
#define double long double
#define endl "\n"
#define pb push_back
#define PI 3.1415926535897932384626433832795l
#define F first
#define S second
#define mp make_pair
#define f(i, n) for (int i = 0; i < n; i++)
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define sort(v) sort((v).begin(), (v).end())
#define rsort(v) sort((v).rbegin(), (v).rend())
#define gcd(a, b) __gcd((a), (b))
#define minn(v) *min_element(v.begin(), v.end());
#define maxx(v) *max_element(v.begin(), v.end());
#define print(x) cout << (x) << endl;
#define sum(v) +x accumulate(v.begin(), v.end(), x);
typedef pair<int, int> pii;
typedef vector<int> vi;
// x.substr(start, length);
/*
// Create a vector containing n
//vectors of size m.
vector<vector<int> > vec( n , vector<int> (m, 0));
*/
struct type {
int k, i, j;
};
// to check if a no is prime or not?
bool isPrime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
// minimum subaaray sum of size k-sliding window approach
int findSubarray(int arr[], int n, int k) {
int window_sum = 0;
int min_window = INT_MAX;
int last = 0;
for (int i = 0; i < n; i++) {
window_sum += arr[i];
if (i + 1 >= k) {
if (min_window > window_sum) {
min_window = window_sum;
last = i;
}
window_sum -= arr[i + 1 - k];
}
}
int sum = 0;
for (int i = last - k + 1; i <= last; i++) {
sum += arr[i];
}
return sum;
}
// finds the next permutation to given sequence of nos
int nextpermutation(vi v) {
vi t = v;
sort(t);
int x = 0;
while (true) {
x++;
if (t == v) {
return x;
}
next_permutation(all(t));
}
}
signed main() {
fastio;
cout << fixed << setprecision(12);
string s;
cin >> s;
int n = s.length();
int ans = 1;
bool flag = true;
for (int i = 1; i < n; i++) {
if (flag and s[i] == s[i - 1]) {
if (i == n - 1)
break;
ans++;
i++;
flag = false;
} else {
ans++;
flag = true;
}
}
print(ans)
}
|
[
"literal.number.change",
"variable_declaration.value.change"
] | 741,304
| 741,305
|
u858929490
|
cpp
|
p02939
|
#include <iostream>
#include <string>
int main() {
std::string S;
std::cin >> S;
std::string subS = "";
int i = 0;
int k = 0;
while (i < S.size()) {
k++;
if (subS == S.substr(i, 1)) {
subS = S.substr(i, 2);
i += 2;
if (i >= S.size()) {
k--;
}
} else {
subS = S.substr(i, 1);
i++;
}
}
std::cout << k << std::endl;
}
|
#include <iostream>
#include <string>
int main() {
std::string S;
std::cin >> S;
std::string subS = "";
int i = 0;
int k = 0;
while (i < S.size()) {
k++;
if (subS == S.substr(i, 1)) {
subS = S.substr(i, 2);
i += 2;
if (i > S.size()) {
k--;
}
} else {
subS = S.substr(i, 1);
i++;
}
}
std::cout << k << std::endl;
}
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 741,312
| 741,313
|
u327750344
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int ans = 0;
string s1, s2 = " ";
for (int i = 0; i < (int)s.length(); i++) {
s1 += s[i];
if (s1 == s2)
continue;
s2 = s1;
s1 = " ";
ans++;
}
cout << ans - 1 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int ans = 0;
string s1, s2 = "";
for (int i = 0; i < (int)s.length(); i++) {
s1 += s[i];
if (s1 == s2)
continue;
s2 = s1;
s1 = "";
ans++;
}
cout << ans << "\n";
}
|
[
"literal.string.change",
"assignment.value.change",
"expression.operation.binary.remove"
] | 741,316
| 741,317
|
u422430159
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#define repl(i, l, r) for (int i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
string t, p = "";
int ans = 0;
rep(i, s.size() - 1) {
t += s[i];
if (t == p)
continue;
p = t;
t = "";
ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define repl(i, l, r) for (int i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
string t, p = "";
int ans = 0;
rep(i, s.size()) {
t += s[i];
if (t == p)
continue;
p = t;
t = "";
ans++;
}
cout << ans << endl;
return 0;
}
|
[
"expression.operation.binary.remove"
] | 741,322
| 741,323
|
u547099897
|
cpp
|
p02939
|
#include "bits/stdc++.h"
using namespace std;
void Main() {
string S;
cin >> S;
int ans = 0;
int took = -1;
string last = "";
for (int i = 0; i < S.size(); ++i) {
if (i == 0) {
last = S.substr(i, 1);
++ans;
took = 0;
continue;
}
string sub = S.substr(took, i - took);
if (last == sub) {
continue;
} else {
last = sub;
++ans;
took = i;
}
}
cout << ans << endl;
}
int main() {
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
void Main() {
string S;
cin >> S;
int ans = 0;
int took = -1;
string last = "";
for (int i = 0; i < S.size(); ++i) {
if (i == 0) {
last = S.substr(0, 1);
++ans;
took = 0;
continue;
}
string sub = S.substr(took + 1, i - took);
if (last == sub) {
continue;
} else {
last = sub;
++ans;
took = i;
}
}
cout << ans << endl;
}
int main() {
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
|
[
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 741,324
| 741,325
|
u138886316
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s, pre, post;
cin >> s;
pre = s.at(0), post = "";
int k = 0;
for (int i = 1; i < s.size(); i++) {
post += s[i];
if (pre != post) {
k++;
pre = post;
post = "";
}
}
cout << k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s, pre, post;
cin >> s;
pre = s.at(0), post = "";
int k = 1;
for (int i = 1; i < s.size(); i++) {
post += s.at(i);
if (pre != post) {
k++;
pre = post;
post = "";
}
}
cout << k << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"call.add"
] | 741,332
| 741,333
|
u889173297
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
string S;
cin >> S;
vector<int> g(S.size() + 1);
g.at(0) = 0;
g.at(1) = 1;
if (S.size() == 1) {
cout << 1 << endl;
return 0;
}
if (S.at(0) == S.at(1)) {
g.at(2) = 1;
} else {
g.at(2) = 2;
}
for (int i = 2; i < S.size(); ++i) {
if (S.at(i - 2) == S.at(i - 1)) {
g.at(i) = g.at(i - 3) + 2;
} else {
g.at(i) = g.at(i - 1) + 1;
}
}
cout << g.at(S.size()) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
string S;
cin >> S;
vector<int> g(S.size() + 1);
g.at(0) = 0;
g.at(1) = 1;
if (S.size() < 2) {
cout << 1 << endl;
return 0;
}
if (S.at(0) == S.at(1)) {
g.at(2) = 1;
} else {
g.at(2) = 2;
}
for (int i = 3; i <= S.size(); ++i) {
if (S.at(i - 2) == S.at(i - 1)) {
g.at(i) = g.at(i - 3) + 2;
} else {
g.at(i) = g.at(i - 1) + 1;
}
}
cout << g.at(S.size()) << endl;
}
|
[
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 741,338
| 741,339
|
u089241640
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
string S;
int main() {
cin >> S;
ll ans = 0;
bool prev_one = false;
rep(i, S.size()) {
// 最後の2個
if (i == S.size() - 2 && S[i] == S[i + 1]) {
ans++;
break;
}
// 直前の1個が同じ
if (prev_one && S[i] == S[i + 1]) {
// 2文字とる
i++;
ans++;
prev_one = false;
} else {
// 1文字とる
ans++;
prev_one = true;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
string S;
int main() {
cin >> S;
ll ans = 0;
bool prev_one = false;
rep(i, S.size()) {
// 最後の2個
if (i == S.size() - 2 && S[i] == S[i + 1]) {
ans++;
break;
}
// 直前の1個が同じ
if (prev_one && S[i] == S[i - 1]) {
// 2文字とる
i++;
ans++;
prev_one = false;
} else {
// 1文字とる
ans++;
prev_one = true;
}
}
cout << ans << endl;
}
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 741,344
| 741,345
|
u455366471
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
int dp[200001][2];
string s;
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = s.size();
s = '?' + s;
for (int i = 1; i <= n; i++) {
dp[i][1] = dp[i][2] = -1e9;
}
dp[1][1] = 0;
for (int i = 2; i <= n; i++) {
dp[i][1] = max(dp[i][1], dp[i - 1][2] + 1);
if (s[i] != s[i - 1])
dp[i][1] = max(dp[i][1], dp[i - 1][1] + 1);
dp[i][2] = max(dp[i][2], dp[i - 2][1] + 1);
if (i <= 3 || s[i] != s[i - 2] || s[i - 1] != s[i - 3])
dp[i][2] = max(dp[i][2], dp[i - 2][2] + 1);
}
cout << max(dp[n][1], dp[n][2]) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[200001][2];
string s;
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = s.size();
s = '?' + s;
for (int i = 1; i <= n; i++) {
dp[i][1] = dp[i][2] = -1e9;
}
dp[1][1] = 1;
for (int i = 2; i <= n; i++) {
dp[i][1] = max(dp[i][1], dp[i - 1][2] + 1);
if (s[i] != s[i - 1])
dp[i][1] = max(dp[i][1], dp[i - 1][1] + 1);
dp[i][2] = max(dp[i][2], dp[i - 2][1] + 1);
if (i <= 3 || s[i] != s[i - 2] || s[i - 1] != s[i - 3])
dp[i][2] = max(dp[i][2], dp[i - 2][2] + 1);
}
cout << max(dp[n][1], dp[n][2]) << endl;
}
|
[
"literal.number.change",
"assignment.value.change"
] | 741,356
| 741,357
|
u707303246
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
int dp[200001][2];
string s;
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = s.size();
s = '?' + s;
for (int i = 1; i <= n; i++) {
dp[i][1] = dp[i][2] = -1e9;
}
dp[1][1] = 0;
for (int i = 2; i <= n; i++) {
dp[i][1] = max(dp[i][1], dp[i - 1][2] + 1);
if (s[i] != s[i - 1])
dp[i][1] = max(dp[i][1], dp[i - 1][1] + 1);
dp[i][2] = max(dp[i][2], dp[i - 2][1] + 1);
if (i <= 3 || s[i] != s[i - 2] && s[i - 1] != s[i - 3])
dp[i][2] = max(dp[i][2], dp[i - 2][2] + 1);
}
cout << max(dp[n][1], dp[n][2]) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[200001][2];
string s;
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = s.size();
s = '?' + s;
for (int i = 1; i <= n; i++) {
dp[i][1] = dp[i][2] = -1e9;
}
dp[1][1] = 1;
for (int i = 2; i <= n; i++) {
dp[i][1] = max(dp[i][1], dp[i - 1][2] + 1);
if (s[i] != s[i - 1])
dp[i][1] = max(dp[i][1], dp[i - 1][1] + 1);
dp[i][2] = max(dp[i][2], dp[i - 2][1] + 1);
if (i <= 3 || s[i] != s[i - 2] || s[i - 1] != s[i - 3])
dp[i][2] = max(dp[i][2], dp[i - 2][2] + 1);
}
cout << max(dp[n][1], dp[n][2]) << endl;
}
|
[
"literal.number.change",
"assignment.value.change",
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 741,358
| 741,357
|
u707303246
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
cin >> S;
int N = S.size();
vector<int> dp(N, 0);
dp.at(0) == 1;
if (N > 1)
dp.at(1) = (S.at(0) == S.at(1)) ? 1 : 2;
if (N > 2)
dp.at(2) = (S.at(1) == S.at(2)) ? 2 : dp.at(1) + 1;
for (int i = 3; i < N; ++i) {
if (S.at(i - 1) != S.at(i)) {
dp.at(i) = dp.at(i - 1) + 1;
} else {
dp.at(i) = dp.at(i - 3) + 2;
}
}
cout << dp.at(N - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
cin >> S;
int N = S.size();
vector<int> dp(N, 0);
dp.at(0) = 1;
if (N > 1)
dp.at(1) = (S.at(0) == S.at(1)) ? 1 : 2;
if (N > 2)
dp.at(2) = (S.at(1) == S.at(2)) ? 2 : dp.at(1) + 1;
for (int i = 3; i < N; ++i) {
if (S.at(i - 1) != S.at(i)) {
dp.at(i) = dp.at(i - 1) + 1;
} else {
dp.at(i) = dp.at(i - 3) + 2;
}
}
cout << dp.at(N - 1) << endl;
return 0;
}
|
[
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 741,359
| 741,360
|
u433685759
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
string s;
int g[s.size()];
g[0] = 1;
if (s.size() == 1) {
cout << g[0] << endl;
return 0;
}
if (s[0] == s[1])
g[1] = 1;
else
g[1] = 2;
if (s.size() == 2) {
cout << g[1] << endl;
return 0;
}
if (s[1] != s[2])
g[2] = g[1] + 1;
else
g[2] = 2;
if (s.size() == 3) {
cout << g[2] << endl;
return 0;
}
for (int i = 3; i < s.size(); i++) {
if (s[i - 1] != s[i])
g[i] = g[i - 1] + 1;
else
g[i] = g[i - 3] + 2;
}
cout << g[s.size() - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
string s;
cin >> s;
int g[s.size()];
g[0] = 1;
if (s.size() == 1) {
cout << g[0] << endl;
return 0;
}
if (s[0] == s[1])
g[1] = 1;
else
g[1] = 2;
if (s.size() == 2) {
cout << g[1] << endl;
return 0;
}
if (s[1] != s[2])
g[2] = g[1] + 1;
else
g[2] = 2;
if (s.size() == 3) {
cout << g[2] << endl;
return 0;
}
for (int i = 3; i < s.size(); i++) {
if (s[i - 1] != s[i])
g[i] = g[i - 1] + 1;
else
g[i] = g[i - 3] + 2;
}
cout << g[s.size() - 1] << endl;
return 0;
}
|
[] | 741,367
| 741,368
|
u201553784
|
cpp
|
p02939
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ll int64_t
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rrep(i, n) for (ll i = 1; i <= n; i++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mod 1000000007
#define PI 3.141592653589793
#define vec vector
#define dump(x) cerr << #x << "=" << x << endl
using namespace std;
bool compare_by_b(pair<string, ll> a, pair<string, ll> b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
bool my_compare(pair<string, ll> a, pair<string, ll> b) {
if (a.first != b.first)
return a.first < b.first;
if (a.second != b.second)
return a.second > b.second;
else
return true;
}
ll factorial(ll n) {
ll x = 1;
rrep(i, n)(x *= i) %= mod;
return x;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
ll a = 1, count = 1;
string sub = s.substr(0, 1);
for (ll i = 1; i < s.size(); i++) {
string text = s.substr(a, i - a + 1);
if (sub == text)
continue;
else {
count++;
}
sub = text;
a = i + 1;
}
cout << a << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ll int64_t
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rrep(i, n) for (ll i = 1; i <= n; i++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mod 1000000007
#define PI 3.141592653589793
#define vec vector
#define dump(x) cerr << #x << "=" << x << endl
using namespace std;
bool compare_by_b(pair<string, ll> a, pair<string, ll> b) {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
bool my_compare(pair<string, ll> a, pair<string, ll> b) {
if (a.first != b.first)
return a.first < b.first;
if (a.second != b.second)
return a.second > b.second;
else
return true;
}
ll factorial(ll n) {
ll x = 1;
rrep(i, n)(x *= i) %= mod;
return x;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
ll a = 1, count = 1;
string sub = s.substr(0, 1);
for (ll i = 1; i < s.size(); i++) {
string text = s.substr(a, i - a + 1);
if (sub == text)
continue;
else {
count++;
}
sub = text;
a = i + 1;
}
cout << count << endl;
return 0;
}
|
[
"identifier.change",
"io.output.change"
] | 741,373
| 741,374
|
u356754940
|
cpp
|
p02939
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
// output
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
// utility
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define RFOR(i, a, n) for (int i = (n)-1; i >= (a); --i)
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define IN(a, x, b) (a <= x && x < b)
#define OUT(a, x, b) (x < a || b <= x)
template <class T> inline T chmax(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T chmin(T &a, const T b) {
return a = (a > b) ? b : a;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
/* const int MOD = 998244353; */
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT {
INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}
} INIT;
signed main() {
string s;
cin >> s;
int N = s.size();
int ans = 0;
string past = "A";
FOR(i, 1, N) {
if (past != s.substr(i, 1)) {
ans++;
past = s[i];
} else {
if (i != N - 1) {
ans++;
past = s[i] + s[i + 1];
}
i++;
}
}
cout << ans << "\n";
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
// output
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
// utility
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define RFOR(i, a, n) for (int i = (n)-1; i >= (a); --i)
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define IN(a, x, b) (a <= x && x < b)
#define OUT(a, x, b) (x < a || b <= x)
template <class T> inline T chmax(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T chmin(T &a, const T b) {
return a = (a > b) ? b : a;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
/* const int MOD = 998244353; */
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT {
INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}
} INIT;
signed main() {
string s;
cin >> s;
int N = s.size();
int ans = 0;
string past = "A";
REP(i, N) {
if (past != s.substr(i, 1)) {
ans++;
past = s[i];
} else {
if (i != N - 1) {
ans++;
past = s[i] + s[i + 1];
}
i++;
}
}
cout << ans << "\n";
return 0;
}
|
[
"call.arguments.change"
] | 741,379
| 741,380
|
u812973725
|
cpp
|
p02939
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
using vpii = vector<pair<int, int>>;
using vpll = vector<pair<ll, ll>>;
// ceil() 切り上げ, floor() 切り捨て
// next_permutation(all(x))
int main(void) {
string S;
cin >> S;
string A;
A += S[0];
int ans = 1, i = 1, j = 1;
while (i + j <= S.size()) {
j = 1;
while (A == S.substr(i, j)) {
j++;
if (i + j > S.size()) {
cout << ans << endl;
return (0);
}
}
ans++;
A = S.substr(i, j);
i += j;
}
cout << ans << endl;
return (0);
}
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
using vpii = vector<pair<int, int>>;
using vpll = vector<pair<ll, ll>>;
// ceil() 切り上げ, floor() 切り捨て
// next_permutation(all(x))
int main(void) {
string S;
cin >> S;
string A;
A += S[0];
int ans = 1, i = 1, j = 1;
while (i + 1 <= S.size()) {
j = 1;
while (A == S.substr(i, j)) {
j++;
if (i + j > S.size()) {
cout << ans << endl;
return (0);
}
}
ans++;
A = S.substr(i, j);
i += j;
}
cout << ans << endl;
return (0);
}
|
[
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.condition.change"
] | 741,387
| 741,388
|
u675042710
|
cpp
|
p02939
|
#include <bits/stdc++.h>
// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
using namespace std;
typedef long long ll;
// region template
#pragma region template
#define pb push_back
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
/**
* \brief Input helpers.
*/
namespace In {
template <class T> T in() {
T val;
cin >> val;
return val;
}
} // namespace In
/**
* \brief Various useful helpers for STL.
*/
namespace STL {
/**
* \brief Create a 2D vector<vector<T>> of dimension i * j.
*/
template <class T> vector<vector<T>> vector2(int i, int j) {
return vector<vector<T>>(i, vector<T>(j));
}
} // namespace STL
/**
* \brief Various useful utilities for competitive programming.
*/
namespace Util {
// sprintf that returns a string.
string ssprintf(const string fmt_str, ...) {
int final_n, n = ((int)fmt_str.size()) * 2;
unique_ptr<char[]> formatted;
va_list ap;
while (1) {
formatted.reset(new char[n]);
strcpy(&formatted[0], fmt_str.c_str());
va_start(ap, fmt_str);
final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
va_end(ap);
if (final_n < 0 || final_n >= n)
n += abs(final_n - n + 1);
else
break;
}
return string(formatted.get());
}
template <class T> void assign(T &a, T b) { a = b; }
template <class T, class U> void assign(T &a, U &b, T c, U d) { a = c, b = d; }
template <class T, class U, class V>
void assign(T &a, U &b, V &c, T d, U e, V f) {
a = d, b = e, c = f;
}
template <class T, class U, class V, class W>
void assign(T &a, U &b, V &c, W &d, T e, U f, V g, W h) {
a = e, b = f, c = g, d = h;
}
} // namespace Util
namespace Math {
ll modpow(ll b, ll p, ll m) {
ll r = 1;
for (; p; p >>= 1, b = b * b % m)
if (p & 1)
r = r * b % m;
return r;
}
ll modinv(ll b, ll m) { return modpow(b, m - 2, m); }
ll sumdigit(ll num) {
ll res = 0;
while (num) {
res += num % 10;
num /= 10;
}
return res;
}
ll sumdigit(string num) {
ll res = 0;
for (char c : num)
res += c - '0';
return res;
}
// Least significant bit.
ll lsb(ll x) { return x & (-x); }
template <class T> const T inf() { return 0; }
template <> const ll inf<ll>() { return 0x3f3f3f3f3f3f3f3fll; }
template <> const int inf<int>() { return 0x3f3f3f3f; }
template <class T> T gcd(T a, T b) { return abs(__gcd(a, b)); }
template <class T> T clamp(T n, T l, T r) { return n < l ? l : n > r ? r : n; }
template <class T> T lcm(T a, T b) { return abs(a / gcd(a, b) * b); }
template <class T> T sgn(T n) { return n == 0 ? 0 : n > 0 ? 1 : -1; }
template <class T, int size> struct Vector;
// Matrix class.
template <class T, int size_m, int size_n> struct Matrix {
T val[size_m][size_n];
Matrix() {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
val[i][j] = 0;
}
/**
* \brief Matrix type casting for another matrix of the same dimension.
*/
template <class U> Matrix(Matrix<U, size_m, size_n> mat) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
val[i][j] = mat.val[i][j];
}
/**
* \brief Construct a matrix from a 2D array.
*/
Matrix(T **arr) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
val[i][j] = arr[i][j];
}
/**
* \brief Returns the reference to the cell (i, j) in the matrix.
*/
T &operator()(const int i, const int j) { return val[i][j]; }
/**
* \brief Explicitly cast the matrix to Matrix<U>.
*/
template <class U> const Matrix<U, size_m, size_n> convert() {
return Matrix<U, size_m, size_n>(*this);
}
const Matrix operator+=(const Matrix<T, size_m, size_n> mat) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
(*this)(i, j) += mat(i, j);
}
const Matrix operator-=(const Matrix<T, size_m, size_n> mat) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
(*this)(i, j) -= mat(i, j);
}
const Matrix operator+(const Matrix<T, size_m, size_n> mat) {
Matrix<T, size_m, size_n> res = *this;
res += mat;
return res;
}
const Matrix operator-(const Matrix<T, size_m, size_n> mat) {
Matrix<T, size_m, size_n> res = *this;
res -= mat;
return res;
}
/**
* \brief Matrix-matrix multiplication.
*/
template <int size_p>
Matrix<T, size_m, size_p> operator*(Matrix<T, size_n, size_p> mat) {
Matrix<T, size_m, size_p> res;
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_p; j++)
for (int k = 0; k < size_n; k++)
res(i, j) += (*this)(i, k) * mat(k, j);
return res;
}
/**
* \brief Matrix-vector multiplication.
*/
Vector<T, size_n> operator*(Vector<T, size_n> vec) {
Vector<T, size_n> res;
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
res.val[j] += val[i][j] * vec[j];
return res;
}
};
// Vector class.
template <class T, int size> struct Vector {
/**
* Specialization for Vector of size 2.
*/
template <class U> static const Vector<U, 2> vec2(U a, U b) {
Vector<U, 2> vec;
vec.val[0] = a, vec.val[1] = b;
return vec;
}
/**
* Specialization for Vector of size 3.
*/
template <class U> static const Vector<U, 3> vec3(U a, U b, U c) {
Vector<U, 3> vec;
vec.val[0] = a, vec.val[1] = b, vec.val[2] = c;
return vec;
}
T val[size];
/**
* \brief Empty vector constructor.
*/
Vector() {
for (int i = 0; i < size; i++)
val[i] = 0;
}
/**
* \brief Vector type casting for another vector of the same size.
*/
template <class U> Vector(Vector<U, size> vec) {
for (int i = 0; i < size; i++)
val[i] = vec.val[i];
}
/**
* \brief Constructing a vector from an array.
*/
Vector(T *arr) {
for (int i = 0; i < size; i++)
val[i] = arr[i];
}
/**
* \brief Explicitly cast the vector to Vector<U> with the same size.
*/
template <class U> Vector<U, size> convert() {
return Vector<U, size>(*this);
}
const Vector operator+(const Vector &vec) const {
Vector v = *this;
v += vec;
return v;
}
const Vector operator-(const Vector &vec) const {
Vector v = *this;
v -= vec;
return v;
}
const Vector operator*(const Vector &vec) const {
Vector v = *this;
v *= vec;
return v;
}
const Vector operator/(const Vector &vec) const {
Vector v = *this;
v /= vec;
return v;
}
const Vector operator+=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] += vec.val[i];
return *this;
}
const Vector operator-=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] -= vec.val[i];
return *this;
}
const Vector operator*=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] *= vec.val[i];
return *this;
}
const Vector operator/=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] /= vec.val[i];
return *this;
}
/**
* \brief Compute the dot product of two vectors.
*/
const T dot(const Vector<T, size> vec) {
T acc = 0;
for (int i = 0; i < size; i++)
acc += val[i] * vec.val[i];
return acc;
}
};
struct Log2Table {
vector<int> val;
// Last value that we computed to.
int pmax = 0;
Log2Table() {
val.resize(1);
val[0] = -1;
}
int get(int n) {
if (n >= val.size()) {
eprintf("Error: request log2[%d] but is not computed yet\n", n);
exit(1);
}
return val[n];
}
void require(int n) {
if (n < pmax)
return;
val.resize(n + 1);
for (int i = 0; i < 30; i++)
for (int j = max(1 << i, pmax + 1); j < min(1 << (i + 1), n + 1); j++)
val[j] = i;
pmax = n;
}
};
Log2Table log2t;
// Generic modular integer.
template <int MOD, typename IntType = int> struct GModint {
IntType val;
GModint() : val(0) {}
GModint(int v, bool safe = false) {
val = safe ? v : ((v % MOD) + MOD) % MOD;
}
GModint(ll v, bool safe = false) { val = safe ? v : ((v % MOD) + MOD) % MOD; }
explicit operator bool() const { return val != 0; }
const bool operator==(const GModint &g) const { return val == g.val; }
const bool operator!=(const GModint &g) const { return val != g.val; }
const GModint operator+=(const GModint &g) { return *this = *this + g; }
const GModint operator-=(const GModint &g) { return *this = *this - g; }
const GModint operator*=(const GModint &g) { return *this = *this * g; }
const GModint operator/=(const GModint &g) { return *this = *this / g; }
const GModint operator^=(const GModint &g) { return *this = *this ^ g; }
const GModint operator-() const {
return GModint(val == 0 ? 0 : MOD - val, true);
}
const GModint operator+(const GModint &g) const {
ll newval = val + g.val;
if (newval >= MOD)
newval -= MOD;
return GModint(newval, true);
}
const GModint operator-(const GModint &g) const { return *this + (-g); }
const GModint operator*(const GModint &g) const {
return GModint(1ll * val * g.val);
}
const GModint operator/(const GModint &g) const { return *this * g.inv(); }
template <class T> const GModint operator^(const T t) const {
return GModint(modpow(val, t, MOD));
}
const GModint inv() const { return GModint(modinv(val, MOD)); }
};
using Modint = GModint<1000000007>;
} // namespace Math
namespace DS {
// Building a 0-based sparse table for associative operations.
// i.e. A op (B op C) = (A op B) op C
template <class T, class Combiner> struct SparseTable {
int n, nlog, base;
vector<vector<T>> st;
Combiner combiner;
SparseTable(int n, T *t, int base = 0) : n(n), base(base) {
Math::log2t.require(n);
nlog = Math::log2t.get(n);
st.resize(nlog + 1);
for (int i = 0; i <= nlog; i++)
st[i].resize(n + base);
for (int j = 0; j < n + base; j++)
st[0][j] = t[j];
for (int i = 1; i <= nlog; i++)
for (int j = 0; j + (1 << (i - 1)) < n; j++)
st[i][j] = combiner(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
T query(int l, int r) {
if (l > r) {
eprintf("Error: sparse table query (L, R) = (%d, %d).\n", l, r);
exit(1);
}
l = Math::clamp(l, 0, n - 1);
r = Math::clamp(r, 0, n - 1);
int len = Math::log2t.get(r - l + 1);
T val = st[len][l];
l += 1 << len;
if (l <= r)
val = combiner(val, query(l, r));
return val;
}
};
template <class T> struct SparseTableCombinerSample {
const T operator()(const T &a, const T &b) { return a + b; }
};
struct DSU {
int size;
vector<int> dsu, block;
DSU() {}
DSU(int size) { init(size); }
void init(int new_size) {
size = new_size;
dsu.resize(size + 1);
block.resize(size + 1);
for (int i = 0; i <= size; i++)
dsu[i] = i, block[i] = 1;
}
int find(int u) { return u == dsu[u] ? u : dsu[u] = find(dsu[u]); }
bool same_component(int u, int v) { return find(u) == find(v); }
void merge(int u, int v) {
if (!same_component(u, v)) {
block[find(u)] += block[find(v)];
dsu[find(v)] = find(u);
}
}
int block_size(int u) { return block[find(u)]; }
};
} // namespace DS
namespace Graph {
const int DEFAULT_NODE_LO = 1;
const int NODE_NIL = -1;
template <typename LenType> struct Edge {
int from, to;
LenType len;
Edge(int from, int to, LenType len) : from(from), to(to), len(len) {}
};
// The graph uses ID [lo, lo + n).
template <typename LenType> struct Graph {
using edge = Edge<LenType>;
vector<vector<edge>> G;
int n, lo;
Graph() {}
Graph(int size, int node_lo = DEFAULT_NODE_LO) { resize(size, node_lo); }
void resize(int new_size, int node_lo = DEFAULT_NODE_LO) {
n = new_size;
lo = node_lo;
G.resize(n + 1);
}
void add_edge(int from, int to, LenType len = 1) {
G[from].push_back(edge(from, to, len));
}
void add_bidir_edge(int u, int v, LenType len = 1) {
add_edge(u, v, len), add_edge(v, u, len);
}
};
template <typename LenType> struct BiColoring {
bool success = true;
vector<int> color;
BiColoring(Graph<LenType> G) {
color = vector<int>(G.n + 1, 0);
queue<int> Q;
Q.push(G.lo);
color[G.lo] = 1;
while (!Q.empty()) {
int node = Q.front();
Q.pop();
for (Edge<LenType> edge : G.G[node]) {
if (color[edge.to] == color[edge.from]) {
success = false;
return;
}
if (!color[edge.to]) {
color[edge.to] = color[edge.from] != 1 ? 1 : 2;
Q.push(edge.to);
}
}
}
}
};
template <typename LenType> struct FloydWarshall {
vector<vector<LenType>> dist;
FloydWarshall(Graph<LenType> G) {
dist = vector<vector<LenType>>(
G.n + 1, vector<LenType>(G.n + 1, Math::inf<LenType>()));
for (int i = G.lo; i < G.lo + G.n; i++)
dist[i][i] = 0;
for (int i = G.lo; i < G.lo + G.n; i++)
for (Edge<LenType> edge : G.G[i])
dist[edge.from][edge.to] = edge.len;
for (int k = G.lo; k < G.lo + G.n; k++)
for (int i = G.lo; i < G.lo + G.n; i++)
for (int j = G.lo; j < G.lo + G.n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
};
template <typename LenType> struct Tree : public Graph<LenType> {
using edge = typename Graph<LenType>::edge;
using Graph<LenType>::n;
using Graph<LenType>::G;
int root;
vector<LenType> depth, parent;
Tree() : Graph<LenType>() {}
Tree(int size) : Graph<LenType>(size) {}
void init_dfs(int n, int p = NODE_NIL) {
typename vector<edge>::iterator it_parent = G[n].end();
parent[n] = p;
for (typename vector<edge>::iterator it = G[n].begin(); it != G[n].end();
it++) {
if (it->to == p) {
it_parent = it;
} else {
depth[it->to] = depth[n] + it->len;
init_dfs(it->to, n);
}
}
}
void init_tree(int new_root = 1, int root_depth = 0) {
root = new_root;
depth.resize(n + 1);
parent.resize(n + 1);
depth[root] = root_depth;
init_dfs(root);
}
};
using UnweightedTree = Tree<int>;
struct LCA {
int n, nlog;
vector<int> depth;
vector<vector<int>> jump_table;
LCA(const UnweightedTree &tree) { init(tree); }
void init(const UnweightedTree &tree) {
n = tree.n;
depth = tree.depth;
Math::log2t.require(n);
nlog = Math::log2t.get(n);
jump_table.resize(nlog + 1);
for (int i = 0; i <= nlog; i++)
jump_table[i].resize(n + 1);
for (int i = 0; i <= n; i++)
jump_table[0][i] = tree.parent[i];
for (int i = 1; i <= nlog; i++)
for (int j = 0; j <= n; j++)
jump_table[i][j] = jump_table[i - 1][j] == NODE_NIL
? NODE_NIL
: jump_table[i - 1][jump_table[i - 1][j]];
}
int up(int node_id, int level) {
for (int i = nlog; i >= 0; i--)
if ((level >> i) & 1)
node_id = jump_table[i][node_id];
return node_id;
}
int lca(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
v = up(v, depth[v] - depth[u]);
if (u == v)
return u;
for (int i = nlog; i >= 0; i--)
if (jump_table[i][u] != jump_table[i][v])
u = jump_table[i][u], v = jump_table[i][v];
return jump_table[0][u];
}
int dist(int u, int v) {
int l = lca(u, v);
return depth[u] + depth[v] - 2 * depth[l];
}
int furthest_node(int node, int node_lo, int node_hi) {
int furthest = node, furthest_dist = 0;
for (int i = node_lo; i <= node_hi; i++)
if (i != node) {
int new_dist = dist(node, i);
if (new_dist > furthest_dist)
furthest = i, furthest_dist = new_dist;
}
return furthest;
}
int diameter(int node_lo, int node_hi) {
int node1 = furthest_node(node_lo, node_lo, node_hi);
int node2 = furthest_node(node1, node_lo, node_hi);
return dist(node1, node2);
}
};
} // namespace Graph
namespace Regex {
bool match(string regex_rule, string content) {
regex r(regex_rule);
return regex_match(content, r);
}
} // namespace Regex
template <int MOD>
ostream &operator<<(ostream &out, const Math::GModint<MOD> m) {
out << m.val;
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> v) {
out << "[";
for (typename vector<T>::iterator it = v.begin(); it != v.end(); it++) {
out << *it;
if (next(it) != v.end())
out << ", ";
}
out << "]";
return out;
}
template <class T, class U>
ostream &operator<<(ostream &out, const map<T, U> m) {
out << "{";
for (typename map<T, U>::const_iterator it = m.begin(); it != m.end(); it++) {
out << it->first << " -> " << it->second;
if (next(it) != m.end())
out << ", ";
}
out << "}";
return out;
}
template <class T> ostream &operator<<(ostream &out, const set<T> s) {
out << "(";
for (typename set<T>::iterator it = s.begin(); it != s.end(); it++) {
out << *it;
if (next(it) != s.end())
out << ", ";
}
out << ")";
return out;
}
template <class T, class U>
ostream &operator<<(ostream &out, const pair<T, U> p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
// endregion
#pragma endregion template
const int NINF = -0x3f3f3f3f;
int dp[200005][3];
int main() {
string s;
cin >> s;
if (s.length() == 1) {
cout << 1 << endl;
return 0;
}
dp[1][1] = 1;
dp[1][2] = NINF;
dp[2][2] = 1;
dp[2][1] = s[0] == s[1] ? NINF : 1;
for (int i = 3; i <= s.length(); i++) {
if (s[i - 1] != s[i - 2]) {
dp[i][1] = max(dp[i - 1][1], dp[i - 1][2]) + 1;
} else {
dp[i][1] = dp[i - 1][2] + 1;
}
dp[i][2] = dp[i - 2][1] + 1;
if (i >= 4 && (s[i - 1] != s[i - 3] || s[i - 2] != s[i - 4])) {
dp[i][2] = max(dp[i][2], dp[i - 2][2] + 1);
}
}
// for (int i = 1; i <= s.length(); i++)
// printf("%d ", dp[i][1]);
// printf("\n");
// for (int i = 1; i <= s.length(); i++)
// printf("%d ", dp[i][2]);
// printf("\n");
cout << max(dp[s.length()][1], dp[s.length()][2]) << endl;
}
|
#include <bits/stdc++.h>
// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
using namespace std;
typedef long long ll;
// region template
#pragma region template
#define pb push_back
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
/**
* \brief Input helpers.
*/
namespace In {
template <class T> T in() {
T val;
cin >> val;
return val;
}
} // namespace In
/**
* \brief Various useful helpers for STL.
*/
namespace STL {
/**
* \brief Create a 2D vector<vector<T>> of dimension i * j.
*/
template <class T> vector<vector<T>> vector2(int i, int j) {
return vector<vector<T>>(i, vector<T>(j));
}
} // namespace STL
/**
* \brief Various useful utilities for competitive programming.
*/
namespace Util {
// sprintf that returns a string.
string ssprintf(const string fmt_str, ...) {
int final_n, n = ((int)fmt_str.size()) * 2;
unique_ptr<char[]> formatted;
va_list ap;
while (1) {
formatted.reset(new char[n]);
strcpy(&formatted[0], fmt_str.c_str());
va_start(ap, fmt_str);
final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
va_end(ap);
if (final_n < 0 || final_n >= n)
n += abs(final_n - n + 1);
else
break;
}
return string(formatted.get());
}
template <class T> void assign(T &a, T b) { a = b; }
template <class T, class U> void assign(T &a, U &b, T c, U d) { a = c, b = d; }
template <class T, class U, class V>
void assign(T &a, U &b, V &c, T d, U e, V f) {
a = d, b = e, c = f;
}
template <class T, class U, class V, class W>
void assign(T &a, U &b, V &c, W &d, T e, U f, V g, W h) {
a = e, b = f, c = g, d = h;
}
} // namespace Util
namespace Math {
ll modpow(ll b, ll p, ll m) {
ll r = 1;
for (; p; p >>= 1, b = b * b % m)
if (p & 1)
r = r * b % m;
return r;
}
ll modinv(ll b, ll m) { return modpow(b, m - 2, m); }
ll sumdigit(ll num) {
ll res = 0;
while (num) {
res += num % 10;
num /= 10;
}
return res;
}
ll sumdigit(string num) {
ll res = 0;
for (char c : num)
res += c - '0';
return res;
}
// Least significant bit.
ll lsb(ll x) { return x & (-x); }
template <class T> const T inf() { return 0; }
template <> const ll inf<ll>() { return 0x3f3f3f3f3f3f3f3fll; }
template <> const int inf<int>() { return 0x3f3f3f3f; }
template <class T> T gcd(T a, T b) { return abs(__gcd(a, b)); }
template <class T> T clamp(T n, T l, T r) { return n < l ? l : n > r ? r : n; }
template <class T> T lcm(T a, T b) { return abs(a / gcd(a, b) * b); }
template <class T> T sgn(T n) { return n == 0 ? 0 : n > 0 ? 1 : -1; }
template <class T, int size> struct Vector;
// Matrix class.
template <class T, int size_m, int size_n> struct Matrix {
T val[size_m][size_n];
Matrix() {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
val[i][j] = 0;
}
/**
* \brief Matrix type casting for another matrix of the same dimension.
*/
template <class U> Matrix(Matrix<U, size_m, size_n> mat) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
val[i][j] = mat.val[i][j];
}
/**
* \brief Construct a matrix from a 2D array.
*/
Matrix(T **arr) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
val[i][j] = arr[i][j];
}
/**
* \brief Returns the reference to the cell (i, j) in the matrix.
*/
T &operator()(const int i, const int j) { return val[i][j]; }
/**
* \brief Explicitly cast the matrix to Matrix<U>.
*/
template <class U> const Matrix<U, size_m, size_n> convert() {
return Matrix<U, size_m, size_n>(*this);
}
const Matrix operator+=(const Matrix<T, size_m, size_n> mat) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
(*this)(i, j) += mat(i, j);
}
const Matrix operator-=(const Matrix<T, size_m, size_n> mat) {
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
(*this)(i, j) -= mat(i, j);
}
const Matrix operator+(const Matrix<T, size_m, size_n> mat) {
Matrix<T, size_m, size_n> res = *this;
res += mat;
return res;
}
const Matrix operator-(const Matrix<T, size_m, size_n> mat) {
Matrix<T, size_m, size_n> res = *this;
res -= mat;
return res;
}
/**
* \brief Matrix-matrix multiplication.
*/
template <int size_p>
Matrix<T, size_m, size_p> operator*(Matrix<T, size_n, size_p> mat) {
Matrix<T, size_m, size_p> res;
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_p; j++)
for (int k = 0; k < size_n; k++)
res(i, j) += (*this)(i, k) * mat(k, j);
return res;
}
/**
* \brief Matrix-vector multiplication.
*/
Vector<T, size_n> operator*(Vector<T, size_n> vec) {
Vector<T, size_n> res;
for (int i = 0; i < size_m; i++)
for (int j = 0; j < size_n; j++)
res.val[j] += val[i][j] * vec[j];
return res;
}
};
// Vector class.
template <class T, int size> struct Vector {
/**
* Specialization for Vector of size 2.
*/
template <class U> static const Vector<U, 2> vec2(U a, U b) {
Vector<U, 2> vec;
vec.val[0] = a, vec.val[1] = b;
return vec;
}
/**
* Specialization for Vector of size 3.
*/
template <class U> static const Vector<U, 3> vec3(U a, U b, U c) {
Vector<U, 3> vec;
vec.val[0] = a, vec.val[1] = b, vec.val[2] = c;
return vec;
}
T val[size];
/**
* \brief Empty vector constructor.
*/
Vector() {
for (int i = 0; i < size; i++)
val[i] = 0;
}
/**
* \brief Vector type casting for another vector of the same size.
*/
template <class U> Vector(Vector<U, size> vec) {
for (int i = 0; i < size; i++)
val[i] = vec.val[i];
}
/**
* \brief Constructing a vector from an array.
*/
Vector(T *arr) {
for (int i = 0; i < size; i++)
val[i] = arr[i];
}
/**
* \brief Explicitly cast the vector to Vector<U> with the same size.
*/
template <class U> Vector<U, size> convert() {
return Vector<U, size>(*this);
}
const Vector operator+(const Vector &vec) const {
Vector v = *this;
v += vec;
return v;
}
const Vector operator-(const Vector &vec) const {
Vector v = *this;
v -= vec;
return v;
}
const Vector operator*(const Vector &vec) const {
Vector v = *this;
v *= vec;
return v;
}
const Vector operator/(const Vector &vec) const {
Vector v = *this;
v /= vec;
return v;
}
const Vector operator+=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] += vec.val[i];
return *this;
}
const Vector operator-=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] -= vec.val[i];
return *this;
}
const Vector operator*=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] *= vec.val[i];
return *this;
}
const Vector operator/=(const Vector &vec) {
for (int i = 0; i < size; i++)
val[i] /= vec.val[i];
return *this;
}
/**
* \brief Compute the dot product of two vectors.
*/
const T dot(const Vector<T, size> vec) {
T acc = 0;
for (int i = 0; i < size; i++)
acc += val[i] * vec.val[i];
return acc;
}
};
struct Log2Table {
vector<int> val;
// Last value that we computed to.
int pmax = 0;
Log2Table() {
val.resize(1);
val[0] = -1;
}
int get(int n) {
if (n >= val.size()) {
eprintf("Error: request log2[%d] but is not computed yet\n", n);
exit(1);
}
return val[n];
}
void require(int n) {
if (n < pmax)
return;
val.resize(n + 1);
for (int i = 0; i < 30; i++)
for (int j = max(1 << i, pmax + 1); j < min(1 << (i + 1), n + 1); j++)
val[j] = i;
pmax = n;
}
};
Log2Table log2t;
// Generic modular integer.
template <int MOD, typename IntType = int> struct GModint {
IntType val;
GModint() : val(0) {}
GModint(int v, bool safe = false) {
val = safe ? v : ((v % MOD) + MOD) % MOD;
}
GModint(ll v, bool safe = false) { val = safe ? v : ((v % MOD) + MOD) % MOD; }
explicit operator bool() const { return val != 0; }
const bool operator==(const GModint &g) const { return val == g.val; }
const bool operator!=(const GModint &g) const { return val != g.val; }
const GModint operator+=(const GModint &g) { return *this = *this + g; }
const GModint operator-=(const GModint &g) { return *this = *this - g; }
const GModint operator*=(const GModint &g) { return *this = *this * g; }
const GModint operator/=(const GModint &g) { return *this = *this / g; }
const GModint operator^=(const GModint &g) { return *this = *this ^ g; }
const GModint operator-() const {
return GModint(val == 0 ? 0 : MOD - val, true);
}
const GModint operator+(const GModint &g) const {
ll newval = val + g.val;
if (newval >= MOD)
newval -= MOD;
return GModint(newval, true);
}
const GModint operator-(const GModint &g) const { return *this + (-g); }
const GModint operator*(const GModint &g) const {
return GModint(1ll * val * g.val);
}
const GModint operator/(const GModint &g) const { return *this * g.inv(); }
template <class T> const GModint operator^(const T t) const {
return GModint(modpow(val, t, MOD));
}
const GModint inv() const { return GModint(modinv(val, MOD)); }
};
using Modint = GModint<1000000007>;
} // namespace Math
namespace DS {
// Building a 0-based sparse table for associative operations.
// i.e. A op (B op C) = (A op B) op C
template <class T, class Combiner> struct SparseTable {
int n, nlog, base;
vector<vector<T>> st;
Combiner combiner;
SparseTable(int n, T *t, int base = 0) : n(n), base(base) {
Math::log2t.require(n);
nlog = Math::log2t.get(n);
st.resize(nlog + 1);
for (int i = 0; i <= nlog; i++)
st[i].resize(n + base);
for (int j = 0; j < n + base; j++)
st[0][j] = t[j];
for (int i = 1; i <= nlog; i++)
for (int j = 0; j + (1 << (i - 1)) < n; j++)
st[i][j] = combiner(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
T query(int l, int r) {
if (l > r) {
eprintf("Error: sparse table query (L, R) = (%d, %d).\n", l, r);
exit(1);
}
l = Math::clamp(l, 0, n - 1);
r = Math::clamp(r, 0, n - 1);
int len = Math::log2t.get(r - l + 1);
T val = st[len][l];
l += 1 << len;
if (l <= r)
val = combiner(val, query(l, r));
return val;
}
};
template <class T> struct SparseTableCombinerSample {
const T operator()(const T &a, const T &b) { return a + b; }
};
struct DSU {
int size;
vector<int> dsu, block;
DSU() {}
DSU(int size) { init(size); }
void init(int new_size) {
size = new_size;
dsu.resize(size + 1);
block.resize(size + 1);
for (int i = 0; i <= size; i++)
dsu[i] = i, block[i] = 1;
}
int find(int u) { return u == dsu[u] ? u : dsu[u] = find(dsu[u]); }
bool same_component(int u, int v) { return find(u) == find(v); }
void merge(int u, int v) {
if (!same_component(u, v)) {
block[find(u)] += block[find(v)];
dsu[find(v)] = find(u);
}
}
int block_size(int u) { return block[find(u)]; }
};
} // namespace DS
namespace Graph {
const int DEFAULT_NODE_LO = 1;
const int NODE_NIL = -1;
template <typename LenType> struct Edge {
int from, to;
LenType len;
Edge(int from, int to, LenType len) : from(from), to(to), len(len) {}
};
// The graph uses ID [lo, lo + n).
template <typename LenType> struct Graph {
using edge = Edge<LenType>;
vector<vector<edge>> G;
int n, lo;
Graph() {}
Graph(int size, int node_lo = DEFAULT_NODE_LO) { resize(size, node_lo); }
void resize(int new_size, int node_lo = DEFAULT_NODE_LO) {
n = new_size;
lo = node_lo;
G.resize(n + 1);
}
void add_edge(int from, int to, LenType len = 1) {
G[from].push_back(edge(from, to, len));
}
void add_bidir_edge(int u, int v, LenType len = 1) {
add_edge(u, v, len), add_edge(v, u, len);
}
};
template <typename LenType> struct BiColoring {
bool success = true;
vector<int> color;
BiColoring(Graph<LenType> G) {
color = vector<int>(G.n + 1, 0);
queue<int> Q;
Q.push(G.lo);
color[G.lo] = 1;
while (!Q.empty()) {
int node = Q.front();
Q.pop();
for (Edge<LenType> edge : G.G[node]) {
if (color[edge.to] == color[edge.from]) {
success = false;
return;
}
if (!color[edge.to]) {
color[edge.to] = color[edge.from] != 1 ? 1 : 2;
Q.push(edge.to);
}
}
}
}
};
template <typename LenType> struct FloydWarshall {
vector<vector<LenType>> dist;
FloydWarshall(Graph<LenType> G) {
dist = vector<vector<LenType>>(
G.n + 1, vector<LenType>(G.n + 1, Math::inf<LenType>()));
for (int i = G.lo; i < G.lo + G.n; i++)
dist[i][i] = 0;
for (int i = G.lo; i < G.lo + G.n; i++)
for (Edge<LenType> edge : G.G[i])
dist[edge.from][edge.to] = edge.len;
for (int k = G.lo; k < G.lo + G.n; k++)
for (int i = G.lo; i < G.lo + G.n; i++)
for (int j = G.lo; j < G.lo + G.n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
};
template <typename LenType> struct Tree : public Graph<LenType> {
using edge = typename Graph<LenType>::edge;
using Graph<LenType>::n;
using Graph<LenType>::G;
int root;
vector<LenType> depth, parent;
Tree() : Graph<LenType>() {}
Tree(int size) : Graph<LenType>(size) {}
void init_dfs(int n, int p = NODE_NIL) {
typename vector<edge>::iterator it_parent = G[n].end();
parent[n] = p;
for (typename vector<edge>::iterator it = G[n].begin(); it != G[n].end();
it++) {
if (it->to == p) {
it_parent = it;
} else {
depth[it->to] = depth[n] + it->len;
init_dfs(it->to, n);
}
}
}
void init_tree(int new_root = 1, int root_depth = 0) {
root = new_root;
depth.resize(n + 1);
parent.resize(n + 1);
depth[root] = root_depth;
init_dfs(root);
}
};
using UnweightedTree = Tree<int>;
struct LCA {
int n, nlog;
vector<int> depth;
vector<vector<int>> jump_table;
LCA(const UnweightedTree &tree) { init(tree); }
void init(const UnweightedTree &tree) {
n = tree.n;
depth = tree.depth;
Math::log2t.require(n);
nlog = Math::log2t.get(n);
jump_table.resize(nlog + 1);
for (int i = 0; i <= nlog; i++)
jump_table[i].resize(n + 1);
for (int i = 0; i <= n; i++)
jump_table[0][i] = tree.parent[i];
for (int i = 1; i <= nlog; i++)
for (int j = 0; j <= n; j++)
jump_table[i][j] = jump_table[i - 1][j] == NODE_NIL
? NODE_NIL
: jump_table[i - 1][jump_table[i - 1][j]];
}
int up(int node_id, int level) {
for (int i = nlog; i >= 0; i--)
if ((level >> i) & 1)
node_id = jump_table[i][node_id];
return node_id;
}
int lca(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
v = up(v, depth[v] - depth[u]);
if (u == v)
return u;
for (int i = nlog; i >= 0; i--)
if (jump_table[i][u] != jump_table[i][v])
u = jump_table[i][u], v = jump_table[i][v];
return jump_table[0][u];
}
int dist(int u, int v) {
int l = lca(u, v);
return depth[u] + depth[v] - 2 * depth[l];
}
int furthest_node(int node, int node_lo, int node_hi) {
int furthest = node, furthest_dist = 0;
for (int i = node_lo; i <= node_hi; i++)
if (i != node) {
int new_dist = dist(node, i);
if (new_dist > furthest_dist)
furthest = i, furthest_dist = new_dist;
}
return furthest;
}
int diameter(int node_lo, int node_hi) {
int node1 = furthest_node(node_lo, node_lo, node_hi);
int node2 = furthest_node(node1, node_lo, node_hi);
return dist(node1, node2);
}
};
} // namespace Graph
namespace Regex {
bool match(string regex_rule, string content) {
regex r(regex_rule);
return regex_match(content, r);
}
} // namespace Regex
template <int MOD>
ostream &operator<<(ostream &out, const Math::GModint<MOD> m) {
out << m.val;
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> v) {
out << "[";
for (typename vector<T>::iterator it = v.begin(); it != v.end(); it++) {
out << *it;
if (next(it) != v.end())
out << ", ";
}
out << "]";
return out;
}
template <class T, class U>
ostream &operator<<(ostream &out, const map<T, U> m) {
out << "{";
for (typename map<T, U>::const_iterator it = m.begin(); it != m.end(); it++) {
out << it->first << " -> " << it->second;
if (next(it) != m.end())
out << ", ";
}
out << "}";
return out;
}
template <class T> ostream &operator<<(ostream &out, const set<T> s) {
out << "(";
for (typename set<T>::iterator it = s.begin(); it != s.end(); it++) {
out << *it;
if (next(it) != s.end())
out << ", ";
}
out << ")";
return out;
}
template <class T, class U>
ostream &operator<<(ostream &out, const pair<T, U> p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
// endregion
#pragma endregion template
const int NINF = -0x3f3f3f3f;
int dp[200005][3];
int main() {
string s;
cin >> s;
if (s.length() == 1) {
cout << 1 << endl;
return 0;
}
dp[1][1] = 1;
dp[1][2] = NINF;
dp[2][2] = 1;
dp[2][1] = s[0] == s[1] ? NINF : 2;
for (int i = 3; i <= s.length(); i++) {
if (s[i - 1] != s[i - 2]) {
dp[i][1] = max(dp[i - 1][1], dp[i - 1][2]) + 1;
} else {
dp[i][1] = dp[i - 1][2] + 1;
}
dp[i][2] = dp[i - 2][1] + 1;
if (i >= 4 && (s[i - 1] != s[i - 3] || s[i - 2] != s[i - 4])) {
dp[i][2] = max(dp[i][2], dp[i - 2][2] + 1);
}
}
// for (int i = 1; i <= s.length(); i++)
// printf("%d ", dp[i][1]);
// printf("\n");
// for (int i = 1; i <= s.length(); i++)
// printf("%d ", dp[i][2]);
// printf("\n");
cout << max(dp[s.length()][1], dp[s.length()][2]) << endl;
}
|
[
"literal.number.change"
] | 741,401
| 741,402
|
u729337236
|
cpp
|
p02939
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const ll MOD_CONST = 1000000007;
const ll BIG_NUM = 1000000000000000000;
const int BIG_INT = 1000000000;
int main() {
string s;
cin >> s;
int len = s.length();
vector<int> dp(len + 1);
if (len == 1) {
cout << 1 << endl;
} else if (len == 2) {
cout << (s[0] == s[1] ? 1 : 2) << endl;
} else {
dp[0] = 1;
dp[1] = (s[0] == s[1] ? 1 : 2);
dp[2] = (s[0] != s[1] && s[1] != s[2] ? 3 : 2);
for (int i = 3; i < len; i++) {
if (s[i] == s[i - 1]) {
dp[i] = max(dp[i], dp[i - 3] + 2);
} else {
dp[i] = max(dp[i], dp[i] + 1);
}
}
cout << dp[len - 1] << endl;
}
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const ll MOD_CONST = 1000000007;
const ll BIG_NUM = 1000000000000000000;
const int BIG_INT = 1000000000;
int main() {
string s;
cin >> s;
int len = s.length();
vector<int> dp(len + 1);
if (len == 1) {
cout << 1 << endl;
} else if (len == 2) {
cout << (s[0] == s[1] ? 1 : 2) << endl;
} else {
dp[0] = 1;
dp[1] = (s[0] == s[1] ? 1 : 2);
dp[2] = (s[0] != s[1] && s[1] != s[2] ? 3 : 2);
for (int i = 3; i < len; i++) {
if (s[i] == s[i - 1]) {
dp[i] = max(dp[i], dp[i - 3] + 2);
} else {
dp[i] = max(dp[i], dp[i - 1] + 1);
}
}
cout << dp[len - 1] << endl;
}
}
|
[] | 741,407
| 741,408
|
u156778176
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll find(int n) {
int left = 1, right = n;
while (left < right) {
int mid = (left + right + 1) / 2;
if ((1ll * mid * (mid + 1)) / 2 > n) {
right = mid - 1;
} else {
left = mid;
}
}
return left;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
string s;
cin >> s;
vector<pair<int, int>> dp(s.size());
dp[0].first = 1;
dp[0].second = -1e9;
for (int i = 1; i < s.size(); ++i) {
if (s[i - 1] != s[i]) {
dp[i].first = max(dp[i - 1].first, dp[i - 1].second) + 1;
} else {
dp[i].first = dp[i - 1].second + 1;
}
if (i == 1) {
dp[i].second = 1;
} else if (i == 2) {
dp[i].second = 1 + dp[i - 2].first;
} else {
if (s[i] + s[i - 1] != s[i - 2] + s[i - 3]) {
dp[i].second = max(dp[i - 2].first, dp[i - 2].second) + 1;
} else {
dp[i].second = dp[i - 2].first;
}
}
}
cout << max(dp[s.size() - 1].first, dp[s.size() - 1].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll find(int n) {
int left = 1, right = n;
while (left < right) {
int mid = (left + right + 1) / 2;
if ((1ll * mid * (mid + 1)) / 2 > n) {
right = mid - 1;
} else {
left = mid;
}
}
return left;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
string s;
cin >> s;
vector<pair<int, int>> dp(s.size());
dp[0].first = 1;
dp[0].second = -1e9;
for (int i = 1; i < s.size(); ++i) {
if (s[i - 1] != s[i]) {
dp[i].first = max(dp[i - 1].first, dp[i - 1].second) + 1;
} else {
dp[i].first = dp[i - 1].second + 1;
}
if (i == 1) {
dp[i].second = 1;
} else if (i == 2) {
dp[i].second = 1 + dp[i - 2].first;
} else {
if (s[i] + s[i - 1] != s[i - 2] + s[i - 3]) {
dp[i].second = max(dp[i - 2].first, dp[i - 2].second) + 1;
} else {
dp[i].second = dp[i - 2].first + 1;
}
}
}
cout << max(dp[s.size() - 1].first, dp[s.size() - 1].second);
return 0;
}
|
[
"assignment.change"
] | 741,409
| 741,410
|
u225717512
|
cpp
|
p02939
|
#include <bits/stdc++.h>
using namespace std;
const int n = 2 * 1e5;
int a[n];
int main() {
string s;
cin >> s;
int e = 0;
for (int i = 1; i < s.size(); i++) {
if (s[i] != s[i - 1]) {
e++;
}
if (s[i] == s[i - 1]) {
if (i == s.size() - 1 - 2) {
cout << e + 2;
return 0;
}
if (i == s.size() - 1 - 1) {
cout << e + 1;
return 0;
}
if (i == s.size() - 1) {
cout << e;
return 0;
}
e += 2;
i += 2;
}
}
cout << e + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int n = 2 * 1e5;
int a[n];
int main() {
string s;
cin >> s;
int e = 0;
for (int i = 1; i < s.size(); i++) {
if (s[i] != s[i - 1]) {
e++;
}
if (s[i] == s[i - 1]) {
if (i == s.size() - 1 - 2) {
cout << e + 3;
return 0;
}
if (i == s.size() - 1 - 1) {
cout << e + 2;
return 0;
}
if (i == s.size() - 1) {
cout << e + 1;
return 0;
}
e += 2;
i += 2;
}
}
cout << e + 1;
}
|
[
"literal.number.change",
"io.output.change"
] | 741,413
| 741,414
|
u994462919
|
cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.