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 |
|---|---|---|---|---|---|---|---|
p03141 | #define DEBUG 1
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using tll = tuple<ll, ll, ll>;
using vtll = vector<tll>;
using vvtll = vector<vtll>;
#define all(v) (v).begin(), (v).end()
#define for1(i, n) for (ll i = 0; i < (n); i++)
#define for2(i, m, n) for (ll i = (m); i < (n); i++)
#define for3(i, m, n, d) for (ll i = (m); i < (n); i += (d))
#define rfor2(i, m, n) for (ll i = (m); i > (n); i--)
#define rfor3(i, m, n, d) for (ll i = (m); i > (n); i += (d))
#define PI 3.1415926535897932384626433832795028841971693993751L
#define INF 1111111111111111111LL
#define print(...) print_1(__VA_ARGS__)
#define in(...) in_1(__VA_ARGS__)
#if DEBUG
#define dump(...) dump_1(#__VA_ARGS__, __VA_ARGS__)
#define dumpa(...) dumpa_1(#__VA_ARGS__, __VA_ARGS__)
#else
#define dump(...)
#define dumpa(...)
#endif
template <typename Head> void dump_1(const char *str, Head &&h) {
cerr << str << ": " << h << '\n';
}
template <typename Head, typename... Tail>
void dump_1(const char *str, Head &&h, Tail &&...t) {
while (*str != ',') {
cerr << *str++;
}
cerr << ": " << h << ' ';
dump_1(str + 1, t...);
}
template <typename T>
void dumpa_1(const char *str, const T v[], const ll size) {
while (*str != ',') {
cerr << *str++;
}
cerr << ": ";
for1(i, size) {
if (i != 0) {
cerr << ' ';
}
cerr << v[i];
}
cerr << '\n';
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &v) {
os << v.first << ' ' << v.second;
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &v) {
os << get<0>(v) << ' ' << get<1>(v) << ' ' << get<2>(v);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &v) {
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &v) {
os << '{';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ", ";
}
os << it->first << ':' << it->second;
}
os << '}';
return os;
}
ll divup(ll nume, ll deno) {
assert(nume >= 0);
assert(deno > 0);
return (nume + deno - 1) / deno;
}
void Yes(void) { cout << "Yes\n"; }
void No(void) { cout << "No\n"; }
void YES(void) { cout << "YES\n"; }
void NO(void) { cout << "NO\n"; }
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> void vin(vector<T> &v) {
ll len = v.size();
for1(i, len) { cin >> v[i]; }
}
template <typename Head> void in_1(Head &h) { cin >> h; }
template <typename Head, typename... Tail> void in_1(Head &h, Tail &...t) {
cin >> h;
in_1(t...);
}
template <typename Head> void print_1(Head &&h) { cout << h << '\n'; }
template <typename Head, typename... Tail> void print_1(Head &&h, Tail &&...t) {
cout << h << ' ';
print_1(t...);
}
//---------------------------------------------------------
const ll mod = 1000000007LL; // 10**9 + 7
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &v) {
os << v.x;
return os;
}
};
//---------------------------------------------------------
struct mintcomb {
vector<mint> fact, ifact;
mintcomb(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i) {
fact[i] = fact[i - 1] * i;
}
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) {
ifact[i - 1] = ifact[i] * i;
}
}
mint permutation(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[n - k];
}
mint combination(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//---------------------------------------------------------
void solve() {
ll N;
in(N);
vector<tll> A;
for1(i, N) {
ll a, b;
in(a, b);
A.emplace_back(b + a, a, b);
}
sort(all(A));
vll sc(2);
for1(i, N) {
if (i % 2 == 0) {
sc[0] += get<1>(A[i]);
} else {
sc[1] += get<2>(A[i]);
}
}
print(sc[0] - sc[1]);
}
//---------------------------------------------------------
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(16);
cerr << fixed << setprecision(16);
solve();
}
| #define DEBUG 1
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using tll = tuple<ll, ll, ll>;
using vtll = vector<tll>;
using vvtll = vector<vtll>;
#define all(v) (v).begin(), (v).end()
#define for1(i, n) for (ll i = 0; i < (n); i++)
#define for2(i, m, n) for (ll i = (m); i < (n); i++)
#define for3(i, m, n, d) for (ll i = (m); i < (n); i += (d))
#define rfor2(i, m, n) for (ll i = (m); i > (n); i--)
#define rfor3(i, m, n, d) for (ll i = (m); i > (n); i += (d))
#define PI 3.1415926535897932384626433832795028841971693993751L
#define INF 1111111111111111111LL
#define print(...) print_1(__VA_ARGS__)
#define in(...) in_1(__VA_ARGS__)
#if DEBUG
#define dump(...) dump_1(#__VA_ARGS__, __VA_ARGS__)
#define dumpa(...) dumpa_1(#__VA_ARGS__, __VA_ARGS__)
#else
#define dump(...)
#define dumpa(...)
#endif
template <typename Head> void dump_1(const char *str, Head &&h) {
cerr << str << ": " << h << '\n';
}
template <typename Head, typename... Tail>
void dump_1(const char *str, Head &&h, Tail &&...t) {
while (*str != ',') {
cerr << *str++;
}
cerr << ": " << h << ' ';
dump_1(str + 1, t...);
}
template <typename T>
void dumpa_1(const char *str, const T v[], const ll size) {
while (*str != ',') {
cerr << *str++;
}
cerr << ": ";
for1(i, size) {
if (i != 0) {
cerr << ' ';
}
cerr << v[i];
}
cerr << '\n';
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &v) {
os << v.first << ' ' << v.second;
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &v) {
os << get<0>(v) << ' ' << get<1>(v) << ' ' << get<2>(v);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &v) {
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ' ';
}
os << *it;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &v) {
os << '{';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) {
os << ", ";
}
os << it->first << ':' << it->second;
}
os << '}';
return os;
}
ll divup(ll nume, ll deno) {
assert(nume >= 0);
assert(deno > 0);
return (nume + deno - 1) / deno;
}
void Yes(void) { cout << "Yes\n"; }
void No(void) { cout << "No\n"; }
void YES(void) { cout << "YES\n"; }
void NO(void) { cout << "NO\n"; }
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> void vin(vector<T> &v) {
ll len = v.size();
for1(i, len) { cin >> v[i]; }
}
template <typename Head> void in_1(Head &h) { cin >> h; }
template <typename Head, typename... Tail> void in_1(Head &h, Tail &...t) {
cin >> h;
in_1(t...);
}
template <typename Head> void print_1(Head &&h) { cout << h << '\n'; }
template <typename Head, typename... Tail> void print_1(Head &&h, Tail &&...t) {
cout << h << ' ';
print_1(t...);
}
//---------------------------------------------------------
const ll mod = 1000000007LL; // 10**9 + 7
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &v) {
os << v.x;
return os;
}
};
//---------------------------------------------------------
struct mintcomb {
vector<mint> fact, ifact;
mintcomb(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i) {
fact[i] = fact[i - 1] * i;
}
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) {
ifact[i - 1] = ifact[i] * i;
}
}
mint permutation(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[n - k];
}
mint combination(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//---------------------------------------------------------
void solve() {
ll N;
in(N);
vector<tll> A;
for1(i, N) {
ll a, b;
in(a, b);
A.emplace_back(-b - a, a, b);
}
sort(all(A));
vll sc(2);
for1(i, N) {
if (i % 2 == 0) {
sc[0] += get<1>(A[i]);
} else {
sc[1] += get<2>(A[i]);
}
}
print(sc[0] - sc[1]);
}
//---------------------------------------------------------
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(16);
cerr << fixed << setprecision(16);
solve();
}
| [
"expression.operation.unary.add",
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 940,953 | 940,954 | u426683236 | cpp |
p03141 | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
struct Info {
long long int a;
long long int b;
long long int c;
Info(long long int ax, long long int bx, long long int cx) {
a = ax;
b = bx;
c = cx;
}
};
bool cmp(const Info &x, const Info &y) { return x.c > y.c; }
int main() {
long long int a[200005] = {}, b[200005] = {}, c[200005] = {}, d, n, m = 0;
vector<Info> info;
string str, str2, str3;
map<int, long long int> mp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = -b[i] + a[i];
info.push_back(Info(a[i], b[i], c[i]));
}
sort(info.begin(), info.end(), cmp);
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
m += info[i].a;
} else {
m -= info[i].b;
}
}
cout << m;
} | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
struct Info {
long long int a;
long long int b;
long long int c;
Info(long long int ax, long long int bx, long long int cx) {
a = ax;
b = bx;
c = cx;
}
};
bool cmp(const Info &x, const Info &y) { return x.c > y.c; }
int main() {
long long int a[200005] = {}, b[200005] = {}, c[200005] = {}, d, n, m = 0;
vector<Info> info;
string str, str2, str3;
map<int, long long int> mp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = b[i] + a[i];
info.push_back(Info(a[i], b[i], c[i]));
}
sort(info.begin(), info.end(), cmp);
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
m += info[i].a;
} else {
m -= info[i].b;
}
}
cout << m;
} | [
"expression.operation.unary.arithmetic.remove"
] | 940,955 | 940,956 | u018872912 | cpp |
p03141 | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
struct Info {
long long int a;
long long int b;
long long int c;
Info(long long int ax, long long int bx, long long int cx) {
a = ax;
b = bx;
c = cx;
}
};
bool cmp(const Info &x, const Info &y) { return x.c < y.c; }
int main() {
long long int a[200005] = {}, b[200005] = {}, c[200005] = {}, d, n, m = 0;
vector<Info> info;
string str, str2, str3;
map<int, long long int> mp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = -b[i] + a[i];
info.push_back(Info(a[i], b[i], c[i]));
}
sort(info.begin(), info.end(), cmp);
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
m += info[i].a;
} else {
m -= info[i].b;
}
}
cout << m;
} | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
struct Info {
long long int a;
long long int b;
long long int c;
Info(long long int ax, long long int bx, long long int cx) {
a = ax;
b = bx;
c = cx;
}
};
bool cmp(const Info &x, const Info &y) { return x.c > y.c; }
int main() {
long long int a[200005] = {}, b[200005] = {}, c[200005] = {}, d, n, m = 0;
vector<Info> info;
string str, str2, str3;
map<int, long long int> mp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = b[i] + a[i];
info.push_back(Info(a[i], b[i], c[i]));
}
sort(info.begin(), info.end(), cmp);
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
m += info[i].a;
} else {
m -= info[i].b;
}
}
cout << m;
} | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change",
"expression.operation.unary.arithmetic.remove"
] | 940,957 | 940,956 | u018872912 | cpp |
p03141 | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
struct Info {
long long int a;
long long int b;
long long int c;
Info(long long int ax, long long int bx, long long int cx) {
a = ax;
b = bx;
c = cx;
}
};
bool cmp(const Info &x, const Info &y) { return x.c < y.c; }
int main() {
long long int a[200005] = {}, b[200005] = {}, c[200005] = {}, d, n, m = 0;
vector<Info> info;
string str, str2, str3;
map<int, long long int> mp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = b[i] - a[i];
info.push_back(Info(a[i], b[i], c[i]));
}
sort(info.begin(), info.end(), cmp);
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
m += info[i].a;
} else {
m -= info[i].b;
}
}
cout << m;
} | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
struct Info {
long long int a;
long long int b;
long long int c;
Info(long long int ax, long long int bx, long long int cx) {
a = ax;
b = bx;
c = cx;
}
};
bool cmp(const Info &x, const Info &y) { return x.c > y.c; }
int main() {
long long int a[200005] = {}, b[200005] = {}, c[200005] = {}, d, n, m = 0;
vector<Info> info;
string str, str2, str3;
map<int, long long int> mp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = b[i] + a[i];
info.push_back(Info(a[i], b[i], c[i]));
}
sort(info.begin(), info.end(), cmp);
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
m += info[i].a;
} else {
m -= info[i].b;
}
}
cout << m;
} | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change",
"expression.operator.arithmetic.change",
"assignment.value.change"
] | 940,958 | 940,956 | u018872912 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const ll MOD = (ll)(1e9 + 7);
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define possible(n) cout << ((n) ? "possible" : "impossible") << endl
#define Yay(n) cout << ((n) ? "Yay!" : ":(") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(50) << setiosflags(ios::fixed);
ll n;
cin >> n;
vector<pll> v;
rep(i, n) {
ll a, b;
cin >> a >> b;
v.push_back(MP(a, b));
}
const auto comp = [](pll &p1, pll &p2) {
return p1.first + p1.second < p2.first + p2.second;
};
sort(all(v), comp);
ll ans = 0;
rep(i, n) { ans += (i % 2 == 0 ? v[i].first : -v[i].second); }
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const ll MOD = (ll)(1e9 + 7);
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define possible(n) cout << ((n) ? "possible" : "impossible") << endl
#define Yay(n) cout << ((n) ? "Yay!" : ":(") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(50) << setiosflags(ios::fixed);
ll n;
cin >> n;
vector<pll> v;
rep(i, n) {
ll a, b;
cin >> a >> b;
v.push_back(MP(a, b));
}
const auto comp = [](pll &p1, pll &p2) {
return p1.first + p1.second > p2.first + p2.second;
};
sort(all(v), comp);
ll ans = 0;
rep(i, n) { ans += (i % 2 == 0 ? v[i].first : -v[i].second); }
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 940,959 | 940,960 | u878615689 | cpp |
p03140 | #include <iostream>
using namespace std;
int main(int argc, char *argv[]) {
int N;
string A, B, C;
cin >> N;
cin >> A;
cin >> B;
cin >> C;
int answer = 0;
for (int i = 0; i < N; i++) {
if (A[i] == B[i] && B[i] == C[i]) {
break;
} else if (A[i] == B[i] || B[i] == C[i] || C[i] == A[i]) {
answer += 1;
} else {
answer += 2;
}
}
cout << answer;
return 0;
} | #include <iostream>
using namespace std;
int main(int argc, char *argv[]) {
int N;
string A, B, C;
cin >> N;
cin >> A;
cin >> B;
cin >> C;
int answer = 0;
for (int i = 0; i < N; i++) {
if (A[i] == B[i] && B[i] == C[i]) {
continue;
} else if (A[i] == B[i] || B[i] == C[i] || C[i] == A[i]) {
answer += 1;
} else {
answer += 2;
}
}
cout << answer;
return 0;
} | [
"control_flow.break.remove",
"control_flow.continue.add"
] | 940,976 | 940,977 | u417683939 | cpp |
p03140 | #include <bits/stdc++.h>
using namespace std;
int n, i, res;
char a[1000], b[1000], c[1000];
int main() {
cin >> n;
scanf("%s", &a);
scanf("%s", &b);
scanf("%s", &c);
for (i = 0; i < n; i++) {
if (a[i] == b[i])
if (a[i] != c[i])
res++;
if (a[i] != b[i])
;
{
if (b[i] == c[i])
res++;
if (b[i] != c[i]) {
if (c[i] == a[i])
res++;
if (c[i] != a[i])
res += 2;
}
}
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int n, i, res;
char a[1000], b[1000], c[1000];
int main() {
cin >> n;
scanf("%s", &a);
scanf("%s", &b);
scanf("%s", &c);
for (i = 0; i < n; i++) {
if (a[i] == b[i])
if (a[i] != c[i])
res++;
if (a[i] != b[i]) {
if (b[i] == c[i])
res++;
if (b[i] != c[i]) {
if (c[i] == a[i])
res++;
if (c[i] != a[i])
res += 2;
}
}
}
cout << res << endl;
} | [] | 940,992 | 940,993 | u542075673 | cpp |
p03140 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, ans; //過半数を占める文字をしらべる
string a, b, c;
ans = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) {
if (a[i] = b[i] && b[i] == c[i]) {
} else {
ans++;
}
} else {
ans = ans + 2;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, ans; //過半数を占める文字をしらべる
string a, b, c;
ans = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i < n; i++) {
if (a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) {
if (a[i] == b[i] && b[i] == c[i]) {
} else {
ans++;
}
} else {
ans = ans + 2;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 941,003 | 941,004 | u840013257 | cpp |
p03141 | #include <algorithm>
#include <complex>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
//#define INF 100000000
//#define MOD (int) (1e9+7)
#define rep(i, a) for (int i = 0; i < (a); i++)
using namespace std;
/*
const int MAX = 1000000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
//テーブルの前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
//そのまま計算すると負の値になるのでMODを足す
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//UnionFind木
struct UnionFind{
vector<long long int> par; //par[i] : iの親の番号
vector<long long int> rnk; //root[i] : iの木のサイズ
//コンストラクタ
UnionFind(long long int n): par(n), rnk(n){
//木の初期化
for(long long int i = 0; i < n; i++){
par[i] = i;
rnk[i] = 1;
}
}
//データxが属する木の根を再帰で取得
long long int root(long long int x){
if(par[x] == x){
return x;
}else{
return par[x] = root(par[x]);
}
}
//xとyが同じ木に属しているかを判定
bool same(long long int x, long long int y){
return root(x) == root(y);
}
//xとyの木を併合
void unite(long long int x, long long int y){
long long int rx = root(x); //xの根
long long int ry = root(y); //yの根
if(rx == ry) return; //根が同じならそのまま
//併合するときにサイズを足し合わせる
if(rnk[rx] < rnk[ry]){
par[rx] = ry;
rnk[ry] += rnk[rx];
}else{
par[ry] = rx;
rnk[rx] += rnk[ry];
}
}
//属している木のサイズを取得
long long int size(long long int x){
return rnk[root(x)];
}
};
*/
int main() {
int n;
cin >> n;
vector<long long int> v;
long long int sum = 0;
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
sum -= b;
v.push_back(a + b);
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
sum += v[i];
}
cout << sum << endl;
}
| #include <algorithm>
#include <complex>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
//#define INF 100000000
//#define MOD (int) (1e9+7)
#define rep(i, a) for (int i = 0; i < (a); i++)
using namespace std;
/*
const int MAX = 1000000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
//テーブルの前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
//そのまま計算すると負の値になるのでMODを足す
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//UnionFind木
struct UnionFind{
vector<long long int> par; //par[i] : iの親の番号
vector<long long int> rnk; //root[i] : iの木のサイズ
//コンストラクタ
UnionFind(long long int n): par(n), rnk(n){
//木の初期化
for(long long int i = 0; i < n; i++){
par[i] = i;
rnk[i] = 1;
}
}
//データxが属する木の根を再帰で取得
long long int root(long long int x){
if(par[x] == x){
return x;
}else{
return par[x] = root(par[x]);
}
}
//xとyが同じ木に属しているかを判定
bool same(long long int x, long long int y){
return root(x) == root(y);
}
//xとyの木を併合
void unite(long long int x, long long int y){
long long int rx = root(x); //xの根
long long int ry = root(y); //yの根
if(rx == ry) return; //根が同じならそのまま
//併合するときにサイズを足し合わせる
if(rnk[rx] < rnk[ry]){
par[rx] = ry;
rnk[ry] += rnk[rx];
}else{
par[ry] = rx;
rnk[rx] += rnk[ry];
}
}
//属している木のサイズを取得
long long int size(long long int x){
return rnk[root(x)];
}
};
*/
int main() {
int n;
cin >> n;
vector<long long int> v;
long long int sum = 0;
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
sum -= b;
v.push_back(a + b);
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
sum += v[n - 1 - i];
}
cout << sum << endl;
}
| [
"assignment.change"
] | 941,009 | 941,010 | u536712674 | cpp |
p03141 | // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ends ' '
#define die(x) return cout << x << endl, 0
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x.size())
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << ends << H;
debug_out(T...);
}
#define debug(...) cerr << "{" << #__VA_ARGS__ << "}:", debug_out(__VA_ARGS__)
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
////////////////////////////////////////////////////////////////////
const int N = 1e5 + 5;
int A[N], B[N], C[N];
bool CMP(int i, int j) { return A[i] + B[i] > A[j] + B[j]; }
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i] >> B[i], C[i] = i;
sort(C, C + n, CMP);
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i & 1)
ans -= B[i];
else
ans += A[i];
}
cout << ans << endl;
return 0;
}
| // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ends ' '
#define die(x) return cout << x << endl, 0
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x.size())
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << ends << H;
debug_out(T...);
}
#define debug(...) cerr << "{" << #__VA_ARGS__ << "}:", debug_out(__VA_ARGS__)
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
////////////////////////////////////////////////////////////////////
const int N = 1e5 + 5;
int A[N], B[N], C[N];
bool CMP(int i, int j) { return A[i] + B[i] > A[j] + B[j]; }
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i] >> B[i], C[i] = i;
sort(C, C + n, CMP);
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i & 1)
ans -= B[C[i]];
else
ans += A[C[i]];
}
cout << ans << endl;
return 0;
}
| [] | 941,027 | 941,028 | u379382721 | cpp |
p03141 | #include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("no-stack-protector,fast-math")
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef pair<ll, ll> pll;
#define debug(x) cerr << #x << '=' << (x) << endl;
#define debugp(x) \
cerr << #x << "= {" << (x.first) << ", " << (x.second) << "}" << endl;
#define debug2(x, y) \
cerr << "{" << #x << ", " << #y << "} = {" << (x) << ", " << (y) << "}" \
<< endl;
#define debugv(v) \
{ \
cerr << #v << " : "; \
for (auto x : v) \
cerr << x << ' '; \
cerr << endl; \
}
#define all(x) x.begin(), x.end()
#define pb push_back
#define kill(x) return cout << x << '\n', 0;
const ld eps = 1e-7;
const int inf = 1000000010;
const ll INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 20;
ll n, m, k, u, v, x, y, t, a, b, ans;
ll A[MAXN], B[MAXN], ind[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> A[i] >> B[i], ind[i] = i;
sort(ind + 1, ind + n + 1,
[](int i, int j) { return A[i] + B[i] > A[j] + B[j]; });
for (int i = 1; i <= n; i += 2)
ans += A[i];
for (int i = 2; i <= n; i += 2)
ans -= B[i];
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("no-stack-protector,fast-math")
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef pair<ll, ll> pll;
#define debug(x) cerr << #x << '=' << (x) << endl;
#define debugp(x) \
cerr << #x << "= {" << (x.first) << ", " << (x.second) << "}" << endl;
#define debug2(x, y) \
cerr << "{" << #x << ", " << #y << "} = {" << (x) << ", " << (y) << "}" \
<< endl;
#define debugv(v) \
{ \
cerr << #v << " : "; \
for (auto x : v) \
cerr << x << ' '; \
cerr << endl; \
}
#define all(x) x.begin(), x.end()
#define pb push_back
#define kill(x) return cout << x << '\n', 0;
const ld eps = 1e-7;
const int inf = 1000000010;
const ll INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 20;
ll n, m, k, u, v, x, y, t, a, b, ans;
ll A[MAXN], B[MAXN], ind[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> A[i] >> B[i], ind[i] = i;
sort(ind + 1, ind + n + 1,
[](int i, int j) { return A[i] + B[i] > A[j] + B[j]; });
for (int i = 1; i <= n; i += 2)
ans += A[ind[i]];
for (int i = 2; i <= n; i += 2)
ans -= B[ind[i]];
cout << ans << '\n';
return 0;
}
| [] | 941,029 | 941,030 | u924011226 | cpp |
p03141 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define ll long long
using namespace std;
// typedef vector<unsigned int>vec;
// typedef vector<ll>vec;
// typedef vector<vec> mat;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int INF = 1000000000;
const ll LINF = 1000000000000000000; // 1e18
const ll MOD = 1000000007;
const double PI = acos(-1.0);
const double EPS = 1e-10;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// template<class T> inline void add(T &a, T b){a = ((a+b) % MOD + MOD) % MOD;};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> a(N), b(N), idx(N);
iota(idx.begin(), idx.end(), 0);
REP(i, N) cin >> a[i] >> b[i];
sort(idx.begin(), idx.end(),
[&](int x, int y) { return a[x] + b[x] > a[y] + b[y]; });
ll ans = 0;
REP(i, N) {
if (i % 2 == 0)
ans += a[i];
else
ans -= b[i];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define ll long long
using namespace std;
// typedef vector<unsigned int>vec;
// typedef vector<ll>vec;
// typedef vector<vec> mat;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int INF = 1000000000;
const ll LINF = 1000000000000000000; // 1e18
const ll MOD = 1000000007;
const double PI = acos(-1.0);
const double EPS = 1e-10;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// template<class T> inline void add(T &a, T b){a = ((a+b) % MOD + MOD) % MOD;};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> a(N), b(N), idx(N);
iota(idx.begin(), idx.end(), 0);
REP(i, N) cin >> a[i] >> b[i];
sort(idx.begin(), idx.end(),
[&](int x, int y) { return a[x] + b[x] > a[y] + b[y]; });
ll ans = 0;
REP(i, N) {
if (i % 2 == 0)
ans += a[idx[i]];
else
ans -= b[idx[i]];
}
cout << ans << endl;
} | [] | 941,031 | 941,032 | u493750228 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 5;
long long n, q, w;
long long A[MAX_N], B[MAX_N];
long long Arr[MAX_N];
bool cmp(long long a, long long b) { return A[a] + B[a] < A[b] + B[b]; }
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++)
cin >> A[i] >> B[i];
for (long long i = 0; i < n; i++)
Arr[i] = i;
sort(Arr, Arr + n, cmp);
for (long long i = 0; i < n; i++) {
if (i & 1)
q += B[Arr[i]];
else
w += A[Arr[i]];
}
cout << w - q << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 5;
long long n, q, w;
long long A[MAX_N], B[MAX_N];
long long Arr[MAX_N];
bool cmp(long long a, long long b) { return A[a] + B[a] > A[b] + B[b]; }
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++)
cin >> A[i] >> B[i];
for (long long i = 0; i < n; i++)
Arr[i] = i;
sort(Arr, Arr + n, cmp);
for (long long i = 0; i < n; i++) {
if (i & 1)
q += B[Arr[i]];
else
w += A[Arr[i]];
}
cout << w - q << '\n';
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,035 | 941,036 | u386747769 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<ll> enum_div(ll n) {
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
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;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N;
cin >> N;
vector<pair<ll, pair<ll, ll>>> A(N);
REP(i, N) {
int a, b;
cin >> a >> b;
A[i].first = a + b;
A[i].second = {a, b};
}
SORT(A);
ll Sa = 0, Sb = 0;
REP(i, N) {
if (i % 2 == 0) {
Sa += A[i].second.first;
} else {
Sb += A[i].second.second;
}
}
cout << Sa - Sb << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<ll> enum_div(ll n) {
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
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;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N;
cin >> N;
vector<pair<ll, pair<ll, ll>>> A(N);
REP(i, N) {
int a, b;
cin >> a >> b;
A[i].first = a + b;
A[i].second = {a, b};
}
RSORT(A);
ll Sa = 0, Sb = 0;
REP(i, N) {
if (i % 2 == 0) {
Sa += A[i].second.first;
} else {
Sb += A[i].second.second;
}
}
cout << Sa - Sb << endl;
return 0;
} | [
"identifier.change",
"call.function.change"
] | 941,039 | 941,040 | u303039933 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<ll> enum_div(ll n) {
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
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;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N;
cin >> N;
vector<pair<ll, pair<ll, ll>>> A(N);
REP(i, N) {
int a, b;
cin >> a >> b;
A[i].first = a + b;
A[i].second = {a, b};
}
SORT(A);
ll Sa = 0, Sb = 0;
FORR(i, N, 0) {
if (i % 2 == 0) {
Sa += A[i].second.first;
} else {
Sb += A[i].second.second;
}
}
cout << Sa - Sb << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<ll> enum_div(ll n) {
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
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;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N;
cin >> N;
vector<pair<ll, pair<ll, ll>>> A(N);
REP(i, N) {
int a, b;
cin >> a >> b;
A[i].first = a + b;
A[i].second = {a, b};
}
RSORT(A);
ll Sa = 0, Sb = 0;
REP(i, N) {
if (i % 2 == 0) {
Sa += A[i].second.first;
} else {
Sb += A[i].second.second;
}
}
cout << Sa - Sb << endl;
return 0;
} | [
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 941,041 | 941,040 | u303039933 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
ll sum = 0;
vector<ll> num(n);
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
num[i] = a + b;
sum += b;
}
sort(num.begin(), num.end());
ll ans = 0;
for (int i = 0; i < n; i += 2) {
ans += num[i];
}
cout << ans - sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
ll sum = 0;
vector<ll> num(n);
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
num[i] = a + b;
sum += b;
}
sort(num.rbegin(), num.rend());
ll ans = 0;
for (int i = 0; i < n; i += 2) {
ans += num[i];
}
cout << ans - sum << endl;
} | [
"call.function.change",
"call.arguments.change"
] | 941,046 | 941,047 | u351265848 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> ostream &operator<<(ostream &os, vector<T> &v) {
for (auto i = v.begin(); i != v.end(); i++) {
os << *i << " ";
}
return os;
}
void solve(long long N, std::vector<long long> A, std::vector<long long> B) {
vector<pair<ll, ll>> v;
ll t = 0;
ll a = 0;
for (ll i = 0; i < N; i++) {
v.push_back(make_pair(A[i] + B[i], i));
}
sort(v.begin(), v.end());
for (ll i = 0; i < N; i++) {
if (i % 2 == 0)
t += A[v[i].second];
else
a += B[v[i].second];
}
std::cout << t - a << std::endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> A(N);
std::vector<long long> B(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
}
solve(N, std::move(A), std::move(B));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> ostream &operator<<(ostream &os, vector<T> &v) {
for (auto i = v.begin(); i != v.end(); i++) {
os << *i << " ";
}
return os;
}
void solve(long long N, std::vector<long long> A, std::vector<long long> B) {
vector<pair<ll, ll>> v;
ll t = 0;
ll a = 0;
for (ll i = 0; i < N; i++) {
v.push_back(make_pair(A[i] + B[i], i));
}
sort(v.rbegin(), v.rend());
for (ll i = 0; i < N; i++) {
if (i % 2 == 0)
t += A[v[i].second];
else
a += B[v[i].second];
}
std::cout << t - a << std::endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> A(N);
std::vector<long long> B(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
}
solve(N, std::move(A), std::move(B));
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,054 | 941,055 | u131340563 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
typedef pair<ll, P> PP;
vector<PP> r;
ll a[100005];
ll b[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
r.push_back(PP(b[i] - a[i], P(a[i], i)));
}
sort(r.begin(), r.end());
ll ans = 0;
bool TorA = true;
for (int i = n - 1; i >= 0; i--) {
if (TorA)
ans += a[r[i].second.second];
else
ans -= b[r[i].second.second];
TorA = !TorA;
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
typedef pair<ll, P> PP;
vector<PP> r;
ll a[100005];
ll b[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
r.push_back(PP(b[i] + a[i], P(a[i], i)));
}
sort(r.begin(), r.end());
ll ans = 0;
bool TorA = true;
for (int i = n - 1; i >= 0; i--) {
if (TorA)
ans += a[r[i].second.second];
else
ans -= b[r[i].second.second];
TorA = !TorA;
}
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,059 | 941,060 | u126361752 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, N) for (int i = 0; i < (int)N; i++)
const ll MOD = pow(10, 9) + 7;
const ll LLINF = pow(2, 61) - 1;
const int INF = pow(2, 30) - 1;
typedef pair<ll, ll> p_ll;
int main() {
ll N;
cin >> N;
ll A[N], B[N];
rep(i, N) cin >> A[i] >> B[i];
p_ll dish[N];
rep(i, N) dish[i] = make_pair(A[i], B[i]);
sort(dish, dish + N, [](const p_ll &x, const p_ll &y) {
return x.first - x.second < y.first - y.second;
});
ll result = 0;
rep(i, N) result += A[i];
rep(i, N / 2) result -= dish[i * 2 + 1].first + dish[i * 2 + 1].second;
cout << result << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, N) for (int i = 0; i < (int)N; i++)
const ll MOD = pow(10, 9) + 7;
const ll LLINF = pow(2, 61) - 1;
const int INF = pow(2, 30) - 1;
typedef pair<ll, ll> p_ll;
int main() {
ll N;
cin >> N;
ll A[N], B[N];
rep(i, N) cin >> A[i] >> B[i];
p_ll dish[N];
rep(i, N) dish[i] = make_pair(A[i], B[i]);
sort(dish, dish + N, [](const p_ll &x, const p_ll &y) {
return x.first + x.second > y.first + y.second;
});
ll result = 0;
rep(i, N) result += A[i];
rep(i, N / 2) result -= dish[i * 2 + 1].first + dish[i * 2 + 1].second;
cout << result << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"expression.operator.compare.change"
] | 941,067 | 941,068 | u680707192 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define DUMP(x) std::cerr << (#x) << " = " << (x) << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define ALL(r) r.begin(), r.end()
#define YES puts("YES")
#define Yes puts("Yes")
#define NO puts("NO")
#define No puts("No")
#define IMP puts("IMPOSSIBLE")
#define Imp puts("Impossible")
#define imp puts("impossible")
#define M1 puts("-1")
#define pb push_back
template <typename T> T dup(T x, T y) { return (x + y - 1) / y; };
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using pll = pair<ll, ll>;
using setint = set<int32_t>;
using setstr = set<string>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
void Main() {
int n;
cin >> n;
vector<pll> ab(n);
rep(i, n) {
int a, b;
cin >> a >> b;
ab[i] = make_pair(a, b);
}
sort(ALL(ab), [](auto lhs, auto rhs) {
return lhs.first - lhs.second < rhs.first - rhs.second;
});
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += ab[i].first;
else
ans -= ab[i].second;
}
cout << ans << endl;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define DUMP(x) std::cerr << (#x) << " = " << (x) << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define ALL(r) r.begin(), r.end()
#define YES puts("YES")
#define Yes puts("Yes")
#define NO puts("NO")
#define No puts("No")
#define IMP puts("IMPOSSIBLE")
#define Imp puts("Impossible")
#define imp puts("impossible")
#define M1 puts("-1")
#define pb push_back
template <typename T> T dup(T x, T y) { return (x + y - 1) / y; };
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using pll = pair<ll, ll>;
using setint = set<int32_t>;
using setstr = set<string>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
void Main() {
int n;
cin >> n;
vector<pll> ab(n);
rep(i, n) {
int a, b;
cin >> a >> b;
ab[i] = make_pair(a, b);
}
sort(ALL(ab), [](auto lhs, auto rhs) {
return lhs.first + lhs.second > rhs.first + rhs.second;
});
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += ab[i].first;
else
ans -= ab[i].second;
}
cout << ans << endl;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"expression.operator.compare.change"
] | 941,076 | 941,077 | u664394831 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define DUMP(x) std::cerr << (#x) << " = " << (x) << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define ALL(r) r.begin(), r.end()
#define YES puts("YES")
#define Yes puts("Yes")
#define NO puts("NO")
#define No puts("No")
#define IMP puts("IMPOSSIBLE")
#define Imp puts("Impossible")
#define imp puts("impossible")
#define M1 puts("-1")
#define pb push_back
template <typename T> T dup(T x, T y) { return (x + y - 1) / y; };
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using pll = pair<ll, ll>;
using setint = set<int32_t>;
using setstr = set<string>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
void Main() {
int n;
cin >> n;
vector<pll> ab(n);
rep(i, n) {
int a, b;
cin >> a >> b;
ab[i] = make_pair(a, b);
}
sort(ALL(ab), [](auto lhs, auto rhs) {
return lhs.first + lhs.second < rhs.first + rhs.second;
});
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += ab[i].first;
else
ans -= ab[i].second;
}
cout << ans << endl;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define DUMP(x) std::cerr << (#x) << " = " << (x) << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define ALL(r) r.begin(), r.end()
#define YES puts("YES")
#define Yes puts("Yes")
#define NO puts("NO")
#define No puts("No")
#define IMP puts("IMPOSSIBLE")
#define Imp puts("Impossible")
#define imp puts("impossible")
#define M1 puts("-1")
#define pb push_back
template <typename T> T dup(T x, T y) { return (x + y - 1) / y; };
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using pll = pair<ll, ll>;
using setint = set<int32_t>;
using setstr = set<string>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
void Main() {
int n;
cin >> n;
vector<pll> ab(n);
rep(i, n) {
int a, b;
cin >> a >> b;
ab[i] = make_pair(a, b);
}
sort(ALL(ab), [](auto lhs, auto rhs) {
return lhs.first + lhs.second > rhs.first + rhs.second;
});
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += ab[i].first;
else
ans -= ab[i].second;
}
cout << ans << endl;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,078 | 941,077 | u664394831 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < n; i++)
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
int main() {
int N;
cin >> N;
priority_queue<tuple<ll, ll>> que;
vector<ll> iA, iB;
REP(i, N) {
ll A, B;
cin >> A >> B;
iA.push_back(A);
iB.push_back(B);
que.emplace(abs(A - B), i);
}
ll A = 0, B = 0;
REP(i, N) {
ll val, idx;
tie(val, idx) = que.top();
que.pop();
if (i % 2 == 0)
A += iA[idx];
if (i % 2 == 1)
B += iB[idx];
}
cout << A - B << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < n; i++)
template <class T>
using reversed_priority_queue = priority_queue<T, vector<T>, greater<T>>;
int main() {
int N;
cin >> N;
priority_queue<tuple<ll, ll>> que;
vector<ll> iA, iB;
REP(i, N) {
ll A, B;
cin >> A >> B;
iA.push_back(A);
iB.push_back(B);
que.emplace(A + B, i);
}
ll A = 0, B = 0;
REP(i, N) {
ll val, idx;
tie(val, idx) = que.top();
que.pop();
if (i % 2 == 0)
A += iA[idx];
if (i % 2 == 1)
B += iB[idx];
}
cout << A - B << endl;
return 0;
}
| [
"call.remove",
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,079 | 941,080 | u693386219 | cpp |
p03141 | #include <algorithm>
#include <cstring>
#include <iterator>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define MOD 1000000007
using namespace std;
int main(int argc, char *argv[]) {
long n;
scanf("%ld", &n);
vector<long> a(n), b(n);
vector<pair<long, long>> c(n);
long i;
for (i = 0; i < n; i++) {
scanf("%ld%ld", &a[i], &b[i]);
c[i] = make_pair(a[i] + b[i], i);
}
sort(c.begin(), c.end());
ll sum = 0;
for (i = n - 1; i >= 0; i--) {
if (i % 2 == 0)
sum += a[c[i].second];
else
sum -= b[c[i].second];
}
printf("%lld\n", sum);
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iterator>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define MOD 1000000007
using namespace std;
int main(int argc, char *argv[]) {
long n;
scanf("%ld", &n);
vector<long> a(n), b(n);
vector<pair<long, long>> c(n);
long i;
for (i = 0; i < n; i++) {
scanf("%ld%ld", &a[i], &b[i]);
c[i] = make_pair(a[i] + b[i], i);
}
sort(c.begin(), c.end());
ll sum = 0;
for (i = n - 1; i >= 0; i--) {
if ((n - 1 + i) % 2 == 0)
sum += a[c[i].second];
else
sum -= b[c[i].second];
}
printf("%lld\n", sum);
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,081 | 941,082 | u209713918 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
const long long MOD = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<ld, ll> pdl;
typedef pair<ld, ld> pdd;
// typedef boost::multiprecision::cpp_int bigint;
ll N;
vector<ll> A;
int main() {
cin >> N;
A.resize(N);
ll asum = 0;
for (ll n = 0; n < N; n++) {
ll a, b;
cin >> a >> b;
asum += a;
A[n] = a + b;
}
sort(A.begin(), A.end(), [](ll a, ll b) { return a < b; });
for (ll n = 1; n < N; n += 2) {
asum -= A[n];
}
cout << asum << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
const long long MOD = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<ld, ll> pdl;
typedef pair<ld, ld> pdd;
// typedef boost::multiprecision::cpp_int bigint;
ll N;
vector<ll> A;
int main() {
cin >> N;
A.resize(N);
ll asum = 0;
for (ll n = 0; n < N; n++) {
ll a, b;
cin >> a >> b;
asum += a;
A[n] = a + b;
}
sort(A.begin(), A.end(), [](ll a, ll b) { return a > b; });
for (ll n = 1; n < N; n += 2) {
asum -= A[n];
}
cout << asum << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,085 | 941,086 | u457790148 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int mod = 1e9 + 7;
const int MAX = 510000;
const int V = 100005;
ll dy[8] = {1, 0, -1, 0, 1, -1, 1, -1};
ll dx[8] = {0, 1, 0, -1, 1, -1, -1, 1};
const double pi = acos(-1);
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << endl;
}
int main() {
ll n;
cin >> n;
vector<tuple<ll, ll, ll>> v(n);
rep(i, n) {
ll a, b, c;
cin >> a >> b;
c = b - a;
v[i] = tie(c, a, b);
}
sort(rall(v));
ll ta = 0, ao = 0;
for (ll i = 0; i < n; i += 2) {
ll a, b;
tie(ignore, a, b) = v[i];
ta += a;
if (i == n - 1)
break;
tie(ignore, a, b) = v[i + 1];
ao += b;
}
cout << ta - ao << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int mod = 1e9 + 7;
const int MAX = 510000;
const int V = 100005;
ll dy[8] = {1, 0, -1, 0, 1, -1, 1, -1};
ll dx[8] = {0, 1, 0, -1, 1, -1, -1, 1};
const double pi = acos(-1);
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << endl;
}
int main() {
ll n;
cin >> n;
vector<tuple<ll, ll, ll>> v(n);
rep(i, n) {
ll a, b, c;
cin >> a >> b;
c = b + a;
v[i] = tie(c, a, b);
}
sort(rall(v));
ll ta = 0, ao = 0;
for (ll i = 0; i < n; i += 2) {
ll a, b;
tie(ignore, a, b) = v[i];
ta += a;
if (i == n - 1)
break;
tie(ignore, a, b) = v[i + 1];
ao += b;
}
cout << ta - ao << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,091 | 941,092 | u242679311 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
int B, C, ans = 0, sum = 0;
for (int i = 0; i < N; i++) {
cin >> B >> C;
A.at(i) = B + C;
ans += C;
}
sort(A.begin(), A.end(), greater<long long>());
for (int i = 0; i < N; i += 2) {
sum += A.at(i);
}
cout << sum - ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
long long B, C, ans = 0, sum = 0;
for (int i = 0; i < N; i++) {
cin >> B >> C;
A.at(i) = B + C;
ans += C;
}
sort(A.begin(), A.end(), greater<long long>());
for (int i = 0; i < N; i += 2) {
sum += A.at(i);
}
cout << sum - ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 941,095 | 941,096 | u815026012 | cpp |
p03141 | /*
URL https://
SCORE 0
AC false
WA false
TLE false
MLE false
TASK_TYPE
FAILURE_TYPE
NOTES
*/
#include <algorithm>
#include <cstdint>
#include <experimental/optional>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
/* import STL */
// stream
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::flush;
// basic types
using std::nullptr_t;
using std::pair;
using std::string;
using std::tuple;
using std::experimental::optional;
// function for basic types
using std::get;
using std::make_pair;
using std::make_tuple;
using std::experimental::make_optional;
/* TODO remove them */
using std::queue;
using std::stack;
using std::vector;
// algorithms
using std::accumulate;
using std::lower_bound;
using std::max_element;
using std::min_element;
using std::nth_element;
using std::upper_bound;
/* macros */
// loops
#define REP(i, n) for (i64 i = 0; i < static_cast<decltype(i)>(n); ++i)
#define REPR(i, n) for (i64 i = (n)-1; i >= static_cast<decltype(i)>(0); --i)
#define FOR(i, n, m) for (i64 i = (n); i < static_cast<decltype(i)>(m); ++i)
#define FORR(i, n, m) for (i64 i = (m)-1; i >= static_cast<decltype(i)>(n); --i)
#define EACH(x, xs) for (auto &x : (xs))
#define EACH_V(x, xs) for (auto x : (xs))
// helpers
#define CTR(x) (x).begin(), (x).end()
/* utils for std::tuple */
namespace internal {
namespace tuple_utils { // TODO rename to "internal::tuple"
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Tuple, size_t... Is>
void read(std::istream &stream, Tuple &t, seq<Is...>) {
static_cast<void>((int[]){0, (void(stream >> get<Is>(t)), 0)...});
}
template <class Tuple, size_t... Is>
void print(std::ostream &stream, Tuple const &t, seq<Is...>) {
static_cast<void>(
(int[]){0, (void(stream << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...});
}
template <size_t I, class F, class A, class... Elems> struct ForEach {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
void operator()(A &arg, tuple<Elems...> &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
};
template <class F, class A, class... Elems> struct ForEach<0, F, A, Elems...> {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<0>(t));
}
void operator()(A &arg, tuple<Elems...> &t) const { F()(arg, get<0>(t)); }
};
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> const &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
} // namespace tuple_utils
} // namespace internal
/* utils for Matrix (definition of Matrix) */
namespace internal {
namespace matrix {
template <typename V, int N> struct matrix_t {
using type = std::vector<typename matrix_t<V, N - 1>::type>;
};
template <typename V> struct matrix_t<V, 0> { using type = V; };
template <typename V, int N> using Matrix = typename matrix_t<V, N>::type;
template <typename V, typename It, int N> struct matrix_helper {
static Matrix<V, N> create(const It &begin, const It &end,
const V &default_value) {
return Matrix<V, N>(*begin, matrix_helper<V, It, N - 1>::create(
begin + 1, end, default_value));
}
};
template <typename V, typename It> struct matrix_helper<V, It, 0> {
static Matrix<V, 0> create(const It &begin __attribute__((unused)),
const It &end __attribute__((unused)),
const V &default_value) {
return default_value;
}
};
} // namespace matrix
} // namespace internal
/* Primitive types */
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using usize = size_t;
/* Data structure type */
template <typename T> using Vector = std::vector<T>;
template <typename V> using OrderedSet = std::set<V>;
template <typename V> using HashSet = std::unordered_set<V>;
template <typename K, typename V> using OrderedMap = std::map<K, V>;
template <typename K, typename V> using HashMap = std::unordered_map<K, V>;
template <typename T, int N> using Matrix = internal::matrix::Matrix<T, N>;
template <typename T, typename Compare = std::less<T>,
typename Container = std::vector<T>>
using PriorityQueue = std::priority_queue<T, Container, Compare>;
/* utils for Vector */
template <typename V> Vector<V> make_pre_allocated_vector(size_t N) {
Vector<V> retval;
retval.reserve(N);
return retval;
}
/* utils for Matrix */
template <class V, int N>
Matrix<V, N> make_matrix(const std::array<size_t, N> &shape,
V default_value = V()) {
return internal::matrix::matrix_helper<V, decltype(shape.begin()), N>::create(
shape.begin(), shape.end(), default_value);
}
/* utils for STL iterators */
namespace internal {
template <typename Iterator, typename F> struct MappedIterator {
MappedIterator(const Iterator &it, const F &function)
: it(it), function(function) {}
auto operator*() const { return this->function(this->it); }
void operator++() { ++this->it; }
void operator+=(size_t n) { this->it += n; }
auto operator+(size_t n) const {
return MappedIterator<Iterator, F>(this->it + n, this->function);
}
bool operator==(const MappedIterator<Iterator, F> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const MappedIterator<Iterator, F> &rhs) const {
return !(*this == rhs);
}
private:
Iterator it;
F function;
};
template <typename Iterator, typename P> struct FilteredIterator {
FilteredIterator(const Iterator &it, const Iterator &end, const P &predicate)
: it(it), end(end), predicate(predicate) {
if (this->it != end) {
if (!predicate(this->it)) {
this->increment();
}
}
}
decltype(auto) operator*() const { return *this->it; }
auto operator->() const { return this->it; }
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool operator==(const FilteredIterator<Iterator, P> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const FilteredIterator<Iterator, P> &rhs) const {
return !(*this == rhs);
}
private:
void increment() {
if (this->it == this->end) {
return;
}
++this->it;
while (this->it != this->end && !this->predicate(this->it)) {
++this->it;
}
}
Iterator it;
Iterator end;
P predicate;
};
template <typename Iterator, typename ElementIterator>
struct FlattenedIterator {
FlattenedIterator(const Iterator &it, const Iterator &end)
: it(make_pair(it, ElementIterator())), end(end) {
if (this->it.first != this->end) {
this->it.second = it->begin();
}
this->find_valid();
}
decltype(auto) operator*() const { return this->it; }
const pair<Iterator, ElementIterator> *operator->() const {
return &this->it;
}
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool
operator==(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
if (this->it.first != rhs.it.first) {
return false;
}
if (this->it.first == this->end || rhs.it.first == rhs.end) {
if (this->end == rhs.end) {
return true;
} else {
return false;
}
} else {
return this->it.second == rhs.it.second;
}
}
bool
operator!=(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
return !(*this == rhs);
}
private:
bool is_end() const { return this->it.first == this->end; }
bool is_valid() const {
if (this->is_end())
return false;
if (this->it.second == this->it.first->end())
return false;
return true;
}
void _increment() {
if (this->it.second == this->it.first->end()) {
++this->it.first;
if (this->it.first != this->end) {
this->it.second = this->it.first->begin();
}
} else {
++this->it.second;
}
}
void find_valid() {
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
void increment() {
this->_increment();
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
pair<Iterator, ElementIterator> it;
Iterator end;
};
} // namespace internal
template <class Iterator> struct Container {
Container(const Iterator &begin, const Iterator &end)
: m_begin(begin), m_end(end) {}
const Iterator &begin() const { return this->m_begin; }
const Iterator &end() const { return this->m_end; }
Iterator m_begin;
Iterator m_end;
};
template <typename C, typename F> auto iterator_map(const C &c, F function) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::MappedIterator<Iterator, F>>(
internal::MappedIterator<Iterator, F>(c.begin(), function),
internal::MappedIterator<Iterator, F>(c.end(), function));
}
template <typename C, typename P>
auto iterator_filter(const C &c, P predicate) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::FilteredIterator<Iterator, P>>(
internal::FilteredIterator<Iterator, P>(c.begin(), c.end(), predicate),
internal::FilteredIterator<Iterator, P>(c.end(), c.end(), predicate));
}
template <typename C> auto iterator_flatten(const C &c) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
using ElementIterator = std::remove_const_t<
std::remove_reference_t<decltype(c.begin()->begin())>>;
return Container<internal::FlattenedIterator<Iterator, ElementIterator>>(
internal::FlattenedIterator<Iterator, ElementIterator>(c.begin(),
c.end()),
internal::FlattenedIterator<Iterator, ElementIterator>(c.end(), c.end()));
}
/* input */
template <class F, class S>
std::istream &operator>>(std::istream &stream, pair<F, S> &pair) {
stream >> pair.first;
stream >> pair.second;
return stream;
}
template <class... Args>
std::istream &operator>>(std::istream &stream, tuple<Args...> &tuple) {
internal::tuple_utils::read(
stream, tuple, internal::tuple_utils::gen_seq<sizeof...(Args)>());
return stream;
}
template <class T> T read() {
T t;
cin >> t;
return t;
}
template <class F, class S> pair<F, S> read() {
pair<F, S> p;
cin >> p;
return p;
}
template <class T1, class T2, class T3, class... Args>
tuple<T1, T2, T3, Args...> read() {
tuple<T1, T2, T3, Args...> t;
cin >> t;
return t;
}
template <typename T, typename F = std::function<T()>>
Vector<T> read(const usize length, F r) {
auto retval = make_pre_allocated_vector<T>(length);
REP(i, length) { retval.emplace_back(r()); }
return retval;
}
template <class T> Vector<T> read(const usize length) {
return read<T>(length, [] { return read<T>(); });
}
template <class F, class S> Vector<pair<F, S>> read(const usize length) {
return read<pair<F, S>>(length);
}
template <class T1, class T2, class T3, class... Args>
Vector<tuple<T1, T2, T3, Args...>> read(const usize length) {
return read<tuple<T1, T2, T3, Args...>>(length);
}
namespace internal {
template <typename T> struct oneline {
std::string operator()(const T &t) const {
std::ostringstream oss;
oss << t;
return oss.str();
}
};
template <typename F, typename S> struct oneline<pair<F, S>> {
std::string operator()(const pair<F, S> &p) const {
std::ostringstream oss;
oss << "{" << oneline<F>()(p.first) << ", " << oneline<S>()(p.second)
<< "}";
return oss.str();
}
};
template <typename... Args> struct oneline<tuple<Args...>> {
struct oneline_tuple {
template <class V>
void operator()(Vector<std::string> &strs, const V &v) const {
strs.emplace_back(oneline<V>()(v));
}
};
std::string operator()(const tuple<Args...> &t) const {
std::ostringstream oss;
Vector<std::string> strs;
internal::tuple_utils::for_each<oneline_tuple, Vector<std::string>,
Args...>(strs, t);
oss << "{";
REPR(i, strs.size()) {
oss << strs[i];
if (i != 0) {
oss << ", ";
}
}
oss << "}";
return oss.str();
}
};
template <> struct oneline<bool> {
std::string operator()(const bool b) const { return b ? "true" : "false"; }
};
template <typename X> struct oneline<Vector<X>> {
std::string operator()(const Vector<X> &vec) const {
std::string retval = "[";
auto f = oneline<X>();
REP(i, vec.size()) {
retval += f(vec[i]);
if (i != static_cast<i64>(vec.size() - 1)) {
retval += ", ";
}
}
retval += "]";
return retval;
}
};
template <typename X> struct oneline<OrderedSet<X>> {
std::string operator()(const OrderedSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename X> struct oneline<HashSet<X>> {
std::string operator()(const HashSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<OrderedMap<K, V>> {
std::string operator()(const OrderedMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<HashMap<K, V>> {
std::string operator()(const HashMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename V> struct keys { /* no implementation */
};
template <typename X> struct keys<std::vector<X>> {
Vector<size_t> operator()(const Vector<X> &v) const {
Vector<size_t> keys;
REP(i, v.size()) { keys.emplace_back(i); }
return keys;
}
};
template <typename K, typename V> struct keys<OrderedMap<K, V>> {
Vector<K> operator()(const OrderedMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
template <typename K, typename V> struct keys<HashMap<K, V>> {
Vector<K> operator()(const HashMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
} // namespace internal
template <typename T> void dump(const T &t) {
using namespace internal;
std::cerr << oneline<T>()(t) << std::endl;
}
template <typename V1, typename V2, typename... Args>
void dump(const V1 &v1, const V2 &v2, const Args &...args) {
using namespace internal;
using F = typename oneline<tuple<V1, V2, Args...>>::oneline_tuple;
auto x = std::make_tuple(v1, v2, args...);
Vector<std::string> strs;
internal::tuple_utils::for_each<F, Vector<std::string>, V1, V2, Args...>(strs,
x);
REPR(i, strs.size()) {
std::cerr << strs[i];
if (i != 0) {
std::cerr << ", ";
}
}
std::cerr << std::endl;
}
template <typename C> std::string as_set(const C &ctr) {
Vector<std::string> values;
using namespace internal;
EACH(x, ctr) { values.emplace_back(oneline<decltype(x)>()(x)); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_map(const C &ctr) {
using namespace internal;
auto ks = keys<C>()(ctr);
Vector<std::string> keys;
Vector<std::string> values;
EACH(key, ks) {
keys.emplace_back(oneline<decltype(key)>()(key));
values.emplace_back(oneline<decltype(ctr.at(key))>()(ctr.at(key)));
}
size_t l = 0;
EACH(key, keys) { l = std::max(l, key.size()); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += keys[i];
REP(j, l - keys[i].size()) { retval += " "; }
retval += ": ";
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_table(const C &ctr) {
using namespace internal;
auto rkeys = keys<C>()(ctr);
auto ckeys = OrderedSet<std::string>();
auto values =
Vector<pair<std::string, OrderedMap<std::string, std::string>>>();
/* Stringify all data */
EACH(rkey, rkeys) {
auto rkey_str = oneline<decltype(rkey)>()(rkey);
values.emplace_back(rkey_str, OrderedMap<std::string, std::string>());
auto row = ctr.at(rkey);
auto ks = keys<decltype(row)>()(row);
EACH(ckey, ks) {
auto ckey_str = oneline<decltype(ckey)>()(ckey);
ckeys.emplace(ckey_str);
values.back().second.emplace(
ckey_str, oneline<decltype(row.at(ckey))>()(row.at(ckey)));
}
}
/* Calculate string length */
size_t max_row_key_length = 0;
EACH(value, values) {
max_row_key_length = std::max(max_row_key_length, value.first.size());
}
OrderedMap<std::string, size_t> max_col_length;
EACH(ckey, ckeys) { max_col_length.emplace(ckey, ckey.size()); }
EACH(value, values) {
EACH(elem, value.second) {
auto ckey = elem.first;
auto value = elem.second;
max_col_length[ckey] = std::max(max_col_length[ckey], value.size());
}
}
std::string retval = "---\n";
/* Header */
REP(i, max_row_key_length) { retval += " "; }
retval += " ";
size_t cnt = 0;
EACH(ckey, ckeys) {
retval += ckey;
REP(j, max_col_length[ckey] - ckey.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n------\n";
/* Values */
EACH(value, values) {
retval += value.first;
REP(i, max_row_key_length - value.first.size()) { retval += " "; }
retval += "| ";
size_t cnt = 0;
EACH(ckey, ckeys) {
auto v = std::string("");
if (value.second.find(ckey) != value.second.end()) {
v = value.second.at(ckey);
}
retval += v;
REP(j, max_col_length[ckey] - v.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n";
}
retval += "---";
return retval;
}
// Hash
namespace std {
template <class F, class S> struct hash<pair<F, S>> {
size_t operator()(const pair<F, S> &p) const {
return hash<F>()(p.first) ^ hash<S>()(p.second);
}
};
template <class... Args> struct hash<tuple<Args...>> {
struct hash_for_element {
template <class V> void operator()(size_t &size, const V &v) const {
size ^= std::hash<V>()(v);
}
};
size_t operator()(const tuple<Args...> &t) const {
size_t retval = 0;
internal::tuple_utils::for_each<hash_for_element, size_t, Args...>(retval,
t);
return retval;
}
};
} // namespace std
#define MAIN
void body();
// main function (DO NOT EDIT)
int main(int argc, char **argv) {
cin.tie(0);
std::ios_base::sync_with_stdio(false);
cout << std::fixed;
body();
return 0;
}
void body() {
auto N = read<i64>();
auto ABs = read<i64, i64>(N);
sort(CTR(ABs), [](auto lhs, auto rhs) {
return lhs.first + lhs.second > rhs.first + lhs.second;
});
i64 ans = 0;
REP(i, N) {
if (i % 2 == 0) {
ans += ABs[i].first;
} else {
ans -= ABs[i].second;
}
}
cout << ans << endl;
}
| /*
URL https://
SCORE 0
AC false
WA false
TLE false
MLE false
TASK_TYPE
FAILURE_TYPE
NOTES
*/
#include <algorithm>
#include <cstdint>
#include <experimental/optional>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
/* import STL */
// stream
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::flush;
// basic types
using std::nullptr_t;
using std::pair;
using std::string;
using std::tuple;
using std::experimental::optional;
// function for basic types
using std::get;
using std::make_pair;
using std::make_tuple;
using std::experimental::make_optional;
/* TODO remove them */
using std::queue;
using std::stack;
using std::vector;
// algorithms
using std::accumulate;
using std::lower_bound;
using std::max_element;
using std::min_element;
using std::nth_element;
using std::upper_bound;
/* macros */
// loops
#define REP(i, n) for (i64 i = 0; i < static_cast<decltype(i)>(n); ++i)
#define REPR(i, n) for (i64 i = (n)-1; i >= static_cast<decltype(i)>(0); --i)
#define FOR(i, n, m) for (i64 i = (n); i < static_cast<decltype(i)>(m); ++i)
#define FORR(i, n, m) for (i64 i = (m)-1; i >= static_cast<decltype(i)>(n); --i)
#define EACH(x, xs) for (auto &x : (xs))
#define EACH_V(x, xs) for (auto x : (xs))
// helpers
#define CTR(x) (x).begin(), (x).end()
/* utils for std::tuple */
namespace internal {
namespace tuple_utils { // TODO rename to "internal::tuple"
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Tuple, size_t... Is>
void read(std::istream &stream, Tuple &t, seq<Is...>) {
static_cast<void>((int[]){0, (void(stream >> get<Is>(t)), 0)...});
}
template <class Tuple, size_t... Is>
void print(std::ostream &stream, Tuple const &t, seq<Is...>) {
static_cast<void>(
(int[]){0, (void(stream << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...});
}
template <size_t I, class F, class A, class... Elems> struct ForEach {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
void operator()(A &arg, tuple<Elems...> &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
};
template <class F, class A, class... Elems> struct ForEach<0, F, A, Elems...> {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<0>(t));
}
void operator()(A &arg, tuple<Elems...> &t) const { F()(arg, get<0>(t)); }
};
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> const &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
} // namespace tuple_utils
} // namespace internal
/* utils for Matrix (definition of Matrix) */
namespace internal {
namespace matrix {
template <typename V, int N> struct matrix_t {
using type = std::vector<typename matrix_t<V, N - 1>::type>;
};
template <typename V> struct matrix_t<V, 0> { using type = V; };
template <typename V, int N> using Matrix = typename matrix_t<V, N>::type;
template <typename V, typename It, int N> struct matrix_helper {
static Matrix<V, N> create(const It &begin, const It &end,
const V &default_value) {
return Matrix<V, N>(*begin, matrix_helper<V, It, N - 1>::create(
begin + 1, end, default_value));
}
};
template <typename V, typename It> struct matrix_helper<V, It, 0> {
static Matrix<V, 0> create(const It &begin __attribute__((unused)),
const It &end __attribute__((unused)),
const V &default_value) {
return default_value;
}
};
} // namespace matrix
} // namespace internal
/* Primitive types */
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using usize = size_t;
/* Data structure type */
template <typename T> using Vector = std::vector<T>;
template <typename V> using OrderedSet = std::set<V>;
template <typename V> using HashSet = std::unordered_set<V>;
template <typename K, typename V> using OrderedMap = std::map<K, V>;
template <typename K, typename V> using HashMap = std::unordered_map<K, V>;
template <typename T, int N> using Matrix = internal::matrix::Matrix<T, N>;
template <typename T, typename Compare = std::less<T>,
typename Container = std::vector<T>>
using PriorityQueue = std::priority_queue<T, Container, Compare>;
/* utils for Vector */
template <typename V> Vector<V> make_pre_allocated_vector(size_t N) {
Vector<V> retval;
retval.reserve(N);
return retval;
}
/* utils for Matrix */
template <class V, int N>
Matrix<V, N> make_matrix(const std::array<size_t, N> &shape,
V default_value = V()) {
return internal::matrix::matrix_helper<V, decltype(shape.begin()), N>::create(
shape.begin(), shape.end(), default_value);
}
/* utils for STL iterators */
namespace internal {
template <typename Iterator, typename F> struct MappedIterator {
MappedIterator(const Iterator &it, const F &function)
: it(it), function(function) {}
auto operator*() const { return this->function(this->it); }
void operator++() { ++this->it; }
void operator+=(size_t n) { this->it += n; }
auto operator+(size_t n) const {
return MappedIterator<Iterator, F>(this->it + n, this->function);
}
bool operator==(const MappedIterator<Iterator, F> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const MappedIterator<Iterator, F> &rhs) const {
return !(*this == rhs);
}
private:
Iterator it;
F function;
};
template <typename Iterator, typename P> struct FilteredIterator {
FilteredIterator(const Iterator &it, const Iterator &end, const P &predicate)
: it(it), end(end), predicate(predicate) {
if (this->it != end) {
if (!predicate(this->it)) {
this->increment();
}
}
}
decltype(auto) operator*() const { return *this->it; }
auto operator->() const { return this->it; }
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool operator==(const FilteredIterator<Iterator, P> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const FilteredIterator<Iterator, P> &rhs) const {
return !(*this == rhs);
}
private:
void increment() {
if (this->it == this->end) {
return;
}
++this->it;
while (this->it != this->end && !this->predicate(this->it)) {
++this->it;
}
}
Iterator it;
Iterator end;
P predicate;
};
template <typename Iterator, typename ElementIterator>
struct FlattenedIterator {
FlattenedIterator(const Iterator &it, const Iterator &end)
: it(make_pair(it, ElementIterator())), end(end) {
if (this->it.first != this->end) {
this->it.second = it->begin();
}
this->find_valid();
}
decltype(auto) operator*() const { return this->it; }
const pair<Iterator, ElementIterator> *operator->() const {
return &this->it;
}
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool
operator==(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
if (this->it.first != rhs.it.first) {
return false;
}
if (this->it.first == this->end || rhs.it.first == rhs.end) {
if (this->end == rhs.end) {
return true;
} else {
return false;
}
} else {
return this->it.second == rhs.it.second;
}
}
bool
operator!=(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
return !(*this == rhs);
}
private:
bool is_end() const { return this->it.first == this->end; }
bool is_valid() const {
if (this->is_end())
return false;
if (this->it.second == this->it.first->end())
return false;
return true;
}
void _increment() {
if (this->it.second == this->it.first->end()) {
++this->it.first;
if (this->it.first != this->end) {
this->it.second = this->it.first->begin();
}
} else {
++this->it.second;
}
}
void find_valid() {
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
void increment() {
this->_increment();
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
pair<Iterator, ElementIterator> it;
Iterator end;
};
} // namespace internal
template <class Iterator> struct Container {
Container(const Iterator &begin, const Iterator &end)
: m_begin(begin), m_end(end) {}
const Iterator &begin() const { return this->m_begin; }
const Iterator &end() const { return this->m_end; }
Iterator m_begin;
Iterator m_end;
};
template <typename C, typename F> auto iterator_map(const C &c, F function) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::MappedIterator<Iterator, F>>(
internal::MappedIterator<Iterator, F>(c.begin(), function),
internal::MappedIterator<Iterator, F>(c.end(), function));
}
template <typename C, typename P>
auto iterator_filter(const C &c, P predicate) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::FilteredIterator<Iterator, P>>(
internal::FilteredIterator<Iterator, P>(c.begin(), c.end(), predicate),
internal::FilteredIterator<Iterator, P>(c.end(), c.end(), predicate));
}
template <typename C> auto iterator_flatten(const C &c) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
using ElementIterator = std::remove_const_t<
std::remove_reference_t<decltype(c.begin()->begin())>>;
return Container<internal::FlattenedIterator<Iterator, ElementIterator>>(
internal::FlattenedIterator<Iterator, ElementIterator>(c.begin(),
c.end()),
internal::FlattenedIterator<Iterator, ElementIterator>(c.end(), c.end()));
}
/* input */
template <class F, class S>
std::istream &operator>>(std::istream &stream, pair<F, S> &pair) {
stream >> pair.first;
stream >> pair.second;
return stream;
}
template <class... Args>
std::istream &operator>>(std::istream &stream, tuple<Args...> &tuple) {
internal::tuple_utils::read(
stream, tuple, internal::tuple_utils::gen_seq<sizeof...(Args)>());
return stream;
}
template <class T> T read() {
T t;
cin >> t;
return t;
}
template <class F, class S> pair<F, S> read() {
pair<F, S> p;
cin >> p;
return p;
}
template <class T1, class T2, class T3, class... Args>
tuple<T1, T2, T3, Args...> read() {
tuple<T1, T2, T3, Args...> t;
cin >> t;
return t;
}
template <typename T, typename F = std::function<T()>>
Vector<T> read(const usize length, F r) {
auto retval = make_pre_allocated_vector<T>(length);
REP(i, length) { retval.emplace_back(r()); }
return retval;
}
template <class T> Vector<T> read(const usize length) {
return read<T>(length, [] { return read<T>(); });
}
template <class F, class S> Vector<pair<F, S>> read(const usize length) {
return read<pair<F, S>>(length);
}
template <class T1, class T2, class T3, class... Args>
Vector<tuple<T1, T2, T3, Args...>> read(const usize length) {
return read<tuple<T1, T2, T3, Args...>>(length);
}
namespace internal {
template <typename T> struct oneline {
std::string operator()(const T &t) const {
std::ostringstream oss;
oss << t;
return oss.str();
}
};
template <typename F, typename S> struct oneline<pair<F, S>> {
std::string operator()(const pair<F, S> &p) const {
std::ostringstream oss;
oss << "{" << oneline<F>()(p.first) << ", " << oneline<S>()(p.second)
<< "}";
return oss.str();
}
};
template <typename... Args> struct oneline<tuple<Args...>> {
struct oneline_tuple {
template <class V>
void operator()(Vector<std::string> &strs, const V &v) const {
strs.emplace_back(oneline<V>()(v));
}
};
std::string operator()(const tuple<Args...> &t) const {
std::ostringstream oss;
Vector<std::string> strs;
internal::tuple_utils::for_each<oneline_tuple, Vector<std::string>,
Args...>(strs, t);
oss << "{";
REPR(i, strs.size()) {
oss << strs[i];
if (i != 0) {
oss << ", ";
}
}
oss << "}";
return oss.str();
}
};
template <> struct oneline<bool> {
std::string operator()(const bool b) const { return b ? "true" : "false"; }
};
template <typename X> struct oneline<Vector<X>> {
std::string operator()(const Vector<X> &vec) const {
std::string retval = "[";
auto f = oneline<X>();
REP(i, vec.size()) {
retval += f(vec[i]);
if (i != static_cast<i64>(vec.size() - 1)) {
retval += ", ";
}
}
retval += "]";
return retval;
}
};
template <typename X> struct oneline<OrderedSet<X>> {
std::string operator()(const OrderedSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename X> struct oneline<HashSet<X>> {
std::string operator()(const HashSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<OrderedMap<K, V>> {
std::string operator()(const OrderedMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<HashMap<K, V>> {
std::string operator()(const HashMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename V> struct keys { /* no implementation */
};
template <typename X> struct keys<std::vector<X>> {
Vector<size_t> operator()(const Vector<X> &v) const {
Vector<size_t> keys;
REP(i, v.size()) { keys.emplace_back(i); }
return keys;
}
};
template <typename K, typename V> struct keys<OrderedMap<K, V>> {
Vector<K> operator()(const OrderedMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
template <typename K, typename V> struct keys<HashMap<K, V>> {
Vector<K> operator()(const HashMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
} // namespace internal
template <typename T> void dump(const T &t) {
using namespace internal;
std::cerr << oneline<T>()(t) << std::endl;
}
template <typename V1, typename V2, typename... Args>
void dump(const V1 &v1, const V2 &v2, const Args &...args) {
using namespace internal;
using F = typename oneline<tuple<V1, V2, Args...>>::oneline_tuple;
auto x = std::make_tuple(v1, v2, args...);
Vector<std::string> strs;
internal::tuple_utils::for_each<F, Vector<std::string>, V1, V2, Args...>(strs,
x);
REPR(i, strs.size()) {
std::cerr << strs[i];
if (i != 0) {
std::cerr << ", ";
}
}
std::cerr << std::endl;
}
template <typename C> std::string as_set(const C &ctr) {
Vector<std::string> values;
using namespace internal;
EACH(x, ctr) { values.emplace_back(oneline<decltype(x)>()(x)); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_map(const C &ctr) {
using namespace internal;
auto ks = keys<C>()(ctr);
Vector<std::string> keys;
Vector<std::string> values;
EACH(key, ks) {
keys.emplace_back(oneline<decltype(key)>()(key));
values.emplace_back(oneline<decltype(ctr.at(key))>()(ctr.at(key)));
}
size_t l = 0;
EACH(key, keys) { l = std::max(l, key.size()); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += keys[i];
REP(j, l - keys[i].size()) { retval += " "; }
retval += ": ";
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_table(const C &ctr) {
using namespace internal;
auto rkeys = keys<C>()(ctr);
auto ckeys = OrderedSet<std::string>();
auto values =
Vector<pair<std::string, OrderedMap<std::string, std::string>>>();
/* Stringify all data */
EACH(rkey, rkeys) {
auto rkey_str = oneline<decltype(rkey)>()(rkey);
values.emplace_back(rkey_str, OrderedMap<std::string, std::string>());
auto row = ctr.at(rkey);
auto ks = keys<decltype(row)>()(row);
EACH(ckey, ks) {
auto ckey_str = oneline<decltype(ckey)>()(ckey);
ckeys.emplace(ckey_str);
values.back().second.emplace(
ckey_str, oneline<decltype(row.at(ckey))>()(row.at(ckey)));
}
}
/* Calculate string length */
size_t max_row_key_length = 0;
EACH(value, values) {
max_row_key_length = std::max(max_row_key_length, value.first.size());
}
OrderedMap<std::string, size_t> max_col_length;
EACH(ckey, ckeys) { max_col_length.emplace(ckey, ckey.size()); }
EACH(value, values) {
EACH(elem, value.second) {
auto ckey = elem.first;
auto value = elem.second;
max_col_length[ckey] = std::max(max_col_length[ckey], value.size());
}
}
std::string retval = "---\n";
/* Header */
REP(i, max_row_key_length) { retval += " "; }
retval += " ";
size_t cnt = 0;
EACH(ckey, ckeys) {
retval += ckey;
REP(j, max_col_length[ckey] - ckey.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n------\n";
/* Values */
EACH(value, values) {
retval += value.first;
REP(i, max_row_key_length - value.first.size()) { retval += " "; }
retval += "| ";
size_t cnt = 0;
EACH(ckey, ckeys) {
auto v = std::string("");
if (value.second.find(ckey) != value.second.end()) {
v = value.second.at(ckey);
}
retval += v;
REP(j, max_col_length[ckey] - v.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n";
}
retval += "---";
return retval;
}
// Hash
namespace std {
template <class F, class S> struct hash<pair<F, S>> {
size_t operator()(const pair<F, S> &p) const {
return hash<F>()(p.first) ^ hash<S>()(p.second);
}
};
template <class... Args> struct hash<tuple<Args...>> {
struct hash_for_element {
template <class V> void operator()(size_t &size, const V &v) const {
size ^= std::hash<V>()(v);
}
};
size_t operator()(const tuple<Args...> &t) const {
size_t retval = 0;
internal::tuple_utils::for_each<hash_for_element, size_t, Args...>(retval,
t);
return retval;
}
};
} // namespace std
#define MAIN
void body();
// main function (DO NOT EDIT)
int main(int argc, char **argv) {
cin.tie(0);
std::ios_base::sync_with_stdio(false);
cout << std::fixed;
body();
return 0;
}
void body() {
auto N = read<i64>();
auto ABs = read<i64, i64>(N);
sort(CTR(ABs), [](auto lhs, auto rhs) {
return lhs.first + lhs.second > rhs.first + rhs.second;
});
i64 ans = 0;
REP(i, N) {
if (i % 2 == 0) {
ans += ABs[i].first;
} else {
ans -= ABs[i].second;
}
}
cout << ans << endl;
}
| [
"identifier.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,107 | 941,108 | u071730284 | cpp |
p03141 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &o) {
out << "(" << o.first << "," << o.second << ")";
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &V) {
for (int i = 0; i < V.size(); i++) {
out << V[i];
if (i != V.size() - 1)
out << " ";
}
return out;
}
template <class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &Mat) {
for (int i = 0; i < Mat.size(); i++) {
if (i != 0)
out << endl;
out << Mat[i];
}
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &mp) {
out << "{ ";
for (auto it = mp.begin(); it != mp.end(); it++) {
out << it->first << ":" << it->second;
if (mp.size() - 1 != distance(mp.begin(), it))
out << ", ";
}
out << " }";
return out;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
/*
<url:>
問題文============================================================
=================================================================
解説=============================================================
================================================================
*/
template <class Type> Type solve(Type res = Type()) {
ll N;
cin >> N;
vector<ll> A(N), B(N);
for (int i = 0; i < N; i++)
cin >> A[i] >> B[i];
vector<pll> P(N);
for (int i = 0; i < N; i++)
P[i] = {A[i] + B[i], i};
sort(P.begin(), P.end());
for (int i = 0; i < N; i++) {
res += i % 2 == 0 ? A[P[i].second] : -B[P[i].second];
}
return res;
}
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
// solve(0);
cout << fixed << setprecision(15) << solve<ll>() << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &o) {
out << "(" << o.first << "," << o.second << ")";
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &V) {
for (int i = 0; i < V.size(); i++) {
out << V[i];
if (i != V.size() - 1)
out << " ";
}
return out;
}
template <class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &Mat) {
for (int i = 0; i < Mat.size(); i++) {
if (i != 0)
out << endl;
out << Mat[i];
}
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &mp) {
out << "{ ";
for (auto it = mp.begin(); it != mp.end(); it++) {
out << it->first << ":" << it->second;
if (mp.size() - 1 != distance(mp.begin(), it))
out << ", ";
}
out << " }";
return out;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
/*
<url:>
問題文============================================================
=================================================================
解説=============================================================
================================================================
*/
template <class Type> Type solve(Type res = Type()) {
ll N;
cin >> N;
vector<ll> A(N), B(N);
for (int i = 0; i < N; i++)
cin >> A[i] >> B[i];
vector<pll> P(N);
for (int i = 0; i < N; i++)
P[i] = {A[i] + B[i], i};
sort(P.rbegin(), P.rend());
for (int i = 0; i < N; i++) {
res += i % 2 == 0 ? A[P[i].second] : -B[P[i].second];
}
return res;
}
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
// solve(0);
cout << fixed << setprecision(15) << solve<ll>() << endl;
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,114 | 941,115 | u728732647 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, int> pdi;
typedef pair<ll, ll> pll;
#define S second
#define F first
#define kill(x) return (cout << x << endl, 0)
#define debug(x) cerr << #x << " : " << x << endl
#define ddebug(x, y) \
cerr << #x << " : " << x << ", " << #y << " : " << y << endl
#define sz(s) (int)s.size()
#define sq(x) (x) * (x)
#define PB(x) push_back(x)
#define smax(x, y) (x) = max((x), (y))
#define smin(x, y) (x) = min((x), (y))
#define all(x) x.begin(), x.end()
#define SP fixed << setprecision(10)
#define UB upper_bound
const int MAXN = 100 * 1000 + 10;
int a[MAXN], b[MAXN], ind[MAXN];
bool c(int i, int j) { return (a[i] + b[i] < a[j] + b[j]); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
ind[i] = i;
}
sort(ind, ind + n, c);
ll ans = 0;
for (int i = 0; i < n; i++)
ans += ((i & 1 ^ 1) ? a[ind[i]] : (-1 * b[ind[i]]));
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, int> pdi;
typedef pair<ll, ll> pll;
#define S second
#define F first
#define kill(x) return (cout << x << endl, 0)
#define debug(x) cerr << #x << " : " << x << endl
#define ddebug(x, y) \
cerr << #x << " : " << x << ", " << #y << " : " << y << endl
#define sz(s) (int)s.size()
#define sq(x) (x) * (x)
#define PB(x) push_back(x)
#define smax(x, y) (x) = max((x), (y))
#define smin(x, y) (x) = min((x), (y))
#define all(x) x.begin(), x.end()
#define SP fixed << setprecision(10)
#define UB upper_bound
const int MAXN = 100 * 1000 + 10;
int a[MAXN], b[MAXN], ind[MAXN];
bool c(int i, int j) { return (a[i] + b[i] > a[j] + b[j]); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
ind[i] = i;
}
sort(ind, ind + n, c);
ll ans = 0;
for (int i = 0; i < n; i++)
ans += ((i & 1 ^ 1) ? a[ind[i]] : (-1 * b[ind[i]]));
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,116 | 941,117 | u209742093 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 21;
int a[MAXN], b[MAXN];
int n;
long long ans;
pair<int, int> c[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i].first = a[i] + b[i];
c[i].second = i;
}
sort(c, c + n);
for (int i = n - 1; i >= 0; i -= 2)
ans += a[c[i].second];
for (int i = n - 2; i >= 0; i -= 2)
ans -= a[c[i].second];
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 21;
int a[MAXN], b[MAXN];
int n;
long long ans;
pair<int, int> c[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i].first = a[i] + b[i];
c[i].second = i;
}
sort(c, c + n);
for (int i = n - 1; i >= 0; i -= 2)
ans += a[c[i].second];
for (int i = n - 2; i >= 0; i -= 2)
ans -= b[c[i].second];
cout << ans << '\n';
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 941,118 | 941,119 | u699904147 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
long long n;
const long long N = 100 * 1000 + 5;
pair<long long, long long> a[N];
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
return x.first + x.second < y.first + y.second;
}
int main() {
cin >> n;
long long one = 0;
long long two = 0;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
a[i] = {x, y};
}
sort(a, a + n);
reverse(a, a + n);
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
one += a[i].first;
} else {
two += a[i].second;
}
}
cout << (one - two);
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
long long n;
const long long N = 100 * 1000 + 5;
pair<long long, long long> a[N];
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
return x.first + x.second < y.first + y.second;
}
int main() {
cin >> n;
long long one = 0;
long long two = 0;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
a[i] = {x, y};
}
sort(a, a + n, cmp);
reverse(a, a + n);
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
one += a[i].first;
} else {
two += a[i].second;
}
}
cout << (one - two);
}
| [
"call.arguments.add"
] | 941,121 | 941,122 | u900305088 | cpp |
p03141 | // +-- -- --++-- +-In the name of ALLAH-+ --++-- -- --+ \\
#include <bits/stdc++.h>
#define F first
#define S second
#define _sz(x) (int)x.size()
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
const int N = 1e5 + 20;
int n, a[N], b[N], ord[N];
ll ans;
inline bool cmp(int i, int j) { return a[i] + b[i] > a[j] + b[j]; }
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i], ans -= b[i];
iota(ord, ord + n, 0);
sort(ord, ord + n, cmp);
for (int i = 0; i < n; i += 2)
ans += a[i] + b[i];
cout << ans << '\n';
}
| // +-- -- --++-- +-In the name of ALLAH-+ --++-- -- --+ \\
#include <bits/stdc++.h>
#define F first
#define S second
#define _sz(x) (int)x.size()
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
const int N = 1e5 + 20;
int n, a[N], b[N], ord[N];
ll ans;
inline bool cmp(int i, int j) { return a[i] + b[i] > a[j] + b[j]; }
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i], ans -= b[i];
iota(ord, ord + n, 0);
sort(ord, ord + n, cmp);
for (int i = 0; i < n; i += 2)
ans += a[ord[i]] + b[ord[i]];
cout << ans << '\n';
}
| [] | 941,123 | 941,124 | u731138875 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF64 = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
bool comp(P a, P b) { return a.second < b.second; }
void solve() {
int N;
cin >> N;
vector<ll> A(N), B(N);
vector<P> AB(N);
for (int i = 0; i < N; ++i) {
cin >> A[i] >> B[i];
AB[i] = {i, A[i] + B[i]};
}
sort(AB.begin(), AB.end(), comp);
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
ans += A[AB[i].first];
} else {
ans -= B[AB[i].first];
}
}
cout << ans << '\n';
}
int main() {
#ifdef MYLOCAL
const int CASES = 3;
vector<string> filenames{"input1.txt", "input2.txt", "input3.txt"};
cout << "------------\n";
for (int i = 0; i < CASES; ++i) {
ifstream in(filenames[i]);
cin.rdbuf(in.rdbuf());
solve();
cout << "------------\n";
}
#else
solve();
#endif
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF64 = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
bool comp(P a, P b) { return a.second > b.second; }
void solve() {
int N;
cin >> N;
vector<ll> A(N), B(N);
vector<P> AB(N);
for (int i = 0; i < N; ++i) {
cin >> A[i] >> B[i];
AB[i] = {i, A[i] + B[i]};
}
sort(AB.begin(), AB.end(), comp);
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
ans += A[AB[i].first];
} else {
ans -= B[AB[i].first];
}
}
cout << ans << '\n';
}
int main() {
#ifdef MYLOCAL
const int CASES = 3;
vector<string> filenames{"input1.txt", "input2.txt", "input3.txt"};
cout << "------------\n";
for (int i = 0; i < CASES; ++i) {
ifstream in(filenames[i]);
cin.rdbuf(in.rdbuf());
solve();
cout << "------------\n";
}
#else
solve();
#endif
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,131 | 941,132 | u335667012 | cpp |
p03141 | // https://atcoder.jp/contests/nikkei2019-qual/tasks/nikkei2019_qual_c
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
struct dish {
int diff, a, b;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<dish> v(n);
REP(i, n) {
int a, b;
cin >> a >> b;
v[i] = {a - b, a, b};
}
sort(ALL(v), [](const dish &a, const dish &b) {
// 降順ソート
return a.diff > b.diff;
}); //比較関数をラムダ式で作る
ll ans = 0;
REP(i, n) {
if (i % 2 == 0) {
ans += v[i].a;
} else {
ans -= v[i].b;
}
}
cout << ans << endl;
return 0;
}
| // https://atcoder.jp/contests/nikkei2019-qual/tasks/nikkei2019_qual_c
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
struct dish {
int diff, a, b;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<dish> v(n);
REP(i, n) {
int a, b;
cin >> a >> b;
v[i] = {a + b, a, b};
}
sort(ALL(v), [](const dish &a, const dish &b) {
// 降順ソート
return a.diff > b.diff;
}); //比較関数をラムダ式で作る
ll ans = 0;
REP(i, n) {
if (i % 2 == 0) {
ans += v[i].a;
} else {
ans -= v[i].b;
}
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 941,139 | 941,140 | u858107870 | cpp |
p03141 | #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);
vector<pair<ll, ll>> Sum(N);
for (ll i = 0; i < N; i++) {
cin >> A[i] >> B[i];
Sum[i].first = A[i] + B[i];
Sum[i].second = i;
}
sort(Sum.rbegin(), Sum.rend());
ll t = 0;
ll a = 0;
for (ll i = 0; i < N; i++) {
if (i % 2) { // Takahashi
t += A[Sum[i].second];
} else {
a += B[Sum[i].second];
}
}
cout << t - a << endl;
return 0;
}
| #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);
vector<pair<ll, ll>> Sum(N);
for (ll i = 0; i < N; i++) {
cin >> A[i] >> B[i];
Sum[i].first = A[i] + B[i];
Sum[i].second = i;
}
sort(Sum.rbegin(), Sum.rend());
ll t = 0;
ll a = 0;
for (ll i = 0; i < N; i++) {
if ((i % 2) == 0) { // Takahashi
t += A[Sum[i].second];
} else {
a += B[Sum[i].second];
}
}
cout << t - a << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,149 | 941,150 | u904123392 | cpp |
p03141 | #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);
vector<pair<ll, ll>> Sum(N);
for (ll i = 0; i < N; i++) {
cin >> A[i] >> B[i];
Sum[i].first = A[i] + B[i];
Sum[i].second = i;
}
sort(Sum.rbegin(), Sum.rend());
ll t = 0;
ll a = 0;
for (ll i = 0; i < N; i++) {
if (!i % 2) { // Takahashi
t += A[Sum[i].second];
} else {
a += B[Sum[i].second];
}
}
cout << t - a << endl;
return 0;
}
| #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);
vector<pair<ll, ll>> Sum(N);
for (ll i = 0; i < N; i++) {
cin >> A[i] >> B[i];
Sum[i].first = A[i] + B[i];
Sum[i].second = i;
}
sort(Sum.rbegin(), Sum.rend());
ll t = 0;
ll a = 0;
for (ll i = 0; i < N; i++) {
if ((i % 2) == 0) { // Takahashi
t += A[Sum[i].second];
} else {
a += B[Sum[i].second];
}
}
cout << t - a << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,151 | 941,150 | u904123392 | cpp |
p03132 | #include <cstdio>
#include <iostream>
using namespace std;
typedef long long ll;
const ll INF_ll = 4611686018427387903;
const int N = 2e5 + 10;
int n, a[N];
ll dp[N][5], ans;
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (register int i = 1; i <= n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][1], dp[i - 1][0]) + (a[i] ? (a[i] & 1) : 2);
dp[i][2] =
min(dp[i - 1][2], min(dp[i - 1][1], dp[i - 1][0])) + ((a[i] & 1) ^ 1);
dp[i][3] =
min(dp[i - 1][3], min(dp[i - 1][2], min(dp[i - 1][1], dp[i - 1][0]))) +
(a[i] ? (a[i] & 1) : 2);
dp[i][4] = min(dp[i - 1][4],
min(dp[i - 1][3],
min(dp[i - 1][2], min(dp[i - 1][1], dp[i - 1][0])))) +
a[i];
}
ans = dp[n][0];
for (register int i = 1; i < 6; i++)
ans = min(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
typedef long long ll;
const ll INF_ll = 4611686018427387903;
const int N = 2e5 + 10;
int n, a[N];
ll dp[N][5], ans;
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (register int i = 1; i <= n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][1], dp[i - 1][0]) + (a[i] ? (a[i] & 1) : 2);
dp[i][2] =
min(dp[i - 1][2], min(dp[i - 1][1], dp[i - 1][0])) + ((a[i] & 1) ^ 1);
dp[i][3] =
min(dp[i - 1][3], min(dp[i - 1][2], min(dp[i - 1][1], dp[i - 1][0]))) +
(a[i] ? (a[i] & 1) : 2);
dp[i][4] = min(dp[i - 1][4],
min(dp[i - 1][3],
min(dp[i - 1][2], min(dp[i - 1][1], dp[i - 1][0])))) +
a[i];
}
ans = dp[n][0];
for (register int i = 1; i < 5; i++)
ans = min(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 941,154 | 941,155 | u917335077 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
long long n, v, a, b, c, d, e;
int main() {
cin >> n;
while (n--)
cin >> v, a += v, b = min(b + (v ? v % 2 : 2), a), c = min(c + !(v % 2), b),
d = min(d + (v ? v % 2 : 2), c), e = min(e, d);
cout << e;
}
| #include <bits/stdc++.h>
using namespace std;
long long n, v, a, b, c, d, e;
int main() {
cin >> n;
while (n--)
cin >> v, a += v, b = min(b + (v ? v % 2 : 2), a), c = min(c + !(v % 2), b),
d = min(d + (v ? v % 2 : 2), c), e = min(e + v, d);
cout << e;
}
| [
"assignment.change"
] | 941,156 | 941,157 | u963610246 | cpp |
p03132 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, max_i = (n); i < max_i; i++)
#define REPI(i, a, b) for (int i = (a), max_i = (b); i < max_i; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define fi first
#define se second
#define int long long
using namespace std;
using ll = long long;
using II = pair<int, int>;
using VII = vector<II>;
using VVII = vector<VII>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
template <class T = int> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T = int> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &d) {
REP(i, d.size()) s << d[i] << (i == d.size() - 1 ? "" : " ");
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
REP(i, d.size()) s << d[i] << (i == d.size() - 1 ? "" : "\n");
return s;
}
template <class T, class S>
ostream &operator<<(ostream &s, const pair<T, S> &p) {
s << "{" << p.first << ", " << p.second << "}";
return s;
}
template <class T, class S> ostream &operator<<(ostream &s, const map<T, S> m) {
for (auto it = m.begin(); it != m.end(); it++) {
s << *it << (next(it) == m.end() ? "" : "\n");
}
return s;
}
#ifdef _MY_DEBUG
#define dump(...) \
cerr << "/* " << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ \
<< "]" << endl, \
dump_func(__VA_ARGS__), cerr << "*/\n\n";
#else
#define dump(...)
#endif
void dump_func() { cerr << endl; }
template <class Head, class... Tail> void dump_func(Head &&h, Tail &&...t) {
cerr << h << (sizeof...(Tail) == 0 ? "" : ", "),
dump_func(forward<Tail>(t)...);
}
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
constexpr int MOD = 1e9 + 7;
int dif(int type, int x) {
if (type == 0 || type == 4)
return x;
if (type == 1 || type == 2)
return x == 0 ? 2 : x % 2;
return (x + 1) % 2;
}
signed main() {
int n;
cin >> n;
VI a(n);
REP(i, n) cin >> a[i];
VVI dp(n + 1, VI(5, 1e18));
REP(j, 5) dp[0][j] = 0;
REP(i, n) {
REP(j, 5) {
REP(k, j + 1) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][k] + dif(j, a[i]));
}
}
}
int ans = 1e18;
REP(j, 5) ans = min(ans, dp[n][j]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, max_i = (n); i < max_i; i++)
#define REPI(i, a, b) for (int i = (a), max_i = (b); i < max_i; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define fi first
#define se second
#define int long long
using namespace std;
using ll = long long;
using II = pair<int, int>;
using VII = vector<II>;
using VVII = vector<VII>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
template <class T = int> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T = int> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &d) {
REP(i, d.size()) s << d[i] << (i == d.size() - 1 ? "" : " ");
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
REP(i, d.size()) s << d[i] << (i == d.size() - 1 ? "" : "\n");
return s;
}
template <class T, class S>
ostream &operator<<(ostream &s, const pair<T, S> &p) {
s << "{" << p.first << ", " << p.second << "}";
return s;
}
template <class T, class S> ostream &operator<<(ostream &s, const map<T, S> m) {
for (auto it = m.begin(); it != m.end(); it++) {
s << *it << (next(it) == m.end() ? "" : "\n");
}
return s;
}
#ifdef _MY_DEBUG
#define dump(...) \
cerr << "/* " << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ \
<< "]" << endl, \
dump_func(__VA_ARGS__), cerr << "*/\n\n";
#else
#define dump(...)
#endif
void dump_func() { cerr << endl; }
template <class Head, class... Tail> void dump_func(Head &&h, Tail &&...t) {
cerr << h << (sizeof...(Tail) == 0 ? "" : ", "),
dump_func(forward<Tail>(t)...);
}
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
constexpr int MOD = 1e9 + 7;
int dif(int type, int x) {
if (type == 0 || type == 4)
return x;
if (type == 1 || type == 3)
return x == 0 ? 2 : x % 2;
return (x + 1) % 2;
}
signed main() {
int n;
cin >> n;
VI a(n);
REP(i, n) cin >> a[i];
VVI dp(n + 1, VI(5, 1e18));
REP(j, 5) dp[0][j] = 0;
REP(i, n) {
REP(j, 5) {
REP(k, j + 1) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][k] + dif(j, a[i]));
}
}
}
int ans = 1e18;
REP(j, 5) ans = min(ans, dp[n][j]);
cout << ans << endl;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 941,160 | 941,161 | u852113235 | cpp |
p03132 | #include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define ios() cin.tie(0), ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
ll const MOD = 1e9 + 7;
ll const INF = 1e18;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> v(n);
for (auto &i : v) {
cin >> i;
}
vector<vector<ll>> dp(n + 1, vector<ll>(5, INF));
REP(i, 5) { dp[0][i] = 0; }
REP(i, n) {
dp[i + 1][0] = dp[i][0] + v[i];
dp[i + 1][1] = min(dp[i][0], dp[i][1]) + (v[i + 1] == 0 ? 2 : v[i] % 2);
dp[i + 1][2] = min({dp[i][0], dp[i][1], dp[i][2]}) + (v[i] + 1) % 2;
dp[i + 1][3] = min({dp[i][0], dp[i][1], dp[i][2], dp[i][3]}) +
(v[i] == 0 ? 2 : v[i] % 2);
dp[i + 1][4] =
min({dp[i][0], dp[i][1], dp[i][2], dp[i][3], dp[i][4]}) + v[i];
}
cout << *min_element(all(dp[n])) << endl;
return 0;
} | #include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define ios() cin.tie(0), ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
ll const MOD = 1e9 + 7;
ll const INF = 1e18;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> v(n);
for (auto &i : v) {
cin >> i;
}
vector<vector<ll>> dp(n + 1, vector<ll>(5, INF));
REP(i, 5) { dp[0][i] = 0; }
REP(i, n) {
dp[i + 1][0] = dp[i][0] + v[i];
dp[i + 1][1] = min(dp[i][0], dp[i][1]) + (v[i] == 0 ? 2 : v[i] % 2);
dp[i + 1][2] = min({dp[i][0], dp[i][1], dp[i][2]}) + (v[i] + 1) % 2;
dp[i + 1][3] = min({dp[i][0], dp[i][1], dp[i][2], dp[i][3]}) +
(v[i] == 0 ? 2 : v[i] % 2);
dp[i + 1][4] =
min({dp[i][0], dp[i][1], dp[i][2], dp[i][3], dp[i][4]}) + v[i];
}
cout << *min_element(all(dp[n])) << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 941,162 | 941,163 | u994831328 | cpp |
p03132 | #include <bits/stdc++.h>
#define all(vec) vec.begin(), vec.end()
#define mp make_pair
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 1LL << 30;
const ll LINF = 1LL << 62;
const double eps = 1e-5;
const ll MOD = 1000000007LL;
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n;
cin >> n;
vector<ll> a(n + 10);
for (int i = 1; i <= n; i++)
cin >> a[i];
vector<vector<ll>> dp(n + 10, vector<ll>(5, LINF));
for (int i = 0; i < 5; i++)
dp[0][i] = 0;
for (int i = 1; i <= n; i++) {
ll mi = dp[i - 1][0];
chmin(dp[i][0], mi + a[i]);
chmin(mi, dp[i - 1][1]);
if (a[i] == 0) {
chmin(dp[i][1], mi + 2);
} else if (a[i] % 2) {
chmin(dp[i][1], mi + 1);
} else {
chmin(dp[i][1], mi);
}
chmin(mi, dp[i - 1][2]);
chmin(dp[i][2], mi + (a[i] % 2 ? 0LL : 1LL));
chmin(mi, dp[i - 1][3]);
if (a[i] == 0) {
chmin(dp[i][3], mi + 2);
} else if (a[i] % 2) {
chmin(dp[i][3], mi + 1);
} else {
chmin(dp[i][3], mi);
}
chmin(mi, dp[i - 1][4]);
chmin(dp[i][3], mi + a[i]);
}
cout << min({dp[n][0], dp[n][1], dp[n][2], dp[n][3], dp[n][4]}) << endl;
}
| #include <bits/stdc++.h>
#define all(vec) vec.begin(), vec.end()
#define mp make_pair
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 1LL << 30;
const ll LINF = 1LL << 62;
const double eps = 1e-5;
const ll MOD = 1000000007LL;
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n;
cin >> n;
vector<ll> a(n + 10);
for (int i = 1; i <= n; i++)
cin >> a[i];
vector<vector<ll>> dp(n + 10, vector<ll>(5, LINF));
for (int i = 0; i < 5; i++)
dp[0][i] = 0;
for (int i = 1; i <= n; i++) {
ll mi = dp[i - 1][0];
chmin(dp[i][0], mi + a[i]);
chmin(mi, dp[i - 1][1]);
if (a[i] == 0) {
chmin(dp[i][1], mi + 2);
} else if (a[i] % 2) {
chmin(dp[i][1], mi + 1);
} else {
chmin(dp[i][1], mi);
}
chmin(mi, dp[i - 1][2]);
chmin(dp[i][2], mi + (a[i] % 2 ? 0LL : 1LL));
chmin(mi, dp[i - 1][3]);
if (a[i] == 0) {
chmin(dp[i][3], mi + 2);
} else if (a[i] % 2) {
chmin(dp[i][3], mi + 1);
} else {
chmin(dp[i][3], mi);
}
chmin(mi, dp[i - 1][4]);
chmin(dp[i][4], mi + a[i]);
}
cout << min({dp[n][0], dp[n][1], dp[n][2], dp[n][3], dp[n][4]}) << endl;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 941,166 | 941,167 | u924339359 | cpp |
p03132 | #include <stdio.h>
typedef long long ll;
int main(void) {
ll i, j, k, l, ans = 1e18;
scanf("%lld", &l);
ll dp[l][5], a[l];
for (i = 0; i < l; ++i)
scanf("%lld", &a[i]);
for (i = 0; i < l; ++i)
for (j = 0; j < 5; ++j)
dp[i][j] = 1e18;
dp[0][0] = dp[0][4] = a[0], dp[0][1] = dp[0][3] = a[0] ? a[0] % 2 : 2,
dp[0][2] = a[0] % 2 ? 0 : 1;
for (i = 1; i < l; ++i) {
for (j = 0; j < 5; ++j)
for (k = j; k < 5; ++k) {
if (!k || k == 4) {
if (dp[i][k] > dp[i - 1][j] + a[i])
dp[i][k] = dp[i - 1][j] + a[i];
} else if (k == 1 || k == 3) {
if (dp[i][k] > dp[i - 1][j] + (a[i] ? a[j] % 2 : 2))
dp[i][k] = dp[i - 1][j] + (a[i] ? a[i] % 2 : 2);
} else {
if (dp[i][k] > dp[i - 1][j] + (a[i] % 2 ? 0 : 1))
dp[i][k] = dp[i - 1][j] + (a[i] % 2 ? 0 : 1);
}
}
}
for (i = 0; i < 5; ++i)
if (ans > dp[l - 1][i])
ans = dp[l - 1][i];
printf("%lld", ans);
return 0;
} | #include <stdio.h>
typedef long long ll;
int main(void) {
ll i, j, k, l, ans = 1e18;
scanf("%lld", &l);
ll dp[l][5], a[l];
for (i = 0; i < l; ++i)
scanf("%lld", &a[i]);
for (i = 0; i < l; ++i)
for (j = 0; j < 5; ++j)
dp[i][j] = 1e18;
dp[0][0] = dp[0][4] = a[0], dp[0][1] = dp[0][3] = a[0] ? a[0] % 2 : 2,
dp[0][2] = a[0] % 2 ? 0 : 1;
for (i = 1; i < l; ++i) {
for (j = 0; j < 5; ++j)
for (k = j; k < 5; ++k) {
if (!k || k == 4) {
if (dp[i][k] > dp[i - 1][j] + a[i])
dp[i][k] = dp[i - 1][j] + a[i];
} else if (k == 1 || k == 3) {
if (dp[i][k] > dp[i - 1][j] + (a[i] ? a[i] % 2 : 2))
dp[i][k] = dp[i - 1][j] + (a[i] ? a[i] % 2 : 2);
} else {
if (dp[i][k] > dp[i - 1][j] + (a[i] % 2 ? 0 : 1))
dp[i][k] = dp[i - 1][j] + (a[i] % 2 ? 0 : 1);
}
}
}
for (i = 0; i < 5; ++i)
if (ans > dp[l - 1][i])
ans = dp[l - 1][i];
printf("%lld", ans);
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 941,172 | 941,173 | u440920318 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef gp_hash_table<long long, long long> umap;
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define rep(i, n) for (long long i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (long long i = (n)-1; i >= 0; i--)
#define foreach(it, ar) \
for (typeof(ar.begin()) it = ar.begin(); it != ar.end(); it++)
#define fill(ar, val) memset(ar, val, sizeof(ar))
#define fill0(ar) fill((ar), 0)
#define fillinf(ar, n) fr(i, 0, (n)) ar[i] = INF
#define debug(x) cout << #x << ": " << x << endl
#define arr1d(a, n) \
cout << #a << " : "; \
fr(_, 1, n) cout << a[_] << ' '; \
cout << endl;
#define arr1d0(a, n) \
cout << #a << " : "; \
rep(_, n) cout << a[_] << ' '; \
cout << endl;
#define arr2d(a, n, m) \
cout << #a << " :" << endl; \
fr(_, 1, n) { \
fr(__, 1, m) cout << a[_][__] << ' '; \
cout << endl; \
}
#define arr2d0(a, n, m) \
cout << #a << " :" << endl; \
rep(_, n) { \
rep(__, m) cout << a[_][__] << ' '; \
cout << endl; \
}
/*Author Ritick Goenka || ritick(codechef) ||ritick(codeforces) */
/*IIT Roorkee = <3 */
#define ull unsigned long long
#define ll long long
#define ld double
#define ui unsigned int
#define all(ar) ar.begin(), ar.end()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define y0 yyyyyy0
#define y1 yyyyyy1
#define sot(bello) bello.begin(), bello.end()
#define BIT(n) (1 << (n))
#define SQR(x) ((x) * (x))
#define CUBE(x) ((x) * (x) * (x))
#define LSOne(S) (S) & (-S)
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<string> vs;
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) { return (a * b) / gcd(a, b); }
template <typename T> string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <class T> void splitStr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
inline int two(int n) { return 1 << n; }
inline int isOnBit(int n, int b) { return (n >> b) & 1; }
inline void onBit(int &n, int b) { n |= two(b); }
inline void offBit(int &n, int b) { n &= ~two(b); }
inline int lastBit(int n) { return n & (-n); }
inline int cntBit(int n) {
int res = 0;
while (n && ++res)
n -= n & (-n);
return res;
}
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
#define INP "test.inp"
#define OUT "test.out"
#define PI 3.1415926535897932385
#define INF 1000000000000000
#define EPS 1e-7
#define MAXN 100000
#define MOD 998244353
#define dec decr
// END OF COMPETITVE PROGRAMMING TEMPLATE
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll modexp(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll dp[200005][5];
ll ar[200005];
ll fn(ll i, ll j) {
if (i < 1 || j < 0) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
if (j == 4) {
return dp[i][j] = min(fn(i, 3), fn(i - 1, 4) + ar[i]);
} else if (j == 3) {
return dp[i][j] = min(fn(i, 2), fn(i - 1, 3) + ar[i] % 2 + (ar[i] == 0));
} else if (j == 2) {
return dp[i][j] = min(fn(i, 1), fn(i - 1, 2) + (ar[i] + 1) % 2);
} else if (j == 1) {
return dp[i][j] = min(fn(i, 0), fn(i - 1, 1) + (ar[i]) % 2 + (ar[i] == 0));
} else {
return dp[i][j] = ar[i] + fn(i - 1, j);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(11);
ll n;
cin >> n;
rep(i, 200005) {
rep(j, 5) { dp[i][j] = -1; }
}
rep(i, n) { cin >> ar[i + 1]; }
cout << fn(n, 4);
// cout<<fn(n-1,4);
// debug(ar[6]);
// cout<<fn(n-1,3);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef gp_hash_table<long long, long long> umap;
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define rep(i, n) for (long long i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (long long i = (n)-1; i >= 0; i--)
#define foreach(it, ar) \
for (typeof(ar.begin()) it = ar.begin(); it != ar.end(); it++)
#define fill(ar, val) memset(ar, val, sizeof(ar))
#define fill0(ar) fill((ar), 0)
#define fillinf(ar, n) fr(i, 0, (n)) ar[i] = INF
#define debug(x) cout << #x << ": " << x << endl
#define arr1d(a, n) \
cout << #a << " : "; \
fr(_, 1, n) cout << a[_] << ' '; \
cout << endl;
#define arr1d0(a, n) \
cout << #a << " : "; \
rep(_, n) cout << a[_] << ' '; \
cout << endl;
#define arr2d(a, n, m) \
cout << #a << " :" << endl; \
fr(_, 1, n) { \
fr(__, 1, m) cout << a[_][__] << ' '; \
cout << endl; \
}
#define arr2d0(a, n, m) \
cout << #a << " :" << endl; \
rep(_, n) { \
rep(__, m) cout << a[_][__] << ' '; \
cout << endl; \
}
/*Author Ritick Goenka || ritick(codechef) ||ritick(codeforces) */
/*IIT Roorkee = <3 */
#define ull unsigned long long
#define ll long long
#define ld double
#define ui unsigned int
#define all(ar) ar.begin(), ar.end()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define y0 yyyyyy0
#define y1 yyyyyy1
#define sot(bello) bello.begin(), bello.end()
#define BIT(n) (1 << (n))
#define SQR(x) ((x) * (x))
#define CUBE(x) ((x) * (x) * (x))
#define LSOne(S) (S) & (-S)
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<string> vs;
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) { return (a * b) / gcd(a, b); }
template <typename T> string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <class T> void splitStr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
inline int two(int n) { return 1 << n; }
inline int isOnBit(int n, int b) { return (n >> b) & 1; }
inline void onBit(int &n, int b) { n |= two(b); }
inline void offBit(int &n, int b) { n &= ~two(b); }
inline int lastBit(int n) { return n & (-n); }
inline int cntBit(int n) {
int res = 0;
while (n && ++res)
n -= n & (-n);
return res;
}
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
#define INP "test.inp"
#define OUT "test.out"
#define PI 3.1415926535897932385
#define INF 1000000000000000
#define EPS 1e-7
#define MAXN 100000
#define MOD 998244353
#define dec decr
// END OF COMPETITVE PROGRAMMING TEMPLATE
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll modexp(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll dp[200005][5];
ll ar[200005];
ll fn(ll i, ll j) {
if (i < 1 || j < 0) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
if (j == 4) {
return dp[i][j] = min(fn(i, 3), fn(i - 1, 4) + ar[i]);
} else if (j == 3) {
return dp[i][j] =
min(fn(i, 2), fn(i - 1, 3) + ar[i] % 2 + 2 * (ar[i] == 0));
} else if (j == 2) {
return dp[i][j] = min(fn(i, 1), fn(i - 1, 2) + (ar[i] + 1) % 2);
} else if (j == 1) {
return dp[i][j] =
min(fn(i, 0), fn(i - 1, 1) + (ar[i]) % 2 + 2 * (ar[i] == 0));
} else {
return dp[i][j] = ar[i] + fn(i - 1, j);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(11);
ll n;
cin >> n;
rep(i, 200005) {
rep(j, 5) { dp[i][j] = -1; }
}
rep(i, n) { cin >> ar[i + 1]; }
cout << fn(n, 4);
// cout<<fn(n-1,4);
// debug(ar[6]);
// cout<<fn(n-1,3);
return 0;
} | [
"assignment.change"
] | 941,182 | 941,183 | u795058347 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[i] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[0];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[i] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[i];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 941,187 | 941,188 | u987476436 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define M 1000000000000000000
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[0] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[0];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[i] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[i];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 941,189 | 941,188 | u987476436 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[i] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[0];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define M 1000000000000000000
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[i] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[i];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 941,187 | 941,190 | u987476436 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define M 1000000000000000000
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[0] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[0];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define M 1000000000000000000
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<ll>> dp(n, vector<ll>(5));
dp[0][0] = dp[0][4] = a[0];
dp[0][1] = dp[0][3] = (a[0] == 0 ? 2 : a[0] % 2 == 0 ? 0 : 1);
dp[0][2] = (a[0] % 2 == 0 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + a[i];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + (a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][2] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) +
(a[i] % 2 == 0 ? 1 : 0);
dp[i][3] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]}) +
(a[i] == 0 ? 2
: a[i] % 2 == 0 ? 0
: 1);
dp[i][4] = min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2], dp[i - 1][3],
dp[i - 1][4]}) +
a[i];
}
cout << min(
{dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3], dp[n - 1][4]});
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 941,189 | 941,190 | u987476436 | cpp |
p03132 | /**********************************************************************/
/******** ********/
/******** Writer:孙~~ ********/
/******** Lang:C++ ********/
/******** Status:Unknow ********/
/******** ********/
/**********************************************************************/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
const long long INF = 4223372036854775807ll;
const int SIZE = 200005;
const double EPS = 1e-6;
long long dp[SIZE][5], a[SIZE];
int main() {
/*main function start*/
int l;
scanf("%d", &l);
for (int i = 0; i < l; i++) {
scanf("%lld", a + i);
}
for (int i = 0; i <= l; i++) {
dp[i][0] = dp[i][1] = dp[i][2] = dp[i][3] = dp[i][4] = INF;
}
dp[0][0] = 0;
for (int i = 1; i <= l; i++) {
if (a[i - 1] == 0) {
long long p = dp[i - 1][0];
dp[i][0] = p;
p = min(p, dp[i - 1][1]);
dp[i][1] = p + 1;
p = min(p, dp[i - 1][2]);
dp[i][2] = p + 1;
p = min(p, dp[i - 1][3]);
dp[i][3] = p + 1;
p = min(p, dp[i - 1][4]);
dp[i][4] = p;
} else if (a[i - 1] % 2 == 0) {
long long p = dp[i - 1][0];
dp[i][0] = p + a[i - 1];
p = min(p, dp[i - 1][1]);
dp[i][1] = p;
p = min(p, dp[i - 1][2]);
dp[i][2] = p + 1;
p = min(p, dp[i - 1][3]);
dp[i][3] = p;
p = min(p, dp[i - 1][4]);
dp[i][4] = p + a[i - 1];
} else {
long long p = dp[i - 1][0];
dp[i][0] = p + a[i - 1];
p = min(p, dp[i - 1][1]);
dp[i][1] = p + 1;
p = min(p, dp[i - 1][2]);
dp[i][2] = p;
p = min(p, dp[i - 1][3]);
dp[i][3] = p + 1;
p = min(p, dp[i - 1][4]);
dp[i][4] = p + a[i - 1];
}
}
long long ans =
min(min(min(dp[l][0], dp[l][1]), min(dp[l][2], dp[l][3])), dp[l][4]);
printf("%lld\n", ans);
return 0;
}
| /**********************************************************************/
/******** ********/
/******** Writer:孙~~ ********/
/******** Lang:C++ ********/
/******** Status:Unknow ********/
/******** ********/
/**********************************************************************/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
const long long INF = 4223372036854775807ll;
const int SIZE = 200005;
const double EPS = 1e-6;
long long dp[SIZE][5], a[SIZE];
int main() {
/*main function start*/
int l;
scanf("%d", &l);
for (int i = 0; i < l; i++) {
scanf("%lld", a + i);
}
for (int i = 0; i <= l; i++) {
dp[i][0] = dp[i][1] = dp[i][2] = dp[i][3] = dp[i][4] = INF;
}
dp[0][0] = 0;
for (int i = 1; i <= l; i++) {
if (a[i - 1] == 0) {
long long p = dp[i - 1][0];
dp[i][0] = p;
p = min(p, dp[i - 1][1]);
dp[i][1] = p + 2;
p = min(p, dp[i - 1][2]);
dp[i][2] = p + 1;
p = min(p, dp[i - 1][3]);
dp[i][3] = p + 2;
p = min(p, dp[i - 1][4]);
dp[i][4] = p;
} else if (a[i - 1] % 2 == 0) {
long long p = dp[i - 1][0];
dp[i][0] = p + a[i - 1];
p = min(p, dp[i - 1][1]);
dp[i][1] = p;
p = min(p, dp[i - 1][2]);
dp[i][2] = p + 1;
p = min(p, dp[i - 1][3]);
dp[i][3] = p;
p = min(p, dp[i - 1][4]);
dp[i][4] = p + a[i - 1];
} else {
long long p = dp[i - 1][0];
dp[i][0] = p + a[i - 1];
p = min(p, dp[i - 1][1]);
dp[i][1] = p + 1;
p = min(p, dp[i - 1][2]);
dp[i][2] = p;
p = min(p, dp[i - 1][3]);
dp[i][3] = p + 1;
p = min(p, dp[i - 1][4]);
dp[i][4] = p + a[i - 1];
}
}
long long ans =
min(min(min(dp[l][0], dp[l][1]), min(dp[l][2], dp[l][3])), dp[l][4]);
printf("%lld\n", ans);
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,196 | 941,197 | u190596522 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) \
sort(x.begin(), x.end()); \
x.erase(unique(x.begin(), x.end()), x.end());
#define rep(i, n) for (int(i) = (0); (i) < (n); ++(i))
#define repp(i, m, n) for (int(i) = (m); (i) < (n); ++(i))
#define dbg(x) cerr << #x << ": " << x << endl;
#define dbg2(x, y) \
cerr << "(" << #x << ", " << #y << ") = " \
<< "(" << x << ", " << y << ")" << endl;
#define dbg3(x, y, z) \
cerr << "(" << #x << ", " << #y << ", " << #z << ") = " \
<< "(" << x << ", " << y << ", " << z << ")" << endl;
#define dbgB(value, size) cerr << #value << ": " << bitset<size>(value) << endl;
#define line() cerr << "---------------" << endl;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const double PI = 3.14159265358979323846;
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;
}
template <typename T> void print1(T begin, T end) {
while (begin != end) {
cout << (*begin) << " ";
*begin++;
}
cout << endl;
}
template <typename T> void print2(T Array, int height, int width) {
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
cout << " " << Array[i][j];
}
cout << endl;
}
}
void print() { std::cerr << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
std::cerr << head << " ";
print(std::forward<Tail>(tail)...);
}
template <class T> void Add(T &a, const T &b, const T &mod = 1e9 + 7) {
int val = ((a % mod) + (b % mod)) % mod;
if (val < 0) {
val += mod;
}
a = val;
}
// ------------------------------------------------------------------------------------------
const int INF = 1e18;
// idx, (未処理, 偶数左, 奇数, 偶数右)
const int VARI = 5;
int dp[200010][VARI];
signed main() {
int N;
cin >> N;
vec<int> v(N);
rep(i, N) { cin >> v[i]; }
const int one = 0; // 左のゼロ区間
const int two = 1; // 右のゼロ区間
const int three = 2; // 左の偶数区間
const int four = 3; // 右の偶数区間
const int five = 4; // 奇数区間
// 初期化
fill(dp[0], dp[N + 1], INF);
dp[0][one] = 0;
dp[0][two] = 0;
dp[0][three] = 0;
dp[0][four] = 0;
dp[0][five] = 0;
// DP
rep(i, N) {
// 左のゼロ区間
int cost1 = v[i];
chmin(dp[i + 1][one], dp[i][1] + cost1);
// 左の偶数区間
int cost2 = v[i] == 0 ? 2 : v[i] % 2;
chmin(dp[i + 1][two], min(dp[i][one], dp[i][two]) + cost2);
// 奇数区間
int cost3 = v[i] == 0 ? 1 : (v[i] % 2 == 0);
chmin(dp[i + 1][three],
min({dp[i][two], dp[i][three], dp[i][one]}) + cost3);
// 右の偶数区間
int cost4 = v[i] == 0 ? 2 : v[i] % 2;
chmin(dp[i + 1][four],
min({dp[i][three], dp[i][four], dp[i][two], dp[i][one]}) + cost4);
// 右のゼロ区間
int cost5 = v[i];
chmin(dp[i + 1][five], min({dp[i][four], dp[i][three], dp[i][two],
dp[i][one], dp[i][five]}) +
cost5);
}
int ans = INF;
rep(i, VARI) { chmin(ans, dp[N][i]); }
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) \
sort(x.begin(), x.end()); \
x.erase(unique(x.begin(), x.end()), x.end());
#define rep(i, n) for (int(i) = (0); (i) < (n); ++(i))
#define repp(i, m, n) for (int(i) = (m); (i) < (n); ++(i))
#define dbg(x) cerr << #x << ": " << x << endl;
#define dbg2(x, y) \
cerr << "(" << #x << ", " << #y << ") = " \
<< "(" << x << ", " << y << ")" << endl;
#define dbg3(x, y, z) \
cerr << "(" << #x << ", " << #y << ", " << #z << ") = " \
<< "(" << x << ", " << y << ", " << z << ")" << endl;
#define dbgB(value, size) cerr << #value << ": " << bitset<size>(value) << endl;
#define line() cerr << "---------------" << endl;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const double PI = 3.14159265358979323846;
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;
}
template <typename T> void print1(T begin, T end) {
while (begin != end) {
cout << (*begin) << " ";
*begin++;
}
cout << endl;
}
template <typename T> void print2(T Array, int height, int width) {
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
cout << " " << Array[i][j];
}
cout << endl;
}
}
void print() { std::cerr << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
std::cerr << head << " ";
print(std::forward<Tail>(tail)...);
}
template <class T> void Add(T &a, const T &b, const T &mod = 1e9 + 7) {
int val = ((a % mod) + (b % mod)) % mod;
if (val < 0) {
val += mod;
}
a = val;
}
// ------------------------------------------------------------------------------------------
const int INF = 1e18;
// idx, (未処理, 偶数左, 奇数, 偶数右)
const int VARI = 5;
int dp[200010][VARI];
signed main() {
int N;
cin >> N;
vec<int> v(N);
rep(i, N) { cin >> v[i]; }
const int one = 0; // 左のゼロ区間
const int two = 1; // 右のゼロ区間
const int three = 2; // 左の偶数区間
const int four = 3; // 右の偶数区間
const int five = 4; // 奇数区間
// 初期化
fill(dp[0], dp[N + 1], INF);
dp[0][one] = 0;
dp[0][two] = 0;
dp[0][three] = 0;
dp[0][four] = 0;
dp[0][five] = 0;
// DP
rep(i, N) {
// 左のゼロ区間
int cost1 = v[i];
chmin(dp[i + 1][one], dp[i][one] + cost1);
// 左の偶数区間
int cost2 = v[i] == 0 ? 2 : v[i] % 2;
chmin(dp[i + 1][two], min(dp[i][one], dp[i][two]) + cost2);
// 奇数区間
int cost3 = v[i] == 0 ? 1 : (v[i] % 2 == 0);
chmin(dp[i + 1][three],
min({dp[i][two], dp[i][three], dp[i][one]}) + cost3);
// 右の偶数区間
int cost4 = v[i] == 0 ? 2 : v[i] % 2;
chmin(dp[i + 1][four],
min({dp[i][three], dp[i][four], dp[i][two], dp[i][one]}) + cost4);
// 右のゼロ区間
int cost5 = v[i];
chmin(dp[i + 1][five], min({dp[i][four], dp[i][three], dp[i][two],
dp[i][one], dp[i][five]}) +
cost5);
}
int ans = INF;
rep(i, VARI) { chmin(ans, dp[N][i]); }
cout << ans << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,202 | 941,203 | u219873012 | cpp |
p03132 | #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define vi vector<ll>
#define vvi vector<vi>
#define BITLE(n) (1LL << (n))
#define BITCNT(n) (__builtin_popcountll(n))
#define SUBS(s, f, t) (s.substr(f - 1, t - f + 1))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
struct Grid {
ll x, y, t;
};
struct Edge {
ll to, cost;
};
struct Graph {
vector<vector<Edge>> E;
int V;
const ll Inf = llINF;
const int MAX_V = 201010;
vector<ll> d;
Graph(int n) : E(n) {
d.resize(MAX_V);
E.resize(n);
V = n;
}
void init() {
for (int i = 0; i < MAX_V; i++)
d[i] = Inf;
}
void add_edge(ll from, ll to, ll cost) { E[from].pb({to, cost}); }
};
ll L;
vi A(210000);
ll dp[210000][5];
ll cost(ll sta, ll i) {
if (sta == 0 || sta == 4) {
return A[i];
} else if (sta == 1 || sta == 3) {
if (A[i] % 2 == 0 && A[i] != 0)
return 0;
else if (A[i] == 0)
return 2;
else
return 1;
} else if (sta == 2) {
return (A[i] % 2 == 0) ? 1 : 0;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> L;
for (int i = 0; i < L; i++)
cin >> A[i];
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 5; j++)
dp[i][j] = llINF;
dp[0][0] = 0;
for (int i = 0; i < 210000; i++) {
for (int j = 0; j < 5; j++) {
for (int k = j; k < 5; k++)
dp[i + 1][k] = min(dp[i + 1][k], dp[i][j] + cost(i, k));
}
}
ll ans = llINF;
for (int i = 0; i < 5; i++)
ans = min(ans, dp[L][i]);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define vi vector<ll>
#define vvi vector<vi>
#define BITLE(n) (1LL << (n))
#define BITCNT(n) (__builtin_popcountll(n))
#define SUBS(s, f, t) (s.substr(f - 1, t - f + 1))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
struct Grid {
ll x, y, t;
};
struct Edge {
ll to, cost;
};
struct Graph {
vector<vector<Edge>> E;
int V;
const ll Inf = llINF;
const int MAX_V = 201010;
vector<ll> d;
Graph(int n) : E(n) {
d.resize(MAX_V);
E.resize(n);
V = n;
}
void init() {
for (int i = 0; i < MAX_V; i++)
d[i] = Inf;
}
void add_edge(ll from, ll to, ll cost) { E[from].pb({to, cost}); }
};
ll L;
vi A(210000);
ll dp[210000][5];
ll cost(ll sta, ll i) {
if (sta == 0 || sta == 4) {
return A[i];
} else if (sta == 1 || sta == 3) {
if (A[i] % 2 == 0 && A[i] != 0)
return 0;
else if (A[i] == 0)
return 2;
else
return 1;
} else if (sta == 2) {
return (A[i] % 2 == 0) ? 1 : 0;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> L;
for (int i = 0; i < L; i++)
cin >> A[i];
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 5; j++)
dp[i][j] = llINF;
dp[0][0] = 0;
for (int i = 0; i < L; i++) {
for (int j = 0; j < 5; j++) {
for (int k = j; k < 5; k++)
dp[i + 1][k] = min(dp[i + 1][k], dp[i][j] + cost(k, i));
}
}
ll ans = llINF;
for (int i = 0; i < 5; i++)
ans = min(ans, dp[L][i]);
cout << ans << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.arguments.change",
"call.arguments.add"
] | 941,218 | 941,217 | u905715926 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define all(x) (x).begin(), (x).end()
#define foreach(u, v) for (auto(u) : (v))
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
const int inf = 1e9;
const ll linf = 1LL << 60;
const ll mod = 1e9 + 7;
const double eps = 1e-9;
/*
dp[i][j]
i個目までで
j : どの状態か
0=散歩前(コストa[i])
1=スタートからいくつか(奇数はコスト)
2=あいだ（偶数はコスト)
3=ゴールからいくつか(奇数はコスト)
4=散歩後(コストa[i])
のときのコストの最小値
*/
ll dp[200001][5];
signed main() {
int n;
cin >> n;
vi a(n);
rep(i, n) cin >> a[i];
rep(i, 200001) rep(j, 5) dp[i][j] = i == 0 ? 0 : linf;
rep(i, n) {
int c = a[i], mindp = dp[i][0];
dp[i + 1][0] = min(dp[i + 1][0], mindp + c);
c = a[i] == 0 ? 2 : a[i] % 2;
mindp = min(mindp, dp[i][1]);
dp[i + 1][1] = min(dp[i + 1][1], mindp + c);
c = a[i] % 2 == 0;
mindp = min(mindp, dp[i][2]);
dp[i + 1][2] = min(dp[i + 1][2], mindp + c);
c = a[i] == 0 ? 2 : a[i] % 2;
mindp = min(mindp, dp[i][3]);
dp[i + 1][3] = min(dp[i + 1][3], mindp + c);
c = a[i];
mindp = min(mindp, dp[i][2]);
dp[i + 1][4] = min(dp[i + 1][4], mindp + c);
}
ll ans = linf;
rep(i, 5) {
ans = min(ans, dp[n][i]);
// cout << dp[n][i] << endl;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define all(x) (x).begin(), (x).end()
#define foreach(u, v) for (auto(u) : (v))
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
const int inf = 1e9;
const ll linf = 1LL << 60;
const ll mod = 1e9 + 7;
const double eps = 1e-9;
/*
dp[i][j]
i個目までで
j : どの状態か
0=散歩前(コストa[i])
1=スタートからいくつか(奇数はコスト)
2=あいだ（偶数はコスト)
3=ゴールからいくつか(奇数はコスト)
4=散歩後(コストa[i])
のときのコストの最小値
*/
ll dp[200001][5];
signed main() {
int n;
cin >> n;
vi a(n);
rep(i, n) cin >> a[i];
rep(i, 200001) rep(j, 5) dp[i][j] = i == 0 ? 0 : linf;
rep(i, n) {
int c = a[i], mindp = dp[i][0];
dp[i + 1][0] = min(dp[i + 1][0], mindp + c);
c = a[i] == 0 ? 2 : a[i] % 2;
mindp = min(mindp, dp[i][1]);
dp[i + 1][1] = min(dp[i + 1][1], mindp + c);
c = a[i] % 2 == 0;
mindp = min(mindp, dp[i][2]);
dp[i + 1][2] = min(dp[i + 1][2], mindp + c);
c = a[i] == 0 ? 2 : a[i] % 2;
mindp = min(mindp, dp[i][3]);
dp[i + 1][3] = min(dp[i + 1][3], mindp + c);
c = a[i];
mindp = min(mindp, dp[i][4]);
dp[i + 1][4] = min(dp[i + 1][4], mindp + c);
}
ll ans = linf;
rep(i, 5) {
ans = min(ans, dp[n][i]);
// cout << dp[n][i] << endl;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 941,219 | 941,220 | u057866967 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << x << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
#define CHMIN(a, b) a = min((a), (b))
#define CHMAX(a, b) a = max((a), (b))
const ll MOD = 1000000007ll;
// const ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-11;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
ll sum[252521], dp1[252521], dp2[252521], dp3[252521];
ll INF = 1e16;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int l;
ll a[252521];
cin >> l;
bool ok = false;
REP(i, l) {
cin >> a[i];
if (a[i]) {
ok = true;
}
sum[i + 1] = sum[i] + a[i];
}
if (!ok) {
cout << 0 << '\n';
return 0;
}
dp1[0] = dp2[0] = dp3[0] = INF;
ll ans = INF;
REP(i, l) {
dp1[i + 1] = min(dp1[i], sum[i]) + (a[i] == 0 ? 2 : a[i] & 1);
dp2[i + 1] = min({dp1[i], dp2[i], sum[i]}) + (~a[i] & 1);
dp3[i + 1] =
min({dp1[i], dp2[i], dp3[i], sum[i]}) + (a[i] == 0 ? 2 : a[i] & 1);
ans = min({ans, dp1[i + 1], dp2[i + 1], dp3[i + 1]}) + sum[l] - sum[i + 1];
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << x << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
#define CHMIN(a, b) a = min((a), (b))
#define CHMAX(a, b) a = max((a), (b))
const ll MOD = 1000000007ll;
// const ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-11;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
ll sum[252521], dp1[252521], dp2[252521], dp3[252521];
ll INF = 1e16;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int l;
ll a[252521];
cin >> l;
bool ok = false;
REP(i, l) {
cin >> a[i];
if (a[i]) {
ok = true;
}
sum[i + 1] = sum[i] + a[i];
}
if (!ok) {
cout << 0 << '\n';
return 0;
}
dp1[0] = dp2[0] = dp3[0] = INF;
ll ans = INF;
REP(i, l) {
dp1[i + 1] = min(dp1[i], sum[i]) + (a[i] == 0 ? 2 : a[i] & 1);
dp2[i + 1] = min({dp1[i], dp2[i], sum[i]}) + (~a[i] & 1);
dp3[i + 1] =
min({dp1[i], dp2[i], dp3[i], sum[i]}) + (a[i] == 0 ? 2 : a[i] & 1);
CHMIN(ans, min({dp1[i + 1], dp2[i + 1], dp3[i + 1]}) + sum[l] - sum[i + 1]);
}
cout << ans << '\n';
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 941,225 | 941,226 | u833393891 | cpp |
p03132 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
ll dp[202020][5];
int main() {
int n;
cin >> n;
ll a[n];
rep(i, n) cin >> a[i];
rep(i, n) {
dp[i + 1][0] = dp[i][0] + a[i];
dp[i + 1][1] = min(dp[i + 1][0], dp[i][1] + a[i] % 2 + (!a[i]) * 2);
dp[i + 1][2] = min(dp[i + 1][1], dp[i][2] + (a[i] + 1) % 2);
dp[i + 1][3] = min(dp[i + 1][2], dp[i][2] + a[i] % 2 + (!a[i]) * 2);
dp[i + 1][4] = min(dp[i + 1][3], dp[i][4] + a[i]);
}
cout << dp[n][4] << endl;
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
ll dp[202020][5];
int main() {
int n;
cin >> n;
ll a[n];
rep(i, n) cin >> a[i];
rep(i, n) {
dp[i + 1][0] = dp[i][0] + a[i];
dp[i + 1][1] = min(dp[i + 1][0], dp[i][1] + a[i] % 2 + (!a[i]) * 2);
dp[i + 1][2] = min(dp[i + 1][1], dp[i][2] + !(a[i] & 1));
dp[i + 1][3] = min(dp[i + 1][2], dp[i][3] + a[i] % 2 + (!a[i]) * 2);
dp[i + 1][4] = min(dp[i + 1][3], dp[i][4] + a[i]);
}
cout << dp[n][4] << endl;
return 0;
}
| [
"expression.operation.unary.add",
"call.arguments.change",
"assignment.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"literal.number.change",
"variable_access.subscript.index.change"
] | 941,231 | 941,232 | u352642493 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (int i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class S> S sum(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void YN(bool b) { cout << (b ? "YES" : "NO") << "\n"; }
void Yn(bool b) { cout << (b ? "Yes" : "No") << "\n"; }
void yn(bool b) { cout << (b ? "yes" : "no") << "\n"; }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll mx = 0;
cin >> n;
vl a(n + 2);
rep(i, n) cin >> a[i + 1];
vl sum(n + 2);
rep(i, n) {
ll t = (a[i + 1] == 0 ? -1 : (a[i + 1] + 1) / 2 * 2 - 1);
sum[i + 1] = sum[i] + t;
}
mx = accumulate(all(a), 0LL);
// cout<<sum<<endl;;
vl rsum(n + 2), lsum(n + 2);
ll cur = 0, mn = 0;
rep(i, n) {
ll t = (a[i + 1] == 0 ? -2 : a[i + 1] / 2 * 2);
cur += t;
chmin(mn, cur);
lsum[i + 1] = cur - mn;
}
cur = 0;
mn = 0;
rrep(i, n) {
ll t = (a[i + 1] == 0 ? -2 : a[i + 1] / 2 * 2);
cur += t;
chmin(mn, cur);
rsum[i + 1] = cur - mn;
}
vl lans(n + 2);
vl rans(n + 2);
rep(i, n + 2) { lans[i] = rans[i] = sum[i]; }
rep(i, n) { lans[i + 1] -= lsum[i + 1]; }
rep(i, n) { rans[i + 1] += rsum[i + 2]; }
ll ans = 0;
mn = LINF;
ll ansmx = -LINF;
ll l, r, rr;
/*
cout<<lsum<<endl;
cout<<rsum<<endl;
cout<<lans<<endl;
cout<<rans<<endl;
*/
range(i, 1, n + 1) {
if (chmin(mn, lans[i]))
rr = i;
ll t = rans[i] - mn;
if (ansmx < t) {
r = i;
l = rr;
ansmx = t;
}
}
// cout<<l<<" "<<r<<endl;
cout << mx - ansmx << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll>;
using tlll = tuple<ll, ll, ll>;
using vs = vector<string>;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) range(i, 0, n)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define range(i, a, n) for (int i = (a); i < (n); i++)
#define LINF ((ll)1ll << 60)
#define INF ((int)1 << 30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout << setprecision(a) << fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class S> S sum(vector<S> &a) { return accumulate(all(a), S()); }
template <class S> S max(vector<S> &a) { return *max_element(all(a)); }
template <class S> S min(vector<S> &a) { return *min_element(all(a)); }
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void YN(bool b) { cout << (b ? "YES" : "NO") << "\n"; }
void Yn(bool b) { cout << (b ? "Yes" : "No") << "\n"; }
void yn(bool b) { cout << (b ? "yes" : "no") << "\n"; }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
template <class T> void puta(T &&t) { cout << t << "\n"; }
template <class H, class... T> void puta(H &&h, T &&...t) {
cout << h << ' ';
puta(t...);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
};
template <class S> auto &operator<<(ostream &os, vector<S> t) {
bool a = 1;
for (auto s : t) {
os << (a ? "" : " ") << s;
a = 0;
}
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll mx = 0;
cin >> n;
vl a(n + 2);
rep(i, n) cin >> a[i + 1];
vl sum(n + 2);
rep(i, n) {
ll t = (a[i + 1] == 0 ? -1 : (a[i + 1] + 1) / 2 * 2 - 1);
sum[i + 1] = sum[i] + t;
}
mx = accumulate(all(a), 0LL);
// cout<<sum<<endl;;
vl rsum(n + 2), lsum(n + 2);
ll cur = 0, mn = 0;
rep(i, n) {
ll t = (a[i + 1] == 0 ? -2 : a[i + 1] / 2 * 2);
cur += t;
chmin(mn, cur);
lsum[i + 1] = cur - mn;
}
cur = 0;
mn = 0;
rrep(i, n) {
ll t = (a[i + 1] == 0 ? -2 : a[i + 1] / 2 * 2);
cur += t;
chmin(mn, cur);
rsum[i + 1] = cur - mn;
}
vl lans(n + 2);
vl rans(n + 2);
rep(i, n + 2) { lans[i] = rans[i] = sum[i]; }
rep(i, n) { lans[i + 1] -= lsum[i + 1]; }
rep(i, n) { rans[i + 1] += rsum[i + 2]; }
ll ans = 0;
mn = LINF;
ll ansmx = -LINF;
ll l, r, rr;
/*
cout<<lsum<<endl;
cout<<rsum<<endl;
cout<<lans<<endl;
cout<<rans<<endl;
*/
range(i, 0, n + 1) {
if (chmin(mn, lans[i]))
rr = i;
ll t = rans[i] - mn;
if (ansmx < t) {
r = i;
l = rr;
ansmx = t;
}
}
// cout<<l<<" "<<r<<endl;
cout << mx - ansmx << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 941,237 | 941,238 | u591883167 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
ll L;
ll A[200050];
ll sum[200050];
ll even[200050];
ll odd[200050];
ll even_after[200050];
ll even_before[200050];
ll odd_after[200050];
ll odd_before[200050];
int main() {
// cout.precision(10);
cin >> L;
for (int i = 1; i <= L; i++) {
cin >> A[i];
sum[i] = sum[i - 1] + A[i];
even[i] = even[i - 1];
if (A[i] % 2 == 1)
even[i]++;
if (A[i] == 0)
even[i] += 2;
odd[i] = odd[i - 1];
if (A[i] % 2 == 0)
odd[i]++;
}
for (int i = 1; i <= L; i++) {
even_before[i] = min(even_before[i - 1] + (even[i] - even[i - 1]), sum[i]);
odd_before[i] =
min(odd_before[i - 1] + (odd[i] - odd[i - 1]), even_before[i]);
// cout << i << " " << even_before[i] << " " << odd_before[i] << endl;
}
// for(int i = L; i >= 1; i--) {
// even_after[i] = min(even_after[i + 1] + (even[i] - even[i - 1]),
// sum[L] - sum[i - 1]); odd_after[i] = min(odd_after[i + 1] + (odd[i]
// - odd[i - 1]), even_after[i]);
// }
for (int i = L - 1; i >= 0; i--) {
even_after[i] =
min(even_after[i + 1] + (even[i + 1] - even[i]), sum[L] - sum[i + 1]);
odd_after[i] = min(odd_after[i + 1] + (odd[i + 1] - odd[i]), even_after[i]);
}
ll ans = 1e16;
for (int i = 0; i <= L; i++) {
ans = min(ans, odd_before[i] + odd_after[i]);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
ll L;
ll A[200050];
ll sum[200050];
ll even[200050];
ll odd[200050];
ll even_after[200050];
ll even_before[200050];
ll odd_after[200050];
ll odd_before[200050];
int main() {
// cout.precision(10);
cin >> L;
for (int i = 1; i <= L; i++) {
cin >> A[i];
sum[i] = sum[i - 1] + A[i];
even[i] = even[i - 1];
if (A[i] % 2 == 1)
even[i]++;
if (A[i] == 0)
even[i] += 2;
odd[i] = odd[i - 1];
if (A[i] % 2 == 0)
odd[i]++;
}
for (int i = 1; i <= L; i++) {
even_before[i] = min(even_before[i - 1] + (even[i] - even[i - 1]), sum[i]);
odd_before[i] =
min(odd_before[i - 1] + (odd[i] - odd[i - 1]), even_before[i]);
// cout << i << " " << even_before[i] << " " << odd_before[i] << endl;
}
// for(int i = L; i >= 1; i--) {
// even_after[i] = min(even_after[i + 1] + (even[i] - even[i - 1]),
// sum[L] - sum[i - 1]); odd_after[i] = min(odd_after[i + 1] + (odd[i]
// - odd[i - 1]), even_after[i]);
// }
for (int i = L - 1; i >= 0; i--) {
even_after[i] =
min(even_after[i + 1] + (even[i + 1] - even[i]), sum[L] - sum[i]);
odd_after[i] = min(odd_after[i + 1] + (odd[i + 1] - odd[i]), even_after[i]);
}
ll ans = 1e16;
for (int i = 0; i <= L; i++) {
ans = min(ans, odd_before[i] + odd_after[i]);
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 941,242 | 941,243 | u709243470 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9;
const int MOD = 1e9 + 7;
ll dp[200010][10];
int main() {
ll l;
cin >> l;
vector<ll> a(l);
for (auto &e : a)
cin >> e;
for (int i = 0; i <= l; ++i) {
for (int j = 0; j < 5; ++j)
dp[i][j] = 1 << 60;
}
dp[0][0] = 0;
for (int i = 0; i < l; ++i) {
ll nmin = dp[i][0];
dp[i + 1][0] = min(dp[i + 1][0], nmin + a[i]);
nmin = min(dp[i][1], nmin);
dp[i + 1][1] = min(dp[i + 1][1], nmin + a[i] % 2 + 2 * (a[i] == 0));
nmin = min(dp[i][2], nmin);
dp[i + 1][2] = min(dp[i + 1][2], nmin + (a[i] + 1) % 2);
nmin = min(dp[i][3], nmin);
dp[i + 1][3] = min(dp[i + 1][3], nmin + a[i] % 2 + 2 * (a[i] == 0));
nmin = min(dp[i][3], nmin);
dp[i + 1][4] = min(dp[i + 1][4], nmin + a[i]);
}
cout << min({dp[l][0], dp[l][1], dp[l][2], dp[l][3], dp[l][4]}) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9;
const int MOD = 1e9 + 7;
ll dp[200010][10];
int main() {
ll l;
cin >> l;
vector<ll> a(l);
for (auto &e : a)
cin >> e;
for (int i = 0; i <= l; ++i) {
for (int j = 0; j < 5; ++j)
dp[i][j] = 1LL << 60;
}
dp[0][0] = 0;
for (int i = 0; i < l; ++i) {
ll nmin = dp[i][0];
dp[i + 1][0] = min(dp[i + 1][0], nmin + a[i]);
nmin = min(dp[i][1], nmin);
dp[i + 1][1] = min(dp[i + 1][1], nmin + a[i] % 2 + 2 * (a[i] == 0));
nmin = min(dp[i][2], nmin);
dp[i + 1][2] = min(dp[i + 1][2], nmin + (a[i] + 1) % 2);
nmin = min(dp[i][3], nmin);
dp[i + 1][3] = min(dp[i + 1][3], nmin + a[i] % 2 + 2 * (a[i] == 0));
nmin = min(dp[i][4], nmin);
dp[i + 1][4] = min(dp[i + 1][4], nmin + a[i]);
}
cout << min({dp[l][0], dp[l][1], dp[l][2], dp[l][3], dp[l][4]}) << endl;
return 0;
} | [
"literal.number.type.widen.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 941,248 | 941,249 | u054652697 | cpp |
p03132 | #include <algorithm>
#include <iostream>
using namespace std;
int n;
long dp[2 << 17][5];
main() {
cin >> n;
for (int i = 0; i++ < n + 1;) {
long a = 0;
cin >> a;
long now = 9e18;
for (int j = 0; j < 5; j++) {
now = min(now, dp[i - 1][j]);
dp[i][j] = now + (j - 2 ? j % 2 ? a ? a % 2 : 1 : a : 1 - a % 2);
}
}
cout << dp[n + 1][4] << endl;
}
| #include <algorithm>
#include <iostream>
using namespace std;
int n;
long dp[2 << 17][5];
main() {
cin >> n;
for (int i = 0; i++ < n + 1;) {
long a = 0;
cin >> a;
long now = 9e18;
for (int j = 0; j < 5; j++) {
now = min(now, dp[i - 1][j]);
dp[i][j] = now + (j - 2 ? j % 2 ? a ? a % 2 : 2 : a : 1 - a % 2);
}
}
cout << dp[n + 1][4] << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,250 | 941,251 | u657913472 | cpp |
p03132 | #include <bits/stdc++.h>
#define Pct puts("------ Yes ------");
#define rep(a, b, c) for (int a = (b); a <= (c); ++a)
#define per(a, b, c) for (int a = (b); a >= (c); --a)
#define fir first
#define sec second
#define ls son[u][0]
#define rs son[u][1]
#define eps 1e-8
#define PI acos(-1.0)
using namespace std;
template <class T> void rd(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
x *= f;
}
typedef long long ll;
const int N = 2e5 + 5;
ll f[N][5], a[N];
int n, s, m;
ll min3(ll a, ll b, ll c) { return min(min(a, b), c); }
void sol() {
rep(i, 1, n) {
f[i][0] = f[i - 1][0];
rep(j, 1, 4) f[i][j] = min(f[i - 1][j], f[i - 1][j - 1]);
f[i][0] += a[i];
f[i][1] += (a[i] == 0 ? 2 : a[i] % 2);
f[i][2] += (a[i] % 2 == 0);
f[i][3] += (a[i] == 0 ? 2 : a[i] % 2);
f[i][4] += a[i];
}
printf("%lld\n", min3(f[n][0], f[n][1], min3(f[n][2], f[n][3], f[n][4])));
}
int main() {
rd(n);
rep(i, 1, n) rd(a[i]);
sol();
return 0;
} | #include <bits/stdc++.h>
#define Pct puts("------ Yes ------");
#define rep(a, b, c) for (int a = (b); a <= (c); ++a)
#define per(a, b, c) for (int a = (b); a >= (c); --a)
#define fir first
#define sec second
#define ls son[u][0]
#define rs son[u][1]
#define eps 1e-8
#define PI acos(-1.0)
using namespace std;
template <class T> void rd(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
x *= f;
}
typedef long long ll;
const int N = 2e5 + 5;
ll f[N][5], a[N];
int n, s, m;
ll min3(ll a, ll b, ll c) { return min(min(a, b), c); }
void sol() {
rep(i, 1, n) {
f[i][0] = f[i - 1][0];
rep(j, 1, 4) f[i][j] = min(f[i - 1][j], f[i][j - 1]);
f[i][0] += a[i];
f[i][1] += (a[i] == 0 ? 2 : a[i] % 2);
f[i][2] += (a[i] % 2 == 0);
f[i][3] += (a[i] == 0 ? 2 : a[i] % 2);
f[i][4] += a[i];
}
printf("%lld\n", min3(f[n][0], f[n][1], min3(f[n][2], f[n][3], f[n][4])));
}
int main() {
rd(n);
rep(i, 1, n) rd(a[i]);
sol();
return 0;
} | [
"expression.operation.binary.remove"
] | 941,252 | 941,253 | u383898108 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x, to) for (x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
//-------------------------------------------------------
int N;
int A[202020];
ll S[202020];
ll L[202020][3];
ll R[202020];
ll dp[202020][5];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N;
dp[0][1] = dp[0][2] = dp[0][3] = dp[0][4] = 1LL << 60;
FOR(i, N) {
cin >> A[i];
dp[i + 1][0] = dp[i][0] + A[i];
dp[i + 1][1] = min({dp[i][0], dp[i][1]}) + (A[i] == 0 ? 2 : A[i] % 2);
dp[i + 1][2] = min({dp[i][0], dp[i][1], dp[i][2]}) + (1 - A[i] % 2);
dp[i + 1][3] = min({dp[i][0], dp[i][1], dp[i][3], dp[i][4]}) +
(A[i] == 0 ? 2 : A[i] % 2);
dp[i + 1][4] =
min({dp[i][0], dp[i][1], dp[i][2], dp[i][3], dp[i][4]}) + A[i];
}
cout << min({dp[N][0], dp[N][1], dp[N][2], dp[N][3], dp[N][4]}) << endl;
}
int main(int argc, char **argv) {
string s;
int i;
if (argc == 1)
ios::sync_with_stdio(false), cin.tie(0);
FOR(i, argc - 1) s += argv[i + 1], s += '\n';
FOR(i, s.size()) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x, to) for (x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
//-------------------------------------------------------
int N;
int A[202020];
ll S[202020];
ll L[202020][3];
ll R[202020];
ll dp[202020][5];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N;
dp[0][1] = dp[0][2] = dp[0][3] = dp[0][4] = 1LL << 60;
FOR(i, N) {
cin >> A[i];
dp[i + 1][0] = dp[i][0] + A[i];
dp[i + 1][1] = min({dp[i][0], dp[i][1]}) + ((A[i] == 0) ? 2 : A[i] % 2);
dp[i + 1][2] = min({dp[i][0], dp[i][1], dp[i][2]}) + (1 - A[i] % 2);
dp[i + 1][3] = min({dp[i][0], dp[i][1], dp[i][2], dp[i][3]}) +
((A[i] == 0) ? 2 : A[i] % 2);
dp[i + 1][4] =
min({dp[i][0], dp[i][1], dp[i][2], dp[i][3], dp[i][4]}) + A[i];
}
cout << min({dp[N][0], dp[N][1], dp[N][2], dp[N][3], dp[N][4]}) << endl;
}
int main(int argc, char **argv) {
string s;
int i;
if (argc == 1)
ios::sync_with_stdio(false), cin.tie(0);
FOR(i, argc - 1) s += argv[i + 1], s += '\n';
FOR(i, s.size()) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,256 | 941,257 | u452725238 | cpp |
p03132 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int l, a[200005];
ll f[200005][5];
void upd(ll &x, ll y) {
if (x > y)
x = y;
}
int cost(int x, int y) {
if (x == -1)
return y;
if (x == 0)
return y == 0 || y % 2;
return 1 - y % 2;
}
int main() {
scanf("%d", &l);
for (int i = 1; i <= l; i++)
scanf("%d", a + i);
memset(f, 0x3f, sizeof f);
f[0][0] = 0;
for (int i = 0; i < l; i++)
for (int j = 0; j < 5; j++)
for (int k = j; k < 5; k++)
upd(f[i + 1][k], f[i][j] + cost(k == 0 || k == 4 ? -1
: k == 1 || k == 3 ? 0
: 1,
a[i + 1]));
printf("%lld\n", min({f[l][0], f[l][1], f[l][2], f[l][3], f[l][4]}));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int l, a[200005];
ll f[200005][5];
void upd(ll &x, ll y) {
if (x > y)
x = y;
}
int cost(int x, int y) {
if (x == -1)
return y;
if (x == 0)
return y == 0 ? 2 : y % 2;
return 1 - y % 2;
}
int main() {
scanf("%d", &l);
for (int i = 1; i <= l; i++)
scanf("%d", a + i);
memset(f, 0x3f, sizeof f);
f[0][0] = 0;
for (int i = 0; i < l; i++)
for (int j = 0; j < 5; j++)
for (int k = j; k < 5; k++)
upd(f[i + 1][k], f[i][j] + cost(k == 0 || k == 4 ? -1
: k == 1 || k == 3 ? 0
: 1,
a[i + 1]));
printf("%lld\n", min({f[l][0], f[l][1], f[l][2], f[l][3], f[l][4]}));
return 0;
}
| [
"function.return_value.change",
"expression.operation.binary.change"
] | 941,269 | 941,270 | u760178976 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
#define MAXN 100006
typedef long long ll;
ll A[MAXN], B[MAXN], idx[MAXN];
ll n, resa, resb;
bool cmp(ll x, ll y) { return abs(A[x] - B[x]) > abs(A[y] - B[y]); }
int main() {
// freopen("input","r",stdin);
cin >> n;
for (ll i = 1; i <= n; ++i)
scanf("%lld%lld", &A[i], &B[i]), idx[i] = i;
sort(idx + 1, idx + 1 + n, cmp);
ll i = 1, j = 2;
while (j <= n)
resa += A[idx[i]], resb += B[idx[j]], i += 2, j += 2;
if (i == j)
resa += A[idx[i]];
cout << resa - resb;
}
| #include <algorithm>
#include <iostream>
using namespace std;
#define MAXN 100006
typedef long long ll;
ll A[MAXN], B[MAXN], idx[MAXN];
ll n, resa, resb;
bool cmp(ll x, ll y) { return (A[x] + B[x]) > (A[y] + B[y]); }
int main() {
// freopen("input","r",stdin);
cin >> n;
for (ll i = 1; i <= n; ++i)
scanf("%lld%lld", &A[i], &B[i]), idx[i] = i;
sort(idx + 1, idx + 1 + n, cmp);
ll i = 1, j = 2;
while (j <= n)
resa += A[idx[i]], resb += B[idx[j]], i += 2, j += 2;
if (i == n)
resa += A[idx[i]];
cout << resa - resb;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 941,271 | 941,272 | u390140944 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
#define MAXN 100006
typedef long long ll;
ll A[MAXN], B[MAXN], idx[MAXN];
ll n, resa, resb;
bool cmp(ll x, ll y) { return (A[x] - B[x]) > (A[y] - B[y]); }
int main() {
// freopen("input","r",stdin);
cin >> n;
for (ll i = 1; i <= n; ++i)
scanf("%lld%lld", &A[i], &B[i]), idx[i] = i;
sort(idx + 1, idx + 1 + n, cmp);
ll i = 1, j = 2;
while (j <= n)
resa += A[idx[i]], resb += B[idx[j]], i += 2, j += 2;
if (i == n)
resa += A[idx[i]];
cout << resa - resb;
}
| #include <algorithm>
#include <iostream>
using namespace std;
#define MAXN 100006
typedef long long ll;
ll A[MAXN], B[MAXN], idx[MAXN];
ll n, resa, resb;
bool cmp(ll x, ll y) { return (A[x] + B[x]) > (A[y] + B[y]); }
int main() {
// freopen("input","r",stdin);
cin >> n;
for (ll i = 1; i <= n; ++i)
scanf("%lld%lld", &A[i], &B[i]), idx[i] = i;
sort(idx + 1, idx + 1 + n, cmp);
ll i = 1, j = 2;
while (j <= n)
resa += A[idx[i]], resb += B[idx[j]], i += 2, j += 2;
if (i == n)
resa += A[idx[i]];
cout << resa - resb;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,273 | 941,272 | u390140944 | cpp |
p03141 | #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
#define _USE_MATH_DEFINES
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
using namespace std;
#define EPS 1e-12
#define ull unsigned long long
#define ll long long
#define VI vector<ll>
#define PII pair<ll, ll>
#define VVI vector<vector<ll>>
#define REP(i, n) for (int i = 0, _n = (n); (i) < (int)_n; ++i)
#define RANGE(i, a, b) for (int i = (int)a, _b = (int)(b); (i) < _b; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define ALLR(c) (c).rbegin(), (c).rend()
#define PB push_back
#define MP(a, b) make_pair(a, b)
#define POPCOUNT __builtin_popcount
#define POPCOUNTLL __builtin_popcountll
#define CLEAR(table, v) memset(table, v, sizeof(table));
#define PRINT1(table, D0) \
REP(d0, D0) cout << table[d0] << " "; \
cout << "\n";
#define PRINT2(table, D0, D1) \
REP(d0, D0) { \
REP(d1, D1) cout << table[d0][d1] << " "; \
cout << "\n"; \
}
#define PRINT3(table, D0, D1, D2) \
REP(d0, D0) { \
REP(d1, D1) { \
REP(d2, D2) cout << table[d0][d1][d2] << " "; \
cout << "\n"; \
} \
cout << "\n"; \
}
#define UNIFORM_DOUBLE(a, b) \
(((b - a) * (double)rand() / RAND_MAX) + a) // [a, b)
#define UNIFORM_LL(a, b) (ll) UNIFORM_DOUBLE(a, b) // [a, b)
#define IN(v, lo, hi) ((lo) <= (v) && (v) < (hi))
#define DD(v) cout << #v << ": " << v << endl
template <typename T0, typename T1>
std::ostream &operator<<(std::ostream &os, const map<T0, T1> &v) {
for (typename map<T0, T1>::const_iterator p = v.begin(); p != v.end(); p++) {
os << p->first << ": " << p->second << " ";
}
return os;
}
template <typename T0, typename T1>
std::ostream &operator<<(std::ostream &os, const pair<T0, T1> &v) {
os << v.first << ": " << v.second << " ";
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << " ";
}
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << endl;
}
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const set<T> &v) {
vector<T> tmp(v.begin(), v.end());
os << tmp;
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const deque<T> &v) {
vector<T> tmp(v.begin(), v.end());
os << tmp;
return os;
}
#define MOD 1000000007LL
#define INF (1LL << 60)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, A, B;
while (cin >> N) {
VI A(N), B(N);
vector<pair<ll, pair<ll, ll>>> d(N);
REP(i, N) {
cin >> A[i] >> B[i];
d[i] = MP(A[i] - B[i], MP(A[i], i));
}
sort(ALLR(d));
// DD(d);
ll ans = 0;
REP(i, N) {
ll idx = d[i].second.second;
ans += (i & 1) == 0 ? A[idx] : -B[idx];
}
cout << ans << endl;
}
return 0;
}
| #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
#define _USE_MATH_DEFINES
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
using namespace std;
#define EPS 1e-12
#define ull unsigned long long
#define ll long long
#define VI vector<ll>
#define PII pair<ll, ll>
#define VVI vector<vector<ll>>
#define REP(i, n) for (int i = 0, _n = (n); (i) < (int)_n; ++i)
#define RANGE(i, a, b) for (int i = (int)a, _b = (int)(b); (i) < _b; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define ALLR(c) (c).rbegin(), (c).rend()
#define PB push_back
#define MP(a, b) make_pair(a, b)
#define POPCOUNT __builtin_popcount
#define POPCOUNTLL __builtin_popcountll
#define CLEAR(table, v) memset(table, v, sizeof(table));
#define PRINT1(table, D0) \
REP(d0, D0) cout << table[d0] << " "; \
cout << "\n";
#define PRINT2(table, D0, D1) \
REP(d0, D0) { \
REP(d1, D1) cout << table[d0][d1] << " "; \
cout << "\n"; \
}
#define PRINT3(table, D0, D1, D2) \
REP(d0, D0) { \
REP(d1, D1) { \
REP(d2, D2) cout << table[d0][d1][d2] << " "; \
cout << "\n"; \
} \
cout << "\n"; \
}
#define UNIFORM_DOUBLE(a, b) \
(((b - a) * (double)rand() / RAND_MAX) + a) // [a, b)
#define UNIFORM_LL(a, b) (ll) UNIFORM_DOUBLE(a, b) // [a, b)
#define IN(v, lo, hi) ((lo) <= (v) && (v) < (hi))
#define DD(v) cout << #v << ": " << v << endl
template <typename T0, typename T1>
std::ostream &operator<<(std::ostream &os, const map<T0, T1> &v) {
for (typename map<T0, T1>::const_iterator p = v.begin(); p != v.end(); p++) {
os << p->first << ": " << p->second << " ";
}
return os;
}
template <typename T0, typename T1>
std::ostream &operator<<(std::ostream &os, const pair<T0, T1> &v) {
os << v.first << ": " << v.second << " ";
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << " ";
}
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << endl;
}
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const set<T> &v) {
vector<T> tmp(v.begin(), v.end());
os << tmp;
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const deque<T> &v) {
vector<T> tmp(v.begin(), v.end());
os << tmp;
return os;
}
#define MOD 1000000007LL
#define INF (1LL << 60)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, A, B;
while (cin >> N) {
VI A(N), B(N);
vector<pair<ll, pair<ll, ll>>> d(N);
REP(i, N) {
cin >> A[i] >> B[i];
d[i] = MP(A[i] + B[i], MP(A[i], i));
}
sort(ALLR(d));
// DD(d);
ll ans = 0;
REP(i, N) {
ll idx = d[i].second.second;
ans += (i & 1) == 0 ? A[idx] : -B[idx];
}
cout << ans << endl;
}
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,274 | 941,275 | u655723240 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long long n, A[200000], B[200000], C[200000];
long long ans = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i] >> B[i];
for (int i = 0; i < n; i++)
C[i] = A[i] + B[i];
vector<pair<long long, long long>> D(n);
for (int i = 0; i < n; i++)
D[i] = make_pair(C[i], i);
sort(D.begin(), D.end());
for (int i = n - 1; i >= 0; i--) {
if (i % 2 == 0)
ans += A[D[i].second];
else
ans -= B[D[i].second];
}
cout << ans;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
long long n, A[200000], B[200000], C[200000];
long long ans = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i] >> B[i];
for (int i = 0; i < n; i++)
C[i] = A[i] + B[i];
vector<pair<long long, long long>> D(n);
for (int i = 0; i < n; i++)
D[i] = make_pair(C[i], i);
sort(D.begin(), D.end());
for (int i = n - 1; i >= 0; i--) {
if ((i - n + 1) % 2 == 0)
ans += A[D[i].second];
else
ans -= B[D[i].second];
}
cout << ans;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,276 | 941,277 | u441296840 | cpp |
p03141 | #include <algorithm>
#include <cstdio>
using namespace std;
int x[200000], y[200000], z[200000];
int i, n;
long long s;
inline bool cmp(int z1, int z2) { return x[z1] + y[z1] > x[z2] + y[z2]; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), z[i] = i;
sort(z + 1, z + n + 1, cmp);
for (i = 1; i <= n; i++)
if (i & 1)
s = s + x[z[i]];
else
s = s - y[z[i]];
printf("%I64d", s);
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
int x[200000], y[200000], z[200000];
int i, n;
long long s;
inline bool cmp(int z1, int z2) { return x[z1] + y[z1] > x[z2] + y[z2]; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), z[i] = i;
sort(z + 1, z + n + 1, cmp);
for (i = 1; i <= n; i++)
if (i & 1)
s = s + x[z[i]];
else
s = s - y[z[i]];
printf("%lld", s);
return 0;
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 941,283 | 941,284 | u405611259 | cpp |
p03141 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define REP(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define FOR(x, xs) for (auto &x : xs)
using namespace std;
typedef long long ll;
typedef pair<int, int> PI;
typedef pair<ll, ll> PL;
typedef vector<int> VI;
typedef vector<ll> VL;
template <class T, template <class, class> class C, class charT = char>
void vdump(const C<T, allocator<T>> &v, const charT *delimiter = ", ",
ostream &stream = cout) {
copy(v.begin(), v.end(), ostream_iterator<T>(stream, delimiter));
stream << endl;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<tuple<ll, ll, ll>> ds(n);
REP(i, 0, n) {
ll a, b;
cin >> a >> b;
ds[i] = make_tuple(a - b, a, b);
}
sort(ds.rbegin(), ds.rend());
ll ans = 0;
REP(i, 0, n) {
if (i % 2 == 0) {
ans += get<1>(ds[i]);
} else {
ans -= get<2>(ds[i]);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define REP(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define FOR(x, xs) for (auto &x : xs)
using namespace std;
typedef long long ll;
typedef pair<int, int> PI;
typedef pair<ll, ll> PL;
typedef vector<int> VI;
typedef vector<ll> VL;
template <class T, template <class, class> class C, class charT = char>
void vdump(const C<T, allocator<T>> &v, const charT *delimiter = ", ",
ostream &stream = cout) {
copy(v.begin(), v.end(), ostream_iterator<T>(stream, delimiter));
stream << endl;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<tuple<ll, ll, ll>> ds(n);
REP(i, 0, n) {
ll a, b;
cin >> a >> b;
ds[i] = make_tuple(a + b, a, b);
}
sort(ds.rbegin(), ds.rend());
ll ans = 0;
REP(i, 0, n) {
if (i % 2 == 0) {
ans += get<1>(ds[i]);
} else {
ans -= get<2>(ds[i]);
}
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,285 | 941,286 | u652683896 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <stdio.h>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, a, n) for (ll i = (a); i < (n); ++i)
#define urep(i, a, n) for (ll i = (a); i >= (n); --i)
#define all(x) (x).begin(), (x).end()
#define INF 1e18
const int mod = 1e9 + 7;
typedef long long ll;
using namespace std;
ll dx[4] = {1, -1, 0, 0};
ll dy[4] = {0, 0, 1, -1};
ll N, M, X, Y, A, B, C, Q, K, R, W, H, P, L;
string S, T;
ll ans;
ll x[101010];
ll y[101010];
ll a[101010];
ll b[101010];
ll c[101010];
ll t[101010];
ll p[101010];
ll n[101010];
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
struct Edge {
ll to, cost;
Edge(int to, int cost) : to(to), cost(cost) {}
};
typedef vector<vector<Edge>> AdjList;
AdjList graph;
vector<ll> dist;
ll tmp[101010];
int main() {
pair<ll, ll> num[101010];
cin >> N;
rep(i, 0, N) {
cin >> a[i] >> b[i];
num[i].first = max(a[i], b[i]);
num[i].second = i;
}
sort(num, num + N, greater<pair<ll, ll>>());
ll takahashi = 0;
ll aoki = 0;
rep(i, 0, N) {
if (i % 2 == 0) {
takahashi += a[num[i].second];
} else {
aoki += b[num[i].second];
}
}
cerr << takahashi << " " << aoki << endl;
cout << takahashi - aoki << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <stdio.h>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, a, n) for (ll i = (a); i < (n); ++i)
#define urep(i, a, n) for (ll i = (a); i >= (n); --i)
#define all(x) (x).begin(), (x).end()
#define INF 1e18
const int mod = 1e9 + 7;
typedef long long ll;
using namespace std;
ll dx[4] = {1, -1, 0, 0};
ll dy[4] = {0, 0, 1, -1};
ll N, M, X, Y, A, B, C, Q, K, R, W, H, P, L;
string S, T;
ll ans;
ll x[101010];
ll y[101010];
ll a[101010];
ll b[101010];
ll c[101010];
ll t[101010];
ll p[101010];
ll n[101010];
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
struct Edge {
ll to, cost;
Edge(int to, int cost) : to(to), cost(cost) {}
};
typedef vector<vector<Edge>> AdjList;
AdjList graph;
vector<ll> dist;
ll tmp[101010];
int main() {
pair<ll, ll> num[101010];
cin >> N;
rep(i, 0, N) {
cin >> a[i] >> b[i];
num[i].first = a[i] + b[i];
num[i].second = i;
}
sort(num, num + N, greater<pair<ll, ll>>());
ll takahashi = 0;
ll aoki = 0;
rep(i, 0, N) {
if (i % 2 == 0) {
takahashi += a[num[i].second];
} else {
aoki += b[num[i].second];
}
}
cerr << takahashi << " " << aoki << endl;
cout << takahashi - aoki << endl;
return 0;
}
| [
"call.remove",
"assignment.value.change",
"call.arguments.change"
] | 941,290 | 941,291 | u406225550 | cpp |
p03141 | #include <bits/stdc++.h>
#define INF 1000000007
#define LINF 1000000000000000007
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int n, a[101010], b[101010];
P p[101010];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
p[i] = P(b[i] - a[i], a[i]);
}
sort(p, p + n);
ll cnt = 0;
for (int i = 0; i < n; i++) {
if (i % 2)
cnt -= p[n - i - 1].first + p[n - i - 1].second;
else
cnt += p[n - i - 1].second;
}
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
#define INF 1000000007
#define LINF 1000000000000000007
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int n, a[101010], b[101010];
P p[101010];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
p[i] = P(b[i] + a[i], a[i]);
}
sort(p, p + n);
ll cnt = 0;
for (int i = 0; i < n; i++) {
if (i % 2) {
cnt -= p[n - i - 1].first - p[n - i - 1].second;
} else {
cnt += p[n - i - 1].second;
}
}
cout << cnt << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,292 | 941,293 | u414947284 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef vector<LL> VI;
typedef vector<VI> VVI;
typedef pair<LL, LL> PII;
typedef vector<string> VS;
inline LL toInt(string s) {
LL v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
#define PB push_back
#define MP make_pair
#define SZ(a) LL((a).size())
#define EACH(x, c) for (auto x : (c))
#define EXIST(s, e) ((s).find(e) != (s).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define STABLE_SORT(c) stable_sort((c).begin(), (c).end())
#define STABLE_RSORT(c) stable_sort((c).rbegin(), (c).rend())
#define UNIQUE(c) \
SORT(c); \
(c).erase(unique((c).begin(), (c).end()), (c).end());
#define FOR(i, a, b) for (LL i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
const double INF = 1e7;
const double EPS = 1e-10;
const double PI = acos(-1.0);
#define dump(x) cerr << #x << " = " << (x) << endl;
int main() {
LL N;
cin >> N;
VI A(N), B(N), S(N);
REP(i, N) {
cin >> A[i] >> B[i];
S[i] = A[i] + B[i];
}
VI index(N);
REP(i, N) { index[i] = i; }
sort(index.begin(), index.end(), [&](LL x, LL y) { return S[x] > S[y]; });
LL ans = 0;
for (LL i = 0; i < N; i += 2) {
ans += A[i];
}
for (LL i = 1; i < N; i += 2) {
ans -= B[i];
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef vector<LL> VI;
typedef vector<VI> VVI;
typedef pair<LL, LL> PII;
typedef vector<string> VS;
inline LL toInt(string s) {
LL v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
#define PB push_back
#define MP make_pair
#define SZ(a) LL((a).size())
#define EACH(x, c) for (auto x : (c))
#define EXIST(s, e) ((s).find(e) != (s).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define STABLE_SORT(c) stable_sort((c).begin(), (c).end())
#define STABLE_RSORT(c) stable_sort((c).rbegin(), (c).rend())
#define UNIQUE(c) \
SORT(c); \
(c).erase(unique((c).begin(), (c).end()), (c).end());
#define FOR(i, a, b) for (LL i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
const double INF = 1e7;
const double EPS = 1e-10;
const double PI = acos(-1.0);
#define dump(x) cerr << #x << " = " << (x) << endl;
int main() {
LL N;
cin >> N;
VI A(N), B(N), S(N);
REP(i, N) {
cin >> A[i] >> B[i];
S[i] = A[i] + B[i];
}
VI index(N);
REP(i, N) { index[i] = i; }
sort(index.begin(), index.end(), [&](LL x, LL y) { return S[x] > S[y]; });
LL ans = 0;
for (LL i = 0; i < N; i += 2) {
ans += A[index[i]];
}
for (LL i = 1; i < N; i += 2) {
ans -= B[index[i]];
}
cout << ans << endl;
return 0;
}
| [] | 941,296 | 941,297 | u816800341 | cpp |
p03141 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdint.h>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-12;
static const double PI = acos(-1.0);
static const ll MOD = 1000000007;
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(a) (a).begin(), (a).end()
#define DEBUG(x) cout << #x << ": " << x << endl
void solve(long long N, std::vector<long long> A, std::vector<long long> B) {
vector<pair<ll, ll>> C(N);
REP(i, N) {
C[i].first = A[i] + B[i];
C[i].second = i;
}
sort(ALL(C));
ll ans = 0;
REP(i, N) {
if (i % 2 == 0) {
ans += A[C[i].second];
} else {
ans -= B[C[i].second];
}
}
std::cout << ans << std::endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> A(N);
std::vector<long long> B(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
}
solve(N, std::move(A), std::move(B));
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdint.h>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-12;
static const double PI = acos(-1.0);
static const ll MOD = 1000000007;
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(a) (a).begin(), (a).end()
#define DEBUG(x) cout << #x << ": " << x << endl
void solve(long long N, std::vector<long long> A, std::vector<long long> B) {
vector<pair<ll, ll>> C(N);
REP(i, N) {
C[i].first = -(A[i] + B[i]);
C[i].second = i;
}
sort(ALL(C));
ll ans = 0;
REP(i, N) {
if (i % 2 == 0) {
ans += A[C[i].second];
} else {
ans -= B[C[i].second];
}
}
std::cout << ans << std::endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> A(N);
std::vector<long long> B(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
}
solve(N, std::move(A), std::move(B));
return 0;
}
| [] | 941,298 | 941,299 | u792273212 | cpp |
p03141 | #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long int ll;
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long int ll;
ll n, a[114514], b[114514];
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
v.pb(mp(b[i] + a[i], i));
}
sort(v.begin(), v.end());
// for(int i=0;i<n;i++) cerr << v[i].first << " " << v[i].second << endl;
vector<ll> sum(2);
for (int i = 0; i < n; i++) {
int idx = v[n - 1 - i].second;
if (i % 2) {
sum[1] += b[i];
} else {
sum[0] += a[i];
}
}
cout << sum[0] - sum[1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long int ll;
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long int ll;
ll n, a[114514], b[114514];
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
v.pb(mp(b[i] + a[i], i));
}
sort(v.begin(), v.end());
// for(int i=0;i<n;i++) cerr << v[i].first << " " << v[i].second << endl;
vector<ll> sum(2);
for (int i = 0; i < n; i++) {
int idx = v[n - 1 - i].second;
if (i % 2) {
sum[1] += b[idx];
} else {
sum[0] += a[idx];
}
}
cout << sum[0] - sum[1] << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 941,300 | 941,301 | u628262476 | cpp |
p03141 | #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long int ll;
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long int ll;
ll n, a[114514], b[114514];
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
v.pb(mp(b[i] - a[i], i));
}
sort(v.begin(), v.end());
// for(int i=0;i<n;i++) cerr << v[i].first << " " << v[i].second << endl;
vector<ll> sum(2);
for (int i = 0; i < n; i++) {
int idx = v[n - 1 - i].second;
if (i % 2) {
sum[1] += b[i];
} else {
sum[0] += a[i];
}
}
cout << sum[0] - sum[1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long int ll;
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long int ll;
ll n, a[114514], b[114514];
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
v.pb(mp(b[i] + a[i], i));
}
sort(v.begin(), v.end());
// for(int i=0;i<n;i++) cerr << v[i].first << " " << v[i].second << endl;
vector<ll> sum(2);
for (int i = 0; i < n; i++) {
int idx = v[n - 1 - i].second;
if (i % 2) {
sum[1] += b[idx];
} else {
sum[0] += a[idx];
}
}
cout << sum[0] - sum[1] << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 941,302 | 941,301 | u628262476 | cpp |
p03141 | #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long int ll;
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long int ll;
ll n, a[114514], b[114514];
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
v.pb(mp(b[i] - a[i], i));
}
sort(v.begin(), v.end());
vector<ll> sum(2);
for (int i = 0; i < n; i++) {
int idx = v[n - 1 - i].second;
if (i % 2) {
sum[1] += b[i];
} else {
sum[0] += a[i];
}
}
cout << sum[0] - sum[1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long int ll;
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long int ll;
ll n, a[114514], b[114514];
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
v.pb(mp(b[i] + a[i], i));
}
sort(v.begin(), v.end());
// for(int i=0;i<n;i++) cerr << v[i].first << " " << v[i].second << endl;
vector<ll> sum(2);
for (int i = 0; i < n; i++) {
int idx = v[n - 1 - i].second;
if (i % 2) {
sum[1] += b[idx];
} else {
sum[0] += a[idx];
}
}
cout << sum[0] - sum[1] << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 941,303 | 941,301 | u628262476 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
struct N {
ll a, b, c;
};
bool operator<(const N &l, const N &r) { return l.c > r.c; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<N> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i].a >> c[i].b;
c[i].c = c[i].a - c[i].b;
}
sort(c.begin(), c.end());
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i * 2 < n)
ans += c[i].a;
else
ans -= c[i].b;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
struct N {
ll a, b, c;
};
bool operator<(const N &l, const N &r) { return l.c > r.c; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<N> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i].a >> c[i].b;
c[i].c = c[i].a + c[i].b;
}
sort(c.begin(), c.end());
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += c[i].a;
else
ans -= c[i].b;
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,304 | 941,305 | u656572785 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
struct N {
ll a, b, c;
};
bool operator<(const N &l, const N &r) { return l.c > r.c; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<N> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i].a >> c[i].b;
c[i].c = c[i].a - c[i].b;
}
sort(c.begin(), c.end());
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += c[i].a;
else
ans -= c[i].b;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
struct N {
ll a, b, c;
};
bool operator<(const N &l, const N &r) { return l.c > r.c; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<N> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i].a >> c[i].b;
c[i].c = c[i].a + c[i].b;
}
sort(c.begin(), c.end());
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += c[i].a;
else
ans -= c[i].b;
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,306 | 941,305 | u656572785 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pii;
typedef pair<llint, llint> pll;
typedef vector<int> vi;
typedef vector<llint> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
#define ci cin
#define co cout
#define en endl
#define ln cout << '\n'
#define rep(i, n) for (int i = 0; i < n; i++)
#define outl(x) cout << (x) << '\n'
#define pb push_back
#define fi first
#define se second
#define MOD 1000000007
template <typename Tn> Tn gcd(Tn a, Tn b) { return (b ? gcd(b, a % b) : a); }
template <typename Tn> Tn lcm(Tn a, Tn b) { return a / gcd(a, b) * b; }
string IntToString(int number) {
stringstream ss;
ss << number;
return ss.str();
}
struct abc {
llint a, b, c;
abc() {}
abc(llint a, llint b, llint c) : a(a), b(b), c(c) {}
bool operator<(const abc &tmp) const { return c < tmp.c; }
};
int n;
abc c[100001];
int main() {
ci >> n;
llint a, b;
rep(i, n) {
ci >> a >> b;
c[i] = abc(a, b, a + b);
}
sort(c, c + n);
llint taka = 0, aoki = 0;
rep(i, n) {
if (i % 2 == 0)
taka += c[i].a;
else
aoki += c[i].b;
}
co << taka - aoki << en;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pii;
typedef pair<llint, llint> pll;
typedef vector<int> vi;
typedef vector<llint> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
#define ci cin
#define co cout
#define en endl
#define ln cout << '\n'
#define rep(i, n) for (int i = 0; i < n; i++)
#define outl(x) cout << (x) << '\n'
#define pb push_back
#define fi first
#define se second
#define MOD 1000000007
template <typename Tn> Tn gcd(Tn a, Tn b) { return (b ? gcd(b, a % b) : a); }
template <typename Tn> Tn lcm(Tn a, Tn b) { return a / gcd(a, b) * b; }
string IntToString(int number) {
stringstream ss;
ss << number;
return ss.str();
}
struct abc {
llint a, b, c;
abc() {}
abc(llint a, llint b, llint c) : a(a), b(b), c(c) {}
bool operator<(const abc &tmp) const { return c > tmp.c; }
};
int n;
abc c[100001];
int main() {
ci >> n;
llint a, b;
rep(i, n) {
ci >> a >> b;
c[i] = abc(a, b, a + b);
}
sort(c, c + n);
llint taka = 0, aoki = 0;
rep(i, n) {
if (i % 2 == 0)
taka += c[i].a;
else
aoki += c[i].b;
}
co << taka - aoki << en;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,313 | 941,314 | u966921248 | cpp |
p03141 | #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define rep(i, n) for (auto i = 0; i < (n); i++)
#define rep1(i, n) for (auto i = 1; i <= (n); i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
struct init {
init() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
};
} aaaaaaa;
struct Node {
ll a;
ll b;
ll v;
bool operator<(const Node &r) const { return v > r.v; }
};
int main() {
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
rep(i, n) cin >> a[i] >> b[i];
vector<Node> v;
rep(i, n) v.push_back({a[i], b[i], a[i] + b[i]});
sort(all(v));
reverse(all(v));
ll res = 0;
rep(i, n) {
res += v[i].a;
i++;
if (i < n)
res -= v[i].b;
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define rep(i, n) for (auto i = 0; i < (n); i++)
#define rep1(i, n) for (auto i = 1; i <= (n); i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
struct init {
init() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
};
} aaaaaaa;
struct Node {
ll a;
ll b;
ll v;
bool operator<(const Node &r) const { return v < r.v; }
};
int main() {
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
rep(i, n) cin >> a[i] >> b[i];
vector<Node> v;
rep(i, n) v.push_back({a[i], b[i], a[i] + b[i]});
sort(all(v));
reverse(all(v));
ll res = 0;
rep(i, n) {
res += v[i].a;
i++;
if (i < n)
res -= v[i].b;
}
cout << res << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,317 | 941,318 | u779159595 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("O3")
//#pragma GCC target("sse4")
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for (int i = (b)-1; i >= (a); --i)
#define ITER(it, a) \
for (__typeof(a.begin()) it = a.begin(); it != a.end(); it++)
#define FILL(a, value) memset(a, value, sizeof(a))
#define SZ(a) (int)((a).size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const LL LINF = (LL)INF * INF;
const int MAX = 100 * 1000 + 7;
bool operator<(const PII &a, const PII &b) {
return a.first + a.second > b.first + b.second;
}
PII p[MAX];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
// freopen("In.txt", "r", stdin);
int n;
cin >> n;
FOR(i, 0, n)
cin >> p[i].first >> p[i].second;
sort(p, p + n);
LL ans = 0;
FOR(i, 0, n)
ans += (i & 1 ? -p[i].second : p[i].first);
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("O3")
//#pragma GCC target("sse4")
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for (int i = (b)-1; i >= (a); --i)
#define ITER(it, a) \
for (__typeof(a.begin()) it = a.begin(); it != a.end(); it++)
#define FILL(a, value) memset(a, value, sizeof(a))
#define SZ(a) (int)((a).size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const LL LINF = (LL)INF * INF;
const int MAX = 100 * 1000 + 7;
bool cmp(const PII &a, const PII &b) {
return a.first + a.second > b.first + b.second;
}
PII p[MAX];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
// freopen("In.txt", "r", stdin);
int n;
cin >> n;
FOR(i, 0, n)
cin >> p[i].first >> p[i].second;
sort(p, p + n, cmp);
LL ans = 0;
FOR(i, 0, n)
ans += (i & 1 ? -p[i].second : p[i].first);
cout << ans;
return 0;
} | [
"call.arguments.add"
] | 941,321 | 941,322 | u109908451 | cpp |
p03141 | #include <algorithm>
#include <array>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ALL(c) (c).begin(), (c).end()
using namespace std;
using ll = long long;
using pli = pair<ll, int>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdi = pair<double, int>;
using pdd = pair<double, double>;
int N;
vector<int> A, B;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int tmpa, tmpb;
cin >> tmpa >> tmpb;
A.push_back(tmpa);
B.push_back(tmpb);
}
vector<pii> C;
for (int i = 0; i < N; i++) {
C.push_back(pii(A[i] - B[i], i));
}
sort(C.rbegin(), C.rend());
ll ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
ans += A[C[i].second];
} else {
ans -= B[C[i].second];
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ALL(c) (c).begin(), (c).end()
using namespace std;
using ll = long long;
using pli = pair<ll, int>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdi = pair<double, int>;
using pdd = pair<double, double>;
int N;
vector<int> A, B;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int tmpa, tmpb;
cin >> tmpa >> tmpb;
A.push_back(tmpa);
B.push_back(tmpb);
}
vector<pli> C;
for (int i = 0; i < N; i++) {
C.push_back(pli(A[i] + B[i], i));
}
sort(C.rbegin(), C.rend());
ll ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
ans += A[C[i].second];
} else {
ans -= B[C[i].second];
}
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 941,325 | 941,326 | u378945900 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#ifdef ENABLE_DEBUG
#define DEBUG(a) cerr << #a << "=" << a << endl
#define DEBUG_ARRAY(a, n) cerr << #a << "[" << n << "]=" << a[n] << endl
#else
#define DEBUG(a)
#define DEBUG_ARRAY(a, n)
#endif
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define For(i, a) FOR(i, 0, a)
#define REV(i, a, b) for (int i = b - 1; i >= a; i--)
#define Rev(i, a) REV(i, 0, a)
#define REP(a) For(i, a)
typedef long long int ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
typedef vector<ll> vll;
const ll INF = (1LL << 50);
void solve(long long N, std::vector<long long> A, std::vector<long long> B) {
ll ans = 0;
vector<P> ab;
REP(N) { ab.push_back(P(A[i], B[i])); }
sort(ab.begin(), ab.end(),
[](P a, P b) { return (a.first + a.second) < (b.first + b.second); });
REP(N) {
if (i % 2 == 0) {
ans += ab[i].first;
} else {
ans -= ab[i].second;
}
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> A(N);
std::vector<long long> B(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
}
solve(N, std::move(A), std::move(B));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef ENABLE_DEBUG
#define DEBUG(a) cerr << #a << "=" << a << endl
#define DEBUG_ARRAY(a, n) cerr << #a << "[" << n << "]=" << a[n] << endl
#else
#define DEBUG(a)
#define DEBUG_ARRAY(a, n)
#endif
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define For(i, a) FOR(i, 0, a)
#define REV(i, a, b) for (int i = b - 1; i >= a; i--)
#define Rev(i, a) REV(i, 0, a)
#define REP(a) For(i, a)
typedef long long int ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
typedef vector<ll> vll;
const ll INF = (1LL << 50);
void solve(long long N, std::vector<long long> A, std::vector<long long> B) {
ll ans = 0;
vector<P> ab;
REP(N) { ab.push_back(P(A[i], B[i])); }
sort(ab.begin(), ab.end(),
[](P a, P b) { return (a.first + a.second) > (b.first + b.second); });
REP(N) {
if (i % 2 == 0) {
ans += ab[i].first;
} else {
ans -= ab[i].second;
}
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> A(N);
std::vector<long long> B(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
}
solve(N, std::move(A), std::move(B));
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,329 | 941,330 | u634743753 | cpp |
p03141 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int N;
cin >> N;
vector<long long> A(N), B(N);
vector<pair<long long, int>> C(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
C[i].first = A[i] - B[i];
C[i].second = i;
}
sort(C.rbegin(), C.rend());
int tak = 0;
int aok = 1;
long long ans = 0;
while (1) {
if (tak >= N)
break;
ans += A[C[tak].second];
tak += 2;
if (aok >= N)
break;
ans -= B[C[aok].second];
aok += 2;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int N;
cin >> N;
vector<long long> A(N), B(N);
vector<pair<long long, int>> C(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
C[i].first = A[i] + B[i];
C[i].second = i;
}
sort(C.rbegin(), C.rend());
int tak = 0;
int aok = 1;
long long ans = 0;
while (1) {
if (tak >= N)
break;
ans += A[C[tak].second];
tak += 2;
if (aok >= N)
break;
ans -= B[C[aok].second];
aok += 2;
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,331 | 941,332 | u898331860 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
static const double EPS = 1e-9;
template <class T> bool INRANGE(T x, T a, T b) { return a <= x && x <= b; }
template <class T> void amin(T &a, T v) {
if (a > v)
a = v;
}
template <class T> void amax(T &a, T v) {
if (a < v)
a = v;
}
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
#define PI (acos(-1))
#define ARRAY_NUM(a) (sizeof(a) / sizeof(a[0]))
#define NG (-1)
#define BIG ((int)1e9 + 10)
#define BIGLL ((ll)4e18)
#define SZ(a) ((int)(a).size())
#define SQ(a) ((a) * (a))
typedef unsigned long long ull;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> a(N);
vector<ll> b(N);
vector<pair<ll, int>> c(N);
for (int i = 0; i < N; ++i) {
cin >> a[i] >> b[i];
c[i] = make_pair(a[i] + b[i], i);
}
sort(c.begin(), c.end());
ll ans = 0;
ll sum_a = 0;
ll sum_b = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
sum_a += a[c[i].second];
} else {
sum_b += b[c[i].second];
}
}
cout << sum_a - sum_b << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
static const double EPS = 1e-9;
template <class T> bool INRANGE(T x, T a, T b) { return a <= x && x <= b; }
template <class T> void amin(T &a, T v) {
if (a > v)
a = v;
}
template <class T> void amax(T &a, T v) {
if (a < v)
a = v;
}
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
#define PI (acos(-1))
#define ARRAY_NUM(a) (sizeof(a) / sizeof(a[0]))
#define NG (-1)
#define BIG ((int)1e9 + 10)
#define BIGLL ((ll)4e18)
#define SZ(a) ((int)(a).size())
#define SQ(a) ((a) * (a))
typedef unsigned long long ull;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> a(N);
vector<ll> b(N);
vector<pair<ll, int>> c(N);
for (int i = 0; i < N; ++i) {
cin >> a[i] >> b[i];
c[i] = make_pair(a[i] + b[i], i);
}
sort(c.rbegin(), c.rend());
ll ans = 0;
ll sum_a = 0;
ll sum_b = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
sum_a += a[c[i].second];
} else {
sum_b += b[c[i].second];
}
}
cout << sum_a - sum_b << endl;
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,335 | 941,336 | u922299738 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, n) for (int i = 0; i < n; i++)
ll A[100100];
ll B[100100];
pair<ll, int> D[100100];
int main() {
int N;
cin >> N;
REP(i, N) {
ll a, b;
cin >> a >> b;
A[i] = a;
B[i] = b;
D[i] = make_pair(a + b, i);
}
sort(D, D + N);
ll t = 0;
ll a = 0;
bool taka = true;
REP(i, N) {
pair<ll, int> p = D[N - 1 - i];
int idx = p.second;
if (taka) {
t += A[i];
} else {
a += B[i];
}
taka = !taka;
}
cout << t - a << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, n) for (int i = 0; i < n; i++)
ll A[100100];
ll B[100100];
pair<ll, int> D[100100];
int main() {
int N;
cin >> N;
REP(i, N) {
ll a, b;
cin >> a >> b;
A[i] = a;
B[i] = b;
D[i] = make_pair(a + b, i);
}
sort(D, D + N);
ll t = 0;
ll a = 0;
bool taka = true;
REP(i, N) {
pair<ll, int> p = D[N - 1 - i];
int idx = p.second;
if (taka) {
t += A[idx];
} else {
a += B[idx];
}
taka = !taka;
// printf("t:%lld, a:%lld, idx:%d\n", t, a, idx);
}
cout << t - a << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 941,337 | 941,338 | u666394517 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define For(i, n) for (int i = 0; i < n; i++)
#define Fre(i, a, b) for (int i = a; i < b; i++)
#define sf(n) scanf("%d", &n)
#define sff(a, b) scanf("%d %d", &a, &b)
#define sfff(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define pfn(n) printf("%d\n", n)
#define pfs(n) printf("%d ", n)
#define ff first
#define ss second
#define mem(a, b) memset(a, b, sizeof(a))
#define READ freopen("in.txt", "r", stdin)
#define WRITE freopen("out.txt", "w", stdout)
#define sz size()
#define number_of_digit(n) __builtin_ffs(n);
#define ll long long
#define T int
#define ld long double
inline void print(T n) {
if (n == 0) {
putchar('0');
putchar('\n');
} else if (n == -1) {
putchar('-');
putchar('1');
putchar('\n');
} else {
char buf[11];
buf[10] = '\n';
int i = 9;
while (n) {
buf[i--] = n % 10 + '0';
n /= 10;
}
while (buf[i] != '\n')
putchar(buf[++i]);
}
}
int read() {
int cc = getc(stdin);
for (; cc < '0' || cc > '9';)
cc = getc(stdin);
int ret = 0;
for (; cc >= '0' && cc <= '9';) {
ret = ret * 10 + cc - '0';
cc = getc(stdin);
}
return ret;
}
ll power(ll num, ll g) {
if (g == 0)
return 1;
if (g % 2 == 1)
return (num * power((num * num) % mod, g / 2)) % mod;
return power((num * num) % mod, g / 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
ll a[n], b[n];
For(i, n) cin >> a[i] >> b[i];
pair<int, int> pa[n];
For(i, n) { pa[i] = mp(a[i] - b[i], i); }
sort(pa, pa + n);
For(i, n) {
int j = i;
while (j + 1 < n && pa[j].ff == pa[j + 1].ff)
j++;
i = j;
}
bool is = true;
int i = 0, j = n - 1;
ll ans = 0;
while (0 <= j) {
if (is) {
ans -= b[pa[j].ss];
is = false;
j--;
} else {
ans += a[pa[j].ss];
is = true;
j--;
}
// cout<<ans<<endl;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define For(i, n) for (int i = 0; i < n; i++)
#define Fre(i, a, b) for (int i = a; i < b; i++)
#define sf(n) scanf("%d", &n)
#define sff(a, b) scanf("%d %d", &a, &b)
#define sfff(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define pfn(n) printf("%d\n", n)
#define pfs(n) printf("%d ", n)
#define ff first
#define ss second
#define mem(a, b) memset(a, b, sizeof(a))
#define READ freopen("in.txt", "r", stdin)
#define WRITE freopen("out.txt", "w", stdout)
#define sz size()
#define number_of_digit(n) __builtin_ffs(n);
#define ll long long
#define T int
#define ld long double
inline void print(T n) {
if (n == 0) {
putchar('0');
putchar('\n');
} else if (n == -1) {
putchar('-');
putchar('1');
putchar('\n');
} else {
char buf[11];
buf[10] = '\n';
int i = 9;
while (n) {
buf[i--] = n % 10 + '0';
n /= 10;
}
while (buf[i] != '\n')
putchar(buf[++i]);
}
}
int read() {
int cc = getc(stdin);
for (; cc < '0' || cc > '9';)
cc = getc(stdin);
int ret = 0;
for (; cc >= '0' && cc <= '9';) {
ret = ret * 10 + cc - '0';
cc = getc(stdin);
}
return ret;
}
ll power(ll num, ll g) {
if (g == 0)
return 1;
if (g % 2 == 1)
return (num * power((num * num) % mod, g / 2)) % mod;
return power((num * num) % mod, g / 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
ll a[n], b[n];
For(i, n) cin >> a[i] >> b[i];
pair<int, int> pa[n];
For(i, n) { pa[i] = mp(a[i] + b[i], i); }
sort(pa, pa + n);
For(i, n) {
int j = i;
while (j + 1 < n && pa[j].ff == pa[j + 1].ff)
j++;
i = j;
}
bool is = false;
int i = 0, j = n - 1;
ll ans = 0;
while (0 <= j) {
if (is) {
ans -= b[pa[j].ss];
is = false;
j--;
} else {
ans += a[pa[j].ss];
is = true;
j--;
}
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_declaration.value.change"
] | 941,339 | 941,340 | u318324429 | cpp |
p03141 | #include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define repeat(n) for (int _ = 1; _ <= n; _++)
struct Node {
int x1;
int x2;
};
bool operator<(Node a, Node b) { return a.x1 + a.x2 > b.x1 + b.x2; }
int main() {
ios::sync_with_stdio(false);
#ifdef CAI_WEI_HAN
freopen("test.in", "r", stdin);
#endif
int n;
cin >> n;
static Node a[100005];
for (int i = 1; i <= n; i++)
cin >> a[i].x1 >> a[i].x2;
sort(&a[1], &a[n] + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
if ((n - i) % 2 == 0)
ans += a[i].x1;
else
ans -= a[i].x2;
}
cout << ans;
}
| #include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define repeat(n) for (int _ = 1; _ <= n; _++)
struct Node {
int x1;
int x2;
};
bool operator<(Node a, Node b) { return a.x1 + a.x2 < b.x1 + b.x2; }
int main() {
ios::sync_with_stdio(false);
#ifdef CAI_WEI_HAN
freopen("test.in", "r", stdin);
#endif
int n;
cin >> n;
static Node a[100005];
for (int i = 1; i <= n; i++)
cin >> a[i].x1 >> a[i].x2;
sort(&a[1], &a[n] + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
if ((n - i) % 2 == 0)
ans += a[i].x1;
else
ans -= a[i].x2;
}
cout << ans;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,341 | 941,342 | u506713609 | cpp |
p03141 | #include <bits/stdc++.h>
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define debug(x) cerr << #x << " = " << x << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef string str;
typedef pair<ll, ll> pll;
const ld PI = 3.14159265359;
const ll MOD = (ll)998244353ll;
const ll MAXN = (ll)2e5 + 10;
const ll INF = (ll)2242545357980376863;
const ld EPS = (ld)1e-8;
bool CMP(pll a, pll b) { return a.F + a.S < b.F + b.S; }
pll a[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
ll f = 0, s = 0;
for (int i = 0; i < n; i++)
cin >> a[i].F >> a[i].S;
sort(a, a + n, CMP);
for (int i = 0; i < n; i += 2)
f += a[i].F;
for (int i = 1; i < n; i += 2)
s += a[i].S;
cout << f - s;
return 0;
}
/*
____ ,----.. ,----..
,---, ,' , `. / / \ / / \
' .' \ ,-+-,.' _ | / . : / . :
/ ; '. ,-+-. ; , || . / ;. \ . / ;.
\ : : \ ,--.'|' | ;| . ; / ` ; . ; /
` ; : | /\ \ | | ,', | ': ; | ; \ ; | ; |
; \ ; | | : ' ;. : | | / | | || | : | ; | ' |
: | ; | ' | | ;/ \ \ ' | : | : |, . | ' ' ' : . |
' ' ' : ' : | \ \ ,' ; . | ; |--' ' ; \; / | '
; \; / | | | ' '--' | : | | , \ \ ', /
\ \ ', / | : : | : ' |/ ; : / ; : /
| | ,' ; | |`-' \ \ .' \ \ .'
`--'' | ;/ `---` `---`
'---'
*/
| #include <bits/stdc++.h>
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define debug(x) cerr << #x << " = " << x << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef string str;
typedef pair<ll, ll> pll;
const ld PI = 3.14159265359;
const ll MOD = (ll)998244353ll;
const ll MAXN = (ll)2e5 + 10;
const ll INF = (ll)2242545357980376863;
const ld EPS = (ld)1e-8;
bool CMP(pll a, pll b) { return a.F + a.S > b.F + b.S; }
pll a[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
ll f = 0, s = 0;
for (int i = 0; i < n; i++)
cin >> a[i].F >> a[i].S;
sort(a, a + n, CMP);
for (int i = 0; i < n; i += 2)
f += a[i].F;
for (int i = 1; i < n; i += 2)
s += a[i].S;
cout << f - s;
return 0;
}
/*
____ ,----.. ,----..
,---, ,' , `. / / \ / / \
' .' \ ,-+-,.' _ | / . : / . :
/ ; '. ,-+-. ; , || . / ;. \ . / ;.
\ : : \ ,--.'|' | ;| . ; / ` ; . ; /
` ; : | /\ \ | | ,', | ': ; | ; \ ; | ; |
; \ ; | | : ' ;. : | | / | | || | : | ; | ' |
: | ; | ' | | ;/ \ \ ' | : | : |, . | ' ' ' : . |
' ' ' : ' : | \ \ ,' ; . | ; |--' ' ; \; / | '
; \; / | | | ' '--' | : | | , \ \ ', /
\ \ ', / | : : | : ' |/ ; : / ; : /
| | ,' ; | |`-' \ \ .' \ \ .'
`--'' | ;/ `---` `---`
'---'
*/
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,347 | 941,348 | u787690200 | cpp |
p03141 | #include <bits/stdc++.h>
#define typeof(x) __typeof__(x)
#define int long long int
#define double long double
#define mod(x) ((x % MOD) + MOD) % MOD
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define RREP(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SZ(c) (int)((c).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define LB(c, x) (int)(lower_bound(ALL(c), x) - (c).begin())
#define UB(c, x) (int)(upper_bound(ALL(c), x) - (c).begin())
#define COUNT(c, x) (UB(c, x) - LB(c, x))
#define UNIQUE(c) \
SORT(c); \
(c).erase(unique(ALL(c)), (c).end());
#define COPY(c1, c2) copy(ALL(c1), (c2).begin())
#define EXIST(s, e) (s).find(e) != (s).end()
#define PB push_back
#define MP make_pair
#define vec vector
#define DUMP(x) cerr << #x << " = " << (x) << endl;
#define NL cerr << endl;
using namespace std;
typedef pair<int, int> P;
struct edge {
int from, to;
int cost;
};
ostream &operator<<(ostream &s, const edge &e) {
s << "(" << e.from << "->" << e.to << ": " << e.cost << ")";
return s;
}
bool operator<(const edge &edge1, const edge &edge2) {
return edge1.cost < edge2.cost;
};
const int INF = 1e18;
const int MOD = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
s << "[";
for (int i = 0; i < v.size(); i++) {
s << v[i];
if (i < v.size() - 1)
s << " ";
}
s << "]";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &se) {
s << "{";
for (auto i = se.begin(); i != se.end(); ++i) {
s << *i;
if (next(i) != se.end())
s << ", ";
}
s << "}";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
s << "(" << p.first << "," << p.second << ")";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{";
for (auto i = m.begin(); i != m.end(); ++i) {
s << i->first << ":" << i->second;
if (next(i) != m.end())
s << ", ";
}
s << "}";
return s;
}
signed main() {
int N;
cin >> N;
vec<int> A(N), B(N);
REP(i, 0, N) { cin >> A[i] >> B[i]; }
vec<P> C(N);
REP(i, 0, N) { C[i] = MP(A[i] + B[i], i); }
SORT(C);
int ans = 0;
REP(i, 0, N) {
if (i % 2 == 0) {
ans += A[C[i].second];
} else {
ans -= B[C[i].second];
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define typeof(x) __typeof__(x)
#define int long long int
#define double long double
#define mod(x) ((x % MOD) + MOD) % MOD
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define RREP(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SZ(c) (int)((c).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define LB(c, x) (int)(lower_bound(ALL(c), x) - (c).begin())
#define UB(c, x) (int)(upper_bound(ALL(c), x) - (c).begin())
#define COUNT(c, x) (UB(c, x) - LB(c, x))
#define UNIQUE(c) \
SORT(c); \
(c).erase(unique(ALL(c)), (c).end());
#define COPY(c1, c2) copy(ALL(c1), (c2).begin())
#define EXIST(s, e) (s).find(e) != (s).end()
#define PB push_back
#define MP make_pair
#define vec vector
#define DUMP(x) cerr << #x << " = " << (x) << endl;
#define NL cerr << endl;
using namespace std;
typedef pair<int, int> P;
struct edge {
int from, to;
int cost;
};
ostream &operator<<(ostream &s, const edge &e) {
s << "(" << e.from << "->" << e.to << ": " << e.cost << ")";
return s;
}
bool operator<(const edge &edge1, const edge &edge2) {
return edge1.cost < edge2.cost;
};
const int INF = 1e18;
const int MOD = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
s << "[";
for (int i = 0; i < v.size(); i++) {
s << v[i];
if (i < v.size() - 1)
s << " ";
}
s << "]";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &se) {
s << "{";
for (auto i = se.begin(); i != se.end(); ++i) {
s << *i;
if (next(i) != se.end())
s << ", ";
}
s << "}";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
s << "(" << p.first << "," << p.second << ")";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{";
for (auto i = m.begin(); i != m.end(); ++i) {
s << i->first << ":" << i->second;
if (next(i) != m.end())
s << ", ";
}
s << "}";
return s;
}
signed main() {
int N;
cin >> N;
vec<int> A(N), B(N);
REP(i, 0, N) { cin >> A[i] >> B[i]; }
vec<P> C(N);
REP(i, 0, N) { C[i] = MP(A[i] + B[i], i); }
RSORT(C);
int ans = 0;
REP(i, 0, N) {
if (i % 2 == 0) {
ans += A[C[i].second];
} else {
ans -= B[C[i].second];
}
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"call.function.change"
] | 941,349 | 941,350 | u960524878 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (int i = (l); i < (r); i++)
#define incII(i, l, r) for (int i = (l); i <= (r); i++)
#define decID(i, l, r) for (int i = (r)-1; i >= (l); i--)
#define decII(i, l, r) for (int i = (r); i >= (l); i--)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define PQ priority_queue
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define FOR(it, v) for (auto it = v.begin(); it != v.end(); ++it)
#define RFOR(it, v) for (auto it = v.rbegin(); it != v.rend(); ++it)
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ---- ----
template <typename T> void Asort(T *a, int n) { sort(a, a + n, less<T>()); }
template <typename T> void RAsort(T *a, int n) { sort(a, a + n, greater<T>()); }
LL n, ans;
array<LL, 3> a[100000];
int main() {
cin >> n;
inc(i, n) {
cin >> a[i][1] >> a[i][2];
a[i][0] = abs(a[i][1] - a[i][2]);
}
RAsort(a, n);
inc(i, n) {
if (i % 2 == 0) {
ans += a[i][1];
} else {
ans -= a[i][2];
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (int i = (l); i < (r); i++)
#define incII(i, l, r) for (int i = (l); i <= (r); i++)
#define decID(i, l, r) for (int i = (r)-1; i >= (l); i--)
#define decII(i, l, r) for (int i = (r); i >= (l); i--)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define PQ priority_queue
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define FOR(it, v) for (auto it = v.begin(); it != v.end(); ++it)
#define RFOR(it, v) for (auto it = v.rbegin(); it != v.rend(); ++it)
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ---- ----
template <typename T> void Asort(T *a, int n) { sort(a, a + n, less<T>()); }
template <typename T> void RAsort(T *a, int n) { sort(a, a + n, greater<T>()); }
LL n, ans;
array<LL, 3> a[100000];
int main() {
cin >> n;
inc(i, n) {
cin >> a[i][1] >> a[i][2];
a[i][0] = a[i][1] + a[i][2];
}
RAsort(a, n);
inc(i, n) {
if (i % 2 == 0) {
ans += a[i][1];
} else {
ans -= a[i][2];
}
}
cout << ans << endl;
return 0;
}
| [
"call.remove",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,351 | 941,352 | u568652083 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (int i = (l); i < (r); i++)
#define incII(i, l, r) for (int i = (l); i <= (r); i++)
#define decID(i, l, r) for (int i = (r)-1; i >= (l); i--)
#define decII(i, l, r) for (int i = (r); i >= (l); i--)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define PQ priority_queue
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define FOR(it, v) for (auto it = v.begin(); it != v.end(); ++it)
#define RFOR(it, v) for (auto it = v.rbegin(); it != v.rend(); ++it)
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ---- ----
template <typename T> void Asort(T *a, int n) { sort(a, a + n, less<T>()); }
template <typename T> void RAsort(T *a, int n) { sort(a, a + n, greater<T>()); }
LL n, ans;
array<LL, 3> a[100000];
int main() {
cin >> n;
inc(i, n) {
cin >> a[i][1] >> a[i][2];
a[i][0] = a[i][1] - a[i][2];
}
RAsort(a, n);
inc(i, n) {
if (i % 2 == 0) {
ans += a[i][1];
} else {
ans -= a[i][2];
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (int i = (l); i < (r); i++)
#define incII(i, l, r) for (int i = (l); i <= (r); i++)
#define decID(i, l, r) for (int i = (r)-1; i >= (l); i--)
#define decII(i, l, r) for (int i = (r); i >= (l); i--)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define PQ priority_queue
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define FOR(it, v) for (auto it = v.begin(); it != v.end(); ++it)
#define RFOR(it, v) for (auto it = v.rbegin(); it != v.rend(); ++it)
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ---- ----
template <typename T> void Asort(T *a, int n) { sort(a, a + n, less<T>()); }
template <typename T> void RAsort(T *a, int n) { sort(a, a + n, greater<T>()); }
LL n, ans;
array<LL, 3> a[100000];
int main() {
cin >> n;
inc(i, n) {
cin >> a[i][1] >> a[i][2];
a[i][0] = a[i][1] + a[i][2];
}
RAsort(a, n);
inc(i, n) {
if (i % 2 == 0) {
ans += a[i][1];
} else {
ans -= a[i][2];
}
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,353 | 941,352 | u568652083 | cpp |
p03141 | #include <bits/stdc++.h>
#define PB push_back
#define X first
#define Y second
#define INF 1000 * 1000 * 1000
#define LL long long
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const LL LINF = INF * (LL)INF;
const int MAX = 1 << 17;
int a[100005], b[100005], c[100005];
bool cmp(pair<int, int> p1, pair<int, int> p2) {
return p1.X + p1.Y < p2.X + p2.Y;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
v.PB({a[i], b[i]});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
LL ans = 0;
for (int i = 0; i < v.size(); i++) {
if (i % 2)
ans -= v[i].Y;
else
ans += v[i].X;
}
cout << ans;
}
| #include <bits/stdc++.h>
#define PB push_back
#define X first
#define Y second
#define INF 1000 * 1000 * 1000
#define LL long long
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const LL LINF = INF * (LL)INF;
const int MAX = 1 << 17;
int a[100005], b[100005], c[100005];
bool cmp(pair<int, int> p1, pair<int, int> p2) {
return p1.X + p1.Y < p2.X + p2.Y;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
v.PB({a[i], b[i]});
}
sort(v.begin(), v.end(), cmp);
reverse(v.begin(), v.end());
LL ans = 0;
for (int i = 0; i < v.size(); i++) {
if (i % 2)
ans -= v[i].Y;
else
ans += v[i].X;
}
cout << ans;
}
| [
"call.arguments.add"
] | 941,354 | 941,355 | u804093140 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
struct ts {
long long s, a, b;
bool operator<(const ts &r) const { return s < r.s; }
};
ts p[100009];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].a >> p[i].b;
p[i].s = p[i].a + p[i].b;
}
sort(p, p + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += p[i].a;
else
ans -= p[i].b;
}
cout << ans << '\n';
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
struct ts {
long long s, a, b;
bool operator<(const ts &r) const { return s > r.s; }
};
ts p[100009];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].a >> p[i].b;
p[i].s = p[i].a + p[i].b;
}
sort(p, p + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += p[i].a;
else
ans -= p[i].b;
}
cout << ans << '\n';
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,356 | 941,357 | u105725117 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<ll> a(n), b(n);
vector<pair<ll, int>> c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = {a[i] + b[i], i};
}
sort(c.rbegin(), c.rend());
ll ans = 0;
for (int i = 0; i < n; i++) {
int idx = c[i].second;
if (i % 2 == 0) {
ans += a[i];
} else {
ans -= b[i];
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<ll> a(n), b(n);
vector<pair<ll, int>> c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = {a[i] + b[i], i};
}
sort(c.rbegin(), c.rend());
ll ans = 0;
for (int i = 0; i < n; i++) {
int idx = c[i].second;
if (i % 2 == 0) {
ans += a[idx];
} else {
ans -= b[idx];
}
}
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 941,358 | 941,359 | u843522325 | cpp |
p03141 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
#include <stack>
#include <utility>
#include <vector>
#define int long long
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<int, int> pii;
const int INF = 1l << 60;
#define u_b upper_bound
#define l_b lower_bound
int N;
int A[100100], B[100100];
pii C[100100];
signed main() {
cin >> N;
rep(i, N) {
cin >> A[i] >> B[i];
C[i] = pii(A[i] - B[i], i);
}
sort(C, C + N);
int taka = 0;
int aoki = 0;
int s = 1;
for (int i = N - 1; i >= 0; --i) {
if (s == 1) {
taka += A[C[i].second];
} else {
aoki += B[C[i].second];
}
s *= -1;
}
cout << taka - aoki << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
#include <stack>
#include <utility>
#include <vector>
#define int long long
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<int, int> pii;
const int INF = 1l << 60;
#define u_b upper_bound
#define l_b lower_bound
int N;
int A[100100], B[100100];
pii C[100100];
signed main() {
cin >> N;
rep(i, N) {
cin >> A[i] >> B[i];
C[i] = pii(A[i] + B[i], i);
}
sort(C, C + N);
int taka = 0;
int aoki = 0;
int s = 1;
for (int i = N - 1; i >= 0; --i) {
if (s == 1) {
taka += A[C[i].second];
} else {
aoki += B[C[i].second];
}
s *= -1;
}
cout << taka - aoki << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,360 | 941,361 | u015768390 | cpp |
p03141 | //**************************
//*** author : Alex Hu **
//************************
#include <bits/stdc++.h>
using namespace std;
#define CLEAN(a, b) memset(a, b, sizeof(a))
#define mkp make_pair
#define pb push_back
#define rept(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int n;
struct thing {
int a, b;
int dif;
void input() {
scanf("%lld%lld", &a, &b);
dif = a + b;
}
};
bool operator<(thing a, thing b) {
return a.dif != b.dif ? a.dif > b.dif : a.a > b.a;
}
multiset<thing> th;
signed main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
thing t;
t.input();
th.insert(t);
}
cerr << "ok init\n";
int ans = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
ans -= (*th.begin()).b;
} else {
ans += (*th.begin()).a;
}
th.erase(th.begin());
}
cout << ans << endl;
return 0;
} | //**************************
//*** author : Alex Hu **
//************************
#include <bits/stdc++.h>
using namespace std;
#define CLEAN(a, b) memset(a, b, sizeof(a))
#define mkp make_pair
#define pb push_back
#define rept(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define int long long
int n;
struct thing {
int a, b;
int dif;
void input() {
scanf("%lld%lld", &a, &b);
dif = a + b;
}
};
bool operator<(thing a, thing b) {
return a.dif != b.dif ? a.dif > b.dif : a.a > b.a;
}
multiset<thing> th;
signed main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
thing t;
t.input();
th.insert(t);
}
cerr << "ok init\n";
int ans = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
ans -= (*th.begin()).b;
} else {
ans += (*th.begin()).a;
}
th.erase(th.begin());
}
cout << ans << endl;
return 0;
} | [] | 941,364 | 941,365 | u548920851 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
struct P {
bool operator<(const P &p) const { return a + b < p.a + p.b; }
int a, b;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<P> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].a >> p[i].b;
}
sort(p.begin(), p.end());
ll r = 0;
for (int i = 0; i < n; i++) {
r += i % 2 == 0 ? p[i].a : -p[i].b;
}
cout << r << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
struct P {
bool operator<(const P &p) const { return a + b > p.a + p.b; }
int a, b;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<P> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].a >> p[i].b;
}
sort(p.begin(), p.end());
ll r = 0;
for (int i = 0; i < n; i++) {
r += i % 2 == 0 ? p[i].a : -p[i].b;
}
cout << r << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,372 | 941,373 | u215860196 | cpp |
p03141 | // ConsoleApplication9.cpp : アプリケーションのエントリ ポイントを定義します。
//
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 9999999999
#define m0(x) memset(x, 0, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define print(x) cout << x << endl;
#define pe(x) cout << x << " ";
#define lb(v, n) lower_bound(v.begin(), v.end(), n);
#define int long long
using namespace std;
int dy[4] = {0, 0, 1, -1};
int dx[4] = {1, -1, 0, 0};
int dxx[9] = {0, 0, 0, 1, 1, 1, -1, -1, -1};
int dyy[9] = {0, 1, -1, 0, 1, -1, 0, 1, -1};
ll gcd(ll x, ll y) {
ll m = max(x, y), n = min(x, y);
if (m % n == 0)
return n;
else
return gcd(m % n, n);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
ll pow2(ll a, ll n) { // aのn乗を計算します。
ll x = 1;
while (n > 0) { //全てのbitが捨てられるまで。
if (n & 1) { // 1番右のbitが1のとき。
x = x * a;
}
a = a * a;
n >>= 1; // bit全体を右に1つシフトして一番右を捨てる。
}
return x;
}
long long nCr(int n, int r) {
if (r > n / 2)
r = n - r; // because C(n, r) == C(n, n - r)
long long ans = 1;
int i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool arr[100000100];
vector<ll> sosuu;
void Eratosthenes() {
ll N = 10000010;
int c = 0;
for (int i = 0; i < N; i++) {
arr[i] = 1;
}
for (ll i = 2; i < sqrt(N); i++) {
if (arr[i]) {
for (ll j = 0; i * (j + 2) < N; j++) {
arr[i * (j + 2)] = 0;
}
}
}
for (ll i = 2; i < N; i++) {
if (arr[i]) {
sosuu.pb(i);
// cout << sosuu[c] << " ";
c++;
}
}
// cout << endl;
// cout << c << endl;
}
ll stoL(string s) {
ll n = s.length();
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += pow2(10, n - i - 1) * (ll)(s[i] - '0');
}
return ans;
}
int A[100010], B[100010];
vector<pair<ll, int>> vec;
signed main() {
int N;
cin >> N;
REP(i, N) {
cin >> A[i] >> B[i];
vec.pb(make_pair(A[i] + B[i], i));
}
ll taka = 0, aoki = 0;
VSORT(vec);
REP(i, N) {
if (i % 2 == 0) {
taka += A[vec[i].second];
} else {
aoki += B[vec[i].second];
}
}
print(taka - aoki);
} | // ConsoleApplication9.cpp : アプリケーションのエントリ ポイントを定義します。
//
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 9999999999
#define m0(x) memset(x, 0, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define print(x) cout << x << endl;
#define pe(x) cout << x << " ";
#define lb(v, n) lower_bound(v.begin(), v.end(), n);
#define int long long
using namespace std;
int dy[4] = {0, 0, 1, -1};
int dx[4] = {1, -1, 0, 0};
int dxx[9] = {0, 0, 0, 1, 1, 1, -1, -1, -1};
int dyy[9] = {0, 1, -1, 0, 1, -1, 0, 1, -1};
ll gcd(ll x, ll y) {
ll m = max(x, y), n = min(x, y);
if (m % n == 0)
return n;
else
return gcd(m % n, n);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
ll pow2(ll a, ll n) { // aのn乗を計算します。
ll x = 1;
while (n > 0) { //全てのbitが捨てられるまで。
if (n & 1) { // 1番右のbitが1のとき。
x = x * a;
}
a = a * a;
n >>= 1; // bit全体を右に1つシフトして一番右を捨てる。
}
return x;
}
long long nCr(int n, int r) {
if (r > n / 2)
r = n - r; // because C(n, r) == C(n, n - r)
long long ans = 1;
int i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool arr[100000100];
vector<ll> sosuu;
void Eratosthenes() {
ll N = 10000010;
int c = 0;
for (int i = 0; i < N; i++) {
arr[i] = 1;
}
for (ll i = 2; i < sqrt(N); i++) {
if (arr[i]) {
for (ll j = 0; i * (j + 2) < N; j++) {
arr[i * (j + 2)] = 0;
}
}
}
for (ll i = 2; i < N; i++) {
if (arr[i]) {
sosuu.pb(i);
// cout << sosuu[c] << " ";
c++;
}
}
// cout << endl;
// cout << c << endl;
}
ll stoL(string s) {
ll n = s.length();
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += pow2(10, n - i - 1) * (ll)(s[i] - '0');
}
return ans;
}
int A[100010], B[100010];
vector<pair<ll, int>> vec;
signed main() {
int N;
cin >> N;
REP(i, N) {
cin >> A[i] >> B[i];
vec.pb(make_pair(A[i] + B[i], i));
}
ll taka = 0, aoki = 0;
VSORT(vec);
VREVERSE(vec);
// REP(i, N) {
// pe(vec[i].first); pe(vec[i].second);
// cout << endl;
//}
REP(i, N) {
if (i % 2 == 0) {
taka += A[vec[i].second];
} else {
aoki += B[vec[i].second];
}
}
print(taka - aoki);
} | [
"call.add"
] | 941,374 | 941,375 | u859396346 | cpp |
p03141 | #include <algorithm>
#include <cstdint>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<tuple<int64_t, int64_t, int64_t>> vs(n);
for (auto &v : vs) {
int64_t a, b;
cin >> a >> b;
int64_t d = a + b;
v = make_tuple(d, a, b);
}
sort(vs.begin(), vs.end());
int64_t sum = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
sum += get<1>(vs[i]);
} else {
sum -= get<2>(vs[i]);
}
}
cout << sum << endl;
} | #include <algorithm>
#include <cstdint>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<tuple<int64_t, int64_t, int64_t>> vs(n);
for (auto &v : vs) {
int64_t a, b;
cin >> a >> b;
int64_t d = a + b;
v = make_tuple(d, a, b);
}
sort(vs.begin(), vs.end(), greater<>());
int64_t sum = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
sum += get<1>(vs[i]);
} else {
sum -= get<2>(vs[i]);
}
}
cout << sum << endl;
} | [
"call.arguments.add"
] | 941,376 | 941,377 | u537234062 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
typedef int _int;
#define int long long
struct ele {
int a, b, p;
inline bool operator<(const ele &x) const { return p < x.p; }
} o[N];
int n, ans;
_int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> o[i].a >> o[i].b, o[i].p = o[i].a - o[i].b;
sort(o + 1, o + 1 + n);
for (int i = 1; i <= n; ++i)
ans += (i & 1 ? o[i].a : -o[i].b);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
typedef int _int;
#define int long long
struct ele {
int a, b, p;
inline bool operator<(const ele &x) const { return p > x.p; }
} o[N];
int n, ans;
_int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> o[i].a >> o[i].b, o[i].p = o[i].b + o[i].a;
sort(o + 1, o + 1 + n);
for (int i = 1; i <= n; ++i)
ans += (i & 1 ? o[i].a : -o[i].b);
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 941,378 | 941,379 | u454097714 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
ll a[200000], b[200000];
ll c[200000];
int main() {
// ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
ll ans = 0;
for (int i = 0; i < n; i++) {
c[i] = a[i] + b[i];
ans -= b[i];
}
sort(c, c + n);
// cout<<ans<<endl;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += c[i];
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
ll a[200000], b[200000];
ll c[200000];
int main() {
// ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
ll ans = 0;
for (int i = 0; i < n; i++) {
c[i] = a[i] + b[i];
ans -= b[i];
}
sort(c, c + n);
// cout<<ans<<endl;
for (int i = 0; i < n; i++) {
if ((i + n + 1) % 2 == 0)
ans += c[i];
}
cout << ans;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,380 | 941,381 | u279130306 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <locale>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
#define F first
#define S second
#define pb push_back
#define MP make_pair
#define ALL(x) begin(x), end(x)
#define SZ(x) (int)(x).size()
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define ln(i, n) " \n"[i == n]
typedef long long LL;
typedef long double LDB;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
//////////////////////
const long double eps = 1e-13;
const long double PI = acos(-1);
const int INF = (int)1e9;
const LL INFF = (LL)1e15;
const int mod = 998244353;
const int MXN = (int)1e6 + 7;
LL a[MXN], b[MXN];
int id[MXN];
bool cmp(int &u, int &v) { return a[u] + b[u] > a[v] + b[v]; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld %lld", a + i, b + i);
id[i] = i;
}
sort(id + 1, id + n + 1, cmp);
LL v1 = 0;
for (int i = 1; i <= n; i++) {
if (i & 1)
v1 += a[i];
else
v1 -= b[i];
}
printf("%lld\n", v1);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <locale>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
#define F first
#define S second
#define pb push_back
#define MP make_pair
#define ALL(x) begin(x), end(x)
#define SZ(x) (int)(x).size()
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define ln(i, n) " \n"[i == n]
typedef long long LL;
typedef long double LDB;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
//////////////////////
const long double eps = 1e-13;
const long double PI = acos(-1);
const int INF = (int)1e9;
const LL INFF = (LL)1e15;
const int mod = 998244353;
const int MXN = (int)1e6 + 7;
LL a[MXN], b[MXN];
int id[MXN];
bool cmp(int &u, int &v) { return a[u] + b[u] > a[v] + b[v]; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld %lld", a + i, b + i);
id[i] = i;
}
sort(id + 1, id + n + 1, cmp);
LL v1 = 0;
for (int i = 1; i <= n; i++) {
if (i & 1)
v1 += a[id[i]];
else
v1 -= b[id[i]];
}
printf("%lld\n", v1);
return 0;
}
| [] | 941,384 | 941,385 | u008017892 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.