problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p02970 | // abc134_b
// #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main(void) {
int N, D;
cin >> N >> D;
int count = 0;
int i = D + 1;
for (; i <= N; i = i + 2 * D + 1) {
count++;
// cout << i << endl;
}
if (N > i - D) {
count++;
// cout << i - D << endl;
}
cout << count << endl;
} | // abc134_b
// #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main(void) {
int N, D;
cin >> N >> D;
int count = 0;
int i = D + 1;
for (; i <= N; i = i + 2 * D + 1) {
count++;
}
if (N > i - D - 1) {
count++;
}
cout << count << endl;
} | [
"control_flow.branch.if.condition.change"
] | 774,718 | 774,719 | u798557584 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << ceil(a / (b * 2 + 1)) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
double a, b;
cin >> a >> b;
cout << ceil(a / (b * 2 + 1)) << endl;
} | [
"variable_declaration.type.primitive.change"
] | 774,733 | 774,734 | u913008467 | cpp |
p02970 | #include <algorithm>
#include <array>
#include <cmath>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
namespace io {
// Input
void in() {}
template <class T, class... Ts> void in(T &a, Ts &...as) {
cin >> a;
in(as...);
}
template <class V> istream &operator>>(istream &i, vector<V> &a) {
for (auto &e : a)
i >> e;
return i;
}
template <class F, class S>
istream &operator>>(istream &i, pair<F, S> const &p) {
return i >> p.first >> p.second;
}
template <class... Ts> istream &tuple_in(istream &i, Ts &...ts);
istream &tuple_in(istream &i) { return i; }
template <class T, class... Ts> istream &tuple_in(istream &i, T &t, Ts &...ts) {
return tuple_in(i >> t, ts...);
}
template <class... Ts, size_t... I>
istream &input_tuple(istream &i, tuple<Ts...> &t, index_sequence<I...>) {
return tuple_in(i, get<I>(t)...);
}
template <class... Ts> istream &operator>>(istream &i, tuple<Ts...> &t) {
return input_tuple(i, t,
make_index_sequence<tuple_size<tuple<Ts...>>::value>());
}
// Output
void out() { cout << endl; }
template <class T> void out(T const &a) { cout << a << endl; }
template <class T, class... Ts> void out(T const &a, Ts const &...as) {
cout << a << " ";
out(as...);
}
template <class F, class S>
ostream &operator<<(ostream &o, pair<F, S> const &p) {
return o << "(" << p.first << " : " << p.second << ")";
}
template <class... Ts> ostream &tuple_out(ostream &o, Ts const &...ts);
ostream &tuple_out(ostream &o) { return o; }
template <class T> ostream &tuple_out(ostream &o, T const &t) { return o << t; }
template <class T0, class T1, class... Ts>
ostream &tuple_out(ostream &o, T0 const &t0, T1 const &t1, Ts const &...ts) {
return tuple_out(o << t0 << ",", t1, ts...);
}
template <class... Ts, size_t... I>
ostream &output_tuple(ostream &o, tuple<Ts...> const &t, index_sequence<I...>) {
return tuple_out(o, get<I>(t)...);
}
template <class... Ts> ostream &operator<<(ostream &o, tuple<Ts...> const &t) {
return output_tuple(o << "(", t,
make_index_sequence<tuple_size<tuple<Ts...>>::value>())
<< ")";
}
template <class C,
typename enable_if<!is_pointer<C>::value && !is_array<C>::value &&
!is_same<C, char>::value &&
!is_same<C, string>::value,
nullptr_t>::type = nullptr>
ostream &operator<<(ostream &o, C const &a) {
return a.empty() ? (o << "[]") : ([&o, &a]() -> ostream & {
o << "[" << *a.begin();
accumulate(next(a.begin()), a.end(), 0,
[&o](auto &x, auto e) { return (o << "," << e), x; });
return o << "]";
}());
}
} // namespace io
template <class... Xs> void input(Xs &...xs) { io::in(xs...); }
template <class... Xs> void print(Xs const &...xs) { io::out(xs...); }
// Hash
namespace hashcode {
template <class... Ts> size_t hash_args(size_t h, Ts const &...ts);
size_t hash_args(size_t h) { return h; }
template <class T> size_t hash_args(size_t h, T const &t) {
return h * 31 + hash<T>{}(t);
}
template <class T0, class T1, class... Ts>
size_t hash_args(size_t h, T0 const &t0, T1 const &t1, Ts const &...ts) {
return hash_args(h * 31 + hash<T0>{}(t0), t1, ts...);
}
template <class... Ts, size_t... I>
size_t hash_tuple(tuple<Ts...> const &t, index_sequence<I...>) {
return hash_args(17, get<I>(t)...);
}
} // namespace hashcode
namespace std {
template <class... Ts> struct hash<tuple<Ts...>> {
size_t operator()(tuple<Ts...> const &t) const {
return hashcode::hash_tuple(t, index_sequence_for<Ts...>());
}
};
template <class T> struct hash<unordered_set<T>> {
size_t operator()(unordered_set<T> const &s) const {
return accumulate(s.begin(), s.end(), 0, [](auto const &a, auto const &e) {
return a + hash<T>{}(e);
});
}
};
} // namespace std
// Range
using namespace std;
using lli = long long int;
template <class T = lli> vector<T> range(T begin, T end) {
vector<T> ret(end - begin);
iota(ret.begin(), ret.end(), begin);
return ret;
}
template <class T = lli> vector<T> range(T end) { return range(T(), end); }
template <class T = lli> vector<T> vec(size_t n, T &&init = T()) {
return vector<T>(n, init);
}
template <class Itr, class T = typename iterator_traits<Itr>::value_type>
vector<T> vec(Itr begin, Itr end) {
return vector<T>(begin, end);
}
// MOD
constexpr lli gcd(lli const p, lli const q) {
return q == 0 ? p : gcd(q, p % q);
}
constexpr lli pow(lli const a, lli const n, lli const m) {
return (!n) ? 1
: (n & 1) ? (((a % m) * pow(a, n - 1, m)) % m)
: [=] {
lli b = pow(a, n / 2, m);
return (b * b) % m;
}();
}
constexpr lli inv(lli const a, lli const p) { return pow(a, p - 2, p); }
constexpr lli MOD = 1e9 + 7;
// Main
int main() {
lli N, D;
input(N, D);
print(static_cast<int>(ceil(N / (D * 2.0))));
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
namespace io {
// Input
void in() {}
template <class T, class... Ts> void in(T &a, Ts &...as) {
cin >> a;
in(as...);
}
template <class V> istream &operator>>(istream &i, vector<V> &a) {
for (auto &e : a)
i >> e;
return i;
}
template <class F, class S>
istream &operator>>(istream &i, pair<F, S> const &p) {
return i >> p.first >> p.second;
}
template <class... Ts> istream &tuple_in(istream &i, Ts &...ts);
istream &tuple_in(istream &i) { return i; }
template <class T, class... Ts> istream &tuple_in(istream &i, T &t, Ts &...ts) {
return tuple_in(i >> t, ts...);
}
template <class... Ts, size_t... I>
istream &input_tuple(istream &i, tuple<Ts...> &t, index_sequence<I...>) {
return tuple_in(i, get<I>(t)...);
}
template <class... Ts> istream &operator>>(istream &i, tuple<Ts...> &t) {
return input_tuple(i, t,
make_index_sequence<tuple_size<tuple<Ts...>>::value>());
}
// Output
void out() { cout << endl; }
template <class T> void out(T const &a) { cout << a << endl; }
template <class T, class... Ts> void out(T const &a, Ts const &...as) {
cout << a << " ";
out(as...);
}
template <class F, class S>
ostream &operator<<(ostream &o, pair<F, S> const &p) {
return o << "(" << p.first << " : " << p.second << ")";
}
template <class... Ts> ostream &tuple_out(ostream &o, Ts const &...ts);
ostream &tuple_out(ostream &o) { return o; }
template <class T> ostream &tuple_out(ostream &o, T const &t) { return o << t; }
template <class T0, class T1, class... Ts>
ostream &tuple_out(ostream &o, T0 const &t0, T1 const &t1, Ts const &...ts) {
return tuple_out(o << t0 << ",", t1, ts...);
}
template <class... Ts, size_t... I>
ostream &output_tuple(ostream &o, tuple<Ts...> const &t, index_sequence<I...>) {
return tuple_out(o, get<I>(t)...);
}
template <class... Ts> ostream &operator<<(ostream &o, tuple<Ts...> const &t) {
return output_tuple(o << "(", t,
make_index_sequence<tuple_size<tuple<Ts...>>::value>())
<< ")";
}
template <class C,
typename enable_if<!is_pointer<C>::value && !is_array<C>::value &&
!is_same<C, char>::value &&
!is_same<C, string>::value,
nullptr_t>::type = nullptr>
ostream &operator<<(ostream &o, C const &a) {
return a.empty() ? (o << "[]") : ([&o, &a]() -> ostream & {
o << "[" << *a.begin();
accumulate(next(a.begin()), a.end(), 0,
[&o](auto &x, auto e) { return (o << "," << e), x; });
return o << "]";
}());
}
} // namespace io
template <class... Xs> void input(Xs &...xs) { io::in(xs...); }
template <class... Xs> void print(Xs const &...xs) { io::out(xs...); }
// Hash
namespace hashcode {
template <class... Ts> size_t hash_args(size_t h, Ts const &...ts);
size_t hash_args(size_t h) { return h; }
template <class T> size_t hash_args(size_t h, T const &t) {
return h * 31 + hash<T>{}(t);
}
template <class T0, class T1, class... Ts>
size_t hash_args(size_t h, T0 const &t0, T1 const &t1, Ts const &...ts) {
return hash_args(h * 31 + hash<T0>{}(t0), t1, ts...);
}
template <class... Ts, size_t... I>
size_t hash_tuple(tuple<Ts...> const &t, index_sequence<I...>) {
return hash_args(17, get<I>(t)...);
}
} // namespace hashcode
namespace std {
template <class... Ts> struct hash<tuple<Ts...>> {
size_t operator()(tuple<Ts...> const &t) const {
return hashcode::hash_tuple(t, index_sequence_for<Ts...>());
}
};
template <class T> struct hash<unordered_set<T>> {
size_t operator()(unordered_set<T> const &s) const {
return accumulate(s.begin(), s.end(), 0, [](auto const &a, auto const &e) {
return a + hash<T>{}(e);
});
}
};
} // namespace std
// Range
using namespace std;
using lli = long long int;
template <class T = lli> vector<T> range(T begin, T end) {
vector<T> ret(end - begin);
iota(ret.begin(), ret.end(), begin);
return ret;
}
template <class T = lli> vector<T> range(T end) { return range(T(), end); }
template <class T = lli> vector<T> vec(size_t n, T &&init = T()) {
return vector<T>(n, init);
}
template <class Itr, class T = typename iterator_traits<Itr>::value_type>
vector<T> vec(Itr begin, Itr end) {
return vector<T>(begin, end);
}
// MOD
constexpr lli gcd(lli const p, lli const q) {
return q == 0 ? p : gcd(q, p % q);
}
constexpr lli pow(lli const a, lli const n, lli const m) {
return (!n) ? 1
: (n & 1) ? (((a % m) * pow(a, n - 1, m)) % m)
: [=] {
lli b = pow(a, n / 2, m);
return (b * b) % m;
}();
}
constexpr lli inv(lli const a, lli const p) { return pow(a, p - 2, p); }
constexpr lli MOD = 1e9 + 7;
// Main
int main() {
lli N, D;
input(N, D);
print(static_cast<int>(ceil(N / (1 + (D * 2.0)))));
}
| [
"call.arguments.change"
] | 774,754 | 774,755 | u465699806 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int i = 0;
while ((2 * D + 1) * i < N) {
i++;
}
cout << i + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int i = 0;
while ((2 * D + 1) * i < N) {
i++;
}
cout << i << endl;
}
| [
"expression.operation.binary.remove"
] | 774,769 | 774,770 | u591755251 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int tph = 2 * d + 1;
int ans = 0;
for (int i = 0; i < n; i++) {
if (n > tph * i) {
ans = i;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int tph = 2 * d + 1;
int ans = 0;
for (int i = 0; i < n; i++) {
if (n > tph * i) {
ans = i + 1;
}
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 774,785 | 774,786 | u453634104 | cpp |
p02970 | #include <iostream>
using namespace std;
int main() {
int n, d, num;
cin >> n >> d;
num = (n + (2 * d - 1)) / (2 * d);
cout << num << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, d, num;
cin >> n >> d;
num = (n + (2 * d)) / (2 * d + 1);
cout << num << endl;
return 0;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 774,799 | 774,800 | u830087664 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans;
double n, d, reg;
cin >> n;
cin >> d;
reg = n / (2 * d + 1);
ans = int(reg + 0.9);
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans;
double n, d, reg;
cin >> n;
cin >> d;
reg = n / (2 * d + 1);
ans = int(reg + 0.999);
cout << ans;
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 774,814 | 774,815 | u540741303 | cpp |
p02970 | #include <stdio.h>
int main() {
int n, d, j;
int i = 0;
scanf("%d", &n);
scanf("%d", &d);
for (j = 1; j <= n; j = j + (2 * d) + 1) {
i++;
}
printf("%d", i + 1);
return 0;
} | #include <stdio.h>
int main() {
int n, d, j;
int i = 0;
scanf("%d", &n);
scanf("%d", &d);
for (j = 1; j <= n; j = j + (2 * d) + 1) {
i++;
}
printf("%d", i);
return 0;
} | [
"expression.operation.binary.remove"
] | 774,851 | 774,852 | u488700515 | cpp |
p02970 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
int main() {
int n, d;
cin >> n >> d;
int a = d * 2 - 1;
cout << (n + a - 1) / a << endl;
return 0;
} | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
int main() {
int n, d;
cin >> n >> d;
int a = d * 2 + 1;
cout << (n + a - 1) / a << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 774,869 | 774,870 | u654240084 | cpp |
p02970 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
int main() {
int n, d;
cin >> n >> d;
int a = d * 2;
cout << (n + a - 1) / a << endl;
return 0;
} | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
int main() {
int n, d;
cin >> n >> d;
int a = d * 2 + 1;
cout << (n + a - 1) / a << endl;
} | [
"assignment.change"
] | 774,871 | 774,870 | u654240084 | cpp |
p02970 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int k = N / (2 * D + 1);
int l = (N % (2 * D + 1)) / (2 * D + 1);
cout << k + l << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int k = N / (2 * D + 1);
int l = ((N % (2 * D + 1)) + 2 * D) / (2 * D + 1);
cout << k + l << endl;
} | [] | 774,877 | 774,878 | u548684908 | cpp |
p02970 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int x;
x = ceil(N / 2.0 / D);
cout << x << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
int x;
x = ceil(N / (2.0 * D + 1));
cout << x << endl;
return 0;
} | [
"call.arguments.change",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 774,883 | 774,884 | u975472502 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
cout << ceil(n / ((2 * d) + 1)) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
cout << ceil((float)n / (float)((2 * d) + 1)) << endl;
return 0;
} | [
"type_conversion.add"
] | 774,908 | 774,909 | u230086201 | cpp |
p02970 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int NN = 1;
int main() {
double ans;
double a, b;
scanf("%lf%lf", &a, &b);
ans = ceil(a / (2.0 * b));
printf("%.0f\n", ans);
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
const int NN = 1;
int main() {
double ans;
double a, b;
scanf("%lf%lf", &a, &b);
ans = ceil(a / (2.0 * b + 1.0));
printf("%.0f\n", ans);
}
| [
"assignment.change"
] | 774,932 | 774,933 | u463734200 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, d, a;
cin >> N >> d;
a = 0;
for (int now = 0; now <= N;) {
a++;
now += 2 * d + 1;
}
cout << a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, d, a;
cin >> N >> d;
a = 0;
for (int now = 0; now < N;) {
a++;
now += 2 * d + 1;
}
cout << a << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 774,936 | 774,937 | u222866518 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, d, a;
cin >> N >> d;
a = 0;
for (int now = d; now <= N;) {
a++;
now += 2 * d + 1;
}
cout << a << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, d, a;
cin >> N >> d;
a = 0;
for (int now = 0; now < N;) {
a++;
now += 2 * d + 1;
}
cout << a << endl;
}
| [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 774,938 | 774,937 | u222866518 | cpp |
p02970 | #include <bits/stdc++.h>
#include <iomanip>
#include <numeric>
using namespace std;
using ll = long long;
constexpr int mo = 1e9 + 7;
constexpr int mod = mo;
constexpr ll inf = 1ll << 62;
int main() {
int n, d;
cin >> n >> d;
d = 2 * d + 1;
d *= 2;
n = (d - 1) + n;
cout << n / d << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iomanip>
#include <numeric>
using namespace std;
using ll = long long;
constexpr int mo = 1e9 + 7;
constexpr int mod = mo;
constexpr ll inf = 1ll << 62;
int main() {
int n, d;
cin >> n >> d;
d = 2 * d + 1;
n = (d - 1) + n;
cout << n / d << endl;
return 0;
}
| [] | 774,939 | 774,940 | u699193595 | cpp |
p02970 | #include <math.h>
#include <stdio.h>
int cul(int, int);
int main(void) {
int N, D, num;
scanf("%d %d", &N, &D);
num = cul(N, D);
printf("%d\n", num);
return 0;
}
int cul(int N, int D) {
int num;
num = ceil(double(N) / (2 * double(D + 1)));
return num;
} | #include <math.h>
#include <stdio.h>
int cul(int, int);
int main(void) {
int N, D, num;
scanf("%d %d", &N, &D);
num = cul(N, D);
printf("%d\n", num);
return 0;
}
int cul(int N, int D) {
int num;
num = ceil(double(N) / (2 * double(D) + 1));
return num;
} | [
"call.arguments.change"
] | 774,941 | 774,942 | u456658814 | cpp |
p02970 | #include <bits/stdc++.h>
#define ll long long int
#define pb push_back
using namespace std;
const int M = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, d;
cin >> n >> d;
int ans = 0;
int i = 1;
while (i < n) {
i = i + d + d + 1;
ans++;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
#define pb push_back
using namespace std;
const int M = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, d;
cin >> n >> d;
int ans = 0;
int i = 1;
while (i <= n) {
i = i + d + d + 1;
// cout<<i<<endl;
ans++;
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 774,969 | 774,970 | u912430437 | cpp |
p02970 | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int gcd(int a, int b) {
int c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
typedef long long ll;
ll M = 1000000007;
vector<ll> fac(300001); // n!(mod M)
vector<ll> ifac(300001); // k!^{M-2} (mod M)
ll mpow(ll x, ll n) {
ll ans = 1;
while (n != 0) {
if (n & 1)
ans = ans * x % M;
x = x * x % M;
n = n >> 1;
}
return ans;
}
void setcomb() {
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 300000; i++) {
fac[i + 1] = fac[i] * (i + 1) % M; // n!(mod M)
ifac[i + 1] =
ifac[i] * mpow(i + 1, M - 2) % M; // k!^{M-2} (mod M) ←累乗にmpowを採用
}
}
ll comb(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % M;
return tmp * fac[a] % M;
}
ll perm(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
return fac[a] * ifac[a - b] % M;
}
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a) {
long long b = M, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= M;
if (u < 0)
u += M;
return u;
}
vector<vector<ll>> mul(vector<vector<ll>> a, vector<vector<ll>> b, int n) {
int i, j, k, t;
vector<vector<ll>> c(n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
t = 0;
for (k = 0; k < n; k++)
t = (t + a[i][k] * b[k][j] % M) % M;
c[i].push_back(t);
}
}
return c;
}
template <typename Monoid> struct SegmentTree {
int sz;
vector<Monoid> seg;
const Monoid M1;
SegmentTree(int n, const Monoid &M1) : M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid value(const int &k) const { return seg[k + sz]; }
Monoid f(Monoid a, Monoid b) { return a + b; }
};
int main() {
int a, b;
cin >> a >> b;
b = b * b + 1;
cout << (a + b - 1) / b << endl;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int gcd(int a, int b) {
int c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
typedef long long ll;
ll M = 1000000007;
vector<ll> fac(300001); // n!(mod M)
vector<ll> ifac(300001); // k!^{M-2} (mod M)
ll mpow(ll x, ll n) {
ll ans = 1;
while (n != 0) {
if (n & 1)
ans = ans * x % M;
x = x * x % M;
n = n >> 1;
}
return ans;
}
void setcomb() {
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 300000; i++) {
fac[i + 1] = fac[i] * (i + 1) % M; // n!(mod M)
ifac[i + 1] =
ifac[i] * mpow(i + 1, M - 2) % M; // k!^{M-2} (mod M) ←累乗にmpowを採用
}
}
ll comb(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % M;
return tmp * fac[a] % M;
}
ll perm(ll a, ll b) {
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
return fac[a] * ifac[a - b] % M;
}
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a) {
long long b = M, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= M;
if (u < 0)
u += M;
return u;
}
vector<vector<ll>> mul(vector<vector<ll>> a, vector<vector<ll>> b, int n) {
int i, j, k, t;
vector<vector<ll>> c(n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
t = 0;
for (k = 0; k < n; k++)
t = (t + a[i][k] * b[k][j] % M) % M;
c[i].push_back(t);
}
}
return c;
}
template <typename Monoid> struct SegmentTree {
int sz;
vector<Monoid> seg;
const Monoid M1;
SegmentTree(int n, const Monoid &M1) : M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid value(const int &k) const { return seg[k + sz]; }
Monoid f(Monoid a, Monoid b) { return a + b; }
};
int main() {
int a, b;
cin >> a >> b;
b = 2 * b + 1;
cout << (a + b - 1) / b << endl;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change"
] | 774,987 | 774,988 | u933068010 | cpp |
p02970 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-8;
const int MOD = 1000000007; // 998244353;
const int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
/*-------------------------------------------------*/
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("input.txt", "r", stdin);
int n, d;
cin >> n >> d;
d *= 2;
cout << (n + d - 1) / d << '\n';
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-8;
const int MOD = 1000000007; // 998244353;
const int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
/*-------------------------------------------------*/
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("input.txt", "r", stdin);
int n, d;
cin >> n >> d;
d = 2 * d + 1;
cout << (n + d - 1) / d << '\n';
return 0;
}
| [
"assignment.value.change",
"assignment.change"
] | 775,004 | 775,005 | u219786796 | cpp |
p02970 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const double PI = acos(-1);
const int inf = 2e9;
const ll INF = 2e18;
const ll MOD = 1e9 + 7;
#define sz(s) (s).size()
#define pb push_back
#define fi first
#define se second
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(a) begin(a), end(a)
int main(void) {
int N, D;
cin >> N >> D;
int m = D * 2 + 1;
cout << (N + 1 + m) / m << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const double PI = acos(-1);
const int inf = 2e9;
const ll INF = 2e18;
const ll MOD = 1e9 + 7;
#define sz(s) (s).size()
#define pb push_back
#define fi first
#define se second
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(a) begin(a), end(a)
int main(void) {
int N, D;
cin >> N >> D;
int m = D * 2 + 1;
cout << (N - 1 + m) / m << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 775,006 | 775,007 | u511344501 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << (n + 2 * d - 1) / (2 * d) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
cout << (n + 2 * d) / (2 * d + 1) << endl;
}
| [
"expression.operation.binary.remove"
] | 775,011 | 775,012 | u215722591 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; ++i)
#define ALL(obj) (obj).begin(), (obj).end()
typedef unsigned int uint;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<int> V;
typedef vector<V> VV;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define LINF ((ll)1 << 63 - 1)
#define INF (1 << 29)
#define MINF -2000000007
#define MAX 100050
const int MOD = 1e9 + 7;
// テンプレ終了
//====================================================================//
//
int main() {
int N, D;
cin >> N >> D;
cout << ceil((double)N / (2 * D)) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; ++i)
#define ALL(obj) (obj).begin(), (obj).end()
typedef unsigned int uint;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<int> V;
typedef vector<V> VV;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define LINF ((ll)1 << 63 - 1)
#define INF (1 << 29)
#define MINF -2000000007
#define MAX 100050
const int MOD = 1e9 + 7;
// テンプレ終了
//====================================================================//
//
int main() {
int N, D;
cin >> N >> D;
cout << ceil((double)N / (2 * D + 1)) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 775,017 | 775,018 | u090325904 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, D;
cin >> N >> D;
cout << (N + 2 * D - 1) / (2 * D) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, D;
cin >> N >> D;
cout << (N + 2 * D) / (2 * D + 1) << endl;
} | [
"expression.operation.binary.remove"
] | 775,021 | 775,022 | u679366464 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ldb = long double;
using pa = pair<ll, ll>;
using vec = vector<ll>;
#define pb push_back
#define po pop_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define f(i, x, n) for (ll i = x; i < n; i++)
#define unique_sort(x) \
sort(all(x)), x.resize(distance(x.begin(), unique(all(x))))
#define all(c) c.begin(), c.end()
#define str string
#define edl "\n"
#define add insert
#define cot continue
#define fast() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
const int MOD = 1e9 + 7, INF = INT_MAX, N = 1e5 + 10;
const double PI = acos(-1);
const ll LINF = LLONG_MAX;
int main() {
fast();
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt","w",stdout);
// #endif
ll n, d;
cin >> n >> d;
cout << ceil(1.0 * n / (2 * d));
cerr << "Time taken: " << int((clock() * 1000.) / CLOCKS_PER_SEC) << "ms\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ldb = long double;
using pa = pair<ll, ll>;
using vec = vector<ll>;
#define pb push_back
#define po pop_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define f(i, x, n) for (ll i = x; i < n; i++)
#define unique_sort(x) \
sort(all(x)), x.resize(distance(x.begin(), unique(all(x))))
#define all(c) c.begin(), c.end()
#define str string
#define edl "\n"
#define add insert
#define cot continue
#define fast() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
const int MOD = 1e9 + 7, INF = INT_MAX, N = 1e5 + 10;
const double PI = acos(-1);
const ll LINF = LLONG_MAX;
int main() {
fast();
ll n, d;
cin >> n >> d;
cout << ceil(1.0 * n / (2 * d + 1));
cerr << "Time taken: " << int((clock() * 1000.) / CLOCKS_PER_SEC) << "ms\n";
return 0;
}
| [
"expression.operation.binary.add"
] | 775,058 | 775,059 | u063404629 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// ori
#define MOD 1000000007
int main() {
int N, D;
cin >> N >> D;
int a = D * 2 + 1;
int b = N / a, c = N % a;
if (a > 0)
b++;
cout << b << endl;
} | #include <bits/stdc++.h>
using namespace std;
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// ori
#define MOD 1000000007
int main() {
int N, D;
cin >> N >> D;
int a = D * 2 + 1;
int b = N / a, c = N % a;
if (c > 0)
b++;
cout << b << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 775,070 | 775,071 | u276588887 | cpp |
p02970 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b, n) for (Int i = b; i < Int(n); i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
using Int = long long;
Int inf = 1000000000000000001LL;
using vi = vector<Int>;
using vvi = vector<vi>;
using mapis = unordered_map<Int, string>;
using mapii = unordered_map<Int, Int>;
using pii = pair<Int, Int>;
Int GCD(Int a, Int b) {
if (b == 0)
return a;
if (a < b)
return GCD(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
Int printX(Int r, Int D, Int X, int count) {
if (count == 10) {
return 0;
}
Int nextX = r * X - D;
cout << nextX << endl;
printX(r, D, nextX, count + 1);
}
int myPow(int x, int p) {
if (p == 0)
return 1;
if (p == 1)
return x;
return x * myPow(x, p - 1);
}
int main() {
int N, D;
cin >> N >> D;
Int ans = 0;
int tmp = N;
REP(i, 1, N + 1) {
ans++;
tmp = tmp - (2 * D + i);
if (tmp <= 0) {
break;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(i, b, n) for (Int i = b; i < Int(n); i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
using Int = long long;
Int inf = 1000000000000000001LL;
using vi = vector<Int>;
using vvi = vector<vi>;
using mapis = unordered_map<Int, string>;
using mapii = unordered_map<Int, Int>;
using pii = pair<Int, Int>;
Int GCD(Int a, Int b) {
if (b == 0)
return a;
if (a < b)
return GCD(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
Int printX(Int r, Int D, Int X, int count) {
if (count == 10) {
return 0;
}
Int nextX = r * X - D;
cout << nextX << endl;
printX(r, D, nextX, count + 1);
}
int myPow(int x, int p) {
if (p == 0)
return 1;
if (p == 1)
return x;
return x * myPow(x, p - 1);
}
int main() {
int N, D;
cin >> N >> D;
Int ans = 0;
int tmp = N;
REP(i, 1, N + 1) {
ans++;
tmp = tmp - (2 * D + 1);
if (tmp <= 0) {
break;
}
}
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change"
] | 775,078 | 775,079 | u375619974 | cpp |
p02970 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(a) (a).begin(), (a).end()
int main() {
int n, d;
cin >> n >> d;
int p = 1;
int res = 0;
while (p < n) {
res++;
p += d + 1;
p += d;
}
cout << res;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(a) (a).begin(), (a).end()
int main() {
int n, d;
cin >> n >> d;
int p = 1;
int res = 0;
while (p <= n) {
res++;
p += d + 1;
p += d;
}
cout << res;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 775,080 | 775,081 | u969116807 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int D;
cin >> N >> D;
if (N % (D * 2) > 0) {
cout << N / (D * 2) + 1 << endl;
} else {
cout << N / (D * 2) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int D;
cin >> N >> D;
if (N % (D * 2 + 1) > 0) {
cout << N / (D * 2 + 1) + 1 << endl;
} else {
cout << N / (D * 2 + 1) << endl;
}
} | [
"control_flow.branch.if.condition.change"
] | 775,082 | 775,083 | u820051975 | cpp |
p02970 | #include <bits/stdc++.h>
#define ___ \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define endl '\n'
#define pii pair<int, int>
#define MAX INT_MAX
#pragma GCC optimize("Ofast")
#define int long long
const int MOD = (1e9 + 7);
using namespace std;
#define vvi vector<vector<int>>
const int mod = 998244353;
signed main() {
___ float n, d;
cin >> n >> d;
int x = ceil(1.0 * n / (2 * d + 1));
cout << ceil(n / (2 * d)) << endl;
}
| #include <bits/stdc++.h>
#define ___ \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define endl '\n'
#define pii pair<int, int>
#define MAX INT_MAX
#pragma GCC optimize("Ofast")
#define int long long
const int MOD = (1e9 + 7);
using namespace std;
#define vvi vector<vector<int>>
const int mod = 998244353;
signed main() {
___ float n, d;
cin >> n >> d;
int x = ceil(1.0 * n / (2 * d + 1));
cout << ceil(n / (2 * d + 1)) << endl;
}
| [
"expression.operation.binary.add"
] | 775,098 | 775,099 | u699580536 | cpp |
p02970 | #include <bits/stdc++.h>
#define ___ \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define endl '\n'
#define pii pair<int, int>
#define MAX INT_MAX
#pragma GCC optimize("Ofast")
#define int long long
const int MOD = (1e9 + 7);
using namespace std;
#define vvi vector<vector<int>>
const int mod = 998244353;
signed main() {
___ float n, d;
cin >> n >> d;
int x = ceil(1.0 * n / (2 * d));
cout << ceil(n / (2 * d)) << endl;
}
| #include <bits/stdc++.h>
#define ___ \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define endl '\n'
#define pii pair<int, int>
#define MAX INT_MAX
#pragma GCC optimize("Ofast")
#define int long long
const int MOD = (1e9 + 7);
using namespace std;
#define vvi vector<vector<int>>
const int mod = 998244353;
signed main() {
___ float n, d;
cin >> n >> d;
int x = ceil(1.0 * n / (2 * d + 1));
cout << ceil(n / (2 * d + 1)) << endl;
}
| [
"assignment.change",
"expression.operation.binary.add"
] | 775,100 | 775,099 | u699580536 | cpp |
p02970 | #include <algorithm>
#include <cctype>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <istream>
#include <math.h>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
double n, d;
cin >> n >> d;
cout << ceil(n / (2 * d)) << endl;
} | #include <algorithm>
#include <cctype>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <istream>
#include <math.h>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
double n, d;
cin >> n >> d;
cout << ceil(n / ((2 * d) + 1)) << endl;
} | [
"call.arguments.change"
] | 775,118 | 775,119 | u230139835 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int count = 0;
int ans = 1;
while (count < n) {
count += 2 * d + 1;
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int count = 0;
int ans = 0;
while (count < n) {
count += 2 * d + 1;
ans++;
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 775,127 | 775,128 | u006721330 | cpp |
p02970 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << ceil(N / (2 * D + 1));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << ceil(N / (double)(2 * D + 1));
return 0;
} | [
"type_conversion.add"
] | 775,158 | 775,159 | u947426792 | cpp |
p02971 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const int MOD = 1000000007;
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
int leftMax[N];
int rightMax[N];
leftMax[0] = 0;
rightMax[N - 1] = 0;
for (int i = 1; i < N; i++)
leftMax[i] = max(leftMax[i - 1], A[i - 1]);
for (int i = N - 2; i >= 0; i--)
rightMax[i] = max(rightMax[i], A[i + 1]);
for (int i = 0; i < N; i++) {
cout << max(rightMax[i], leftMax[i]) << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const int MOD = 1000000007;
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
int leftMax[N];
int rightMax[N];
leftMax[0] = 0;
rightMax[N - 1] = 0;
for (int i = 1; i < N; i++)
leftMax[i] = max(leftMax[i - 1], A[i - 1]);
for (int i = N - 2; i >= 0; i--)
rightMax[i] = max(rightMax[i + 1], A[i + 1]);
for (int i = 0; i < N; i++) {
cout << max(rightMax[i], leftMax[i]) << endl;
}
}
| [
"assignment.change"
] | 775,175 | 775,176 | u878454346 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll a;
cin >> a;
vector<ll> vec(a);
for (ll i = 0; i < a; i++) {
cin >> vec.at(i);
}
vector<ll> veco(a);
veco = vec;
sort(vec.begin(), vec.end());
for (ll i = 0; i < a; i++) {
if (veco.at(i) == veco.at(a - 1)) {
cout << veco.at(a - 2) << endl;
} else {
cout << vec.at(a - 1) << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll a;
cin >> a;
vector<ll> vec(a);
for (ll i = 0; i < a; i++) {
cin >> vec.at(i);
}
vector<ll> veco(a);
veco = vec;
sort(vec.begin(), vec.end());
for (ll i = 0; i < a; i++) {
if (veco.at(i) == vec.at(a - 1)) {
cout << vec.at(a - 2) << endl;
} else {
cout << vec.at(a - 1) << endl;
}
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 775,185 | 775,186 | u883297128 | cpp |
p02971 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int N;
cin >> N;
vector<int> A(N);
rep(i, N) { cin >> A.at(i); }
vector<int> right(N);
vector<int> left(N);
for (int i = 1; i < N; i++)
left.at(i) = max(left.at(i - 1), A.at(i - 1));
for (int i = N - 2; i >= 0; i--)
right.at(i) = max(right.at(i + 1), A.at(i));
rep(i, N) cout << max(left.at(i), right.at(i)) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int N;
cin >> N;
vector<int> A(N);
rep(i, N) { cin >> A.at(i); }
vector<int> right(N);
vector<int> left(N);
for (int i = 1; i < N; i++)
left.at(i) = max(left.at(i - 1), A.at(i - 1));
for (int i = N - 2; i >= 0; i--)
right.at(i) = max(right.at(i + 1), A.at(i + 1));
rep(i, N) cout << max(left.at(i), right.at(i)) << endl;
return 0;
}
| [
"assignment.change"
] | 775,189 | 775,190 | u575988755 | cpp |
p02971 | #include <bits/stdc++.h>
#define LOCAL
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
ostream &operator<<(ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
ostream &operator<<(ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream &operator<<(ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
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...);
}
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
#define int long long
using P = pair<int, int>;
//#########################################
signed main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> pre(n + 1), suf(n + 1);
rep(i, n) cin >> a[i];
rep(i, n) pre[i + 1] = max(pre[i + 1], a[i]);
for (int i = n - 1; i >= 0; i--)
suf[i] = max(suf[i + 1], a[i]);
rep(i, n) cout << max(pre[i], suf[i + 1]) << "\n";
return 0;
} | #include <bits/stdc++.h>
#define LOCAL
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
ostream &operator<<(ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
ostream &operator<<(ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream &operator<<(ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
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...);
}
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
#define int long long
using P = pair<int, int>;
//#########################################
signed main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> pre(n + 1), suf(n + 1);
rep(i, n) cin >> a[i];
rep(i, n) pre[i + 1] = max(pre[i], a[i]);
for (int i = n - 1; i >= 0; i--)
suf[i] = max(suf[i + 1], a[i]);
rep(i, n) cout << max(pre[i], suf[i + 1]) << "\n";
return 0;
} | [
"expression.operation.binary.remove"
] | 775,191 | 775,192 | u818349438 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
#define int long long
using P = pair<int, int>;
signed main() {
int n;
cin >> n;
vector<int> migi(n), hidari(n);
int a[n];
rep(i, n) cin >> a[i];
int now = 0;
rep(i, n) {
hidari[i] = max(now, a[i]);
now = a[i];
}
now = 0;
for (int i = n - 1; i >= 0; i--) {
migi[i] = max(now, a[i]);
now = a[i];
}
rep(i, n) {
if (!i)
cout << migi[i] << endl;
else if (i == n - 1)
cout << hidari[i] << endl;
else
cout << max(migi[i + 1], hidari[i - 1]) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
#define int long long
using P = pair<int, int>;
signed main() {
int n;
cin >> n;
vector<int> migi(n), hidari(n);
int a[n];
rep(i, n) cin >> a[i];
int now = 0;
rep(i, n) {
hidari[i] = max(now, a[i]);
now = hidari[i];
}
now = 0;
for (int i = n - 1; i >= 0; i--) {
migi[i] = max(now, a[i]);
now = migi[i];
}
rep(i, n) {
if (!i)
cout << migi[i + 1] << endl;
else if (i == n - 1)
cout << hidari[i - 1] << endl;
else
cout << max(migi[i + 1], hidari[i - 1]) << endl;
}
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 775,193 | 775,194 | u818349438 | cpp |
p02971 | #define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 4244) // 最悪をします
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define BIT(nr) (1UL << (nr))
#define int long long
//#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 //ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 //ない環境用
#define MIN -(9223372036854775807 / 2)
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#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 repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using namespace std;
//デバッグ用カッコの有無
#ifdef DEBUG
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;
}
#endif // DEBUG
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? " " : "") << v[i];
return o;
}
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
int dxp[4] = {0, 1}; // x軸方向への変位(正のみ)
int dyp[4] = {1, 0}; // y軸方向への変位(負のみ)
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
// libalgo
// のものに追加、メンバを追加するだけなので互換性は崩さないはず、逆辺のG[e.dstの]インデックスを保持
int rev;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
// 辺がメンバに src と dst
// を持つ隣接リスト表記のグラフをダンプ(https://hello-world-494ec.firebaseapp.com/)
// に投げることを想定
template <typename T> void dump_graph(T G) {
int V = G.size();
int E = 0;
ostringstream os;
for (auto es : G) {
for (auto e : es) {
E++;
os << e.src << " " << e.dst << "\n";
}
}
cout << V << " " << E << "\n";
cout << os.str() << "\n";
}
// グリッドからグラフを構築
// @pre: gはノード数H*Wのグラフ
void create_from_grid(Graph &g, int h, int w, vector<string> &mapData,
char wall) {
//グラフ構築 O(HW)
rep(y, h) {
rep(x, w) {
if (mapData[y][x] == wall) {
continue;
}
int id = y * w + x;
//右と下(変位が正)のみ見る(辺の重複を回避するため)
rep(i, 2) {
int nx = x + dxp[i];
int ny = y + dyp[i];
int nid = ny * w + nx;
if (nx < 0 || nx >= w) {
continue;
}
if (ny < 0 || ny >= h) {
continue;
}
if (mapData[ny][nx] != wall) {
add_edge(g, id, nid);
}
}
}
}
}
// マスに重みが定義されるグリッドから重み付きグラフを構築、ダイクストラなどをするとき始点のこすとは入らないことに注意
// @pre: gはノード数H*Wのグラフ
void create_weighted_from_grid(Graph &g, int h, int w,
vector<vector<int>> &mapData) {
//グラフ構築 O(HW)
rep(y, h) {
rep(x, w) {
int id = y * w + x;
// こんどは全方向見る(行きと帰りで重みが違うはず)
rep(i, 4) {
int nx = x + dx[i];
int ny = y + dy[i];
int nid = ny * w + nx;
if (nx < 0 || nx >= w) {
continue;
}
if (ny < 0 || ny >= h) {
continue;
}
// 移動先のコストを足す
add_arc(g, id, nid, mapData[ny][nx]);
}
}
}
}
// グリッドにおいて座標をグラフのノード番号に変換する
int point_to_node_num(int x, int y, int W) { return y * W + x; }
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
template <signed M, unsigned T> struct mod_int {
constexpr static signed MODULO = M;
constexpr static unsigned TABLE_SIZE = T;
signed x;
mod_int() : x(0) {}
mod_int(long long y)
: x(static_cast<signed>(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO)) {}
mod_int(signed y) : x(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO) {}
mod_int &operator+=(const mod_int &rhs) {
if ((x += rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator-=(const mod_int &rhs) {
if ((x += MODULO - rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator*=(const mod_int &rhs) {
x = static_cast<signed>(1LL * x * rhs.x % MODULO);
return *this;
}
mod_int &operator/=(const mod_int &rhs) {
x = static_cast<signed>((1LL * x * rhs.inv().x) % MODULO);
return *this;
}
mod_int operator-() const { return mod_int(-x); }
mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }
mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }
mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }
mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }
bool operator<(const mod_int &rhs) const { return x < rhs.x; }
mod_int inv() const {
assert(x != 0);
if (x <= static_cast<signed>(TABLE_SIZE)) {
if (_inv[1].x == 0)
prepare();
return _inv[x];
} else {
signed a = x, b = MODULO, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mod_int(u);
}
}
mod_int pow(long long t) const {
assert(!(x == 0 && t == 0));
mod_int e = *this, res = mod_int(1);
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
mod_int fact() {
if (_fact[0].x == 0)
prepare();
return _fact[x];
}
mod_int inv_fact() {
if (_fact[0].x == 0)
prepare();
return _inv_fact[x];
}
mod_int choose(mod_int y) {
assert(y.x <= x);
return this->fact() * y.inv_fact() * mod_int(x - y.x).inv_fact();
}
static mod_int _inv[TABLE_SIZE + 1];
static mod_int _fact[TABLE_SIZE + 1];
static mod_int _inv_fact[TABLE_SIZE + 1];
static void prepare() {
_inv[1] = 1;
for (int i = 2; i <= (int)TABLE_SIZE; ++i) {
_inv[i] = 1LL * _inv[MODULO % i].x * (MODULO - MODULO / i) % MODULO;
}
_fact[0] = 1;
for (unsigned i = 1; i <= TABLE_SIZE; ++i) {
_fact[i] = _fact[i - 1] * signed(i);
}
_inv_fact[TABLE_SIZE] = _fact[TABLE_SIZE].inv();
for (int i = (int)TABLE_SIZE - 1; i >= 0; --i) {
_inv_fact[i] = _inv_fact[i + 1] * (i + 1);
}
}
};
template <signed M, unsigned F>
std::ostream &operator<<(std::ostream &os, const mod_int<M, F> &rhs) {
return os << rhs.x;
}
template <signed M, unsigned F>
std::istream &operator>>(std::istream &is, mod_int<M, F> &rhs) {
long long s;
is >> s;
rhs = mod_int<M, F>(s);
return is;
}
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
bool operator==(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return lhs.x == rhs.x;
}
template <int M, unsigned F>
bool operator!=(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return !(lhs == rhs);
}
const signed MF = 1000010;
const signed MOD = 1000000007;
using mint = mod_int<MOD, MF>;
mint binom(int n, int r) {
return (r < 0 || r > n || n < 0) ? 0 : mint(n).choose(r);
}
mint fact(int n) { return mint(n).fact(); }
mint inv_fact(int n) { return mint(n).inv_fact(); }
//出典 http://beet-aizu.hatenablog.com/entry/2017/12/01/225955
/*
コンストラクタ引数説明
int n_
要素数。
f
2つの要素Tをマージするための関数。
区間MAX区間更新の時: max
区間Sum区間Addの時: +
g
1つの要素Tに作用素Eを適用するための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
h
2つの作用素Eをマージするための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
T d1
演算fの単位元。
区間MAX区間更新の時: -INF
区間Sum区間Addの時: 0
E d0,
g, hの単位元。
区間MAX区間更新の時: 定義域外のどこか
区間Sum区間Addの時: 0
vector<T> v = vector<T>()
セグ木を構成するときのvector
P p = [](E a, int b) {return a; }
区間の長さbを引数に取り、区間の長さによって変化する作用素E'を返す関数。
例えば、区間MAX区間Addの時なんかは区間長によって足すべき数が変化するので必要
区間Sum区間Addの時: *
//具体例
//区間chmin, 区間min
auto myMin = [](int a, int b) {return min(a, b); };
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
//区間update、区間min
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
//区間Add、区間Sum
vector<int> v(0, N + 1);
SegmentTree<int, int> segtree(N + 1, plus<int>(), plus<int>(), plus<int>(), 0,
0, v, [](int a, int b) {return a * b; });
//区間Add、区間Min
vector<int> v(0, N + 1);
SegmentTree<int, int> segtree(N + 1, myMin, plus<int>(), plus<int>(),
LL_HALFMAX, 0, v, [](int a, int b) {return a; });
*/
template <typename T, typename E> struct SegmentTree {
typedef function<T(T, T)> F;
typedef function<T(T, E)> G;
typedef function<E(E, E)> H;
typedef function<E(E, int)> P;
int n;
F f;
G g;
H h;
P p;
T d1;
E d0;
vector<T> dat;
vector<E> laz;
SegmentTree(
int n_, F f, G g, H h, T d1, E d0, vector<T> v = vector<T>(),
P p = [](E a, int b) { return a; })
: f(f), g(g), h(h), d1(d1), d0(d0), p(p) {
init(n_);
if (n_ == (int)v.size())
build(n_, v);
}
//初期化。要素配列と遅延配列を2*n-1個にする
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, d1);
laz.clear();
laz.resize(2 * n - 1, d0);
}
//既存のvectorからセグ木を構築
void build(int n_, vector<T> v) {
for (int i = 0; i < n_; i++)
dat[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
}
//ノードを評価する。
inline void eval(int len, int k) {
//遅延配列に単位元が入ってたら評価済みなのでおしまい
if (laz[k] == d0)
return;
//葉ノードでないなら遅延伝播する
if (k * 2 + 1 < n * 2 - 1) {
// h: 2つの作用素を引数に取り合成した作用素を返す関数
laz[k * 2 + 1] = h(laz[k * 2 + 1], laz[k]);
laz[k * 2 + 2] = h(laz[k * 2 + 2], laz[k]);
}
// p:
// このノードに対応する区間長と作用素を引数に取り、区間長に対応する作用素を返す関数
// dat[k] にlaz に溜めていた作用素を適用(g:
// 要素型と作用素型を引数に取り、要素に作用素を作用させた結果を返す関数、ここでの作用素とは区間Sum区間Addなら
// (+ 3) とか)
dat[k] = g(dat[k], p(laz[k], len));
//適用し終わったので遅延配列をクリア
laz[k] = d0;
}
//[l,r)の区間を再帰的に見ながら0-indexedの[a, b)を更新する
T update(int a, int b, E x, int k, int l, int r) {
//先に評価
eval(r - l, k);
//範囲外ならなにもしないでそのノードが持つ値を返す
if (r <= a || b <= l)
return dat[k];
//完全被覆なら既に遅延配列に入っている作用素と追加したい作用素をマージした後にそれを要素に作用させた結果を返す、pは区間長に対応する作用素を得るための（ｒｙ
if (a <= l && r <= b) {
laz[k] = h(laz[k], x);
return g(dat[k], p(laz[k], r - l));
}
//完全被覆でも範囲外でもないなら(中途半端にかぶっているなら)完全被覆と範囲外の境界が見えるまで木を潜って変化後の値を得る
return dat[k] = f(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
}
T update(int a, int b, E x) { return update(a, b, x, 0, 0, n); }
T update(int a, E x) { return update(a, a + 1, x); }
T query(int a, int b, int k, int l, int r) {
eval(r - l, k);
//範囲外なら単位元を返す
if (r <= a || b <= l)
return d1;
//完全被覆ならそのまま返す
if (a <= l && r <= b)
return dat[k];
//一部被覆なら完全被覆と範囲外に分かれるまで木を潜る
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
// 0-indexedで[a, b)の区間*を求める
T query(int a, int b) { return query(a, b, 0, 0, n); }
T query(int a) { return query(a, a + 1, 0, 0, n); }
void debug_print(int num) {
vector<T> v;
rep(i, num) { v.push_back(query(i)); }
cout << "{" << v << "}\n";
}
};
//座標圧縮
class compress {
public:
map<int, int> zip;
vector<int> unzip;
compress(vector<int> x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip.push_back(i);
}
}
};
unsigned euclidean_gcd(unsigned a, unsigned b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
// https://ei1333.github.io/luzhiled/snippets/dp/cumulative-sum-2d.html
template <class T> struct CumulativeSum2D {
vector<vector<T>> data;
CumulativeSum2D(int W, int H) : data(W + 1, vector<int>(H + 1, 0)) {}
void add(int x, int y, T z) {
++x, ++y;
if (x >= data.size() || y >= data[0].size())
return;
data[x][y] += z;
}
void build() {
for (int i = 1; i < data.size(); i++) {
for (int j = 1; j < data[i].size(); j++) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
}
T query(int sx, int sy, int gx, int gy) {
return (data[gx][gy] - data[sx][gy] - data[gx][sy] + data[sx][sy]);
}
};
// lib
int nC2(int n) { return n * (n - 1) / 2; }
class node {
public:
int depth;
int num;
node(int d, int n) {
depth = d;
num = n;
}
};
template <class T> struct CumulativeSum {
vector<T> data;
CumulativeSum(int sz) : data(sz, 0){};
void add(int k, T x) { data[k] += x; }
void build() {
for (int i = 1; i < data.size(); i++) {
data[i] += data[i - 1];
}
}
T query(int k) {
if (k < 0)
return (0);
return (data[min(k, (int)data.size() - 1)]);
}
//[left, right]の和
T query(int left, int right) { return query(right) - query(left - 1); }
};
std::vector<int> eratosthenes_sieve(int n) {
std::vector<int> ps(n + 1);
std::iota(ps.begin() + 2, ps.end(), 2);
for (int i = 2; i * i <= n; ++i)
if (ps[i])
for (int j = i * i; j <= n; j += i)
ps[j] = 0;
return ps;
}
std::vector<int> make_primes(int n) {
std::vector<int> ps = eratosthenes_sieve(n);
ps.erase(std::remove(ps.begin(), ps.end(), 0), ps.end());
return ps;
}
// 区間[a, b)の素数判定をする、is_prime[i]: a + i が素数 or not つまり
// is_prime[i-a] が true: iが素数
std::vector<bool> segment_eratosthenes_sieve(int a, int b) {
vector<bool> is_prime(b - a, true);
vector<bool> is_prime_small;
for (int i = 0; i * i < b; i++)
is_prime_small.push_back(true);
for (int i = 2; i * i < b; i++) {
if (is_prime_small[i]) {
for (int j = 2 * i; j * j < b; j += i) {
is_prime_small[j] = false; // [2, sqrt(b))のふるい
}
// (a + i - 1LL) / i * i a以上の最小のiの倍数
for (int j = max(2LL, (a + i - 1LL) / i) * i; j < b; j += i) {
is_prime[j - a] = false; // [a, b)のふるい
}
}
}
return is_prime;
}
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
// 汎用的な二分探索のテンプレ(めぐる式)
int binary_search(function<bool(int)> isOk, int ng, int ok) {
/* ok と ng のどちらが大きいかわからないことを考慮 */
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (isOk(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0;; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
//更新がなくなったらおはり
if (!update)
break;
// n回以上更新されてたら負閉路がある
if (i > n) {
negCycle = true;
break;
}
}
return std::make_pair(dist, !negCycle);
}
//ゴールを指定して、それまでのパスに負閉路がなかったらOK(嘘修正済)
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s, int d) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0; i < n * 2; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
// n回目の更新で d が更新されてたら問答無用で負閉路ありとしてNG
if (i >= n - 1 && e.dst == d) {
negCycle = true;
}
// 終点以外に負閉路がある場合はそこの距離を十分小さい値に置き換える
else if (i >= n - 1) {
dist[e.dst] = -inf;
update = true;
} else {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
}
//更新がなくなったらおはり
if (!update)
break;
}
return std::make_pair(dist, !negCycle);
}
// R[i] == S[i] を中心とした極大回文長 なるvector Rを返す
vector<int> Manachar(string S) {
int len = S.length();
vector<int> R(len);
int i = 0, j = 0;
while (i < S.size()) {
while (i - j >= 0 && i + j < S.size() && S[i - j] == S[i + j])
++j;
R[i] = j;
int k = 1;
while (i - k >= 0 && i + k < S.size() && k + R[i - k] < j)
R[i + k] = R[i - k], ++k;
i += k;
j -= k;
}
return R;
}
std::vector<int> tsort(const Graph &g) {
int n = g.size(), k = 0;
std::vector<int> ord(n), in(n);
for (auto &es : g)
for (auto &e : es)
in[e.dst]++;
std::queue<int> q;
//入次数0の点をキューに追加
for (int i = 0; i < n; ++i)
if (in[i] == 0)
q.push(i);
while (q.size()) {
int v = q.front();
// Sから node n を削除する
q.pop();
// L に n を追加する
ord[k++] = v;
for (auto &e : g[v]) {
//選択した点から出てる辺を削除、0になったらキューに追加
if (--in[e.dst] == 0) {
q.push(e.dst);
}
}
}
return *std::max_element(in.begin(), in.end()) == 0 ? ord
: std::vector<int>();
}
std::vector<Weight> dijkstra(const Graph &g, int s) {
const Weight INF = std::numeric_limits<Weight>::max() / 8;
using state = std::tuple<Weight, int>;
std::priority_queue<state> q;
std::vector<Weight> dist(g.size(), INF);
dist[s] = 0;
q.emplace(0, s);
while (q.size()) {
Weight d;
int v;
std::tie(d, v) = q.top();
q.pop();
d *= -1;
/* if(v == t) return d; */
if (dist[v] < d)
continue;
for (auto &e : g[v]) {
if (dist[e.dst] > dist[v] + e.weight) {
dist[e.dst] = dist[v] + e.weight;
q.emplace(-dist[e.dst], e.dst);
}
}
}
return dist;
}
Matrix WarshallFloyd(const Graph &g) {
auto const INF = std::numeric_limits<Weight>::max() / 8;
int n = g.size();
Matrix d(n, Array(n, INF));
rep(i, n) d[i][i] = 0;
rep(i, n) for (auto &e : g[i]) d[e.src][e.dst] =
std::min(d[e.src][e.dst], e.weight);
rep(k, n) rep(i, n) rep(j, n) {
if (d[i][k] != INF && d[k][j] != INF)
d[i][j] = std::min(d[i][j], d[i][k] + d[k][j]);
}
return d;
}
std::pair<std::vector<int>, std::vector<int>> prime_factor_decomp(int n) {
std::vector<int> p, e;
int m = n;
for (int i = 2; i * i <= n; i++) {
if (m % i != 0)
continue;
int c = 0;
while (m % i == 0)
c++, m /= i;
p.push_back(i);
e.push_back(c);
}
if (m > 1) {
p.push_back(m);
e.push_back(1);
}
return std::make_pair(p, e);
}
int extgcd(int a, int b, int &x, int &y) {
int g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
// 不定方程式 ax + by = c の一般整数解(pt + q, rt + s)を求める
/*
* exist: 解が存在するか否か
* p, q, r, s: 存在するならば不定方程式の一般解(pt + q, rt + s)
* ここで、式変形から、p > 0、 q < 0
* となることに注意する。(解の条件を絞るときなどに必要になる)
*/
void IndeterminateEq(int a, int b, int c, bool &exist, int &p, int &q, int &r,
int &s) {
int X, Y;
int g = euclidean_gcd(a, b);
// c が最大公約数の整数倍でないならNG
if (c % g != 0) {
exist = false;
return;
}
exist = true;
// 拡張ユークリッドの互除法で ax + by = gcd(a, b) なる (X, Y) を求める
extgcd(a, b, X, Y);
int m = c / g;
// ax + by = c の解にする
X *= m;
Y *= m;
int a2 = a / g;
int b2 = b / g;
p = b2;
q = X;
r = -a2;
s = Y;
}
// x^n mod modulo を繰り返し二乗法で計算する
// n を 2^k の和で表す -> n
// を二進表記したとき、kbit目(0-indexed)が立っているときだけx^kをかける
int mod_pow(int x, int n, int modulo) {
int res = 1;
while (n > 0) {
if (n & 1) {
res = res * x % modulo;
}
x = x * x % modulo;
n >>= 1;
}
return res;
}
int64_t popcnt(int64_t n) {
int64_t c = 0;
c = (n & 0x5555555555555555) + ((n >> 1) & 0x5555555555555555);
c = (c & 0x3333333333333333) + ((c >> 2) & 0x3333333333333333);
c = (c & 0x0f0f0f0f0f0f0f0f) + ((c >> 4) & 0x0f0f0f0f0f0f0f0f);
c = (c & 0x00ff00ff00ff00ff) + ((c >> 8) & 0x00ff00ff00ff00ff);
c = (c & 0x0000ffff0000ffff) + ((c >> 16) & 0x0000ffff0000ffff);
c = (c & 0x00000000ffffffff) + ((c >> 32) & 0x00000000ffffffff);
return (c);
}
/*
行列積と行列累乗
行列積
vector<vector<T>> matrixMultiplies(vector<vector<T>> l, vector<vector<T>> r, F
plus = plus<T>(), G multiple = multiplies<T>(), T eplus = 0LL) 行列累乗
vector<vector<T>> matrixPower(vector<vector<T>> m, int n, F plus =
std::plus<T>(), G multiple = multiplies<T>(), T eplus = 0LL, T emultiple = 1LL)
T: 考える集合(競プロにおいてはたぶんほぼ整数)
l: 左からかける行列
r: 右からかける行列
plus: 加法演算
multiple: 乗法演算
eplus: 加法の単位元
emultiple: 乗法の単位元
*/
template <typename T = long long, typename F = decltype(std::plus<T>()),
typename G = decltype(multiplies<T>())>
vector<vector<T>>
matrixMultiplies(vector<vector<T>> l, vector<vector<T>> r, F plus = plus<T>(),
G multiple = multiplies<T>(), T eplus = 0LL) {
int rx = r[0].size();
int ry = r.size();
vector<vector<T>> ret;
for (int y = 0; y < ry; y++) {
vector<T> add;
for (int x = 0; x < rx; x++) {
T cell = eplus;
for (int i = 0; i < ry; i++) {
T mul = multiple(l[y][i], r[i][x]);
cell = plus(cell, mul);
}
add.push_back(cell);
}
ret.push_back(add);
}
return ret;
}
template <typename T = long long, typename F = decltype(std::plus<T>()),
typename G = decltype(multiplies<T>())>
vector<vector<T>>
matrixPower(vector<vector<T>> m, int n, F plus = std::plus<T>(),
G multiple = multiplies<T>(), T eplus = 0LL, T emultiple = 1LL) {
int k = m.size();
if (n == 0) {
vector<vector<T>> E;
for (int i = 0; i < k; i++) {
// 単位行列は対角成分を乗法単位元、非対角成分をゼロ元で埋める
vector<T> v(k, eplus);
v[i] = emultiple;
E.push_back(v);
}
return E;
}
vector<vector<T>> ret =
matrixPower(matrixMultiplies(m, m, plus, multiple, eplus), n / 2, plus,
multiple, eplus, emultiple);
if (n % 2 == 1) {
ret = matrixMultiplies(m, ret, plus, multiple);
}
return ret;
}
// フロー系のアルゴリズム
// 最大流
/*
Ford-Fulkerson法(蟻本) O(F|E|)
F: 最大流量
E: 辺数
コンストラクタ引数でノード数nを受け取り初期化し、add_edge
で辺と逆辺を追加していく
*/
class Ford_Fulkerson {
private:
struct Edge {
int src, dst;
// libalgo
// のものに追加、メンバを追加するだけなので互換性は崩さないはず、逆辺のG[e.dstの]インデックスを保持
int rev;
int cap;
Edge(int s, int d, int c, int r) : src(s), dst(d), cap(c), rev(r) {}
};
vector<vector<Edge>> G;
vector<bool> used;
public:
Ford_Fulkerson(int n) : G(n), used(n, false) {}
void add_edge(int s, int d, int cap) {
G[s].emplace_back(s, d, cap, G[d].size());
G[d].emplace_back(d, s, 0, G[s].size() - 1);
}
int dfs(int v, int t, int f) {
if (v == t) {
return f;
}
used[v] = true;
for (Edge &e : G[v]) {
if (!used[e.dst] && e.cap > 0) {
// 流せる辺があったら流す
int d = dfs(e.dst, t, min(f, e.cap));
if (d > 0) {
// 辺の残り容量を減らす
e.cap -= d;
// 逆辺の容量を増やす
G[e.dst][e.rev].cap += d;
return d;
}
}
}
// t にたどり着けなかったら0
return 0;
}
int max_flow(int s, int t) {
int flow = 0;
while (1) {
for (int i = 0; i < used.size(); i++) {
used[i] = false;
}
int f = dfs(s, t, LL_HALFMAX);
if (f == 0) {
return flow;
}
flow += f;
}
}
};
/*
Dinic法 From libalgo O(V^2 * E)
dinic::solve(s, t) : s -> t の最大流を求める
dinic;;flow[u][v] : 辺(u, v)の流量
*/
struct dinic {
int n, s, t;
std::vector<int> level, prog, que;
std::vector<std::vector<Flow>> cap, flow;
std::vector<std::vector<int>> g;
Flow inf;
dinic(const Graph &graph)
: n(graph.size()), cap(n, std::vector<Flow>(n)),
flow(n, std::vector<Flow>(n)), g(n, std::vector<int>()),
inf(std::numeric_limits<Flow>::max() / 8) {
for (int i = 0; i < n; i++) {
for (auto &e : graph[i]) {
int u = e.src, v = e.dst;
Flow c = e.cap;
cap[u][v] += c;
cap[v][u] += c;
flow[v][u] += c;
g[u].push_back(v);
g[v].push_back(u);
}
}
}
// 残りを求める
inline Flow residue(int u, int v) { return cap[u][v] - flow[u][v]; }
// 実際に最大流問題を解く
Flow solve(int s_, int t_) {
this->t = t_, this->s = s_;
que.resize(n + 1);
Flow res = 0;
// levelize() == false: bfs で s から t に到達できなかった
while (levelize()) {
prog.assign(n, 0);
res += augment(s, inf);
}
return res;
}
// bfs でレベルグラフをつくる
bool levelize() {
int l = 0, r = 0;
level.assign(n, -1);
level[s] = 0;
que[r++] = s;
while (l != r) {
int v = que[l++];
if (v == t)
break;
for (const int &d : g[v]) {
// まだレベルが決まっておらず、v -> dの辺に流せるならlevel[d] = level[v]
// + 1
if (level[d] == -1 && residue(v, d) != 0) {
level[d] = level[v] + 1;
que[r++] = d;
}
}
}
// t に到達できるなら true を返す
return level[t] != -1;
}
// dfs で実際に流してみる
Flow augment(int v, Flow lim) {
Flow res = 0;
if (v == t)
return lim;
// prog[v]: dfs
// において、vを展開する際、vの子の何番目まで展開したかを覚えておく
for (int &i = prog[v]; i < (int)g[v].size(); i++) {
const int &d = g[v][i];
// v -> d に流せない or v(流す側) の方がレベルが大きい(=深い)場合NG
if (residue(v, d) == 0 || level[v] >= level[d])
continue;
// 流せるなら、流せるだけ流す
const Flow aug = augment(d, std::min(lim, residue(v, d)));
flow[v][d] += aug;
flow[d][v] -= aug;
res += aug;
lim -= aug;
// ノードvに来ている流量を使い切ったら終わり
if (lim == 0)
break;
}
return res;
}
};
/*
Primal-Dual法(蟻本版 / ベルマンフォード)
*/
class Primal_Dual_BellmanFord {
using Cost = int;
struct Edge {
int src, dst;
// libalgo
// のものに追加、メンバを追加するだけなので互換性は崩さないはず、逆辺のG[e.dstの]インデックスを保持
int rev;
Cost cost;
Flow cap;
Edge(int s, int d, int aRev, Cost aCost, Flow aCap)
: src(s), dst(d), rev(aRev), cost(aCost), cap(aCap) {}
};
int V; //頂点数
vector<vector<Edge>> G; // 隣接リスト
vector<int> dist; // 最短距離
vector<int> prevv; // 直前の頂点
vector<int> preve; // 直前の辺
const int INF;
public:
// 頂点数 n を引数にとって初期化
Primal_Dual_BellmanFord(int n)
: V(n), G(n), dist(n, 0), prevv(n, 0), preve(n, 0),
INF(std::numeric_limits<int>::max() / 8) {}
void add_edge(int src, int dst, int cap, int cost) {
// cost は weight に入れる
G[src].emplace_back(src, dst, G[dst].size(), cost, cap);
G[dst].emplace_back(dst, src, G[src].size() - 1, -cost, 0);
}
int min_cost_flow(int s, int t, int f) {
int res = 0;
while (f > 0) {
// ベルマンフォードによりs-t最短路をもとめる
dist.assign(V, INF);
dist[s] = 0;
bool update = true;
while (update) {
update = false;
for (int v = 0; v < V; v++) {
if (dist[v] == INF)
continue;
for (int i = 0; i < G[v].size(); i++) {
Edge &e = G[v][i];
if (e.cap > 0 && dist[e.dst] > dist[v] + e.cost) {
dist[e.dst] = dist[v] + e.cost;
prevv[e.dst] = v;
preve[e.dst] = i;
update = true;
}
}
}
}
// これ以上流せない
if (dist[t] == INF) {
return -1;
}
// 復元したs-t最短路に沿って流せるだけ流す
int d = f;
// 尻からprevvを辿っていき、流せる量を求める
for (int v = t; v != s; v = prevv[v]) {
// 一つ手前に戻るための辺
Edge &e = G[prevv[v]][preve[v]];
chmin(d, e.cap);
}
f -= d;
// ここでの dist
// はコスト和なので、それに流す量をかけると今回見つけた最短パスに流すコストとなる。
res += d * dist[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
};
/*
ダイクストラ版 Primal-Dual
出典: https://ei1333.github.io/luzhiled/snippets/graph/primal-dual.html
*/
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
edge(int aTo, flow_t aCap, cost_t aCost, int aRev, bool aIsRev)
: to(aTo), cap(aCap), cost(aCost), rev(aRev), isrev(aIsRev) {}
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(to, cap, cost, (int)graph[to].size(), false);
graph[to].emplace_back(from, 0, -cost, (int)graph[from].size() - 1, true);
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
class lca {
public:
int n, segn;
vector<int> path; // 蟻本の vs、オイラーツアーを保持
vector<int> depth; // 蟻本の depth、path[i] であるノードの深さを保持
vector<int>
in_order; // 蟻本の
// id、ノードiがオイラーツアーで最初に出てくるインデックスを保持
vector<pair<int, int>> dat;
const std::pair<int, int> INF = std::make_pair(1000000000, 1000000000);
lca(const Graph &g, int root)
: n(g.size()), path(n * 2 - 1), depth(n * 2 - 1), in_order(n) {
int k = 0;
dfs(g, root, -1, 0, k);
// セグ木を構築、持つのはpair(depth, index) => depth が最小となる index
// がわかる
for (segn = 1; segn < n * 2 - 1; segn <<= 1)
;
dat.assign(segn * 2, INF);
for (int i = 0; i < (int)depth.size(); ++i)
dat[segn + i] = std::make_pair(depth[i], i);
for (int i = segn - 1; i >= 1; --i)
dat[i] = min(dat[i * 2], dat[i * 2 + 1]);
}
int get(int u, int v) const {
int l = std::min(in_order[u], in_order[v]);
int r = std::max(in_order[u], in_order[v]) + 1;
return path[range_min(1, segn, l, r).second];
}
void dfs(const Graph &g, int v, int p, int d, int &k) {
// k: オイラーツアーの何番目かを保持する変数
in_order[v] = k;
path[k] = v;
depth[k++] = d;
for (auto &e : g[v]) {
if (e.dst != p) {
dfs(g, e.dst, v, d + 1, k);
// ここに来た時はノードvの子であるe.dstを展開し終わってvに戻ってきたときなので、再度
// path と depth に記録する
path[k] = v;
depth[k++] = d;
}
}
}
// v : いまみてるノード、w: 今見てるノードに対応する区間長 l: ? r: ?
pair<int, int> range_min(int v, int w, int l, int r) const {
if (r <= l || w == 0)
return INF;
if (r - l == w)
return dat[v];
int m = w / 2;
auto rmin = range_min(v * 2, m, l, std::min(r, m));
auto lmin = range_min(v * 2 + 1, m, std::max(0LL, l - m), r - m);
return min(rmin, lmin);
}
};
// int における ceil と floor、負数対応(a / b の ceil, floor)
int64_t intceil(int64_t a, int64_t b) {
int sign_a = (a > 0) - (a < 0);
int sign_b = (b > 0) - (b < 0);
if (sign_a == sign_b) {
return (a + b - sign_b) / b;
} else {
return a / b;
}
}
int64_t intfloor(int64_t a, int64_t b) {
int sign_a = (a > 0) - (a < 0);
int sign_b = (b > 0) - (b < 0);
if (sign_a == sign_b) {
return a / b;
} else {
return (a - b + sign_b) / b;
}
}
const string YES = "Yes";
void solve(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B);
void solve_TLE(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B);
class StressTest {
private:
mt19937 m_RandEngine;
bool judge_case(long long N, long long M, std::vector<long long> A,
std::vector<long long> B) {
ostringstream fast, tle;
solve(fast, N, M, std::move(A), std::move(B));
solve_TLE(tle, N, M, std::move(A), std::move(B));
if (fast.str() == tle.str()) {
return true;
} else {
return false;
}
}
// [l, l+1, ... r] の数列を生成し、シャッフルする
vector<int> create_range_permutation(int l, int r) {
vector<int> ret;
for (int i = l; i <= r; i++) {
ret.push_back(i);
}
shuffle(ret.begin(), ret.end(), m_RandEngine);
return ret;
}
// [1, n] の順列を生成する
vector<int> create_permutation(int n) { create_range_permutation(1, n); }
// 範囲が[l, r] でサイズが n の数列を生成する
vector<int> create_random_sequence(int l, int r, int n) {
uniform_int_distribution<> randLR(l, r);
vector<int> ret;
for (int i = 0; i < n; i++) {
ret.push_back(randLR(m_RandEngine));
}
return ret;
}
/*
* 頂点数 n, 辺数 m で自己ループと多重辺のない無向グラフを生成
* 慣習的に頂点番号が1-indexed な AtCoder で 1-n の頂点が使えるようにするため
* n+1 頂点のグラフを生成し、0番を無視することとする weighted を true
* にすると重み付き、maxWeight で最大重みを指定
* 連結でないグラフが出力される可能性があることに注意する
*/
Graph create_undirected_graph(int n, int m, bool weighted = false,
int maxWeight = 10) {
Graph ret(n + 1);
set<pair<int, int>> used;
uniform_int_distribution<> randNode(1, n);
uniform_int_distribution<> randWeight(1, maxWeight);
while (used.size() < m * 2) {
int src = randNode(m_RandEngine);
int dst = randNode(m_RandEngine);
// 自己ループ、多重辺判定
if (used.count(make_pair(src, dst)) == 0 &&
used.count(make_pair(dst, src)) == 0 && src != dst) {
used.insert(make_pair(src, dst));
used.insert(make_pair(dst, src));
add_edge(ret, src, dst, weighted ? randWeight(m_RandEngine) : 1);
}
}
return ret;
}
/*
* 頂点数 n, 辺数 m で自己ループと多重辺のない有向グラフを生成
* 慣習的に頂点番号が1-indexed な AtCoder で 1-n の頂点が使えるようにするため
* n+1 頂点のグラフを生成し、0番を無視することとする weighted を true
* にすると重み付き、maxWeight で最大重みを指定
* 連結でないグラフが出力される可能性があることに注意する
*/
Graph create_directed_graph(int n, int m, bool weighted = false,
int maxWeight = 10) {
Graph ret(n + 1);
set<pair<int, int>> used;
uniform_int_distribution<> randNode(1, n);
uniform_int_distribution<> randWeight(1, maxWeight);
while (used.size() < m) {
int src = randNode(m_RandEngine);
int dst = randNode(m_RandEngine);
// 自己ループ、多重辺判定
if (used.count(make_pair(src, dst)) == 0 && src != dst) {
used.insert(make_pair(src, dst));
add_arc(ret, src, dst, weighted ? randWeight(m_RandEngine) : 1);
}
}
return ret;
}
/*
* 頂点数nの木(無向)を生成します。
*/
Graph create_tree(int n, bool weighted = false, int maxWeight = 10) {
Graph ret(n + 1);
uf_tree uf(n + 1);
int cnt = 0;
uniform_int_distribution<> randNode(1, n);
uniform_int_distribution<> randWeight(1, maxWeight);
while (cnt < n - 1) {
int n1 = randNode(m_RandEngine);
int n2 = randNode(m_RandEngine);
if (n1 != n2 && !uf.is_same(n1, n2)) {
cnt++;
add_edge(ret, n1, n2, weighted ? randWeight(m_RandEngine) : 1);
}
}
}
public:
StressTest(int seed) : m_RandEngine(seed) {}
void test() {
while (1) {
// TODO: generate random case
// if (!judge_case(N, M, std::move(A), std::move(B))) {
// TODO: output case
// break;
//}
}
}
};
void solve(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B) {}
void solve_TLE(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B) {}
// dp[i][c][fixed] := i(1-indexed) まで決まってて、0以外がc個あって、fixed =
// true: 既にNイカであることが決まっている false: きまっていない
int dp[110][4][2];
signed main() {
int N;
cin >> N;
vector<int> A(N, 0), B(N, 0), C(N, 0);
rep(i, N) cin >> A[i];
int ma = -1;
rep(i, N) {
chmax(ma, A[i]);
B[i] = ma;
}
ma = -1;
RREP(i, N) {
chmax(ma, A[i]);
C[i] = ma;
}
rep(i, N) {
if (i == 0) {
cout << C[1] << "\n";
} else if (i == N - 1) {
cout << B[N - 1] << "\n";
} else {
int ans = max(B[i - 1], C[i + 1]);
cout << ans << "\n";
}
}
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 4244) // 最悪をします
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define BIT(nr) (1UL << (nr))
#define int long long
//#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 //ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 //ない環境用
#define MIN -(9223372036854775807 / 2)
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#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 repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using namespace std;
//デバッグ用カッコの有無
#ifdef DEBUG
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;
}
#endif // DEBUG
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? " " : "") << v[i];
return o;
}
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
int dxp[4] = {0, 1}; // x軸方向への変位(正のみ)
int dyp[4] = {1, 0}; // y軸方向への変位(負のみ)
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
// libalgo
// のものに追加、メンバを追加するだけなので互換性は崩さないはず、逆辺のG[e.dstの]インデックスを保持
int rev;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
// 辺がメンバに src と dst
// を持つ隣接リスト表記のグラフをダンプ(https://hello-world-494ec.firebaseapp.com/)
// に投げることを想定
template <typename T> void dump_graph(T G) {
int V = G.size();
int E = 0;
ostringstream os;
for (auto es : G) {
for (auto e : es) {
E++;
os << e.src << " " << e.dst << "\n";
}
}
cout << V << " " << E << "\n";
cout << os.str() << "\n";
}
// グリッドからグラフを構築
// @pre: gはノード数H*Wのグラフ
void create_from_grid(Graph &g, int h, int w, vector<string> &mapData,
char wall) {
//グラフ構築 O(HW)
rep(y, h) {
rep(x, w) {
if (mapData[y][x] == wall) {
continue;
}
int id = y * w + x;
//右と下(変位が正)のみ見る(辺の重複を回避するため)
rep(i, 2) {
int nx = x + dxp[i];
int ny = y + dyp[i];
int nid = ny * w + nx;
if (nx < 0 || nx >= w) {
continue;
}
if (ny < 0 || ny >= h) {
continue;
}
if (mapData[ny][nx] != wall) {
add_edge(g, id, nid);
}
}
}
}
}
// マスに重みが定義されるグリッドから重み付きグラフを構築、ダイクストラなどをするとき始点のこすとは入らないことに注意
// @pre: gはノード数H*Wのグラフ
void create_weighted_from_grid(Graph &g, int h, int w,
vector<vector<int>> &mapData) {
//グラフ構築 O(HW)
rep(y, h) {
rep(x, w) {
int id = y * w + x;
// こんどは全方向見る(行きと帰りで重みが違うはず)
rep(i, 4) {
int nx = x + dx[i];
int ny = y + dy[i];
int nid = ny * w + nx;
if (nx < 0 || nx >= w) {
continue;
}
if (ny < 0 || ny >= h) {
continue;
}
// 移動先のコストを足す
add_arc(g, id, nid, mapData[ny][nx]);
}
}
}
}
// グリッドにおいて座標をグラフのノード番号に変換する
int point_to_node_num(int x, int y, int W) { return y * W + x; }
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
template <signed M, unsigned T> struct mod_int {
constexpr static signed MODULO = M;
constexpr static unsigned TABLE_SIZE = T;
signed x;
mod_int() : x(0) {}
mod_int(long long y)
: x(static_cast<signed>(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO)) {}
mod_int(signed y) : x(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO) {}
mod_int &operator+=(const mod_int &rhs) {
if ((x += rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator-=(const mod_int &rhs) {
if ((x += MODULO - rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator*=(const mod_int &rhs) {
x = static_cast<signed>(1LL * x * rhs.x % MODULO);
return *this;
}
mod_int &operator/=(const mod_int &rhs) {
x = static_cast<signed>((1LL * x * rhs.inv().x) % MODULO);
return *this;
}
mod_int operator-() const { return mod_int(-x); }
mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }
mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }
mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }
mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }
bool operator<(const mod_int &rhs) const { return x < rhs.x; }
mod_int inv() const {
assert(x != 0);
if (x <= static_cast<signed>(TABLE_SIZE)) {
if (_inv[1].x == 0)
prepare();
return _inv[x];
} else {
signed a = x, b = MODULO, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mod_int(u);
}
}
mod_int pow(long long t) const {
assert(!(x == 0 && t == 0));
mod_int e = *this, res = mod_int(1);
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
mod_int fact() {
if (_fact[0].x == 0)
prepare();
return _fact[x];
}
mod_int inv_fact() {
if (_fact[0].x == 0)
prepare();
return _inv_fact[x];
}
mod_int choose(mod_int y) {
assert(y.x <= x);
return this->fact() * y.inv_fact() * mod_int(x - y.x).inv_fact();
}
static mod_int _inv[TABLE_SIZE + 1];
static mod_int _fact[TABLE_SIZE + 1];
static mod_int _inv_fact[TABLE_SIZE + 1];
static void prepare() {
_inv[1] = 1;
for (int i = 2; i <= (int)TABLE_SIZE; ++i) {
_inv[i] = 1LL * _inv[MODULO % i].x * (MODULO - MODULO / i) % MODULO;
}
_fact[0] = 1;
for (unsigned i = 1; i <= TABLE_SIZE; ++i) {
_fact[i] = _fact[i - 1] * signed(i);
}
_inv_fact[TABLE_SIZE] = _fact[TABLE_SIZE].inv();
for (int i = (int)TABLE_SIZE - 1; i >= 0; --i) {
_inv_fact[i] = _inv_fact[i + 1] * (i + 1);
}
}
};
template <signed M, unsigned F>
std::ostream &operator<<(std::ostream &os, const mod_int<M, F> &rhs) {
return os << rhs.x;
}
template <signed M, unsigned F>
std::istream &operator>>(std::istream &is, mod_int<M, F> &rhs) {
long long s;
is >> s;
rhs = mod_int<M, F>(s);
return is;
}
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
bool operator==(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return lhs.x == rhs.x;
}
template <int M, unsigned F>
bool operator!=(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return !(lhs == rhs);
}
const signed MF = 1000010;
const signed MOD = 1000000007;
using mint = mod_int<MOD, MF>;
mint binom(int n, int r) {
return (r < 0 || r > n || n < 0) ? 0 : mint(n).choose(r);
}
mint fact(int n) { return mint(n).fact(); }
mint inv_fact(int n) { return mint(n).inv_fact(); }
//出典 http://beet-aizu.hatenablog.com/entry/2017/12/01/225955
/*
コンストラクタ引数説明
int n_
要素数。
f
2つの要素Tをマージするための関数。
区間MAX区間更新の時: max
区間Sum区間Addの時: +
g
1つの要素Tに作用素Eを適用するための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
h
2つの作用素Eをマージするための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
T d1
演算fの単位元。
区間MAX区間更新の時: -INF
区間Sum区間Addの時: 0
E d0,
g, hの単位元。
区間MAX区間更新の時: 定義域外のどこか
区間Sum区間Addの時: 0
vector<T> v = vector<T>()
セグ木を構成するときのvector
P p = [](E a, int b) {return a; }
区間の長さbを引数に取り、区間の長さによって変化する作用素E'を返す関数。
例えば、区間MAX区間Addの時なんかは区間長によって足すべき数が変化するので必要
区間Sum区間Addの時: *
//具体例
//区間chmin, 区間min
auto myMin = [](int a, int b) {return min(a, b); };
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
//区間update、区間min
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
//区間Add、区間Sum
vector<int> v(0, N + 1);
SegmentTree<int, int> segtree(N + 1, plus<int>(), plus<int>(), plus<int>(), 0,
0, v, [](int a, int b) {return a * b; });
//区間Add、区間Min
vector<int> v(0, N + 1);
SegmentTree<int, int> segtree(N + 1, myMin, plus<int>(), plus<int>(),
LL_HALFMAX, 0, v, [](int a, int b) {return a; });
*/
template <typename T, typename E> struct SegmentTree {
typedef function<T(T, T)> F;
typedef function<T(T, E)> G;
typedef function<E(E, E)> H;
typedef function<E(E, int)> P;
int n;
F f;
G g;
H h;
P p;
T d1;
E d0;
vector<T> dat;
vector<E> laz;
SegmentTree(
int n_, F f, G g, H h, T d1, E d0, vector<T> v = vector<T>(),
P p = [](E a, int b) { return a; })
: f(f), g(g), h(h), d1(d1), d0(d0), p(p) {
init(n_);
if (n_ == (int)v.size())
build(n_, v);
}
//初期化。要素配列と遅延配列を2*n-1個にする
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, d1);
laz.clear();
laz.resize(2 * n - 1, d0);
}
//既存のvectorからセグ木を構築
void build(int n_, vector<T> v) {
for (int i = 0; i < n_; i++)
dat[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
}
//ノードを評価する。
inline void eval(int len, int k) {
//遅延配列に単位元が入ってたら評価済みなのでおしまい
if (laz[k] == d0)
return;
//葉ノードでないなら遅延伝播する
if (k * 2 + 1 < n * 2 - 1) {
// h: 2つの作用素を引数に取り合成した作用素を返す関数
laz[k * 2 + 1] = h(laz[k * 2 + 1], laz[k]);
laz[k * 2 + 2] = h(laz[k * 2 + 2], laz[k]);
}
// p:
// このノードに対応する区間長と作用素を引数に取り、区間長に対応する作用素を返す関数
// dat[k] にlaz に溜めていた作用素を適用(g:
// 要素型と作用素型を引数に取り、要素に作用素を作用させた結果を返す関数、ここでの作用素とは区間Sum区間Addなら
// (+ 3) とか)
dat[k] = g(dat[k], p(laz[k], len));
//適用し終わったので遅延配列をクリア
laz[k] = d0;
}
//[l,r)の区間を再帰的に見ながら0-indexedの[a, b)を更新する
T update(int a, int b, E x, int k, int l, int r) {
//先に評価
eval(r - l, k);
//範囲外ならなにもしないでそのノードが持つ値を返す
if (r <= a || b <= l)
return dat[k];
//完全被覆なら既に遅延配列に入っている作用素と追加したい作用素をマージした後にそれを要素に作用させた結果を返す、pは区間長に対応する作用素を得るための（ｒｙ
if (a <= l && r <= b) {
laz[k] = h(laz[k], x);
return g(dat[k], p(laz[k], r - l));
}
//完全被覆でも範囲外でもないなら(中途半端にかぶっているなら)完全被覆と範囲外の境界が見えるまで木を潜って変化後の値を得る
return dat[k] = f(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
}
T update(int a, int b, E x) { return update(a, b, x, 0, 0, n); }
T update(int a, E x) { return update(a, a + 1, x); }
T query(int a, int b, int k, int l, int r) {
eval(r - l, k);
//範囲外なら単位元を返す
if (r <= a || b <= l)
return d1;
//完全被覆ならそのまま返す
if (a <= l && r <= b)
return dat[k];
//一部被覆なら完全被覆と範囲外に分かれるまで木を潜る
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
// 0-indexedで[a, b)の区間*を求める
T query(int a, int b) { return query(a, b, 0, 0, n); }
T query(int a) { return query(a, a + 1, 0, 0, n); }
void debug_print(int num) {
vector<T> v;
rep(i, num) { v.push_back(query(i)); }
cout << "{" << v << "}\n";
}
};
//座標圧縮
class compress {
public:
map<int, int> zip;
vector<int> unzip;
compress(vector<int> x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip.push_back(i);
}
}
};
unsigned euclidean_gcd(unsigned a, unsigned b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
// https://ei1333.github.io/luzhiled/snippets/dp/cumulative-sum-2d.html
template <class T> struct CumulativeSum2D {
vector<vector<T>> data;
CumulativeSum2D(int W, int H) : data(W + 1, vector<int>(H + 1, 0)) {}
void add(int x, int y, T z) {
++x, ++y;
if (x >= data.size() || y >= data[0].size())
return;
data[x][y] += z;
}
void build() {
for (int i = 1; i < data.size(); i++) {
for (int j = 1; j < data[i].size(); j++) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
}
T query(int sx, int sy, int gx, int gy) {
return (data[gx][gy] - data[sx][gy] - data[gx][sy] + data[sx][sy]);
}
};
// lib
int nC2(int n) { return n * (n - 1) / 2; }
class node {
public:
int depth;
int num;
node(int d, int n) {
depth = d;
num = n;
}
};
template <class T> struct CumulativeSum {
vector<T> data;
CumulativeSum(int sz) : data(sz, 0){};
void add(int k, T x) { data[k] += x; }
void build() {
for (int i = 1; i < data.size(); i++) {
data[i] += data[i - 1];
}
}
T query(int k) {
if (k < 0)
return (0);
return (data[min(k, (int)data.size() - 1)]);
}
//[left, right]の和
T query(int left, int right) { return query(right) - query(left - 1); }
};
std::vector<int> eratosthenes_sieve(int n) {
std::vector<int> ps(n + 1);
std::iota(ps.begin() + 2, ps.end(), 2);
for (int i = 2; i * i <= n; ++i)
if (ps[i])
for (int j = i * i; j <= n; j += i)
ps[j] = 0;
return ps;
}
std::vector<int> make_primes(int n) {
std::vector<int> ps = eratosthenes_sieve(n);
ps.erase(std::remove(ps.begin(), ps.end(), 0), ps.end());
return ps;
}
// 区間[a, b)の素数判定をする、is_prime[i]: a + i が素数 or not つまり
// is_prime[i-a] が true: iが素数
std::vector<bool> segment_eratosthenes_sieve(int a, int b) {
vector<bool> is_prime(b - a, true);
vector<bool> is_prime_small;
for (int i = 0; i * i < b; i++)
is_prime_small.push_back(true);
for (int i = 2; i * i < b; i++) {
if (is_prime_small[i]) {
for (int j = 2 * i; j * j < b; j += i) {
is_prime_small[j] = false; // [2, sqrt(b))のふるい
}
// (a + i - 1LL) / i * i a以上の最小のiの倍数
for (int j = max(2LL, (a + i - 1LL) / i) * i; j < b; j += i) {
is_prime[j - a] = false; // [a, b)のふるい
}
}
}
return is_prime;
}
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
// 汎用的な二分探索のテンプレ(めぐる式)
int binary_search(function<bool(int)> isOk, int ng, int ok) {
/* ok と ng のどちらが大きいかわからないことを考慮 */
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (isOk(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0;; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
//更新がなくなったらおはり
if (!update)
break;
// n回以上更新されてたら負閉路がある
if (i > n) {
negCycle = true;
break;
}
}
return std::make_pair(dist, !negCycle);
}
//ゴールを指定して、それまでのパスに負閉路がなかったらOK(嘘修正済)
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s, int d) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0; i < n * 2; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
// n回目の更新で d が更新されてたら問答無用で負閉路ありとしてNG
if (i >= n - 1 && e.dst == d) {
negCycle = true;
}
// 終点以外に負閉路がある場合はそこの距離を十分小さい値に置き換える
else if (i >= n - 1) {
dist[e.dst] = -inf;
update = true;
} else {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
}
//更新がなくなったらおはり
if (!update)
break;
}
return std::make_pair(dist, !negCycle);
}
// R[i] == S[i] を中心とした極大回文長 なるvector Rを返す
vector<int> Manachar(string S) {
int len = S.length();
vector<int> R(len);
int i = 0, j = 0;
while (i < S.size()) {
while (i - j >= 0 && i + j < S.size() && S[i - j] == S[i + j])
++j;
R[i] = j;
int k = 1;
while (i - k >= 0 && i + k < S.size() && k + R[i - k] < j)
R[i + k] = R[i - k], ++k;
i += k;
j -= k;
}
return R;
}
std::vector<int> tsort(const Graph &g) {
int n = g.size(), k = 0;
std::vector<int> ord(n), in(n);
for (auto &es : g)
for (auto &e : es)
in[e.dst]++;
std::queue<int> q;
//入次数0の点をキューに追加
for (int i = 0; i < n; ++i)
if (in[i] == 0)
q.push(i);
while (q.size()) {
int v = q.front();
// Sから node n を削除する
q.pop();
// L に n を追加する
ord[k++] = v;
for (auto &e : g[v]) {
//選択した点から出てる辺を削除、0になったらキューに追加
if (--in[e.dst] == 0) {
q.push(e.dst);
}
}
}
return *std::max_element(in.begin(), in.end()) == 0 ? ord
: std::vector<int>();
}
std::vector<Weight> dijkstra(const Graph &g, int s) {
const Weight INF = std::numeric_limits<Weight>::max() / 8;
using state = std::tuple<Weight, int>;
std::priority_queue<state> q;
std::vector<Weight> dist(g.size(), INF);
dist[s] = 0;
q.emplace(0, s);
while (q.size()) {
Weight d;
int v;
std::tie(d, v) = q.top();
q.pop();
d *= -1;
/* if(v == t) return d; */
if (dist[v] < d)
continue;
for (auto &e : g[v]) {
if (dist[e.dst] > dist[v] + e.weight) {
dist[e.dst] = dist[v] + e.weight;
q.emplace(-dist[e.dst], e.dst);
}
}
}
return dist;
}
Matrix WarshallFloyd(const Graph &g) {
auto const INF = std::numeric_limits<Weight>::max() / 8;
int n = g.size();
Matrix d(n, Array(n, INF));
rep(i, n) d[i][i] = 0;
rep(i, n) for (auto &e : g[i]) d[e.src][e.dst] =
std::min(d[e.src][e.dst], e.weight);
rep(k, n) rep(i, n) rep(j, n) {
if (d[i][k] != INF && d[k][j] != INF)
d[i][j] = std::min(d[i][j], d[i][k] + d[k][j]);
}
return d;
}
std::pair<std::vector<int>, std::vector<int>> prime_factor_decomp(int n) {
std::vector<int> p, e;
int m = n;
for (int i = 2; i * i <= n; i++) {
if (m % i != 0)
continue;
int c = 0;
while (m % i == 0)
c++, m /= i;
p.push_back(i);
e.push_back(c);
}
if (m > 1) {
p.push_back(m);
e.push_back(1);
}
return std::make_pair(p, e);
}
int extgcd(int a, int b, int &x, int &y) {
int g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
// 不定方程式 ax + by = c の一般整数解(pt + q, rt + s)を求める
/*
* exist: 解が存在するか否か
* p, q, r, s: 存在するならば不定方程式の一般解(pt + q, rt + s)
* ここで、式変形から、p > 0、 q < 0
* となることに注意する。(解の条件を絞るときなどに必要になる)
*/
void IndeterminateEq(int a, int b, int c, bool &exist, int &p, int &q, int &r,
int &s) {
int X, Y;
int g = euclidean_gcd(a, b);
// c が最大公約数の整数倍でないならNG
if (c % g != 0) {
exist = false;
return;
}
exist = true;
// 拡張ユークリッドの互除法で ax + by = gcd(a, b) なる (X, Y) を求める
extgcd(a, b, X, Y);
int m = c / g;
// ax + by = c の解にする
X *= m;
Y *= m;
int a2 = a / g;
int b2 = b / g;
p = b2;
q = X;
r = -a2;
s = Y;
}
// x^n mod modulo を繰り返し二乗法で計算する
// n を 2^k の和で表す -> n
// を二進表記したとき、kbit目(0-indexed)が立っているときだけx^kをかける
int mod_pow(int x, int n, int modulo) {
int res = 1;
while (n > 0) {
if (n & 1) {
res = res * x % modulo;
}
x = x * x % modulo;
n >>= 1;
}
return res;
}
int64_t popcnt(int64_t n) {
int64_t c = 0;
c = (n & 0x5555555555555555) + ((n >> 1) & 0x5555555555555555);
c = (c & 0x3333333333333333) + ((c >> 2) & 0x3333333333333333);
c = (c & 0x0f0f0f0f0f0f0f0f) + ((c >> 4) & 0x0f0f0f0f0f0f0f0f);
c = (c & 0x00ff00ff00ff00ff) + ((c >> 8) & 0x00ff00ff00ff00ff);
c = (c & 0x0000ffff0000ffff) + ((c >> 16) & 0x0000ffff0000ffff);
c = (c & 0x00000000ffffffff) + ((c >> 32) & 0x00000000ffffffff);
return (c);
}
/*
行列積と行列累乗
行列積
vector<vector<T>> matrixMultiplies(vector<vector<T>> l, vector<vector<T>> r, F
plus = plus<T>(), G multiple = multiplies<T>(), T eplus = 0LL) 行列累乗
vector<vector<T>> matrixPower(vector<vector<T>> m, int n, F plus =
std::plus<T>(), G multiple = multiplies<T>(), T eplus = 0LL, T emultiple = 1LL)
T: 考える集合(競プロにおいてはたぶんほぼ整数)
l: 左からかける行列
r: 右からかける行列
plus: 加法演算
multiple: 乗法演算
eplus: 加法の単位元
emultiple: 乗法の単位元
*/
template <typename T = long long, typename F = decltype(std::plus<T>()),
typename G = decltype(multiplies<T>())>
vector<vector<T>>
matrixMultiplies(vector<vector<T>> l, vector<vector<T>> r, F plus = plus<T>(),
G multiple = multiplies<T>(), T eplus = 0LL) {
int rx = r[0].size();
int ry = r.size();
vector<vector<T>> ret;
for (int y = 0; y < ry; y++) {
vector<T> add;
for (int x = 0; x < rx; x++) {
T cell = eplus;
for (int i = 0; i < ry; i++) {
T mul = multiple(l[y][i], r[i][x]);
cell = plus(cell, mul);
}
add.push_back(cell);
}
ret.push_back(add);
}
return ret;
}
template <typename T = long long, typename F = decltype(std::plus<T>()),
typename G = decltype(multiplies<T>())>
vector<vector<T>>
matrixPower(vector<vector<T>> m, int n, F plus = std::plus<T>(),
G multiple = multiplies<T>(), T eplus = 0LL, T emultiple = 1LL) {
int k = m.size();
if (n == 0) {
vector<vector<T>> E;
for (int i = 0; i < k; i++) {
// 単位行列は対角成分を乗法単位元、非対角成分をゼロ元で埋める
vector<T> v(k, eplus);
v[i] = emultiple;
E.push_back(v);
}
return E;
}
vector<vector<T>> ret =
matrixPower(matrixMultiplies(m, m, plus, multiple, eplus), n / 2, plus,
multiple, eplus, emultiple);
if (n % 2 == 1) {
ret = matrixMultiplies(m, ret, plus, multiple);
}
return ret;
}
// フロー系のアルゴリズム
// 最大流
/*
Ford-Fulkerson法(蟻本) O(F|E|)
F: 最大流量
E: 辺数
コンストラクタ引数でノード数nを受け取り初期化し、add_edge
で辺と逆辺を追加していく
*/
class Ford_Fulkerson {
private:
struct Edge {
int src, dst;
// libalgo
// のものに追加、メンバを追加するだけなので互換性は崩さないはず、逆辺のG[e.dstの]インデックスを保持
int rev;
int cap;
Edge(int s, int d, int c, int r) : src(s), dst(d), cap(c), rev(r) {}
};
vector<vector<Edge>> G;
vector<bool> used;
public:
Ford_Fulkerson(int n) : G(n), used(n, false) {}
void add_edge(int s, int d, int cap) {
G[s].emplace_back(s, d, cap, G[d].size());
G[d].emplace_back(d, s, 0, G[s].size() - 1);
}
int dfs(int v, int t, int f) {
if (v == t) {
return f;
}
used[v] = true;
for (Edge &e : G[v]) {
if (!used[e.dst] && e.cap > 0) {
// 流せる辺があったら流す
int d = dfs(e.dst, t, min(f, e.cap));
if (d > 0) {
// 辺の残り容量を減らす
e.cap -= d;
// 逆辺の容量を増やす
G[e.dst][e.rev].cap += d;
return d;
}
}
}
// t にたどり着けなかったら0
return 0;
}
int max_flow(int s, int t) {
int flow = 0;
while (1) {
for (int i = 0; i < used.size(); i++) {
used[i] = false;
}
int f = dfs(s, t, LL_HALFMAX);
if (f == 0) {
return flow;
}
flow += f;
}
}
};
/*
Dinic法 From libalgo O(V^2 * E)
dinic::solve(s, t) : s -> t の最大流を求める
dinic;;flow[u][v] : 辺(u, v)の流量
*/
struct dinic {
int n, s, t;
std::vector<int> level, prog, que;
std::vector<std::vector<Flow>> cap, flow;
std::vector<std::vector<int>> g;
Flow inf;
dinic(const Graph &graph)
: n(graph.size()), cap(n, std::vector<Flow>(n)),
flow(n, std::vector<Flow>(n)), g(n, std::vector<int>()),
inf(std::numeric_limits<Flow>::max() / 8) {
for (int i = 0; i < n; i++) {
for (auto &e : graph[i]) {
int u = e.src, v = e.dst;
Flow c = e.cap;
cap[u][v] += c;
cap[v][u] += c;
flow[v][u] += c;
g[u].push_back(v);
g[v].push_back(u);
}
}
}
// 残りを求める
inline Flow residue(int u, int v) { return cap[u][v] - flow[u][v]; }
// 実際に最大流問題を解く
Flow solve(int s_, int t_) {
this->t = t_, this->s = s_;
que.resize(n + 1);
Flow res = 0;
// levelize() == false: bfs で s から t に到達できなかった
while (levelize()) {
prog.assign(n, 0);
res += augment(s, inf);
}
return res;
}
// bfs でレベルグラフをつくる
bool levelize() {
int l = 0, r = 0;
level.assign(n, -1);
level[s] = 0;
que[r++] = s;
while (l != r) {
int v = que[l++];
if (v == t)
break;
for (const int &d : g[v]) {
// まだレベルが決まっておらず、v -> dの辺に流せるならlevel[d] = level[v]
// + 1
if (level[d] == -1 && residue(v, d) != 0) {
level[d] = level[v] + 1;
que[r++] = d;
}
}
}
// t に到達できるなら true を返す
return level[t] != -1;
}
// dfs で実際に流してみる
Flow augment(int v, Flow lim) {
Flow res = 0;
if (v == t)
return lim;
// prog[v]: dfs
// において、vを展開する際、vの子の何番目まで展開したかを覚えておく
for (int &i = prog[v]; i < (int)g[v].size(); i++) {
const int &d = g[v][i];
// v -> d に流せない or v(流す側) の方がレベルが大きい(=深い)場合NG
if (residue(v, d) == 0 || level[v] >= level[d])
continue;
// 流せるなら、流せるだけ流す
const Flow aug = augment(d, std::min(lim, residue(v, d)));
flow[v][d] += aug;
flow[d][v] -= aug;
res += aug;
lim -= aug;
// ノードvに来ている流量を使い切ったら終わり
if (lim == 0)
break;
}
return res;
}
};
/*
Primal-Dual法(蟻本版 / ベルマンフォード)
*/
class Primal_Dual_BellmanFord {
using Cost = int;
struct Edge {
int src, dst;
// libalgo
// のものに追加、メンバを追加するだけなので互換性は崩さないはず、逆辺のG[e.dstの]インデックスを保持
int rev;
Cost cost;
Flow cap;
Edge(int s, int d, int aRev, Cost aCost, Flow aCap)
: src(s), dst(d), rev(aRev), cost(aCost), cap(aCap) {}
};
int V; //頂点数
vector<vector<Edge>> G; // 隣接リスト
vector<int> dist; // 最短距離
vector<int> prevv; // 直前の頂点
vector<int> preve; // 直前の辺
const int INF;
public:
// 頂点数 n を引数にとって初期化
Primal_Dual_BellmanFord(int n)
: V(n), G(n), dist(n, 0), prevv(n, 0), preve(n, 0),
INF(std::numeric_limits<int>::max() / 8) {}
void add_edge(int src, int dst, int cap, int cost) {
// cost は weight に入れる
G[src].emplace_back(src, dst, G[dst].size(), cost, cap);
G[dst].emplace_back(dst, src, G[src].size() - 1, -cost, 0);
}
int min_cost_flow(int s, int t, int f) {
int res = 0;
while (f > 0) {
// ベルマンフォードによりs-t最短路をもとめる
dist.assign(V, INF);
dist[s] = 0;
bool update = true;
while (update) {
update = false;
for (int v = 0; v < V; v++) {
if (dist[v] == INF)
continue;
for (int i = 0; i < G[v].size(); i++) {
Edge &e = G[v][i];
if (e.cap > 0 && dist[e.dst] > dist[v] + e.cost) {
dist[e.dst] = dist[v] + e.cost;
prevv[e.dst] = v;
preve[e.dst] = i;
update = true;
}
}
}
}
// これ以上流せない
if (dist[t] == INF) {
return -1;
}
// 復元したs-t最短路に沿って流せるだけ流す
int d = f;
// 尻からprevvを辿っていき、流せる量を求める
for (int v = t; v != s; v = prevv[v]) {
// 一つ手前に戻るための辺
Edge &e = G[prevv[v]][preve[v]];
chmin(d, e.cap);
}
f -= d;
// ここでの dist
// はコスト和なので、それに流す量をかけると今回見つけた最短パスに流すコストとなる。
res += d * dist[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
};
/*
ダイクストラ版 Primal-Dual
出典: https://ei1333.github.io/luzhiled/snippets/graph/primal-dual.html
*/
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
edge(int aTo, flow_t aCap, cost_t aCost, int aRev, bool aIsRev)
: to(aTo), cap(aCap), cost(aCost), rev(aRev), isrev(aIsRev) {}
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(to, cap, cost, (int)graph[to].size(), false);
graph[to].emplace_back(from, 0, -cost, (int)graph[from].size() - 1, true);
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
class lca {
public:
int n, segn;
vector<int> path; // 蟻本の vs、オイラーツアーを保持
vector<int> depth; // 蟻本の depth、path[i] であるノードの深さを保持
vector<int>
in_order; // 蟻本の
// id、ノードiがオイラーツアーで最初に出てくるインデックスを保持
vector<pair<int, int>> dat;
const std::pair<int, int> INF = std::make_pair(1000000000, 1000000000);
lca(const Graph &g, int root)
: n(g.size()), path(n * 2 - 1), depth(n * 2 - 1), in_order(n) {
int k = 0;
dfs(g, root, -1, 0, k);
// セグ木を構築、持つのはpair(depth, index) => depth が最小となる index
// がわかる
for (segn = 1; segn < n * 2 - 1; segn <<= 1)
;
dat.assign(segn * 2, INF);
for (int i = 0; i < (int)depth.size(); ++i)
dat[segn + i] = std::make_pair(depth[i], i);
for (int i = segn - 1; i >= 1; --i)
dat[i] = min(dat[i * 2], dat[i * 2 + 1]);
}
int get(int u, int v) const {
int l = std::min(in_order[u], in_order[v]);
int r = std::max(in_order[u], in_order[v]) + 1;
return path[range_min(1, segn, l, r).second];
}
void dfs(const Graph &g, int v, int p, int d, int &k) {
// k: オイラーツアーの何番目かを保持する変数
in_order[v] = k;
path[k] = v;
depth[k++] = d;
for (auto &e : g[v]) {
if (e.dst != p) {
dfs(g, e.dst, v, d + 1, k);
// ここに来た時はノードvの子であるe.dstを展開し終わってvに戻ってきたときなので、再度
// path と depth に記録する
path[k] = v;
depth[k++] = d;
}
}
}
// v : いまみてるノード、w: 今見てるノードに対応する区間長 l: ? r: ?
pair<int, int> range_min(int v, int w, int l, int r) const {
if (r <= l || w == 0)
return INF;
if (r - l == w)
return dat[v];
int m = w / 2;
auto rmin = range_min(v * 2, m, l, std::min(r, m));
auto lmin = range_min(v * 2 + 1, m, std::max(0LL, l - m), r - m);
return min(rmin, lmin);
}
};
// int における ceil と floor、負数対応(a / b の ceil, floor)
int64_t intceil(int64_t a, int64_t b) {
int sign_a = (a > 0) - (a < 0);
int sign_b = (b > 0) - (b < 0);
if (sign_a == sign_b) {
return (a + b - sign_b) / b;
} else {
return a / b;
}
}
int64_t intfloor(int64_t a, int64_t b) {
int sign_a = (a > 0) - (a < 0);
int sign_b = (b > 0) - (b < 0);
if (sign_a == sign_b) {
return a / b;
} else {
return (a - b + sign_b) / b;
}
}
const string YES = "Yes";
void solve(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B);
void solve_TLE(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B);
class StressTest {
private:
mt19937 m_RandEngine;
bool judge_case(long long N, long long M, std::vector<long long> A,
std::vector<long long> B) {
ostringstream fast, tle;
solve(fast, N, M, std::move(A), std::move(B));
solve_TLE(tle, N, M, std::move(A), std::move(B));
if (fast.str() == tle.str()) {
return true;
} else {
return false;
}
}
// [l, l+1, ... r] の数列を生成し、シャッフルする
vector<int> create_range_permutation(int l, int r) {
vector<int> ret;
for (int i = l; i <= r; i++) {
ret.push_back(i);
}
shuffle(ret.begin(), ret.end(), m_RandEngine);
return ret;
}
// [1, n] の順列を生成する
vector<int> create_permutation(int n) { create_range_permutation(1, n); }
// 範囲が[l, r] でサイズが n の数列を生成する
vector<int> create_random_sequence(int l, int r, int n) {
uniform_int_distribution<> randLR(l, r);
vector<int> ret;
for (int i = 0; i < n; i++) {
ret.push_back(randLR(m_RandEngine));
}
return ret;
}
/*
* 頂点数 n, 辺数 m で自己ループと多重辺のない無向グラフを生成
* 慣習的に頂点番号が1-indexed な AtCoder で 1-n の頂点が使えるようにするため
* n+1 頂点のグラフを生成し、0番を無視することとする weighted を true
* にすると重み付き、maxWeight で最大重みを指定
* 連結でないグラフが出力される可能性があることに注意する
*/
Graph create_undirected_graph(int n, int m, bool weighted = false,
int maxWeight = 10) {
Graph ret(n + 1);
set<pair<int, int>> used;
uniform_int_distribution<> randNode(1, n);
uniform_int_distribution<> randWeight(1, maxWeight);
while (used.size() < m * 2) {
int src = randNode(m_RandEngine);
int dst = randNode(m_RandEngine);
// 自己ループ、多重辺判定
if (used.count(make_pair(src, dst)) == 0 &&
used.count(make_pair(dst, src)) == 0 && src != dst) {
used.insert(make_pair(src, dst));
used.insert(make_pair(dst, src));
add_edge(ret, src, dst, weighted ? randWeight(m_RandEngine) : 1);
}
}
return ret;
}
/*
* 頂点数 n, 辺数 m で自己ループと多重辺のない有向グラフを生成
* 慣習的に頂点番号が1-indexed な AtCoder で 1-n の頂点が使えるようにするため
* n+1 頂点のグラフを生成し、0番を無視することとする weighted を true
* にすると重み付き、maxWeight で最大重みを指定
* 連結でないグラフが出力される可能性があることに注意する
*/
Graph create_directed_graph(int n, int m, bool weighted = false,
int maxWeight = 10) {
Graph ret(n + 1);
set<pair<int, int>> used;
uniform_int_distribution<> randNode(1, n);
uniform_int_distribution<> randWeight(1, maxWeight);
while (used.size() < m) {
int src = randNode(m_RandEngine);
int dst = randNode(m_RandEngine);
// 自己ループ、多重辺判定
if (used.count(make_pair(src, dst)) == 0 && src != dst) {
used.insert(make_pair(src, dst));
add_arc(ret, src, dst, weighted ? randWeight(m_RandEngine) : 1);
}
}
return ret;
}
/*
* 頂点数nの木(無向)を生成します。
*/
Graph create_tree(int n, bool weighted = false, int maxWeight = 10) {
Graph ret(n + 1);
uf_tree uf(n + 1);
int cnt = 0;
uniform_int_distribution<> randNode(1, n);
uniform_int_distribution<> randWeight(1, maxWeight);
while (cnt < n - 1) {
int n1 = randNode(m_RandEngine);
int n2 = randNode(m_RandEngine);
if (n1 != n2 && !uf.is_same(n1, n2)) {
cnt++;
add_edge(ret, n1, n2, weighted ? randWeight(m_RandEngine) : 1);
}
}
}
public:
StressTest(int seed) : m_RandEngine(seed) {}
void test() {
while (1) {
// TODO: generate random case
// if (!judge_case(N, M, std::move(A), std::move(B))) {
// TODO: output case
// break;
//}
}
}
};
void solve(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B) {}
void solve_TLE(ostringstream &aout, long long N, long long M,
std::vector<long long> A, std::vector<long long> B) {}
// dp[i][c][fixed] := i(1-indexed) まで決まってて、0以外がc個あって、fixed =
// true: 既にNイカであることが決まっている false: きまっていない
int dp[110][4][2];
signed main() {
int N;
cin >> N;
vector<int> A(N, 0), B(N, 0), C(N, 0);
rep(i, N) cin >> A[i];
int ma = -1;
rep(i, N) {
chmax(ma, A[i]);
B[i] = ma;
}
ma = -1;
RREP(i, N) {
chmax(ma, A[i]);
C[i] = ma;
}
rep(i, N) {
if (i == 0) {
cout << C[1] << "\n";
} else if (i == N - 1) {
cout << B[N - 2] << "\n";
} else {
int ans = max(B[i - 1], C[i + 1]);
cout << ans << "\n";
}
}
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,195 | 775,196 | u783675879 | cpp |
p02971 | #include <algorithm>
#include <bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 1000000000000
int MOD = 1000000007;
int modpow(int a, int x) {
if (a < 0)
a += MOD;
int ans = 1;
while (x > 0) {
if (x & 1)
ans = ans * a % MOD;
a = a * a % MOD;
x >>= 1;
}
return ans;
}
int gyaku(int n) { return modpow(n, MOD - 2); }
signed main() {
int n;
cin >> n;
vector<int> a(n);
int max1 = 0, max2 = 0;
rep(i, n) {
cin >> a[i];
if (max1 < a[i]) {
max2 = max1;
max1 = a[i];
}
if (max1 > a[i] && max2 < a[i]) {
max2 = a[i];
}
}
rep(i, n) {
if (a[i] == max1) {
cout << max2 << endl;
} else
cout << max1 << endl;
}
}
| #include <algorithm>
#include <bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 1000000000000
int MOD = 1000000007;
int modpow(int a, int x) {
if (a < 0)
a += MOD;
int ans = 1;
while (x > 0) {
if (x & 1)
ans = ans * a % MOD;
a = a * a % MOD;
x >>= 1;
}
return ans;
}
int gyaku(int n) { return modpow(n, MOD - 2); }
signed main() {
int n;
cin >> n;
vector<int> a(n);
int max1 = 0, max2 = 0;
rep(i, n) {
cin >> a[i];
if (max1 <= a[i]) {
max2 = max1;
max1 = a[i];
} else if (max1 >= a[i] && max2 < a[i]) {
max2 = a[i];
}
}
rep(i, n) {
if (a[i] == max1) {
cout << max2 << endl;
} else
cout << max1 << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 775,203 | 775,204 | u532514769 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
vector<int> v(N);
for (int X = 0; X < N; X++) {
cin >> vec.at(X);
v.at(X) = vec.at(X);
}
sort(v.begin(), v.end());
for (int X = 0; X < N; X++) {
if (vec.at(X) = v.at(N - 1)) {
cout << v.at(N - 2) << endl;
} else {
cout << v.at(N - 1) << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
vector<int> v(N);
for (int X = 0; X < N; X++) {
cin >> vec.at(X);
v.at(X) = vec.at(X);
}
sort(v.begin(), v.end());
for (int X = 0; X < N; X++) {
if (vec.at(X) == v.at(N - 1)) {
cout << v.at(N - 2) << endl;
} else {
cout << v.at(N - 1) << endl;
}
}
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 775,205 | 775,206 | u740002394 | cpp |
p02971 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define INF 100000000
#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define repp(i, n, s) for (int i = (int)(n); i >= (int)(s); i--)
#define mp make_pair
ll mod = 1000000007;
ll mod2 = 998244353;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n), b(n), c(n);
rep(i, 0, n) { cin >> a[i]; }
b[0] = a[0];
c[n - 1] = a[n - 1];
rep(i, 1, n) b[i] = max(b[i - 1], a[i]);
repp(i, n - 2, 0) c[i] = max(c[i + 1], a[i]);
rep(i, 0, n) {
if (i == 0) {
cout << c[1] << endl;
continue;
}
if (i == n - 1) {
cout << b[n - 1] << endl;
continue;
}
cout << max(b[i - 1], c[i + 1]) << endl;
}
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define INF 100000000
#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define repp(i, n, s) for (int i = (int)(n); i >= (int)(s); i--)
#define mp make_pair
ll mod = 1000000007;
ll mod2 = 998244353;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n), b(n), c(n);
rep(i, 0, n) { cin >> a[i]; }
b[0] = a[0];
c[n - 1] = a[n - 1];
rep(i, 1, n) b[i] = max(b[i - 1], a[i]);
repp(i, n - 2, 0) c[i] = max(c[i + 1], a[i]);
rep(i, 0, n) {
if (i == 0) {
cout << c[1] << endl;
continue;
}
if (i == n - 1) {
cout << b[n - 2] << endl;
continue;
}
cout << max(b[i - 1], c[i + 1]) << endl;
}
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,211 | 775,212 | u590825760 | cpp |
p02971 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
long double const pi = std::acos(-1.0L);
typedef pair<int, int> P;
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> b = a;
sort(b.rbegin(), b.rend());
rep(i, n) {
int ans = b[0];
if (b[0] == a[i])
ans = b[i];
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
long double const pi = std::acos(-1.0L);
typedef pair<int, int> P;
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> b = a;
sort(b.rbegin(), b.rend());
rep(i, n) {
int ans = b[0];
if (b[0] == a[i])
ans = b[1];
cout << ans << endl;
}
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 775,222 | 775,223 | u186506670 | cpp |
p02971 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
using namespace std;
void solve() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
int m1 = 0, m2 = 0;
rep(i, n) {
cin >> a[i];
if (m1 <= a[i]) {
m2 = m1;
m1 = a[i];
} else {
if (m2 < a[1]) {
m2 = a[i];
}
}
}
rep(i, n) {
if (a[i] == m1) {
cout << m2 << endl;
} else {
cout << m1 << endl;
}
}
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
using namespace std;
void solve() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
int m1 = 0, m2 = 0;
rep(i, n) {
cin >> a[i];
if (m1 <= a[i]) {
m2 = m1;
m1 = a[i];
} else {
if (m2 < a[i]) {
m2 = a[i];
}
}
}
rep(i, n) {
if (a[i] == m1) {
cout << m2 << endl;
} else {
cout << m1 << endl;
}
}
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 775,224 | 775,225 | u931173291 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using Pair = pair<int, int>;
using Graph = vector<vector<int>>;
#define MOD 1000000007
#define INF 1000000007
#define SEP " "
int main() {
int n;
vector<int> a(n, 0);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<int> b = a;
sort(b.begin(), b.end(), greater<int>());
if (b[0] == b[1]) {
for (int i = 0; i < n; i++)
cout << b[0] << endl;
} else {
for (int i = 0; i < n; i++) {
if (a[i] == b[0])
cout << b[1] << endl;
else
cout << b[0] << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using Pair = pair<int, int>;
using Graph = vector<vector<int>>;
#define MOD 1000000007
#define INF 1000000007
#define SEP " "
int main() {
int n;
cin >> n;
vector<int> a(n, 0);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<int> b = a;
sort(b.begin(), b.end(), greater<int>());
if (b[0] == b[1]) {
for (int i = 0; i < n; i++)
cout << b[0] << endl;
} else {
for (int i = 0; i < n; i++) {
if (a[i] == b[0])
cout << b[1] << endl;
else
cout << b[0] << endl;
}
}
}
| [] | 775,253 | 775,254 | u894418077 | cpp |
p02971 | //インクルード(アルファベット順)
#include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <chrono> //実行時間計測
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm,accumulate
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <string> //文字列
#include <unordered_map> //順序保持しないmap
#include <unordered_set> //順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= ll(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= ll(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) x.begin(), x.end()
#define SIZE(x) ll(x.size())
//定数
#define INF 1000000000000 // 10^12:∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange
//略記
#define PB push_back //挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define PI 3.14159265358979323846264338327950L
#define YESNO(T) \
if (T) { \
cout << "YES" << endl; \
} else { \
cout << "NO" << endl; \
}
#define yesno(T) \
if (T) { \
cout << "yes" << endl; \
} else { \
cout << "no" << endl; \
}
#define YesNo(T) \
if (T) { \
cout << "Yes" << endl; \
} else { \
cout << "No" << endl; \
}
#define int long long
#define Graph vector<vector<int>>
#define PII pair<int, int>
#define VI vector<int>
#define VVI vector<vector<int>>
#define VPII vector<pair<int, int>>
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
long long powmod(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1)
ret = ret * x %
MOD; // n の最下位bitが1ならば(nが奇数ならば) x^(2^i) をかける
x = x * x % MOD;
n >>= 1; // n を1bit 左にずらす
}
return ret;
}
int ctoi(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
}
else {
return (gcd(b, a % b));
}
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool isPrime(int x) {
int i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1; //素数だった時の
return ret;
}
long long nCr(long long n, long long r) {
long long x = 1, y = 1;
for (int i = 0; i < r; i++) {
x = x * (n - i) % MOD;
y = y * (i + 1) % MOD;
}
return x * powmod(y, MOD - 2) % MOD;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここにグローバル変数宣言
int dh[4] = {1, 0, -1, 0};
int dw[4] = {0, 1, 0, -1}; // BFS関連
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここに関数宣言
int d(int n) {
string s = to_string(n);
n = s.size();
return n;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
signed main() {
//入力の高速化用のコード
ios::sync_with_stdio(false);
cin.tie(nullptr);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int N;
cin >> N;
VI A(N); //ソートさせる;
VI ACP(N); //非ソート
REP(i, N) {
cin >> A[i];
ACP[i] = A[i];
}
sort(ALL(A));
reverse(ALL(A)); //大きいもの順に
REP(i, N) {
if (A[0] == ACP[i]) {
cout << A[i] << endl;
} else
cout << A[0] << endl;
}
return 0;
}
| //インクルード(アルファベット順)
#include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <chrono> //実行時間計測
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm,accumulate
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <string> //文字列
#include <unordered_map> //順序保持しないmap
#include <unordered_set> //順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= ll(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= ll(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) x.begin(), x.end()
#define SIZE(x) ll(x.size())
//定数
#define INF 1000000000000 // 10^12:∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange
//略記
#define PB push_back //挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define PI 3.14159265358979323846264338327950L
#define YESNO(T) \
if (T) { \
cout << "YES" << endl; \
} else { \
cout << "NO" << endl; \
}
#define yesno(T) \
if (T) { \
cout << "yes" << endl; \
} else { \
cout << "no" << endl; \
}
#define YesNo(T) \
if (T) { \
cout << "Yes" << endl; \
} else { \
cout << "No" << endl; \
}
#define int long long
#define Graph vector<vector<int>>
#define PII pair<int, int>
#define VI vector<int>
#define VVI vector<vector<int>>
#define VPII vector<pair<int, int>>
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
long long powmod(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1)
ret = ret * x %
MOD; // n の最下位bitが1ならば(nが奇数ならば) x^(2^i) をかける
x = x * x % MOD;
n >>= 1; // n を1bit 左にずらす
}
return ret;
}
int ctoi(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
}
else {
return (gcd(b, a % b));
}
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool isPrime(int x) {
int i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1; //素数だった時の
return ret;
}
long long nCr(long long n, long long r) {
long long x = 1, y = 1;
for (int i = 0; i < r; i++) {
x = x * (n - i) % MOD;
y = y * (i + 1) % MOD;
}
return x * powmod(y, MOD - 2) % MOD;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここにグローバル変数宣言
int dh[4] = {1, 0, -1, 0};
int dw[4] = {0, 1, 0, -1}; // BFS関連
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ここに関数宣言
int d(int n) {
string s = to_string(n);
n = s.size();
return n;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
signed main() {
//入力の高速化用のコード
ios::sync_with_stdio(false);
cin.tie(nullptr);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int N;
cin >> N;
VI A(N); //ソートさせる;
VI ACP(N); //非ソート
REP(i, N) {
cin >> A[i];
ACP[i] = A[i];
}
sort(ALL(A));
reverse(ALL(A)); //大きいもの順に
REP(i, N) {
if (A[0] == ACP[i]) {
cout << A[1] << endl;
} else
cout << A[0] << endl;
}
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,277 | 775,278 | u345693891 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
} //最大公約数
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
} //最小公倍数
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
} //コンビネーション
int nHr(int a, int b) { return nCr(a + b - 1, b); } // 重複組み合わせ
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
} //階乗
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
} // a~bまでの階乗
int dsum(int x) {
int r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
} //数字の各位の和
int dsumb(int x, int b) {
int r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
} // b進数の各位の和？
int sankaku(int x) { return ((1 + x) * x) / 2; } //三角数 xまでの和
//以下long long ver
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long lldsum(long long x) {
long long r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
long long lldsumb(long long x, long long b) {
long long r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
long long llsankaku(long long x) { return ((1 + x) * x) / 2; }
// double
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
typedef pair<int, int> ii;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define forr(i, a, b) \
; \
for (int i = (a); i < (b); i++)
#define clean(arr, val) memset(arr, val, sizeof(arr))
#define forn(i, n) forr(i, 0, n)
#define PB push_back
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<pll> vpll;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
/*CODE START HERE*/
int main() {
int n;
cin >> n;
vector<int> a(n);
forn(i, n) { cin >> a.at(i); }
vector<int> left(n);
left.at(0) = a.at(0);
vector<int> right(n);
right.at(n - 1) = a.at(n - 1) forr(i, 1, n) {
left.at(i) = max(left.at(i - 1), a.at(i));
}
forr(i, 1, n) { right.at(n - i - 1) = max(right.at(n - i), a.at(n - i - 1)); }
cout << right.at(0) << endl;
forr(i, 1, n - 1) { cout << max(right.at(i + 1), left.at(i - 1)) << endl; }
cout << left.at(n - 1) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
} //最大公約数
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
} //最小公倍数
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
} //コンビネーション
int nHr(int a, int b) { return nCr(a + b - 1, b); } // 重複組み合わせ
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
} //階乗
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
} // a~bまでの階乗
int dsum(int x) {
int r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
} //数字の各位の和
int dsumb(int x, int b) {
int r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
} // b進数の各位の和？
int sankaku(int x) { return ((1 + x) * x) / 2; } //三角数 xまでの和
//以下long long ver
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long lldsum(long long x) {
long long r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
long long lldsumb(long long x, long long b) {
long long r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
long long llsankaku(long long x) { return ((1 + x) * x) / 2; }
// double
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
typedef pair<int, int> ii;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define forr(i, a, b) \
; \
for (int i = (a); i < (b); i++)
#define clean(arr, val) memset(arr, val, sizeof(arr))
#define forn(i, n) forr(i, 0, n)
#define PB push_back
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<pll> vpll;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
/*CODE START HERE*/
int main() {
int n;
cin >> n;
vector<int> a(n);
forn(i, n) { cin >> a.at(i); }
vector<int> left(n);
left.at(0) = a.at(0);
vector<int> right(n);
right.at(n - 1) = a.at(n - 1) forr(i, 1, n) {
left.at(i) = max(left.at(i - 1), a.at(i));
}
forr(i, 1, n) { right.at(n - i - 1) = max(right.at(n - i), a.at(n - i - 1)); }
cout << right.at(1) << endl;
forr(i, 1, n - 1) { cout << max(right.at(i + 1), left.at(i - 1)) << endl; }
cout << left.at(n - 2) << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 775,279 | 775,280 | u946082956 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define endl "\n"
typedef long long ll;
const double pi = 3.14159265358979323846;
int ctoi(const char c) {
if ('0' <= c && c <= '9')
return (c - '0');
return -1;
}
vector<int> input(int n) {
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
return vec;
}
void output(vector<int> vec) {
for (int i = 0; i < int(vec.size()); i++) {
cout << vec[i] << " ";
}
return;
}
vector<vector<int>> input(int n, int m) {
vector<vector<int>> table(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> table.at(i).at(j);
}
}
return table;
}
void output(vector<vector<int>> table) {
for (int i = 0; i < int(table.size()); i++) {
for (int j = 0; j < int(table.at(0).size()); j++) {
cout << table.at(i).at(j) << " ";
}
cout << endl;
}
}
long long perm(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long perm = 1;
for (int i = n; i > n - r; i--) {
perm *= i;
}
return perm;
}
long long comb(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long comb = perm(n, r);
for (int i = r; i > 0; i--) {
comb /= i;
}
return comb;
}
long long homo(int n, int r) { return comb(n + r - 1, n - 1); }
long long fact(int n) {
long long fact = 1;
for (int i = n; i > 0; i--) {
fact *= i;
}
return fact;
}
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool isprime(int n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
vector<long long> divisors(long long N) {
vector<long long> res;
for (long long i = 1; i * i <= N; ++i) {
if (N % i == 0) {
res.push_back(i);
// 重複しないならば i の相方である N/i も push
if (N / i != i)
res.push_back(N / i);
}
}
// 小さい順に並び替える
sort(res.begin(), res.end());
return res;
/*long long N;
cin >> N;
vector<long long> res = divisors(N);
for (int i = 0; i < res.size(); ++i) {
cout << res[i] << " ";
}
cout << endl;*/
}
vector<pair<long long, long long>> prime_factorize(long long N) {
vector<pair<long long, long long>> res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
void Yes(bool f) {
if (f) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
void YES(bool f) {
if (f) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
bool leapyear(int y) {
//閏年かどうかを判定
if (y % 4 == 0) {
if (y % 100 == 0) {
if (y % 400 == 0) {
return true;
} else {
return false;
}
} else {
return true;
}
} else {
return false;
}
}
tuple<int, int, int> dayplus(int y, int m, int d) {
//次の日を返す
// 31日まである月
if (m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10 || m == 12) {
if (d != 31) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
if (m == 12) {
m = 1;
y++;
return make_tuple(y, m, d);
} else {
m++;
return make_tuple(y, m, d);
}
}
}
// 30日まである月
else if (m == 4 || m == 6 || m == 9 || m == 11) {
if (d != 30) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
m++;
return make_tuple(y, m, d);
}
}
// 2月
else {
//閏年の場合
if (leapyear(y)) {
if (d != 29) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
m++;
return make_tuple(y, m, d);
}
}
//閏年ではない場合
else {
if (d != 28) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
m++;
return make_tuple(y, m, d);
}
}
}
}
tuple<int, int, int> monplus(int y, int m, int d) {
//月を一つ先に、日を一日にする
d = 1;
if (m == 12) {
m = 1;
y++;
return make_tuple(y, m, d);
} else {
m++;
return make_tuple(y, m, d);
}
}
int main() {
int n;
cin >> n;
vector<int> a = input(n);
vector<int> b = a;
sort(b.begin(), b.end());
int fi = b[n - 1], se = b[n - 1];
for (int i = 0; i < n; i++) {
if (a[i] == fi) {
cout << se << endl;
} else {
cout << fi << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define endl "\n"
typedef long long ll;
const double pi = 3.14159265358979323846;
int ctoi(const char c) {
if ('0' <= c && c <= '9')
return (c - '0');
return -1;
}
vector<int> input(int n) {
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
return vec;
}
void output(vector<int> vec) {
for (int i = 0; i < int(vec.size()); i++) {
cout << vec[i] << " ";
}
return;
}
vector<vector<int>> input(int n, int m) {
vector<vector<int>> table(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> table.at(i).at(j);
}
}
return table;
}
void output(vector<vector<int>> table) {
for (int i = 0; i < int(table.size()); i++) {
for (int j = 0; j < int(table.at(0).size()); j++) {
cout << table.at(i).at(j) << " ";
}
cout << endl;
}
}
long long perm(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long perm = 1;
for (int i = n; i > n - r; i--) {
perm *= i;
}
return perm;
}
long long comb(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long comb = perm(n, r);
for (int i = r; i > 0; i--) {
comb /= i;
}
return comb;
}
long long homo(int n, int r) { return comb(n + r - 1, n - 1); }
long long fact(int n) {
long long fact = 1;
for (int i = n; i > 0; i--) {
fact *= i;
}
return fact;
}
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool isprime(int n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
vector<long long> divisors(long long N) {
vector<long long> res;
for (long long i = 1; i * i <= N; ++i) {
if (N % i == 0) {
res.push_back(i);
// 重複しないならば i の相方である N/i も push
if (N / i != i)
res.push_back(N / i);
}
}
// 小さい順に並び替える
sort(res.begin(), res.end());
return res;
/*long long N;
cin >> N;
vector<long long> res = divisors(N);
for (int i = 0; i < res.size(); ++i) {
cout << res[i] << " ";
}
cout << endl;*/
}
vector<pair<long long, long long>> prime_factorize(long long N) {
vector<pair<long long, long long>> res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
void Yes(bool f) {
if (f) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
void YES(bool f) {
if (f) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
bool leapyear(int y) {
//閏年かどうかを判定
if (y % 4 == 0) {
if (y % 100 == 0) {
if (y % 400 == 0) {
return true;
} else {
return false;
}
} else {
return true;
}
} else {
return false;
}
}
tuple<int, int, int> dayplus(int y, int m, int d) {
//次の日を返す
// 31日まである月
if (m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10 || m == 12) {
if (d != 31) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
if (m == 12) {
m = 1;
y++;
return make_tuple(y, m, d);
} else {
m++;
return make_tuple(y, m, d);
}
}
}
// 30日まである月
else if (m == 4 || m == 6 || m == 9 || m == 11) {
if (d != 30) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
m++;
return make_tuple(y, m, d);
}
}
// 2月
else {
//閏年の場合
if (leapyear(y)) {
if (d != 29) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
m++;
return make_tuple(y, m, d);
}
}
//閏年ではない場合
else {
if (d != 28) {
d++;
return make_tuple(y, m, d);
} else {
d = 1;
m++;
return make_tuple(y, m, d);
}
}
}
}
tuple<int, int, int> monplus(int y, int m, int d) {
//月を一つ先に、日を一日にする
d = 1;
if (m == 12) {
m = 1;
y++;
return make_tuple(y, m, d);
} else {
m++;
return make_tuple(y, m, d);
}
}
int main() {
int n;
cin >> n;
vector<int> a = input(n);
vector<int> b = a;
sort(b.begin(), b.end());
int fi = b[n - 1], se = b[n - 2];
for (int i = 0; i < n; i++) {
if (a[i] == fi) {
cout << se << endl;
} else {
cout << fi << endl;
}
}
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 775,281 | 775,282 | u492660436 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
int max1 = 0, max2 = 0;
for (int i = 0; i < n; i++) {
cin >> a.at(i);
if (a.at(i) > max1) {
max2 = max1;
max1 = a.at(i);
} else if (a.at(i) == max1 || a.at(i) > max2) {
max2 = a.at(i);
}
}
for (int i = 0; i < n; i++) {
if (a.at(i) == max1) {
cout << max1 << endl;
} else {
cout << max2 << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
int max1 = 0, max2 = 0;
for (int i = 0; i < n; i++) {
cin >> a.at(i);
if (a.at(i) > max1) {
max2 = max1;
max1 = a.at(i);
} else if (a.at(i) == max1 || a.at(i) > max2) {
max2 = a.at(i);
}
}
for (int i = 0; i < n; i++) {
if (a.at(i) == max1) {
cout << max2 << endl;
} else {
cout << max1 << endl;
}
}
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 775,292 | 775,293 | u442714890 | cpp |
p02971 | // ABC_128_B// pair型の中にpair型
/*int main() {
int n;
cin >> n;
vector<pair<pair<string,int>,int>> a(n);
for(int i=0;i<n;i++){
string s;
cin >> s;
int num;
cin >> num;
num = num * -1;
a.at(i).first.first = s;
a.at(i).first.second = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second +1 << endl;
}
}
*/
// ABC_058_Cのように
// s.at(j) == a のとき
// cout << s.at(j)-'0' - 49 << endl;
//とすると、「0」を出力してくれる。 →もっといいほかの方法はないの？
//全bit探索を入れよう!!
/*ABC_167_C skill up などを参考に…
//https://qiita.com/hareku/items/3d08511eab56a481c7db
int main() {
int n = 3;
// {0, 1, ..., n-1} の部分集合の全探索
for (int bit = 0; bit < (1<<n); ++bit) {
vector<int> S;
for (int i = 0; i < n; ++i) {
if (bit & (1<<i)) { // 列挙に i が含まれるか
S.push_back(i);
}
}
cout << bit << ": {";
for (int i = 0; i < (int)S.size(); ++i) {
cout << S[i] << " ";
}
cout << "}" << endl;
}
}
*/
// next_permutation（順列列挙）
/*https://note.com/memenekokaburi/n/nf0201d6002cd
ABC_150_Cなど。
int main() {
int n;
cin >> n ;
vector<int>array = {};
for(int i=0;i<n;i++){
array.push_back(i);
}
do{
for(int i=0; i<n; i++){
cout << array.at(i);
if(i!=n-1)cout<<" ";
}
cout<<endl;
}while(next_permutation(array.begin(),array.end()));
return 0;
}
*/
// ABC126_Cのように関数でdouble型で返ってきてほしい場合はdouble
// kan_halfのようにかく
/*
//ABC_041_C// pair型
int main() {
int n;
cin >> n;
vector<pair<int,int>>a(n);
for(int i=0;i<n;i++){
int num;
cin >> num;
a.at(i).first = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
reverse(a.begin(),a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second + 1<< endl;
}
}
*/
/*ABC_068_C //boolの配列を使って
bool s[200050] = {};
bool t[200050] = {};
int main() {
ll n, m; cin >> n >> m;
for (int i = 0; i < m; i++){
ll a, b; cin >> a >> b;
if (a == 1) {
t[b] = true;
}
if (b == n) {
s[a] = true;
}
}
for (int i = 0; i < 200050; i++){
if (s[i] && t[i]) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
return 0;
}
*/
// int32 4 signed, signed int, int -2,147,483,648 ～ 2,147,483,647 =
// 2*10^9 再帰関数 ABC_029_C
/*
void f(int rest , string s){
if(rest == 0){
cout << s << endl;
}
else{
for(char moji = 'a' ;moji <='c' ; moji++){
f(rest-1,s+moji);
}
}
}
int main() {
int n;
cin >> n;
f(n, "");
}
*/
//連想配列 ARC_081_Cの解答 //ABC073でも復習できます。
/*
int main() {
ll n;
cin >> n;
vector<ll>a(n);
rep(i,n) cin>>a.at(i);
map<ll,ll>mp;
rep(i,n){
mp[a.at(i)]++;
}
ll one = 0;
ll two = 0;
for(auto p:mp){
// cout << p.first << " " << p.second << endl;
if(p.second >= 2){
if(one <= p.first){
two = one;
one = p.first;
}
}
if(p.second >= 4){
if(one <= p.first){
two = p.first;
one = p.first;
}
}
}
// cout << one << endl;
// cout << two << endl;
// cout << endl;
cout << one * two << endl;
}
*/
//#define pi 3.14159265359
//桁数を指定して出力する方法
//#include <iomanip>//これをincludeしておかないといけない
// cout << fixed << setprecision(20)<< ans << endl;
// s.at(0) = toupper(s.at(0));//小文字なら大文字へ//大文字の場合はそのまま
// s.at(i) = tolower(s.at(i));//大文字なら小文字へ//小文字の場合はそのまま
// getline(cin, s); //空白文字を含むものをまとめて入力できる。
// s配列に格納した単語を、辞書順にソートする
// sort(s.begin(), s.end());
// string t = "keyence";//で文字列を格納できる
// s.empty() //emptyなら1を出力 入っていれば0を出力
/*//ABC018-B 部分的にreverseをかける解法
int main() {
string s; cin >> s;
int n; cin >> n;
vector<int>a(n); vector<int>b(n);
rep(i,n) cin>>a.at(i)>>b.at(i);
rep(i,n)a.at(i)--; rep(i,n)b.at(i)--;
string t;
rep(i,n){
t = s;
for(int k=0;k<=b.at(i)-a.at(i);k++){
t.at(a.at(i)+k) = s.at(b.at(i)-k);
}
s = t;
}
cout << s << endl;
}
*///ABC018-B
// cout << char(i+48) <<
// endl;//なぜかaは47と得る時がある。+48で出力もaにできる。 cout << char(97) <<
// endl;//アスキーコードでaを出力
// sort(b.begin(), b.end());//bという配列を小さい方からソート
// reverse(b.begin(), b.end());//bという配列をリターン
/*01 02 03 12 13 23 と６回見ていくパターン
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
}
}
*/
// vector<vector<int>> a(3, vector<int>(4));//int型の2次元配列(3×4要素の)の宣言
// 10のi乗pow(10, i);//ただしdouble型のため注意
/*string s; stringでの文字列を数字型に変える方法
cin >> s;
rep(i,s.size()-2) {
int a= (s.at(i)-'0')*100 + (s.at(i+1)-'0')*10+ s.at(i+2) -'0';
*/
#include <bits/stdc++.h>
#include <iomanip> //これをincludeしておかないといけない
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265359
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 * b / gcd(a, b);
return a / gcd(a, b) * b;
}
int kan_hyaku(int n) {
int kurai = 0;
for (int i = 0; i < 3; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ju(int n) {
int kurai = 0;
for (int i = 0; i < 2; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ichi(int n) {
int kurai = 0;
for (int i = 0; i < 1; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int keta(int n) {
int wa = 1;
while (n > 0) {
wa *= 10;
n--;
}
return wa;
}
double kan_half(int n) {
double wa = 1;
while (n > 0) {
// cout << "TEST"<<endl;
wa *= 0.5;
// cout << wa << endl;
n--;
}
return wa;
}
ll facctorialMethod(ll k) {
ll sum = 1;
for (ll i = 1; i <= k; ++i) {
sum = sum % 1000000007 * i % 1000000007;
}
return sum;
}
int zorocheck(string s) {
int count = 0;
rep(i, s.size()) {
if (s.at(i) == s.at(0))
count++;
}
if (count == s.size()) {
return 1;
} else {
return 0;
}
}
/*
int n;
cin >> n;
vector<int>a(n);
rep(i,n) cin >> a.at(i);
*/
// cout << fixed << setprecision(10)<< ans << endl;
//数字から文字列に変換 a.at(0) = std::to_string(111);
bool red[100010] = {};
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a.at(i);
int first = 0;
rep(i, n) first = max(first, a.at(i));
int first_count = 0;
rep(i, n) if (first == a.at(i)) first_count++;
// cout << first_count << endl;
if (first_count >= 2) {
rep(i, n) cout << first_count << endl;
return 0;
} else {
int second = 0;
rep(i, n) {
if (a.at(i) != first) {
second = max(second, a.at(i));
}
}
rep(i, n) {
if (a.at(i) == first) {
cout << second << endl;
} else {
cout << first << endl;
}
}
}
} | // ABC_128_B// pair型の中にpair型
/*int main() {
int n;
cin >> n;
vector<pair<pair<string,int>,int>> a(n);
for(int i=0;i<n;i++){
string s;
cin >> s;
int num;
cin >> num;
num = num * -1;
a.at(i).first.first = s;
a.at(i).first.second = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second +1 << endl;
}
}
*/
// ABC_058_Cのように
// s.at(j) == a のとき
// cout << s.at(j)-'0' - 49 << endl;
//とすると、「0」を出力してくれる。 →もっといいほかの方法はないの？
//全bit探索を入れよう!!
/*ABC_167_C skill up などを参考に…
//https://qiita.com/hareku/items/3d08511eab56a481c7db
int main() {
int n = 3;
// {0, 1, ..., n-1} の部分集合の全探索
for (int bit = 0; bit < (1<<n); ++bit) {
vector<int> S;
for (int i = 0; i < n; ++i) {
if (bit & (1<<i)) { // 列挙に i が含まれるか
S.push_back(i);
}
}
cout << bit << ": {";
for (int i = 0; i < (int)S.size(); ++i) {
cout << S[i] << " ";
}
cout << "}" << endl;
}
}
*/
// next_permutation（順列列挙）
/*https://note.com/memenekokaburi/n/nf0201d6002cd
ABC_150_Cなど。
int main() {
int n;
cin >> n ;
vector<int>array = {};
for(int i=0;i<n;i++){
array.push_back(i);
}
do{
for(int i=0; i<n; i++){
cout << array.at(i);
if(i!=n-1)cout<<" ";
}
cout<<endl;
}while(next_permutation(array.begin(),array.end()));
return 0;
}
*/
// ABC126_Cのように関数でdouble型で返ってきてほしい場合はdouble
// kan_halfのようにかく
/*
//ABC_041_C// pair型
int main() {
int n;
cin >> n;
vector<pair<int,int>>a(n);
for(int i=0;i<n;i++){
int num;
cin >> num;
a.at(i).first = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
reverse(a.begin(),a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second + 1<< endl;
}
}
*/
/*ABC_068_C //boolの配列を使って
bool s[200050] = {};
bool t[200050] = {};
int main() {
ll n, m; cin >> n >> m;
for (int i = 0; i < m; i++){
ll a, b; cin >> a >> b;
if (a == 1) {
t[b] = true;
}
if (b == n) {
s[a] = true;
}
}
for (int i = 0; i < 200050; i++){
if (s[i] && t[i]) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
return 0;
}
*/
// int32 4 signed, signed int, int -2,147,483,648 ～ 2,147,483,647 =
// 2*10^9 再帰関数 ABC_029_C
/*
void f(int rest , string s){
if(rest == 0){
cout << s << endl;
}
else{
for(char moji = 'a' ;moji <='c' ; moji++){
f(rest-1,s+moji);
}
}
}
int main() {
int n;
cin >> n;
f(n, "");
}
*/
//連想配列 ARC_081_Cの解答 //ABC073でも復習できます。
/*
int main() {
ll n;
cin >> n;
vector<ll>a(n);
rep(i,n) cin>>a.at(i);
map<ll,ll>mp;
rep(i,n){
mp[a.at(i)]++;
}
ll one = 0;
ll two = 0;
for(auto p:mp){
// cout << p.first << " " << p.second << endl;
if(p.second >= 2){
if(one <= p.first){
two = one;
one = p.first;
}
}
if(p.second >= 4){
if(one <= p.first){
two = p.first;
one = p.first;
}
}
}
// cout << one << endl;
// cout << two << endl;
// cout << endl;
cout << one * two << endl;
}
*/
//#define pi 3.14159265359
//桁数を指定して出力する方法
//#include <iomanip>//これをincludeしておかないといけない
// cout << fixed << setprecision(20)<< ans << endl;
// s.at(0) = toupper(s.at(0));//小文字なら大文字へ//大文字の場合はそのまま
// s.at(i) = tolower(s.at(i));//大文字なら小文字へ//小文字の場合はそのまま
// getline(cin, s); //空白文字を含むものをまとめて入力できる。
// s配列に格納した単語を、辞書順にソートする
// sort(s.begin(), s.end());
// string t = "keyence";//で文字列を格納できる
// s.empty() //emptyなら1を出力 入っていれば0を出力
/*//ABC018-B 部分的にreverseをかける解法
int main() {
string s; cin >> s;
int n; cin >> n;
vector<int>a(n); vector<int>b(n);
rep(i,n) cin>>a.at(i)>>b.at(i);
rep(i,n)a.at(i)--; rep(i,n)b.at(i)--;
string t;
rep(i,n){
t = s;
for(int k=0;k<=b.at(i)-a.at(i);k++){
t.at(a.at(i)+k) = s.at(b.at(i)-k);
}
s = t;
}
cout << s << endl;
}
*///ABC018-B
// cout << char(i+48) <<
// endl;//なぜかaは47と得る時がある。+48で出力もaにできる。 cout << char(97) <<
// endl;//アスキーコードでaを出力
// sort(b.begin(), b.end());//bという配列を小さい方からソート
// reverse(b.begin(), b.end());//bという配列をリターン
/*01 02 03 12 13 23 と６回見ていくパターン
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
}
}
*/
// vector<vector<int>> a(3, vector<int>(4));//int型の2次元配列(3×4要素の)の宣言
// 10のi乗pow(10, i);//ただしdouble型のため注意
/*string s; stringでの文字列を数字型に変える方法
cin >> s;
rep(i,s.size()-2) {
int a= (s.at(i)-'0')*100 + (s.at(i+1)-'0')*10+ s.at(i+2) -'0';
*/
#include <bits/stdc++.h>
#include <iomanip> //これをincludeしておかないといけない
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265359
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 * b / gcd(a, b);
return a / gcd(a, b) * b;
}
int kan_hyaku(int n) {
int kurai = 0;
for (int i = 0; i < 3; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ju(int n) {
int kurai = 0;
for (int i = 0; i < 2; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ichi(int n) {
int kurai = 0;
for (int i = 0; i < 1; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int keta(int n) {
int wa = 1;
while (n > 0) {
wa *= 10;
n--;
}
return wa;
}
double kan_half(int n) {
double wa = 1;
while (n > 0) {
// cout << "TEST"<<endl;
wa *= 0.5;
// cout << wa << endl;
n--;
}
return wa;
}
ll facctorialMethod(ll k) {
ll sum = 1;
for (ll i = 1; i <= k; ++i) {
sum = sum % 1000000007 * i % 1000000007;
}
return sum;
}
int zorocheck(string s) {
int count = 0;
rep(i, s.size()) {
if (s.at(i) == s.at(0))
count++;
}
if (count == s.size()) {
return 1;
} else {
return 0;
}
}
/*
int n;
cin >> n;
vector<int>a(n);
rep(i,n) cin >> a.at(i);
*/
// cout << fixed << setprecision(10)<< ans << endl;
//数字から文字列に変換 a.at(0) = std::to_string(111);
bool red[100010] = {};
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a.at(i);
int first = 0;
rep(i, n) first = max(first, a.at(i));
int first_count = 0;
rep(i, n) if (first == a.at(i)) first_count++;
// cout << first_count << endl;
if (first_count >= 2) {
rep(i, n) cout << first << endl;
return 0;
} else {
int second = 0;
rep(i, n) {
if (a.at(i) != first) {
second = max(second, a.at(i));
}
}
rep(i, n) {
if (a.at(i) == first) {
cout << second << endl;
} else {
cout << first << endl;
}
}
}
} | [
"identifier.change",
"expression.operation.binary.change"
] | 775,300 | 775,301 | u037563046 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 100000000;
#define rep1(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, k, n) for (ll i = k; i < (n); i++)
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;
}
int main() {
ll n;
cin >> n;
vector<ll> a(n, 0), b(n, 0);
rep1(i, n) {
cin >> a[i];
b[i] = a[i];
}
sort(b.begin(), b.end(), greater<ll>());
rep1(i, n) {
if (a[i] == b[0])
cout << b[i] << endl;
else
cout << b[0] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 100000000;
#define rep1(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, k, n) for (ll i = k; i < (n); i++)
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;
}
int main() {
ll n;
cin >> n;
vector<ll> a(n, 0), b(n, 0);
rep1(i, n) {
cin >> a[i];
b[i] = a[i];
}
sort(b.begin(), b.end(), greater<ll>());
rep1(i, n) {
if (a[i] == b[0])
cout << b[1] << endl;
else
cout << b[0] << endl;
}
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,306 | 775,307 | u913016812 | cpp |
p02971 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#define MAX_N 200'000
using namespace std;
int A[MAX_N];
int main() {
int N;
cin >> N;
int x, y;
cin >> x >> y;
A[0] = x;
A[1] = y;
if (x < y) {
swap(x, y);
}
for (int i = 2; i < N; ++i) {
cin >> A[i];
if (x <= A[i]) {
y = x;
x = A[i];
} else if (y < A[i]) {
y = A[i];
}
}
if (x == y) {
for (int i = 0; i < N; ++i) {
printf("%d\n", A[i]);
}
} else {
for (int i = 0; i < N; ++i) {
if (A[i] == x) {
printf("%d\n", y);
} else {
printf("%d\n", x);
}
}
}
} | #include <algorithm>
#include <iostream>
#include <stdio.h>
#define MAX_N 200'000
using namespace std;
int A[MAX_N];
int main() {
int N;
cin >> N;
int x, y;
cin >> x >> y;
A[0] = x;
A[1] = y;
if (x < y) {
swap(x, y);
}
for (int i = 2; i < N; ++i) {
cin >> A[i];
if (x <= A[i]) {
y = x;
x = A[i];
} else if (y < A[i]) {
y = A[i];
}
}
if (x == y) {
for (int i = 0; i < N; ++i) {
printf("%d\n", x);
}
} else {
for (int i = 0; i < N; ++i) {
if (A[i] == x) {
printf("%d\n", y);
} else {
printf("%d\n", x);
}
}
}
} | [
"call.arguments.change",
"io.output.change"
] | 775,316 | 775,317 | u763280125 | cpp |
p02971 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main(int argc, char const *argv[]) {
int N;
cin >> N;
vector<int> A, B;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
B = A;
sort(A.begin(), A.end(), comp);
int max = A[0];
int ans;
for (int n : B) {
if (n < max) {
ans = max;
} else {
ans = A[1];
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main(int argc, char const *argv[]) {
int N;
cin >> N;
vector<int> A, B;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
B = A;
sort(A.begin(), A.end(), comp);
int max = A[0];
int ans;
for (int n : B) {
if (n < max) {
ans = max;
} else {
ans = A[1];
}
cout << ans << endl;
}
return 0;
} | [] | 775,323 | 775,324 | u912952979 | cpp |
p02971 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main(int argc, char const *argv[]) {
int N;
cin >> N;
int tmp;
vector<int> A;
vector<int> B;
for (int i = 0; i < N; i++) {
cin >> tmp;
A.emplace_back(tmp);
}
B = A;
sort(A.begin(), A.end(), comp);
int max = A[0];
int ans;
for (int n : B) {
if (n < max) {
ans = max;
} else {
ans = A[1];
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main(int argc, char const *argv[]) {
int N;
cin >> N;
int tmp;
vector<int> A;
vector<int> B;
for (int i = 0; i < N; i++) {
cin >> tmp;
A.emplace_back(tmp);
}
B = A;
sort(A.begin(), A.end(), comp);
int max = A[0];
int ans;
for (int n : B) {
if (n < max) {
ans = max;
} else {
ans = A[1];
}
cout << ans << endl;
}
return 0;
} | [] | 775,325 | 775,326 | u912952979 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
int inf = 100000000;
int main() {
int n;
cin >> n;
vector<P> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i].first;
vec[i].second = i;
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
for (int i = 0; i < n; i++) {
if (i == vec[i].second)
cout << vec[1].first << endl;
else
cout << vec[0].first << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
int inf = 100000000;
int main() {
int n;
cin >> n;
vector<P> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i].first;
vec[i].second = i;
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
for (int i = 0; i < n; i++) {
if (i == vec[0].second)
cout << vec[1].first << endl;
else
cout << vec[0].first << endl;
}
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 775,327 | 775,328 | u529089914 | cpp |
p02971 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
int INF = 100100101;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
rep(i, n) {
cin >> a[i];
b[i] = a[i];
}
sort(a.begin(), a.end());
rep(i, n) {
if (a[n - 1] != b[i])
cout << a[n - 1] << endl;
else if (a[n - 2] != b[i])
cout << a[n - 2] << endl;
else
cout << a[i] << endl;
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
int INF = 100100101;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
rep(i, n) {
cin >> a[i];
b[i] = a[i];
}
sort(a.begin(), a.end());
rep(i, n) {
if (a[n - 1] != b[i])
cout << a[n - 1] << endl;
else if (a[n - 2] != b[i])
cout << a[n - 2] << endl;
else
cout << b[i] << endl;
}
} | [
"identifier.change",
"io.output.change"
] | 775,333 | 775,334 | u415671616 | cpp |
p02971 | #include <algorithm>
#include <bitset>
#include <cstring>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <deque>
#define pi 3.1415926535
#include <chrono>
#define MOD 1000000007
#define INF 999999999999999999
#define pb push_back
#define ff first
#define ss second
#define mt make_tuple
#define ll long long
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define f0 get<0>
#define f1 get<1>
#define f2 get<2>
using namespace std;
ll n;
ll ncr(ll n, ll r) {
ll i, ans = 1, k = 0;
if (r == 0)
return 1;
else if (n < r)
return 0;
for (i = n; i >= n - r + 1; i--) {
ans *= i;
ans /= n - i + 1;
}
return ans;
}
void max_heapify(int a[100], int i) {
int l, r, largest = i;
l = 2 * i + 1;
r = 2 * i + 2;
if (l < n && a[l] > a[i])
largest = l;
if (r < n && a[r] > a[l])
largest = r;
if (largest != i) {
int k;
k = a[i];
a[i] = a[largest];
a[largest] = k;
max_heapify(a, largest);
}
}
int power(ll x, ll y, ll p) {
int res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool square(ll n) {
double x;
x = sqrt(n);
if (x == floor(x))
return true;
else
return false;
}
bool prime(ll n) {
ll i;
for (i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
ll modi(ll a, ll m) { return power(a, m - 2, m); }
void kmp(string s, ll p[]) {
int n = (int)s.length();
p[0] = 0;
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j])
j = p[j - 1];
if (s[i] == s[j])
j++;
p[i] = j;
}
}
void zfunc(string s, ll z[]) {
ll n = (ll)s.length();
z[0] = 0;
for (ll i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r)
z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]])
++z[i];
if (i + z[i] - 1 > r)
l = i, r = i + z[i] - 1;
}
}
struct pair_hash {
size_t operator()(const pair<int, int> &p) const noexcept {
return hash<ll>()((((ll)p.first) << 32) | ((ll)p.second));
}
};
bool palin(string s) {
ll i, n;
n = s.length();
for (i = 0; i <= n / 2; i++) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
ll sum(ll n) {
ll i;
i = n;
ll sum = 0;
while (i > 0) {
sum += i % 10;
i = i / 10;
}
return sum;
}
ll nCr(ll n, ll r, ll p, ll fac[]) {
if (r == 0)
return 1;
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % p;
return (fac[n] * modi(fac[r], p) % p * modi(fac[n - r], p) % p) % p;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll mod(string num, ll a) {
ll res = 0;
for (ll i = 0; i < num.length(); i++)
res = (res * 10 + (ll)num[i] - '0') % a;
return res;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ll parent[1000], sizer[1000];
ll findset(ll a) {
if (a == parent[a]) {
return a;
}
parent[a] = findset(parent[a]);
return parent[a];
}
void unionset(ll a, ll b) {
a = findset(a);
b = findset(b);
if (sizer[a] < sizer[b]) {
swap(a, b);
}
sizer[b] += sizer[a];
parent[b] = a;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
fast;
ll T = 1, i, j;
// cin >> T;
while (T--) {
ll n;
cin >> n;
vector<ll> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
}
vector<ll> suff(n + 1);
for (i = n - 1; i >= 1; i--) {
suff[i] = max(suff[i], v[i]);
}
suff[n] = -INF;
ll leftmax = -INF;
for (i = 0; i < n; i++) {
cout << max(leftmax, suff[i + 1]) << endl;
leftmax = max(leftmax, v[i]);
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cstring>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <deque>
#define pi 3.1415926535
#include <chrono>
#define MOD 1000000007
#define INF 999999999999999999
#define pb push_back
#define ff first
#define ss second
#define mt make_tuple
#define ll long long
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define f0 get<0>
#define f1 get<1>
#define f2 get<2>
using namespace std;
ll n;
ll ncr(ll n, ll r) {
ll i, ans = 1, k = 0;
if (r == 0)
return 1;
else if (n < r)
return 0;
for (i = n; i >= n - r + 1; i--) {
ans *= i;
ans /= n - i + 1;
}
return ans;
}
void max_heapify(int a[100], int i) {
int l, r, largest = i;
l = 2 * i + 1;
r = 2 * i + 2;
if (l < n && a[l] > a[i])
largest = l;
if (r < n && a[r] > a[l])
largest = r;
if (largest != i) {
int k;
k = a[i];
a[i] = a[largest];
a[largest] = k;
max_heapify(a, largest);
}
}
int power(ll x, ll y, ll p) {
int res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool square(ll n) {
double x;
x = sqrt(n);
if (x == floor(x))
return true;
else
return false;
}
bool prime(ll n) {
ll i;
for (i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
ll modi(ll a, ll m) { return power(a, m - 2, m); }
void kmp(string s, ll p[]) {
int n = (int)s.length();
p[0] = 0;
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j])
j = p[j - 1];
if (s[i] == s[j])
j++;
p[i] = j;
}
}
void zfunc(string s, ll z[]) {
ll n = (ll)s.length();
z[0] = 0;
for (ll i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r)
z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]])
++z[i];
if (i + z[i] - 1 > r)
l = i, r = i + z[i] - 1;
}
}
struct pair_hash {
size_t operator()(const pair<int, int> &p) const noexcept {
return hash<ll>()((((ll)p.first) << 32) | ((ll)p.second));
}
};
bool palin(string s) {
ll i, n;
n = s.length();
for (i = 0; i <= n / 2; i++) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
ll sum(ll n) {
ll i;
i = n;
ll sum = 0;
while (i > 0) {
sum += i % 10;
i = i / 10;
}
return sum;
}
ll nCr(ll n, ll r, ll p, ll fac[]) {
if (r == 0)
return 1;
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % p;
return (fac[n] * modi(fac[r], p) % p * modi(fac[n - r], p) % p) % p;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll mod(string num, ll a) {
ll res = 0;
for (ll i = 0; i < num.length(); i++)
res = (res * 10 + (ll)num[i] - '0') % a;
return res;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ll parent[1000], sizer[1000];
ll findset(ll a) {
if (a == parent[a]) {
return a;
}
parent[a] = findset(parent[a]);
return parent[a];
}
void unionset(ll a, ll b) {
a = findset(a);
b = findset(b);
if (sizer[a] < sizer[b]) {
swap(a, b);
}
sizer[b] += sizer[a];
parent[b] = a;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
fast;
ll T = 1, i, j;
// cin >> T;
while (T--) {
ll n;
cin >> n;
vector<ll> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
}
vector<ll> suff(n + 1);
for (i = n - 1; i >= 1; i--) {
suff[i] = max(suff[i + 1], v[i]);
}
suff[n] = -INF;
ll leftmax = -INF;
for (i = 0; i < n; i++) {
cout << max(leftmax, suff[i + 1]) << endl;
leftmax = max(leftmax, v[i]);
}
}
return 0;
}
| [
"assignment.change"
] | 775,337 | 775,338 | u734397606 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), copy(n);
int i;
for (i = 0; i < n; i++) {
cin >> a.at(i);
copy.at(i) = a.at(i);
}
sort(copy.begin(), copy.end());
reverse(copy.begin(), copy.end());
int p_1 = copy.at(0), p_2 = copy.at(1);
for (i = 0; i < n; i++) {
if (a.at(i) != p_1) {
cout << p_2 << endl;
} else {
cout << p_1 << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), copy(n);
int i;
for (i = 0; i < n; i++) {
cin >> a.at(i);
copy.at(i) = a.at(i);
}
sort(copy.begin(), copy.end());
reverse(copy.begin(), copy.end());
int p_1 = copy.at(0), p_2 = copy.at(1);
for (i = 0; i < n; i++) {
if (a.at(i) != p_1) {
cout << p_1 << endl;
} else {
cout << p_2 << endl;
}
}
}
| [
"identifier.change",
"io.output.change"
] | 775,349 | 775,350 | u130651752 | cpp |
p02971 | #include <algorithm>
#include <iostream>
using namespace std;
int n, a[200005], b[200005], o;
bool cmp(int x, int y) { return x > y; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n, cmp);
for (int i = 0; i < n; i++) {
if (a[i] <= b[0]) {
cout << b[0] << endl;
} else {
cout << b[1] << endl;
}
}
} | #include <algorithm>
#include <iostream>
using namespace std;
int n, a[200005], b[200005], o;
bool cmp(int x, int y) { return x > y; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n, cmp);
for (int i = 0; i < n; i++) {
if (a[i] < b[0]) {
cout << b[0] << endl;
} else {
cout << b[1] << endl;
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 775,351 | 775,352 | u816631826 | cpp |
p02971 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <ctype.h>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define pint pair<int, int>
#define SEG_LEN (1 << 18)
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
ll ceil(const ll a, const ll b) { return (a + b - 1) / b; }
class segment_tree_Sum {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Sum() { seg.resize(seg_size); }
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = seg[ind * 2] + seg[ind * 2 + 1];
}
}
long long Sum(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = 0;
while (l < r) {
if (l % 2 == 1) {
ans += seg[l];
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans += seg[r - 1];
r--;
}
r /= 2;
}
return ans;
}
};
class segment_tree_Min {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Min() {
seg.resize(seg_size);
for (int i = 0; i < seg_size; i++)
seg[i] = INF;
}
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = min(seg[ind * 2], seg[ind * 2 + 1]);
}
}
long long Min(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = INF;
while (l < r) {
if (l % 2 == 1) {
ans = min(seg[l], ans);
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans = min(seg[r - 1], ans);
r--;
}
r /= 2;
}
return ans;
}
};
class segment_tree_Max {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Max() {
seg.resize(seg_size);
for (int i = 0; i < seg_size; i++)
seg[i] = -INF;
}
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = max(seg[ind * 2], seg[ind * 2 + 1]);
}
}
long long Max(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = -INF;
while (l < r) {
if (l % 2 == 1) {
ans = max(seg[l], ans);
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans = max(seg[r - 1], ans);
r--;
}
r /= 2;
}
return ans;
}
};
int main() {
int n;
cin >> n;
segment_tree_Max seg;
rep(i, n) {
int tmp;
cin >> tmp;
seg.update(i, tmp);
}
rep(i, n) {
if (i == 0) {
cout << seg.Max(1, n - 1) << endl;
}
if (i == n - 1) {
cout << seg.Max(0, n - 2) << endl;
}
cout << max(seg.Max(0, i - 1), seg.Max(i + 1, n - 1)) << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <ctype.h>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define pint pair<int, int>
#define SEG_LEN (1 << 18)
const int INF = 1000000007;
const long double EPS = 1e-15;
const long double PI = acos(-1);
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
using Graph_weighted = vector<vector<pair<int, int>>>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
ll ceil(const ll a, const ll b) { return (a + b - 1) / b; }
class segment_tree_Sum {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Sum() { seg.resize(seg_size); }
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = seg[ind * 2] + seg[ind * 2 + 1];
}
}
long long Sum(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = 0;
while (l < r) {
if (l % 2 == 1) {
ans += seg[l];
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans += seg[r - 1];
r--;
}
r /= 2;
}
return ans;
}
};
class segment_tree_Min {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Min() {
seg.resize(seg_size);
for (int i = 0; i < seg_size; i++)
seg[i] = INF;
}
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = min(seg[ind * 2], seg[ind * 2 + 1]);
}
}
long long Min(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = INF;
while (l < r) {
if (l % 2 == 1) {
ans = min(seg[l], ans);
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans = min(seg[r - 1], ans);
r--;
}
r /= 2;
}
return ans;
}
};
class segment_tree_Max {
private:
vector<long long> seg;
int seg_size = SEG_LEN * 2;
public:
segment_tree_Max() {
seg.resize(seg_size);
for (int i = 0; i < seg_size; i++)
seg[i] = -INF;
}
void update(int ind, int n) {
ind += SEG_LEN;
seg[ind] = n;
while (true) {
ind /= 2;
if (ind == 0)
break;
seg[ind] = max(seg[ind * 2], seg[ind * 2 + 1]);
}
}
long long Max(int l, int r) {
l += SEG_LEN;
r += SEG_LEN + 1;
long long ans = -INF;
while (l < r) {
if (l % 2 == 1) {
ans = max(seg[l], ans);
l++;
}
if (l >= r)
break;
l /= 2;
if (r % 2 == 1) {
ans = max(seg[r - 1], ans);
r--;
}
r /= 2;
}
return ans;
}
};
int main() {
int n;
cin >> n;
segment_tree_Max seg;
rep(i, n) {
int tmp;
cin >> tmp;
seg.update(i, tmp);
}
rep(i, n) {
if (i == 0) {
cout << seg.Max(1, n - 1) << endl;
} else if (i == n - 1) {
cout << seg.Max(0, n - 2) << endl;
} else
cout << max(seg.Max(0, i - 1), seg.Max(i + 1, n - 1)) << endl;
}
return 0;
}
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 775,353 | 775,354 | u820341516 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> A(N);
int max = -100;
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (max < A[i]) {
max = A[i];
}
}
for (int i = 0; i < N; i++) {
if (max == A[i])
sum++;
}
int max2 = -100;
for (int i = 0; i < N; i++) {
if (A[i] <= max && max2 < A[i])
max2 = A[i];
}
for (int i = 0; i < N; i++) {
if (max == A[i] && sum == 1) {
cout << max2 << endl;
} else if (max == A[i] && sum > 1) {
cout << max << endl;
} else
cout << max << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> A(N);
int max = -100;
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (max < A[i]) {
max = A[i];
}
}
for (int i = 0; i < N; i++) {
if (max == A[i])
sum++;
}
int max2 = -100;
for (int i = 0; i < N; i++) {
if (A[i] < max && max2 < A[i])
max2 = A[i];
}
for (int i = 0; i < N; i++) {
if (max == A[i] && sum == 1) {
cout << max2 << endl;
} else if (max == A[i] && sum > 1) {
cout << max << endl;
} else
cout << max << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 775,355 | 775,356 | u109191542 | cpp |
p02971 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> a;
bool comp(int i, int j) { return a[i] > a[j]; }
int main(int argc, char *argv[]) {
int N;
cin >> N;
a.reserve(N);
vector<int> indices(N);
for (int i = 0; i < N; ++i) {
int tmp;
cin >> tmp;
a.push_back(tmp);
indices[i] = i;
}
sort(indices.begin(), indices.end(), comp);
for (int i = 0; i < N; ++i) {
if (i != indices[0]) {
cout << a[indices[1]] << endl;
} else {
cout << a[indices[0]] << endl;
}
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> a;
bool comp(int i, int j) { return a[i] > a[j]; }
int main(int argc, char *argv[]) {
int N;
cin >> N;
a.reserve(N);
vector<int> indices(N);
for (int i = 0; i < N; ++i) {
int tmp;
cin >> tmp;
a.push_back(tmp);
indices[i] = i;
}
sort(indices.begin(), indices.end(), comp);
for (int i = 0; i < N; ++i) {
if (i != indices[0]) {
cout << a[indices[0]] << endl;
} else {
cout << a[indices[1]] << endl;
}
}
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,383 | 775,384 | u894471318 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1000000007;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
ll b[n];
for (ll i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
bool flag = false;
if (a[n - 1] == a[n - 2])
flag = true;
ll maxi = 0;
for (ll i = 0; i < n; i++) {
maxi = max(maxi, a[i]);
}
for (ll i = 0; i < n; i++) {
if (a[i] == maxi) {
if (flag)
cout << b[n - 1] << endl;
else
cout << b[n - 2] << endl;
} else
cout << b[n - 1] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1000000007;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
ll b[n];
for (ll i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
bool flag = false;
if (b[n - 1] == b[n - 2])
flag = true;
ll maxi = 0;
for (ll i = 0; i < n; i++) {
maxi = max(maxi, a[i]);
}
for (ll i = 0; i < n; i++) {
if (a[i] == maxi) {
if (flag)
cout << b[n - 1] << endl;
else
cout << b[n - 2] << endl;
} else
cout << b[n - 1] << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 775,407 | 775,408 | u371051907 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep_op(i, a, n) for (int i = a; i < n; i++)
#define rep_d(j, n) for (int j = n; j >= 0; j--)
#define rep_d_op(j, n, a) for (int j = n; j >= a; j--)
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;
}
const int MOD = 1000000007;
const vector<int> dx = {1, 0};
const vector<int> dy = {0, 1};
const ll INF = 1LL << 60;
// int max = *std::max_element(vec.begin(), vec.end());
// int sum = accumulate(list, list + size, 0);
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
using Graph = vector<vector<int>>;
Graph G;
vector<bool> seen;
void dfs(const Graph &G, int v) {
seen[v] = true;
for (auto next_v : G[v]) {
if (seen[next_v])
continue;
dfs(G, next_v);
}
}
int main() {
ll n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> left_max(n);
vector<int> right_max(n);
for (int i = 1; i < n; i++) {
left_max[i] = max(left_max[i - 1], a[i - 1]);
}
for (int i = n - 2; i >= 0; i--) {
right_max[i] = max(left_max[i + 1], right_max[i + 1]);
}
rep(i, n) { cout << max(left_max[i], right_max[i]) << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep_op(i, a, n) for (int i = a; i < n; i++)
#define rep_d(j, n) for (int j = n; j >= 0; j--)
#define rep_d_op(j, n, a) for (int j = n; j >= a; j--)
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;
}
const int MOD = 1000000007;
const vector<int> dx = {1, 0};
const vector<int> dy = {0, 1};
const ll INF = 1LL << 60;
// int max = *std::max_element(vec.begin(), vec.end());
// int sum = accumulate(list, list + size, 0);
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
using Graph = vector<vector<int>>;
Graph G;
vector<bool> seen;
void dfs(const Graph &G, int v) {
seen[v] = true;
for (auto next_v : G[v]) {
if (seen[next_v])
continue;
dfs(G, next_v);
}
}
int main() {
ll n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> left_max(n);
vector<int> right_max(n);
for (int i = 1; i < n; i++) {
left_max[i] = max(left_max[i - 1], a[i - 1]);
}
for (int i = n - 2; i >= 0; i--) {
right_max[i] = max(right_max[i + 1], a[i + 1]);
}
rep(i, n) { cout << max(left_max[i], right_max[i]) << endl; }
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 775,409 | 775,410 | u496074393 | cpp |
p02971 | // url:
// problem name:
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Pl = pair<long, long>;
using veci = vector<int>;
using vecl = vector<long>;
using vecveci = vector<vector<int>>;
using vecvecl = vector<vector<long, long>>;
int main() {
int N;
cin >> N;
vector<P> A(N);
REP(i, N) {
int a;
cin >> a;
A.at(i).first = a;
A.at(i).second = i;
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
REP(i, N) {
if (A.at(0).second == i)
cout << A.at(0).first << endl;
else
cout << A.at(1).first << endl;
}
}
| // url:
// problem name:
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Pl = pair<long, long>;
using veci = vector<int>;
using vecl = vector<long>;
using vecveci = vector<vector<int>>;
using vecvecl = vector<vector<long, long>>;
int main() {
int N;
cin >> N;
vector<P> A(N);
REP(i, N) {
int a;
cin >> a;
A.at(i).first = a;
A.at(i).second = i;
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
REP(i, N) {
if (A.at(0).second != i)
cout << A.at(0).first << endl;
else
cout << A.at(1).first << endl;
}
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 775,438 | 775,439 | u446371873 | cpp |
p02971 | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int A1[N + 2], A2[N + 2];
fill(A1, A1 + N + 2, 0);
fill(A2, A2 + N + 2, 0);
for (int i = 1; i <= N; i++) {
cin >> A1[i];
A2[i] = A1[i];
}
for (int i = 1, j = N; i <= N; i++, j--) {
A1[i] = max(A1[i], A1[i - 1]);
A2[j] = max(A1[j], A2[j + 1]);
}
for (int i = 1; i <= N; i++) {
cout << max(A1[i - 1], A2[i + 1]) << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int A1[N + 2], A2[N + 2];
fill(A1, A1 + N + 2, 0);
fill(A2, A2 + N + 2, 0);
for (int i = 1; i <= N; i++) {
cin >> A1[i];
A2[i] = A1[i];
}
for (int i = 1, j = N; i <= N; i++, j--) {
A1[i] = max(A1[i], A1[i - 1]);
A2[j] = max(A2[j], A2[j + 1]);
}
for (int i = 1; i <= N; i++) {
cout << max(A1[i - 1], A2[i + 1]) << endl;
}
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 775,447 | 775,448 | u131000248 | cpp |
p02971 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<int> A(N);
vector<int> B(N);
rep(i, N) {
cin >> A[i];
B[i] = A[i];
}
sort(B.begin(), B.begin());
rep(i, N) {
if (A[i] != B[N - 1]) {
cout << B[N - 1] << endl;
}
else {
cout << B[N - 2] << endl;
}
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<int> A(N);
vector<int> B(N);
rep(i, N) {
cin >> A[i];
B[i] = A[i];
}
sort(B.begin(), B.end());
rep(i, N) {
if (A[i] != B[N - 1]) {
cout << B[N - 1] << endl;
}
else {
cout << B[N - 2] << endl;
}
}
} | [
"call.function.change",
"call.arguments.change"
] | 775,451 | 775,452 | u454081619 | cpp |
p02971 | #pragma region
#include <bits/stdc++.h>
using namespace std;
inline void ci(void) { return; }
template <typename First, typename... Rest>
void ci(First &first, Rest &...rest) {
cin >> first;
ci(rest...);
return;
}
inline void co(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest> void co(First first, Rest... rest) {
cout << first << " ";
co(rest...);
return;
}
#define ll long long
#define ld long double
#define st string
#define dl double
#define wh while
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define tp tuple
#define ft first
#define sc second
#define ve vector
#define tos to_string
#define len length
#define rt return 0
#define gcd __gcd
#define lcm(n, m) n *m / gcd(n, m)
#define np next_permutation
#define repi(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) repi(i, 0, n)
#define sz(v) ((int)(v).size())
#define each(i, n) for (auto &&i : n)
#define so(n) sort(n.begin(), n.end())
#define rev(n) reverse(n.begin(), n.end())
#define sp(n) cout << fixed << setprecision(n)
#pragma endregion
// sqrt ルート, int 2*10^9, gcd 最大公約数
int main() {
int N;
ci(N);
ve<int> A(N), B(N);
rep(i, N) {
ci(A.at(i));
B.at(i) = A.at(i);
}
so(B);
rep(i, N) {
int a = 0;
if (B.at(N - 1) == A.at(i)) {
a = B.at(N);
} else {
a = B.at(N - 1);
}
co(a);
}
} | #pragma region
#include <bits/stdc++.h>
using namespace std;
inline void ci(void) { return; }
template <typename First, typename... Rest>
void ci(First &first, Rest &...rest) {
cin >> first;
ci(rest...);
return;
}
inline void co(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest> void co(First first, Rest... rest) {
cout << first << " ";
co(rest...);
return;
}
#define ll long long
#define ld long double
#define st string
#define dl double
#define wh while
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define tp tuple
#define ft first
#define sc second
#define ve vector
#define tos to_string
#define len length
#define rt return 0
#define gcd __gcd
#define lcm(n, m) n *m / gcd(n, m)
#define np next_permutation
#define repi(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) repi(i, 0, n)
#define sz(v) ((int)(v).size())
#define each(i, n) for (auto &&i : n)
#define so(n) sort(n.begin(), n.end())
#define rev(n) reverse(n.begin(), n.end())
#define sp(n) cout << fixed << setprecision(n)
#pragma endregion
// sqrt ルート, int 2*10^9, gcd 最大公約数
int main() {
int N;
ci(N);
ve<int> A(N), B(N);
rep(i, N) {
ci(A.at(i));
B.at(i) = A.at(i);
}
so(B);
rep(i, N) {
int a = 0;
if (B.at(N - 1) == A.at(i)) {
a = B.at(N - 2);
} else {
a = B.at(N - 1);
}
co(a);
}
} | [
"assignment.change"
] | 775,453 | 775,454 | u449573758 | cpp |
p02971 | #include <bits/stdc++.h>
#define lint long long int
using namespace std;
lint num_1 = 0;
lint num_2 = 0;
void max_dp(vector<lint> v, int n) {
vector<lint> dp(n + 1);
vector<lint> dp_2(n + 1);
dp[1] = v[0];
for (int i = 2; i <= n; ++i) {
dp[i] = max(dp[i - 1], v[i - 1]);
}
num_1 = dp[n];
for (int i = 0; i < n; ++i) {
if (num_1 == v[i]) {
v[i] = 0;
continue;
}
}
dp_2[1] = v[0];
for (int i = 2; i <= n; ++i) {
dp_2[i] = max(dp_2[i - 1], v[i - 1]);
}
num_2 = dp_2[n];
}
int main() {
lint n = 0;
cin >> n;
vector<lint> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
max_dp(v, n);
for (int i = 0; i < n; ++i) {
if (num_1 == v[i]) {
cout << num_2 << endl;
} else {
cout << num_1 << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
#define lint long long int
using namespace std;
lint num_1 = 0;
lint num_2 = 0;
void max_dp(vector<lint> v, int n) {
vector<lint> dp(n + 1);
vector<lint> dp_2(n + 1);
dp[1] = v[0];
for (int i = 2; i <= n; ++i) {
dp[i] = max(dp[i - 1], v[i - 1]);
}
num_1 = dp[n];
for (int i = 0; i < n; ++i) {
if (num_1 == v[i]) {
v[i] = 0;
break;
}
}
dp_2[1] = v[0];
for (int i = 2; i <= n; ++i) {
dp_2[i] = max(dp_2[i - 1], v[i - 1]);
}
num_2 = dp_2[n];
}
int main() {
lint n = 0;
cin >> n;
vector<lint> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
max_dp(v, n);
for (int i = 0; i < n; ++i) {
if (num_1 == v[i]) {
cout << num_2 << endl;
} else {
cout << num_1 << endl;
}
}
return 0;
} | [
"control_flow.continue.remove",
"control_flow.break.add"
] | 775,464 | 775,465 | u363550661 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define INF 1999999999
#define MODA 1000000007
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v1(n), v2(n);
for (int i = 0; i < n; i++) {
cin >> v1[i];
}
v2 = v1;
sort(v2.begin(), v2.end());
for (int i = 0; i < n; i++) {
if (v2[i] != v1[n - 1]) {
cout << v1[n - 2] << endl;
} else {
cout << v1[n - 1] << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define INF 1999999999
#define MODA 1000000007
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v1(n), v2(n);
for (int i = 0; i < n; i++) {
cin >> v1[i];
}
v2 = v1;
sort(v1.begin(), v1.end());
for (int i = 0; i < n; i++) {
if (v2[i] != v1[n - 1]) {
cout << v1[n - 1] << endl;
} else {
cout << v1[n - 2] << endl;
}
}
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,470 | 775,471 | u856877925 | cpp |
p02971 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
signed main(void) {
int i, n, first, second;
cin >> n;
vector<int> v(n);
int a[n];
map<int, int> score;
first = 0;
second = 0;
rep(i, n) {
cin >> a[i];
v.push_back(a[i]);
score[a[i]]++;
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
first = v.at(0);
second = v.at(1);
rep(i, n) {
if (v.at(i) == first && score[first] == 1)
cout << second << endl;
else
cout << first << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
signed main(void) {
int i, n, first, second;
cin >> n;
vector<int> v(n);
int a[n];
map<int, int> score;
first = 0;
second = 0;
rep(i, n) {
cin >> a[i];
v.push_back(a[i]);
score[a[i]]++;
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
first = v.at(0);
second = v.at(1);
rep(i, n) {
if (a[i] == first && score[first] == 1)
cout << second << endl;
else
cout << first << endl;
}
return 0;
}
| [
"call.remove",
"control_flow.branch.if.condition.change"
] | 775,482 | 775,483 | u890331732 | cpp |
p02971 | #include <iostream>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
int main() {
long int n;
cin >> n;
vector<long int> a(n);
rep(i, n) cin >> a[i];
vector<long int> lm(n, 0);
vector<long int> rm(n, 0);
for (int i = 1; i < n; i++)
lm[i] = max(lm[i - 1], a[i - 1]);
for (int i = n - 1; i >= 0; i--)
rm[i] = max(rm[i + 1], a[i + 1]);
for (int i = 0; i < n; i++)
cout << max(rm[i], lm[i]) << endl;
return 0;
}
| #include <iostream>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
int main() {
long int n;
cin >> n;
vector<long int> a(n);
rep(i, n) cin >> a[i];
vector<long int> lm(n, 0);
vector<long int> rm(n, 0);
for (int i = 1; i < n; i++)
lm[i] = max(lm[i - 1], a[i - 1]);
for (int i = n - 2; i >= 0; i--)
rm[i] = max(rm[i + 1], a[i + 1]);
for (int i = 0; i < n; i++)
cout << max(rm[i], lm[i]) << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 775,486 | 775,487 | u651109406 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int n, a[200005], b[200005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], b[i] = a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
if (b[i] == a[1])
cout << a[2] << endl;
else
cout << a[1] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, a[200005], b[200005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], b[i] = a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
if (b[i] == a[n])
cout << a[n - 1] << endl;
else
cout << a[n] << endl;
}
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 775,504 | 775,505 | u469639111 | cpp |
p02971 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
ll gcd(ll n, ll m) {
ll tmp;
while (m != 0) {
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m) {
return abs(n * m) / gcd(n, m); // gl=xy
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using namespace std;
//ここから
void solve() {
int n;
cin >> n;
vector<int> a(n);
map<int, int> mp;
int maxv = 0;
rep(i, n) cin >> a[i], mp[a[i]]++, chmax(maxv, a[i]);
vector<int> b = a;
sort(b.rbegin(), b.rend());
int se = b[1];
rep(i, n) {
if (a[i] == maxv) {
if (mp[a[i]] != 1)
cout << maxv << endl;
else
cout << b[i] << endl;
} else
cout << maxv << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
ll gcd(ll n, ll m) {
ll tmp;
while (m != 0) {
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m) {
return abs(n * m) / gcd(n, m); // gl=xy
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using namespace std;
//ここから
void solve() {
int n;
cin >> n;
vector<int> a(n);
map<int, int> mp;
int maxv = 0;
rep(i, n) cin >> a[i], mp[a[i]]++, chmax(maxv, a[i]);
vector<int> b = a;
sort(b.rbegin(), b.rend());
int se = b[1];
rep(i, n) {
if (a[i] == maxv) {
if (mp[a[i]] != 1)
cout << maxv << endl;
else
cout << se << endl;
} else
cout << maxv << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| [
"io.output.change"
] | 775,510 | 775,511 | u698883164 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
int ans = 0;
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
if (a[i] == b[n - 1])
cout << a[n - 2] << endl;
else
cout << a[n - 1] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
int ans = 0;
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
if (a[i] == b[n - 1])
cout << b[n - 2] << endl;
else
cout << b[n - 1] << endl;
}
} | [
"identifier.change",
"io.output.change"
] | 775,516 | 775,517 | u057810841 | cpp |
p02971 | #include <bits/stdc++.h>
#define ford(i, a, b) for (int i = (a); i >= b; i--)
#define rep(i, a, b) for (int i = (a); (i) <= (b); (i)++)
#define ll long long
#define mp map<int, int>
using namespace std;
int a[200005], b[200005];
int main() {
int n;
cin >> n;
rep(i, 1, n) cin >> a[i], b[i] = a[i];
sort(b + 1, b + n + 1);
rep(i, 1, n) {
if (a[i] <= b[n])
cout << b[n] << "\n";
else
cout << b[n - 1] << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
#define ford(i, a, b) for (int i = (a); i >= b; i--)
#define rep(i, a, b) for (int i = (a); (i) <= (b); (i)++)
#define ll long long
#define mp map<int, int>
using namespace std;
int a[200005], b[200005];
int main() {
int n;
cin >> n;
rep(i, 1, n) cin >> a[i], b[i] = a[i];
sort(b + 1, b + n + 1);
rep(i, 1, n) {
if (a[i] < b[n])
cout << b[n] << "\n";
else
cout << b[n - 1] << "\n";
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 775,527 | 775,528 | u796123030 | cpp |
p02971 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n)-1; i >= 0; i--)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int n;
int main() {
cin >> n;
vector<int> a(n + 1);
vector<int> r(n + 1), l(n + 1);
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 1] = a[n - 1];
for (int i = 0; i < n; ++i)
l[i + 1] = max(l[i], a[i + 1]);
for (int i = n - 1; i >= 0; --i)
r[i] = max(r[i + 1], a[i]);
cout << r[0] << endl;
for (int i = 1; i < n - 1; ++i)
cout << max(l[i - 1], r[i + 1]) << endl;
cout << l[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n)-1; i >= 0; i--)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int n;
int main() {
cin >> n;
vector<int> a(n + 1);
vector<int> r(n + 1), l(n + 1);
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 1] = a[n - 1];
for (int i = 0; i < n; ++i)
l[i + 1] = max(l[i], a[i + 1]);
for (int i = n - 1; i >= 0; --i)
r[i] = max(r[i + 1], a[i]);
cout << r[1] << endl;
for (int i = 1; i < n - 1; ++i)
cout << max(l[i - 1], r[i + 1]) << endl;
cout << l[n - 2] << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,531 | 775,532 | u620269708 | cpp |
p02971 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n)-1; i >= 0; i--)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int n;
int main() {
cin >> n;
vector<int> a(n + 1);
vector<int> r(n + 1), l(n + 1);
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 1] = a[n - 1];
for (int i = 0; i < n; ++i)
l[i + 1] = max(l[i], a[i + 1]);
for (int i = n - 1; i >= 0; --i)
r[i] = max(r[i + 1], a[i]);
cout << r[1] << endl;
for (int i = 1; i < n - 1; ++i)
cout << max(l[i - 1], r[i + 1]) << endl;
cout << l[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n)-1; i >= 0; i--)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int n;
int main() {
cin >> n;
vector<int> a(n + 1);
vector<int> r(n + 1), l(n + 1);
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 1] = a[n - 1];
for (int i = 0; i < n; ++i)
l[i + 1] = max(l[i], a[i + 1]);
for (int i = n - 1; i >= 0; --i)
r[i] = max(r[i + 1], a[i]);
cout << r[1] << endl;
for (int i = 1; i < n - 1; ++i)
cout << max(l[i - 1], r[i + 1]) << endl;
cout << l[n - 2] << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,533 | 775,532 | u620269708 | cpp |
p02971 | #include <algorithm>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <numeric>
#include <stdio.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
int a, b, c, n;
string s, t;
int main() {
cin >> n;
vector<int> A(n), b(n);
rep(i, n) {
cin >> A.at(i);
b.at(i) = A.at(i);
}
sort(all(A));
reverse(all(A));
rep(i, n) {
if (b.at(i) == A.at(1))
cout << A.at(1) << endl;
else
cout << A.at(0) << endl;
}
}
| #include <algorithm>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <numeric>
#include <stdio.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
int a, b, c, n;
string s, t;
int main() {
cin >> n;
vector<int> A(n), b(n);
rep(i, n) {
cin >> A.at(i);
b.at(i) = A.at(i);
}
sort(all(A));
reverse(all(A));
rep(i, n) {
if (b.at(i) != A.at(0))
cout << A.at(0) << endl;
else
cout << A.at(1) << endl;
}
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 775,538 | 775,539 | u465760322 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> a_tmp(n);
int max_index = 0;
int max = 0;
int second_max = 0;
int max_cnt = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > max) {
max_index = i;
second_max = max;
max = a[i];
} else if (a[i] == max) {
max_cnt++;
} else if (a[i] > second_max) {
second_max = a[i];
}
}
// cout << max_index << endl;
// cout << max << endl;
// cout << second_max << endl;
for (int i = 0; i < n; i++) {
if (max_cnt >= 1) {
cout << max << endl;
} else if (i == max_index) {
cout << second_max << endl;
} else {
cout << max << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> a_tmp(n);
int max_index = 0;
int max = 0;
int second_max = 0;
int max_cnt = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > max) {
max_index = i;
second_max = max;
max = a[i];
max_cnt = 0;
} else if (a[i] == max) {
max_cnt++;
} else if (a[i] > second_max) {
second_max = a[i];
}
}
// cout << max_index << endl;
// cout << max << endl;
// cout << second_max << endl;
for (int i = 0; i < n; i++) {
if (max_cnt >= 1) {
cout << max << endl;
} else if (i == max_index) {
cout << second_max << endl;
} else {
cout << max << endl;
}
}
return 0;
}
| [
"assignment.add"
] | 775,540 | 775,541 | u596311864 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
multiset<int> s;
vector<int> v(n);
int m = n;
for (auto &i : v) {
cin >> i;
s.insert(i);
}
for (auto i : v) {
s.erase(i);
cout << *s.rbegin() << "\n";
s.insert(i);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
multiset<int> s;
vector<int> v(n);
int m = n;
for (auto &i : v) {
cin >> i;
s.insert(i);
}
for (auto i : v) {
s.erase(s.find(i));
cout << *s.rbegin() << "\n";
s.insert(i);
}
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 775,546 | 775,547 | u767871438 | cpp |
p02971 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n); i >= 0; i--)
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define ALL(obj) begin(obj), end(obj)
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int INF = 2100100100;
const int MOD = 1e9 + 7;
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
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 (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N);
REP(i, N) { cin >> A.at(i); }
int max = A[0];
int max2 = 0;
REP(i, N) {
if (max <= A[i]) {
max2 = max;
max = A[i];
} else if (max2 <= A[i]) {
max2 = A[i];
}
}
REP(i, N) {
if (max == A[i]) {
cout << max2 << endl;
} else {
cout << max << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n); i >= 0; i--)
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define ALL(obj) begin(obj), end(obj)
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int INF = 2100100100;
const int MOD = 1e9 + 7;
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
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 (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N);
REP(i, N) { cin >> A.at(i); }
int max = A[0];
int max2 = 0;
FOR(i, 1, N) {
if (max <= A[i]) {
max2 = max;
max = A[i];
} else if (max2 <= A[i]) {
max2 = A[i];
}
}
REP(i, N) {
if (max == A[i]) {
cout << max2 << endl;
} else {
cout << max << endl;
}
}
return 0;
}
| [
"call.arguments.add"
] | 775,555 | 775,556 | u571173211 | cpp |
p02971 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array, vector<T> &v) {
T temp;
int i = 0;
array.resize(N);
v.resize(N);
while (cin >> temp) {
array[i] = v[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
int main() {
ll n;
cin >> n;
vector<ll> v, fg;
splitIn(n, v, fg);
eraseSame(fg);
auto itr = fg.end();
for (auto &o : v) {
if (fg.size() == 1) {
cout << fg[0] << endl;
} else if (o == *(itr - 1)) {
cout << *(itr - 2) << endl;
} else {
cout << *(itr - 1) << endl;
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define MOD 1000000007 // 10億 = 10^9になってる
#define juu 100000 // 10万 10e5
#define hyaku 1000000 // 100万 10e6
#define mINF -922337200085470000 // llのmax-1桁の小さい方
#define pINF 922337203600070000 // llのmax-1桁のデカい方
#define uINF 1844674407300000000 // ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num) {
int i = 0, kosuu = 0;
while (*(factor + i) != 0) {
while (num % *(factor + i) == 0) {
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number) {
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++) {
flag = 0;
for (int j = 0; j <= tmp; j++) {
if (i % (*(factor + j)) == 0) {
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r) {
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++) {
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r) {
ll val = 1;
ll i;
for (i = 0; i < r; i++) {
val *= (n - i);
}
return val;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T> void eraseSame(T &a) {
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T> bool swapmax(T &a, T &b) {
T temp;
temp = a;
if (a > b) {
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T> void splitIn(ll N, vector<T> &array, vector<T> &v) {
T temp;
int i = 0;
array.resize(N);
v.resize(N);
while (cin >> temp) {
array[i] = v[i] = temp;
i++;
if (i >= N) {
break;
}
}
return;
}
int main() {
ll n;
cin >> n;
vector<ll> v, fg;
splitIn(n, v, fg);
sort(all(fg));
auto itr = fg.end();
for (auto &o : v) {
if (fg.size() == 1) {
cout << fg[0] << endl;
} else if (o == *(itr - 1)) {
cout << *(itr - 2) << endl;
} else {
cout << *(itr - 1) << endl;
}
}
return 0;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.add",
"call.arguments.change"
] | 775,557 | 775,558 | u143100985 | cpp |
p02971 | #include <bits/stdc++.h>
#define PI 3.1415926535897932
#define MOD 1000000007
#define INF 1e9
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP1(i, n) for (int i = 1; i <= (n); i++)
#define ALL(v) (v).begin(), (v).end()
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef vector<bool> vb;
void solve() {
int N;
cin >> N;
vi A(N);
REP(i, N) cin >> A[i];
int m1 = 0, m2 = 0;
REP(i, N) if (A[m1] < A[i]) m1 = i;
REP(i, N) if (i != m1 && A[m2] < A[i]) m2 = i;
REP(i, N) {
if (i == m1)
cout << A[m2] << endl;
else
cout << A[m1] << endl;
}
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
solve();
return 0;
} | #include <bits/stdc++.h>
#define PI 3.1415926535897932
#define MOD 1000000007
#define INF 1e9
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP1(i, n) for (int i = 1; i <= (n); i++)
#define ALL(v) (v).begin(), (v).end()
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef vector<bool> vb;
void solve() {
int N;
cin >> N;
vi A(N);
REP(i, N) cin >> A[i];
int m1 = 0, m2 = -1;
REP(i, N) if (A[m1] < A[i]) m1 = i;
REP(i, N) if (i != m1 && A[m2] < A[i]) m2 = i;
REP(i, N) {
if (i == m1)
cout << A[m2] << endl;
else
cout << A[m1] << endl;
}
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
solve();
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 775,560 | 775,561 | u952289831 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, long long>
#define double long double
#define INF 1e10
#define MOD 1e9 + 7
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;
}
using Graph = vector<vector<int>>;
signed main() {
int a;
cin >> a;
vector<int> b(a), c(a);
rep(i, a) cin >> b[i];
rep(i, a) c[i] = b[i];
sort(all(c));
int d = c[a - 1];
int e = c[a - 2];
rep(i, a) {
if (b[i] != d)
cout << e << endl;
else
cout << d << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, long long>
#define double long double
#define INF 1e10
#define MOD 1e9 + 7
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;
}
using Graph = vector<vector<int>>;
signed main() {
int a;
cin >> a;
vector<int> b(a), c(a);
rep(i, a) cin >> b[i];
rep(i, a) c[i] = b[i];
sort(all(c));
int d = c[a - 1];
int e = c[a - 2];
rep(i, a) {
if (b[i] == d)
cout << e << endl;
else
cout << d << endl;
}
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 775,571 | 775,572 | u341447450 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(in) in.begin(), in.end()
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<int, pii>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num + 1 > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
do {
l = (l - 1) >> 1, r = (r - 1) >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = (k - 1) >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater = Func())
: obj(bufsize(n), e), e(e), updater(updater) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
typename vector<T>::reference operator[](int n) { return obj[n + offset]; }
};
signed main() {
int N;
cin >> N;
vector<int> A(N);
for (auto &e : A)
cin >> e;
auto sgt = segtree<int>(A, -INF, [](int a, int b) { return max(a, b); });
rep(i, N) { cout << max(sgt.query(0, i), sgt.query(i, N)) << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(in) in.begin(), in.end()
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<int, pii>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num + 1 > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
do {
l = (l - 1) >> 1, r = (r - 1) >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = (k - 1) >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater = Func())
: obj(bufsize(n), e), e(e), updater(updater) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
typename vector<T>::reference operator[](int n) { return obj[n + offset]; }
};
signed main() {
int N;
cin >> N;
vector<int> A(N);
for (auto &e : A)
cin >> e;
auto sgt = segtree<int>(A, -INF, [](int a, int b) { return max(a, b); });
rep(i, N) { cout << max(sgt.query(0, i), sgt.query(i + 1, N)) << endl; }
}
| [
"expression.operation.binary.add"
] | 775,573 | 775,574 | u318334550 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(in) in.begin(), in.end()
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<int, pii>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num + 1 > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
do {
l = (l - 1) >> 1, r = (r - 1) >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = (k - 1) >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater = Func())
: obj(bufsize(n), e), e(e), updater(updater) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
typename vector<T>::reference operator[](int n) { return obj[n + offset]; }
};
signed main() {
int N;
cin >> N;
vector<int> A(N);
for (auto &e : A)
cin >> e;
auto sgt = segtree<int>(A, 0, [](int a, int b) { return max(a, b); });
for (int i = 0; i < N; ++i) {
cout << max(sgt.query(0, i), sgt.query(i + 1, N));
}
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(in) in.begin(), in.end()
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<int, pii>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num + 1 > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
do {
l = (l - 1) >> 1, r = (r - 1) >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = (k - 1) >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater = Func())
: obj(bufsize(n), e), e(e), updater(updater) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
typename vector<T>::reference operator[](int n) { return obj[n + offset]; }
};
signed main() {
int N;
cin >> N;
vector<int> A(N);
for (auto &e : A)
cin >> e;
auto sgt = segtree<int>(A, 0, [](int a, int b) { return max(a, b); });
for (int i = 0; i < N; ++i) {
cout << max(sgt.query(0, i), sgt.query(i + 1, N));
cout << endl;
}
}
| [] | 775,575 | 775,576 | u318334550 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define co(a) cout << a << endl
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define V2(a, b, c) V<V<int>> a(b, V<int>(c))
#define V2a(a, b, c, d) V<V<int>> a(b, V<int>(c, d))
#define incin(a) \
int a; \
cin >> a
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define Pi P<int, int>
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double b = sqrt(a);
for (int i = 3; i <= b; i += 2) {
if (a % i == 0) {
return false;
}
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
int lcm(int a, int b) { return a / gcm(a, b) * b; }
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
int c = 1;
for (int i = a; i >= b; i--)
c *= i;
return c;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
// 最短距離の表:c
// スタート:sx,sy
// ゴール:gx,gy
/*int bfs(V<V<char>> a){
Q<P<int,int>> b;
fo(i,a.sz){
fo(j,a[0].sz){
c[i][j]==INF;
}
}
b.push({sx,sy});
c[sx][sy]=0;
while(b.sz){
P d=b.front();
b.pop();
if(d=={gx,gy})
break;
fo(i,4){
int e=d.fi+mawari4[i],f=d.se+mawari4[i];
if(naka(e,f,a)&&a[e][f]=='.'&&c[e][f]==INF){
b.push({e,f});
c[e][f]==c[d.fi][d.se]+1;
}
}
}
return c[gx][gy];
}*/
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
signed main() {
int n;
cin >> n;
int d;
V<int> a(n);
fo(i, n) { cin >> a[i]; }
V<int> b(n);
b = a;
fo(i, n) { cin >> b[i]; }
Sort(b);
fo(i, n) {
if (b[i] == a[n - 1]) {
d = i;
break;
}
}
fo(i, n) {
if (d == i)
cout << b[n - 2] << endl;
else
cout << b[n - 1] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define co(a) cout << a << endl
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define V2(a, b, c) V<V<int>> a(b, V<int>(c))
#define V2a(a, b, c, d) V<V<int>> a(b, V<int>(c, d))
#define incin(a) \
int a; \
cin >> a
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define Pi P<int, int>
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double b = sqrt(a);
for (int i = 3; i <= b; i += 2) {
if (a % i == 0) {
return false;
}
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
int lcm(int a, int b) { return a / gcm(a, b) * b; }
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
int c = 1;
for (int i = a; i >= b; i--)
c *= i;
return c;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
// 最短距離の表:c
// スタート:sx,sy
// ゴール:gx,gy
/*int bfs(V<V<char>> a){
Q<P<int,int>> b;
fo(i,a.sz){
fo(j,a[0].sz){
c[i][j]==INF;
}
}
b.push({sx,sy});
c[sx][sy]=0;
while(b.sz){
P d=b.front();
b.pop();
if(d=={gx,gy})
break;
fo(i,4){
int e=d.fi+mawari4[i],f=d.se+mawari4[i];
if(naka(e,f,a)&&a[e][f]=='.'&&c[e][f]==INF){
b.push({e,f});
c[e][f]==c[d.fi][d.se]+1;
}
}
}
return c[gx][gy];
}*/
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
signed main() {
int n;
cin >> n;
int d;
V<int> a(n);
fo(i, n) { cin >> a[i]; }
V<int> b(n);
b = a;
fo(i, n) { cin >> b[i]; }
Sort(a);
fo(i, n) {
if (b[i] == a[n - 1]) {
d = i;
break;
}
}
fo(i, n) {
if (d == i)
cout << a[n - 2] << endl;
else
cout << a[n - 1] << endl;
}
}
| [
"identifier.change",
"call.arguments.change",
"io.output.change"
] | 775,577 | 775,578 | u790461875 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[200200];
int maxx1 = 0;
int maxx2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
maxx1 = max(maxx1, a[i]);
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == maxx1)
cnt++;
else
maxx2 = max(maxx2, a[i]);
if (cnt == n)
maxx2 = maxx1;
}
for (int i = 0; i < n; i++) {
if (a[i] == maxx1)
cout << maxx2 << endl;
else
cout << maxx1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[200200];
int maxx1 = 0;
int maxx2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
maxx1 = max(maxx1, a[i]);
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == maxx1)
cnt++;
else
maxx2 = max(maxx2, a[i]);
if (cnt >= 2)
maxx2 = maxx1;
}
for (int i = 0; i < n; i++) {
if (a[i] == maxx1)
cout << maxx2 << endl;
else
cout << maxx1 << endl;
}
} | [
"control_flow.loop.for.condition.change"
] | 775,583 | 775,584 | u796877631 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i) {
b[i] = a[i];
}
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i) {
if (a[i] != b[n - 1])
cout << b[n - 1] << endl;
else
cout << b[n - 2];
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i) {
b[i] = a[i];
}
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i) {
if (a[i] != b[n - 1])
cout << b[n - 1] << endl;
else
cout << b[n - 2] << endl;
}
} | [
"io.output.newline.add"
] | 775,585 | 775,586 | u417563928 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> data(0, 0), A(0, 0), B(0, 0);
int x = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
x = max(x, a);
data.push_back(a);
A.push_back(x);
}
x = 0;
for (int i = N - 1; i >= 0; i--) {
x = max(x, data[i]);
B.push_back(x);
}
for (int i = 0; i < N; i++) {
if (i == 0)
cout << B[N - 1] << endl;
else if (i == N - 1)
cout << A[i - 1] << endl;
else {
int a;
a = max(A[i - 1], B[N - 2 - i]);
cout << a << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> data(0, 0), A(0, 0), B(0, 0);
int x = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
x = max(x, a);
data.push_back(a);
A.push_back(x);
}
x = 0;
for (int i = N - 1; i >= 0; i--) {
x = max(x, data[i]);
B.push_back(x);
}
for (int i = 0; i < N; i++) {
if (i == 0)
cout << B[N - 2] << endl;
else if (i == N - 1)
cout << A[i - 1] << endl;
else {
int a;
a = max(A[i - 1], B[N - 2 - i]);
cout << a << endl;
}
}
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,587 | 775,588 | u071282706 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> data(0, 0), A(0, 0), B(0, 0);
int x = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
x = max(x, a);
data.push_back(a);
A.push_back(x);
}
x = 0;
for (int i = N - 1; i >= 0; i--) {
x = max(x, data[i]);
B.push_back(x);
}
for (int i = 0; i < N; i++) {
if (i == 0)
cout << B[N - 1] << endl;
else if (i == N - 1)
cout << A[i] << endl;
else {
int a;
a = max(A[i - 1], B[N - 2 - i]);
cout << a << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> data(0, 0), A(0, 0), B(0, 0);
int x = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
x = max(x, a);
data.push_back(a);
A.push_back(x);
}
x = 0;
for (int i = N - 1; i >= 0; i--) {
x = max(x, data[i]);
B.push_back(x);
}
for (int i = 0; i < N; i++) {
if (i == 0)
cout << B[N - 2] << endl;
else if (i == N - 1)
cout << A[i - 1] << endl;
else {
int a;
a = max(A[i - 1], B[N - 2 - i]);
cout << a << endl;
}
}
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,589 | 775,588 | u071282706 | cpp |
p02971 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int A[N];
int s[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
s[i] = A[i];
}
int max = 0;
for (int i = 0; i < N; i++) {
if (max < A[i]) {
max = A[i];
}
}
sort(s, s + N);
for (int i = 0; i < N; i++) {
if (A[i] == max) {
cout << s[1] << endl;
} else {
cout << max << endl;
}
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int A[N];
int s[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
s[i] = A[i];
}
int max = 0;
for (int i = 0; i < N; i++) {
if (max < A[i]) {
max = A[i];
}
}
sort(s, s + N);
for (int i = 0; i < N; i++) {
if (A[i] == max) {
cout << s[N - 2] << endl;
} else {
cout << max << endl;
}
}
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"io.output.change"
] | 775,590 | 775,591 | u584787460 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
int largest = A[0];
int next_largest = A[1];
if (largest < next_largest)
swap(largest, next_largest);
for (int i = 0; i < N; i++) {
if (A[i] >= largest) {
next_largest = largest;
largest = A[i];
} else if (A[i] > next_largest) {
next_largest = A[i];
}
}
for (int i = 0; i < N; i++) {
if (A[i] == largest) {
cout << next_largest << endl;
} else {
cout << largest << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
int largest = A[0];
int next_largest = A[1];
if (largest < next_largest)
swap(largest, next_largest);
for (int i = 2; i < N; i++) {
if (A[i] >= largest) {
next_largest = largest;
largest = A[i];
} else if (A[i] > next_largest) {
next_largest = A[i];
}
}
for (int i = 0; i < N; i++) {
if (A[i] == largest) {
cout << next_largest << endl;
} else {
cout << largest << endl;
}
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 775,592 | 775,593 | u599568485 | cpp |
p02971 | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define fi first
#define se second
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n), e(n);
for (int i = 0; i < n; i++)
cin >> a[i];
b[0] = a[0], e[n - 1] = a[n - 1];
for (int i = 1; i < n; i++)
b[i] = max(b[i - 1], a[i]);
for (int i = n - 2; i >= 0; i--)
e[i] = max(b[i + 1], a[i]);
printf("%d\n", e[1]);
for (int i = 1; i < n - 1; i++)
printf("%d\n", max(b[i - 1], e[i + 1]));
printf("%d\n", b[n - 2]);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define fi first
#define se second
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n), e(n);
for (int i = 0; i < n; i++)
cin >> a[i];
b[0] = a[0], e[n - 1] = a[n - 1];
for (int i = 1; i < n; i++)
b[i] = max(b[i - 1], a[i]);
for (int i = n - 2; i >= 0; i--)
e[i] = max(e[i + 1], a[i]);
printf("%d\n", e[1]);
for (int i = 1; i < n - 1; i++)
printf("%d\n", max(b[i - 1], e[i + 1]));
printf("%d\n", b[n - 2]);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 775,608 | 775,609 | u427571081 | cpp |
p02971 | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define fi first
#define se second
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n), e(n);
for (int i = 0; i < n; i++)
cin >> a[i];
b[0] = a[0], e[n - 1] = a[n - 1];
for (int i = 1; i < n; i++)
b[i] = max(b[i - 1], a[i]);
for (int i = n - 2; i >= 0; i--)
e[i] = max(b[i + 1], a[i]);
printf("%d\n", e[0]);
for (int i = 1; i < n - 1; i++)
printf("%d\n", max(b[i - 1], e[i + 1]));
printf("%d\n", b[n - 1]);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define fi first
#define se second
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n), e(n);
for (int i = 0; i < n; i++)
cin >> a[i];
b[0] = a[0], e[n - 1] = a[n - 1];
for (int i = 1; i < n; i++)
b[i] = max(b[i - 1], a[i]);
for (int i = n - 2; i >= 0; i--)
e[i] = max(e[i + 1], a[i]);
printf("%d\n", e[1]);
for (int i = 1; i < n - 1; i++)
printf("%d\n", max(b[i - 1], e[i + 1]));
printf("%d\n", b[n - 2]);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change",
"expression.operation.binary.change"
] | 775,610 | 775,609 | u427571081 | cpp |
p02971 | #include <iostream>
int main() {
int N, A[200000];
int max = 0;
int max2 = 0;
int flag = 0;
scanf("%d", &N);
for (int i = 0; i <= N - 1; i++) {
scanf("%d", &A[i]);
if (A[i] > max) {
max = A[i];
}
if (A[i] > max2) {
if (A[i] != max) {
max2 = A[i];
}
}
}
for (int k = 0; k <= N - 1; k++) {
if (A[k] == max) {
flag++;
}
}
for (int j = 0; j <= N - 1; j++) {
if (A[j] != max) {
printf("%d\n", max);
} else {
if (flag > 1) {
printf("%d\n", max);
} else {
printf("%d\n", max2);
}
}
}
} | #include <iostream>
int main() {
int N, A[200000];
int max = 0;
int max2 = 0;
int flag = 0;
scanf("%d", &N);
for (int i = 0; i <= N - 1; i++) {
scanf("%d", &A[i]);
if (A[i] > max) {
max2 = max;
max = A[i];
}
if (A[i] > max2) {
if (A[i] != max) {
max2 = A[i];
}
}
}
for (int k = 0; k <= N - 1; k++) {
if (A[k] == max) {
flag++;
}
}
for (int j = 0; j <= N - 1; j++) {
if (A[j] != max) {
printf("%d\n", max);
} else {
if (flag > 1) {
printf("%d\n", max);
} else {
printf("%d\n", max2);
}
}
}
} | [
"assignment.add"
] | 775,632 | 775,633 | u392164874 | cpp |
p02971 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<int> numbers(N);
int max_number = 0;
int max_index = 0;
int n;
for (int i = 0; i < N; i++) {
cin >> numbers.at(i);
if (max_number < numbers.at(i)) {
max_number = numbers.at(i);
max_index = i;
}
}
for (int i = 1; i < N; i++) {
if (i == max_index) {
int m = 0;
int m_index = 0;
for (int j = 0; j < N; j++) {
if (i == j) {
continue;
}
if (m < numbers.at(j)) {
m = numbers.at(j);
m_index = j;
}
}
cout << m << endl;
} else {
cout << max_number << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<int> numbers(N);
int max_number = 0;
int max_index = 0;
int n;
for (int i = 0; i < N; i++) {
cin >> numbers.at(i);
if (max_number < numbers.at(i)) {
max_number = numbers.at(i);
max_index = i;
}
}
for (int i = 0; i < N; i++) {
if (i == max_index) {
int m = 0;
int m_index = 0;
for (int j = 0; j < N; j++) {
if (i == j) {
continue;
}
if (m < numbers.at(j)) {
m = numbers.at(j);
m_index = j;
}
}
cout << m << endl;
} else {
cout << max_number << endl;
}
}
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 775,634 | 775,635 | u975658594 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.