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 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define DEBUG_
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
#define PI 3.141592653589793238
#define RMAX 4294967295
#ifdef DEBUG_
#define DEB
#else
#define DEB if (false)
#endif
#ifdef DEBUG_
#define dump(...) \
DUMPOUT << " "; \
dump_func(string(#__VA_ARGS__) + ":", \
"[" + to_string(__LINE__) + ":" + __FUNCTION__ + "]"); \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#else
#define dump(...)
#endif
typedef long long ll;
typedef pair<int, int> Pi;
typedef pair<ll, ll> Pll;
typedef pair<double, double> Pd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<Pi> vPi;
typedef vector<Pll> vPll;
typedef vector<Pd> vPd;
typedef vector<vector<int>> vvi;
typedef vector<vector<bool>> vvb;
typedef vector<vector<ll>> vvll;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<double>> vvd;
typedef vector<vector<Pi>> vvPi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<vector<vector<Pi>>> vvvPi;
typedef vector<vector<vector<vector<Pi>>>> vvvvPi;
typedef priority_queue<int, vector<int>, greater<int>> pqli;
typedef priority_queue<ll, vector<ll>, greater<ll>> pqlll;
typedef priority_queue<Pi, vector<Pi>, greater<Pi>> pqlP;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
string debug_show(Pi a) {
return "(" + to_string(a.first) + "," + to_string(a.second) + ")";
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) <= 1) {
DUMPOUT << " ";
} else {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << "," << pair_var.second << ")";
return os;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << "," << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << "(" << itr->first << "," << itr->second << ")";
itr++;
if (itr == map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << " " << *itr << endl;
itr++;
if (itr == set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
char dirchar[4] = {'<', '^', '>', 'v'};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
struct Edge {
int from, to, cost;
bool operator<(Edge e) { return cost < e.cost; }
};
using Graph = vec<vec<Edge>>;
ostream &operator<<(ostream &os, Edge &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
//======================================================
int main(void) {
int N;
cin >> N;
vec<tuple<ll, ll, ll>> t(N);
rep(i, N) {
ll a, b;
cin >> a >> b;
t[i] = mt(a + b, a, b);
}
sort(all(t));
ll sum_a = 0, sum_b = 0;
rep(i, N) {
if (i % 2 == 0) {
sum_a += get<1>(t[i]);
} else {
sum_b += get<2>(t[i]);
}
}
cout << sum_a - sum_b << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define DEBUG_
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
#define PI 3.141592653589793238
#define RMAX 4294967295
#ifdef DEBUG_
#define DEB
#else
#define DEB if (false)
#endif
#ifdef DEBUG_
#define dump(...) \
DUMPOUT << " "; \
dump_func(string(#__VA_ARGS__) + ":", \
"[" + to_string(__LINE__) + ":" + __FUNCTION__ + "]"); \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#else
#define dump(...)
#endif
typedef long long ll;
typedef pair<int, int> Pi;
typedef pair<ll, ll> Pll;
typedef pair<double, double> Pd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<Pi> vPi;
typedef vector<Pll> vPll;
typedef vector<Pd> vPd;
typedef vector<vector<int>> vvi;
typedef vector<vector<bool>> vvb;
typedef vector<vector<ll>> vvll;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<double>> vvd;
typedef vector<vector<Pi>> vvPi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<vector<vector<Pi>>> vvvPi;
typedef vector<vector<vector<vector<Pi>>>> vvvvPi;
typedef priority_queue<int, vector<int>, greater<int>> pqli;
typedef priority_queue<ll, vector<ll>, greater<ll>> pqlll;
typedef priority_queue<Pi, vector<Pi>, greater<Pi>> pqlP;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
string debug_show(Pi a) {
return "(" + to_string(a.first) + "," + to_string(a.second) + ")";
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) <= 1) {
DUMPOUT << " ";
} else {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << "," << pair_var.second << ")";
return os;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << "," << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << "(" << itr->first << "," << itr->second << ")";
itr++;
if (itr == map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << " " << *itr << endl;
itr++;
if (itr == set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
char dirchar[4] = {'<', '^', '>', 'v'};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
struct Edge {
int from, to, cost;
bool operator<(Edge e) { return cost < e.cost; }
};
using Graph = vec<vec<Edge>>;
ostream &operator<<(ostream &os, Edge &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
//======================================================
int main(void) {
int N;
cin >> N;
vec<tuple<ll, ll, ll>> t(N);
rep(i, N) {
ll a, b;
cin >> a >> b;
t[i] = mt(a + b, a, b);
}
sort(rall(t));
ll sum_a = 0, sum_b = 0;
rep(i, N) {
if (i % 2 == 0) {
sum_a += get<1>(t[i]);
} else {
sum_b += get<2>(t[i]);
}
}
cout << sum_a - sum_b << endl;
} | [
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 941,386 | 941,387 | u366676780 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
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 S, class T> using P = pair<S, T>;
template <class S, class T, class U> using TP = tuple<S, T, U>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(v, N) \
vll(v)((N)); \
vin(v);
#define vllin2(a, b, N) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(v, N) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define min(...) Min(__VA_ARGS__)
#define max(...) Max(__VA_ARGS__)
#define emin(a, ...) ((a) = Min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = Max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInput(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInput(size, __VA_ARGS__);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInputNum(ll num) {}
template <class T, class... Args>
void vInputNum(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNum(num, args...);
}
void vInput(ll size) {}
template <class... Args> void vInput(ll size, Args &...args) {
vInit(size, args...);
REP(i, size) vInputNum(i, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T, class... Args> void salv(V<T> v, Args... args) {
salv(v);
salv(args...);
}
void salv2() {}
template <class T> void salv2(V<V<T>> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv2(V<V<T>> v, Args... args) {
salv2(v);
salv2(args...);
}
template <class Monoid> struct Action {
public:
Monoid I;
function<Monoid(Monoid, Monoid)> A;
Action(Monoid I, function<Monoid(Monoid, Monoid)> A) : I(I), A(A) {}
Monoid operator()() { return I; }
Monoid operator()(Monoid x) { return x; }
Monoid operator()(Monoid l, Monoid r) { return A(l, r); }
template <class... Args> Monoid operator()(Monoid x, Args... args) {
Monoid tmp = operator()(args...);
return A(x, tmp);
}
};
template <class T> Action<T> ADD = Action<T>(0, [](T l, T r) { return l + r; });
template <>
Action<str> ADD<str> = Action<str>("", [](str l, str r) { return l + r; });
template <class T1, class T2>
Action<P<T1, T2>> ADD<P<T1, T2>> =
Action<P<T1, T2>>(mp(ADD<T1>.I, ADD<T2>.I), [](P<T1, T2> l, P<T1, T2> r) {
return mp(l.fi + r.fi, l.se + r.se);
});
template <class T> Action<T> MUL = Action<T>(1, [](T l, T r) { return l * r; });
template <class T> Action<T> OR = Action<T>(0, [](T l, T r) { return l | r; });
template <class T> Action<T> XOR = Action<T>(0, [](T l, T r) { return l ^ r; });
template <class T>
Action<T> AND = Action<T>(((ll)(1) << 63) - 1, [](T l, T r) { return l & r; });
template <>
Action<bool> AND<bool> = Action<bool>(true,
[](bool l, bool r) { return l & r; });
template <>
Action<ull> AND<ull> = Action<ull>(((ull)(1) << 63) - 1,
[](ull l, ull r) { return l & r; });
template <class T>
Action<T> MIN = Action<T>(INF, [](T l, T r) { return (l < r) ? l : r; });
template <class T>
Action<T> MAX = Action<T>(-INF, [](T l, T r) { return (l > r) ? l : r; });
template <class T>
Action<T> GCD = Action<T>(0, [](T l, T r) {
if (l < r) {
l ^= r;
r ^= l;
l ^= r;
}
return (r ? GCD<T>(r, l % r) : l);
});
template <class T>
Action<T> LCM = Action<T>(1, [](T l, T r) { return (l * r) / GCD<T>(l, r); });
template <class Head> Head Min(Head head) { return head; }
template <class Head, class... Body> Head Min(Head head, Body... body) {
auto tmp = Min(body...);
return (head < tmp) ? head : tmp;
}
template <class Head> Head Max(Head head) { return head; }
template <class Head, class... Body> auto Max(Head head, Body... body) {
auto tmp = Max(body...);
return (head > tmp) ? head : tmp;
}
ll gcd(ll a, ll b) {
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll gcd(ll head) { return head; }
template <class... Body> ll gcd(ll head, Body... body) {
return gcd(head, gcd(body...));
}
ll lcm(ll head) { return head; }
template <class... Body> ll lcm(ll head, Body... body) {
return lcm(head, lcm(body...));
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT() {}
UFT(const UFT &uft) {}
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
vvll sizepv;
pUFT() {}
pUFT(const pUFT &puft) {}
pUFT(ll tsizeget) {
tsize = tsizeget;
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {1});
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
par[y] += par[x];
sizepi[y].pb(now);
sizepv[y].pb(-par[y]);
par[x] = y;
mtime[x] = now;
} else {
par[x] += par[y];
sizepi[x].pb(now);
sizepv[x].pb(-par[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
ll size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT() {}
wUFT(const wUFT &wuft) {}
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
template <typename lentype> class Graph {
public:
ll size;
ll mode;
ll mapmode;
lentype zlen;
lentype ilen;
vector<map<ll, ll>> v2n;
vvll n2v;
vector<vector<lentype>> Edge;
vector<pair<lentype, ll>> Primresult;
Graph() {}
Graph(const Graph &graph) {}
Graph(ll sizeget = 0, ll mapmodeget = 0, ll modeget = 0, lentype zlenget = 0,
lentype ilenget = INF) {
size = sizeget;
mapmode = mapmodeget;
mode = modeget;
zlen = zlenget;
ilen = ilenget;
init();
}
void init() {
Edge.res(size);
v2n.res(size);
n2v.res(size);
Primresult.asn(size, mp(ilen, -1));
}
lentype lenplus(lentype l, lentype r) { return l + r; }
lentype lenequal(lentype l, lentype r) { return l == r; }
lentype lenlcr(lentype l, lentype r) { return l < r; }
ll addV(ll vs) {
size += vs;
init();
return size;
}
void caddE(ll x, ll y, lentype c) {
if (mapmode)
v2n[x][y] = Edge[x].sz;
Edge[x].pb(c);
n2v[x].pb(y);
}
void csetE(ll x, ll y, lentype c) {
if (mapmode)
Edge[x][v2n[x][y]] = c;
}
void cersE(ll x, ll y) {
if (mapmode) {
ll n = v2n[x][y];
Edge[x][n] = ilen;
n2v[x][n] = -1;
v2n[x].ers(y);
}
}
void addE(ll x, ll y, lentype c) {
caddE(x, y, c);
if (!mode)
caddE(y, x, c);
}
void setE(ll x, ll y, lentype c) {
csetE(x, y, c);
if (!mode)
csetE(y, x, c);
}
void ersE(ll x, ll y, lentype c) {
cersE(x, y, c);
if (!mode)
cersE(y, x, c);
}
lentype getE(ll x, ll y) {
if (mapmode) {
if (v2n[x].count(y)) {
return Edge[x][v2n[x][y]];
}
}
return ilen;
}
ll getVsz(ll x) { return Edge[x].sz; }
pair<lentype, ll> getV(ll x, ll n) {
if (n >= getVsz(x))
return mp(ilen, -1);
return mp(Edge[x][n], n2v[x][n]);
}
vector<pair<lentype, vll>> Dijk(ll x) {
vector<pair<lentype, vll>> result(size);
REP(i, size) {
result[i].fi = ilen;
result[i].se = {-1};
}
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
result[x].fi = zlen;
result[x].se = {-1};
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else if (lenequal(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].se.pb(now.se);
}
}
}
}
return result;
}
lentype Prim(ll x = 0) {
lentype ans = zlen;
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
Primresult[x] = mp(zlen, -1);
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
ans = lenplus(ans, Primresult[now.se].fi);
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(nowlv.fi, Primresult[nowlv.se].fi)) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
}
}
}
}
return ans;
}
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
Action<T> Add;
Sum(V<T> v, Action<T> Add = ADD<T>) : v(v), size(v.sz), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Add.I); }
void Calc() { REP(i, size) s[i + 1] = Add(s[i], v[i]); }
T operator()(ll x) { return operator()(0, x); }
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Add.I;
return s[r + 1] - s[l]; // for ADD
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
V<V<T>> v, s;
ll RowSize, ColumnSize;
Action<T> Add;
Sum2(V<V<T>> v, Action<T> Add = ADD<T>)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize, Add.I)); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
s[r][c] =
v[r - 1][c - 1] + operator()(r, c - 1) + operator()(r - 1, c) -
operator()(r - 1, c - 1);
}
}
}
T operator()(ll r, ll c) { return operator()(0, 0, r, c); }
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Add.I;
if (c1 > c2)
return Add.I;
return s[r2 + 1][c2 + 1] - s[r2 + 1][c1] - s[r1][c2 + 1] + s[r1][c1];
}
};
using sum2ll = Sum2<ll>;
template <class T> struct Point2 {
public:
V<V<T>> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
template <class T> T vmin(V<T> v) {
T tmp = MIN<T>.I;
ROR(v, i) emin(tmp, i);
return tmp;
}
template <class T, class... Args> T vmin(V<T> v, Args... args) {
T tmp = vmin(args...);
return min(vmin(v), tmp);
}
template <class T> T vmax(V<T> v) {
T tmp = MAX<T>.I;
ROR(v, i) emax(tmp, i);
return tmp;
}
template <class T, class... Args> T vmax(V<T> v, Args... args) {
T tmp = vmax(args...);
return max(vmax(v), tmp);
}
template <class T> T vgcd(V<T> v) {
T tmp = GCD<T>.I;
ROR(v, i) egcd(tmp, i);
return tmp;
}
template <class T, class... Args> T vgcd(V<T> v, Args... args) {
T tmp = vgcd(args...);
return gcd(vgcd(v), tmp);
}
template <class T> T vlcm(V<T> v) {
T tmp = LCM<T>.I;
ROR(v, i) elcm(tmp, i);
return tmp;
}
template <class T, class... Args> T vlcm(V<T> v, Args... args) {
T tmp = vlcm(args...);
return lcm(vlcm(v), tmp);
}
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
void PCmprs(vll &v) {
if (v.sz == 0)
return;
vll vv(v);
IOTA(vv, 0);
sort(vv.bgn, vv.en, [&](ll v1, ll v2) { return v[v1] < v[v2]; });
IOTA(v, 0);
sort(v.bgn, v.en, [&](ll v1, ll v2) { return vv[v1] < vv[v2]; });
return;
}
ll BblCnt(vll v) {
PCmprs(v);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T>
V<V<T>> MultiMatrix(V<V<T>> A, V<V<T>> B, Action<T> Mul = MUL<T>,
Action<T> Add = ADD<T>) {
V<V<T>> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) { ans[i][k] = Add(ans[i][k], Mul(A[i][j], B[j][k])); }
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> auto vecn(T val) { return val; }
template <class... Args> auto vecn(ll val, Args... args) {
auto tmp = vecn(args...);
return V<decltype(tmp)>(val, tmp);
}
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
void Solve() {
li(n);
vli(n, a, b);
ll r = 0;
vector<pair<ll, pair<ll, ll>>> c(n);
REP(i, n) { c[i] = mp(a[i] + b[i], mp(a[i], b[i])); }
SORT(c);
REP(i, n) {
if (i % 2) {
r -= c[i].se.se;
} else {
r += c[i].se.fi;
}
}
cout << r;
return;
} | #include <bits/stdc++.h>
using namespace std;
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 S, class T> using P = pair<S, T>;
template <class S, class T, class U> using TP = tuple<S, T, U>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(v, N) \
vll(v)((N)); \
vin(v);
#define vllin2(a, b, N) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(v, N) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define min(...) Min(__VA_ARGS__)
#define max(...) Max(__VA_ARGS__)
#define emin(a, ...) ((a) = Min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = Max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInput(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInput(size, __VA_ARGS__);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInputNum(ll num) {}
template <class T, class... Args>
void vInputNum(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNum(num, args...);
}
void vInput(ll size) {}
template <class... Args> void vInput(ll size, Args &...args) {
vInit(size, args...);
REP(i, size) vInputNum(i, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T, class... Args> void salv(V<T> v, Args... args) {
salv(v);
salv(args...);
}
void salv2() {}
template <class T> void salv2(V<V<T>> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv2(V<V<T>> v, Args... args) {
salv2(v);
salv2(args...);
}
template <class Monoid> struct Action {
public:
Monoid I;
function<Monoid(Monoid, Monoid)> A;
Action(Monoid I, function<Monoid(Monoid, Monoid)> A) : I(I), A(A) {}
Monoid operator()() { return I; }
Monoid operator()(Monoid x) { return x; }
Monoid operator()(Monoid l, Monoid r) { return A(l, r); }
template <class... Args> Monoid operator()(Monoid x, Args... args) {
Monoid tmp = operator()(args...);
return A(x, tmp);
}
};
template <class T> Action<T> ADD = Action<T>(0, [](T l, T r) { return l + r; });
template <>
Action<str> ADD<str> = Action<str>("", [](str l, str r) { return l + r; });
template <class T1, class T2>
Action<P<T1, T2>> ADD<P<T1, T2>> =
Action<P<T1, T2>>(mp(ADD<T1>.I, ADD<T2>.I), [](P<T1, T2> l, P<T1, T2> r) {
return mp(l.fi + r.fi, l.se + r.se);
});
template <class T> Action<T> MUL = Action<T>(1, [](T l, T r) { return l * r; });
template <class T> Action<T> OR = Action<T>(0, [](T l, T r) { return l | r; });
template <class T> Action<T> XOR = Action<T>(0, [](T l, T r) { return l ^ r; });
template <class T>
Action<T> AND = Action<T>(((ll)(1) << 63) - 1, [](T l, T r) { return l & r; });
template <>
Action<bool> AND<bool> = Action<bool>(true,
[](bool l, bool r) { return l & r; });
template <>
Action<ull> AND<ull> = Action<ull>(((ull)(1) << 63) - 1,
[](ull l, ull r) { return l & r; });
template <class T>
Action<T> MIN = Action<T>(INF, [](T l, T r) { return (l < r) ? l : r; });
template <class T>
Action<T> MAX = Action<T>(-INF, [](T l, T r) { return (l > r) ? l : r; });
template <class T>
Action<T> GCD = Action<T>(0, [](T l, T r) {
if (l < r) {
l ^= r;
r ^= l;
l ^= r;
}
return (r ? GCD<T>(r, l % r) : l);
});
template <class T>
Action<T> LCM = Action<T>(1, [](T l, T r) { return (l * r) / GCD<T>(l, r); });
template <class Head> Head Min(Head head) { return head; }
template <class Head, class... Body> Head Min(Head head, Body... body) {
auto tmp = Min(body...);
return (head < tmp) ? head : tmp;
}
template <class Head> Head Max(Head head) { return head; }
template <class Head, class... Body> auto Max(Head head, Body... body) {
auto tmp = Max(body...);
return (head > tmp) ? head : tmp;
}
ll gcd(ll a, ll b) {
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll gcd(ll head) { return head; }
template <class... Body> ll gcd(ll head, Body... body) {
return gcd(head, gcd(body...));
}
ll lcm(ll head) { return head; }
template <class... Body> ll lcm(ll head, Body... body) {
return lcm(head, lcm(body...));
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT() {}
UFT(const UFT &uft) {}
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
vvll sizepv;
pUFT() {}
pUFT(const pUFT &puft) {}
pUFT(ll tsizeget) {
tsize = tsizeget;
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {1});
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
par[y] += par[x];
sizepi[y].pb(now);
sizepv[y].pb(-par[y]);
par[x] = y;
mtime[x] = now;
} else {
par[x] += par[y];
sizepi[x].pb(now);
sizepv[x].pb(-par[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
ll size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT() {}
wUFT(const wUFT &wuft) {}
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
template <typename lentype> class Graph {
public:
ll size;
ll mode;
ll mapmode;
lentype zlen;
lentype ilen;
vector<map<ll, ll>> v2n;
vvll n2v;
vector<vector<lentype>> Edge;
vector<pair<lentype, ll>> Primresult;
Graph() {}
Graph(const Graph &graph) {}
Graph(ll sizeget = 0, ll mapmodeget = 0, ll modeget = 0, lentype zlenget = 0,
lentype ilenget = INF) {
size = sizeget;
mapmode = mapmodeget;
mode = modeget;
zlen = zlenget;
ilen = ilenget;
init();
}
void init() {
Edge.res(size);
v2n.res(size);
n2v.res(size);
Primresult.asn(size, mp(ilen, -1));
}
lentype lenplus(lentype l, lentype r) { return l + r; }
lentype lenequal(lentype l, lentype r) { return l == r; }
lentype lenlcr(lentype l, lentype r) { return l < r; }
ll addV(ll vs) {
size += vs;
init();
return size;
}
void caddE(ll x, ll y, lentype c) {
if (mapmode)
v2n[x][y] = Edge[x].sz;
Edge[x].pb(c);
n2v[x].pb(y);
}
void csetE(ll x, ll y, lentype c) {
if (mapmode)
Edge[x][v2n[x][y]] = c;
}
void cersE(ll x, ll y) {
if (mapmode) {
ll n = v2n[x][y];
Edge[x][n] = ilen;
n2v[x][n] = -1;
v2n[x].ers(y);
}
}
void addE(ll x, ll y, lentype c) {
caddE(x, y, c);
if (!mode)
caddE(y, x, c);
}
void setE(ll x, ll y, lentype c) {
csetE(x, y, c);
if (!mode)
csetE(y, x, c);
}
void ersE(ll x, ll y, lentype c) {
cersE(x, y, c);
if (!mode)
cersE(y, x, c);
}
lentype getE(ll x, ll y) {
if (mapmode) {
if (v2n[x].count(y)) {
return Edge[x][v2n[x][y]];
}
}
return ilen;
}
ll getVsz(ll x) { return Edge[x].sz; }
pair<lentype, ll> getV(ll x, ll n) {
if (n >= getVsz(x))
return mp(ilen, -1);
return mp(Edge[x][n], n2v[x][n]);
}
vector<pair<lentype, vll>> Dijk(ll x) {
vector<pair<lentype, vll>> result(size);
REP(i, size) {
result[i].fi = ilen;
result[i].se = {-1};
}
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
result[x].fi = zlen;
result[x].se = {-1};
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].fi = lenplus(result[now.se].fi, nowlv.fi);
result[nowlv.se].se = {now.se};
Q.set(nowlv.se, mp(result[nowlv.se].fi, nowlv.se));
} else if (lenequal(lenplus(result[now.se].fi, nowlv.fi),
result[nowlv.se].fi)) {
result[nowlv.se].se.pb(now.se);
}
}
}
}
return result;
}
lentype Prim(ll x = 0) {
lentype ans = zlen;
vll stat(size, 0);
pair<lentype, ll> now;
pair<lentype, ll> nowlv;
SegT<pair<lentype, ll>> Q(size, mp(ilen, -1),
[](pair<lentype, ll> l, pair<lentype, ll> r) {
if (l.se == -1)
return r;
if (r.se == -1)
return l;
return l.fi < r.fi ? l : r;
});
Q.set(x, mp(zlen, x));
Primresult[x] = mp(zlen, -1);
while (Q.que(0, size - 1).se != -1) {
now = Q.que(0, size - 1);
Q.set(now.se, mp(ilen, -1));
stat[now.se] = 1;
ans = lenplus(ans, Primresult[now.se].fi);
REP(i, getVsz(now.se)) {
nowlv = getV(now.se, i);
if (stat[nowlv.se])
continue;
if (Q[nowlv.se].se == -1) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
} else {
if (lenlcr(nowlv.fi, Primresult[nowlv.se].fi)) {
Primresult[nowlv.se] = mp(nowlv.fi, now.se);
Q.set(nowlv.se, mp(Primresult[nowlv.se].fi, nowlv.se));
}
}
}
}
return ans;
}
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
Action<T> Add;
Sum(V<T> v, Action<T> Add = ADD<T>) : v(v), size(v.sz), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Add.I); }
void Calc() { REP(i, size) s[i + 1] = Add(s[i], v[i]); }
T operator()(ll x) { return operator()(0, x); }
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Add.I;
return s[r + 1] - s[l]; // for ADD
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
V<V<T>> v, s;
ll RowSize, ColumnSize;
Action<T> Add;
Sum2(V<V<T>> v, Action<T> Add = ADD<T>)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize, Add.I)); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
s[r][c] =
v[r - 1][c - 1] + operator()(r, c - 1) + operator()(r - 1, c) -
operator()(r - 1, c - 1);
}
}
}
T operator()(ll r, ll c) { return operator()(0, 0, r, c); }
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Add.I;
if (c1 > c2)
return Add.I;
return s[r2 + 1][c2 + 1] - s[r2 + 1][c1] - s[r1][c2 + 1] + s[r1][c1];
}
};
using sum2ll = Sum2<ll>;
template <class T> struct Point2 {
public:
V<V<T>> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
template <class T> T vmin(V<T> v) {
T tmp = MIN<T>.I;
ROR(v, i) emin(tmp, i);
return tmp;
}
template <class T, class... Args> T vmin(V<T> v, Args... args) {
T tmp = vmin(args...);
return min(vmin(v), tmp);
}
template <class T> T vmax(V<T> v) {
T tmp = MAX<T>.I;
ROR(v, i) emax(tmp, i);
return tmp;
}
template <class T, class... Args> T vmax(V<T> v, Args... args) {
T tmp = vmax(args...);
return max(vmax(v), tmp);
}
template <class T> T vgcd(V<T> v) {
T tmp = GCD<T>.I;
ROR(v, i) egcd(tmp, i);
return tmp;
}
template <class T, class... Args> T vgcd(V<T> v, Args... args) {
T tmp = vgcd(args...);
return gcd(vgcd(v), tmp);
}
template <class T> T vlcm(V<T> v) {
T tmp = LCM<T>.I;
ROR(v, i) elcm(tmp, i);
return tmp;
}
template <class T, class... Args> T vlcm(V<T> v, Args... args) {
T tmp = vlcm(args...);
return lcm(vlcm(v), tmp);
}
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
void PCmprs(vll &v) {
if (v.sz == 0)
return;
vll vv(v);
IOTA(vv, 0);
sort(vv.bgn, vv.en, [&](ll v1, ll v2) { return v[v1] < v[v2]; });
IOTA(v, 0);
sort(v.bgn, v.en, [&](ll v1, ll v2) { return vv[v1] < vv[v2]; });
return;
}
ll BblCnt(vll v) {
PCmprs(v);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T>
V<V<T>> MultiMatrix(V<V<T>> A, V<V<T>> B, Action<T> Mul = MUL<T>,
Action<T> Add = ADD<T>) {
V<V<T>> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) { ans[i][k] = Add(ans[i][k], Mul(A[i][j], B[j][k])); }
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> auto vecn(T val) { return val; }
template <class... Args> auto vecn(ll val, Args... args) {
auto tmp = vecn(args...);
return V<decltype(tmp)>(val, tmp);
}
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
void Solve() {
li(n);
vli(n, a, b);
ll r = 0;
vector<pair<ll, pair<ll, ll>>> c(n);
REP(i, n) { c[i] = mp(a[i] + b[i], mp(a[i], b[i])); }
rSORT(c);
REP(i, n) {
if (i % 2) {
r -= c[i].se.se;
} else {
r += c[i].se.fi;
}
}
cout << r;
return;
} | [
"identifier.change",
"call.function.change"
] | 941,388 | 941,389 | u172929647 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
long long inf = 1e9 + 7;
int main(void) {
long long n;
cin >> n;
vector<long long> a(n), b(n), d(n);
vector<pair<int, int>> bridge(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
d[i] = a[i] - b[i];
bridge[i] = make_pair(a[i] - b[i], i);
}
sort(bridge.begin(), bridge.end());
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (i % 2 == (n - 1) % 2)
ans += a[bridge[i].second];
else
ans -= b[bridge[i].second];
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
long long inf = 1e9 + 7;
int main(void) {
long long n;
cin >> n;
vector<long long> a(n), b(n), d(n);
vector<pair<long long, long long>> bridge(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
d[i] = a[i] - b[i];
bridge[i] = make_pair(a[i] + b[i], i);
}
sort(bridge.begin(), bridge.end());
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (i % 2 == (n - 1) % 2)
ans += a[bridge[i].second];
else
ans -= b[bridge[i].second];
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,392 | 941,393 | u921168761 | cpp |
p03141 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <set>
using namespace std;
typedef long long LL;
#define dd c = getchar()
inline int read() {
int a = 0, b = 1, dd;
while (!isdigit(c)) {
if (c == '-')
b = -b;
dd;
}
while (isdigit(c)) {
a = a * 10 + c - '0';
dd;
}
return a * b;
}
inline void print(LL x) {
static int c[23];
static int n;
if (x == 0) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
n = 0;
while (x > 0) {
c[n++] = x % 10;
x /= 10;
}
while (n-- > 0) {
putchar(c[n] + '0');
}
}
inline void printsp(LL x) {
print(x);
putchar(' ');
}
inline void println(LL x) {
print(x);
putchar('\n');
}
#undef dd
int n;
struct st {
int a, b;
} a[100003];
bool operator<(st a, st b) { return a.a + a.b < b.a + b.b; }
LL ans;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].a = read();
a[i].b = read();
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (i & 1) {
ans += a[i].a;
} else {
ans -= a[i].b;
}
}
println(ans);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <set>
using namespace std;
typedef long long LL;
#define dd c = getchar()
inline int read() {
int a = 0, b = 1, dd;
while (!isdigit(c)) {
if (c == '-')
b = -b;
dd;
}
while (isdigit(c)) {
a = a * 10 + c - '0';
dd;
}
return a * b;
}
inline void print(LL x) {
static int c[23];
static int n;
if (x == 0) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
n = 0;
while (x > 0) {
c[n++] = x % 10;
x /= 10;
}
while (n-- > 0) {
putchar(c[n] + '0');
}
}
inline void printsp(LL x) {
print(x);
putchar(' ');
}
inline void println(LL x) {
print(x);
putchar('\n');
}
#undef dd
int n;
struct st {
int a, b;
} a[100003];
bool operator<(st a, st b) { return a.a + a.b > b.a + b.b; }
LL ans;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].a = read();
a[i].b = read();
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (i & 1) {
ans += a[i].a;
} else {
ans -= a[i].b;
}
}
println(ans);
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,398 | 941,399 | u000109997 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N;
vector<tuple<long long, long long, long long>> v;
cin >> N;
for (int i = 0; i < N; ++i) {
long long a, b;
cin >> a >> b;
v.push_back(make_tuple(a - b, a, -b));
}
sort(v.begin(), v.end());
long long result = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
result += get<1>(v[N - i - 1]);
} else {
result += get<2>(v[N - i - 1]);
}
}
cout << result << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N;
vector<tuple<long long, long long, long long>> v;
cin >> N;
for (int i = 0; i < N; ++i) {
long long a, b;
cin >> a >> b;
v.push_back(make_tuple(a + b, a, b));
}
sort(v.begin(), v.end());
long long result = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
result += get<1>(v[N - i - 1]);
} else {
result -= get<2>(v[N - i - 1]);
}
}
cout << result << '\n';
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.unary.arithmetic.remove",
"expression.operator.change"
] | 941,400 | 941,401 | u003080851 | cpp |
p03141 | #include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define LL long long
#define LD long double
#define FOR(i, a, b) for (int i = (int)a; i <= (int)b; i++)
#define RFOR(i, a, b) for (int i = (int)a; i >= (int)b; i--)
#define int LL
using namespace std;
const int MX = 1e5 + 1;
bool vis[MX];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n], b[n];
FOR(i, 0, n - 1)
cin >> a[i] >> b[i];
pair<int, int> p[n];
FOR(i, 0, n - 1)
p[i] = MP(a[i] - b[i], i);
sort(p, p + n);
for (int i = n - 1; i >= 0; i -= 2)
vis[p[i].S] = true;
int ans = 0;
FOR(i, 0, n - 1)
if (vis[i])
ans += a[i];
else
ans -= b[i];
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define LL long long
#define LD long double
#define FOR(i, a, b) for (int i = (int)a; i <= (int)b; i++)
#define RFOR(i, a, b) for (int i = (int)a; i >= (int)b; i--)
#define int LL
using namespace std;
const int MX = 1e5 + 1;
bool vis[MX];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n], b[n];
FOR(i, 0, n - 1)
cin >> a[i] >> b[i];
pair<int, int> p[n];
FOR(i, 0, n - 1)
p[i] = MP(a[i] + b[i], i);
sort(p, p + n);
for (int i = n - 1; i >= 0; i -= 2)
vis[p[i].S] = true;
int ans = 0;
FOR(i, 0, n - 1)
if (vis[i])
ans += a[i];
else
ans -= b[i];
cout << ans;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,407 | 941,408 | u472870759 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
struct Pair {
long long score;
int index;
Pair(long long s, int i) {
score = s;
index = i;
}
bool operator<(const Pair &another) const { return score < another.score; };
};
int main() {
int n;
cin >> n;
long long a[n], b[n];
vector<Pair> pairs;
long long bufa, bufb;
for (int i = 0; i < n; i++) {
cin >> bufa >> bufb;
a[i] = bufa;
b[i] = bufb;
pairs.push_back(Pair(bufa + bufb, i));
}
sort(pairs.begin(), pairs.end());
long long answer = 0;
for (int i = 0; i < n; i++) {
int ind = pairs[i].index;
if (i % 2 == 0) {
answer += a[ind];
} else {
answer -= b[ind];
}
}
cout << answer << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
struct Pair {
long long score;
int index;
Pair(long long s, int i) {
score = s;
index = i;
}
bool operator<(const Pair &another) const { return score < another.score; };
};
int main() {
int n;
cin >> n;
long long a[n], b[n];
vector<Pair> pairs;
long long bufa, bufb;
for (int i = 0; i < n; i++) {
cin >> bufa >> bufb;
a[i] = bufa;
b[i] = bufb;
pairs.push_back(Pair(bufa + bufb, i));
}
sort(pairs.begin(), pairs.end());
long long answer = 0;
for (int i = 0; i < n; i++) {
int ind = pairs[n - i - 1].index;
if (i % 2 == 0) {
answer += a[ind];
} else {
answer -= b[ind];
}
}
cout << answer << endl;
return 0;
}
| [
"assignment.change"
] | 941,411 | 941,412 | u847307807 | cpp |
p03141 | #define _CRT_SECURE_NO_WARNINGS
/* include ***********************/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* define *************************/
// for
#define REP(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define REPS(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define RREPS(i, n) for (int i = (int)(n); i > 0; i--)
#define FOR(i, s, n) \
for (int i = (int)(s), i##_len = (int)(n); i < i##_len; i++)
#define RFOR(i, s, n) \
for (int i = (int)(s)-1, i##_len = (int)(n); i >= i##_len; i--)
// printf
#define PRINTD(d) printf("%d\n", (d))
#define PRINTL(d) printf("%lld\n", (d))
// memset
#define m0(s) memset(s, 0, sizeof(s))
#define ml(s) memset(s, 63, sizeof(s))
#define fill(s, c) memset(s, c, sizeof(s))
#define INF 1e9
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int a[100000], b[100000];
int c[100000], in[100000];
int diff[4][2] = {
{0, -1},
{-1, 0},
{1, 0},
{0, 1},
};
int Min(int a, int b) { return (a) < (b) ? (a) : (b); }
int Max(int a, int b) { return (a) > (b) ? (a) : (b); }
void Swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
void hSwap(int x[], int i, int j) {
int temp;
temp = x[i];
x[i] = x[j];
x[j] = temp;
}
void ShowData(int x[], int left, int right) {
int i;
for (i = left; i <= right; i++)
printf("%d ", x[i]);
printf("\n");
}
void QSort(int x[], int y[], int left, int right, int n) {
int i, j; //左端,右端
int pivot; //軸
i = left;
j = right;
pivot = x[(left + right) / 2];
while (1) {
if (n > 0) { // n>0なら昇順、n<=0なら降順
while ((x[i] < pivot) && (i <= right))
i++; //軸値より大きい要素
while ((pivot < x[j]) && (i <= right))
j--; //軸値より小さい要素
} else {
while ((x[i] > pivot) && (i <= right))
i++; //軸値より小さい要素
while ((pivot > x[j]) && (i <= right))
j--; //軸値より大きい要素
}
if (i >= j)
break;
hSwap(x, i, j);
hSwap(y, i, j);
i++;
j--;
}
// ShowData(x, left, right);
if (left < i - 1)
QSort(x, y, left, i - 1, n);
if (j + 1 < right)
QSort(x, y, j + 1, right, n);
}
int main() {
int n;
scanf("%d", &n);
REP(i, n) {
scanf("%d%d", &a[i], &b[i]);
c[i] = a[i] + b[i];
in[i] = i;
}
QSort(c, in, 0, n - 1, 0);
// ShowData(c, 0, n-1);
// ShowData(index, 0, n - 1);
ll ans = 0;
REP(i, n) { ans += (i % 2) ? -b[i] : a[i]; }
PRINTL(ans);
} | #define _CRT_SECURE_NO_WARNINGS
/* include ***********************/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* define *************************/
// for
#define REP(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define REPS(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define RREPS(i, n) for (int i = (int)(n); i > 0; i--)
#define FOR(i, s, n) \
for (int i = (int)(s), i##_len = (int)(n); i < i##_len; i++)
#define RFOR(i, s, n) \
for (int i = (int)(s)-1, i##_len = (int)(n); i >= i##_len; i--)
// printf
#define PRINTD(d) printf("%d\n", (d))
#define PRINTL(d) printf("%lld\n", (d))
// memset
#define m0(s) memset(s, 0, sizeof(s))
#define ml(s) memset(s, 63, sizeof(s))
#define fill(s, c) memset(s, c, sizeof(s))
#define INF 1e9
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int a[100000], b[100000];
int c[100000], in[100000];
int diff[4][2] = {
{0, -1},
{-1, 0},
{1, 0},
{0, 1},
};
int Min(int a, int b) { return (a) < (b) ? (a) : (b); }
int Max(int a, int b) { return (a) > (b) ? (a) : (b); }
void Swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
void hSwap(int x[], int i, int j) {
int temp;
temp = x[i];
x[i] = x[j];
x[j] = temp;
}
void ShowData(int x[], int left, int right) {
int i;
for (i = left; i <= right; i++)
printf("%d ", x[i]);
printf("\n");
}
void QSort(int x[], int y[], int left, int right, int n) {
int i, j; //左端,右端
int pivot; //軸
i = left;
j = right;
pivot = x[(left + right) / 2];
while (1) {
if (n > 0) { // n>0なら昇順、n<=0なら降順
while ((x[i] < pivot) && (i <= right))
i++; //軸値より大きい要素
while ((pivot < x[j]) && (i <= right))
j--; //軸値より小さい要素
} else {
while ((x[i] > pivot) && (i <= right))
i++; //軸値より小さい要素
while ((pivot > x[j]) && (i <= right))
j--; //軸値より大きい要素
}
if (i >= j)
break;
hSwap(x, i, j);
hSwap(y, i, j);
i++;
j--;
}
// ShowData(x, left, right);
if (left < i - 1)
QSort(x, y, left, i - 1, n);
if (j + 1 < right)
QSort(x, y, j + 1, right, n);
}
int main() {
int n;
//*
scanf("%d", &n);
REP(i, n) {
scanf("%d%d", &a[i], &b[i]);
c[i] = a[i] + b[i];
in[i] = i;
}
/*/
n = 1e5;
REP(i, n) {
a[i] = 1e9-i;
b[i] = i+1e5;
c[i] = a[i] + b[i];
in[i] = i;
printf("%d %d\n", a[i], b[i]);
}
//*/
QSort(c, in, 0, n - 1, 0);
// ShowData(c, 0, n-1);
// ShowData(in, 0, n - 1);
ll ans = 0;
REP(i, n) { ans += (i % 2) ? -b[in[i]] : a[in[i]]; }
PRINTL(ans);
} | [] | 941,420 | 941,421 | u539339654 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define dbg(x) cerr << #x "=" << x << endl;
typedef long long LL;
typedef pair<LL, LL> P;
#define x first
#define y second
const int MAX_N = 1e5 + 100;
P A[MAX_N], B[MAX_N];
LL orA[MAX_N], orB[MAX_N];
int N;
bool cmp(P a, P b) { return a.x > b.x; }
int main() {
// freopen("in.txt", "r", stdin);
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> orA[i] >> orB[i];
A[i].x = orB[i] - orA[i];
A[i].y = i;
}
sort(A, A + N, cmp);
LL ans = 0;
for (int i = 0; i < N; ++i) {
int idx = A[i].y;
if (i & 1) {
ans -= orB[idx];
} else {
ans += orA[idx];
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define dbg(x) cerr << #x "=" << x << endl;
typedef long long LL;
typedef pair<LL, LL> P;
#define x first
#define y second
const int MAX_N = 1e5 + 100;
P A[MAX_N], B[MAX_N];
LL orA[MAX_N], orB[MAX_N];
int N;
bool cmp(P a, P b) { return a.x > b.x; }
int main() {
// freopen("in.txt", "r", stdin);
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> orA[i] >> orB[i];
A[i].x = orB[i] + orA[i];
A[i].y = i;
}
sort(A, A + N, cmp);
LL ans = 0;
for (int i = 0; i < N; ++i) {
int idx = A[i].y;
if (i & 1) {
ans -= orB[idx];
} else {
ans += orA[idx];
}
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,430 | 941,431 | u466497827 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
long long score[100000];
long long A[100000], B[100000];
int index[100000];
cin >> N;
for (int i = 0; i < N; i++) {
long long a, b;
cin >> A[i] >> B[i];
score[i] = A[i] + B[i];
index[i] = i;
}
sort(index, index + N,
[&score](int i1, int i2) { return score[i1] < score[i2]; });
long long allscore = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
allscore += A[index[i]];
else
allscore -= B[index[i]];
}
cout << allscore << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
long long score[100000];
long long A[100000], B[100000];
int index[100000];
cin >> N;
for (int i = 0; i < N; i++) {
long long a, b;
cin >> A[i] >> B[i];
score[i] = A[i] + B[i];
index[i] = i;
}
sort(index, index + N,
[&score](int i1, int i2) { return score[i1] > score[i2]; });
long long allscore = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
allscore += A[index[i]];
else
allscore -= B[index[i]];
}
cout << allscore << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,438 | 941,439 | u721980697 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef tuple<ll, ll, int> P;
bool cmp(const P &a, const P &b) {
if (get<1>(a) == get<1>(b)) {
return get<0>(a) > get<0>(b);
} else {
return get<1>(a) > get<1>(b);
}
}
int main() {
int n;
cin >> n;
vector<P> ps1, ps2;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
ps1.push_back(P(a, b - a, i));
ps2.push_back(P(b, a - b, i));
}
sort(ps1.begin(), ps1.end(), cmp);
sort(ps2.begin(), ps2.end(), cmp);
vector<bool> checked(n);
int ai = 0, bi = 0;
ll ans = 0;
for (int turn = 0; turn < n; turn++) {
P p;
if (turn % 2 == 0) {
while (true) {
p = ps1[ai];
if (!checked[get<2>(p)])
break;
ai++;
}
checked[get<2>(p)] = true;
ans += get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",ai=" <<
// ai << endl;
} else {
while (true) {
p = ps2[bi];
if (!checked[get<2>(p)])
break;
bi++;
}
checked[get<2>(p)] = true;
ans -= get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",bi=" <<
// bi << endl;
}
// cout << ans << endl;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef tuple<ll, ll, int> P;
bool cmp(const P &a, const P &b) {
if (get<1>(a) == get<1>(b)) {
return get<0>(a) > get<0>(b);
} else {
return get<1>(a) > get<1>(b);
}
}
int main() {
int n;
cin >> n;
vector<P> ps1, ps2;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
ps1.push_back(P(a, b + a, i));
ps2.push_back(P(b, a + b, i));
}
sort(ps1.begin(), ps1.end(), cmp);
sort(ps2.begin(), ps2.end(), cmp);
vector<bool> checked(n);
int ai = 0, bi = 0;
ll ans = 0;
for (int turn = 0; turn < n; turn++) {
P p;
if (turn % 2 == 0) {
while (true) {
p = ps1[ai];
if (!checked[get<2>(p)])
break;
ai++;
}
checked[get<2>(p)] = true;
ans += get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",ai=" <<
// ai << endl;
} else {
while (true) {
p = ps2[bi];
if (!checked[get<2>(p)])
break;
bi++;
}
checked[get<2>(p)] = true;
ans -= get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",bi=" <<
// bi << endl;
}
// cout << ans << endl;
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,440 | 941,441 | u508729896 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef tuple<ll, ll, int> P;
bool cmp(const P &a, const P &b) {
if (get<1>(a) == get<1>(b)) {
return get<0>(a) > get<0>(b);
} else {
return get<1>(a) > get<1>(b);
}
}
int main() {
int n;
cin >> n;
vector<P> ps1, ps2;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
ps1.push_back(P(a, b - a, i));
ps2.push_back(P(b, b - a, i));
}
sort(ps1.begin(), ps1.end(), cmp);
sort(ps2.begin(), ps2.end(), cmp);
vector<bool> checked(n);
int ai = 0, bi = 0;
ll ans = 0;
for (int turn = 0; turn < n; turn++) {
P p;
if (turn % 2 == 0) {
while (true) {
p = ps1[ai];
if (!checked[get<2>(p)])
break;
ai++;
}
checked[get<2>(p)] = true;
ans += get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",ai=" <<
// ai << endl;
} else {
while (true) {
p = ps2[bi];
if (!checked[get<2>(p)])
break;
bi++;
}
checked[get<2>(p)] = true;
ans -= get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",bi=" <<
// bi << endl;
}
// cout << ans << endl;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef tuple<ll, ll, int> P;
bool cmp(const P &a, const P &b) {
if (get<1>(a) == get<1>(b)) {
return get<0>(a) > get<0>(b);
} else {
return get<1>(a) > get<1>(b);
}
}
int main() {
int n;
cin >> n;
vector<P> ps1, ps2;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
ps1.push_back(P(a, b + a, i));
ps2.push_back(P(b, a + b, i));
}
sort(ps1.begin(), ps1.end(), cmp);
sort(ps2.begin(), ps2.end(), cmp);
vector<bool> checked(n);
int ai = 0, bi = 0;
ll ans = 0;
for (int turn = 0; turn < n; turn++) {
P p;
if (turn % 2 == 0) {
while (true) {
p = ps1[ai];
if (!checked[get<2>(p)])
break;
ai++;
}
checked[get<2>(p)] = true;
ans += get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",ai=" <<
// ai << endl;
} else {
while (true) {
p = ps2[bi];
if (!checked[get<2>(p)])
break;
bi++;
}
checked[get<2>(p)] = true;
ans -= get<0>(p);
// cout << get<0>(p) << "," << get<1>(p) << "," << get<2>(p) << ",bi=" <<
// bi << endl;
}
// cout << ans << endl;
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 941,442 | 941,441 | u508729896 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define INF 2100000000
#define INVALID -1
using namespace std;
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
class Ryouri {
public:
long long int a, b;
bool operator<(const Ryouri &another) const {
if (b - a == another.b - another.a)
return a > another.a;
else
return b - a > another.b - another.a;
}
Ryouri(long long int ia, long long int ib) {
a = ia;
b = ib;
}
};
vector<Ryouri> ryouri;
int absint(int a) { return max(a, -a); }
int main() {
long long int n, i, ans = 0, a, b;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a >> b;
ryouri.push_back(Ryouri(a, b));
}
sort(ryouri.begin(), ryouri.end());
for (i = 0; i < n; i++) {
// printf("a%db%d\n", ryouri[i].a, ryouri[i].b);
if (i % 2)
ans -= ryouri[i].b;
else
ans += ryouri[i].a;
}
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define INF 2100000000
#define INVALID -1
using namespace std;
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
class Ryouri {
public:
long long int a, b;
bool operator<(const Ryouri &another) const {
if (b + a == another.b + another.a)
return a > another.a;
else
return b + a > another.b + another.a;
}
Ryouri(long long int ia, long long int ib) {
a = ia;
b = ib;
}
};
vector<Ryouri> ryouri;
int absint(int a) { return max(a, -a); }
int main() {
long long int n, i, ans = 0, a, b;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a >> b;
ryouri.push_back(Ryouri(a, b));
}
sort(ryouri.begin(), ryouri.end());
for (i = 0; i < n; i++) {
// printf("a%db%d\n", ryouri[i].a, ryouri[i].b);
if (i % 2)
ans -= ryouri[i].b;
else
ans += ryouri[i].a;
}
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,443 | 941,444 | u697367509 | cpp |
p03141 | #include <bits/stdc++.h>
#define uint unsigned int
#define ld long double
#define int long long
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RFOR(i, a, b) for (int i = a; i > b; --i)
#define f first
#define se second
#define maxn 200005
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define pqueue priority_queue<int>
#define pdqueue priority_queue<int, vector<int>, greater<int>>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// const int md = 998244353;
/*const int mod = 998244353;
int power(int a,int n)
{
if(n == 1)return a%mod;
if(n == 0)return 1;
if(n&1)return ((a%mod)*(power((a*a)%mod,n/2))%mod)%mod;
return power((a*a)%mod,n/2)%mod;
}
*/
int eat[maxn], a[maxn], b[maxn];
signed main() {
showoff;
int n, s1 = 0, s2 = 0;
cin >> n;
vector<pii> v;
FOR(i, 0, n) {
int a, b;
cin >> a >> b;
v.pb({a + b, a});
}
sort(v.begin(), v.end());
FOR(i, 0, n) {
s1 += v[i].se;
++i;
if (i == n)
break;
s2 += v[i].f - v[i].se;
}
cout << s1 - s2;
return 0;
}
| #include <bits/stdc++.h>
#define uint unsigned int
#define ld long double
#define int long long
#define showoff \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define pb push_back
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RFOR(i, a, b) for (int i = a; i > b; --i)
#define f first
#define se second
#define maxn 200005
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define pqueue priority_queue<int>
#define pdqueue priority_queue<int, vector<int>, greater<int>>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// const int md = 998244353;
/*const int mod = 998244353;
int power(int a,int n)
{
if(n == 1)return a%mod;
if(n == 0)return 1;
if(n&1)return ((a%mod)*(power((a*a)%mod,n/2))%mod)%mod;
return power((a*a)%mod,n/2)%mod;
}
*/
int eat[maxn], a[maxn], b[maxn];
signed main() {
showoff;
int n, s1 = 0, s2 = 0;
cin >> n;
vector<pii> v;
FOR(i, 0, n) {
int a, b;
cin >> a >> b;
v.pb({-a - b, -a});
}
sort(v.begin(), v.end());
FOR(i, 0, n) {
s1 -= v[i].se;
++i;
if (i == n)
break;
s2 -= v[i].f - v[i].se;
}
cout << s1 - s2;
return 0;
}
| [
"expression.operation.unary.add",
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"expression.operator.change"
] | 941,449 | 941,450 | u578751202 | cpp |
p03141 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll n, ans, a, b, cnt, cn;
vector<P> v, v2;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (auto x : v) {
v2.push_back({x.second, -cnt});
cnt++;
}
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
for (auto x : v2) {
if (cn % 2 == 0) {
ans += v[-x.second].first;
} else
ans -= v[-x.second].second;
cn++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll n, ans, a, b, cnt, cn;
vector<P> v, v2;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (auto x : v) {
v2.push_back({x.first + x.second, -cnt});
cnt++;
}
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
for (auto x : v2) {
if (cn % 2 == 0) {
ans += v[-x.second].first;
} else
ans -= v[-x.second].second;
cn++;
}
cout << ans << endl;
}
| [
"expression.operation.binary.add"
] | 941,451 | 941,452 | u050428930 | cpp |
p03141 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll n, ans, a, b, cnt, cn;
vector<P> v, v2;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (auto x : v) {
v2.push_back({abs(x.first - x.second), -cnt});
cnt++;
}
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
for (auto x : v2) {
if (cn % 2 == 0) {
ans += v[-x.second].first;
} else
ans -= v[-x.second].second;
cn++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll n, ans, a, b, cnt, cn;
vector<P> v, v2;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (auto x : v) {
v2.push_back({x.first + x.second, -cnt});
cnt++;
}
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
for (auto x : v2) {
if (cn % 2 == 0) {
ans += v[-x.second].first;
} else
ans -= v[-x.second].second;
cn++;
}
cout << ans << endl;
}
| [
"call.remove",
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,453 | 941,452 | u050428930 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<iii> viii;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#define FOR(i, n, m) for (ll i = (n); i < (m); ++i)
#define FORR(i, n, m) for (ll i = (m)-1; i >= (n); --i)
#define FORE(x, xs) for (auto &x : (xs))
#define ALL(v) v.begin(), v.end()
#define ZERO(a) memset(a, 0, sizeof(a))
#define Miii(x, y, z) make_pair(x, make_pair(y, z))
const int INF = 1000000009;
const int MOD = 1000000007;
const double EPS = 1e-14;
const double PI = acos(-1);
const int MAX = 1e5;
int N;
viii A, B;
bool used[MAX];
int main() {
cin >> N;
REP(i, N) {
int a, b;
cin >> a >> b;
A.push_back(Miii(a + b, -a, i));
B.push_back(Miii(a + b, -b, i));
}
sort(ALL(A));
sort(ALL(B));
ll ans = 0;
int ia = 0, ib = 0;
REP(i, N) {
if (i % 2 == 0) {
while (used[A[ia].second.second])
ia++;
ans -= A[ia].second.first;
used[A[ia].second.second] = true;
} else {
while (used[B[ib].second.second])
ib++;
ans += B[ib].second.first;
used[B[ib].second.second] = true;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<iii> viii;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#define FOR(i, n, m) for (ll i = (n); i < (m); ++i)
#define FORR(i, n, m) for (ll i = (m)-1; i >= (n); --i)
#define FORE(x, xs) for (auto &x : (xs))
#define ALL(v) v.begin(), v.end()
#define ZERO(a) memset(a, 0, sizeof(a))
#define Miii(x, y, z) make_pair(x, make_pair(y, z))
const int INF = 1000000009;
const int MOD = 1000000007;
const double EPS = 1e-14;
const double PI = acos(-1);
const int MAX = 1e5;
int N;
viii A, B;
bool used[MAX];
int main() {
cin >> N;
REP(i, N) {
int a, b;
cin >> a >> b;
A.push_back(Miii(-a - b, -a, i));
B.push_back(Miii(-a - b, -b, i));
}
sort(ALL(A));
sort(ALL(B));
ll ans = 0;
int ia = 0, ib = 0;
REP(i, N) {
if (i % 2 == 0) {
while (used[A[ia].second.second])
ia++;
ans -= A[ia].second.first;
used[A[ia].second.second] = true;
} else {
while (used[B[ib].second.second])
ib++;
ans += B[ib].second.first;
used[B[ib].second.second] = true;
}
}
cout << ans << endl;
} | [
"expression.operation.unary.add",
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 941,454 | 941,455 | u957084285 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<iii> viii;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#define FOR(i, n, m) for (ll i = (n); i < (m); ++i)
#define FORR(i, n, m) for (ll i = (m)-1; i >= (n); --i)
#define FORE(x, xs) for (auto &x : (xs))
#define ALL(v) v.begin(), v.end()
#define ZERO(a) memset(a, 0, sizeof(a))
#define Miii(x, y, z) make_pair(x, make_pair(y, z))
const int INF = 1000000009;
const int MOD = 1000000007;
const double EPS = 1e-14;
const double PI = acos(-1);
const int MAX = 1e5;
int N;
viii A, B;
bool used[MAX];
int main() {
cin >> N;
REP(i, N) {
int a, b;
cin >> a >> b;
A.push_back(Miii(-a + b, -a, i));
B.push_back(Miii(-a + b, -b, i));
}
sort(ALL(A));
sort(ALL(B));
ll ans = 0;
int ia = 0, ib = 0;
REP(i, N) {
if (i % 2 == 0) {
while (used[A[ia].second.second])
ia++;
ans -= A[ia].second.first;
used[A[ia].second.second] = true;
} else {
while (used[B[ib].second.second])
ib++;
ans += B[ib].second.first;
used[B[ib].second.second] = true;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<iii> viii;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#define FOR(i, n, m) for (ll i = (n); i < (m); ++i)
#define FORR(i, n, m) for (ll i = (m)-1; i >= (n); --i)
#define FORE(x, xs) for (auto &x : (xs))
#define ALL(v) v.begin(), v.end()
#define ZERO(a) memset(a, 0, sizeof(a))
#define Miii(x, y, z) make_pair(x, make_pair(y, z))
const int INF = 1000000009;
const int MOD = 1000000007;
const double EPS = 1e-14;
const double PI = acos(-1);
const int MAX = 1e5;
int N;
viii A, B;
bool used[MAX];
int main() {
cin >> N;
REP(i, N) {
int a, b;
cin >> a >> b;
A.push_back(Miii(-a - b, -a, i));
B.push_back(Miii(-a - b, -b, i));
}
sort(ALL(A));
sort(ALL(B));
ll ans = 0;
int ia = 0, ib = 0;
REP(i, N) {
if (i % 2 == 0) {
while (used[A[ia].second.second])
ia++;
ans -= A[ia].second.first;
used[A[ia].second.second] = true;
} else {
while (used[B[ib].second.second])
ib++;
ans += B[ib].second.first;
used[B[ib].second.second] = true;
}
}
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,456 | 941,455 | u957084285 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
deque<long long> a(n), b(n);
deque<pair<long long, int>> c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = {a[i] + b[i], a[i]};
}
sort(c.begin(), c.end());
bool turn = true;
long long ans1 = 0;
long long ans2 = 0;
while (!c.empty()) {
long long t;
if (turn) {
t = c.front().second;
ans1 += t;
c.pop_front();
} else {
t = c.front().first - c.front().second;
c.pop_front();
ans2 += t;
}
turn = !turn;
}
cout << ans1 - ans2 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
deque<long long> a(n), b(n);
deque<pair<long long, int>> c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = {a[i] + b[i], a[i]};
}
sort(c.rbegin(), c.rend());
bool turn = true;
long long ans1 = 0;
long long ans2 = 0;
while (!c.empty()) {
long long t;
if (turn) {
t = c.front().second;
ans1 += t;
c.pop_front();
} else {
t = c.front().first - c.front().second;
c.pop_front();
ans2 += t;
}
turn = !turn;
}
cout << ans1 - ans2 << endl;
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,462 | 941,463 | u521364030 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<ll>> v(n, vector<ll>(3));
for (int i = 0; i < n; i++) {
cin >> v[i][1] >> v[i][2];
v[i][0] = v[i][1] - v[i][2];
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long ret = 0;
for (int i = 0; i < n; i++)
ret += (i % 2 == 0 ? v[i][1] : -v[i][2]);
cout << ret << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<ll>> v(n, vector<ll>(3));
for (int i = 0; i < n; i++) {
cin >> v[i][1] >> v[i][2];
v[i][0] = v[i][1] + v[i][2];
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long ret = 0;
for (int i = 0; i < n; i++)
ret += (i % 2 == 0 ? v[i][1] : -v[i][2]);
cout << ret << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,471 | 941,472 | u412908746 | cpp |
p03141 | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, b) for (int i = a; i >= b; i--)
#define int long long
#define all(a) a.begin(), a.end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n), b(n);
vector<P> c(n);
int ans = 0;
rep(i, 0, n) {
cin >> a[i] >> b[i];
c[i].first = max(a[i], b[i]);
c[i].second = i;
}
sort(c.rbegin(), c.rend());
rep(i, 0, n) {
if (i % 2 == 0) {
ans += a[c[i].second];
} else {
ans -= b[c[i].second];
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, b) for (int i = a; i >= b; i--)
#define int long long
#define all(a) a.begin(), a.end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n), b(n);
vector<P> c(n);
int ans = 0;
rep(i, 0, n) {
cin >> a[i] >> b[i];
c[i].first = a[i] + b[i];
c[i].second = i;
}
sort(c.rbegin(), c.rend());
rep(i, 0, n) {
if (i % 2 == 0) {
ans += a[c[i].second];
} else {
ans -= b[c[i].second];
}
}
cout << ans << endl;
} | [
"call.remove",
"assignment.value.change",
"call.arguments.change"
] | 941,473 | 941,474 | u984730891 | cpp |
p03141 | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, b) for (int i = a; i >= b; i--)
#define int long long
#define all(a) a.begin(), a.end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n), b(n);
vector<P> c(n);
int ans = 0;
rep(i, 0, n) {
cin >> a[i] >> b[i];
c[i].first = a[i] - b[i];
c[i].second = i;
}
sort(c.begin(), c.end());
rep(i, 0, n) {
if (i % 2 == 0) {
ans += a[c[i].second];
} else {
ans -= b[c[i].second];
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, b) for (int i = a; i >= b; i--)
#define int long long
#define all(a) a.begin(), a.end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n), b(n);
vector<P> c(n);
int ans = 0;
rep(i, 0, n) {
cin >> a[i] >> b[i];
c[i].first = a[i] + b[i];
c[i].second = i;
}
sort(c.rbegin(), c.rend());
rep(i, 0, n) {
if (i % 2 == 0) {
ans += a[c[i].second];
} else {
ans -= b[c[i].second];
}
}
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.function.change",
"call.arguments.change"
] | 941,475 | 941,474 | u984730891 | cpp |
p03141 | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
typedef tuple<ll, ll, ll> T;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<T> c;
REP(i, n) {
int a, b;
cin >> a >> b;
c.push_back(make_tuple(a - b, a, b));
}
sort(c.begin(), c.end(), greater<>());
ll choku = 0;
ll aoki = 0;
REP(i, n) {
if (i % 2 == 0)
choku += get<1>(c[i]);
else
aoki += get<2>(c[i]);
}
cout << choku - aoki << endl;
return 0;
} | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
typedef tuple<ll, ll, ll> T;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<T> c;
REP(i, n) {
int a, b;
cin >> a >> b;
c.push_back(make_tuple(a + b, a, b));
}
sort(c.begin(), c.end(), greater<>());
ll choku = 0;
ll aoki = 0;
REP(i, n) {
if (i % 2 == 0)
choku += get<1>(c[i]);
else
aoki += get<2>(c[i]);
}
cout << choku - aoki << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,476 | 941,477 | u102602414 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
struct triple {
ll first, second, third;
};
bool used[100000];
int main() {
int N, A, B;
triple diff_a[100000], diff_b[100000];
cin >> N;
REP(i, N) {
cin >> A >> B;
diff_a[i] = {A - B, A, i};
diff_b[i] = {A - B, B, i};
}
sort(diff_a, diff_a + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first < b.first;
}
});
sort(diff_b, diff_b + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first < b.first;
}
});
ll ans = 0;
int a = 0, b = 0;
while (true) {
while (a < N && used[diff_a[a].third])
a++;
if (a == N)
break;
used[diff_a[a].third] = true;
ans += diff_a[a].second;
while (b < N && used[diff_b[b].third])
b++;
if (b == N)
break;
used[diff_b[b].third] = true;
ans -= diff_b[b].second;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
struct triple {
ll first, second, third;
};
bool used[100000];
int main() {
int N, A, B;
triple diff_a[100000], diff_b[100000];
cin >> N;
REP(i, N) {
cin >> A >> B;
diff_a[i] = {A + B, A, i};
diff_b[i] = {A + B, B, i};
}
sort(diff_a, diff_a + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first > b.first;
}
});
sort(diff_b, diff_b + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first > b.first;
}
});
ll ans = 0;
int a = 0, b = 0;
while (true) {
while (a < N && used[diff_a[a].third])
a++;
if (a == N)
break;
used[diff_a[a].third] = true;
ans += diff_a[a].second;
while (b < N && used[diff_b[b].third])
b++;
if (b == N)
break;
used[diff_b[b].third] = true;
ans -= diff_b[b].second;
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change"
] | 941,478 | 941,479 | u472675932 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
struct triple {
int first, second, third;
};
bool used[100000];
int main() {
int N, A, B;
triple diff_a[100000], diff_b[100000];
cin >> N;
REP(i, N) {
cin >> A >> B;
diff_a[i] = {A - B, A, i};
diff_b[i] = {A - B, B, i};
}
sort(diff_a, diff_a + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first < b.first;
}
});
sort(diff_b, diff_b + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first < b.first;
}
});
ll ans = 0;
int a = 0, b = 0;
while (true) {
while (a < N && used[diff_a[a].third])
a++;
if (a == N)
break;
used[diff_a[a].third] = true;
ans += diff_a[a].second;
while (b < N && used[diff_b[b].third])
b++;
if (b == N)
break;
used[diff_b[b].third] = true;
ans -= diff_b[b].second;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
struct triple {
ll first, second, third;
};
bool used[100000];
int main() {
int N, A, B;
triple diff_a[100000], diff_b[100000];
cin >> N;
REP(i, N) {
cin >> A >> B;
diff_a[i] = {A + B, A, i};
diff_b[i] = {A + B, B, i};
}
sort(diff_a, diff_a + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first > b.first;
}
});
sort(diff_b, diff_b + N, [](const triple &a, const triple &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first > b.first;
}
});
ll ans = 0;
int a = 0, b = 0;
while (true) {
while (a < N && used[diff_a[a].third])
a++;
if (a == N)
break;
used[diff_a[a].third] = true;
ans += diff_a[a].second;
while (b < N && used[diff_b[b].third])
b++;
if (b == N)
break;
used[diff_b[b].third] = true;
ans -= diff_b[b].second;
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change"
] | 941,480 | 941,479 | u472675932 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define BIG 1000000010
#define repi(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) repi(i, 0, n)
#define repn(i, n) for (int i = n; i >= 0; i--)
typedef long long int ll;
int main() {
ll n;
ll ans = 0;
ll a[100000], b[100000], c[100000];
pair<ll, pair<ll, ll>> p[100000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
p[i] = make_pair(c[i], make_pair(a[i], b[i]));
}
sort(p, p + n);
for (int i = n - 1; i >= 0; i--) {
if (i % 2 == 0)
ans += p[i].second.first;
else
ans -= p[i].second.second;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define BIG 1000000010
#define repi(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) repi(i, 0, n)
#define repn(i, n) for (int i = n; i >= 0; i--)
typedef long long int ll;
int main() {
ll n;
ll ans = 0;
ll a[100000], b[100000], c[100000];
pair<ll, pair<ll, ll>> p[100000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
p[i] = make_pair(c[i], make_pair(a[i], b[i]));
}
sort(p, p + n);
for (int i = n - 1; i >= 0; i--) {
if ((n - i) % 2 == 1)
ans += p[i].second.first;
else
ans -= p[i].second.second;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"literal.number.change"
] | 941,487 | 941,488 | u386769326 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define BIG 1000000010
#define repi(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) repi(i, 0, n)
#define repn(i, n) for (int i = n; i >= 0; i--)
typedef long long int ll;
int main() {
ll n;
ll ans = 0;
int a[100000], b[100000], c[100000];
pair<ll, pair<ll, ll>> p[100000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
p[i] = make_pair(c[i], make_pair(a[i], b[i]));
}
sort(p, p + n);
for (int i = n - 1; i >= 0; i--) {
if (i % 2 == 0)
ans += p[i].second.first;
else
ans -= p[i].second.second;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define BIG 1000000010
#define repi(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) repi(i, 0, n)
#define repn(i, n) for (int i = n; i >= 0; i--)
typedef long long int ll;
int main() {
ll n;
ll ans = 0;
ll a[100000], b[100000], c[100000];
pair<ll, pair<ll, ll>> p[100000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
p[i] = make_pair(c[i], make_pair(a[i], b[i]));
}
sort(p, p + n);
for (int i = n - 1; i >= 0; i--) {
if ((n - i) % 2 == 1)
ans += p[i].second.first;
else
ans -= p[i].second.second;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"literal.number.change"
] | 941,489 | 941,488 | u386769326 | cpp |
p03141 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++(i))
#define ALL(x) begin(x), end(x)
using ll = long long;
using namespace std;
ll solve(int n, vector<ll> const &a, vector<ll> const &b) {
vector<int> order(n);
iota(ALL(order), 0);
sort(ALL(order), [&](int i, int j) { return a[i] - b[i] < a[j] - b[j]; });
ll delta = 0;
REP(i, n) {
int j = order[i];
if (i % 2 == 0) {
delta += a[j];
} else {
delta -= b[j];
}
}
return delta;
}
int main() {
int n;
cin >> n;
vector<ll> a(n), b(n);
REP(i, n) cin >> a[i] >> b[i];
cout << solve(n, a, b) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++(i))
#define ALL(x) begin(x), end(x)
using ll = long long;
using namespace std;
ll solve(int n, vector<ll> const &a, vector<ll> const &b) {
vector<int> order(n);
iota(ALL(order), 0);
sort(ALL(order), [&](int i, int j) { return a[i] + b[i] > a[j] + b[j]; });
ll delta = 0;
REP(i, n) {
int j = order[i];
if (i % 2 == 0) {
delta += a[j];
} else {
delta -= b[j];
}
}
return delta;
}
int main() {
int n;
cin >> n;
vector<ll> a(n), b(n);
REP(i, n) cin >> a[i] >> b[i];
cout << solve(n, a, b) << 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,492 | 941,493 | u207056619 | cpp |
p03141 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(x) cerr << #x << " = " << (x) << endl;
#define PB push_back
#define MP make_pair
#define ll long long
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
/* Pass to std::sort */
bool predication(const pair<ll, pair<ll, ll>> &a,
const pair<ll, pair<ll, ll>> &b) {
return a.first < b.first;
}
int main() {
std::ios::sync_with_stdio(false);
ll t_sum = 0, a_sum = 0;
ll a, b, n;
cin >> n;
vector<pair<ll, pair<ll, ll>>> piii;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
piii.push_back(make_pair(a + b, make_pair(a, b)));
}
sort(piii.begin(), piii.end(), predication);
for (int i = 0; i < n; ++i) {
if ((i % 2) == 0) {
t_sum += piii[i].second.first;
} else {
a_sum += piii[i].second.second;
}
}
cout << t_sum - a_sum << endl;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(x) cerr << #x << " = " << (x) << endl;
#define PB push_back
#define MP make_pair
#define ll long long
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
/* Pass to std::sort */
bool predication(const pair<ll, pair<ll, ll>> &a,
const pair<ll, pair<ll, ll>> &b) {
return a.first < b.first;
}
int main() {
std::ios::sync_with_stdio(false);
ll t_sum = 0, a_sum = 0;
ll a, b, n;
cin >> n;
vector<pair<ll, pair<ll, ll>>> piii;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
piii.push_back(make_pair(a + b, make_pair(a, b)));
}
sort(piii.rbegin(), piii.rend(), predication);
for (int i = 0; i < n; ++i) {
if ((i % 2) == 0) {
t_sum += piii[i].second.first;
} else {
a_sum += piii[i].second.second;
}
}
cout << t_sum - a_sum << endl;
} | [
"call.function.change",
"call.arguments.change"
] | 941,496 | 941,497 | u340303097 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
pii A[100009];
int main() {
long long ans = 0;
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++)
scanf("%d%d", &A[i].first, &A[i].second);
sort(A, A + N,
[&](pii P, pii Q) { return P.first + P.second < Q.first + Q.second; });
for (int i = 0; i < N; i++)
ans += (i % 2 ? -A[i].second : A[i].first);
printf("%lld", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
pii A[100009];
int main() {
long long ans = 0;
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++)
scanf("%d%d", &A[i].first, &A[i].second);
sort(A, A + N,
[&](pii P, pii Q) { return P.first + P.second > Q.first + Q.second; });
for (int i = 0; i < N; i++)
ans += (i % 2 ? -A[i].second : A[i].first);
printf("%lld", ans);
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,500 | 941,501 | u052065730 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define MOD (1000000007l)
#define rep(i, n) for (long i = 0; i < (n); i++)
using namespace std;
void solve() {
long N;
cin >> N;
vector<long> AB(N);
long Bsum = 0;
rep(i, N) {
long a, b;
cin >> a >> b;
AB[i] = a + b;
Bsum += b;
}
sort(AB.begin(), AB.end());
long ABsum = 0;
for (long i = 0; i < N; i += 2) {
ABsum += AB[i];
}
cout << ABsum - Bsum << endl;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(12);
solve();
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define MOD (1000000007l)
#define rep(i, n) for (long i = 0; i < (n); i++)
using namespace std;
void solve() {
long N;
cin >> N;
vector<long> AB(N);
long Bsum = 0;
rep(i, N) {
long a, b;
cin >> a >> b;
AB[i] = a + b;
Bsum += b;
}
sort(AB.rbegin(), AB.rend());
long ABsum = 0;
for (long i = 0; i < N; i += 2) {
ABsum += AB[i];
}
cout << ABsum - Bsum << endl;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(12);
solve();
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,502 | 941,503 | u995792346 | cpp |
p03141 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
using namespace std;
typedef long long int ll;
typedef complex<double> com;
const int mod = 1e9 + 7;
const int MOD = 998244353;
const ll INF = 4e18;
int main() {
int n;
cin >> n;
vector<ll> a(n);
ll ans = 0;
rep(i, 0, n) {
int x, y;
cin >> x >> y;
ans -= y;
a[i] = x + y;
}
sort(a.begin(), a.end(), greater<ll>());
rep(i, 0, n) if (i % 2 == 0) ans += a[i];
printf("%d", ans);
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
using namespace std;
typedef long long int ll;
typedef complex<double> com;
const int mod = 1e9 + 7;
const int MOD = 998244353;
const ll INF = 4e18;
int main() {
int n;
cin >> n;
vector<ll> a(n);
ll ans = 0;
rep(i, 0, n) {
int x, y;
cin >> x >> y;
ans -= y;
a[i] = x + y;
}
sort(a.begin(), a.end(), greater<ll>());
rep(i, 0, n) if (i % 2 == 0) ans += a[i];
printf("%lld", ans);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 941,508 | 941,509 | u407614884 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define ll long long
#define P pair<int, int>
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define GI(name) \
int(name); \
scanf("%d", &(name))
#define GI2(name1, name2) \
int(name1), (name2); \
scanf("%d %d", &(name1), &(name2))
#define GI3(name1, name2, name3) \
int(name1), (name2), (name3); \
scanf("%d %d %d", &(name1), &(name2), &(name3))
#define GVI(name, size) \
vector<int>(name)(size); \
FOR(i, (size)) scanf("%d", &(name)[i])
#define GS(name) \
string(name); \
cin >> (name);
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int main() {
GI(N);
vector<ll> A(N), B(N);
vector<ll> li(N);
FOR(i, N) {
cin >> A[i] >> B[i];
li[i] = A[i] - B[i];
}
vector<int> ind(N);
FOR(i, N) ind[i] = i;
sort(ALL(ind), [&](const int &l, const int &r) { return li[l] > li[r]; });
ll ans = 0;
FOR(i, N) {
if (i % 2 == 0) {
ans += A[ind[i]];
} else {
ans -= B[ind[i]];
}
}
print(ans);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define ll long long
#define P pair<int, int>
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define GI(name) \
int(name); \
scanf("%d", &(name))
#define GI2(name1, name2) \
int(name1), (name2); \
scanf("%d %d", &(name1), &(name2))
#define GI3(name1, name2, name3) \
int(name1), (name2), (name3); \
scanf("%d %d %d", &(name1), &(name2), &(name3))
#define GVI(name, size) \
vector<int>(name)(size); \
FOR(i, (size)) scanf("%d", &(name)[i])
#define GS(name) \
string(name); \
cin >> (name);
#define MOD 1000000007
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
string to_string(string s) { return s; }
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int main() {
GI(N);
vector<ll> A(N), B(N);
vector<ll> li(N);
FOR(i, N) {
cin >> A[i] >> B[i];
li[i] = A[i] + B[i];
}
vector<int> ind(N);
FOR(i, N) ind[i] = i;
sort(ALL(ind), [&](const int &l, const int &r) { return li[l] > li[r]; });
ll ans = 0;
FOR(i, N) {
if (i % 2 == 0) {
ans += A[ind[i]];
} else {
ans -= B[ind[i]];
}
}
print(ans);
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,510 | 941,511 | u656771711 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 100003;
struct point {
ll diff;
ll a;
ll b;
int num;
};
auto compare1 = [](point &A, point &B) {
if (A.diff == B.diff)
return A.a < B.a;
return A.diff > B.diff;
};
auto compare2 = [](point &A, point &B) {
if (A.diff == B.diff)
return A.b < B.b;
return A.diff > B.diff;
};
int main() {
int N;
cin >> N;
vector<point> S(N);
vector<bool> C(N, 0);
priority_queue<point, vector<point>, decltype(compare1)> PQ1(compare1);
priority_queue<point, vector<point>, decltype(compare2)> PQ2(compare2);
for (int i = 0; i < N; i++) {
ll a, b;
cin >> a >> b;
S[i].diff = a - b;
S[i].a = a;
S[i].b = b;
S[i].num = i;
PQ1.push(S[i]);
PQ2.push(S[i]);
}
ll ans = 0;
/*for(int i=0;i<N;i++){
cout<<PQ1.top().num<<" "<<PQ2.top().num<<endl;
PQ1.pop();
PQ2.pop();
}*/
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
while (C[PQ1.top().num] == 1) {
PQ1.pop();
}
ans += PQ1.top().a;
C[PQ1.top().num] = 1;
PQ1.pop();
} else {
while (C[PQ2.top().num] == 1) {
PQ2.pop();
}
ans -= PQ2.top().b;
C[PQ2.top().num] = 1;
PQ2.pop();
}
// cout<<ans<<endl;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 100003;
struct point {
ll diff;
ll a;
ll b;
int num;
};
auto compare1 = [](point &A, point &B) {
if (A.diff == B.diff)
return A.a < B.a;
return A.diff < B.diff;
};
auto compare2 = [](point &A, point &B) {
if (A.diff == B.diff)
return A.b < B.b;
return A.diff < B.diff;
};
int main() {
int N;
cin >> N;
vector<point> S(N);
vector<bool> C(N, 0);
priority_queue<point, vector<point>, decltype(compare1)> PQ1(compare1);
priority_queue<point, vector<point>, decltype(compare2)> PQ2(compare2);
for (int i = 0; i < N; i++) {
ll a, b;
cin >> a >> b;
S[i].diff = a + b;
S[i].a = a;
S[i].b = b;
S[i].num = i;
PQ1.push(S[i]);
PQ2.push(S[i]);
}
ll ans = 0;
/*for(int i=0;i<N;i++){
cout<<PQ1.top().num<<" "<<PQ2.top().num<<endl;
PQ1.pop();
PQ2.pop();
}*/
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
while (C[PQ1.top().num] == 1) {
PQ1.pop();
}
ans += PQ1.top().a;
C[PQ1.top().num] = 1;
PQ1.pop();
} else {
while (C[PQ2.top().num] == 1) {
PQ2.pop();
}
ans -= PQ2.top().b;
C[PQ2.top().num] = 1;
PQ2.pop();
}
// cout<<ans<<endl;
}
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change",
"expression.operator.arithmetic.change",
"assignment.value.change"
] | 941,512 | 941,513 | u133391510 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pint;
const ll inf = (1LL << 60);
const ll mod = 1000000007;
ll N;
vector<pint> AB, list;
int main() {
cin >> N;
ll v, u;
rep(i, N) {
cin >> v >> u;
list.push_back({v, u});
AB.push_back({MAX(v, u), i});
}
sort(AB.begin(), AB.end());
reverse(AB.begin(), AB.end());
ll sumT = 0, sumA = 0;
rep(i, N) {
if (i % 2 == 0) {
sumT += list[AB[i].second].first;
} else
sumA += list[AB[i].second].second;
}
cout << sumT - sumA << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pint;
const ll inf = (1LL << 60);
const ll mod = 1000000007;
ll N;
vector<pint> AB, list;
int main() {
cin >> N;
ll v, u;
rep(i, N) {
cin >> v >> u;
list.push_back({v, u});
AB.push_back({v + u, i});
}
sort(AB.begin(), AB.end());
reverse(AB.begin(), AB.end());
ll sumT = 0, sumA = 0;
rep(i, N) {
if (i % 2 == 0) {
sumT += list[AB[i].second].first;
} else
sumA += list[AB[i].second].second;
}
cout << sumT - sumA << endl;
return 0;
} | [
"call.remove",
"call.arguments.change"
] | 941,518 | 941,519 | u305138467 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef pair<long long, int> P;
int main() {
int N;
cin >> N;
vector<long long> A(N), B(N);
vector<P> v(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
long long s = A[i] + B[i];
v[i] = P(s, i);
}
sort(v.begin(), v.end(), greater<P>());
long long tk = 0, ao = 0;
for (int i = 0; i < N; i++) {
int x = v[i].second;
if (i % 2 == 0) {
tk += A[i];
} else {
ao += B[i];
}
}
cout << tk - ao << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<long long, int> P;
int main() {
int N;
cin >> N;
vector<long long> A(N), B(N);
vector<P> v(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
long long s = A[i] + B[i];
v[i] = P(s, i);
}
sort(v.begin(), v.end(), greater<P>());
long long tk = 0, ao = 0;
for (int i = 0; i < N; i++) {
int x = v[i].second;
if (i % 2 == 0) {
tk += A[x];
} else {
ao += B[x];
}
}
cout << tk - ao << endl;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 941,520 | 941,521 | u413492096 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
long long ans1, ans2, n;
vector<pii> vec;
bool cmp(pii a, pii b) { return a.first + a.second < b.first + b.second; }
bool flag = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
vec.push_back(pii(a, b));
}
sort(vec.begin(), vec.end());
while (!vec.empty()) {
if (!flag) {
ans1 += vec.back().first;
} else {
ans2 += vec.back().second;
}
flag = !flag;
vec.pop_back();
}
cout << ans1 - ans2;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
long long ans1, ans2, n;
vector<pii> vec;
bool cmp(pii a, pii b) { return a.first + a.second < b.first + b.second; }
bool flag = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
vec.push_back(pii(a, b));
}
sort(vec.begin(), vec.end(), cmp);
while (!vec.empty()) {
if (!flag) {
ans1 += vec.back().first;
} else {
ans2 += vec.back().second;
}
flag = !flag;
vec.pop_back();
}
cout << ans1 - ans2;
} | [
"call.arguments.add"
] | 941,522 | 941,523 | u138661009 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, a[N], b[N], c[N];
long long ans;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
iota(c, c + n, 0);
sort(c, c + n, [](int A, int B) { return (a[A] + b[A] > a[B] + b[B]); });
for (int i = 0; i < n; i++)
ans += (i & 1 ? a[c[i]] : -b[c[i]]);
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, a[N], b[N], c[N];
long long ans;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
iota(c, c + n, 0);
sort(c, c + n, [](int A, int B) { return (a[A] + b[A] > a[B] + b[B]); });
for (int i = 0; i < n; i++)
ans += (i & 1 ? -b[c[i]] : a[c[i]]);
cout << ans;
return 0;
} | [
"assignment.value.change"
] | 941,524 | 941,525 | u163061394 | cpp |
p03141 | // * *********** ********* * ** *
// * * * * *** * * * * *
// * * * * *** * * * * *
// *********** *********** *** ********* * *
// *
// * * * * *** * * * * *
// * * * * *** * * * * *
// * * * ** ********* * * * **
// ********** * *********** ***********
// * * * * * *
// * * * * * *
// * * * *********** *********** ***********
// * * * * * * *
// * * * * * *
// * * * * * *
// ********** * * *********** ***********
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <deque>
#include <float.h>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <numeric>
#include <queue>
#include <stack>
#include <stdio.h>
#include <vector>
#define ll long long
#define dou double
#define Turbo std::ios::sync_with_stdio(false)
using namespace std;
// Until 256 ;)
const int N = 1e5 + 20;
ll a[N], b[N], c[N], ans = 0;
int main() {
Turbo;
ll n;
cin >> n;
for (ll i = 0; i < n; i += 2) {
cin >> a[i] >> b[i];
ans -= b[i];
c[i] = a[i] + b[i];
}
sort(c, c + n, greater<int>());
for (ll i = 0; i < n; i += 2) {
ans += c[i];
}
cout << ans << '\n';
return 0;
}
| // * *********** ********* * ** *
// * * * * *** * * * * *
// * * * * *** * * * * *
// *********** *********** *** ********* * *
// *
// * * * * *** * * * * *
// * * * * *** * * * * *
// * * * ** ********* * * * **
// ********** * *********** ***********
// * * * * * *
// * * * * * *
// * * * *********** *********** ***********
// * * * * * * *
// * * * * * *
// * * * * * *
// ********** * * *********** ***********
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <deque>
#include <float.h>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <numeric>
#include <queue>
#include <stack>
#include <stdio.h>
#include <vector>
#define ll long long
#define dou double
#define Turbo std::ios::sync_with_stdio(false)
using namespace std;
// Until 256 ;)
const int N = 1e5 + 20;
ll a[N], b[N], c[N], ans = 0;
int main() {
Turbo;
ll n;
cin >> n;
for (ll i = 0; i < n; i++) {
cin >> a[i] >> b[i];
ans -= b[i];
c[i] = a[i] + b[i];
}
sort(c, c + n, greater<int>());
for (ll i = 0; i < n; i += 2) {
ans += c[i];
}
cout << ans << '\n';
return 0;
}
| [] | 941,526 | 941,527 | u217574537 | cpp |
p03141 | #include <bits/stdc++.h>
#define ff first
#define ss second
using namespace std;
long double PI = 3.14159265;
const int N = 2e6 + 1000;
long long int ans, ans1, ans2, ans3;
long long int n, m, h;
long long int a[N];
long long int b[N];
long long int c[N];
string s, t;
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];
c[i] = a[i] + b[i];
}
sort(c, c + n, greater<int>());
for (int i = 0; i < n; i++) {
if (0 == i % 2)
ans -= c[i];
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
#define ff first
#define ss second
using namespace std;
long double PI = 3.14159265;
const int N = 2e6 + 1000;
long long int ans, ans1, ans2, ans3;
long long int n, m, h;
long long int a[N];
long long int b[N];
long long int c[N];
string s, t;
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];
c[i] = a[i] + b[i];
}
sort(c, c + n, greater<int>());
for (int i = 0; i < n; i++) {
if (0 == i % 2)
ans += c[i];
}
cout << ans;
return 0;
}
| [
"expression.operator.change"
] | 941,532 | 941,533 | u917609891 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long ans, a[N], b[N];
int n;
vector<int> v;
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];
for (int i = 0; i < n; i++)
v.push_back(i);
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += a[v[i]];
else
ans -= b[v[i]];
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long ans, a[N], b[N];
int n;
vector<int> v;
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];
for (int i = 0; i < n; i++)
v.push_back(i);
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += a[v[i]];
else
ans -= b[v[i]];
}
cout << ans;
} | [
"call.arguments.add"
] | 941,534 | 941,535 | u503381547 | cpp |
p03141 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> P;
typedef long long int ll;
typedef pair<int, int> Pii;
const int INF = (1 << 30) - 1;
const ll INFl = 9223372036854775807;
const int MAX = 310;
const ll MOD = 1000000007;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main(void) {
int n;
cin >> n;
ll ans = 0;
ll a[100100], b[100100], ab[100100];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
ans += (ll)b[i];
ab[i] = a[i] + b[i];
}
ans *= (-1);
sort(a, a + n, greater<int>());
for (int i = 0; i < (n + 1) / 2; i++)
ans += (ll)ab[i * 2];
cout << ans << endl;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> P;
typedef long long int ll;
typedef pair<int, int> Pii;
const int INF = (1 << 30) - 1;
const ll INFl = 9223372036854775807;
const int MAX = 310;
const ll MOD = 1000000007;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main(void) {
int n;
cin >> n;
ll ans = 0;
ll a[100100], b[100100], ab[100100];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
ans += (ll)b[i];
ab[i] = a[i] + b[i];
}
ans *= (-1);
sort(ab, ab + n, greater<int>());
for (int i = 0; i < (n + 1) / 2; i++)
ans += (ll)ab[i * 2];
cout << ans << endl;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,542 | 941,543 | u055303078 | cpp |
p03141 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> P;
typedef long long int ll;
typedef pair<int, int> Pii;
const int INF = (1 << 30) - 1;
const ll INFl = 9223372036854775807;
const int MAX = 310;
const ll MOD = 1000000007;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main(void) {
int n;
cin >> n;
ll ans = 0;
int a[100100], b[100100], ab[100100];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
ans += (ll)b[i];
ab[i] = a[i] + b[i];
}
ans *= (-1);
sort(a, a + n, greater<int>());
for (int i = 0; i < (n + 1) / 2; i++)
ans += (ll)ab[i * 2];
cout << ans << endl;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> P;
typedef long long int ll;
typedef pair<int, int> Pii;
const int INF = (1 << 30) - 1;
const ll INFl = 9223372036854775807;
const int MAX = 310;
const ll MOD = 1000000007;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main(void) {
int n;
cin >> n;
ll ans = 0;
ll a[100100], b[100100], ab[100100];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
ans += (ll)b[i];
ab[i] = a[i] + b[i];
}
ans *= (-1);
sort(ab, ab + n, greater<int>());
for (int i = 0; i < (n + 1) / 2; i++)
ans += (ll)ab[i * 2];
cout << ans << endl;
} | [
"variable_declaration.type.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,544 | 941,543 | u055303078 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
long long n;
typedef pair<long long, long long> pll;
bool cmp(pll x, pll y) { return x.first + x.second > y.first + y.second; }
pll dd[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> dd[i].first >> dd[i].second;
}
sort(dd + 1, dd + n + 1);
long long ttt = 0, aaa = 0;
for (int i = 1; i <= n; i++) {
ttt += dd[i].first;
i++;
if (i > n)
break;
aaa += dd[i].second;
}
cout << ttt - aaa << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
long long n;
typedef pair<long long, long long> pll;
bool cmp(pll x, pll y) { return x.first + x.second > y.first + y.second; }
pll dd[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> dd[i].first >> dd[i].second;
}
sort(dd + 1, dd + n + 1, cmp);
long long ttt = 0, aaa = 0;
for (int i = 1; i <= n; i++) {
ttt += dd[i].first;
i++;
if (i > n)
break;
aaa += dd[i].second;
}
cout << ttt - aaa << endl;
return 0;
}
| [
"call.arguments.add"
] | 941,549 | 941,550 | u313427116 | cpp |
p03141 | #include <algorithm>
#include <cstdint>
#include <iostream>
using namespace std; // 575
const int MAX = 100000;
int main() {
int N, A, B;
static int p[MAX];
int64_t ans = 0;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> A >> B;
p[i] = A + B;
ans -= B;
}
sort(p, p + N);
for (int i = 0; i < N; i += 2)
ans += p[i];
cout << ans;
return 0;
}
/*
31536000のコメント解説欄
ここテンプレで用意してるから、A問題とかだとこの先空欄の危険あり
また、コンテスト後に https://31536000.hatenablog.com/
で解説していると思うので、良かったら読んでねー
*/ | #include <algorithm>
#include <cstdint>
#include <iostream>
using namespace std; // 575
const int MAX = 100000;
int main() {
int N, A, B;
static int p[MAX];
int64_t ans = 0;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> A >> B;
p[i] = -(A + B);
ans -= B;
}
sort(p, p + N);
for (int i = 0; i < N; i += 2)
ans -= p[i];
cout << ans;
return 0;
}
/*
31536000のコメント解説欄
ここテンプレで用意してるから、A問題とかだとこの先空欄の危険あり
また、コンテスト後に https://31536000.hatenablog.com/
で解説していると思うので、良かったら読んでねー
*/ | [
"expression.operator.change"
] | 941,555 | 941,556 | u550314572 | cpp |
p03141 | #include <algorithm>
#include <cstdint>
#include <iostream>
using namespace std; // 575
const int MAX = 100000;
int main() {
int N;
static pair<int, pair<int, int>> p[MAX];
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> p[i].second.first >> p[i].second.second;
p[i].first = p[i].second.first + p[i].second.second;
}
sort(p, p + N);
int64_t get = 0;
for (int i = 0; i < N; ++i) {
if (i & 1)
get -= p[i].second.second;
else
get += p[i].second.first;
}
cout << get;
return 0;
}
/*
31536000のコメント解説欄
ここテンプレで用意してるから、A問題とかだとこの先空欄の危険あり
また、コンテスト後に https://31536000.hatenablog.com/
で解説していると思うので、良かったら読んでねー
*/ | #include <algorithm>
#include <cstdint>
#include <iostream>
using namespace std; // 575
const int MAX = 100000;
int main() {
int N;
static pair<int, pair<int, int>> p[MAX];
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> p[i].second.first >> p[i].second.second;
p[i].first = -p[i].second.first - p[i].second.second;
}
sort(p, p + N);
int64_t get = 0;
for (int i = 0; i < N; ++i) {
if (i & 1)
get -= p[i].second.second;
else
get += p[i].second.first;
}
cout << get;
return 0;
}
/*
31536000のコメント解説欄
ここテンプレで用意してるから、A問題とかだとこの先空欄の危険あり
また、コンテスト後に https://31536000.hatenablog.com/
で解説していると思うので、良かったら読んでねー
*/ | [
"expression.operation.unary.add",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,557 | 941,558 | u550314572 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <random>
#include <vector>
using namespace std;
int N;
pair<long long, pair<long long, long long>> P[100000];
int main(void) {
long long a, b;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%lld %lld", &a, &b);
P[i] = make_pair(a + b, make_pair(a, b));
}
sort(P, P + N);
long long ans = 0;
for (int i = N - 1; i >= 0; i++) {
if (i % 2 == (N - 1) % 2) {
ans += P[i].second.first;
} else {
ans -= P[i].second.second;
}
}
printf("%lld\n", ans);
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <random>
#include <vector>
using namespace std;
int N;
pair<long long, pair<long long, long long>> P[100000];
int main(void) {
long long a, b;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%lld %lld", &a, &b);
P[i] = make_pair(a + b, make_pair(a, b));
}
sort(P, P + N);
long long ans = 0;
for (int i = N - 1; i >= 0; i--) {
if (i % 2 == (N - 1) % 2) {
ans += P[i].second.first;
} else {
ans -= P[i].second.second;
}
}
printf("%lld\n", ans);
} | [] | 941,568 | 941,569 | u828732026 | cpp |
p03141 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
#define MOD 1000000007
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
return (a.second + a.first > b.second + b.first) ||
((a.second + a.first >= b.second + b.first) && a.first > b.first);
}
int main(void) {
int n;
cin >> n;
long long sum = 0, j, turn = 1;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end(), comp);
for (int i = 0; i < n; i++) {
j = i;
while (j + 1 < n &&
a[j + 1].first + a[j + 1].second == a[i].first + a[i].second) {
j++;
}
for (int k = 0; i + k <= j - k; k++) {
if (i + k == j - k) {
if (turn == 1)
sum += a[i + k].first;
else
sum -= a[j - k].second;
turn *= -1;
} else
sum += a[i + k].first - a[j - k].second;
}
}
cout << sum << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
#define MOD 1000000007
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
return (a.second + a.first > b.second + b.first) ||
((a.second + a.first >= b.second + b.first) && a.first > b.first);
}
int main(void) {
int n;
cin >> n;
long long sum = 0, j, turn = 1;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end(), comp);
for (int i = 0; i < n; i++) {
j = i;
while (j + 1 < n &&
a[j + 1].first + a[j + 1].second == a[i].first + a[i].second) {
j++;
}
for (int k = 0; i + k <= j - k; k++) {
if (i + k == j - k) {
if (turn == 1)
sum += a[i + k].first;
else
sum -= a[j - k].second;
turn *= -1;
} else
sum += a[i + k].first - a[j - k].second;
}
i = j;
}
cout << sum << endl;
return 0;
}
| [
"assignment.add"
] | 941,570 | 941,571 | u122365993 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll d[100005];
int main() {
int N;
cin >> N;
ll a, b;
ll ret = 0;
for (int i = 0; i < N; i++) {
cin >> a >> b;
ret -= b;
d[i] = a + b;
}
sort(d, d + N, less<ll>());
for (int i = 0; i < N; i += 2) {
ret += d[i];
}
cout << ret << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll d[100005];
int main() {
int N;
cin >> N;
ll a, b;
ll ret = 0;
for (int i = 0; i < N; i++) {
cin >> a >> b;
ret -= b;
d[i] = a + b;
}
sort(d, d + N, greater<ll>());
for (int i = 0; i < N; i += 2) {
ret += d[i];
}
cout << ret << endl;
} | [
"identifier.change",
"call.arguments.change"
] | 941,574 | 941,575 | u608234874 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define sz size
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define FORN(i, a, b) for (int i = a; i <= b; i++)
#define FORRN(i, a, b) for (int i = (a); i >= (b); i--)
#define FORR(i, a, b) for (int i = (a); i > (b); i--)
typedef unsigned long long ull;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false); // Fast I/O
cin.tie(0);
cout.tie(0);
// freopen("input.in","r",stdin);
// freopen("output.out","w",stdout);
int n;
cin >> n;
ll A[n], B[n];
FOR(i, 0, n)
cin >> A[i] >> B[i];
ll C[n];
ll cc = -(accumulate(B, B + n, 0));
FOR(i, 0, n)
C[i] = A[i] + B[i];
sort(C, C + n);
reverse(C, C + n);
FOR(i, 0, n) {
if (i % 2 == 0)
cc += C[i];
}
cout << cc << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define sz size
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define FORN(i, a, b) for (int i = a; i <= b; i++)
#define FORRN(i, a, b) for (int i = (a); i >= (b); i--)
#define FORR(i, a, b) for (int i = (a); i > (b); i--)
typedef unsigned long long ull;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false); // Fast I/O
cin.tie(0);
cout.tie(0);
// freopen("input.in","r",stdin);
// freopen("output.out","w",stdout);
int n;
cin >> n;
ll A[n], B[n];
FOR(i, 0, n)
cin >> A[i] >> B[i];
ll C[n];
ll cc = -(accumulate(B, B + n, 0LL));
FOR(i, 0, n)
C[i] = A[i] + B[i];
sort(C, C + n);
reverse(C, C + n);
FOR(i, 0, n) {
if (i % 2 == 0)
cc += C[i];
}
cout << cc << endl;
return 0;
}
| [
"literal.number.type.widen.change"
] | 941,578 | 941,579 | u921592714 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int n;
cin >> n;
long a[n], b[n], c[n], ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
ans -= b[i];
}
sort(c, c + n);
for (int j = 0; j < n; j += 2)
ans += c[j];
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int n;
cin >> n;
long a[n], b[n], c[n], ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
ans -= b[i];
}
sort(c, c + n);
for (int j = 0; j < n; j += 2)
ans += c[n - j - 1];
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 941,580 | 941,581 | u014847606 | cpp |
p03141 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#define X first
#define Y second
#define vsort(v) sort((v).begin(), (v).end())
#define vrev(v) reverse((v).begin(), (v).end())
#define P pair
// stoi(s): string to int
// stod(s): string to double
// INT_MAX
// INT_MIN
// LLONG_MAX
// LLONG_MIN
// DBL_MIN
// DBL_MAX
// LDBL_MIN
// LDBL_MAX
// A-Z: 65~90
// a-z: 97~122
// |a-z| = 26
using namespace std;
using ll = long long;
int main(int argc, const char *argv[]) {
int n;
cin >> n;
vector<P<int, int>> v(n);
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v[i].X = a + b;
v[i].Y = a;
}
vsort(v);
vrev(v);
int ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans += v[i].Y;
} else {
ans -= v[i].X - v[i].Y;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#define X first
#define Y second
#define vsort(v) sort((v).begin(), (v).end())
#define vrev(v) reverse((v).begin(), (v).end())
#define P pair
// stoi(s): string to int
// stod(s): string to double
// INT_MAX
// INT_MIN
// LLONG_MAX
// LLONG_MIN
// DBL_MIN
// DBL_MAX
// LDBL_MIN
// LDBL_MAX
// A-Z: 65~90
// a-z: 97~122
// |a-z| = 26
using namespace std;
using ll = long long;
int main(int argc, const char *argv[]) {
int n;
cin >> n;
vector<P<ll, int>> v(n);
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v[i].X = a + b;
v[i].Y = a;
}
vsort(v);
vrev(v);
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans += v[i].Y;
} else {
ans -= v[i].X - v[i].Y;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.change"
] | 941,582 | 941,583 | u493080913 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// https://qiita.com/Nasupl_r/items/35a903a4a69932c26c83
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
std::vector<int> vec(n);
int sumao = 0;
for (int i = 0; i < n; ++i) {
vec[i] = a[i] + b[i];
sumao += b[i];
}
std::sort(vec.begin(), vec.end(), std::greater<int>()); //降順ソート
int sumta = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
sumta += vec[i];
}
}
cout << sumta - sumao << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// https://qiita.com/Nasupl_r/items/35a903a4a69932c26c83
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
std::vector<int> vec(n);
long sumao = 0;
for (int i = 0; i < n; ++i) {
vec[i] = a[i] + b[i];
sumao += b[i];
}
std::sort(vec.begin(), vec.end(), std::greater<int>()); //降順ソート
long sumta = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
sumta += vec[i];
}
}
cout << sumta - sumao << endl;
return 0;
/*
int ta=0;
int ao=0;
for(int i=0;i<n;i++){
if(i % 2 == 0){
std::vector<int>::iterator iter = std::max_element(vec.begin(),
vec.end()); int index = std::distance(vec.begin(), iter); ta += a[index];
vec.erase(iter);
a.erase(a.begin() + index);
b.erase(b.begin() + index);
}else{
std::vector<int>::iterator iter = std::max_element(vec.begin(),
vec.end()); int index = std::distance(vec.begin(), iter); ao += b[index];
vec.erase(iter);
a.erase(a.begin() + index);
b.erase(b.begin() + index);
}
}
cout << ta - ao << endl;
return 0;
*/
} | [
"variable_declaration.type.primitive.change"
] | 941,584 | 941,585 | u097443428 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// https://qiita.com/Nasupl_r/items/35a903a4a69932c26c83
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
std::vector<int> vec(n);
int sumao = 0;
for (int i = 0; i < n; ++i) {
vec[i] = a[i] + b[i];
sumao += b[i];
}
std::sort(vec.begin(), vec.end(), std::greater<int>()); //降順ソート
int sumta = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
sumta += vec[i];
}
}
cout << sumta - sumao << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// https://qiita.com/Nasupl_r/items/35a903a4a69932c26c83
int n;
cin >> n;
long a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
std::vector<int> vec(n);
long sumao = 0;
for (int i = 0; i < n; ++i) {
vec[i] = a[i] + b[i];
sumao += b[i];
}
std::sort(vec.begin(), vec.end(), std::greater<int>()); //降順ソート
long sumta = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
sumta += vec[i];
}
}
cout << sumta - sumao << endl;
return 0;
/*
int ta=0;
int ao=0;
for(int i=0;i<n;i++){
if(i % 2 == 0){
std::vector<int>::iterator iter = std::max_element(vec.begin(),
vec.end()); int index = std::distance(vec.begin(), iter); ta += a[index];
vec.erase(iter);
a.erase(a.begin() + index);
b.erase(b.begin() + index);
}else{
std::vector<int>::iterator iter = std::max_element(vec.begin(),
vec.end()); int index = std::distance(vec.begin(), iter); ao += b[index];
vec.erase(iter);
a.erase(a.begin() + index);
b.erase(b.begin() + index);
}
}
cout << ta - ao << endl;
return 0;
*/
} | [
"variable_declaration.type.primitive.change"
] | 941,584 | 941,586 | u097443428 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
#define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DBG(fmt, ...)
#endif
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 100010
ll N;
vector<ll> A, B;
enum Player { Alice = 0, Bob = 1 };
signed main() {
cin >> N;
A.resize(N);
B.resize(N);
REP(i, N) { cin >> A[i] >> B[i]; }
vector<tuple<ll, ll, ll>> AB; // max, A, B
REP(i, N) { AB.push_back(make_tuple(max(A[i], B[i]), A[i], B[i])); }
sort(AB.begin(), AB.end(), greater<tuple<ll, ll, ll>>());
ll alice = 0; // takahashi
ll bob = 0;
ll player = Alice;
REP(i, N) {
// DBG("%lld %lld %lld\n", get<0>(AB[i]), get<1>(AB[i]), get<2>(AB[i]));
if (player == Alice) {
alice += get<1>(AB[i]);
// DBG("alice += %lld\n", get<1>(AB[i]));
player = Bob;
} else {
bob += get<2>(AB[i]);
// DBG("bob += %lld\n", get<2>(AB[i]));
player = Alice;
}
}
printf("%lld\n", alice - bob);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
#define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DBG(fmt, ...)
#endif
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 100010
ll N;
vector<ll> A, B;
enum Player { Alice = 0, Bob = 1 };
signed main() {
cin >> N;
A.resize(N);
B.resize(N);
REP(i, N) { cin >> A[i] >> B[i]; }
vector<tuple<ll, ll, ll>> AB; // max, A, B
REP(i, N) { AB.push_back(make_tuple(A[i] + B[i], A[i], B[i])); }
sort(AB.begin(), AB.end(), greater<tuple<ll, ll, ll>>());
ll alice = 0; // takahashi
ll bob = 0;
ll player = Alice;
REP(i, N) {
// DBG("%lld %lld %lld\n", get<0>(AB[i]), get<1>(AB[i]), get<2>(AB[i]));
if (player == Alice) {
alice += get<1>(AB[i]);
// DBG("alice += %lld\n", get<1>(AB[i]));
player = Bob;
} else {
bob += get<2>(AB[i]);
// DBG("bob += %lld\n", get<2>(AB[i]));
player = Alice;
}
}
printf("%lld\n", alice - bob);
return 0;
}
| [
"call.remove",
"call.arguments.change"
] | 941,589 | 941,590 | u633020228 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const int INF = 1e9 + 7;
int main() {
ll N;
cin >> N;
ll A[100010];
ll B[100010];
vector<ll> C(N);
vector<pair<ll, ll>> P(N);
for (int i = 0; i < N; ++i) {
cin >> A[i] >> B[i];
C[i] = A[i] - B[i];
P[i].first = C[i];
P[i].second = i;
}
sort(P.begin(), P.end(), greater<pair<ll, ll>>());
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
ans += A[P[i].second];
} else {
ans -= B[P[i].second];
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const int INF = 1e9 + 7;
int main() {
ll N;
cin >> N;
ll A[100010];
ll B[100010];
vector<ll> C(N);
vector<pair<ll, ll>> P(N);
for (int i = 0; i < N; ++i) {
cin >> A[i] >> B[i];
C[i] = A[i] + B[i];
P[i].first = C[i];
P[i].second = i;
}
sort(P.begin(), P.end(), greater<pair<ll, ll>>());
ll ans = 0;
for (int i = 0; i < N; ++i) {
if (i % 2 == 0) {
ans += A[P[i].second];
} else {
ans -= B[P[i].second];
}
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,591 | 941,592 | u406158207 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
// vector<pair<uint, uint>> d;
uint d[100000];
int main(int, char **) {
unsigned int n;
ll t = 0;
cin >> n;
// d.resize(n);
for (unsigned int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
d[i] = a + b;
t -= b;
}
sort(d, d + n);
for (unsigned int i = 0; i < n; i += 2) {
t += (ll)(d[i]);
}
cout << t << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
// vector<pair<uint, uint>> d;
ll d[100000];
int main(int, char **) {
unsigned int n;
ll t = 0;
cin >> n;
// d.resize(n);
for (unsigned int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
d[i] = -a - b;
t += b;
}
sort(d, d + n);
for (unsigned int i = 0; i < n; i += 2) {
t += (ll)(d[i]);
}
cout << -t << endl;
return 0;
} | [
"variable_declaration.type.change",
"expression.operation.unary.add",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"expression.operator.change"
] | 941,596 | 941,597 | u869644355 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
vector<pair<ll, ll>> d;
int main(int, char **) {
unsigned int n;
ll t = 0, s = 0;
cin >> n;
d.resize(n);
for (unsigned int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
d[i].first = a + b;
d[i].second = a;
}
sort(d.begin(), d.end(), greater<>());
for (unsigned int i = 0; i < n; i++) {
if (i % 2 == 0)
t += d[i].second;
else
s += d[i].first - d[i].second;
}
cout << t - s << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<pair<ll, ll>> d;
int main(int, char **) {
unsigned int n;
ll t = 0, s = 0;
cin >> n;
d.resize(n);
for (unsigned int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
d[i].first = a + b;
d[i].second = a;
}
sort(d.begin(), d.end(), greater<>());
for (unsigned int i = 0; i < n; i++) {
if (i % 2 == 0)
t += d[i].second;
else
s += d[i].first - d[i].second;
}
cout << t - s << endl;
return 0;
} | [
"variable_declaration.type.narrow.change"
] | 941,602 | 941,603 | u869644355 | cpp |
p03141 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define pb push_back
#define ALL(obj) (obj).begin(), (obj).end() //昇順
#define RALL(obj) (obj).rbegin(), (obj).rend() //降順
#define print(obj) cout << obj << endl
#define scan(obj) cin >> obj
typedef long long ll;
using namespace std;
int main(void) {
ll n, ans = 0;
cin >> n;
vector<pair<ll, ll>> plus(n);
ll a[n], b[n];
rep(i, n) {
cin >> a[i] >> b[i];
plus[i] = make_pair(a[i] + b[i], i);
}
sort(ALL(plus));
rep(i, n) {
if (i % 2 == 0) {
ans += a[plus[i].second];
} else {
ans -= b[plus[i].second];
}
}
print(ans);
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define pb push_back
#define ALL(obj) (obj).begin(), (obj).end() //昇順
#define RALL(obj) (obj).rbegin(), (obj).rend() //降順
#define print(obj) cout << obj << endl
#define scan(obj) cin >> obj
typedef long long ll;
using namespace std;
int main(void) {
ll n, ans = 0;
cin >> n;
vector<pair<ll, ll>> plus(n);
ll a[n], b[n];
rep(i, n) {
cin >> a[i] >> b[i];
plus[i] = make_pair(a[i] + b[i], i);
}
sort(RALL(plus));
rep(i, n) {
if (i % 2 == 0) {
ans += a[plus[i].second];
} else {
ans -= b[plus[i].second];
}
}
print(ans);
} | [
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 941,606 | 941,607 | u650565403 | cpp |
p03141 | #include <bits/stdc++.h>
#define INF (1 << 31) - 1 // INT_MAX/2
#define MOD 1000000007
#define PI acos(-1)
using ll = long long;
using ull = unsigned long long;
using P = std::pair<int, int>;
int main(int argc, char *argv[]) {
int N;
std::cin >> N;
std::vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
std::cin >> A[i] >> B[i];
}
std::vector<int> C(N);
for (int i = 0; i < N; i++) {
C[i] = A[i] + B[i];
}
std::sort(C.rbegin(), C.rend());
ll sum = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
sum += C[i];
}
sum -= B[i];
}
std::cout << sum / 2 << std::endl;
return 0;
}
| #include <bits/stdc++.h>
#define INF (1 << 31) - 1 // INT_MAX/2
#define MOD 1000000007
#define PI acos(-1)
using ll = long long;
using ull = unsigned long long;
using P = std::pair<int, int>;
int main(int argc, char *argv[]) {
int N;
std::cin >> N;
std::vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
std::cin >> A[i] >> B[i];
}
std::vector<int> C(N);
for (int i = 0; i < N; i++) {
C[i] = A[i] + B[i];
}
std::sort(C.rbegin(), C.rend());
ll sum = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
sum += C[i];
}
sum -= B[i];
}
std::cout << sum << std::endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 941,610 | 941,611 | u458798873 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
int N;
long long ans = 0;
cin >> N;
vector<long long> A(N), B(N), sum;
for (int i = 0; i < N; i++) {
cin >> A.at(i) >> B.at(i);
sum.push_back(A.at(i) + B.at(i));
ans -= B.at(i);
}
sort(sum.begin(), sum.end());
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ans += sum.at(i);
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
int N;
long long ans = 0;
cin >> N;
vector<long long> A(N), B(N), sum;
for (int i = 0; i < N; i++) {
cin >> A.at(i) >> B.at(i);
sum.push_back(A.at(i) + B.at(i));
ans -= B.at(i);
}
sort(sum.begin(), sum.end(), greater<>());
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ans += sum.at(i);
}
cout << ans;
} | [
"call.arguments.add"
] | 941,612 | 941,613 | u441250130 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n, x, y;
vector<pair<ll, ll>> v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back({x + y, x});
}
sort(v.begin(), v.end());
ll a = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
a += v[i].second;
else
a += v[i].second - v[i].first;
}
cout << a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n, x, y;
vector<pair<ll, ll>> v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back({x + y, x});
}
sort(v.rbegin(), v.rend());
ll a = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
a += v[i].second;
else
a += v[i].second - v[i].first;
}
cout << a << endl;
} | [
"call.function.change",
"call.arguments.change"
] | 941,614 | 941,615 | u673058289 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
struct Data {
long a;
long b;
long c;
};
bool cmp(const Data &a, const Data &b) { return a.c < b.c; }
int main() {
int N, ans = 0;
long temp;
cin >> N;
bool taka = true;
struct Data num[N];
for (int i = 0; i < N; i++) {
cin >> num[i].a >> num[i].b;
num[i].c = num[i].a + num[i].b;
}
sort(num, num + N, cmp);
for (int j = N - 1; j >= 0; j--) {
ans += taka ? num[j].a : -1 * num[j].b;
taka = !taka;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
using namespace std;
struct Data {
long a;
long b;
long c;
};
bool cmp(const Data &a, const Data &b) { return a.c < b.c; }
int main() {
int N;
long temp, ans = 0;
cin >> N;
bool taka = true;
struct Data num[N];
for (int i = 0; i < N; i++) {
cin >> num[i].a >> num[i].b;
num[i].c = num[i].a + num[i].b;
}
sort(num, num + N, cmp);
for (int j = N - 1; j >= 0; j--) {
ans += taka ? num[j].a : -1 * num[j].b;
taka = !taka;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.add",
"variable_declaration.remove"
] | 941,616 | 941,617 | u912533549 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define len(val) static_cast<long long>(val.size())
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int, int> P;
ll A[100005], B[100005];
pair<ll, pair<ll, ll>> x[100005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
x[i] = make_pair(max(A[i], B[i]), make_pair(A[i], B[i]));
}
sort(x, x + N);
reverse(x, x + N);
ll ta = 0;
ll ao = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ta += x[i].second.first;
else
ao += x[i].second.second;
}
// cout << ta << " " << ao << endl;
cout << ta - ao << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define len(val) static_cast<long long>(val.size())
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int, int> P;
ll A[100005], B[100005];
pair<ll, pair<ll, ll>> x[100005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
x[i] = make_pair(A[i] + B[i], make_pair(A[i], B[i]));
}
sort(x, x + N);
reverse(x, x + N);
ll ta = 0;
ll ao = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ta += x[i].second.first;
else
ao += x[i].second.second;
}
// cout << ta << " " << ao << endl;
cout << ta - ao << endl;
}
| [
"call.remove",
"assignment.value.change",
"call.arguments.change"
] | 941,618 | 941,619 | u295988383 | cpp |
p03141 | #include <iostream>
#include <queue>
using namespace std;
struct dish {
long long A;
long long B;
};
int main() {
// 整数の入力
long long N, K, i, a_i, b_i, sumA, sumB;
sumA = 0LL;
sumB = 0LL;
auto c = [](dish p1, dish p2) { return (p1.A + p1.B) > (p2.A + p2.B); };
priority_queue<dish, vector<dish>, decltype(c)> q1(c);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a_i >> b_i;
q1.push({a_i, b_i});
}
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
dish d = q1.top();
sumA += d.A;
q1.pop();
} else {
dish d = q1.top();
sumB += d.B;
q1.pop();
}
}
cout << sumA - sumB << endl;
return 0;
} | #include <iostream>
#include <queue>
using namespace std;
struct dish {
long long A;
long long B;
};
int main() {
// 整数の入力
long long N, K, i, a_i, b_i, sumA, sumB;
sumA = 0LL;
sumB = 0LL;
auto c = [](dish p1, dish p2) { return (p1.A + p1.B) < (p2.A + p2.B); };
priority_queue<dish, vector<dish>, decltype(c)> q1(c);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a_i >> b_i;
q1.push({a_i, b_i});
}
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
dish d = q1.top();
sumA += d.A;
q1.pop();
} else {
dish d = q1.top();
sumB += d.B;
q1.pop();
}
}
cout << sumA - sumB << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,622 | 941,623 | u902500155 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, b_sum = 0;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
b_sum += b[i];
}
sort(c, c + n);
reverse(c, c + n);
int score = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
score += c[i];
}
}
score -= b_sum;
cout << score << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long n, b_sum = 0;
cin >> n;
long a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] + b[i];
b_sum += b[i];
}
sort(c, c + n);
reverse(c, c + n);
long score = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
score += c[i];
}
}
score -= b_sum;
cout << score << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 941,624 | 941,625 | u875541682 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <vector>
using namespace std;
const long long INF = 1LL << 60; // どういう意味だろうか
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int N;
int A[100100] = {0};
int B[100100] = {0};
multimap<long long int, int> mp;
long long int taka_sum = 0, aoki_sum = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
mp.insert(pair<const long long int, int>((A[i] + B[i]), i));
}
long long int flg = 0;
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
if (flg % 2 == 0) {
taka_sum += A[itr->second];
} else {
aoki_sum += B[itr->second];
}
flg++;
}
cout << taka_sum - aoki_sum << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <vector>
using namespace std;
const long long INF = 1LL << 60; // どういう意味だろうか
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int N;
int A[100100] = {0};
int B[100100] = {0};
multimap<long long int, int> mp;
long long int taka_sum = 0, aoki_sum = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
mp.insert(pair<const long long int, int>((A[i] + B[i]) * (-1), i));
}
long long int flg = 0;
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
if (flg % 2 == 0) {
taka_sum += A[itr->second];
} else {
aoki_sum += B[itr->second];
}
flg++;
}
cout << taka_sum - aoki_sum << endl;
}
| [
"expression.operation.binary.add"
] | 941,626 | 941,627 | u635329504 | cpp |
p03141 | #include <algorithm>
#include <iostream>
using namespace std;
typedef pair<long long, int> P;
long long a[100010], b[100010];
P c[100010];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = P(a[i] + b[i], i);
}
sort(c, c + n);
long long takahashi = 0, aoki = 0;
for (int i = n - 1; i >= 0; i--) {
if (i % 2 == 0) {
takahashi += a[c[i].second];
} else {
aoki += b[c[i].second];
}
}
cout << takahashi - aoki << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
typedef pair<long long, int> P;
long long a[100010], b[100010];
P c[100010];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = P(a[i] + b[i], i);
}
sort(c, c + n);
long long takahashi = 0, aoki = 0;
for (int i = n - 1; i >= 0; i--) {
if ((n - 1 - i) % 2 == 0) {
takahashi += a[c[i].second];
} else {
aoki += b[c[i].second];
}
}
cout << takahashi - aoki << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,636 | 941,637 | u678503521 | cpp |
p03141 | /*input
6
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define RE(i, n) for (int i = 1; i <= n; i++)
#define RED(i, n) for (int i = n; i > 0; i--)
#define REPS(i, n) for (int i = 1; (i * i) <= n; i++)
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REPD(i, n) for (int i = n - 1; i >= 0; i--)
#define FORD(i, a, b) for (int i = a; i >= b; i--)
#define remax(a, b) a = max(a, b)
#define remin(a, b) a = min(a, b)
#define all(v) v.begin(), v.end()
#define pii pair<int, int>
#define mii map<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define WL(t) while (t--)
#define gcd(a, b) __gcd((a), (b))
#define lcm(a, b) ((a) * (b)) / gcd((a), (b))
#define print(arr) \
for (auto it = arr.begin(); it != arr.end(); ++it) \
cout << *it << " "; \
cout << endl;
#define debug(x) cout << x << endl;
#define debug2(x, y) cout << x << " " << y << endl;
#define debug3(x, y, z) cout << x << " " << y << " " << z << endl;
const int INF = 1e18 + 1;
const int MOD = 1e9 + 7;
const double PI = 3.14159265358979323846264338;
int fast_ex(int a, int n, int m) {
if (n == 0)
return 1;
if (n == 1)
return a;
int x = 1;
x *= fast_ex(a, n / 2, m);
x %= m;
x *= x;
x %= m;
if (n % 2)
x *= a;
x %= m;
return x;
}
int n;
int c[100001];
int a[100001];
int b[100001];
bool comp(int x, int y) { return a[x] + b[x] > a[y] + b[y]; }
void solve() {
cin >> n;
REP(i, n) {
cin >> a[i] >> b[i];
c[i] = i;
}
sort(c, c + n, comp);
int ans = 0;
REP(i, n) {
if (i % 2)
ans -= b[i];
else
ans += a[i];
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen(".in","r",stdin);freopen(".out","w",stdout);
int t = 1; // cin >> t;
WL(t) solve();
return 0;
} | /*input
6
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000
*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define RE(i, n) for (int i = 1; i <= n; i++)
#define RED(i, n) for (int i = n; i > 0; i--)
#define REPS(i, n) for (int i = 1; (i * i) <= n; i++)
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REPD(i, n) for (int i = n - 1; i >= 0; i--)
#define FORD(i, a, b) for (int i = a; i >= b; i--)
#define remax(a, b) a = max(a, b)
#define remin(a, b) a = min(a, b)
#define all(v) v.begin(), v.end()
#define pii pair<int, int>
#define mii map<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define WL(t) while (t--)
#define gcd(a, b) __gcd((a), (b))
#define lcm(a, b) ((a) * (b)) / gcd((a), (b))
#define print(arr) \
for (auto it = arr.begin(); it != arr.end(); ++it) \
cout << *it << " "; \
cout << endl;
#define debug(x) cout << x << endl;
#define debug2(x, y) cout << x << " " << y << endl;
#define debug3(x, y, z) cout << x << " " << y << " " << z << endl;
const int INF = 1e18 + 1;
const int MOD = 1e9 + 7;
const double PI = 3.14159265358979323846264338;
int fast_ex(int a, int n, int m) {
if (n == 0)
return 1;
if (n == 1)
return a;
int x = 1;
x *= fast_ex(a, n / 2, m);
x %= m;
x *= x;
x %= m;
if (n % 2)
x *= a;
x %= m;
return x;
}
int n;
int c[100001];
int a[100001];
int b[100001];
bool comp(int x, int y) { return a[x] + b[x] > a[y] + b[y]; }
void solve() {
cin >> n;
REP(i, n) {
cin >> a[i] >> b[i];
c[i] = i;
}
sort(c, c + n, comp);
int ans = 0;
REP(i, n) {
if (i % 2)
ans -= b[c[i]];
else
ans += a[c[i]];
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen(".in","r",stdin);freopen(".out","w",stdout);
int t = 1; // cin >> t;
WL(t) solve();
return 0;
} | [] | 941,642 | 941,643 | u799165954 | cpp |
p03141 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 100002;
long long ans, a[maxn], b[maxn];
int n;
bool mycmp(int i, int j) { return a[i] + b[i] > a[j] + b[j]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
vector<int> d;
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
d.push_back(i);
// d2.push_back(i);
}
sort(d.begin(), d.begin(), mycmp);
for (int i = 0; i < n; ++i) {
// printf("i:%d d[i]:%d\n", i,d[i]);
if (i & 1)
ans -= b[d[i]];
else
ans += a[d[i]];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 100002;
long long ans, a[maxn], b[maxn];
int n;
bool mycmp(int i, int j) { return a[i] + b[i] > a[j] + b[j]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
vector<int> d;
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
d.push_back(i);
}
sort(d.begin(), d.end(), mycmp);
for (int i = 0; i < n; ++i) {
// printf("i:%d d[i]:%d\n", i,d[i]);
if (i & 1)
ans -= b[d[i]];
else
ans += a[d[i]];
}
cout << ans << endl;
return 0;
} | [
"call.function.change",
"call.arguments.change"
] | 941,648 | 941,649 | u499373855 | cpp |
p03141 | #include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int n;
P p[100005];
ll a[100005], b[100005], c[100005];
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
c[i] = a[i] + b[i];
p[i] = P(c[i], a[i]);
}
sort(c, c + n);
ll ans = 0;
int l = 0, r = n;
int s = 0;
while (l < r) {
if (s == 0) {
ll pl = p[r - 1].second;
ans += pl;
r--;
} else {
ll pl = p[r - 1].first - p[r - 1].second;
ans -= pl;
r--;
}
s = 1 - s;
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int n;
P p[100005];
ll a[100005], b[100005], c[100005];
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
c[i] = a[i] + b[i];
p[i] = P(c[i], a[i]);
}
sort(p, p + n);
ll ans = 0;
int l = 0, r = n;
int s = 0;
while (l < r) {
// printf("%lld\n",ans);
if (s == 0) {
ll pl = p[r - 1].second;
ans += pl;
r--;
} else {
ll pl = p[r - 1].first - p[r - 1].second;
ans -= pl;
r--;
}
s = 1 - s;
}
printf("%lld\n", ans);
return 0;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 941,650 | 941,651 | u854869949 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A[100000], B[100000];
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i] >> B[i];
vector<int> order;
for (int i = 0; i < N; i++)
order.push_back(i);
sort(order.begin(), order.end(),
[&](int a, int b) { return A[a] + B[a] > A[b] + B[b]; });
int64_t ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
ans += A[i];
} else {
ans -= B[i];
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A[100000], B[100000];
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i] >> B[i];
vector<int> order;
for (int i = 0; i < N; i++)
order.push_back(i);
sort(order.begin(), order.end(),
[&](int a, int b) { return A[a] + B[a] > A[b] + B[b]; });
int64_t ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
ans += A[order[i]];
} else {
ans -= B[order[i]];
}
}
cout << ans << endl;
return 0;
} | [] | 941,652 | 941,653 | u314396879 | cpp |
p03141 | #include <algorithm>
#include <functional>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool cmp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.first - a.second > b.first - b.second;
}
int main(void) {
int N;
scanf("%d", &N);
vector<pair<long long, long long>> po;
for (int i = 0; i < N; i++) {
long long a, b;
scanf("%lld %lld", &a, &b);
po.push_back(make_pair(a, b));
}
sort(po.begin(), po.end(), cmp);
long long ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ans += po[i].first;
else
ans -= po[i].second;
}
printf("%lld", ans);
return 0;
}
| #include <algorithm>
#include <functional>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool cmp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.first + a.second > b.first + b.second;
}
int main(void) {
int N;
scanf("%d", &N);
vector<pair<long long, long long>> po;
for (int i = 0; i < N; i++) {
long long a, b;
scanf("%lld %lld", &a, &b);
po.push_back(make_pair(a, b));
}
sort(po.begin(), po.end(), cmp);
long long ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0)
ans += po[i].first;
else
ans -= po[i].second;
}
printf("%lld", ans);
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,656 | 941,657 | u601717680 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<pair<ll, ll>> vs;
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
vs.emplace_back(A + B, A);
}
sort(vs.begin(), vs.end());
ll res = 0, t = 1;
for (auto p : vs) {
res += t ? p.second : -(p.first - p.second);
t ^= 1;
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<pair<ll, ll>> vs;
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
vs.emplace_back(A + B, A);
}
sort(vs.rbegin(), vs.rend());
ll res = 0, t = 1;
for (auto p : vs) {
res += t ? p.second : -(p.first - p.second);
t ^= 1;
}
cout << res << endl;
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,658 | 941,659 | u752161277 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
int main() {
long N;
cin >> N;
vector<pair<long, long>> D(N);
for (auto &i : D)
cin >> i.first >> i.second;
sort(D.begin(), D.end(),
[](auto a, auto b) { return a.first + a.second < b.second + b.first; });
long long A(0), B(0), d(0);
for (auto i : D) {
if (!d)
A += i.first;
else
B += i.second;
d ^= 1;
}
cout << A - B << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long N;
cin >> N;
vector<pair<long, long>> D(N);
for (auto &i : D)
cin >> i.first >> i.second;
sort(D.rbegin(), D.rend(),
[](auto a, auto b) { return a.first + a.second < b.second + b.first; });
long long A(0), B(0), d(0);
for (auto i : D) {
if (!d)
A += i.first;
else
B += i.second;
d ^= 1;
}
cout << A - B << endl;
} | [
"call.function.change",
"call.arguments.change"
] | 941,660 | 941,661 | u462437857 | cpp |
p03141 | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
namespace {
using Integer = long long; //__int128;
template <class T, class S> istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &val : vec)
is >> val;
return is;
}
template <class T> istream &operator,(istream &is, T &val) { return is >> val; }
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i == vec.size() - 1 ? "" : " ");
return os;
}
template <class T> ostream &operator,(ostream &os, const T &val) {
return os << " " << val;
}
template <class H> void print(const H &head) { cout << head; }
template <class H, class... T> void print(const H &head, const T &...tail) {
cout << head << " ";
print(tail...);
}
template <class... T> void println(const T &...values) {
print(values...);
cout << endl;
}
template <class H> void eprint(const H &head) { cerr << head; }
template <class H, class... T> void eprint(const H &head, const T &...tail) {
cerr << head << " ";
eprint(tail...);
}
template <class... T> void eprintln(const T &...values) {
eprint(values...);
cerr << endl;
}
class range {
Integer start_, end_, step_;
public:
struct range_iterator {
Integer val, step_;
range_iterator(Integer v, Integer step) : val(v), step_(step) {}
Integer operator*() { return val; }
void operator++() { val += step_; }
bool operator!=(range_iterator &x) {
return step_ > 0 ? val < x.val : val > x.val;
}
};
range(Integer len) : start_(0), end_(len), step_(1) {}
range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
range(Integer start, Integer end, Integer step)
: start_(start), end_(end), step_(step) {}
range_iterator begin() { return range_iterator(start_, step_); }
range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char *str, size_t size) {
return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
return k == 0 ? z
: k == 1 ? z * x
: (k & 1) ? my_pow(x * x, k >> 1, z * x)
: my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
return k == 0 ? z % M
: k == 1 ? z * x % M
: (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
: my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; } // 0-indexed
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count());
template <class T> string join(const vector<T> &v, const string &sep) {
stringstream ss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0)
ss << sep;
ss << v[i];
}
return ss.str();
}
inline string operator*(string s, int k) {
string ret;
while (k) {
if (k & 1)
ret += s;
s += s;
k >>= 1;
}
return ret;
}
} // namespace
constexpr long long mod = 9_ten + 7;
int main() {
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] = {a[i] + b[i], i};
}
sort(c.begin(), c.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans += a[c[i].second];
} else {
ans -= b[c[i].second];
}
}
println(ans);
return 0;
}
| #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
namespace {
using Integer = long long; //__int128;
template <class T, class S> istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &val : vec)
is >> val;
return is;
}
template <class T> istream &operator,(istream &is, T &val) { return is >> val; }
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i == vec.size() - 1 ? "" : " ");
return os;
}
template <class T> ostream &operator,(ostream &os, const T &val) {
return os << " " << val;
}
template <class H> void print(const H &head) { cout << head; }
template <class H, class... T> void print(const H &head, const T &...tail) {
cout << head << " ";
print(tail...);
}
template <class... T> void println(const T &...values) {
print(values...);
cout << endl;
}
template <class H> void eprint(const H &head) { cerr << head; }
template <class H, class... T> void eprint(const H &head, const T &...tail) {
cerr << head << " ";
eprint(tail...);
}
template <class... T> void eprintln(const T &...values) {
eprint(values...);
cerr << endl;
}
class range {
Integer start_, end_, step_;
public:
struct range_iterator {
Integer val, step_;
range_iterator(Integer v, Integer step) : val(v), step_(step) {}
Integer operator*() { return val; }
void operator++() { val += step_; }
bool operator!=(range_iterator &x) {
return step_ > 0 ? val < x.val : val > x.val;
}
};
range(Integer len) : start_(0), end_(len), step_(1) {}
range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
range(Integer start, Integer end, Integer step)
: start_(start), end_(end), step_(step) {}
range_iterator begin() { return range_iterator(start_, step_); }
range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char *str, size_t size) {
return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
return k == 0 ? z
: k == 1 ? z * x
: (k & 1) ? my_pow(x * x, k >> 1, z * x)
: my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
return k == 0 ? z % M
: k == 1 ? z * x % M
: (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
: my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; } // 0-indexed
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count());
template <class T> string join(const vector<T> &v, const string &sep) {
stringstream ss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0)
ss << sep;
ss << v[i];
}
return ss.str();
}
inline string operator*(string s, int k) {
string ret;
while (k) {
if (k & 1)
ret += s;
s += s;
k >>= 1;
}
return ret;
}
} // namespace
constexpr long long mod = 9_ten + 7;
int main() {
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] = {a[i] + b[i], i};
}
sort(c.rbegin(), c.rend());
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans += a[c[i].second];
} else {
ans -= b[c[i].second];
}
}
println(ans);
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,662 | 941,663 | u075551644 | cpp |
p03141 | #include <bits/stdc++.h>
#define show(x) std::cerr << #x << " = " << (x) << std::endl
using ll = long long;
template <typename T> constexpr T MOD = static_cast<T>(1000000007);
template <typename T> constexpr T INF = std::numeric_limits<T>::max() / 16;
int main() {
int N;
std::cin >> N;
using P = std::pair<ll, ll>;
std::vector<P> A(N);
for (int i = 0; i < N; i++) {
std::cin >> A[i].first >> A[i].second;
}
std::sort(A.begin(), A.end(), [](const P &p1, const P &p2) {
return p1.first + p1.second > p2.first * p2.second;
});
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += (i % 2 == 0 ? A[i].first : -A[i].second);
}
std::cout << ans << std::endl;
return 0;
} | #include <bits/stdc++.h>
#define show(x) std::cerr << #x << " = " << (x) << std::endl
using ll = long long;
template <typename T> constexpr T MOD = static_cast<T>(1000000007);
template <typename T> constexpr T INF = std::numeric_limits<T>::max() / 16;
int main() {
int N;
std::cin >> N;
using P = std::pair<ll, ll>;
std::vector<P> A(N);
for (int i = 0; i < N; i++) {
std::cin >> A[i].first >> A[i].second;
}
std::sort(A.begin(), A.end(), [](const P &p1, const P &p2) {
return p1.first + p1.second > p2.first + p2.second;
});
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += (i % 2 == 0 ? A[i].first : -A[i].second);
}
std::cout << ans << std::endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,664 | 941,665 | u603303736 | cpp |
p03141 | #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;
int main() {
int n;
cin >> n;
ll a[n], b[n];
ll ans = 0;
rep(i, n) {
cin >> a[i] >> b[i];
ans += a[i];
}
vector<int> ord(n);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(),
[&](int x, int y) { return a[x] + b[x] > a[y] + b[y]; });
rep(i, n) {
if (i % 2) {
ans -= a[i] + b[i];
}
}
cout << ans << 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;
int main() {
int n;
cin >> n;
ll a[n], b[n];
ll ans = 0;
rep(i, n) {
cin >> a[i] >> b[i];
ans += a[i];
}
vector<int> ord(n);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(),
[&](int x, int y) { return a[x] + b[x] > a[y] + b[y]; });
rep(i, n) {
if (i % 2) {
ans -= a[ord[i]] + b[ord[i]];
}
}
cout << ans << endl;
return 0;
} | [] | 941,666 | 941,667 | u352642493 | cpp |
p03141 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define int long long
int MOD = 1000000007;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N);
vector<int> B(N);
int res = 0;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> vp;
for (int i = 0; i < N; i++) {
vp.emplace_back(A[i] + B[i], i);
}
sort(vp.begin(), vp.end());
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
res += A[vp[i].second];
} else {
res -= B[vp[i].second];
}
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define int long long
int MOD = 1000000007;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N);
vector<int> B(N);
int res = 0;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> vp;
for (int i = 0; i < N; i++) {
vp.emplace_back(A[i] + B[i], i);
}
sort(vp.rbegin(), vp.rend());
for (int i = 0; i < N; i++) {
if (i % 2 == 0) {
res += A[vp[i].second];
} else {
res -= B[vp[i].second];
}
}
cout << res << endl;
} | [
"call.function.change",
"call.arguments.change"
] | 941,668 | 941,669 | u864888234 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
#define mod (long)(1e9 + 7)
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl(long(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> inline void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
template <class T> inline void First(T condition) {
if (condition)
cout << "First" << endl;
else
cout << "Second" << endl;
}
template <class T = string, class U = char>
int character_count(T text, U character) {
int ans = 0;
for (U i : text) {
ans += (i == character);
}
return ans;
}
long power(long base, long exponent, long module) {
if (exponent % 2) {
return power(base, exponent - 1, module) * base % module;
} else if (exponent) {
long root_ans = power(base, exponent / 2, module);
return root_ans * root_ans % module;
} else {
return 1;
}
}
struct position {
int y, x;
};
position mv[4] = {
{-1, 0},
{0, 1},
{1, 0},
{0, -1}}; // double euclidean(position first, position second){ return
// sqrt((second.x - first.x) * (second.x - first.x) + (second.y -
// first.y) * (second.y - first.y)); }
template <class T, class U> string to_string(pair<T, U> x) {
return to_string(x.first) + "," + to_string(x.second);
}
template <class itr> void array_output(itr start, itr goal) {
string ans;
for (auto i = start; i != goal; i++) {
ans += to_string(*i) + " ";
}
ans.pop_back();
cout << ans << endl;
}
template <class itr> void cins(itr start, itr goal) {
for (auto i = start; i != goal; i++) {
cin >> (*i);
}
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct combination {
vector<long> fact, inv;
combination(int sz) : fact(sz + 1), inv(sz + 1) {
fact[0] = 1;
for (int i = 1; i <= sz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[sz] = power(fact[sz], mod - 2, mod);
for (int i = sz - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
long C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return (fact[p] * inv[q] % mod * inv[p - q] % mod);
}
};
int main() {
int N;
cin >> N;
pair<long, long> dish[N];
for (int i = 0; i < N; i++) {
long A, B;
cin >> A >> B;
dish[i].first = A + B;
dish[i].second = A;
}
sort(dish, dish + N);
long ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2) {
ans -= dish[i].first - dish[i].second;
} else {
ans += dish[i].second;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
#define mod (long)(1e9 + 7)
#define all(x) (x).begin(), (x).end()
#define bitcount(n) __builtin_popcountl(long(n))
#define fcout cout << fixed << setprecision(15)
#define highest(x) (63 - __builtin_clzl(x))
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> inline void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
template <class T> inline void First(T condition) {
if (condition)
cout << "First" << endl;
else
cout << "Second" << endl;
}
template <class T = string, class U = char>
int character_count(T text, U character) {
int ans = 0;
for (U i : text) {
ans += (i == character);
}
return ans;
}
long power(long base, long exponent, long module) {
if (exponent % 2) {
return power(base, exponent - 1, module) * base % module;
} else if (exponent) {
long root_ans = power(base, exponent / 2, module);
return root_ans * root_ans % module;
} else {
return 1;
}
}
struct position {
int y, x;
};
position mv[4] = {
{-1, 0},
{0, 1},
{1, 0},
{0, -1}}; // double euclidean(position first, position second){ return
// sqrt((second.x - first.x) * (second.x - first.x) + (second.y -
// first.y) * (second.y - first.y)); }
template <class T, class U> string to_string(pair<T, U> x) {
return to_string(x.first) + "," + to_string(x.second);
}
template <class itr> void array_output(itr start, itr goal) {
string ans;
for (auto i = start; i != goal; i++) {
ans += to_string(*i) + " ";
}
ans.pop_back();
cout << ans << endl;
}
template <class itr> void cins(itr start, itr goal) {
for (auto i = start; i != goal; i++) {
cin >> (*i);
}
}
template <class T> T gcd(T a, T b) {
if (a && b) {
return gcd(min(a, b), max(a, b) % min(a, b));
} else {
return a;
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct combination {
vector<long> fact, inv;
combination(int sz) : fact(sz + 1), inv(sz + 1) {
fact[0] = 1;
for (int i = 1; i <= sz; i++) {
fact[i] = fact[i - 1] * i % mod;
}
inv[sz] = power(fact[sz], mod - 2, mod);
for (int i = sz - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
long C(int p, int q) const {
if (q < 0 || p < q)
return 0;
return (fact[p] * inv[q] % mod * inv[p - q] % mod);
}
};
int main() {
int N;
cin >> N;
pair<long, long> dish[N];
for (int i = 0; i < N; i++) {
long A, B;
cin >> A >> B;
dish[i].first = A + B;
dish[i].second = A;
}
sort(dish, dish + N, greater<>());
long ans = 0;
for (int i = 0; i < N; i++) {
if (i % 2) {
ans -= dish[i].first - dish[i].second;
} else {
ans += dish[i].second;
}
}
cout << ans << endl;
}
| [
"call.arguments.add"
] | 941,670 | 941,671 | u115888500 | cpp |
p03141 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
P p[200000];
int main() {
int n;
scanf("%d", &n);
rep(i, n) { scanf("%d%d", &p[i].first, &p[i].second); }
sort(p, p + n,
[](P a, P b) { return a.first + a.second < b.first + b.second; });
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += p[i].first;
else
ans -= p[i].second;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
P p[200000];
int main() {
int n;
scanf("%d", &n);
rep(i, n) { scanf("%d%d", &p[i].first, &p[i].second); }
sort(p, p + n,
[](P a, P b) { return a.first + a.second > b.first + b.second; });
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += p[i].first;
else
ans -= p[i].second;
}
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,672 | 941,673 | u781091740 | cpp |
p03142 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << " ";
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class... Ts> void DEBUG(T d, Ts... e) {
if (DEBUG_OUT == false)
return;
DEBUG(d);
DEBUG(e...);
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
abort();
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// SOLVE
int take[1 << 20], at[1 << 20], dm[1 << 20];
void solve(void) {
int N, M;
cin >> N >> M;
vector<vector<int>> GRAPH(N + 1);
vector<int> in(N + 1, 0);
vector<int> pi(N + 1, 0);
for (int i = 0; i < N - 1 + M; i++) {
int A, B;
cin >> A >> B;
GRAPH[A].push_back(B);
in[B]++;
}
queue<int> q;
for (int i = 1; i <= N; i++) {
if (in[i] == 0)
q.push(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &&i : GRAPH[u]) {
if (--in[i] == 0) {
pi[i] = u;
}
q.push(i);
}
}
for (int i = 1; i <= N; i++) {
cout << pi[i] << endl;
}
{ /* code */ }
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << " ";
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class... Ts> void DEBUG(T d, Ts... e) {
if (DEBUG_OUT == false)
return;
DEBUG(d);
DEBUG(e...);
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
abort();
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// SOLVE
int take[1 << 20], at[1 << 20], dm[1 << 20];
void solve(void) {
int N, M;
cin >> N >> M;
vector<vector<int>> GRAPH(N + 1);
vector<int> in(N + 1, 0);
vector<int> pi(N + 1, 0);
for (int i = 0; i < N - 1 + M; i++) {
int A, B;
cin >> A >> B;
GRAPH[A].push_back(B);
in[B]++;
}
queue<int> q;
for (int i = 1; i <= N; i++) {
if (in[i] == 0)
q.push(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &&i : GRAPH[u]) {
if (--in[i] == 0) {
pi[i] = u;
q.push(i);
}
}
}
for (int i = 1; i <= N; i++) {
cout << pi[i] << endl;
}
{ /* code */ }
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
}
| [] | 941,680 | 941,681 | u221285045 | cpp |
p03142 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
void md(int index, vector<vector<int>> &child, vector<int> &height,
vector<int> &r) {
for (int i = 0; i < child[index].size(); i++) {
r[child[index][i]]--;
if (height[child[index][i]] < height[index] + 1) {
height[child[index][i]] = height[index] + 1;
if (r[child[index][i]] == 0)
md(child[index][i], child, height, r);
}
}
}
int main(void) {
int N, M;
cin >> N >> M;
int E = N - 1 + M;
vector<vector<int>> child(E, vector<int>(0));
vector<bool> isroot(E, true);
vector<int> r(N, 0);
for (int i = 0; i < E; i++) {
int A, B;
cin >> A >> B;
A--;
B--;
child[A].push_back(B);
isroot[B] = false;
r[B]++;
}
int root;
for (root = 0; root < N; root++)
if (isroot[root])
break;
vector<int> height(N, -1);
height[root] = 0;
md(root, child, height, r);
for (int i = 0; i < N; i++) {
for (int j = 0; j < child[i].size(); j++) {
if (height[child[i][j]] > height[i] + 1) {
child[i][j] = -1;
}
}
}
vector<int> parent(N, -1);
for (int i = 0; i < N; i++) {
for (int j = 0; j < child[i].size(); j++) {
if (child[i][j] != -1) {
parent[child[i][j]] = i;
}
}
}
for (int i = 0; i < N; i++)
cout << parent[i] + 1 << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
void md(int index, vector<vector<int>> &child, vector<int> &height,
vector<int> &r) {
for (int i = 0; i < child[index].size(); i++) {
r[child[index][i]]--;
if (height[child[index][i]] < height[index] + 1) {
height[child[index][i]] = height[index] + 1;
}
if (r[child[index][i]] == 0)
md(child[index][i], child, height, r);
}
}
int main(void) {
int N, M;
cin >> N >> M;
int E = N - 1 + M;
vector<vector<int>> child(E, vector<int>(0));
vector<bool> isroot(E, true);
vector<int> r(N, 0);
for (int i = 0; i < E; i++) {
int A, B;
cin >> A >> B;
A--;
B--;
child[A].push_back(B);
isroot[B] = false;
r[B]++;
}
int root;
for (root = 0; root < N; root++)
if (isroot[root])
break;
vector<int> height(N, -1);
height[root] = 0;
md(root, child, height, r);
for (int i = 0; i < N; i++) {
for (int j = 0; j < child[i].size(); j++) {
if (height[child[i][j]] > height[i] + 1) {
child[i][j] = -1;
}
}
}
vector<int> parent(N, -1);
for (int i = 0; i < N; i++) {
for (int j = 0; j < child[i].size(); j++) {
if (child[i][j] != -1) {
parent[child[i][j]] = i;
}
}
}
for (int i = 0; i < N; i++)
cout << parent[i] + 1 << endl;
return 0;
} | [] | 941,694 | 941,695 | u898331860 | cpp |
p03142 | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb emplace_back
#define mp make_pair
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
constexpr int mod = 1e9 + 7;
constexpr int32_t inf = 1001001001;
constexpr int64_t infll = 1001001001001001001ll;
constexpr int dx[] = {0, -1, 1, 0, -1, 1, -1, 1},
dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};
const string YES = "YES", NO = "NO", Yes = "Yes", No = "No", yes = "yes",
no = "no";
// clang-format off
// ostream &operator<<(ostream &os, __int128_t value) { if (ostream::sentry(os)) { __uint128_t tmp = value < 0 ? -value : value; char buffer[64]; char *d = end(buffer); do { --d; *d = "0123456789"[tmp % 10]; tmp /= 10; } while (tmp != 0); if (value < 0) { --d; *d = '-'; } int len = end(buffer) - d; if (os.rdbuf()->sputn(d, len) != len) { os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __int128_t &value) { string in; is >> in; value = 0; for (const char &c : in) { if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } if (in[0] == '-') value *= -1; return is; }
// ostream &operator<<(ostream &os, __uint128_t value) { if (ostream::sentry(os)) { char buffer[64]; char *d = end(buffer); do { --d; *d = "0123456789"[value % 10]; value /= 10; } while (value != 0); int len = end(buffer) - d; if (os.rdbuf()->sputn(d, len) != len) { os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __uint128_t &value) { string in; is >> in; value = 0; for (const char &c : in) { if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } return is; }
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { os << v[0]; for (int i = 1; i < v.size(); ++i) os << " " << v[i]; return os; }
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << p.fs << " " << p.sc; return os; }
template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.fs >> p.sc; return is; }
struct IoSetup { IoSetup(){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(10); cerr << fixed << setprecision(10); } } iosetup;
inline int64_t in() { int64_t x = 0; cin >> x; return x; }
template <typename T> void sort(vector<T> &v) { sort(all(v)); }
template <typename T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template <typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v(ts...))>(a, make_v(ts...)); }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
// clang-format on
signed main(int argc, char *argv[]) {
int n = in(), m = in();
vector<int> deg(n, 0), w(n, 0);
vector<vector<int>> G(n);
vector<int> a(n + m), b(n + m);
vector<int> ans(n), dep(n, -1);
for (int i = 0; i < n - 1 + m; ++i) {
a[i] = in() - 1;
b[i] = in() - 1;
G[a[i]].pb(b[i]);
deg[b[i]]++;
}
int p = -1;
for (int i = 0; i < n; ++i) {
if (deg[i] == 0)
p = i;
}
int cnt = 0;
vector<int> ts(n, -1);
stack<int> st;
st.push(p);
while (!st.empty()) {
int u = st.top();
st.pop();
ts[u] = cnt++;
for (auto &to : G[u]) {
deg[to]--;
if (deg[to] == 0)
st.push(to);
}
}
for (int i = 0; i < n - 1 + m; ++i) {
if (chmax(dep[i], ts[a[i]])) {
ans[b[i]] = a[i] + 1;
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb emplace_back
#define mp make_pair
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
constexpr int mod = 1e9 + 7;
constexpr int32_t inf = 1001001001;
constexpr int64_t infll = 1001001001001001001ll;
constexpr int dx[] = {0, -1, 1, 0, -1, 1, -1, 1},
dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};
const string YES = "YES", NO = "NO", Yes = "Yes", No = "No", yes = "yes",
no = "no";
// clang-format off
// ostream &operator<<(ostream &os, __int128_t value) { if (ostream::sentry(os)) { __uint128_t tmp = value < 0 ? -value : value; char buffer[64]; char *d = end(buffer); do { --d; *d = "0123456789"[tmp % 10]; tmp /= 10; } while (tmp != 0); if (value < 0) { --d; *d = '-'; } int len = end(buffer) - d; if (os.rdbuf()->sputn(d, len) != len) { os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __int128_t &value) { string in; is >> in; value = 0; for (const char &c : in) { if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } if (in[0] == '-') value *= -1; return is; }
// ostream &operator<<(ostream &os, __uint128_t value) { if (ostream::sentry(os)) { char buffer[64]; char *d = end(buffer); do { --d; *d = "0123456789"[value % 10]; value /= 10; } while (value != 0); int len = end(buffer) - d; if (os.rdbuf()->sputn(d, len) != len) { os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __uint128_t &value) { string in; is >> in; value = 0; for (const char &c : in) { if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } return is; }
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { os << v[0]; for (int i = 1; i < v.size(); ++i) os << " " << v[i]; return os; }
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << p.fs << " " << p.sc; return os; }
template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.fs >> p.sc; return is; }
struct IoSetup { IoSetup(){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(10); cerr << fixed << setprecision(10); } } iosetup;
inline int64_t in() { int64_t x = 0; cin >> x; return x; }
template <typename T> void sort(vector<T> &v) { sort(all(v)); }
template <typename T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template <typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v(ts...))>(a, make_v(ts...)); }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
// clang-format on
signed main(int argc, char *argv[]) {
int n = in(), m = in();
vector<int> deg(n, 0), w(n, 0);
vector<vector<int>> G(n);
vector<int> a(n + m), b(n + m);
vector<int> ans(n), dep(n, -1);
for (int i = 0; i < n - 1 + m; ++i) {
a[i] = in() - 1;
b[i] = in() - 1;
G[a[i]].pb(b[i]);
deg[b[i]]++;
}
int p = -1;
for (int i = 0; i < n; ++i) {
if (deg[i] == 0)
p = i;
}
int cnt = 0;
vector<int> ts(n, -1);
stack<int> st;
st.push(p);
while (!st.empty()) {
int u = st.top();
st.pop();
ts[u] = cnt++;
for (auto &to : G[u]) {
deg[to]--;
if (deg[to] == 0)
st.push(to);
}
}
for (int i = 0; i < n - 1 + m; ++i) {
if (chmax(dep[b[i]], ts[a[i]])) {
ans[b[i]] = a[i] + 1;
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << endl;
}
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,702 | 941,703 | u802071009 | cpp |
p03142 | /// Kazuki Hoshino
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
#define inf 1000000000
#define mod 1000000007
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define rep1(i, a, b) for (int i = a; i >= b; i--)
#define dmp(x) cerr << "line " << __LINE__ << " " << #x << ":" << x << endl
#define fs first
#define sc second
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define mt make_tuple
//#define endl '\n'
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
int n, pos[202020], m; // number of vertices
vector<vector<int>> adj; // adjacency list of graph
vector<bool> visited;
vector<int> ans;
vi p[202020];
int indeg[202020], outdeg[202020];
void dfs(int v) {
visited[v] = true;
for (int u : adj[v]) {
if (!visited[u])
dfs(u);
}
ans.push_back(v);
}
void topological_sort(int s) {
visited.assign(n + 100, false);
ans.clear();
dfs(s);
for (int i = 1; i <= n; ++i) {
if (!visited[i])
dfs(i);
}
reverse(ans.begin(), ans.end());
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
cin >> n >> m;
adj.resize(3 * n);
for (int i = 1; i < n + m; i++) {
int x, y;
cin >> x >> y;
indeg[y]++;
outdeg[x]++;
p[y].pb(x);
adj[x].pb(y);
}
int root = 1;
for (int i = 1; i <= n; i++) {
if (indeg[i] == 0)
root = i;
}
topological_sort(root);
for (int i = 0; i < n; i++) {
pos[ans[i]] = i + 1;
}
for (int i = 1; i <= n; i++) {
int cur = 0;
for (auto t : p[i]) {
if (pos[t] > cur) {
cur = t;
}
}
cout << cur << endl;
}
return 0;
}
///....
| /// Kazuki Hoshino
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
#define inf 1000000000
#define mod 1000000007
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define rep1(i, a, b) for (int i = a; i >= b; i--)
#define dmp(x) cerr << "line " << __LINE__ << " " << #x << ":" << x << endl
#define fs first
#define sc second
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define mt make_tuple
//#define endl '\n'
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
int n, pos[202020], m; // number of vertices
vector<vector<int>> adj; // adjacency list of graph
vector<bool> visited;
vector<int> ans;
vi p[202020];
int indeg[202020], outdeg[202020];
void dfs(int v) {
visited[v] = true;
for (int u : adj[v]) {
if (!visited[u])
dfs(u);
}
ans.push_back(v);
}
void topological_sort(int s) {
visited.assign(n + 100, false);
ans.clear();
dfs(s);
for (int i = 1; i <= n; ++i) {
if (!visited[i])
dfs(i);
}
reverse(ans.begin(), ans.end());
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
cin >> n >> m;
adj.resize(3 * n);
for (int i = 1; i < n + m; i++) {
int x, y;
cin >> x >> y;
indeg[y]++;
outdeg[x]++;
p[y].pb(x);
adj[x].pb(y);
}
int root = 1;
for (int i = 1; i <= n; i++) {
if (indeg[i] == 0)
root = i;
}
topological_sort(root);
for (int i = 0; i < n; i++) {
pos[ans[i]] = i + 1;
}
for (int i = 1; i <= n; i++) {
int cur = 0;
for (auto t : p[i]) {
if (pos[t] > pos[cur]) {
cur = t;
}
}
cout << cur << endl;
}
return 0;
}
///....
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 941,708 | 941,709 | u284140331 | cpp |
p03142 | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#include <string>
#include <vector>
#define sqr(x) (x) * (x)
#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
typedef unsigned int u32;
typedef int i32;
typedef unsigned long long int u64;
typedef long long int i64;
typedef uint16_t u16;
typedef int16_t i16;
typedef uint8_t u8;
typedef int8_t i8;
using namespace std;
using namespace std::chrono;
struct less_key {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.first > p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
struct less_key2 {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.second > p2.second ||
(p1.second == p2.second && p1.first > p2.first);
}
};
//
// struct pair_hash
//{
// std::size_t operator()(const i64& k) const
// {
// return static_cast<size_t>(k.first ^ k.second);
// }
//};
#include <random>
const i64 mod = 1000000007ll;
const i64 mod2 = 998244353ll;
const i64 inf = 10000000000000007ll;
const double eps = 1e-10;
template <typename T = i64, T D = 0> class MaxOp {
public:
static T op(const T &a, const T &b) { return max(a, b); }
static T def() { return (T)D; }
};
template <typename T = i64, T D = inf> class MinOp {
public:
static T op(const T &a, const T &b) { return min(a, b); }
static T def() { return (T)D; }
};
template <typename T = i64, T D = 0> class SumOp {
public:
static T op(const T &a, const T &b) { return a + b; }
static T def() { return (T)D; }
};
template <typename D, typename T = i64> class SegTree {
public:
i64 n;
vector<T> t;
private:
void build(const i64 *a, int v, int tl, int tr) {
if (tl == tr)
t[v] = a[tl];
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = D().op(t[v * 2], t[v * 2 + 1]);
}
}
i64 get(int v, int tl, int tr, int l, int r) {
if (l > r) {
return D().def();
}
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
return D().op(get(v * 2, tl, tm, l, min(r, tm)),
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void update(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr) {
t[v] = new_val;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm) {
update(v * 2, tl, tm, pos, new_val);
} else {
update(v * 2 + 1, tm + 1, tr, pos, new_val);
}
t[v] = D().op(t[v * 2] + t[v * 2 + 1]);
}
}
public:
void build(const vector<i64> &a) {
n = a.size();
t.resize(n * 4);
build(a.data(), 1, 0, n - 1);
}
void build(i64 *a, i64 n) {
this->n = n;
t.resize(n * 4);
build(a, 1, 0, n - 1);
}
i64 get(i64 l, i64 r) { return get(1, 0, n - 1, l, r); }
void update(i64 pos, i64 new_val) { update(1, 0, n - 1, pos, new_val); }
};
// dsu
i64 parent[100005];
void make_set(i64 v) { parent[v] = v; }
i64 find_set(i64 v) {
if (v == parent[v])
return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(i64 a, i64 b) {
a = find_set(a);
b = find_set(b);
if (a != b)
parent[b] = a;
}
// del
i64 n, m;
const i64 MAXN = 100005;
vector<i64> e[MAXN];
bool re[MAXN];
bool v[MAXN];
i64 R[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> m;
for (i64 i = 0; i < n - 1 + m; i++) {
i64 u, w;
cin >> u >> w;
e[u].push_back(w);
re[w] = 1;
}
i64 r = -1;
for (i64 i = 0; i < n; i++) {
if (!re[i]) {
r = i;
}
}
queue<i64> q;
q.push(r);
v[r] = 1;
for (;;) {
if (q.empty()) {
break;
}
i64 c = q.front();
q.pop();
for (auto w : e[c]) {
v[w]++;
if (v[w] == re[w]) {
q.push(w);
R[w] = c;
}
}
}
for (i64 i = 1; i <= n; i++) {
cout << R[i] << endl;
}
return 0;
} | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#include <string>
#include <vector>
#define sqr(x) (x) * (x)
#include <algorithm>
#include <functional>
#include <bitset>
#include <functional>
#include <chrono>
typedef unsigned int u32;
typedef int i32;
typedef unsigned long long int u64;
typedef long long int i64;
typedef uint16_t u16;
typedef int16_t i16;
typedef uint8_t u8;
typedef int8_t i8;
using namespace std;
using namespace std::chrono;
struct less_key {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.first > p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
struct less_key2 {
bool operator()(pair<i64, i64> p1, pair<i64, i64> p2) {
return p1.second > p2.second ||
(p1.second == p2.second && p1.first > p2.first);
}
};
//
// struct pair_hash
//{
// std::size_t operator()(const i64& k) const
// {
// return static_cast<size_t>(k.first ^ k.second);
// }
//};
#include <random>
const i64 mod = 1000000007ll;
const i64 mod2 = 998244353ll;
const i64 inf = 10000000000000007ll;
const double eps = 1e-10;
template <typename T = i64, T D = 0> class MaxOp {
public:
static T op(const T &a, const T &b) { return max(a, b); }
static T def() { return (T)D; }
};
template <typename T = i64, T D = inf> class MinOp {
public:
static T op(const T &a, const T &b) { return min(a, b); }
static T def() { return (T)D; }
};
template <typename T = i64, T D = 0> class SumOp {
public:
static T op(const T &a, const T &b) { return a + b; }
static T def() { return (T)D; }
};
template <typename D, typename T = i64> class SegTree {
public:
i64 n;
vector<T> t;
private:
void build(const i64 *a, int v, int tl, int tr) {
if (tl == tr)
t[v] = a[tl];
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = D().op(t[v * 2], t[v * 2 + 1]);
}
}
i64 get(int v, int tl, int tr, int l, int r) {
if (l > r) {
return D().def();
}
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
return D().op(get(v * 2, tl, tm, l, min(r, tm)),
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void update(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr) {
t[v] = new_val;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm) {
update(v * 2, tl, tm, pos, new_val);
} else {
update(v * 2 + 1, tm + 1, tr, pos, new_val);
}
t[v] = D().op(t[v * 2] + t[v * 2 + 1]);
}
}
public:
void build(const vector<i64> &a) {
n = a.size();
t.resize(n * 4);
build(a.data(), 1, 0, n - 1);
}
void build(i64 *a, i64 n) {
this->n = n;
t.resize(n * 4);
build(a, 1, 0, n - 1);
}
i64 get(i64 l, i64 r) { return get(1, 0, n - 1, l, r); }
void update(i64 pos, i64 new_val) { update(1, 0, n - 1, pos, new_val); }
};
// dsu
i64 parent[100005];
void make_set(i64 v) { parent[v] = v; }
i64 find_set(i64 v) {
if (v == parent[v])
return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(i64 a, i64 b) {
a = find_set(a);
b = find_set(b);
if (a != b)
parent[b] = a;
}
// del
i64 n, m;
const i64 MAXN = 100005;
vector<i64> e[MAXN];
i64 re[MAXN];
i64 v[MAXN];
i64 R[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> m;
for (i64 i = 0; i < n - 1 + m; i++) {
i64 u, w;
cin >> u >> w;
e[u].push_back(w);
re[w]++;
}
i64 r = -1;
for (i64 i = 0; i < n; i++) {
if (!re[i]) {
r = i;
}
}
queue<i64> q;
q.push(r);
v[r] = 1;
for (;;) {
if (q.empty()) {
break;
}
i64 c = q.front();
q.pop();
for (auto w : e[c]) {
v[w]++;
if (v[w] == re[w]) {
q.push(w);
R[w] = c;
}
}
}
for (i64 i = 1; i <= n; i++) {
cout << R[i] << endl;
}
return 0;
} | [
"variable_declaration.type.change"
] | 941,710 | 941,711 | u462405902 | cpp |
p03142 | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REPD(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define PB(e) push_back(e)
#define FOREACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define BIT(n, m) (((n) >> (m)) & 1)
typedef long long ll;
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
REP(i, v.size()) {
if (i > 0)
out << ", ";
out << v[i];
}
out << "]";
return out;
}
void dfs(const vector<vector<int>> &RG, int v, vector<int> &visit,
vector<int> &vs) {
visit[v] = true;
for (int w : RG[v]) {
if (!visit[w]) {
dfs(RG, w, visit, vs);
}
}
vs.push_back(v);
}
int main(int argc, char *argv[]) {
int N, M;
cin >> N >> M;
vector<int> A(N + M - 1), B(N + M - 1);
vector<vector<int>> RG(N + M);
vector<int> visit(N + M);
REP(i, N + M - 1) {
cin >> A[i] >> B[i];
RG[B[i]].push_back(A[i]);
}
vector<int> vs;
REP2(v, 1, N + 1) {
if (!visit[v]) {
dfs(RG, v, visit, vs);
}
}
vector<int> res(N);
vector<int> d(N, -1);
REP2(i, 1, N + 1) {
int v = vs[i - 1];
// cout << i - 1 << " " << v << " :"<< endl;
for (int w : RG[v]) {
// cout << v << " " << w << endl;
assert(d[w] >= 0);
d[v] = max(d[w] + 1, d[v]);
}
if (RG[v].size() == 0) {
res[v - 1] = 0;
d[v] = 0;
continue;
}
for (int w : RG[v]) {
if (d[w] == d[v] - 1) {
res[v - 1] = w;
}
}
}
REP(i, N) { cout << res[i] << endl; }
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REPD(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define PB(e) push_back(e)
#define FOREACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define BIT(n, m) (((n) >> (m)) & 1)
typedef long long ll;
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
REP(i, v.size()) {
if (i > 0)
out << ", ";
out << v[i];
}
out << "]";
return out;
}
void dfs(const vector<vector<int>> &RG, int v, vector<int> &visit,
vector<int> &vs) {
visit[v] = true;
for (int w : RG[v]) {
if (!visit[w]) {
dfs(RG, w, visit, vs);
}
}
vs.push_back(v);
}
int main(int argc, char *argv[]) {
int N, M;
cin >> N >> M;
vector<int> A(N + M - 1), B(N + M - 1);
vector<vector<int>> RG(N + M);
vector<int> visit(N + M);
REP(i, N + M - 1) {
cin >> A[i] >> B[i];
RG[B[i]].push_back(A[i]);
}
vector<int> vs;
REP2(v, 1, N + 1) {
if (!visit[v]) {
dfs(RG, v, visit, vs);
}
}
vector<int> res(N);
vector<int> d(N + 1, -1);
REP2(i, 1, N + 1) {
int v = vs[i - 1];
// cout << i - 1 << " " << v << " :"<< endl;
for (int w : RG[v]) {
// cout << v << " " << w << endl;
assert(d[w] >= 0);
d[v] = max(d[w] + 1, d[v]);
}
if (RG[v].size() == 0) {
res[v - 1] = 0;
d[v] = 0;
continue;
}
for (int w : RG[v]) {
if (d[w] == d[v] - 1) {
res[v - 1] = w;
}
}
}
REP(i, N) { cout << res[i] << endl; }
return 0;
}
| [
"assignment.change"
] | 941,712 | 941,713 | u202239169 | cpp |
p03142 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<ll, ll> P;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<vi> vvi;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#define FOR(i, n, m) for (ll i = (n); i < (m); ++i)
#define FORR(i, n, m) for (ll i = (m)-1; i >= (n); --i)
#define FORE(x, xs) for (auto &x : (xs))
#define ALL(v) v.begin(), v.end()
#define ZERO(a) memset(a, 0, sizeof(a))
const int INF = 1000000009;
const int MOD = 1000000007;
const double EPS = 1e-14;
const double PI = acos(-1);
const int MAX = 1e5 + 10;
int N, M, root;
vi childs[MAX];
vi parents[MAX];
bool isRoot[MAX];
int parent[MAX];
int R[MAX];
int dfs(int n) { // n番目のノードの深さを探索
if (R[n] >= 0)
return R[n];
int resRank = -1, idx = -1;
FORE(p, parents[n]) {
int r = dfs(p);
if (r > resRank) {
resRank = r;
idx = p;
}
}
parent[n] = idx;
R[n] = resRank + 1;
return resRank;
}
int main() {
cin >> N >> M;
REP(i, N) { isRoot[i] = true; }
REP(i, N + M - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
parent[i] = -2;
R[i] = -1;
childs[a].push_back(b);
parents[b].push_back(a);
isRoot[b] = false;
}
root = -1;
REP(i, N) {
if (isRoot[i]) {
root = i;
parent[i] = -1;
R[i] = 0;
} else {
if (parents[i].size() == 1) {
parent[i] = parents[i][0];
}
}
}
REP(i, N) dfs(i);
REP(i, N) cout << parent[i] + 1 << "\n";
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<ll, ll> P;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<vi> vvi;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REPR(i, n) for (ll i = (n)-1; i >= 0; --i)
#define FOR(i, n, m) for (ll i = (n); i < (m); ++i)
#define FORR(i, n, m) for (ll i = (m)-1; i >= (n); --i)
#define FORE(x, xs) for (auto &x : (xs))
#define ALL(v) v.begin(), v.end()
#define ZERO(a) memset(a, 0, sizeof(a))
const int INF = 1000000009;
const int MOD = 1000000007;
const double EPS = 1e-14;
const double PI = acos(-1);
const int MAX = 1e5 + 10;
int N, M, root;
vi childs[MAX];
vi parents[MAX];
bool isRoot[MAX];
int parent[MAX];
int R[MAX];
int dfs(int n) { // n番目のノードの深さを探索
if (R[n] >= 0)
return R[n];
int resRank = -1, idx = -1;
FORE(p, parents[n]) {
int r = dfs(p);
if (r > resRank) {
resRank = r;
idx = p;
}
}
parent[n] = idx;
R[n] = resRank + 1;
return R[n];
}
int main() {
cin >> N >> M;
REP(i, N) { isRoot[i] = true; }
REP(i, N + M - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
parent[i] = -2;
R[i] = -1;
childs[a].push_back(b);
parents[b].push_back(a);
isRoot[b] = false;
}
root = -1;
REP(i, N) {
if (isRoot[i]) {
root = i;
parent[i] = -1;
R[i] = 0;
} else {
if (parents[i].size() == 1) {
parent[i] = parents[i][0];
}
}
}
REP(i, N) dfs(i);
REP(i, N) cout << parent[i] + 1 << "\n";
return 0;
} | [
"function.return_value.change"
] | 941,714 | 941,715 | u957084285 | cpp |
p03142 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define FOR(i, n) for (int i = 1; i <= n; i++)
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int n, m;
#define N 100010
int deg[N];
vector<int> adj[N];
int anc[N];
int main() {
#ifdef QWERTIER
freopen("in.txt", "r", stdin);
#endif
scanf("%d%d", &n, &m);
FOR(i, n) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
deg[v]++;
}
queue<int> q;
FOR(i, n) {
if (deg[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : adj[u]) {
deg[v]--;
if (deg[v] == 0) {
q.push(v);
anc[v] = u;
}
}
}
FOR(i, n) { printf("%d\n", anc[i]); }
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define FOR(i, n) for (int i = 1; i <= n; i++)
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int n, m;
#define N 100010
int deg[N];
vector<int> adj[N];
int anc[N];
int main() {
#ifdef QWERTIER
freopen("in.txt", "r", stdin);
#endif
scanf("%d%d", &n, &m);
FOR(i, n - 1 + m) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
deg[v]++;
}
queue<int> q;
FOR(i, n) {
if (deg[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : adj[u]) {
deg[v]--;
if (deg[v] == 0) {
q.push(v);
anc[v] = u;
}
}
}
FOR(i, n) { printf("%d\n", anc[i]); }
return 0;
}
| [
"expression.operation.binary.add"
] | 941,716 | 941,717 | u736446591 | cpp |
p03141 | #include <bits/stdc++.h>
#define ll long long
#define MOD 1000000007
using namespace std;
int main() {
ll n;
cin >> n;
vector<pair<ll, ll>> v;
ll A[n];
ll B[n];
for (ll i = 0; i < n; i++) {
cin >> A[i] >> B[i];
v.push_back({A[i] + B[i], i});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
ll a1 = 0, a2 = 0;
for (ll i = 0; i < n; i++) {
if (i % 2 == 0) {
a1 += A[v[i].second];
} else {
a2 += B[v[i].second];
}
}
cout << abs(a1 - a2);
return 0;
}
// freopen("input.in","r",stdin);
// freopen("output.out","w",stdout);
// ios::sync_with_stdio(0);cin.tie(0);
| #include <bits/stdc++.h>
#define ll long long
#define MOD 1000000007
using namespace std;
int main() {
ll n;
cin >> n;
vector<pair<ll, ll>> v;
ll A[n];
ll B[n];
for (ll i = 0; i < n; i++) {
cin >> A[i] >> B[i];
v.push_back({A[i] + B[i], i});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
ll a1 = 0, a2 = 0;
for (ll i = 0; i < n; i++) {
if (i % 2 == 0) {
a1 += A[v[i].second];
} else {
a2 += B[v[i].second];
}
}
cout << (a1 - a2);
return 0;
}
// freopen("input.in","r",stdin);
// freopen("output.out","w",stdout);
// ios::sync_with_stdio(0);cin.tie(0);
| [] | 941,718 | 941,719 | u206580411 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<ll, ll>;
using namespace std;
template <class T> void vin(vector<T> &v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
int main() {
int n;
cin >> n;
vector<pair<ll, int>> ab(n);
vector<ll> a(n), b(n);
rep(i, n) {
cin >> a[i] >> b[i];
ab[i].first = a[i] - b[i];
;
ab[i].second = i;
}
sort(ab.begin(), ab.end());
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += a[ab[i].second];
else
ans -= b[ab[i].second];
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<ll, ll>;
using namespace std;
template <class T> void vin(vector<T> &v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
int main() {
int n;
cin >> n;
vector<pair<ll, int>> ab(n);
vector<ll> a(n), b(n);
rep(i, n) {
cin >> a[i] >> b[i];
ab[i].first = a[i] + b[i];
;
ab[i].second = i;
}
sort(ab.rbegin(), ab.rend());
ll ans = 0;
rep(i, n) {
if (i % 2 == 0)
ans += a[ab[i].second];
else
ans -= b[ab[i].second];
}
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.function.change",
"call.arguments.change"
] | 941,722 | 941,723 | u482544950 | cpp |
p03141 | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using ll = long long;
int main(void) {
int n;
while (scanf("%d", &n) == 1) {
vi a(n), b(n);
vpii ab(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
ab[i].first = a[i] + b[i];
ab[i].second = i;
}
sort(ab.begin(), ab.end());
ll ans_t = 0, ans_a = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
ans_a += b[ab[i].second];
} else {
ans_t += a[ab[i].second];
}
}
printf("%lld\n", ans_t - ans_a);
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using ll = long long;
int main(void) {
int n;
while (scanf("%d", &n) == 1) {
vi a(n), b(n);
vpii ab(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
ab[i].first = a[i] + b[i];
ab[i].second = i;
}
sort(ab.rbegin(), ab.rend());
ll ans_t = 0, ans_a = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
ans_a += b[ab[i].second];
} else {
ans_t += a[ab[i].second];
}
}
printf("%lld\n", ans_t - ans_a);
}
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 941,724 | 941,725 | u565795452 | cpp |
p03141 | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using ll = long long;
int main(void) {
int n;
while (scanf("%d", &n) == 1) {
vi a(n), b(n);
vpii ab(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
ab[i].first = a[i] - b[i];
ab[i].second = i;
}
sort(ab.begin(), ab.end());
ll ans_t = 0, ans_a = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
ans_a += b[ab[i].second];
} else {
ans_t += a[ab[i].second];
}
}
printf("%lld\n", ans_t - ans_a);
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using ll = long long;
int main(void) {
int n;
while (scanf("%d", &n) == 1) {
vi a(n), b(n);
vpii ab(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
ab[i].first = a[i] + b[i];
ab[i].second = i;
}
sort(ab.rbegin(), ab.rend());
ll ans_t = 0, ans_a = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
ans_a += b[ab[i].second];
} else {
ans_t += a[ab[i].second];
}
}
printf("%lld\n", ans_t - ans_a);
}
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.function.change",
"call.arguments.change"
] | 941,726 | 941,725 | u565795452 | cpp |
p03141 | #include <bits/stdc++.h>
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define erep(e, v) for (auto &&e : v)
#define all(in) in.begin(), in.end()
#define MP make_pair
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
using namespace std;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
template <class T> void join(T a) {
for (auto itr : a) {
if (itr != *a.begin())
cout << " ";
cout << itr;
}
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<pii, int>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
signed main() {
int n;
cin >> n;
vector<piii> v, u;
priority_queue<pii, vector<pii>, greater<pii>> vque;
rep(i, n) {
pii temp;
cin >> temp.first >> temp.second;
v.push_back(piii(temp, i));
vque.push(pii(temp.first + temp.second, i));
}
int cnt = 0, vsum = 0, usum = 0;
while (cnt < n) {
auto top = vque.top();
vque.pop();
if (cnt % 2 == 0) {
vsum += v[top.second].first.first;
} else {
usum += v[top.second].first.second;
}
cnt++;
}
cout << vsum - usum << endl;
}
| #include <bits/stdc++.h>
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define erep(e, v) for (auto &&e : v)
#define all(in) in.begin(), in.end()
#define MP make_pair
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
using namespace std;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
template <class T> void join(T a) {
for (auto itr : a) {
if (itr != *a.begin())
cout << " ";
cout << itr;
}
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<pii, int>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
signed main() {
int n;
cin >> n;
vector<piii> v, u;
priority_queue<pii, vector<pii>> vque;
rep(i, n) {
pii temp;
cin >> temp.first >> temp.second;
v.push_back(piii(temp, i));
vque.push(pii(temp.first + temp.second, i));
}
int cnt = 0, vsum = 0, usum = 0;
while (cnt < n) {
auto top = vque.top();
vque.pop();
if (cnt % 2 == 0) {
vsum += v[top.second].first.first;
} else {
usum += v[top.second].first.second;
}
cnt++;
}
cout << vsum - usum << endl;
}
| [] | 941,729 | 941,730 | u318334550 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool comp(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second < b.second;
}
}
int main() {
ll N;
cin >> N;
vector<ll> A(N), B(N);
vector<pair<ll, ll>> d(N);
for (ll i = 0; i < N; i++)
cin >> A[i] >> B[i];
for (ll i = 0; i < N; i++) {
d[i].first = A[i] + B[i];
d[i].second = i;
}
sort(d.begin(), d.end(), comp);
reverse(d.begin(), d.end());
ll a = 0, t = 0;
for (ll i = 0; i < N; i++) {
// cout << d[i].first <<" "<< d[i].second << endl;
if (i % 2 == 0)
t += A[d[i].second];
else
a += B[d[i].second];
}
// cout << t <<" "<< a << endl;
cout << t - a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool comp(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first) {
return a.first < b.first;
} else {
return a.second < b.second;
}
}
int main() {
ll N;
cin >> N;
vector<ll> A(N), B(N);
vector<pair<ll, ll>> d(N);
for (ll i = 0; i < N; i++)
cin >> A[i] >> B[i];
for (ll i = 0; i < N; i++) {
d[i].first = A[i] + B[i];
d[i].second = i;
}
sort(d.begin(), d.end(), comp);
reverse(d.begin(), d.end());
ll a = 0, t = 0;
for (ll i = 0; i < N; i++) {
// cout << d[i].first <<" "<< d[i].second << endl;
if (i % 2 == 0)
t += A[d[i].second];
else
a += B[d[i].second];
}
// cout << t <<" "<< a << endl;
cout << t - a << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,731 | 941,732 | u672541593 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool comp(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second < b.second;
}
}
int main() {
ll N;
cin >> N;
vector<ll> A(N), B(N);
vector<pair<ll, ll>> d(N);
for (ll i = 0; i < N; i++)
cin >> A[i] >> B[i];
for (ll i = 0; i < N; i++) {
d[i].first = A[i] - B[i];
d[i].second = i;
}
sort(d.begin(), d.end(), comp);
reverse(d.begin(), d.end());
ll a = 0, t = 0;
for (ll i = 0; i < N; i++) {
// cout << d[i].first <<" "<< d[i].second << endl;
if (i % 2 == 0)
t += A[d[i].second];
else
a += B[d[i].second];
}
// cout << t <<" "<< a << endl;
cout << t - a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool comp(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first) {
return a.first < b.first;
} else {
return a.second < b.second;
}
}
int main() {
ll N;
cin >> N;
vector<ll> A(N), B(N);
vector<pair<ll, ll>> d(N);
for (ll i = 0; i < N; i++)
cin >> A[i] >> B[i];
for (ll i = 0; i < N; i++) {
d[i].first = A[i] + B[i];
d[i].second = i;
}
sort(d.begin(), d.end(), comp);
reverse(d.begin(), d.end());
ll a = 0, t = 0;
for (ll i = 0; i < N; i++) {
// cout << d[i].first <<" "<< d[i].second << endl;
if (i % 2 == 0)
t += A[d[i].second];
else
a += B[d[i].second];
}
// cout << t <<" "<< a << endl;
cout << t - a << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change",
"expression.operator.arithmetic.change",
"assignment.value.change"
] | 941,733 | 941,732 | u672541593 | cpp |
p03141 | #include <assert.h>
#include <bits/stdc++.h>
using namespace std;
struct Dish {
long long A, B;
};
int main() {
int N;
cin >> N;
vector<Dish> dish(N);
for (int i = 0; i < N; i++)
cin >> dish[i].A >> dish[i].B;
sort(dish.begin(), dish.end(),
[](const Dish &l, const Dish &r) { return (r.A + r.B > r.A + r.B); });
long long ans = 0;
for (int i = 0; i < N; i++)
if (i % 2 == 0)
ans += dish[i].A;
else
ans -= dish[i].B;
cout << ans << endl;
return 0;
}
| #include <assert.h>
#include <bits/stdc++.h>
using namespace std;
struct Dish {
long long A, B;
};
int main() {
int N;
cin >> N;
vector<Dish> dish(N);
for (int i = 0; i < N; i++)
cin >> dish[i].A >> dish[i].B;
sort(dish.begin(), dish.end(),
[](const Dish &l, const Dish &r) { return (l.A + l.B > r.A + r.B); });
long long ans = 0;
for (int i = 0; i < N; i++)
if (i % 2 == 0)
ans += dish[i].A;
else
ans -= dish[i].B;
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,734 | 941,735 | u623115612 | cpp |
p03141 | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define tr(c, i) for (iter(c) i = (c).begin(); i != (c).end(); ++i)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
using namespace std;
typedef long long int ll;
bool mysort(const vector<ll> &a, const vector<ll> &b) { return (a[0] < b[0]); }
int main() {
ll N;
cin >> N;
vector<vector<ll>> ABs;
rep(i, N) {
ll A, B;
cin >> A >> B;
ll sum = A + B;
vector<ll> AB;
AB.pb(sum);
AB.pb(A);
AB.pb(B);
ABs.pb(AB);
}
sort(all(ABs), mysort);
ll ans = 0;
rep(i, N) {
if (i % 2 == 0) {
ans += ABs[i][1];
} else {
ans -= ABs[i][2];
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define tr(c, i) for (iter(c) i = (c).begin(); i != (c).end(); ++i)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
using namespace std;
typedef long long int ll;
bool mysort(const vector<ll> &a, const vector<ll> &b) { return (a[0] > b[0]); }
int main() {
ll N;
cin >> N;
vector<vector<ll>> ABs;
rep(i, N) {
ll A, B;
cin >> A >> B;
ll sum = A + B;
vector<ll> AB;
AB.pb(sum);
AB.pb(A);
AB.pb(B);
ABs.pb(AB);
}
sort(all(ABs), mysort);
ll ans = 0;
rep(i, N) {
if (i % 2 == 0) {
ans += ABs[i][1];
} else {
ans -= ABs[i][2];
}
}
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 941,736 | 941,737 | u559765551 | cpp |
p03141 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long int> a(n), b(n);
vector<pair<pair<int, int>, int>> c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i].first.first = a[i] - b[i];
c[i].first.second = a[i];
c[i].second = i;
}
sort(c.begin(), c.end());
long long int tk = 0, ao = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
tk += a[c[i].second];
else
ao += b[c[i].second];
}
cout << tk - ao << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long int> a(n), b(n);
vector<pair<pair<int, int>, int>> c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i].first.first = -(a[i] + b[i]);
c[i].first.second = a[i];
c[i].second = i;
}
sort(c.begin(), c.end());
long long int tk = 0, ao = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
tk += a[c[i].second];
else
ao += b[c[i].second];
}
cout << tk - ao << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 941,746 | 941,747 | u205367115 | cpp |
p03141 | #include <bits/stdc++.h>
using namespace std;
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 S, class T> using P = pair<S, T>;
template <class S, class T, class U> using TP = tuple<S, T, U>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
//#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
//#define say(a) cout <<(a);
//#define sal(a) cout <<(a)<<"\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
/*#define llin(a) ll (a);cin >>(a);
#define llin2(a,b) ll (a),(b);cin >>(a)>>(b);
#define llin3(a,b,c) ll (a),(b),(c);cin >>(a)>>(b)>>(c);
#define stin(a) string (a);cin >>(a);*/
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(v, N) \
vll(v)((N)); \
vin(v);
#define vllin2(a, b, N) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(v, N) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define lam(lr) ([](auto l, auto r) { lr })
#define elam(lr) ([=](auto l, auto r) { lr })
#define clam(lr) ([&](auto l, auto r) { lr })
#define min(...) Operation(MIN, __VA_ARGS__)
#define max(...) Operation(MAX, __VA_ARGS__)
#define gcd(...) Operation(GCD, __VA_ARGS__)
#define lcm(...) Operation(LCM, __VA_ARGS__)
#define vmin(...) VOperation(MIN, __VA_ARGS__)
#define vmax(...) VOperation(MAX, __VA_ARGS__)
#define vgcd(...) VOperation(GCD, __VA_ARGS__)
#define vlcm(...) VOperation(LCM, __VA_ARGS__)
#define vsum(...) VOperation(ADD, __VA_ARGS__)
#define vpro(...) VOperation(MUL, __VA_ARGS__)
#define emin(a, ...) ((a) = min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define ActPair(T) P<T, function<T(T, T)>>
#define BoolPair(T) P<T, function<bool(T, T)>>
#define ope Operation
#define vope VOperation
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
//#define vli(size, ...) vll __VA_ARGS__;vInitInput(size,__VA_ARGS__);
#define vlr(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vlc(size, ...) \
vll __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsr(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsc(size, ...) \
vs __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vli2(rowSize, columnSize, ...) \
vvll __VA_ARGS__; \
vInitInput2(rowSize, columnSize, __VA_ARGS__);
#define vplr(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vplc(size, ...) \
vpl __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vpli(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
template <class S, class T> istream &operator>>(istream &in, P<S, T> &p) {
return in >> p.fi >> p.se;
}
template <class T> istream &operator>>(istream &in, V<T> &v) {
REP(i, v.sz) in >> v[i];
return in;
}
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInput(ll size) {}
template <class T, class... Args> void vInput(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInput(size, args...);
}
void vInputR(ll size) {}
template <class T, class... Args>
void vInputR(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInputR(size, args...);
}
void vInputNumC(ll num) {}
template <class T, class... Args>
void vInputNumC(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNumC(num, args...);
}
void vInputC(ll size) {}
template <class... Args> void vInputC(ll size, Args &...args) {
REP(i, size) vInputNumC(i, args...);
}
void vInitInputR(ll size) {}
template <class... Args> void vInitInputR(ll size, Args &...args) {
vInit(size, args...);
vInputR(size, args...);
}
void vInitInputC(ll size) {}
template <class... Args> void vInitInputC(ll size, Args &...args) {
vInit(size, args...);
vInputC(size, args...);
}
void vInit2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInit2(ll rowSize, ll columnSize, V<V<T>> &v, Args &...args) {
v.asn(rowSize, V<T>(columnSize));
vInit2(rowSize, columnSize, args...);
}
void vInput2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInput2(ll rowSize, ll columnSize, V<V<T>> &v, Args &...args) {
REP(r, rowSize) {
REP(c, columnSize) { cin >> v[r][c]; }
}
vInput2(rowSize, columnSize, args...);
}
void vInitInput2(ll rowSize, ll columnSize) {}
template <class... Args>
void vInitInput2(ll rowSize, ll columnSize, Args &...args) {
vInit2(rowSize, columnSize, args...);
vInput2(rowSize, columnSize, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T> void salv(V<V<T>> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv(T v, Args... args) {
salv(v);
salv(args...);
}
template <class L, class R> auto Gcd(L l, R r) -> decltype(l + r) {
if (l < r)
swap(l, r);
return r ? Gcd(r, l % r) : l;
}
template <class L, class R> auto Lcm(L l, R r) {
if (!l || !r)
return 0;
return l / Gcd(l, r) * r;
}
auto LES = mp(INF, lam(return l < r;));
auto GRT = mp(-INF, lam(return l > r;));
auto EQ = mp(0, lam(return l == r;));
auto ADD = mp(0, lam(return l + r;));
auto SUB = mp(0, lam(return l - r;));
auto MUL = mp(1, lam(return l * r;));
auto DIV = mp(1, lam(return l / r;));
auto MDL = mp(1, lam(return l % r;));
auto XOR = mp(0, lam(return l ^ r;));
auto OR = mp(0, lam(return l | r;));
auto AND = mp(((ll)(1) << 63) - 1, lam(return l & r;));
auto MIN = mp(INF, lam(return (l < r) ? l : r;));
auto MAX = mp(-INF, lam(return (l > r) ? l : r;));
auto GCD = mp(0, lam(return Gcd(l, r);));
auto LCM = mp(1, lam(return Lcm(l, r);));
/*
auto ADD = mp(0, [](auto l, auto r) { return l + r; });
auto SUB = mp(1, [](auto l, auto r) { return l - r; });
auto MUL = mp(1, [](auto l, auto r) { return l * r; });
auto DIV = mp(0, [](auto l, auto r) { return l / r; });
auto MDL = mp(0, [](auto l, auto r) { return l % r; });
auto XOR = mp(0, [](auto l, auto r) { return l ^ r; });
auto OR = mp(0, [](auto l, auto r) { return l | r; });
auto AND = mp(((ll)(1) << 63) - 1, [](auto l, auto r) { return l & r; });
auto MIN = mp(INF, [](auto l, auto r) { return (l < r) ? l : r; });
auto MAX = mp(-INF, [](auto l, auto r) { return (l > r) ? l : r; });
auto GCD = mp(0, [](auto l, auto r) { return gcd(l, r); });
auto LCM = mp(1, [](auto l, auto r) { return lcm(l, r); });
*/
template <class OperationType> auto Operation(OperationType A) { return A.fi; }
template <class OperationType, class T> auto Operation(OperationType A, T x) {
return x;
}
template <class OperationType, class T, class... Args>
auto Operation(OperationType A, T x, Args... args) {
auto tmp = Operation(A, args...);
return A.se(x, tmp);
}
template <class OperationType> auto VOperation(OperationType A) { return A.fi; }
template <class OperationType, class T> auto VOperation(OperationType A, T x) {
return x;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<T> x) {
T tmp = A.fi;
ROR(x, i) tmp = A.se(tmp, i);
return tmp;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<V<T>> x) {
T tmp = A.fi;
ROR(x, i) ROR(i, j) tmp = A.se(tmp, j);
return tmp;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<V<V<T>>> x) {
T tmp = A.fi;
ROR(x, i) ROR(i, j) ROR(j, k) tmp = A.se(tmp, k);
return tmp;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<V<V<V<T>>>> x) {
T tmp = A.fi;
ROR(x, i) ROR(i, j) ROR(j, k) ROR(k, l) tmp = A.se(tmp, l);
return tmp;
}
template <class OperationType, class T, class... Args>
auto VOperation(OperationType A, T x, Args... args) {
auto xResult = VOperation(A, x);
auto tmp = VOperation(A, args...);
return A.se(xResult, tmp);
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT() {}
UFT(const UFT &uft) {}
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
vvll sizepv;
pUFT() {}
pUFT(const pUFT &puft) {}
pUFT(ll tsizeget) {
tsize = tsizeget;
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {1});
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
par[y] += par[x];
sizepi[y].pb(now);
sizepv[y].pb(-par[y]);
par[x] = y;
mtime[x] = now;
} else {
par[x] += par[y];
sizepi[x].pb(now);
sizepv[x].pb(-par[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
ll size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT() {}
wUFT(const wUFT &wuft) {}
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Graph {
public:
ll vSize;
ll eMode;
ll mapMode;
ActPair(T) Add;
BoolPair(T) Lesser;
BoolPair(T) Equal;
V<V<P<T, ll>>> adj;
map<pl, T> len;
Graph(ll vSize, ll eMode = 0, ll mapMode = 0, ActPair(T) Add = ADD,
BoolPair(T) Lesser = LES, BoolPair(T) Equal = EQ)
: vSize(vSize), eMode(eMode), mapMode(mapMode), Add(Add), Lesser(Lesser),
Equal(Equal) {
Init();
}
void Init() { adj.asn(vSize, V<P<T, ll>>()); }
void AddE(ll x, ll y, T cost) {
iAddE(x, y, cost);
if (!eMode)
iAddE(y, x, cost);
}
void iAddE(ll x, ll y, T cost) {
adj[x].pb(mp(cost, y));
if (mapMode)
len[mp(x, y)] = cost;
}
P<bool, T> getE(ll x, ll y) {
if (!len.count(mp(x, y)))
return mp(false, Lesser.fi);
return mp(true, len[mp(x, y)]);
}
V<T> Dijk(ll x) {
V<T> ans(vSize, Lesser.fi);
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se] = segt[now.se].fi;
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Add.se(ans[now.se], i.fi), i.se));
continue;
}
if (Lesser.se(Add.se(ans[now.se], i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Add.se(ans[now.se], i.fi), i.se));
continue;
}
}
}
return ans;
}
V<P<T, vll>> rDijk(ll x) {
V<P<T, vll>> ans(vSize, mp(Lesser.fi, vll()));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se].fi = segt[now.se].fi;
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Add.se(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Lesser.se(Add.se(ans[now.se].fi, i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Add.se(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Equal.se(Add.se(ans[now.se].fi, i.fi), segt[i.se].fi)) {
ans[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
T Prim(ll x = 0) {
T ans = Add.fi;
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans = Add.se(ans, segt[now.se].fi);
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
continue;
}
if (Lesser.se(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
continue;
}
}
}
return ans;
}
P<T, V<P<T, vll>>> rPrim(ll x = 0) {
P<T, V<P<T, vll>>> ans =
mp(Add.fi, V<P<T, vll>>(vSize, mp(Lesser.fi, vll())));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans.se[now.se].fi = segt[now.se].fi;
ans.fi = Add.se(ans.fi, ans.se[now.se].fi);
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Lesser.se(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Equal.se(i.fi, segt[i.se].fi)) {
ans.se[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
};
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
ActPair(T) Add;
ActPair(T) Sub;
Sum(V<T> v, ActPair(T) Add = ADD, ActPair(T) Sub = SUB)
: v(v), size(v.sz), Add(Add), Sub(Sub) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Add.fi); }
void Calc() { REP(i, size) s[i + 1] = Add.se(s[i], v[i]); }
T operator()(ll x) {
if (x < -1)
x = -1;
if (x > size - 1)
x = size - 1;
return s[x + 1];
}
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Add.fi;
return Sub.se(s[r + 1], s[l]);
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
V<V<T>> v, s;
ll RowSize, ColumnSize;
ActPair(T) Add;
ActPair(T) Sub;
Sum2(V<V<T>> v, ActPair(T) Add = ADD, ActPair(T) Sub = SUB)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add),
Sub(Sub) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize + 1, Add.fi)); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
// s[r][c] = Sub.se(Add.se(Add.se(v[r - 1][c -
//1], operator()(r - 1, c - 2)), operator()(r - 2, c - 1)), operator()(r
//- 2, c - 2));
s[r][c] = Add.se(s[r][c - 1], v[r - 1][c - 1]);
}
}
REP1(r, RowSize) {
REP1(c, ColumnSize) { s[r][c] = Add.se(s[r - 1][c], s[r][c]); }
}
}
T operator()(ll r, ll c) {
if (r < -1)
r = -1;
if (c < -1)
c = -1;
if (r > RowSize - 1)
r = RowSize - 1;
if (c > ColumnSize - 1)
c = ColumnSize - 1;
return s[r + 1][c + 1];
}
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Add.fi;
if (c1 > c2)
return Add.fi;
return Sub.se(Add.se(s[r2 + 1][c2 + 1], s[r1][c1]),
Add.se(s[r2 + 1][c1], s[r1][c2 + 1]));
}
};
using sumll2 = Sum2<ll>;
template <class T> struct Point2 {
public:
V<V<T>> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend istream &operator>>(istream &in, Modll &m) { return in >> m.v; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T>
V<V<T>> MultiMatrix(V<V<T>> A, V<V<T>> B, ActPair(T) Mul = MUL,
ActPair(T) Add = ADD) {
V<V<T>> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) { ans[i][k] = Add.se(ans[i][k], Mul.se(A[i][j], B[j][k])); }
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> vll PCmprs(V<T> v) {
if (v.sz == 0)
return V<T>();
vll tmp(v.sz);
vll ans(v.sz);
IOTA(tmp, 0);
IOTA(ans, 0);
sort(tmp.bgn, tmp.en, clam(return v[l] < v[r];));
sort(ans.bgn, ans.en, clam(return tmp[l] < tmp[r];));
return ans;
}
ll BblCnt(vll rv) {
vll v = PCmprs(rv);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
template <class T> auto ven(T val) { return val; }
template <> auto ven<int>(int val) { return (ll)val; }
template <class T, class... Args> auto ven(T val, Args... args) {
auto tmp = ven(args...);
return V<decltype(tmp)>(val, tmp);
}
template <class T> void zind(T &v) { v--; }
template <class T> void zind(V<T> &v) { ROR(v, i) zind(i); }
template <class T, class... Args> void zind(T &v, Args &...args) {
zind(v);
zind(args...);
}
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
void Solve() {
li(n);
vlc(n, a, b);
vpl c(n);
REP(i, n) c[i] = mp(a[i] + b[i], i);
SORT(c);
// sort(c.bgn, c.en, lam(return l.fi > r.fi;));
ll t = 0, u = 0, uu = 0;
REP(i, n) {
if (i % 2 == 0)
u += a[c[i].se];
if (i % 2 == 1)
uu += b[c[i].se];
}
/* while (t < n) {
u += a[c[t].se];
t++;
if (t == n) break;
u -= b[c[t].se];
t++;
}*/
sal(u - uu);
} | #include <bits/stdc++.h>
using namespace std;
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 S, class T> using P = pair<S, T>;
template <class S, class T, class U> using TP = tuple<S, T, U>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using str = string;
using vll = V<ll>;
using vvll = V<vll>;
using vvvll = V<vvll>;
using pl = P<ll, ll>;
using tl = TP<ll, ll, ll>;
using vpl = V<pl>;
using vvpl = V<vpl>;
using vtl = V<tl>;
using vvtl = V<vtl>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using qll = queue<ll>;
using qpl = queue<pl>;
using stll = stack<ll>;
using stpl = stack<pl>;
using mapll = map<ll, ll>;
using setll = set<ll>;
using pqll = priority_queue<ll>;
//#define int ll
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define sz size()
#define bgn begin()
#define en end()
#define asn assign
#define emp empty()
#define fr front()
#define bk back()
#define clr clear()
#define ins insert
#define ers erase
#define res resize
#define tp top()
#define p_q priority_queue
#define inv inverse()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, a) FOR((i), 0, (ll)(a)-1)
#define REP0(i, a) FOR((i), 0, (ll)(a))
#define REP1(i, a) FOR((i), 1, (ll)(a))
#define rREP(i, a) rFOR((i), 0, (ll)(a)-1)
#define rREP0(i, a) rFOR((i), 0, (ll)(a))
#define rREP1(i, a) rFOR((i), 1, (ll)(a))
#define ROR(v, i) for (auto &(i) : (v))
#define IOTA(a, n) iota((a).bgn, (a).en, (n))
#define SORT(a) sort((a).bgn, (a).en)
#define rSORT(a) sort((a).rbegin(), (a).rend())
#define UNIQUE(a) (a).erase(unique((a).bgn, (a).en), (a).en)
#define PREVP(a) prev_permutation((a).bgn, (a).en)
#define NEXTP(a) next_permutation((a).bgn, (a).en)
#define BINS(a, b) binary_search((a).bgn, (a).en, (b))
#define LOWB(a, b) (lower_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define UPB(a, b) (upper_bound((a).bgn, (a).en, (b)) - (a).bgn)
#define CNT(a, b) count((a).bgn, (a).en, b)
#define SUM(a) accumulate((a).bgn, (a).en, 0)
#define REV(a) reverse((a).bgn, (a).en)
#define REGS(a, b) regex_search((a), regex(b))
#define REGM(a, b) regex_match((a), regex(b))
#define yn(a) cout << ((a) ? "yes" : "no") << "\n";
#define Yn(a) cout << ((a) ? "Yes" : "No") << "\n";
#define YN(a) cout << ((a) ? "YES" : "NO") << "\n";
#define imp(a) cout << ((a) ? "possible" : "impossible") << "\n";
#define Imp(a) cout << ((a) ? "Possible" : "Impossible") << "\n";
#define IMP(a) cout << ((a) ? "POSSIBLE" : "IMPOSSIBLE") << "\n";
#define fs(a) cout << ((a) ? "second" : "first") << "\n";
#define Fs(a) cout << ((a) ? "Second" : "First") << "\n";
#define FS(a) cout << ((a) ? "SECOND" : "FIRST") << "\n";
//#define say(a) cout <<(a);
//#define sal(a) cout <<(a)<<"\n";
#define sak cout << "\n";
#define sas cout << " ";
#define sat cout << "\t";
#define dbg(a) cerr << (#a) << ": " << (a) << "\n";
#define dbgs(...) \
dal(#__VA_ARGS__); \
dal(__VA_ARGS__);
#define c2l(a) ((ll)(a - 48))
#define a2l(a) ((ll)(a - 97))
#define A2l(a) ((ll)(a - 65))
#define l2c(a) ((char)(a + 48))
#define l2a(a) ((char)(a + 97))
#define l2A(a) ((char)(a + 65))
#define DigN2(a) ((llabs(a) == 0) ? (1) : ((ll)(log2(double(llabs(a)))) + 1))
#define DigN10(a) ((llabs(a) == 0) ? (1) : ((ll)(log10(double(llabs(a)))) + 1))
#define Dig2(a, b) (((a) >> (b)) & 1)
#define Dig10(a, b) (ll)(((a) / ((ll)(pow(10.0, (double)(b))))) % 10)
#define Pow2(a) ((ll)(1) << (a))
#define Pow10(a) ((ll)(pow(10.0, double(a))))
#define LSB(a) ((a) & (-(a)))
/*#define llin(a) ll (a);cin >>(a);
#define llin2(a,b) ll (a),(b);cin >>(a)>>(b);
#define llin3(a,b,c) ll (a),(b),(c);cin >>(a)>>(b)>>(c);
#define stin(a) string (a);cin >>(a);*/
#define vin(v) \
ROR((v), (i)) { cin >> (i); };
#define vllin(v, N) \
vll(v)((N)); \
vin(v);
#define vllin2(a, b, N) \
vll(a)(N), (b)(N); \
REP(i, N) { cin >> (a)[i] >> (b)[i]; };
#define vsin(v, N) \
vs(v)((N)); \
vin(v);
#define rdn(a, b) ((a) / (b))
#define rou(a, b) \
((((double(a) / double(b)) - ((a) / (b))) < 0.5) ? ((a) / (b)) \
: (((a) / (b)) + 1))
#define rup(a, b) ((((a) % (b)) == 0) ? ((a) / (b)) : (((a) / (b)) + 1))
#define powll(a, b) (ll)(pow((double)(a), (double)(b)))
#define Triangle(x1, y1, x2, y2, x3, y3) \
(((x1) - (x2)) * ((y1) - (y3)) - ((x1) - (x3)) * ((y1) - (y2)))
#define lam(lr) ([](auto l, auto r) { lr })
#define elam(lr) ([=](auto l, auto r) { lr })
#define clam(lr) ([&](auto l, auto r) { lr })
#define min(...) Operation(MIN, __VA_ARGS__)
#define max(...) Operation(MAX, __VA_ARGS__)
#define gcd(...) Operation(GCD, __VA_ARGS__)
#define lcm(...) Operation(LCM, __VA_ARGS__)
#define vmin(...) VOperation(MIN, __VA_ARGS__)
#define vmax(...) VOperation(MAX, __VA_ARGS__)
#define vgcd(...) VOperation(GCD, __VA_ARGS__)
#define vlcm(...) VOperation(LCM, __VA_ARGS__)
#define vsum(...) VOperation(ADD, __VA_ARGS__)
#define vpro(...) VOperation(MUL, __VA_ARGS__)
#define emin(a, ...) ((a) = min((a), __VA_ARGS__))
#define emax(a, ...) ((a) = max((a), __VA_ARGS__))
#define egcd(a, ...) ((a) = gcd((a), __VA_ARGS__))
#define elcm(a, ...) ((a) = lcm((a), __VA_ARGS__))
#define ActPair(T) P<T, function<T(T, T)>>
#define BoolPair(T) P<T, function<bool(T, T)>>
#define ope Operation
#define vope VOperation
#define svll SumV<ll>
#define svvll SumV2<ll>
#define li(...) \
ll __VA_ARGS__; \
Input(__VA_ARGS__);
#define si(...) \
str __VA_ARGS__; \
Input(__VA_ARGS__);
//#define vli(size, ...) vll __VA_ARGS__;vInitInput(size,__VA_ARGS__);
#define vlr(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vlc(size, ...) \
vll __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vli(size, ...) \
vll __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsr(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vsc(size, ...) \
vs __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vsi(size, ...) \
vs __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vli2(rowSize, columnSize, ...) \
vvll __VA_ARGS__; \
vInitInput2(rowSize, columnSize, __VA_ARGS__);
#define vplr(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
#define vplc(size, ...) \
vpl __VA_ARGS__; \
vInitInputC(size, __VA_ARGS__);
#define vpli(size, ...) \
vpl __VA_ARGS__; \
vInitInputR(size, __VA_ARGS__);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
// const ll MOD = 924844033;
// const ll MOD = 9007199254740881;
const ll INF = 1LL << 60; // 1.15e18
const double PI = acos(-1.0);
const vll DX = {0, -1, 0, 1, 0, -1, 1, 1, -1};
const vll DY = {0, 0, -1, 0, 1, -1, -1, 1, 1};
const str alp = "abcdefghijklmnopqrstuvwxyz";
const str ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
template <class S, class T> istream &operator>>(istream &in, P<S, T> &p) {
return in >> p.fi >> p.se;
}
template <class T> istream &operator>>(istream &in, V<T> &v) {
REP(i, v.sz) in >> v[i];
return in;
}
void Input() {}
template <class Var, class... Args> void Input(Var &var, Args &...args) {
cin >> var;
Input(args...);
}
void vInit(ll size) {}
template <class T, class... Args> void vInit(ll size, V<T> &v, Args &...args) {
v.res(size);
vInit(size, args...);
}
void vInput(ll size) {}
template <class T, class... Args> void vInput(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInput(size, args...);
}
void vInputR(ll size) {}
template <class T, class... Args>
void vInputR(ll size, V<T> &v, Args &...args) {
REP(i, size) cin >> v[i];
vInputR(size, args...);
}
void vInputNumC(ll num) {}
template <class T, class... Args>
void vInputNumC(ll num, V<T> &v, Args &...args) {
cin >> v[num];
vInputNumC(num, args...);
}
void vInputC(ll size) {}
template <class... Args> void vInputC(ll size, Args &...args) {
REP(i, size) vInputNumC(i, args...);
}
void vInitInputR(ll size) {}
template <class... Args> void vInitInputR(ll size, Args &...args) {
vInit(size, args...);
vInputR(size, args...);
}
void vInitInputC(ll size) {}
template <class... Args> void vInitInputC(ll size, Args &...args) {
vInit(size, args...);
vInputC(size, args...);
}
void vInit2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInit2(ll rowSize, ll columnSize, V<V<T>> &v, Args &...args) {
v.asn(rowSize, V<T>(columnSize));
vInit2(rowSize, columnSize, args...);
}
void vInput2(ll rowSize, ll columnSize) {}
template <class T, class... Args>
void vInput2(ll rowSize, ll columnSize, V<V<T>> &v, Args &...args) {
REP(r, rowSize) {
REP(c, columnSize) { cin >> v[r][c]; }
}
vInput2(rowSize, columnSize, args...);
}
void vInitInput2(ll rowSize, ll columnSize) {}
template <class... Args>
void vInitInput2(ll rowSize, ll columnSize, Args &...args) {
vInit2(rowSize, columnSize, args...);
vInput2(rowSize, columnSize, args...);
}
template <class S, class T>
ostream &operator<<(ostream &out, const P<S, T> &p) {
return out << "[" << p.fi << ", " << p.se << "]";
}
template <class T> ostream &operator<<(ostream &out, V<T> &v) {
if (v.emp)
return out << "{}";
else {
auto itr = v.bgn;
out << "{" << *itr;
itr++;
while (itr != v.en) {
out << ", " << *itr;
itr++;
}
out << "}";
return out;
}
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &m) {
if (m.emp)
return out << "<[]>";
else {
auto itr = m.bgn;
out << "< [" << (itr->fi) << ": " << (itr->se);
itr++;
while (itr != m.en) {
out << "], [" << (itr->fi) << ": " << (itr->se);
itr++;
}
out << "] >";
return out;
}
}
template <class T> ostream &operator<<(ostream &out, const set<T> &s) {
if (s.emp)
return out << "<>";
else {
auto itr = s.bgn;
out << "<" << *itr;
itr++;
while (itr != s.en) {
out << ", " << *itr;
itr++;
}
out << ">";
return out;
}
}
void say() {}
template <class T> void say(T t) { cout << t; }
template <class Head, class... Body> void say(Head head, Body... body) {
cout << head << " ";
say(body...);
}
void sal() { cout << "\n"; }
template <class... Args> void sal(Args... args) {
say(args...);
cout << "\n";
}
void day() {}
template <class T> void day(T t) { cerr << t; }
template <class Head, class... Body> void day(Head head, Body... body) {
cerr << head << " ";
day(body...);
}
void dal() { cerr << "\n"; }
template <class... Args> void dal(Args... args) {
day(args...);
cerr << "\n";
}
void salv() {}
template <class T> void salv(V<T> v) {
if (v.emp)
sal();
else {
auto itr = v.bgn;
say(*itr);
itr++;
while (itr != v.en) {
sas;
say(*itr);
itr++;
}
sak;
}
}
template <class T> void salv(V<V<T>> v) {
if (v.emp)
sal();
else {
ROR(v, i) salv(i);
}
}
template <class T, class... Args> void salv(T v, Args... args) {
salv(v);
salv(args...);
}
template <class L, class R> auto Gcd(L l, R r) -> decltype(l + r) {
if (l < r)
swap(l, r);
return r ? Gcd(r, l % r) : l;
}
template <class L, class R> auto Lcm(L l, R r) {
if (!l || !r)
return 0;
return l / Gcd(l, r) * r;
}
auto LES = mp(INF, lam(return l < r;));
auto GRT = mp(-INF, lam(return l > r;));
auto EQ = mp(0, lam(return l == r;));
auto ADD = mp(0, lam(return l + r;));
auto SUB = mp(0, lam(return l - r;));
auto MUL = mp(1, lam(return l * r;));
auto DIV = mp(1, lam(return l / r;));
auto MDL = mp(1, lam(return l % r;));
auto XOR = mp(0, lam(return l ^ r;));
auto OR = mp(0, lam(return l | r;));
auto AND = mp(((ll)(1) << 63) - 1, lam(return l & r;));
auto MIN = mp(INF, lam(return (l < r) ? l : r;));
auto MAX = mp(-INF, lam(return (l > r) ? l : r;));
auto GCD = mp(0, lam(return Gcd(l, r);));
auto LCM = mp(1, lam(return Lcm(l, r);));
/*
auto ADD = mp(0, [](auto l, auto r) { return l + r; });
auto SUB = mp(1, [](auto l, auto r) { return l - r; });
auto MUL = mp(1, [](auto l, auto r) { return l * r; });
auto DIV = mp(0, [](auto l, auto r) { return l / r; });
auto MDL = mp(0, [](auto l, auto r) { return l % r; });
auto XOR = mp(0, [](auto l, auto r) { return l ^ r; });
auto OR = mp(0, [](auto l, auto r) { return l | r; });
auto AND = mp(((ll)(1) << 63) - 1, [](auto l, auto r) { return l & r; });
auto MIN = mp(INF, [](auto l, auto r) { return (l < r) ? l : r; });
auto MAX = mp(-INF, [](auto l, auto r) { return (l > r) ? l : r; });
auto GCD = mp(0, [](auto l, auto r) { return gcd(l, r); });
auto LCM = mp(1, [](auto l, auto r) { return lcm(l, r); });
*/
template <class OperationType> auto Operation(OperationType A) { return A.fi; }
template <class OperationType, class T> auto Operation(OperationType A, T x) {
return x;
}
template <class OperationType, class T, class... Args>
auto Operation(OperationType A, T x, Args... args) {
auto tmp = Operation(A, args...);
return A.se(x, tmp);
}
template <class OperationType> auto VOperation(OperationType A) { return A.fi; }
template <class OperationType, class T> auto VOperation(OperationType A, T x) {
return x;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<T> x) {
T tmp = A.fi;
ROR(x, i) tmp = A.se(tmp, i);
return tmp;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<V<T>> x) {
T tmp = A.fi;
ROR(x, i) ROR(i, j) tmp = A.se(tmp, j);
return tmp;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<V<V<T>>> x) {
T tmp = A.fi;
ROR(x, i) ROR(i, j) ROR(j, k) tmp = A.se(tmp, k);
return tmp;
}
template <class OperationType, class T>
auto VOperation(OperationType A, V<V<V<V<T>>>> x) {
T tmp = A.fi;
ROR(x, i) ROR(i, j) ROR(j, k) ROR(k, l) tmp = A.se(tmp, l);
return tmp;
}
template <class OperationType, class T, class... Args>
auto VOperation(OperationType A, T x, Args... args) {
auto xResult = VOperation(A, x);
auto tmp = VOperation(A, args...);
return A.se(xResult, tmp);
}
ll Bset(ll a, ll b, ll c) {
if (c)
a |= b;
else
a &= ~b;
return a;
}
struct UFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
UFT() {}
UFT(const UFT &uft) {}
UFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
}
ll root(ll x) { return par[x] < 0 ? x : par[x] = root(par[x]); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
struct pUFT {
public:
ll tsize;
ll now;
vll par;
vll rank;
vll mtime;
vvll sizepi;
vvll sizepv;
pUFT() {}
pUFT(const pUFT &puft) {}
pUFT(ll tsizeget) {
tsize = tsizeget;
now = 0;
par.asn(tsize, -1);
rank.asn(tsize, 0);
mtime.asn(tsize, INF);
sizepi.asn(tsize, {0});
sizepv.asn(tsize, {1});
}
ll root(ll x, ll t) { return (mtime[x] > t) ? x : root(par[x], t); }
bool same(ll x, ll y, ll t) { return root(x, t) == root(y, t); }
ll merge(ll x, ll y) {
now++;
x = root(x, now);
y = root(y, now);
if (x != y) {
if (rank[x] < rank[y]) {
par[y] += par[x];
sizepi[y].pb(now);
sizepv[y].pb(-par[y]);
par[x] = y;
mtime[x] = now;
} else {
par[x] += par[y];
sizepi[x].pb(now);
sizepv[x].pb(-par[x]);
par[y] = x;
mtime[y] = now;
if (rank[x] == rank[y])
rank[x]++;
}
}
return now;
}
ll size(ll x, ll t) {
x = root(x, t);
return sizepv[x][UPB(sizepi[x], t) - 1];
}
};
struct wUFT {
public:
ll tsize;
ll mode;
vll par;
vll rank;
vll dweight;
wUFT() {}
wUFT(const wUFT &wuft) {}
wUFT(ll tsizeget, ll modeget = 0) {
tsize = tsizeget;
mode = modeget;
par.asn(tsize, -1);
if (!mode)
rank.res(tsize, 0);
dweight.asn(tsize, 0);
}
ll root(ll x) {
if (par[x] < 0)
return x;
else {
ll r = root(par[x]);
dweight[x] += dweight[par[x]];
return par[x] = r;
}
}
ll weight(ll x) {
root(x);
return dweight[x];
}
ll diff(ll x, ll y) { return weight(y) - weight(x); }
bool isRoot(ll x) { return x == root(x); }
bool same(ll x, ll y) { return root(x) == root(y); }
void merge(ll x, ll y, ll w) {
w += weight(x);
w -= weight(y);
x = root(x);
y = root(y);
if (x == y)
return;
if (mode) {
par[x] += par[y];
par[y] = x;
} else {
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = y;
dweight[x] = -w;
} else {
par[x] += par[y];
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
dweight[y] = w;
}
}
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename valtype> class SegT {
public:
ll size;
vector<valtype> v;
valtype initv;
function<valtype(valtype x, valtype y)> calc;
SegT() {}
SegT(const SegT &segt) {}
SegT(ll sizeget, ll modeget = 0) {
sizeset(sizeget);
modeset(modeget);
init();
}
SegT(vector<valtype> cpyvec, ll modeget = 0) {
sizeset(cpyvec.sz);
modeset(modeget);
init();
copy(cpyvec);
}
SegT(ll sizeget, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(sizeget);
initv = initvget;
calc = calcget;
init();
}
SegT(vector<valtype> cpyvec, valtype initvget,
function<valtype(valtype x, valtype y)> calcget) {
sizeset(cpyvec.sz);
initv = initvget;
calc = calcget;
init();
copy(cpyvec);
}
void sizeset(ll rsize) {
size = DigN2(rsize);
if (rsize == Pow2(size - 1))
size--;
return;
}
void modeset(ll mode) {
switch (mode) {
case 0:
initv = 0;
calc = [](valtype x, valtype y) { return x + y; };
break;
case 1:
initv = INF;
calc = [](valtype x, valtype y) { return min(x, y); };
break;
case 2:
initv = -INF;
calc = [](valtype x, valtype y) { return max(x, y); };
break;
}
return;
}
void init() { v.asn(Pow2(size + 1) - 1, initv); }
void copy(vector<valtype> cpyvec) {
REP(i, min(cpyvec.sz, Pow2(size))) set(i, cpyvec[i]);
}
ll i2v(ll i) const {
if (i < 0 || i >= Pow2(size))
return -1;
return Pow2(size) + i - 1;
}
ll top(ll i) const {
if (i == 0)
return -1;
return (i - 1) / 2;
}
pl bot(ll i) const {
if (i + 1 >= Pow2(size))
return mp(-1, -1);
return mp(2 * i + 1, 2 * i + 2);
}
void set(ll i, valtype x) {
i = i2v(i);
v[i] = x;
while (i > 0) {
i = top(i);
v[i] = calc(v[bot(i).fi], v[bot(i).se]);
}
return;
}
void add(ll i, valtype x) {
set(i, v[i2v(i)] + x);
return;
}
valtype operator[](const ll &i) const { return v[i2v(i)]; }
// valtype que(ll a = 0, ll b = Pow2(size) - 1) {
valtype que(ll a, ll b) {
if (a == b)
return v[i2v(a)];
if (a > b)
return initv; // swap(a, b);
valtype ans = initv;
ll ai = i2v(a);
ll bi = i2v(b);
FOR(i, 1, size + 1) {
if (a > b)
break;
if (a % Pow2(i)) {
ans = calc(ans, v[ai]);
a += Pow2(i - 1);
ai = top(ai) + 1;
} else {
ai = top(ai);
}
if (a > b)
break;
if ((b + 1) % Pow2(i)) {
ans = calc(ans, v[bi]);
b -= Pow2(i - 1);
bi = top(bi) - 1;
} else {
bi = top(bi);
}
if (a > b)
break;
}
return ans;
}
valtype que(ll b) { return que(0, b); }
valtype que() { return que(0, Pow2(size) - 1); }
};
/*template <class Type> class DP {
public:
vector<Type> v;
Type initv;
vll size, block;
DP() {}
DP(const DP &dp) {}
template<class... Args> DP(Args... args) {
block.asn(1, 1);
Initialize(args...);
}
void Initialize(Type initv_) {
initv = initv_;
v.asn(block.bk, initv);
}
template<class... Args> void Initialize(ll val, Args... args) {
size.pb(val);
block.pb(block.bk*val);
Initialize(args...);
}
};*/
pl Bezout(ll a, ll b) {
if (b != 0) {
pl xy;
xy = Bezout(b, a % b);
return mp(xy.se, xy.fi - ((a / b) * xy.se));
} else {
return mp(1, 0);
}
}
pl Bez(ll a, ll b, ll c) {
pl xy;
ll x, y, z, gc;
xy = Bezout(a, b);
gc = gcd(a, b);
if (c % gc != 0)
return mp(-1, -1);
x = xy.fi * (c / gc);
y = xy.se * (c / gc);
if (x < 0)
z = rup(-x, (b / gc));
if (x >= 0)
z = -x / (b / gc);
x += z * (b / gc);
y -= z * (a / gc);
return mp(x, y);
}
ll DigS10(ll n) {
ll ans = 0;
while (1) {
ans += n % 10;
n /= 10;
if (!n)
break;
}
return ans;
}
ll isP(ll n) {
if (n <= 1)
return 0;
FOR(i, 2, (ll)sqrt(n) + 1) {
if (n % i == 0)
return 0;
}
return 1;
}
ll Tot(ll n) {
if (n <= 0)
return 0;
ll ans = n, x = 2;
while (x * x <= n) {
if (n % x == 0) {
ans -= ans / x;
while (n % x == 0)
n /= x;
}
x++;
}
if (n > 1)
ans -= ans / n;
return ans;
}
template <class T> struct Graph {
public:
ll vSize;
ll eMode;
ll mapMode;
ActPair(T) Add;
BoolPair(T) Lesser;
BoolPair(T) Equal;
V<V<P<T, ll>>> adj;
map<pl, T> len;
Graph(ll vSize, ll eMode = 0, ll mapMode = 0, ActPair(T) Add = ADD,
BoolPair(T) Lesser = LES, BoolPair(T) Equal = EQ)
: vSize(vSize), eMode(eMode), mapMode(mapMode), Add(Add), Lesser(Lesser),
Equal(Equal) {
Init();
}
void Init() { adj.asn(vSize, V<P<T, ll>>()); }
void AddE(ll x, ll y, T cost) {
iAddE(x, y, cost);
if (!eMode)
iAddE(y, x, cost);
}
void iAddE(ll x, ll y, T cost) {
adj[x].pb(mp(cost, y));
if (mapMode)
len[mp(x, y)] = cost;
}
P<bool, T> getE(ll x, ll y) {
if (!len.count(mp(x, y)))
return mp(false, Lesser.fi);
return mp(true, len[mp(x, y)]);
}
V<T> Dijk(ll x) {
V<T> ans(vSize, Lesser.fi);
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se] = segt[now.se].fi;
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Add.se(ans[now.se], i.fi), i.se));
continue;
}
if (Lesser.se(Add.se(ans[now.se], i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Add.se(ans[now.se], i.fi), i.se));
continue;
}
}
}
return ans;
}
V<P<T, vll>> rDijk(ll x) {
V<P<T, vll>> ans(vSize, mp(Lesser.fi, vll()));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans[now.se].fi = segt[now.se].fi;
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, mp(Add.se(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Lesser.se(Add.se(ans[now.se].fi, i.fi), segt[i.se].fi)) {
segt.set(i.se, mp(Add.se(ans[now.se].fi, i.fi), i.se));
ans[i.se].se = {now.se};
continue;
}
if (Equal.se(Add.se(ans[now.se].fi, i.fi), segt[i.se].fi)) {
ans[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
T Prim(ll x = 0) {
T ans = Add.fi;
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans = Add.se(ans, segt[now.se].fi);
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
continue;
}
if (Lesser.se(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
continue;
}
}
}
return ans;
}
P<T, V<P<T, vll>>> rPrim(ll x = 0) {
P<T, V<P<T, vll>>> ans =
mp(Add.fi, V<P<T, vll>>(vSize, mp(Lesser.fi, vll())));
if (x < 0 || x >= vSize)
return ans;
SegT<P<T, ll>> segt(vSize, mp(Lesser.fi, -1),
clam(if (l.se < 0) return r; if (r.se < 0) return l;
return Lesser.se(l.fi, r.fi) ? l : r;));
segt.set(x, mp(Add.fi, x));
P<T, ll> now;
while ((now = segt.que(0, vSize - 1)).se >= 0) {
ans.se[now.se].fi = segt[now.se].fi;
ans.fi = Add.se(ans.fi, ans.se[now.se].fi);
segt.set(now.se, mp(Lesser.fi, -2));
ROR(adj[now.se], i) {
if (segt[i.se].se == -2)
continue;
if (segt[i.se].se == -1) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Lesser.se(i.fi, segt[i.se].fi)) {
segt.set(i.se, i);
ans.se[i.se].se = {now.se};
continue;
}
if (Equal.se(i.fi, segt[i.se].fi)) {
ans.se[i.se].se.pb(now.se);
continue;
}
}
}
return ans;
}
};
template <class T> struct Sum {
public:
V<T> v, s;
ll size;
ActPair(T) Add;
ActPair(T) Sub;
Sum(V<T> v, ActPair(T) Add = ADD, ActPair(T) Sub = SUB)
: v(v), size(v.sz), Add(Add), Sub(Sub) {
Init();
Calc();
}
void Init() { s.asn(size + 1, Add.fi); }
void Calc() { REP(i, size) s[i + 1] = Add.se(s[i], v[i]); }
T operator()(ll x) {
if (x < -1)
x = -1;
if (x > size - 1)
x = size - 1;
return s[x + 1];
}
T operator()(ll l, ll r) {
if (l < 0)
l = 0;
if (r >= size)
r = size - 1;
if (l > r)
return Add.fi;
return Sub.se(s[r + 1], s[l]);
}
};
using sumll = Sum<ll>;
template <class T> struct Sum2 {
public:
V<V<T>> v, s;
ll RowSize, ColumnSize;
ActPair(T) Add;
ActPair(T) Sub;
Sum2(V<V<T>> v, ActPair(T) Add = ADD, ActPair(T) Sub = SUB)
: v(v), RowSize(v.sz), ColumnSize(v.sz ? v[0].sz : 0), Add(Add),
Sub(Sub) {
Init();
Calc();
}
void Init() { s.asn(RowSize + 1, V<T>(ColumnSize + 1, Add.fi)); }
void Calc() {
REP1(r, RowSize) {
REP1(c, ColumnSize) {
// s[r][c] = Sub.se(Add.se(Add.se(v[r - 1][c -
//1], operator()(r - 1, c - 2)), operator()(r - 2, c - 1)), operator()(r
//- 2, c - 2));
s[r][c] = Add.se(s[r][c - 1], v[r - 1][c - 1]);
}
}
REP1(r, RowSize) {
REP1(c, ColumnSize) { s[r][c] = Add.se(s[r - 1][c], s[r][c]); }
}
}
T operator()(ll r, ll c) {
if (r < -1)
r = -1;
if (c < -1)
c = -1;
if (r > RowSize - 1)
r = RowSize - 1;
if (c > ColumnSize - 1)
c = ColumnSize - 1;
return s[r + 1][c + 1];
}
T operator()(ll r1, ll c1, ll r2, ll c2) {
if (r1 < 0)
r1 = 0;
if (c1 < 0)
c1 = 0;
if (r2 >= RowSize)
r2 = RowSize - 1;
if (c2 >= ColumnSize)
c2 = ColumnSize - 1;
if (r1 > r2)
return Add.fi;
if (c1 > c2)
return Add.fi;
return Sub.se(Add.se(s[r2 + 1][c2 + 1], s[r1][c1]),
Add.se(s[r2 + 1][c1], s[r1][c2 + 1]));
}
};
using sumll2 = Sum2<ll>;
template <class T> struct Point2 {
public:
V<V<T>> v;
ll h, w;
Point2() : h(0), w(0) {}
Point2(ll h, ll w) : h(h), w(w) { asn(h, w); }
Point2(ll h, ll w, T val) : h(h), w(w) { asn(h, w, val); }
void assign(ll h, ll w) { v.asn(h, V<T>(w)); }
void assign(ll h, ll w, ll val) { v.asn(h, V<T>(w, val)); }
T &operator()(ll h, ll w) { return v[h][w]; }
T &operator()(pl p) { return v[p.fi][p.se]; }
};
template <class T> using P2 = Point2<T>;
template <ll Mod> struct Modll {
public:
ll v;
Modll() : v(0) {}
Modll(ll _v) { set(_v % Mod + Mod); }
Modll &set(ll _v) {
v = (_v < Mod) ? _v : (_v - Mod);
return *this;
}
Modll pow(ll n) const {
Modll x = *this, ans = 1;
while (n) {
if (n & 1)
ans *= x;
x *= x;
n >>= 1;
}
return ans;
}
Modll inverse() const { return (*this).pow(Mod - 2); }
Modll operator+(const Modll &m) const { return Modll().set(v + m.v); }
Modll operator-(const Modll &m) const { return Modll().set(Mod + v - m.v); }
Modll operator*(const Modll &m) const {
return Modll().set((ull(v) * m.v) % Mod);
}
Modll operator/(const Modll &m) const { return *this * m.inv; }
Modll &operator+=(const Modll &m) { return *this = *this + m; }
Modll &operator-=(const Modll &m) { return *this = *this - m; }
Modll &operator*=(const Modll &m) { return *this = *this * m; }
Modll &operator/=(const Modll &m) { return *this = *this / m; }
Modll operator-() const { return Modll(0) - *this; }
explicit operator bool() const { return v != 0; }
friend istream &operator>>(istream &in, Modll &m) { return in >> m.v; }
friend ostream &operator<<(ostream &out, const Modll &m) {
return out << m.v;
}
};
using mll = Modll<MOD>;
using vmll = V<mll>;
using vvmll = V<vmll>;
using vvvmll = V<vvmll>;
vmll MFactMemo(2, 1);
vmll MIFactMemo(2, 1);
mll mFact(ll n) {
if (MFactMemo.sz <= n) {
ll oldsize = MFactMemo.sz;
MFactMemo.res(n + 1, 1);
FOR(i, oldsize, n) MFactMemo[i] = MFactMemo[i - 1] * i;
}
return MFactMemo[n];
}
mll miFact(ll n) {
if (MIFactMemo.sz <= n) {
ll oldsize = MIFactMemo.sz;
MIFactMemo.res(n + 1, 1);
MIFactMemo.bk = mFact(n).inv;
rFOR(i, oldsize + 1, n) MIFactMemo[i - 1] = MIFactMemo[i] * i;
}
return MIFactMemo[n];
}
mll mComb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return mFact(n) * miFact(k) * miFact(n - k);
}
ll LIS(vll v, ll m = 0) {
if (v.sz > 0) {
ll ans = 0;
vll dp(v.sz, INF);
FOR(i, 0, v.sz - 1) { dp[m ? UPB(dp, v[i]) : LOWB(dp, v[i])] = v[i]; }
FOR(i, 0, v.sz - 1) {
if (dp[i] == INF)
break;
ans++;
}
return ans;
} else {
return 0;
}
}
ll Bsrch(function<bool(ll x)> f, ll mi, ll ma) {
ll ng = mi - 1, ok = ma, mid;
while (ok - ng > 1) {
mid = (ng + ok) / 2;
(f(mid) ? ok : ng) = mid;
}
return ok;
}
template <class T>
V<V<T>> MultiMatrix(V<V<T>> A, V<V<T>> B, ActPair(T) Mul = MUL,
ActPair(T) Add = ADD) {
V<V<T>> ans;
ll ii = A.sz;
if (!ii)
return ans;
ll jj = A[0].sz;
if (!jj)
return ans;
ll jj2 = B.sz;
if (!jj2)
return ans;
if (jj != jj2)
return ans;
ll kk = B[0].sz;
if (!kk)
return ans;
ans.asn(ii, V<T>(kk, 0));
REP(i, ii) {
REP(k, kk) {
REP(j, jj) { ans[i][k] = Add.se(ans[i][k], Mul.se(A[i][j], B[j][k])); }
}
}
return ans;
}
vvll CombMemo(1000, vll(1000, -1));
ll Comb(ll n, ll k) {
if ((n < 0) || (k < 0))
return 0;
if (CombMemo[n][k] == -1) {
if (n < k)
CombMemo[n][k] = 0;
else {
if (n == 0)
CombMemo[n][k] = 1;
else if (k == 0)
CombMemo[n][k] = 1;
else if (n == k)
CombMemo[n][k] = 1;
else
CombMemo[n][k] = Comb(n - 1, k - 1) + Comb(n - 1, k);
}
}
return CombMemo[n][k];
}
template <class T> map<T, ll> Dict(V<T> v) {
map<T, ll> m;
if (!v.sz)
return m;
SORT(v);
UNIQUE(v);
REP(i, v.sz) { m[v[i]] = i; }
return m;
}
template <class T> vll Cmprs(V<T> v) {
auto m = Dict(v);
vll ans(v.sz);
REP(i, v.sz) { ans[i] = m[v[i]]; }
return ans;
}
template <class T> vll PCmprs(V<T> v) {
if (v.sz == 0)
return V<T>();
vll tmp(v.sz);
vll ans(v.sz);
IOTA(tmp, 0);
IOTA(ans, 0);
sort(tmp.bgn, tmp.en, clam(return v[l] < v[r];));
sort(ans.bgn, ans.en, clam(return tmp[l] < tmp[r];));
return ans;
}
ll BblCnt(vll rv) {
vll v = PCmprs(rv);
SegT<ll> b(v.sz, 0);
ll ans = 0;
REP(i, v.sz) {
ans += (i - b.que(0, v[i]));
b.add(v[i], 1);
}
return ans;
}
template <class T> auto ven(T val) { return val; }
template <> auto ven<int>(int val) { return (ll)val; }
template <class T, class... Args> auto ven(T val, Args... args) {
auto tmp = ven(args...);
return V<decltype(tmp)>(val, tmp);
}
template <class T> void zind(T &v) { v--; }
template <class T> void zind(V<T> &v) { ROR(v, i) zind(i); }
template <class T, class... Args> void zind(T &v, Args &...args) {
zind(v);
zind(args...);
}
void Solve();
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
Solve();
}
void Solve() {
li(n);
vlc(n, a, b);
vpl c(n);
REP(i, n) c[i] = mp(a[i] + b[i], i);
rSORT(c);
// sort(c.bgn, c.en, [](pl l, pl r) {return l.fi != r.fi ? l.fi > r.fi:l.se
//< r.se; });
ll t = 0, u = 0, uu = 0;
REP(i, n) {
if (i % 2 == 0)
u += a[c[i].se];
if (i % 2 == 1)
uu += b[c[i].se];
}
/* while (t < n) {
u += a[c[t].se];
t++;
if (t == n) break;
u -= b[c[t].se];
t++;
}*/
sal(u - uu);
} | [
"identifier.change",
"call.function.change"
] | 941,755 | 941,756 | u211681714 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.