text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
vector<pair<int, int> > a, b;
int main() {
int n;
cin >> n;
for (int i = 1, col, w; i <= n; i++) {
scanf("%d%d", &col, &w);
if (col)
a.push_back(make_pair(w, i));
else
b.push_back(make_pair(w, i));
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int cnt1 = 0, cnt2 = 0;
int up1 = a.size();
int up2 = b.size();
while (cnt1 < up1 && cnt2 < up2) {
int tmp = min(a[cnt1].first, b[cnt2].first);
printf("%d %d %d\n", a[cnt1].second, b[cnt2].second, tmp);
a[cnt1].first -= tmp;
b[cnt2].first -= tmp;
if (a[cnt1].first == 0 && cnt1 < up1 - 1)
cnt1++;
else if (b[cnt2].first == 0 && cnt2 < up2 - 1)
cnt2++;
else if (cnt1 < up1 - 1)
cnt1++;
else
cnt2++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, a, b;
cin >> n;
set<pair<long long int, long long int>> s1, s2;
vector<pair<pair<long long int, long long int>, long long int>> res;
for (long long int i = 1; i <= n; i++) {
long long int c, s;
cin >> c >> s;
if (c == 1) {
s1.insert({s, i});
a = i;
} else {
s2.insert({s, i});
b = i;
}
}
while ((!s1.empty()) && (!s2.empty())) {
res.push_back({{s1.begin()->second, s2.begin()->second}, 0});
if (s1.begin()->first <= s2.begin()->first) {
long long int ind = s2.begin()->second,
sum = (s2.begin()->first) - (s1.begin()->first);
res.back().second = s1.begin()->first;
s1.erase(s1.begin());
s2.erase(s2.begin());
s2.insert({sum, ind});
} else {
long long int ind = s1.begin()->second,
sum = (s1.begin()->first) - (s2.begin()->first);
res.back().second = s2.begin()->first;
s1.erase(s1.begin());
s2.erase(s2.begin());
s1.insert({sum, ind});
}
}
if (!s1.empty())
for (auto it = next(s1.begin(), 1); it != s1.end(); it++)
res.push_back({{it->second, b}, 0});
if (!s2.empty())
for (auto it = next(s2.begin(), 1); it != s2.end(); it++)
res.push_back({{it->second, a}, 0});
for (long long int i = 0; i < n - 1; i++)
cout << res[i].first.first << " " << res[i].first.second << " "
<< res[i].second << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int qc = 1;
for (long long int i = 1; i <= qc; i++) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w;
priority_queue<pair<int, int> > pq[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
pq[a].push(make_pair(-b, i));
}
w = 0;
for (int i = 1; i <= n - 1; ++i) {
if (-pq[w].top().first < -pq[w ^ 1].top().first) w ^= 1;
if ((pq[w].top().first == pq[w ^ 1].top().first) &&
(pq[w].size() > pq[w ^ 1].size()))
w ^= 1;
int a = -pq[w].top().first;
int b = pq[w].top().second;
printf("%d %d %d\n", pq[w].top().second, pq[w ^ 1].top().second,
-pq[w ^ 1].top().first);
a -= -pq[w ^ 1].top().first;
pq[0].pop();
pq[1].pop();
pq[w].push(make_pair(-a, b));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq_whi, pq_bla;
for (int i = int(0); i <= int(n - 1); i++) {
int p, q;
scanf("%d", &p);
scanf("%d", &q);
pair<int, int> u = pair<int, int>(q, i + 1);
if (p == 0)
pq_whi.push(u);
else
pq_bla.push(u);
}
bool ch = true;
while (!pq_whi.empty() && !pq_bla.empty()) {
pair<int, int> whi = pq_whi.top();
pq_whi.pop();
pair<int, int> bla = pq_bla.top();
pq_bla.pop();
if (whi.first > bla.first) {
printf("%d %d %d\n", whi.second, bla.second, bla.first);
whi.first -= bla.first;
pq_whi.push(whi);
ch = true;
} else if (whi.first < bla.first) {
printf("%d %d %d\n", whi.second, bla.second, whi.first);
bla.first -= whi.first;
pq_bla.push(bla);
ch = false;
} else if ((ch && !pq_bla.empty()) || (!ch && pq_whi.empty())) {
printf("%d %d %d\n", whi.second, bla.second, whi.first);
whi.first = 0;
pq_whi.push(whi);
ch = !ch;
} else {
printf("%d %d %d\n", whi.second, bla.second, whi.first);
bla.first = 0;
pq_bla.push(bla);
ch = !ch;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 17;
int N;
multiset<pair<int, int> > S[2];
int data[MAXN];
int find(int x) { return (data[x] < 0) ? x : data[x] = find(data[x]); }
int getSize(int x) { return -data[find(x)]; }
void unite(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
if (getSize(u) < getSize(v)) swap(u, v);
data[u] += data[v];
data[v] = u;
}
struct edge {
int u, v, w;
};
vector<edge> edges;
int color[MAXN];
int main() {
ios::sync_with_stdio(0);
memset(data, -1, sizeof(data));
cin >> N;
for (int i = 0; i < (int)N; ++i) {
int c, w;
cin >> c >> w;
color[i] = c;
if (w > 0) S[c].insert(make_pair(w, i));
}
while (!S[0].empty() && !S[1].empty()) {
auto w0 = *S[0].begin();
S[0].erase(S[0].begin());
auto w1 = *S[1].begin();
S[1].erase(S[1].begin());
int edgeCost = min(w0.first, w1.first);
edges.push_back((edge){w0.second, w1.second, edgeCost});
unite(w0.second, w1.second);
w0.first -= edgeCost;
w1.first -= edgeCost;
if (w0.first > 0) S[0].insert(w0);
if (w1.first > 0) S[1].insert(w1);
}
for (int i = 0; i < (int)N; ++i)
if (i > 0)
if (color[i] != color[0] && find(i) != find(0)) {
unite(i, 0);
edges.push_back((edge){0, i, 0});
}
for (int i = 0; i < (int)N; ++i)
if (color[i] != color[0] && find(i) == find(0)) {
for (int j = 0; j < (int)N; ++j)
if (color[j] != color[i] && find(i) != find(j)) {
unite(i, j);
edges.push_back((edge){i, j, 0});
}
break;
}
for (auto e : edges) cout << e.u + 1 << " " << e.v + 1 << " " << e.w << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int u, s;
node() { u = s = 0; }
bool operator<(const node &temp) const {
if (this->s < temp.s) return 1;
return 0;
}
};
node black[100005];
node white[100005];
vector<vector<node> > adj;
int main() {
int n;
scanf("%d", &n);
adj.resize(n);
bool allzero = true;
int w, b;
w = b = 0;
for (int i = 0; i < n; ++i) {
int c;
scanf("%d", &c);
if (c == 0) {
white[w].u = i;
scanf("%d", &white[w].s);
if (white[w].s) allzero = false;
++w;
} else {
black[b].u = i;
scanf("%d", &black[b].s);
if (black[b].s) allzero = false;
++b;
}
}
if (allzero) {
if (w < b) {
for (int i = 0; i < b; ++i)
cout << white[0].u + 1 << ' ' << black[i].u + 1 << ' ' << 0 << endl;
for (int i = 1; i < w; ++i)
cout << white[i].u + 1 << ' ' << black[i].u + 1 << ' ' << 0 << endl;
} else {
for (int i = 0; i < w; ++i)
cout << black[0].u + 1 << ' ' << white[i].u + 1 << ' ' << 0 << endl;
for (int i = 1; i < b; ++i)
cout << black[i].u + 1 << ' ' << white[i].u + 1 << ' ' << 0 << endl;
}
return 0;
}
sort(black, black + b);
sort(white, white + w);
for (int indb = 0, indw = 0; indb < b && indw < w;) {
if (white[indw].s < black[indb].s) {
black[indb].s -= white[indw].s;
adj[black[indb].u].push_back(white[indw]);
++indw;
} else {
white[indw].s -= black[indb].s;
adj[white[indw].u].push_back(black[indb]);
++indb;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < adj[i].size(); ++j) {
printf("%d %d %d\n", i + 1, adj[i][j].u + 1, adj[i][j].s);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int w[maxn], col[maxn], fa[maxn], blk[maxn], wt[maxn], tot;
vector<int> v1, v2, id1, id2;
struct edge {
int u, v, w;
edge() {}
edge(int U, int V, int W) : u(U), v(V), w(W) {}
} e[maxn];
int gf(int x) { return x == fa[x] ? x : fa[x] = gf(fa[x]); }
void mg(int x, int y) {
x = gf(x);
y = gf(y);
fa[x] = y;
if (!blk[y]) blk[y] = blk[x];
if (!wt[y]) wt[y] = wt[x];
}
int main() {
ios::sync_with_stdio(false);
int n, c, s;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c >> s;
w[i] = s;
col[i] = c;
fa[i] = i;
c ? wt[i] = i : blk[i] = i;
if (c)
v1.push_back(s), id1.push_back(i);
else
v2.push_back(s), id2.push_back(i);
}
int p1 = 0, p2 = 0;
while (p1 < v1.size() && p2 < v2.size()) {
if (v1[p1] == v2[p2]) {
e[tot++] = edge(id1[p1], id2[p2], v1[p1]);
mg(id1[p1], id2[p2]);
p1++;
p2++;
} else if (v1[p1] < v2[p2]) {
e[tot++] = edge(id1[p1], id2[p2], v1[p1]);
v2[p2] -= v1[p1];
mg(id1[p1], id2[p2]);
p1++;
} else {
e[tot++] = edge(id1[p1], id2[p2], v2[p2]);
v1[p1] -= v2[p2];
mg(id1[p1], id2[p2]);
p2++;
}
}
int f = gf(1);
for (int i = 2; i <= n; i++) {
int t = gf(i);
if (t != f) {
if (blk[t] && wt[f])
e[tot++] = edge(blk[t], wt[f], 0);
else
e[tot++] = edge(wt[t], blk[f], 0);
mg(t, f);
}
}
for (int i = 0; i < tot; i++)
cout << e[i].u << " " << e[i].v << " " << e[i].w << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAX = 100010;
const long double eps = 0.000000001;
pair<int, int> lis[2][MAX];
int main() {
int n;
cin >> n;
int a, b;
int c[2] = {0, 0};
for (int i = (int)0; i < (int)(n); i++) {
cin >> a >> b;
lis[a][c[a]].first = -b;
lis[a][c[a]].second = i + 1;
c[a]++;
}
sort(lis[0], lis[0] + c[0]);
sort(lis[1], lis[1] + c[1]);
for (int i = (int)0; i < (int)(c[0]); i++) lis[0][i].first *= -1;
for (int i = (int)0; i < (int)(c[1]); i++) lis[1][i].first *= -1;
int pos[2] = {0, 0};
int aux;
while (pos[0] < c[0]) {
cout << lis[0][pos[0]].second << " " << lis[1][pos[1]].second << " "
<< min(lis[0][pos[0]].first, lis[1][pos[1]].first) << endl;
aux = min(lis[0][pos[0]].first, lis[1][pos[1]].first);
lis[0][pos[0]].first -= aux;
lis[1][pos[1]].first -= aux;
if (lis[0][pos[0]].first == 0)
pos[0]++;
else
pos[1]++;
}
pos[0]--;
pos[1]++;
while (pos[1] < c[1]) {
cout << lis[0][pos[0]].second << " " << lis[1][pos[1]].second << " " << 0
<< endl;
pos[1]++;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000")
#pragma warning(disable : 6031)
#pragma warning(disable : 4244)
#pragma warning(disable : 26451)
#pragma GCC target("sse4.2")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long mod = int(1e9) + 7;
const int INF = 1e9;
const long long LINF = 1e18;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << setprecision(18) << fixed;
int n;
cin >> n;
vector<pair<int, int>> b, w;
vector<pair<int, int>> zb, zw;
for (int i = 0; i < n; i++) {
int c, s;
cin >> c >> s;
if (c == 0) {
b.emplace_back(i, s);
} else {
w.emplace_back(i, s);
}
}
if ((int)(b).size() == 0) {
cout << w[0].first + 1 << " " << w[1].first + 1 << 0 << "\n";
return 0;
}
if ((int)(w).size() == 0) {
cout << b[0].first + 1 << " " << b[1].first + 1 << 0 << "\n";
return 0;
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pqw, pqb;
for (auto [i, s] : w) pqw.emplace(s, i);
for (auto [i, s] : b) pqb.emplace(s, i);
int cnt = 0;
vector<int> deg(n);
while (!pqw.empty() && !pqb.empty()) {
if (pqw.top().first < pqb.top().first) {
auto wp = pqw.top();
auto bp = pqb.top();
pqw.pop();
pqb.pop();
int dif = bp.first - wp.first;
cout << wp.second + 1 << " " << bp.second + 1 << " " << wp.first << "\n";
cnt++;
pqb.emplace(dif, bp.second);
deg[wp.second]++;
deg[bp.second]++;
} else if (pqw.top().first >= pqb.top().first) {
auto wp = pqw.top();
auto bp = pqb.top();
pqw.pop();
pqb.pop();
int dif = wp.first - bp.first;
cout << wp.second + 1 << " " << bp.second + 1 << " " << bp.first << "\n";
cnt++;
pqw.emplace(dif, wp.second);
deg[wp.second]++;
deg[bp.second]++;
}
}
while (!pqw.empty()) {
auto wp = pqw.top();
pqw.pop();
if (deg[wp.second] > 0) continue;
cout << wp.second + 1 << " " << b[0].first + 1 << " " << 0 << "\n";
}
while (!pqb.empty()) {
auto bp = pqb.top();
pqb.pop();
if (deg[bp.second] > 0) continue;
cout << bp.second + 1 << " " << w[0].first + 1 << " " << 0 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > A, B;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int c, s;
scanf("%d%d", &c, &s);
if (c)
A.push(make_pair(-s, i));
else
B.push(make_pair(-s, i));
}
while (true) {
if (A.size() && B.size()) {
pair<int, int> a = A.top();
A.pop();
pair<int, int> b = B.top();
B.pop();
a.first *= -1, b.first *= -1;
if (a.first > b.first) {
printf("%d %d %d\n", a.second, b.second, b.first);
A.push(make_pair(-(a.first - b.first), a.second));
} else if (a.first < b.first) {
printf("%d %d %d\n", a.second, b.second, a.first);
B.push(make_pair(-(b.first - a.first), b.second));
} else {
if (A.size() > B.size()) {
printf("%d %d %d\n", a.second, b.second, a.first);
B.push(make_pair(-(b.first - a.first), b.second));
} else {
printf("%d %d %d\n", a.second, b.second, b.first);
A.push(make_pair(-(a.first - b.first), a.second));
}
}
} else
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > poi[2];
for (int i = 0, c, s; i < n; ++i) {
cin >> c >> s;
poi[c].push_back(pair<int, int>(s, 1 + i));
}
sort(poi[0].begin(), poi[0].end(), greater<pair<int, int> >());
sort(poi[1].begin(), poi[1].end(), greater<pair<int, int> >());
for (int i = 1, j = 0, k = 0; i < n; ++i) {
int v = min(poi[0][j].first, poi[1][k].first);
poi[0][j].first -= v;
poi[1][k].first -= v;
cout << poi[0][j].second << ' ' << poi[1][k].second << ' ' << v << endl;
if (poi[0][j].first == 0 && poi[1][k].first == 0) {
if (k + 1 < poi[1].size())
++k;
else
++j;
} else if (poi[0][j].first == 0)
++j;
else
++k;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[200010];
int a[200010], b[200010];
int main() {
int p, q;
int t, ta, tb;
int i;
int n;
while (scanf("%d", &n) != EOF) {
p = q = -1;
for (i = 1; i <= n; i++) {
scanf("%d%d", &t, &s[i]);
if (t)
a[++p] = i;
else
b[++q] = i;
}
for (i = 0; i < n - 1; i++) {
ta = a[p];
tb = b[q];
t = min(s[ta], s[tb]);
printf("%d %d %d\n", ta, tb, t);
s[ta] -= t;
s[tb] -= t;
if (s[ta] == 0 && s[tb] == 0) {
if (p <= q)
q--;
else
p--;
} else {
if (s[ta] == 0)
p--;
else
q--;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int s[N], n;
vector<int> p[2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
int c;
cin >> c >> s[i];
p[c].push_back(i);
}
int i = 0, j = 0;
for (int k = 1; k < n; k++) {
int u = p[0][i];
int v = p[1][j];
int w = min(s[u], s[v]);
cout << u << ' ' << v << ' ' << w << '\n';
s[u] -= w;
s[v] -= w;
if (!s[u] && i < p[0].size() - 1)
i++;
else
j++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > a, b;
vector<pair<pair<int, int>, int> > res;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int c, s;
scanf("%d %d", &c, &s);
if (c == 0)
a.push_back(pair<int, int>(s, i));
else
b.push_back(pair<int, int>(s, i));
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int j = 0;
for (int i = 0; i < a.size(); i++)
if (j == b.size())
res.push_back(pair<pair<int, int>, int>(
pair<int, int>(a[i].second, b.back().second), 0));
else
while (j < b.size()) {
int tk = min(a[i].first, b[j].first);
res.push_back(pair<pair<int, int>, int>(
pair<int, int>(a[i].second, b[j].second), tk));
a[i].first -= tk;
b[j].first -= tk;
if (b[j].first == 0)
j++;
else
break;
}
for (int i = 0; i < res.size(); i++)
printf("%d %d %d\n", res[i].first.first, res[i].first.second,
res[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > st, cl[2];
int c[200010], S[200010], n;
int p[200010];
int PP(int a);
void uni(int a, int b) {
a = PP(a);
b = PP(b);
p[a] = b;
}
int PP(int a) {
if (p[a] == a) return a;
p[a] = PP(p[a]);
return p[a];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &S[i]);
cl[c[i]].insert(make_pair(S[i], i));
st.insert(make_pair(S[i], i));
p[i] = i;
}
while (st.size() > 0) {
int x = (*st.begin()).second;
int y = (*st.begin()).first;
st.erase(make_pair(y, x));
if (y == 0) continue;
if (S[x] != y) {
st.insert(make_pair(S[x], x));
continue;
}
int col = 1 - c[x];
while (S[x] > 0) {
int X = (*cl[col].begin()).second;
int Y = (*cl[col].begin()).first;
cl[col].erase(make_pair(Y, X));
if (Y == 0) continue;
if (S[X] != Y) {
cl[col].insert(make_pair(S[X], X));
continue;
}
int D = min(S[x], S[X]);
printf("%d %d %d\n", x, X, D);
uni(x, X);
S[x] -= D;
S[X] -= D;
uni(x, X);
cl[col].insert(make_pair(S[X], X));
}
}
int z = 1, Z = 1;
while (c[z]) z++;
while (!c[Z]) Z++;
for (int i = 1; i <= n; i++) {
int k = ((c[i] == c[z]) ? Z : z);
if (PP(k) == PP(i)) continue;
printf("%d %d %d\n", i, k, 0);
uni(k, i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = (int)1e5 + 20;
struct Edges {
int v;
int u;
int w;
} e[MAX_N];
set<pair<int, int> > White;
set<pair<int, int> > Black;
set<pair<int, int> >::iterator itW;
set<pair<int, int> >::iterator itB;
bool mark[MAX_N];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int color, s;
cin >> color >> s;
if (color)
Black.insert(make_pair(s, i + 1));
else
White.insert(make_pair(s, i + 1));
}
int head = 0;
while (head < n - 1) {
itW = White.begin();
itB = Black.begin();
pair<int, int> B = *itB, W = *itW;
int tmp = 0;
if (B.first <= W.first) {
if (B.first == W.first) tmp = 1;
e[head].v = B.second;
e[head].u = W.second;
e[head].w = B.first;
Black.erase(B);
White.erase(W);
W.first -= B.first;
B.first = 0;
if (!tmp)
mark[B.second] = 1;
else {
if (White.size() < Black.size() + 1)
mark[B.second] = 1;
else
mark[W.second] = 1;
}
} else {
e[head].v = B.second;
e[head].u = W.second;
e[head].w = W.first;
Black.erase(B);
White.erase(W);
B.first -= W.first;
W.first = 0;
mark[W.second] = 1;
}
if (!mark[B.second]) Black.insert(B);
if (!mark[W.second]) White.insert(W);
head++;
}
for (int i = 0; i < head; i++)
cout << e[i].v << ' ' << e[i].u << ' ' << e[i].w << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v, u;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x)
v.push_back(make_pair(y, i + 1));
else
u.push_back(make_pair(y, i + 1));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
sort(u.begin(), u.end());
reverse(u.begin(), u.end());
int i = 0, j = 0;
bool f = 1;
for (int k = 0; k < n - 1; k++) {
int x = min(v[i].first, u[j].first);
printf("%d %d %d\n", v[i].second, u[j].second, x);
v[i].first -= x;
u[j].first -= x;
if (u[j].first == v[i].first) {
if (j == u.size() - 1) {
i++;
continue;
}
if (i == v.size() - 1) {
j++;
continue;
}
if (f)
j++;
else
i++;
f = !f;
continue;
}
if (v[i].first > u[j].first)
j++;
else
i++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct tagst {
int id, sum;
bool operator<(const tagst &sta) const { return sta.sum < sum; }
};
vector<tagst> g_v[100100];
int fa[100100], col[100100];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
int main() {
tagst sttmp, st[2];
int f[2];
int i, j, n;
scanf("%d", &n);
priority_queue<tagst> que[2];
for (i = 1; i <= n; i++) {
fa[i] = i;
scanf("%d%d", &col[i], &sttmp.sum);
sttmp.id = i;
que[col[i]].push(sttmp);
}
while (que[0].size() && que[1].size()) {
for (i = 0; i < 2; i++)
st[i] = que[i].top(), que[i].pop(), f[i] = find(st[i].id);
if (st[0].sum >= st[1].sum) {
st[0].sum -= st[1].sum;
fa[f[1]] = f[0];
g_v[st[0].id].push_back(st[1]);
if (st[0].sum) {
que[0].push(st[0]);
}
} else {
fa[f[0]] = f[1];
st[1].sum -= st[0].sum;
que[1].push(st[1]);
g_v[st[1].id].push_back(st[0]);
}
}
f[0] = find(1);
for (i = 1; i <= n; i++) {
if (f[0] != (f[1] = find(i))) {
if (col[i] != col[f[0]])
printf("%d %d 0\n", i, f[0]);
else
printf("%d %d 0\n", i, g_v[f[0]][0]);
fa[f[1]] = f[0];
}
for (j = 0; j < g_v[i].size(); j++) {
printf("%d %d %d\n", i, g_v[i][j].id, g_v[i][j].sum);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
struct Node {
int id;
long long val;
bool operator<(const Node &b) const { return val > b.val; }
};
struct Videge {
int fa, son;
long long w;
} v[maxn];
priority_queue<Node> pq1, pq2;
int main() {
int n, m, k;
long long a;
scanf("%d", &n);
Node md;
for (int i = 1; i <= n; i++) {
scanf("%d%I64dd", &k, &a);
md.id = i;
md.val = a;
if (k)
pq1.push(md);
else
pq2.push(md);
}
Node bi, wi;
m = n;
n - n - 1;
while (n--) {
wi = pq1.top();
pq1.pop();
bi = pq2.top();
pq2.pop();
if (wi.val < bi.val) {
v[n].fa = wi.id;
v[n].son = bi.id;
v[n].w = wi.val;
int r = bi.val - wi.val;
bi.val = r;
pq2.push(bi);
} else {
v[n].fa = bi.id;
v[n].son = wi.id;
v[n].w = bi.val;
int r = wi.val - bi.val;
wi.val = r;
pq1.push(wi);
}
}
for (int i = 1; i < m; i++) {
printf("%d %d %I64d\n", v[i].fa, v[i].son, v[i].w);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100010;
int n;
set<pair<int, int>, less<pair<int, int> > > W, B;
int nW, nB;
int main() {
scanf("%d", &n);
nW = 0;
nB = 0;
int cc, cs;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &cc, &cs);
if (cc == 0) {
W.insert(pair<int, int>(cs, i));
++nW;
} else {
B.insert(pair<int, int>(cs, i));
++nB;
}
}
pair<int, int> cW, cB;
for (int i = 0; i < n - 1; ++i) {
cW = (*W.begin());
cB = (*B.begin());
if (cW.first < cB.first or (cW.first == cB.first and nW >= nB)) {
W.erase(W.begin());
B.erase(B.begin());
B.insert(pair<int, int>(cB.first - cW.first, cB.second));
--nW;
printf("%d %d %d\n", cW.second + 1, cB.second + 1, cW.first);
} else {
W.erase(W.begin());
B.erase(B.begin());
W.insert(pair<int, int>(cW.first - cB.first, cW.second));
--nB;
printf("%d %d %d\n", cW.second + 1, cB.second + 1, cB.first);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct _nl {
} nl;
bool _ns = 0;
template <typename T>
void _p(const T& _) {
if constexpr (is_same<T, _nl>()) {
cout << "\n";
_ns = 0;
} else {
if (_ns) cout << " ";
cout << _;
_ns = 1;
}
}
template <typename... T>
void out(const T&... _) {
(_p(_), ...);
}
int ii() {
int _;
cin >> _;
return _;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
struct edge {
int from;
int to;
int w;
};
int n = ii();
vector<pair<int, int>> black;
vector<pair<int, int>> white;
vector<edge> ans;
for (int i = 0; i < n; i++) {
int clr = ii();
int w = ii();
if (clr == 0)
black.emplace_back(make_pair(i + 1, w));
else
white.emplace_back(make_pair(i + 1, w));
}
auto b = black.begin();
auto w = white.begin();
for (int i = 0; i < n - 1; i++) {
int bb = b->second;
int ww = w->second;
int rem = min(bb, ww);
ans.emplace_back(edge{b->first, w->first, rem});
b->second -= rem;
w->second -= rem;
if (bb < ww) {
b++;
} else if (bb > ww) {
w++;
} else {
if (distance(b, black.end()) > 1) {
b++;
} else
w++;
}
}
for (auto el : ans) {
out(el.from, el.to, el.w, nl);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> d[2];
int v[100010];
bool compare(int x, int y) { return v[x] < v[y]; }
vector<int> an;
int main() {
int i, j, k, n;
cin >> n;
for (i = 1; i <= n; i++) {
int ty;
cin >> ty >> v[i];
d[ty].push_back(i);
}
for (i = 0; i < 2; i++) sort(d[i].begin(), d[i].end(), compare);
i = j = 0;
while (1) {
if (i + 1 == d[0].size()) {
for (; j < d[1].size(); j++) {
an.push_back(d[0][i]);
an.push_back(d[1][j]);
an.push_back(v[d[1][j]]);
}
break;
} else if (j + 1 == d[1].size()) {
for (; i < d[0].size(); i++) {
an.push_back(d[0][i]);
an.push_back(d[1][j]);
an.push_back(v[d[0][i]]);
}
break;
} else if (v[d[0][i]] <= v[d[1][j]]) {
an.push_back(d[0][i]);
an.push_back(d[1][j]);
an.push_back(v[d[0][i]]);
v[d[1][j]] -= v[d[0][i]];
i++;
} else {
an.push_back(d[0][i]);
an.push_back(d[1][j]);
an.push_back(v[d[1][j]]);
v[d[0][i]] -= v[d[1][j]];
j++;
}
}
for (i = 0; i < an.size(); i += 3)
printf("%d %d %d\n", an[i], an[i + 1], an[i + 2]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const long long mod = (119 << 23) + 1;
const long long M = 1e9 + 7;
const long long N = 1e5 + 5;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(15);
long long n;
cin >> n;
stack<pair<long long, long long> > a, b;
for (long long i = 1; i <= n; ++i) {
long long c, s;
cin >> c >> s;
if (c)
a.push({i, s});
else
b.push({i, s});
}
ostringstream oss;
long long ar = a.top().first, br = b.top().first;
bool flag = false;
for (long long i = 0; i < n - 1; ++i) {
if (a.empty()) {
if (!flag) {
flag = true;
b.pop();
--i;
continue;
}
oss << ar << ' ' << b.top().first << ' ' << 0 << '\n';
b.pop();
} else if (b.empty()) {
if (!flag) {
flag = true;
a.pop();
--i;
continue;
}
oss << a.top().first << ' ' << br << ' ' << 0 << '\n';
a.pop();
} else {
if (a.top().second < b.top().second) {
oss << a.top().first << ' ' << b.top().first << ' ' << a.top().second
<< '\n';
b.top().second -= a.top().second;
a.pop();
} else {
oss << a.top().first << ' ' << b.top().first << ' ' << b.top().second
<< '\n';
a.top().second -= b.top().second;
b.pop();
}
}
}
cout << oss.str();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100000 + 5;
int N, val[MX];
vector<int> cmp[2];
int main() {
scanf("%d", &N);
for (int i = 1, u; i <= N; i++) {
scanf("%d%d", &u, &val[i]);
cmp[u].push_back(i);
}
int i = 0, j = 0;
for (int k = 1; k < N; k++) {
int u = cmp[0][i], b = cmp[1][j];
int x = min(val[u], val[b]);
val[u] -= x;
val[b] -= x;
if (!val[u] && i + 1 < (int)cmp[0].size())
i++;
else
j++;
printf("%d %d %d\n", u, b, x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005];
vector<pair<int, int> > v[2];
int main() {
int n, c, d;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d %d", &c, &d);
v[c].push_back(make_pair(i + 1, d));
}
int i1 = 0, i2 = 0;
for (int i = 1; i < n; i++) {
d = min(v[0][i1].second, v[1][i2].second);
printf("%d %d %d\n", v[0][i1].first, v[1][i2].first, d);
v[1][i2].second -= d;
v[0][i1].second -= d;
if (i1 == v[0].size() - 1)
i2++;
else if (i2 == v[1].size() - 1)
i1++;
else if (v[0][i1].second < v[1][i2].second)
i1++;
else
i2++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct wie {
int s, nr;
};
struct kraw {
int a, b, c;
};
bool por(wie a, wie b) {
if (a.s < b.s) return true;
if (a.s > b.s) return false;
return a.nr < b.nr;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<vector<wie> > a(2);
vector<int> sumaZer0, sumaZer1;
for (int i = 0; i < n; ++i) {
int c, s;
cin >> c >> s;
if (s != 0)
a[c].push_back({s, i});
else {
if (c == 0)
sumaZer0.push_back(i);
else
sumaZer1.push_back(i);
}
}
if (sumaZer0.size() + sumaZer1.size() == n) {
for (int i = 0; i < sumaZer1.size(); ++i)
cout << sumaZer0[0] + 1 << " " << sumaZer1[i] + 1 << " 0" << endl;
for (int i = 1; i < sumaZer0.size(); ++i)
cout << sumaZer0[i] + 1 << " " << sumaZer1[0] + 1 << " 0" << endl;
return 0;
}
sort(a[0].begin(), a[0].end(), por);
sort(a[1].begin(), a[1].end(), por);
vector<kraw> odp;
vector<int> r0, r1;
for (int i = 0, j = 0; i < a[0].size() && j < a[1].size();) {
if (a[0][i].s < a[1][j].s) {
odp.push_back({a[0][i].nr, a[1][j].nr, a[0][i].s});
a[1][j].s -= a[0][i].s;
++i;
continue;
}
if (a[1][j].s < a[0][i].s) {
odp.push_back({a[0][i].nr, a[1][j].nr, a[1][j].s});
a[0][i].s -= a[1][j].s;
++j;
continue;
}
odp.push_back({a[0][i].nr, a[1][j].nr, a[0][i].s});
r0.push_back(a[0][i].nr);
r1.push_back(a[1][j].nr);
++i;
++j;
}
for (int i = 0; i < odp.size(); ++i)
cout << odp[i].a + 1 << " " << odp[i].b + 1 << " " << odp[i].c << endl;
for (int i = 1; i < r1.size(); ++i)
cout << r0[0] + 1 << " " << r1[i] + 1 << " 0" << endl;
for (int i = 0; i < sumaZer0.size(); ++i)
cout << sumaZer0[i] + 1 << " " << a[1][0].nr + 1 << " 0" << endl;
for (int i = 0; i < sumaZer1.size(); ++i)
cout << sumaZer1[i] + 1 << " " << a[0][0].nr + 1 << " 0" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100010], c[100010], vis[100010];
vector<int> edge[100010];
void dfs(int v) {
if (vis[v]) return;
vis[v] = 1;
for (auto u : edge[v]) {
dfs(u);
}
}
int main() {
int n;
scanf("%d", &n);
priority_queue<pair<int, int>> s[2];
int pv[2] = {-1, -1};
for (int i = 0; i < n; i++) {
scanf("%d%d", &c[i], &a[i]);
s[c[i]].push(make_pair(-a[i], i));
pv[c[i]] = i;
}
vector<pair<int, pair<int, int>>> ans;
while (!s[0].empty() && !s[1].empty()) {
int nol = -s[0].top().first;
int satu = -s[1].top().first;
int u = s[0].top().second;
int v = s[1].top().second;
s[0].pop();
s[1].pop();
ans.push_back(make_pair(min(nol, satu), make_pair(u, v)));
edge[u].push_back(v);
edge[v].push_back(u);
if (nol < satu)
s[1].push(make_pair(nol - satu, v));
else
s[0].push(make_pair(satu - nol, u));
}
for (int i = 0; i < 2; i++) {
dfs(pv[i]);
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
ans.push_back(make_pair(0, make_pair(i, pv[!c[i]])));
dfs(i);
}
}
for (auto p : ans) {
printf("%d %d %d\n", p.second.first + 1, p.second.second + 1, p.first);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const int oo = 1e9 + 5;
int du[] = {-1, 0, 0, 1};
int dv[] = {0, -1, 1, 0};
const long long mod = 1e9 + 7;
long long sqr(long long x) { return x * x; }
struct data {
int u, v, w;
data(int U = 0, int V = 0, int W = 0) {
u = U;
v = V;
w = W;
}
} edge[N + 5];
int n, s[N + 5], cnt;
vector<pair<int, int> > q1, q2;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
int k;
cin >> k >> s[i];
if (k == 1)
q1.push_back({s[i], i});
else
q2.push_back({s[i], i});
}
sort(q1.begin(), q1.end());
sort(q2.begin(), q2.end());
int vt1 = 0, vt2 = 0;
while (vt1 < q1.size() && vt2 < q2.size()) {
if (q1[vt1].first < q2[vt2].first) {
int u = q1[vt1].second, v = q2[vt2].second;
edge[++cnt] = data(u, v, s[u]);
s[v] -= s[u];
s[u] = 0;
q2[vt2].first = s[v];
vt1++;
} else {
int u = q1[vt1].second, v = q2[vt2].second;
edge[++cnt] = data(u, v, s[v]);
s[u] -= s[v];
s[v] = 0;
q1[vt1].first = s[u];
vt2++;
}
}
if (vt1 >= q1.size())
for (int i = vt2 + 1; i < q2.size(); i++)
edge[++cnt] = data(q1[vt1 - 1].second, q2[i].second, 0);
if (vt2 >= q2.size())
for (int i = vt1 + 1; i < q1.size(); i++)
edge[++cnt] = data(q1[i].second, q2[vt2 - 1].second, 0);
for (int i = 1; i < n; i++)
cout << edge[i].u << " " << edge[i].v << " " << edge[i].w << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > a;
vector<pair<int, int> > b;
vector<int> L[100100];
int v[100100];
int dfs(int x, int p) {
int ret = v[x];
for (vector<int>::iterator it = L[x].begin(); it < L[x].end(); it++) {
int u = dfs(*it, x);
printf("%d %d %d\n", x + 1, *it + 1, u);
ret -= u;
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int c;
scanf("%d%d", &c, v + i);
if (c == 0)
a.push_back(pair<int, int>(i, v[i]));
else
b.push_back(pair<int, int>(i, v[i]));
}
int pa = 0, push_back = 0;
int r = 0;
for (int i = 0; i < n - 1; i++) {
;
if ((a[pa].second < b[push_back].second) ||
(a[pa].second == b[push_back].second && push_back == b.size() - 1)) {
L[b[push_back].first].push_back(a[pa].first);
b[push_back].second -= a[pa].second;
r = b[push_back].first;
pa++;
} else {
L[a[pa].first].push_back(b[push_back].first);
a[pa].second -= b[push_back].second;
r = a[pa].first;
push_back++;
}
};
dfs(r, r);
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
set<pair<int, int> > white;
set<pair<int, int> > black;
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
int c, s;
scanf("%d%d", &c, &s);
if (c == 0)
white.insert(make_pair(s, i + 1));
else
black.insert(make_pair(s, i + 1));
}
while (white.size() + black.size() > 1) {
pair<int, int> w = *(white.begin());
pair<int, int> b = *(black.begin());
white.erase(white.begin());
black.erase(black.begin());
if (w.first < b.first ||
w.first == b.first && black.size() < white.size()) {
printf("%d %d %d\n", w.second, b.second, w.first);
black.insert(make_pair(b.first - w.first, b.second));
} else {
printf("%d %d %d\n", w.second, b.second, b.first);
white.insert(make_pair(w.first - b.first, w.second));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
vector<pair<int, int> > edge[200005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<pair<int, int> > v[2];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(pair<int, int>(b, i + 1));
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
int cnt = 0, pnt = 0;
while (cnt < v[0].size() && pnt < v[1].size()) {
if (v[0][cnt].first < v[1][pnt].first) {
v[1][pnt].first -= v[0][cnt].first;
edge[v[0][cnt].second].push_back(
pair<int, int>(v[1][pnt].second, v[0][cnt].first));
cnt++;
} else {
v[0][cnt].first -= v[1][pnt].first;
edge[v[1][pnt].second].push_back(
pair<int, int>(v[0][cnt].second, v[1][pnt].first));
pnt++;
}
}
cnt++;
pnt++;
while (cnt < v[0].size()) {
edge[v[0][cnt].second].push_back(pair<int, int>(v[1][0].second, 0));
cnt++;
}
while (pnt < v[1].size()) {
edge[v[1][pnt].second].push_back(pair<int, int>(v[0][0].second, 0));
pnt++;
}
for (int i = 1; i <= n; i++)
for (auto it : edge[i])
cout << i << " " << it.first << " " << it.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[2];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int t, k;
scanf("%d%d", &t, &k);
v[t].push_back(make_pair(k, i));
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
for (int i = 0, j = 0; i < v[0].size() && j < v[1].size();) {
int k = min(v[0][i].first, v[1][j].first);
printf("%d %d %d\n", v[0][i].second, v[1][j].second, k);
v[0][i].first -= k, v[1][j].first -= k;
if (v[0][i].first)
j++;
else if (v[1][j].first)
i++;
else if (i + 1 < v[0].size())
i++;
else
j++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
struct ky {
int u, val;
bool operator<(const ky &p) const { return val < p.val; }
} a[N], b[N];
int n, ca, cb, ci, vali;
bool tg[N];
inline void fr(int &num) {
num = 0;
char c = getchar();
int p = 1;
while (c < '0' || c > '9') c == '-' ? p = -1, c = getchar() : c = getchar();
while (c >= '0' && c <= '9') num = num * 10 + c - '0', c = getchar();
num *= p;
}
int main() {
fr(n);
for (register int i = 1; i <= n; ++i)
fr(ci), fr(vali), ci ? a[++ca] = (ky){i, vali} : b[++cb] = (ky){i, vali};
sort(a + 1, a + 1 + ca), sort(b + 1, b + 1 + cb);
register int i = 1, j = 1, minn;
while (i <= ca && j <= cb)
minn = (a[i].val < b[j].val ? a[i].val : b[j].val),
printf("%d %d %d\n", a[i].u, b[j].u, minn), a[i].val -= minn,
b[j].val -= minn, tg[a[i].u] = tg[b[j].u] = true, !a[i].val ? ++i : ++j;
while (i <= ca) {
if (!tg[a[i].u]) printf("%d %d 0\n", a[i].u, b[1].u), tg[a[i].u] = 1;
++i;
}
while (j <= cb) {
if (!tg[b[j].u]) printf("%d %d 0\n", a[1].u, b[j].u), tg[b[j].u] = 1;
++j;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > white, black;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int c, s;
cin >> c >> s;
if (c) {
black.push_back(make_pair(s, i + 1));
} else {
white.push_back(make_pair(s, i + 1));
}
}
sort(black.begin(), black.end());
sort(white.begin(), white.end());
int p_b = 0, p_w = 0;
while (p_b < black.size() && p_w < white.size()) {
cout << black[p_b].second << " " << white[p_w].second << " ";
if (black[p_b].first < white[p_w].first) {
cout << black[p_b].first << endl;
pair<int, int>& p = white[p_w];
p.first -= black[p_b].first;
p_b++;
} else {
cout << white[p_w].first << endl;
pair<int, int>& p = black[p_b];
p.first -= white[p_w].first;
p_w++;
}
}
if (p_b < black.size()) {
p_b++;
while (p_b < black.size()) {
cout << white[0].second << " " << black[p_b++].second << " 0" << endl;
}
}
if (p_w < white.size()) {
p_w++;
while (p_w < white.size()) {
cout << black[0].second << " " << white[p_w++].second << " 0" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long sw[100001], sb[100001];
int ind[2][100001];
void printE(int u, int v, unsigned long long w) {
int ui = ind[1][u];
int vi = ind[0][v];
cout << ui + 1 << " " << vi + 1 << " " << w << endl;
}
int main() {
int n;
cin >> n;
int nw = 0, nb = 0;
int c;
unsigned long long s;
for (int i = 0; i < n; i++) {
cin >> c >> s;
if (c == 0) {
sw[nw] = s;
ind[0][nw] = i;
nw++;
} else if (c == 1) {
sb[nb] = s;
ind[1][nb] = i;
nb++;
}
}
int cl = 0;
int ib = 0;
int iw = 0;
while (1) {
if (sb[ib] > sw[iw]) {
sb[ib] = sb[ib] - sw[iw];
printE(ib, iw, sw[iw]);
iw++;
cl = 1;
} else {
sw[iw] = sw[iw] - sb[ib];
printE(ib, iw, sb[ib]);
ib++;
cl = 0;
}
if (iw >= nw || ib >= nb) break;
}
if (cl == 1) {
for (int i = ib + 1; i < nb; i++) {
printE(i, iw - 1, 0);
}
} else {
for (int i = iw + 1; i < nw; i++) {
printE(ib - 1, i, 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, c[200001], p[200001];
vector<pair<int, int> > g[3];
int getp(int v) {
if (p[v] == v) return v;
return p[v] = getp(p[v]);
}
void unite(int a, int b) {
a = getp(a);
b = getp(b);
p[a] = b;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &c[i], &d);
g[c[i]].push_back(make_pair(i, d));
p[i] = i;
}
sort(g[0].begin(), g[0].end());
sort(g[1].begin(), g[1].end());
int l = 0, r = 0;
while (l != g[0].size() && r != g[1].size()) {
int k = min(g[1][r].second, g[0][l].second);
;
cout << g[0][l].first << ' ' << g[1][r].first << ' ' << k << endl;
g[0][l].second -= k;
g[1][r].second -= k;
unite(g[0][l].first, g[1][r].first);
if (!g[0][l].second) l++;
if (!g[1][r].second) r++;
}
for (int i = 1; i <= n; ++i) {
if (!c[i]) {
if (getp(i) != getp(g[1][0].first)) {
cout << i << ' ' << g[1][0].first << " 0\n";
unite(i, g[1][0].first);
}
} else {
if (getp(i) != getp(g[0][0].first)) {
cout << i << ' ' << g[0][0].first << " 0\n";
unite(i, g[0][0].first);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
int a, b, s, N, S[100100], C[100100], A[100100], B[100100];
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
for (int(i) = 1; (i) <= (N); (i)++) {
cin >> C[i] >> S[i];
if (C[i])
A[++A[0]] = i;
else
B[++B[0]] = i;
}
a = b = 1;
while (a <= A[0] && b <= B[0]) {
s = min(S[A[a]], S[B[b]]);
cout << A[a] << " " << B[b] << " " << s << endl;
if (a == A[0] && b == B[0]) return 0;
if (s < S[A[a]]) {
b++;
S[A[a]] -= s;
} else if (s < S[B[b]]) {
a++;
S[B[b]] -= s;
} else if (a == A[0]) {
b++;
S[A[a]] -= s;
} else {
a++;
S[B[b]] -= s;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
int N, a, b, A[100100], B[100100], S[100100], C[100100];
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
for (int(i) = 1; (i) <= (N); (i)++) {
cin >> C[i] >> S[i];
if (C[i])
A[++A[0]] = i;
else
B[++B[0]] = i;
}
b = 1;
for (int(a) = 1; (a) <= (A[0]); (a)++) {
if (b > B[0]) cout << A[a] << " " << B[1] << " " << 0 << endl;
while (b <= B[0]) {
if (S[A[a]] < S[B[b]]) {
cout << A[a] << " " << B[b] << " " << S[A[a]] << endl;
S[B[b]] -= S[A[a]];
break;
} else {
cout << A[a] << " " << B[b] << " " << S[B[b]] << endl;
S[A[a]] -= S[B[b]];
b++;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct df {
int dq, bh;
} hd[100010], bd[100010];
int lh = 0, lb = 0;
int n;
bool px(df a, df b) { return a.dq < b.dq; }
int main() {
cin >> n;
int tmp1;
for (int i = 0; i < n; i++) {
cin >> tmp1;
if (tmp1) {
cin >> hd[lh].dq;
hd[lh].bh = i + 1;
lh++;
} else {
cin >> bd[lb].dq;
bd[lb].bh = i + 1;
lb++;
}
}
sort(hd, hd + lh, px);
sort(bd, bd + lb, px);
int sh = 0, sb = 0, js = 0;
while (sh < lh || sb < lb) {
if (sh == lh && js < n - 1) {
sb++;
cout << hd[0].bh << ' ' << bd[sb].bh << ' ' << 0;
js++;
}
if (sb == lb && js < n - 1) {
sh++;
cout << hd[sh].bh << ' ' << bd[0].bh << ' ' << 0 << endl;
js++;
}
if (js == n - 1) break;
if (sh < lh && sb < lb)
if (hd[sh].dq < bd[sb].dq) {
js++;
cout << hd[sh].bh << ' ' << bd[sb].bh << ' ' << hd[sh].dq << endl;
bd[sb].dq -= hd[sh].dq;
hd[sh].dq = 0;
sh++;
} else {
js++;
cout << hd[sh].bh << ' ' << bd[sb].bh << ' ' << bd[sb].dq << endl;
hd[sh].dq -= bd[sb].dq;
bd[sb].dq = 0;
sb++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int n, c, s;
if (scanf("%d", &n) == EOF) return false;
deque<pair<int, int> > z0, z1;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &c, &s);
if (c)
z1.push_back(make_pair(s, i));
else
z0.push_back(make_pair(s, i));
}
for (int i = 1; i < n; ++i) {
pair<int, int> ss0 = z0.front(), ss1 = z1.front();
z0.pop_front();
z1.pop_front();
int cost = min(ss0.first, ss1.first);
if (ss0.first < ss1.first ||
ss0.first == ss1.first && z1.size() < z0.size())
z1.push_front(make_pair(ss1.first - cost, ss1.second));
else
z0.push_front(make_pair(ss0.first - cost, ss0.second));
printf("%d %d %d\n", ss0.second + 1, ss1.second + 1, cost);
}
return true;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[2][100010];
bool used[100010];
int fat[100010];
int main() {
int i, j, c, v;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d", &c, &v);
a[c][++a[c][0].first] = make_pair(v, i);
}
sort(a[0] + 1, a[0] + a[0][0].first + 1);
sort(a[1] + 1, a[1] + a[1][0].first + 1);
i = j = 1;
for (int t = 1; t < n; t++) {
int tmp = min(a[0][i].first, a[1][j].first);
printf("%d %d %d\n", a[0][i].second, a[1][j].second, tmp);
a[0][i].first -= tmp, a[1][j].first -= tmp;
if (a[0][i].first)
j++;
else if (a[1][j].first)
i++;
else if (i < a[0][0].first)
i++;
else
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
int n;
vector<pair<int, int> > B;
vector<pair<int, int> > W;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int c = read(), s = read();
if (c)
B.push_back(make_pair(s, i));
else
W.push_back(make_pair(s, i));
}
sort(B.begin(), B.end());
sort(W.begin(), W.end());
for (int l = 0, r = 0; l < B.size() && r < W.size();) {
int w = min(B[l].first, W[r].first);
printf("%d %d %d\n", B[l].second, W[r].second, w);
B[l].first -= w, W[r].first -= w;
if (B[l].first == W[r].first && B[l].first == 0) {
if (l + 1 < B.size())
l++;
else
r++;
continue;
}
if (!B[l].first)
l++;
else
r++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
int a, n;
int sum[MAXN];
int main() {
vector<pair<int, int> > black;
vector<pair<int, int> > white;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &a, &sum[i]);
if (a == 0)
white.push_back(make_pair(sum[i], i));
else
black.push_back(make_pair(sum[i], i));
}
sort(white.begin(), white.end());
sort(black.begin(), black.end());
for (int i = 0, j = 0; i < white.size() && j < black.size();) {
int wid = white[i].second;
int bid = black[j].second;
int msum = min(sum[wid], sum[bid]);
sum[wid] -= msum;
sum[bid] -= msum;
printf("%d %d %d\n", wid + 1, bid + 1, msum);
if (i + 1 == white.size())
++j;
else if (j + 1 == black.size())
++i;
else {
if (sum[wid] == 0)
++i;
else
++j;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100002;
struct node {
int id;
int val;
node(int ii = 0, int vv = 0) {
id = ii;
val = vv;
return;
}
} A[maxn], B[maxn];
bool vis[maxn];
int n, ca, cb;
void read() {
memset(vis, false, sizeof(vis));
ca = cb = 0;
int x, y;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
if (x == 0)
A[ca++] = node(i, y);
else
B[cb++] = node(i, y);
}
return;
}
void add(int a, int b) {
if (a == 0 && vis[b]) return;
if (a == 0) vis[b] = true;
printf("%d %d 0\n", A[a].id, B[b].id);
return;
}
void solve() {
int l = 0, r = 0;
for (; l < ca && r < cb; l++) {
while (l < ca && A[l].val == 0) add(l++, 0);
while (A[l].val) {
int tmp = ((A[l].val) < (B[r].val) ? (A[l].val) : (B[r].val));
A[l].val -= tmp;
B[r].val -= tmp;
printf("%d %d %d\n", A[l].id, B[r].id, tmp);
if (A[l].val) r++;
}
}
while (l < ca) add(l++, 0);
r++;
while (r < cb) add(0, r++);
return;
}
int main() {
while (~scanf("%d", &n)) {
read();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
template <class T>
void uniq(vector<T>& c) {
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
}
template <class T>
string to_s(const T& a) {
ostringstream os;
os << a;
return os.str();
}
template <class T>
T to_T(const string& s) {
istringstream is(s);
T res;
is >> res;
return res;
}
template <class T, class U>
ostream& operator<<(ostream& os, pair<T, U>& p) {
os << "( " << p.first << ", " << p.second << " )";
return os;
}
template <class T>
void print(T a, int n, const string& deli = " ", int br = 1) {
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 != n) cout << deli;
}
while (br--) cout << endl;
}
template <class T>
void print(const T& c, const string& deli = " ", int br = 1) {
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it) {
cout << *it;
if (++it != c.end()) cout << deli;
--it;
}
while (br--) cout << endl;
}
template <class T>
void print2d(T a, int w, int h, int width = -1, int br = 1) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1) cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--) cout << endl;
}
template <class T>
void input(T& a, int n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
template <class T>
void input(T* a, int n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
void fix_pre(int n) {
cout.setf(ios::fixed, ios::floatfield);
cout.precision(10);
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
bool valid(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const double PI = acos(-1.0);
const int mod = ((long long)(1e9)) + 7;
int main() {
int n;
vector<pair<int, int> > white, black;
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) {
int c, s;
scanf("%d%d", &c, &s);
(c == 0 ? white : black).push_back(pair<int, int>(s, i + 1));
}
sort((white).begin(), (white).end());
sort((black).begin(), (black).end());
for (int i = white.size() - 1, j = black.size() - 1;;) {
int w = min(white[i].first, black[j].first);
white[i].first -= w;
black[j].first -= w;
printf("%d %d %d\n", white[i].second, black[j].second, w);
if (i == 0 && j == 0) break;
if (white[i].first == 0 && i > 0)
--i;
else if (black[j].first == 0 && j > 0)
--j;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100000 + 10;
int c[M];
int s[M];
struct NODE {
int c;
int s;
int index;
bool operator<(const NODE& x) const { return s < x.s; }
};
vector<NODE> w;
vector<NODE> b;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> s[i];
NODE node;
node.c = c[i];
node.s = s[i];
node.index = i;
if (c[i] == 0) {
w.push_back(node);
} else {
b.push_back(node);
}
}
sort(w.begin(), w.end());
sort(b.begin(), b.end());
int sw = 0;
int sb = 0;
while (sb < b.size() && sw < w.size()) {
if (b[sb].s <= w[sw].s) {
cout << b[sb].index << " ";
cout << w[sw].index << " ";
cout << b[sb].s << endl;
w[sw].s = w[sw].s - b[sb].s;
sb++;
} else {
cout << b[sb].index << " ";
cout << w[sw].index << " ";
cout << w[sw].s << endl;
b[sb].s = b[sb].s - w[sw].s;
sw++;
}
}
if (sb < b.size() - 1) {
for (int i = sb + 1; i < b.size(); i++) {
cout << b[i].index << " " << w[w.size() - 1].index << " 0" << endl;
}
}
if (sw < w.size() - 1) {
for (int i = sw + 1; i < w.size(); i++) {
cout << w[i].index << " " << b[b.size() - 1].index << " 0" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Rec {
int v, nod;
} a[100005], b[100005];
int n, anum = 0, bnum = 0, flag[100005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int k, value;
scanf("%d%d", &k, &value);
if (k == 1) {
a[++anum].v = value;
a[anum].nod = i;
} else {
b[++bnum].v = value;
b[bnum].nod = i;
}
}
int i = 1, j = 1;
while (i <= anum && j <= bnum) {
cout << a[i].nod << ' ' << b[j].nod << ' ' << min(a[i].v, b[j].v) << endl;
int k = min(a[i].v, b[j].v);
a[i].v -= k;
b[j].v -= k;
flag[a[i].nod] = flag[b[j].nod] = 1;
if (a[i].v == 0)
i++;
else
j++;
}
for (; i <= anum; i++) {
if (!flag[a[i].nod]) cout << a[i].nod << ' ' << b[1].nod << " 0" << endl;
}
for (; j <= bnum; j++) {
if (!flag[b[j].nod]) cout << b[j].nod << ' ' << a[1].nod << " 0" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
vector<pair<int, int> > white, black;
void solve() {
int wi = 0, bi = 0;
while (wi < white.size() && bi < black.size()) {
int &wa = white[wi].first, &wb = black[bi].first;
int minn = min(wa, wb);
wa -= minn, wb -= minn;
printf("%d %d %d\n", white[wi].second, black[bi].second, minn);
if (wb == 0) {
if (bi < black.size() - 1)
bi++;
else
wi++;
} else
wi++;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int col, w;
scanf("%d%d", &col, &w);
if (!col)
white.push_back(pair<int, int>(w, i));
else
black.push_back(pair<int, int>(w, i));
}
sort(white.begin(), white.end());
sort(black.begin(), black.end());
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int id, val;
bool operator<(const node& a) const { return val < a.val; }
};
int main() {
int n;
scanf("%d", &n);
multiset<node> p, q;
node tmp;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
tmp.id = i;
tmp.val = y;
if (x == 0)
q.insert(tmp);
else
p.insert(tmp);
}
while (!q.empty()) {
node x = *q.begin();
q.erase(q.begin());
node y = *(--p.end());
p.erase((--p.end()));
printf("%d %d %d\n", x.id, y.id, x.val > y.val ? y.val : x.val);
if (x.val > y.val) {
tmp.id = x.id, tmp.val = x.val - y.val;
q.insert(tmp);
} else if (x.val < y.val) {
tmp.id = y.id, tmp.val = y.val - x.val;
p.insert(tmp);
} else {
if (!p.empty()) {
tmp.id = x.id, tmp.val = 0;
q.insert(tmp);
} else if (!q.empty()) {
tmp.id = y.id, tmp.val = 0;
p.insert(tmp);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 1e9 + 7;
long long int inf = 1e18;
long long int n, m;
long long int binpow(long long int val, long long int deg) {
if (deg < 0) return 0;
if (!deg) return 1 % M;
if (deg & 1) return binpow(val, deg - 1) * val % M;
long long int res = binpow(val, deg >> 1);
return (res * res) % M;
}
long long int modinv(long long int n) { return binpow(n, M - 2); }
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, j, t, k, x, y, z, N;
cin >> n;
vector<pair<long long int, long long int>> black, white;
for (long long int i = 0; i < n; i++) {
cin >> x >> y;
if (x == 1) {
black.push_back({y, i});
} else {
white.push_back({y, i});
}
}
sort(black.begin(), black.end());
sort(white.begin(), white.end());
reverse(black.begin(), black.end());
;
reverse(white.begin(), white.end());
;
vector<tuple<long long int, long long int, long long int>> edge;
i = 0;
j = 0;
long long int cnt = 0;
long long int rem = 0;
rem += black[i].first;
while (i < black.size() && j < white.size()) {
if (cnt == 0) {
while (white[j].first < rem) {
rem -= white[j].first;
edge.push_back({black[i].second, white[j].second, white[j].first});
j++;
}
edge.push_back({black[i].second, white[j].second, rem});
rem = white[j].first - rem;
if (rem == 0) {
while (white[j + 1].first == 0 && j + 1 < white.size()) {
edge.push_back({black[i].second, white[j + 1].second, 0});
j++;
}
}
i++;
} else {
while (black[i].first < rem) {
rem -= black[i].first;
edge.push_back({white[j].second, black[i].second, black[i].first});
i++;
}
edge.push_back({white[j].second, black[i].second, rem});
rem = black[i].first - rem;
if (rem == 0) {
while (black[i + 1].first == 0 && i + 1 < black.size()) {
edge.push_back({white[j].second, black[i + 1].second, 0});
i++;
}
}
j++;
}
cnt ^= 1;
}
for (auto u : edge) {
tie(x, y, z) = u;
cout << x + 1 << " " << y + 1 << " " << z << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5);
int n, c[N], second[N], xx, yy;
multiset<pair<int, int> > st[3];
pair<int, int> a, b;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &second[i]);
st[c[i]].insert(make_pair(second[i], i));
if (c[i] == 1)
xx = i;
else
yy = i;
}
int x, y;
for (int i = 1; i < n; i++) {
if (int(st[0].size()) > 0) {
a = *(st[0].begin());
x = a.first;
st[0].erase(st[0].begin());
} else {
x = 0;
a.second = yy;
}
if (int(st[1].size()) > 0) {
b = *(st[1].begin());
y = b.first;
st[1].erase(st[1].begin());
} else {
y = 0;
b.second = xx;
}
if (x < y) {
st[1].insert(make_pair(y - x, b.second));
} else if (y < x) {
st[0].insert(make_pair(x - y, a.second));
} else if (st[0].size() > st[1].size()) {
st[1].insert(make_pair(y - x, b.second));
} else
st[0].insert(make_pair(x - y, a.second));
printf("%d %d %d\n", a.second, b.second, min(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, s;
cin >> n;
vector<int> a[2], l[2];
for (int(i) = 0; (i) < (int)(n); ++(i)) {
cin >> c >> s;
a[c].push_back(s);
l[c].push_back(i + 1);
}
int p, q;
p = 0;
q = 0;
while (p < a[0].size() && q < a[1].size()) {
if (a[0][p] > a[1][q]) {
a[0][p] -= a[1][q];
cout << l[0][p] << ' ' << l[1][q] << ' ' << a[1][q] << endl;
a[1][q] = 0;
q++;
} else {
a[1][q] -= a[0][p];
cout << l[0][p] << ' ' << l[1][q] << ' ' << a[0][p] << endl;
a[0][p] = 0;
p++;
}
}
p++;
q++;
while (p < a[0].size()) {
cout << l[0][p] << ' ' << l[1][a[1][a[1].size() - 1]] << 0 << endl;
p++;
}
while (q < a[1].size()) {
cout << l[0][a[0][a[0].size() - 1]] << ' ' << l[1][q] << ' ' << 0 << endl;
q++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct Rec {
int v, id;
} a[100005], b[100005];
int n, anum = 0, bnum = 0, flag[100005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int k, value;
scanf("%d%d", &k, &value);
if (k == 1) {
a[++anum].v = value;
a[anum].id = i;
} else {
b[++bnum].v = value;
b[bnum].id = i;
}
}
int i = 1, j = 1;
while (i <= anum && j <= bnum) {
cout << a[i].id << ' ' << b[j].id << ' ' << min(a[i].v, b[j].v) << endl;
int k = min(a[i].v, b[j].v);
a[i].v -= k;
b[j].v -= k;
flag[a[i].id] = flag[b[j].id] = 1;
if (a[i].v == 0)
i++;
else
j++;
}
for (; i <= anum; i++) {
if (!flag[a[i].id]) cout << a[i].id << ' ' << b[1].id << " 0" << endl;
}
for (; j <= bnum; j++) {
if (!flag[b[j].id]) cout << b[j].id << ' ' << a[1].id << " 0" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
int N, A[100100], B[100100], S[100100], C[100100];
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
for (int(i) = 1; (i) <= (N); (i)++) {
cin >> C[i] >> S[i];
if (C[i])
A[++A[0]] = i;
else
B[++B[0]] = i;
}
int b = 1;
for (int(a) = 1; (a) <= (A[0]); (a)++) {
if (b > B[0]) cout << A[a] << " " << B[1] << " 0" << endl;
while (b <= B[0]) {
if (S[A[a]] < S[B[b]]) {
S[B[b]] -= S[A[a]];
cout << A[a] << " " << B[b] << " " << S[A[a]] << endl;
break;
} else {
S[A[a]] -= S[B[b]];
cout << A[a] << " " << B[b] << " " << S[B[b]] << endl;
b++;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e18;
long long int p = 1e9 + 7;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, y, x, z, w, g, key, l, r, n, m, t, k, d, val;
long long int t2, t3, t4, t1;
string s;
t = 1;
while (t--) {
cin >> n;
vector<pair<long long int, long long int>> b, w;
for (i = 0; i < n; i++) {
cin >> key >> x;
if (key == 0)
w.push_back(make_pair(x, i + 1));
else
b.push_back(make_pair(x, i + 1));
}
vector<pair<pair<long long int, long long int>, long long int>> ans;
sort(b.begin(), b.end());
sort(w.begin(), w.end());
long long int i1 = 0, i2 = 0, n1 = b.size(), n2 = w.size();
while (i1 < n1 && i2 < n2) {
t1 = b[i1].first;
t2 = w[i2].first;
t3 = b[i1].second;
t4 = w[i2].second;
if (t1 < t2) {
ans.push_back(make_pair(make_pair(t3, t4), t1));
w[i2].first -= t1;
i1++;
} else {
ans.push_back(make_pair(make_pair(t3, t4), t2));
b[i1].first -= t2;
val = t4;
i2++;
}
}
if (i2 == n2) {
i1++;
while (i1 != n1) {
ans.push_back(make_pair(make_pair(b[i1].second, val), 0));
i1++;
}
}
for (auto u : ans)
cout << u.first.first << " " << u.first.second << " " << u.second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long long mod = 1000000007;
const long long md = 1234567891;
const long long bil = 1000000000;
const char aa = 'a';
const double eps = 1E-9;
const int mil = 1000000;
const int ths = 1000;
const int maxn = 1001;
const int dr[] = {0, -1, 0, 1};
const int dc[] = {1, 0, -1, 0};
const int mxx = 32;
const int inf = (int)1E9;
template <typename T>
void printV(vector<T>& v) {
for (int i = 0; i < (int)(v.size()); i++) cout << v[i] << " ";
cout << endl;
}
template <typename T>
void printVs(vector<vector<T> >& v) {
for (int i = 0; i < (int)(v.size()); i++) printV(v[i]);
}
long long gcd(long long m, long long n) {
if (m == 0 || n == 0) return m + n;
return gcd(n, m % n);
}
const int mxn = 100001;
bool cmpf(vector<int> a, vector<int> b) { return (a[0] > b[0]); }
void run() {
int n;
int s[mxn];
int c[mxn];
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> c[i] >> s[i];
vector<vector<int> > A;
vector<vector<int> > B;
for (int i = 0; i < (int)(n); i++) {
vector<int> v(3);
v[0] = s[i];
v[1] = c[i];
v[2] = i;
if (c[i])
B.push_back(v);
else
A.push_back(v);
}
vector<vector<int> > res;
sort(A.begin(), A.end(), cmpf);
sort(B.begin(), B.end(), cmpf);
int a = A.size() - 1;
int b = B.size() - 1;
while (a >= 0 && b >= 0) {
int v = min(A[a][0], B[b][0]);
A[a][0] -= v;
B[b][0] -= v;
vector<int> e(3);
e[0] = A[a][2] + 1;
e[1] = B[b][2] + 1;
e[2] = v;
res.push_back(e);
if (A[a][0] == 0 && (a || b == 0))
--a;
else
--b;
}
for (int i = 0; i < (int)(res.size()); i++) printV(res[i]);
}
int main() { run(); }
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000")
#pragma warning(disable : 6031)
#pragma warning(disable : 4244)
#pragma warning(disable : 26451)
#pragma GCC target("sse4.2")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long mod = int(1e9) + 7;
const int INF = 1e9;
const long long LINF = 1e18;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << setprecision(18) << fixed;
int n;
cin >> n;
vector<pair<int, int>> b, w;
vector<pair<int, int>> zb, zw;
for (int i = 0; i < n; i++) {
int c, s;
cin >> c >> s;
if (c == 0) {
b.emplace_back(i, s);
} else {
w.emplace_back(i, s);
}
}
if ((int)(b).size() == 0) {
cout << w[0].first + 1 << " " << w[1].first + 1 << 0 << "\n";
return 0;
}
if ((int)(w).size() == 0) {
cout << b[0].first + 1 << " " << b[1].first + 1 << 0 << "\n";
return 0;
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pqw, pqb;
for (auto [i, s] : w) pqw.emplace(s, i);
for (auto [i, s] : b) pqb.emplace(s, i);
int cnt = 0;
vector<int> deg(n);
while (!pqw.empty() && !pqb.empty()) {
if ((int)(pqw).size() > (int)(pqb).size()) swap(pqw, pqb);
if (pqw.top().first < pqb.top().first) {
auto wp = pqw.top();
auto bp = pqb.top();
pqw.pop();
pqb.pop();
int dif = bp.first - wp.first;
cout << wp.second + 1 << " " << bp.second + 1 << " " << wp.first << "\n";
cnt++;
pqb.emplace(dif, bp.second);
deg[wp.second]++;
deg[bp.second]++;
} else if (pqw.top().first >= pqb.top().first) {
auto wp = pqw.top();
auto bp = pqb.top();
pqw.pop();
pqb.pop();
int dif = wp.first - bp.first;
cout << wp.second + 1 << " " << bp.second + 1 << " " << bp.first << "\n";
cnt++;
pqw.emplace(dif, wp.second);
deg[wp.second]++;
deg[bp.second]++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ASDF {
ASDF& operator,(int& a) {
scanf("%d", &a);
return *this;
}
ASDF& operator,(long int& a) {
scanf("%ld", &a);
return *this;
}
ASDF& operator,(long long int& a) {
scanf("%lld", &a);
return *this;
}
ASDF& operator,(char& c) {
scanf("%c", &c);
return *this;
}
ASDF& operator,(double& d) {
scanf("%lf", &d);
return *this;
}
template <typename T>
ASDF& operator,(T& a) {
cin >> a;
return *this;
}
} asdf;
template <typename T>
ostream& operator<<(ostream& output, vector<T>& v) {
output << "[ ";
if (int(v.size())) {
output << v[0];
}
for (int i = 1; i < int(v.size()); i++) {
output << ", " << v[i];
}
output << " ]";
return output;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& output, pair<T1, T2>& p) {
output << "( " << p.first << ", " << p.second << " )";
return output;
}
int main() {
int n;
set<pair<long long, int> > w, b;
int c;
long long s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c >> s;
if (c == 0) {
w.insert(make_pair(s, i));
} else {
b.insert(make_pair(s, i));
}
}
vector<pair<pair<int, int>, long long> > res;
while (!w.empty() && !b.empty()) {
pair<long long, int> wh = *w.begin(), bl = *b.begin();
w.erase(wh);
b.erase(bl);
long long mn = min(wh.first, bl.first);
wh.first -= mn;
bl.first -= mn;
res.push_back(make_pair(make_pair(wh.second, bl.second), mn));
if (wh.first || (!wh.first && !bl.first && int(w.size()) < int(b.size()))) {
w.insert(wh);
} else {
b.insert(bl);
}
}
for (vector<pair<pair<int, int>, long long> >::iterator it = res.begin();
it != res.end(); it++) {
cout << it->first.first + 1 << " " << it->first.second + 1 << " "
<< it->second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
int weight[MAXN], color[MAXN];
int N;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q[2];
int c0, c1;
int fat[MAXN];
int Find(int x);
void Join(int x, int y) {
int m = Find(x), n = Find(y);
fat[n] = m;
}
int Find(int x) {
if (fat[x] != x) {
fat[x] = Find(fat[x]);
}
return fat[x];
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> color[i] >> weight[i];
if (color[i] == 1)
c1 = i;
else
c0 = i;
}
for (int i = 1; i <= N; i++) fat[i] = i;
for (int i = 1; i <= N; i++) {
q[color[i]].push(make_pair(weight[i], i));
}
int c = 0;
while (c < N - 1) {
if (q[0].empty() || q[1].empty()) break;
pair<int, int> a = q[0].top();
pair<int, int> b = q[1].top();
q[0].pop();
q[1].pop();
if (a.first <= b.first) {
cout << a.second << " " << b.second << " " << a.first << endl;
b.first -= a.first;
q[1].push(b);
} else {
cout << a.second << " " << b.second << " " << b.first << endl;
a.first -= b.first;
q[0].push(a);
}
Join(a.second, b.second);
c++;
}
for (int i = 1; i <= N; i++) {
if (Find(i) != Find(1)) {
if (color[i] == 0) {
cout << i << " " << c1 << " " << 0 << endl;
Join(i, c1);
} else {
cout << i << " " << c0 << " " << 0 << endl;
Join(i, c0);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, LOG = 26, M = 110, INF = 1e9 + 10, sn = 320,
MOD = 1e9 + 7;
vector<pair<int, int> > v1, v2;
int n, v, c, cn1 = 0, cn2 = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c >> v;
if (c)
v2.push_back({v, i + 1});
else
v1.push_back({v, i + 1});
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
for (int i = 0, j = 0; i < v1.size() && j < v2.size();) {
int mn = min(v1[i].first, v2[j].first);
v1[i].first -= mn;
v2[j].first -= mn;
cout << v1[i].second << ' ' << v2[j].second << ' ' << mn << '\n';
if (v1[i].first || i == v1.size() - 1)
j++;
else
i++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, heap[2][100001], w[100001], top[2], t, m;
struct CMP {
bool operator()(int p, int q) { return w[p] > w[q]; }
};
int main() {
int a;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &a, &w[i]);
heap[a][top[a]++] = i;
}
make_heap(heap[0], heap[0] + top[0], CMP());
make_heap(heap[1], heap[1] + top[1], CMP());
for (i = 0; i < n - 1; i++) {
t = 0, m = w[heap[0][0]];
if (m > w[heap[1][0]]) t = 1, m = w[heap[1][0]];
if (!top[t]) t = 1 - t;
printf("%d %d %d\n", heap[t][0], heap[1 - t][max(0, top[1 - t] - 1)], m);
pop_heap(heap[t], heap[t] + top[t]--, CMP());
if (top[1 - t]) {
w[heap[1 - t][top[1 - t] - 1]] -= m;
push_heap(heap[1 - t], heap[1 - t] + top[1 - t], CMP());
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, cc, s, u[100001], v[100001], w[100001], nn, bb, ww, c[100001],
ds[100001];
set<pair<int, int>> bl, wh;
int dsu_get(int v) { return (v == ds[v]) ? v : (ds[v] = dsu_get(ds[v])); }
void dsu_union(int a, int b) {
a = dsu_get(a);
b = dsu_get(b);
if (a != b) ds[a] = b;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> cc >> s;
c[i] = cc;
if (cc == 1)
bl.insert(make_pair(i, s)), bb = i;
else
wh.insert(make_pair(i, s)), ww = i;
}
for (int i = 0; i < n; i++) ds[i] = i;
while (!bl.empty() && !wh.empty()) {
pair<int, int> bp = (*bl.begin()), wp = (*wh.begin());
int vich = min(bp.second, wp.second);
u[nn] = bp.first;
v[nn] = wp.first;
w[nn] = vich;
dsu_union(u[nn], v[nn]);
nn++;
bp.second -= vich;
wp.second -= vich;
bl.erase(bl.begin());
wh.erase(wh.begin());
bl.insert(bp);
wh.insert(wp);
if (bp.second == 0)
bl.erase(bl.begin());
else if (wp.second == 0)
wh.erase(wh.begin());
}
int r = dsu_get(ww);
for (int i = 0; i < n; i++)
if (dsu_get(i) != r && c[i] != c[ww]) {
u[nn] = i;
v[nn] = ww;
w[nn] = 0;
dsu_union(u[nn], v[nn]);
r = dsu_get(ww);
nn++;
}
r = dsu_get(bb);
for (int i = 0; i < n; i++)
if (dsu_get(i) != r && c[i] != c[bb]) {
u[nn] = i;
v[nn] = bb;
w[nn] = 0;
dsu_union(u[nn], v[nn]);
r = dsu_get(bb);
nn++;
}
for (int i = 0; i < nn; i++)
cout << u[i] + 1 << " " << v[i] + 1 << " " << w[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int ToInt(string& s, int len) {
int r = 0;
for (int i = 0, max_ = (len); i < max_; ++i) {
r *= 10;
r += s[i] - '0';
}
return r;
}
int GCD(int a, int b) { return b != 0 ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * (b / GCD(a, b)); }
long long Pow(long long n, long long e) {
if (e == 0) return 1;
if (e == 1)
return n;
else if (e & 1) {
long long t = Pow(n, e / 2);
return n * t * t;
} else {
long long t = Pow(n, e / 2);
return t * t;
}
}
int main() {
priority_queue<pair<int, int> > q1, q2;
int N, a, b, id1, id2;
scanf("%d", &N);
for (int i = 0, max_ = (N); i < max_; ++i) {
scanf("%d %d", &a, &b);
if (a == 0) {
q1.push(make_pair(b, i + 1));
id1 = i + 1;
} else {
q2.push(make_pair(b, i + 1));
id2 = i + 1;
}
}
pair<int, int> c, d;
for (int i = 0, max_ = (N - 1); i < max_; ++i) {
c = q1.top();
q1.pop();
d = q2.top();
q2.pop();
int m = min(c.first, d.first);
printf("%d %d %d\n", c.second, d.second, m);
c.first -= m;
d.first -= m;
if ((c.first == 0 && d.first != 0) ||
(c.first == 0 && d.first == 0 && q1.size() > q2.size()))
q2.push(d);
else
q1.push(c);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 100;
pair<int, bool> node[N];
queue<int> c[2];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> node[i].second >> node[i].first;
c[node[i].second].push(i);
}
for (int i = 0; i < n - 1; i++) {
int w = c[0].front(), b = c[1].front();
int m = min(node[w].first, node[b].first);
cout << w + 1 << ' ' << b + 1 << ' ' << m << '\n';
node[w].first -= m;
node[b].first -= m;
if (node[w].first < node[b].first)
c[0].pop();
else if (node[w].first > node[b].first)
c[1].pop();
else {
if (c[0].size() < c[1].size())
c[1].pop();
else
c[0].pop();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long mod = 1e9 + 7;
long long fmod(long long b, long long exp) {
long long res = 1;
while (exp) {
if (exp & 1ll) res = (res * b) % mod;
b = (b * b) % mod;
exp /= 2ll;
}
return res;
}
int st[N], en[N], w[N];
vector<int> v[2], A[2];
int x, y, len = 0;
int ind[2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1, n, i, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
A[x].push_back(i);
}
for (i = 0; i < n - 1; i++) {
int mn = min(v[0][ind[0]], v[1][ind[1]]);
v[0][ind[0]] -= mn;
v[1][ind[1]] -= mn;
st[len] = A[0][ind[0]];
en[len] = A[1][ind[1]];
w[len] = mn;
len++;
if (v[0][ind[0]] == 0 && ind[0] < (v[0].size() - 1))
ind[0]++;
else
ind[1]++;
}
for (i = 0; i < len; i++)
cout << st[i] + 1 << " " << en[i] + 1 << " " << w[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, c, sV;
queue<pair<int, int> > whites;
queue<pair<int, int> > blacks;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> c >> sV;
if (c) {
whites.push(make_pair(i + 1, sV));
} else {
blacks.push(make_pair(i + 1, sV));
}
}
for (int edge = 1; edge < n; ++edge) {
pair<int, int> w = whites.front();
whites.pop();
pair<int, int> b = blacks.front();
blacks.pop();
if (w.second > b.second ||
(w.second == b.second && whites.size() <= blacks.size())) {
cout << w.first << ' ' << b.first << ' ' << b.second << '\n';
w.second -= b.second;
whites.push(w);
} else {
cout << w.first << ' ' << b.first << ' ' << w.second << '\n';
b.second -= w.second;
blacks.push(b);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void _F(const char *name, T arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
const char *name = strchr(names, ',');
cerr.write(names, name - names) << " = " << arg1 << '\n';
_F(name + 2, args...);
}
const long long N = 1e5 + 1;
std::vector<long long> is(N);
vector<pair<long long, long long> > g[N];
long long c[N], black, white;
void dfs(long long v) {
is[v] = 1;
if (c[v])
white = v;
else
black = v;
for (auto u : g[v]) {
if (is[u.first]) continue;
dfs(u.first);
}
}
void solve() {
long long n;
cin >> n;
long long s[n];
bool vis[n];
set<long long> w, b;
for (long long i = 0; i < n; i++) {
vis[i] = 0;
cin >> c[i] >> s[i];
if (c[i])
w.insert(i);
else
b.insert(i);
}
for (long long i = 0; i < n; i++) {
if (vis[i]) continue;
queue<long long> q;
vis[i] = 1;
q.push(i);
if (c[i])
w.erase(i);
else
b.erase(i);
while (!q.empty()) {
long long v = q.front();
q.pop();
if (c[v]) {
std::vector<long long> temp;
for (auto u : b) {
if (!s[v]) break;
if (!vis[u]) {
vis[u] = 1;
long long wt = min(s[v], s[u]);
s[v] -= wt;
s[u] -= wt;
g[v].push_back({u, wt});
q.push(u);
}
if (!s[u]) temp.push_back(u);
}
for (auto u : temp) b.erase(u);
} else {
std::vector<long long> temp;
for (auto u : w) {
if (!s[v]) break;
if (!vis[u]) {
vis[u] = 1;
long long wt = min(s[v], s[u]);
s[v] -= wt;
s[u] -= wt;
g[v].push_back({u, wt});
q.push(u);
}
if (!s[u]) temp.push_back(u);
}
for (auto u : temp) w.erase(u);
}
}
}
bool f = 1;
pair<long long, long long> p = {-1, -1};
std::vector<long long> bb, ww;
for (long long i = 0; i < n; i++) {
if (is[i]) continue;
black = -1;
white = -1;
dfs(i);
if (black != -1 && white != -1 && f)
p = {black, white}, f = 0;
else if (black != -1)
bb.push_back(black);
else
ww.push_back(white);
}
if (p.first != -1) {
for (auto u : bb) g[p.second].push_back({u, 0});
for (auto u : ww) g[p.first].push_back({u, 0});
} else {
for (auto u : bb) {
g[ww[0]].push_back({u, 0});
}
for (long long i = 1; i < (long long)((ww).size()); i++)
g[bb[0]].push_back({ww[i], 0});
}
for (long long i = 0; i < n; i++) {
for (auto u : g[i]) {
cout << i + 1 << " " << u.first + 1 << " " << u.second << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
start = clock();
cout << fixed << setprecision(12);
for (long long i = 1; i <= t; ++i) {
solve();
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long int a[100005], c[100005];
long long int l[100005], r[100005];
int main() {
long long int n, i;
while (cin >> n) {
priority_queue<pair<long long int, long long int> > pq, pq1;
for (long long int i = 1; i < n + 1; i++) cin >> c[i] >> a[i];
for (i = 1; i <= n; i++) {
if (c[i] == 0)
pq.push(make_pair(-a[i], i));
else
pq1.push(make_pair(-a[i], i));
}
for (i = 1; i < n; i++) {
if (pq.size() == 0 || pq1.size() == 0) break;
pair<long long int, long long int> p = pq.top();
pair<long long int, long long int> p1 = pq1.top();
pq.pop();
pq1.pop();
p.first *= (-1);
p1.first *= (-1);
if (p.first < p1.first ||
(p.first == p1.first && pq1.size() < pq.size())) {
l[i] = p.second;
r[i] = p1.second;
c[i] = p.first;
p1.first -= p.first;
pq1.push(make_pair(-p1.first, p1.second));
} else if (p1.first < p.first ||
(p.first == p1.first && pq.size() <= pq1.size())) {
l[i] = p.second;
r[i] = p1.second;
c[i] = p1.first;
p.first -= p1.first;
pq.push(make_pair(-p.first, p.second));
}
}
for (i = 1; i < n; i++) cout << l[i] << " " << r[i] << " " << c[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, i, j, c, s, l, r;
vector<pair<int, int> > v, g, v1, g1;
vector<pair<pair<int, int>, int> > res;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> c >> s;
if (c == 0)
v.push_back(make_pair(s, i));
else
g.push_back(make_pair(s, i));
}
sort(v.begin(), v.end());
sort(g.begin(), g.end());
v1 = v;
g1 = g;
l = 0;
r = 0;
while (l < v.size() && r < g.size()) {
if (g[r].first >= v[l].first) {
res.push_back(make_pair(make_pair(v[l].second, g[r].second), v[l].first));
g[r].first -= v[l].first;
l++;
} else {
res.push_back(make_pair(make_pair(v[l].second, g[r].second), g[r].first));
v[l].first -= g[r].first;
r++;
}
}
while (r < g.size() - 1) {
r++;
res.push_back(make_pair(make_pair(v[l - 1].second, g[r].second), 0));
}
while (l < v.size() - 1) {
l++;
res.push_back(make_pair(make_pair(v[l].second, g[r - 1].second), 0));
}
sort(res.begin(), res.end());
for (i = 0; i < res.size(); i++)
cout << res[i].first.first << " " << res[i].first.second << " "
<< res[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 99;
int n, x, y, p, cnt, ans[N][3], g;
vector<pair<int, int> > v1, v2;
int main() {
cin >> n;
for (long long i = 1; i < n + 1; i++) {
cin >> x >> y;
if (x)
v2.push_back(make_pair(i, y));
else
v1.push_back(make_pair(i, y));
}
for (long long i = 0; i < v1.size(); i++) {
p--;
g = 1;
while (g || v1[i].second || (i == v1.size() - 1 && p < v2.size() - 1)) {
p++, g = 0;
ans[cnt][0] = v1[i].first;
ans[cnt][1] = v2[p].first;
ans[cnt++][2] = min(v1[i].second, v2[p].second);
int s = v1[i].second;
v1[i].second -= min(v1[i].second, v2[p].second);
v2[p].second -= min(s, v2[p].second);
}
}
for (long long i = 0; i < cnt; i++)
cout << ans[i][0] << " " << ans[i][1] << " " << ans[i][2] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int node_no;
int sum;
};
node B[100000];
node C[100000];
node BlackList[100000];
node WhiteList[100000];
int edge[100000][3];
void merge(node A[], int p, int q, int r) {
int n1 = q - p + 2;
int n2 = r - q + 1;
int i, j;
for (i = 0; i < n1 - 1; i++) {
B[i] = A[p + i];
}
for (j = 0; j < n2 - 1; j++) {
C[j] = A[q + j + 1];
}
i = 0;
j = 0;
B[n1 - 1].sum = 10000000000;
C[n2 - 1].sum = 10000000000;
for (int k = p; k <= r; k++) {
if (B[i].sum <= C[j].sum) {
A[k] = B[i];
i++;
} else {
A[k] = C[j];
j++;
}
}
}
void mergeSort(node A[], int p, int r) {
if (p < r) {
int q = (p + r) / 2;
mergeSort(A, p, q);
mergeSort(A, q + 1, r);
merge(A, p, q, r);
}
}
int main() {
int i, n, x, b = 0, w = 0, c, k = 0;
int total = 0;
cin >> n;
for (i = 0; i < n; i++) {
cout << endl;
cin >> c;
if (c == 0) {
WhiteList[w].node_no = (k + 1);
cout << " ";
cin >> x;
WhiteList[w].sum = x;
total += x;
w++;
k++;
} else {
BlackList[b].node_no = (k + 1);
cout << " ";
cin >> x;
BlackList[b].sum = x;
k++;
b++;
}
}
mergeSort(WhiteList, 0, (w - 1));
mergeSort(BlackList, 0, (b - 1));
WhiteList[w].sum = 10000000000;
WhiteList[w].node_no = WhiteList[w - 1].node_no;
BlackList[b].sum = 10000000000;
BlackList[b].node_no = BlackList[b - 1].node_no;
int edgesum = 0, B = 0, W = 0, e = 0;
int Bsum, Wsum, Bl = 0, Wl = 0;
while (e < (n - 1)) {
Bsum = BlackList[B].sum;
Wsum = WhiteList[W].sum;
if (Bsum < Wsum) {
WhiteList[W].sum = WhiteList[W].sum - BlackList[B].sum;
edge[e][0] = BlackList[B].node_no;
edge[e][1] = WhiteList[W].node_no;
edge[e][2] = BlackList[B].sum;
edgesum += BlackList[B].sum;
BlackList[B].sum = 0;
if (B < b) B++;
e++;
} else {
BlackList[B].sum = BlackList[B].sum - WhiteList[W].sum;
edge[e][0] = BlackList[B].node_no;
edge[e][1] = WhiteList[W].node_no;
edge[e][2] = WhiteList[W].sum;
edgesum += WhiteList[W].sum;
WhiteList[W].sum = 0;
if (W < w) W++;
e++;
}
if (W == w && Bl == 0) {
B++;
Bl = 1;
}
if (B == b && Wl == 0) {
W++;
Wl = 1;
}
}
cout << endl;
for (i = 0; i < e; i++) {
cout << endl;
cout << edge[i][0] << " " << edge[i][1] << " " << edge[i][2];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-7;
int main() {
vector<pair<int, int> > V[2];
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int c, s;
scanf("%d %d", &c, &s);
V[c].push_back(make_pair(i, s));
}
int b = 0;
for (int a = 0; a < ((int)(V[0]).size()); a++) {
if (b == ((int)(V[1]).size()))
printf("%d %d 0\n", V[0][a].first, V[1][b - 1].first);
while (b < ((int)(V[1]).size())) {
if (V[0][a].second >= V[1][b].second) {
printf("%d %d %d\n", V[0][a].first, V[1][b].first, V[1][b].second);
V[0][a].second -= V[1][b].second;
b++;
} else {
printf("%d %d %d\n", V[0][a].first, V[1][b].first, V[0][a].second);
V[1][b].second -= V[0][a].second;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
double Time() { return double(clock()) / double(CLOCKS_PER_SEC); }
int n;
vector<int> rl, rr;
vector<long long> rw;
queue<pair<int, long long> > w, b;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
long long cost;
cin >> x >> cost;
if (x)
b.push(make_pair(i, cost));
else
w.push(make_pair(i, cost));
}
int r = 0;
while (!w.empty() && !b.empty()) {
if (r == n - 1) break;
r++;
int wi = w.front().first, bi = b.front().first;
long long wc = w.front().second, bc = b.front().second;
w.pop();
b.pop();
if (bc > wc || (bc == wc && b.size() <= w.size())) {
rl.push_back(bi);
rr.push_back(wi);
rw.push_back(wc);
b.push(make_pair(bi, bc - wc));
} else {
rl.push_back(bi);
rr.push_back(wi);
rw.push_back(bc);
w.push(make_pair(wi, wc - bc));
}
}
for (int i = 0; i < rw.size(); i++)
cout << rl[i] << " " << rr[i] << " " << rw[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct node {
int col;
int val;
int id;
friend bool operator>(node a, node b) { return a.val > b.val; }
} a[N];
int main() {
int n;
priority_queue<node, vector<node>, greater<node> > q0, q1;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].col >> a[i].val;
a[i].id = i;
if (a[i].col)
q1.push(a[i]);
else
q0.push(a[i]);
}
int id0, id1;
while (q0.size() && q1.size()) {
node temp0 = q0.top();
node temp1 = q1.top();
id0 = temp0.id;
id1 = temp1.id;
if (temp0.val < temp1.val) {
q0.pop();
q1.pop();
cout << temp0.id << ' ' << temp1.id << ' ' << temp0.val << endl;
temp1.val -= temp0.val;
if (q0.size()) q1.push(temp1);
} else {
q0.pop();
q1.pop();
cout << temp0.id << ' ' << temp1.id << ' ' << temp1.val << endl;
temp0.val -= temp1.val;
if (q1.size()) q0.push(temp0);
}
}
while (q0.size()) {
node temp = q0.top();
q0.pop();
cout << temp.id << ' ' << id1 << ' ' << temp.val << endl;
}
while (q1.size()) {
node temp = q1.top();
q1.pop();
cout << temp.id << ' ' << id0 << ' ' << temp.val << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 50;
struct edge {
int u, v, cost;
};
int n;
int c[N], s[N];
vector<int> L, R;
vector<edge> res;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c[i] >> s[i];
(c[i] ? L : R).push_back(i);
}
int l = 0, r = 0;
while (l < L.size() - 1 || r < R.size() - 1) {
int sub = min(s[L[l]], s[R[r]]);
res.push_back({L[l], R[r], sub});
s[L[l]] -= sub, s[R[r]] -= sub;
if (s[L[l]] == 0 && l < L.size() - 1)
l++;
else if (s[R[r]] == 0 && r < R.size() - 1)
r++;
}
res.push_back({L[l], R[r], s[L[l]]});
for (const auto &e : res)
cout << e.u + 1 << " " << e.v + 1 << " " << e.cost << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long i, x, y;
vector<pair<long long, long long>> zr, on;
for (i = 1; i <= n; i++) {
cin >> x >> y;
if (x == 0) {
zr.push_back(make_pair(y, i));
} else {
on.push_back(make_pair(y, i));
}
}
sort(zr.begin(), zr.end());
sort(on.begin(), on.end());
vector<pair<long long, pair<long long, long long>>> ans;
long long j = 0;
i = 0;
while (i < zr.size() && j < on.size()) {
long long mn = min(zr[i].first, on[j].first);
ans.push_back(make_pair(zr[i].second, make_pair(on[j].second, mn)));
zr[i].first -= mn;
on[j].first -= mn;
if (zr[i].first == 0 && on[j].first == 0) {
if (i + 1 < zr.size()) {
i++;
} else {
j++;
}
} else if (zr[i].first > 0) {
j++;
} else if (on[j].first > 0) {
i++;
} else {
j++;
}
}
for (i = 0; i < n - 1; i++) {
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 110;
int c[N], s[N], sum[2];
vector<int> a[2];
vector<pair<pair<int, int>, int> > edge;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c[i] >> s[i];
a[c[i]].push_back(i);
}
int id;
while (!a[0].empty() && !a[1].empty()) {
if (s[a[0].back()] >= s[a[1].back()]) {
edge.push_back(
make_pair(make_pair(a[0].back(), a[1].back()), s[a[1].back()]));
s[a[0].back()] -= s[a[1].back()];
id = a[1].back();
a[1].pop_back();
} else {
edge.push_back(
make_pair(make_pair(a[0].back(), a[1].back()), s[a[0].back()]));
s[a[1].back()] -= s[a[0].back()];
a[0].pop_back();
}
}
a[0].pop_back();
while (!a[0].empty()) {
edge.push_back(make_pair(make_pair(a[0].back(), id), 0));
a[0].pop_back();
}
for (int i = 0; i < n - 1; i++) {
cout << edge[i].first.first + 1 << " " << edge[i].first.second + 1 << " "
<< edge[i].second << "\n";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n;
vector<pair<int, int> > w, b;
void init() {
cin >> n;
for (int i = 1; i <= n; i++) {
int c, s;
cin >> c >> s;
if (c == 0) {
w.push_back(pair<int, int>(s, i));
} else {
b.push_back(pair<int, int>(s, i));
}
}
sort(w.begin(), w.end());
sort(w.begin(), w.end());
}
void solve() {
for (int ia = 0, ib = 0; ia < (int)w.size() && ib < (int)b.size();) {
;
;
int ans = min(w[ia].first, b[ib].first);
cout << w[ia].second << ' ' << b[ib].second << ' ' << ans << endl;
w[ia].first -= ans;
b[ib].first -= ans;
if (w[ia].first != 0) {
ib++;
} else if (b[ib].first != 0) {
ia++;
} else {
if (ia < ((int)w.size()) - 1) {
ia++;
} else {
ib++;
}
}
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int N = 100000 + 5;
static int c[N], s[N];
static vector<int> black;
static vector<int> white;
static vector<int> bID;
static vector<int> wID;
static vector<pair<pair<int, int>, int> > G;
int main() {
int n, c, s, wh, bk;
int x, y;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> c >> s;
if (c) {
white.push_back(s);
wID.push_back(i);
} else {
black.push_back(s);
bID.push_back(i);
}
}
wh = (int)white.size();
bk = (int)black.size();
x = y = 0;
for (int i = 0; i < n - 1; ++i) {
s = min(white[x], black[y]);
G.push_back(make_pair(make_pair(wID[x] + 1, bID[y] + 1), s));
white[x] -= s;
black[y] -= s;
if (white[x] == 0 && x < wh - 1) {
x++;
} else if (black[y] == 0 && y < bk - 1) {
y++;
}
}
for (int i = 0; i < n - 1; ++i) {
cout << G[i].first.first << " " << G[i].first.second << " " << G[i].second
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > pq[2];
int main() {
int n, i, c, s;
cin >> n;
int w1, b1;
for (i = 0; i < (n); i++) {
scanf("%d%d", &c, &s);
pq[c].push(make_pair(-s, i + 1));
if (c)
w1 = i + 1;
else
b1 = i + 1;
}
pair<int, int> b, w;
while (!pq[0].empty() && !pq[1].empty()) {
b = pq[0].top();
w = pq[1].top();
pq[0].pop();
pq[1].pop();
b.first *= -1;
w.first *= -1;
if (b.first > w.first) {
pq[0].push(make_pair(-(b.first - w.first), b.second));
} else {
pq[1].push(make_pair(-(w.first - b.first), w.second));
}
printf("%d %d %d\n", b.second, w.second,
((b.first) < (w.first) ? (b.first) : (w.first)));
}
if (((int)(pq[0]).size()) > 1) {
pq[0].pop();
while (!pq[0].empty()) {
printf("%d %d %d\n", w1, pq[0].top().second, 0);
pq[0].pop();
}
}
if (((int)(pq[1]).size()) > 1) {
pq[1].pop();
while (!pq[1].empty()) {
printf("%d %d %d\n", b1, pq[1].top().second, 0);
pq[1].pop();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n;
priority_queue<pair<int, int> > q[2];
int main() {
ios::sync_with_stdio(false);
cin >> n;
int c, x;
for (int i = 0; i < n; ++i) {
cin >> c >> x;
q[c].push(make_pair(-x, i + 1));
}
while (!q[0].empty() && !q[1].empty()) {
pair<int, int> t0 = q[0].top(), t1 = q[1].top();
q[0].pop();
q[1].pop();
int d = max(t0.first, t1.first);
t0.first -= d;
t1.first -= d;
printf("%d %d %d\n", t0.second, t1.second, -d);
if (t0.first || q[0].empty())
q[0].push(t0);
else
q[1].push(t1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
struct var {
long long x, y, wt;
};
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq1, pq2;
long long t = 1;
while (t--) {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long c, s;
cin >> c >> s;
if (c == 0) {
pq1.push({s, i + 1});
} else {
pq2.push({s, i + 1});
}
}
long long rem = 0;
long long val = 0;
pair<long long, long long> x1, y1, prev_x1;
prev_x1 = {0, 0};
vector<var> v1;
while (!pq1.empty() || !pq2.empty()) {
long long flag = 0;
if (rem == 0) {
if (!pq1.empty()) {
flag++;
x1 = pq1.top();
pq1.pop();
rem = x1.first;
}
}
if (val == 0) {
if (!pq2.empty()) {
flag++;
y1 = pq2.top();
pq2.pop();
val = y1.first;
}
}
if (flag == 2 && prev_x1.second != 0) {
v1.push_back({prev_x1.second, y1.second, 0});
}
long long temp = min(val, rem);
val -= temp;
rem -= temp;
prev_x1 = x1;
v1.push_back({x1.second, y1.second, temp});
}
for (auto p : v1) {
cout << p.x << " " << p.y << " " << p.wt << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, c, x, y, N;
queue<pair<long long int, long long int> > q[4];
bool flag;
cin >> N;
for (i = 1; i <= N; i++) {
cin >> j >> k;
q[j].push(make_pair(i, k));
}
c = 1, x = q[1].front().first, y = q[1].front().second;
q[1].pop();
while (!q[0].empty() || !q[1].empty()) {
if (!y && !q[1 - c].empty()) flag = 1;
while (y > 0 || flag) {
j = q[1 - c].front().first, k = q[1 - c].front().second, i = min(k, y);
cout << x << " " << j << " " << i << endl;
y -= i, k -= i, flag = 0;
q[1 - c].pop();
}
if (!q[c].empty()) x = j, y = k, c = 1 - c;
}
while (!q[1 - c].empty()) {
cout << q[1 - c].front().first << " " << x << " 0" << endl;
q[1 - c].pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > b, w;
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long c, s;
cin >> c >> s;
if (c)
b.push_back({i + 1, s});
else
w.push_back({i + 1, s});
}
for (long long bi = 0, wi = 0; bi < b.size() && wi < w.size();) {
long long we = min(b[bi].second, w[wi].second);
b[bi].second -= we;
w[wi].second -= we;
cout << b[bi].first << " " << w[wi].first << " " << we << "\n";
if (b[bi].second == 0 && bi < b.size() - 1)
bi++;
else if (w[wi].second == 0 && wi < w.size() - 1)
wi++;
else if (bi == b.size() - 1 && wi == w.size() - 1)
bi++, wi++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int color, sum;
vector<pair<int, int> > v[2];
for (int i = 0; i < n; i++) {
cin >> color >> sum;
v[color].push_back(pair<int, int>(sum, i + 1));
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
int min = 0;
for (int i = 0, j = 0; i + j != n - 1;) {
min = v[0][i].first;
if (min > v[1][j].first) {
min = v[1][j].first;
}
cout << v[0][i].second << " " << v[1][j].second << " " << min << endl;
v[0][i].first -= min;
v[1][j].first -= min;
if (v[0][i].first < v[1][j].first) {
i++;
} else if (v[0][i].first > v[1][j].first) {
j++;
} else if (i < v[0].size() - 1) {
i++;
} else {
j++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
int s, b, w, N, B[100100], W[100100], C[100100], S[100100], connected[100100];
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
for (int(i) = 1; (i) <= (N); (i)++) {
cin >> C[i] >> S[i];
if (C[i])
B[++B[0]] = i;
else
W[++W[0]] = i;
}
b = w = 1;
while (b <= B[0] && w <= W[0]) {
connected[W[w]] = connected[B[b]] = 1;
if (S[B[b]] < S[W[w]]) {
cout << B[b] << " " << W[w] << " " << S[B[b]] << endl;
S[W[w]] -= S[B[b]];
b++;
} else {
cout << B[b] << " " << W[w] << " " << S[W[w]] << endl;
S[B[b]] -= S[W[w]];
w++;
}
}
while (b <= B[0]) {
if (!connected[B[b]]) {
cout << B[b] << " " << W[1] << " " << 0 << endl;
}
b++;
}
while (w <= W[0]) {
if (!connected[W[w]]) {
cout << B[1] << " " << W[w] << " " << 0 << endl;
}
w++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 999999999;
const double PI = 3.1415931;
const double eps = 1e-9;
const int maxN = 200000 + 10;
set<pair<int, int> > white, black;
vector<pair<pair<int, int>, int> > edge;
int mark[maxN];
void dfs(pair<int, int> x) {
if (mark[x.second] == 0) {
while (!black.empty() && (*black.begin()).first == 0) {
pair<int, int> y = *black.begin();
edge.push_back(
pair<pair<int, int>, int>(pair<int, int>(x.second, y.second), 0));
black.erase(black.begin());
}
while (!black.empty() && x.first >= 0) {
pair<int, int> y = *black.begin();
black.erase(black.begin());
if (x.first > y.first) {
edge.push_back(pair<pair<int, int>, int>(
pair<int, int>(x.second, y.second), y.first));
x.first -= y.first;
} else {
edge.push_back(pair<pair<int, int>, int>(
pair<int, int>(x.second, y.second), x.first));
y.first -= x.first;
x.first = 0;
dfs(y);
break;
}
}
while (!black.empty() && (*black.begin()).first == 0) {
pair<int, int> y = *black.begin();
edge.push_back(
pair<pair<int, int>, int>(pair<int, int>(x.second, y.second), 0));
black.erase(black.begin());
}
} else {
while (!white.empty() && (*white.begin()).first == 0) {
pair<int, int> y = *white.begin();
edge.push_back(
pair<pair<int, int>, int>(pair<int, int>(x.second, y.second), 0));
white.erase(white.begin());
}
while (!white.empty() && x.first >= 0) {
pair<int, int> y = *white.begin();
white.erase(white.begin());
if (x.first > y.first) {
edge.push_back(pair<pair<int, int>, int>(
pair<int, int>(x.second, y.second), y.first));
x.first -= y.first;
} else {
edge.push_back(pair<pair<int, int>, int>(
pair<int, int>(x.second, y.second), x.first));
y.first -= x.first;
x.first = 0;
dfs(y);
break;
}
}
while (!white.empty() && (*white.begin()).first == 0) {
pair<int, int> y = *white.begin();
edge.push_back(
pair<pair<int, int>, int>(pair<int, int>(x.second, y.second), 0));
white.erase(white.begin());
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int myWhite, myBlack;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> y >> x;
mark[i] = y;
if (y == 0) {
white.insert(pair<int, int>(x, i));
myWhite = i;
} else {
black.insert(pair<int, int>(x, i));
myBlack = i;
}
}
pair<int, int> pivot;
if (*white.begin() < *black.begin()) {
pivot = *white.begin();
white.erase(white.begin());
dfs(pivot);
} else {
pivot = *black.begin();
black.erase(black.begin());
dfs(pivot);
}
while (black.size() > 0) {
pair<int, int> y = *black.begin();
edge.push_back(
pair<pair<int, int>, int>(pair<int, int>(myWhite, y.second), 0));
black.erase(black.begin());
}
while (white.size() > 0) {
pair<int, int> y = *white.begin();
edge.push_back(
pair<pair<int, int>, int>(pair<int, int>(myBlack, y.second), 0));
white.erase(white.begin());
}
for (int i = 0; i < edge.size(); i++) {
cout << edge[i].first.first << " " << edge[i].first.second << " "
<< edge[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > w;
set<pair<int, int> > b;
int n;
const int Maxn = 1e5 + 100;
set<pair<int, int> >::iterator it;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
int x, c;
cin >> c >> x;
if (c)
w.insert(make_pair(x, i));
else
b.insert(make_pair(x, i));
}
for (int i = 1; i < n; i++) {
it = w.begin();
pair<int, int> v = *it;
it = b.begin();
pair<int, int> u = *it;
w.erase(v);
b.erase(u);
if (u.first >= v.first && w.size() > 0) {
cout << v.second << ' ' << u.second << ' ' << v.first << endl;
u.first -= v.first;
b.insert(make_pair(u.first, u.second));
} else {
cout << u.second << ' ' << v.second << ' ' << u.first << endl;
v.first -= u.first;
w.insert(make_pair(v.first, v.second));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<long, long> > dw, db, rw, rb;
set<pair<long, long> >::iterator it, it1, it2;
long n, c[200000], s[200000];
long c1, c2, nv1, nv;
vector<pair<pair<long, long>, long> > ans;
void add_edge(long a, long b, long c) {
ans.push_back(make_pair(make_pair(a, b), c));
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> s[i];
if (c[i] == 0)
rb.insert(make_pair(s[i], i));
else
rw.insert(make_pair(s[i], i));
}
for (int i = 1; i < n; i++) {
if (rb.size() > 0) {
it1 = rb.begin();
c1 = (*it1).first;
} else
c1 = 2e9;
if (rw.size() > 0) {
it2 = rw.begin();
c2 = (*it2).first;
} else
c2 = 2e9;
if (rb.size() == 1 && c1 <= c2) {
it1 = rb.begin();
long qq = (*it1).second;
for (it = rw.begin(); it != rw.end(); ++it) {
long q = (*it).second;
add_edge(q, qq, s[qq]);
s[qq] = 0;
}
break;
}
if (rw.size() == 1 && c1 >= c2) {
it1 = rw.begin();
long qq = (*it1).second;
for (it = rb.begin(); it != rb.end(); ++it) {
long q = (*it).second;
add_edge(q, qq, s[qq]);
s[qq] = 0;
}
break;
}
if (c1 > c2) {
nv = (*it2).second;
if (rb.size()) {
nv1 = (*it1).second;
} else {
it1 = db.begin();
nv1 = (*it1).second;
}
add_edge(nv, nv1, c2);
rw.erase(rw.begin());
if (rb.size()) {
rb.erase(rb.begin());
s[nv1] -= c2;
rb.insert(make_pair(s[nv1], nv1));
}
dw.insert(make_pair(0, nv));
} else {
nv = (*it1).second;
if (rw.size()) {
nv1 = (*it2).second;
} else {
it2 = dw.begin();
nv1 = (*it2).second;
}
add_edge(nv, nv1, c1);
rb.erase(rb.begin());
if (rw.size()) {
rw.erase(rw.begin());
s[nv1] -= c1;
rw.insert(make_pair(s[nv1], nv1));
}
db.insert(make_pair(0, nv));
}
}
for (int i = 0; i < n - 1; i++) {
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << endl;
}
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long mod = 1000000007;
const int maxn = 1e5 + 5;
const double PI = acos(-1.0);
int n;
pair<int, int> val[2][maxn];
void solve() {
int i, j;
int f, v, tot0, tot1;
scanf("%d", &n);
int st0 = 0, st1 = 0;
for (i = 1; i <= n; i++) {
scanf("%d%d", &f, &v);
if (f == 0) {
val[f][++st0] = make_pair(v, i);
} else {
val[f][++st1] = make_pair(v, i);
}
}
sort(val[0] + 1, val[0] + st0 + 1);
sort(val[1] + 1, val[1] + st1 + 1);
tot0 = st0, tot1 = st1;
st0 = 1, st1 = 1;
for (i = 1; i <= n - 1; i++) {
int va = min(val[0][st0].first, val[1][st1].first);
printf("%d %d %d\n", val[0][st0].second, val[1][st1].second, va);
val[0][st0].first -= va, val[1][st1].first -= va;
if (val[0][st0].first) {
st1++;
} else if (val[1][st1].first) {
st0++;
} else if (st0 < tot0) {
st0++;
} else {
st1++;
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
struct node {
int no, s;
bool operator<(node a) const { return s < a.s; }
};
multiset<node> a, b;
set<node>::iterator pa, pb;
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int col, sum;
cin >> col >> sum;
node tmp;
tmp.no = i, tmp.s = sum;
if (col)
a.insert(tmp);
else
b.insert(tmp);
}
for (int i = 1; i < n; i++)
if (a.size() && b.size()) {
pa = a.begin();
pb = b.begin();
if (b.size() == 1 || (*pa).s < (*pb).s) {
pb = b.end();
pb--;
node tb = *pb;
printf("%d %d %d\n", (*pa).no, (*pb).no, (*pa).s);
tb.s -= (*pa).s;
a.erase(pa);
b.erase(pb);
b.insert(tb);
} else {
pa = a.end();
pa--;
node ta = *pa;
printf("%d %d %d\n", (*pb).no, (*pa).no, (*pb).s);
ta.s -= (*pb).s;
b.erase(pb);
a.erase(pa);
a.insert(ta);
}
} else
puts("*");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, black, white;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
b, w;
int bb[100005], ww[100005];
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
int col, sum;
scanf("%d", &col);
scanf("%d", &sum);
if (col == 0) {
w.push(make_pair(sum, i));
ww[i] = 1;
white = i;
} else {
b.push(make_pair(sum, i));
bb[i] = 1;
black = i;
}
}
while (!w.empty() && !b.empty()) {
pair<int, int> x, y;
x = w.top(), y = b.top();
w.pop();
b.pop();
if (x.first <= y.first) {
printf("%d %d %d\n", x.second, y.second, x.first);
y.first -= x.first;
b.push(y);
ww[x.second] = 0;
bb[y.second] = 0;
} else {
printf("%d %d %d\n", y.second, x.second, y.first);
x.first -= y.first;
w.push(x);
ww[x.second] = 0;
bb[y.second] = 0;
}
}
if (w.size() > 1) {
for (i = 1; i <= n; i++) {
if (ww[i]) printf("%d %d %d\n", i, black, 0);
}
}
if (b.size() > 1) {
for (i = 1; i <= n; i++) {
if (bb[i]) printf("%d %d %d\n", i, white, 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c, s;
set<pair<int, int> > w, b;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c >> s;
if (c)
b.insert(make_pair(s, i));
else
w.insert(make_pair(s, i));
}
while (b.size() && w.size()) {
pair<int, int> x, y;
x = *(b.begin());
y = *(w.begin());
int edge = min(x.first, y.first);
b.erase(x);
w.erase(y);
cout << y.second << " " << x.second << " " << edge << endl;
x.first -= edge;
y.first -= edge;
bool ind = 1;
if (y.first) w.insert(y), ind = 0;
if (x.first) b.insert(x), ind = 0;
if (ind) {
if (w.size() < b.size())
w.insert(y);
else
b.insert(x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > V[2];
vector<pair<pair<int, int>, int> > ans;
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i < (n + 1); i++) {
int a, b;
scanf("%d%d", &a, &b);
V[a].push_back(make_pair(i, b));
}
int p1 = 0, p2 = 0, flag = 0;
for (int i = (1); i < (n); i++) {
int mi = min(V[0][p1].second, V[1][p2].second);
ans.push_back(make_pair(make_pair(V[0][p1].first, V[1][p2].first), mi));
V[0][p1].second -= mi;
V[1][p2].second -= mi;
if (p1 == (int)(V[0]).size() - 1)
p2++;
else if (p2 == (int)(V[1]).size() - 1)
p1++;
else if (flag) {
if (V[0][p1].second) {
flag ^= 1;
p2++;
} else
p1++;
} else {
if (V[1][p2].second) {
flag ^= 1;
p1++;
} else
p2++;
}
}
for (int i = (0); i < (n - 1); i++)
printf("%d %d %d\n", ans[i].first.first, ans[i].first.second,
ans[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
priority_queue<pair<int, int>> t[2];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
qu[2];
int val[100005];
vector<pair<pair<int, int>, int>> ans;
bool done[100005];
int clr[100005];
int par[100005];
int getrt(int n) { return par[n] = (par[n] == n ? n : getrt(par[n])); }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
int c, n;
cin >> c >> n;
val[i] = n;
qu[c].push({n, i});
t[c].push({n, i});
clr[i] = c;
par[i] = i;
}
for (int i = 1; i < N; i++) {
assert(qu[0].size() || qu[1].size());
for (int j = 0; j < 2; j++) {
while (qu[j].size() && qu[j].top().first != val[qu[j].top().second]) {
int n = qu[j].top().second;
pair<int, int> k = {val[qu[j].top().second], qu[j].top().second};
qu[j].pop();
if (!done[n]) {
qu[j].push(k);
}
}
}
if (qu[1].size() &&
(qu[0].empty() || qu[1].top().first < qu[0].top().first)) {
auto p = qu[1].top();
bool b = 0;
while (t[0].size()) {
if (t[0].top().first != val[t[0].top().second] ||
done[t[0].top().second]) {
int n = t[0].top().second;
pair<int, int> k = {val[t[0].top().second], t[0].top().second};
t[0].pop();
if (!done[n]) {
t[0].push(k);
}
continue;
}
auto q = t[0].top();
t[0].pop();
ans.push_back({{p.second, q.second}, p.first});
val[p.second] = 0;
done[p.second] = 1;
val[q.second] -= p.first;
par[p.second] = q.second;
assert(p.second >= 0);
t[0].push({val[q.second], q.second});
b = 1;
break;
}
if (!b) {
while (true) {
int n = rand() % N + 1;
if (getrt(n) != getrt(p.second) && clr[n] != clr[p.second]) {
par[getrt(n)] = getrt(p.second);
ans.push_back({{p.second, n}, 0});
break;
}
}
}
qu[1].pop();
} else {
auto p = qu[0].top();
bool b = 0;
while (t[1].size()) {
if (t[1].top().first != val[t[1].top().second] ||
done[t[1].top().second]) {
int n = t[1].top().second;
pair<int, int> k = {val[t[1].top().second], t[1].top().second};
t[1].pop();
if (!done[n]) {
t[1].push(k);
}
continue;
}
auto q = t[1].top();
t[1].pop();
ans.push_back({{p.second, q.second}, p.first});
val[p.second] = 0;
done[p.second] = 1;
val[q.second] -= p.first;
par[p.second] = q.second;
assert(p.second >= 0);
t[1].push({val[q.second], q.second});
b = 1;
break;
}
if (!b) {
while (true) {
int n = rand() % N + 1;
if (getrt(n) != getrt(p.second) && clr[n] != clr[p.second]) {
par[getrt(n)] = getrt(p.second);
ans.push_back({{p.second, n}, 0});
break;
}
}
}
qu[0].pop();
}
}
if (ans.size() != N - 1) {
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= N; i++) {
if (!done[i]) {
if (clr[i]) {
cnt1++;
} else {
cnt2++;
}
}
}
cout << cnt1 << " " << cnt2 << endl;
}
assert(ans.size() == N - 1);
for (auto p : ans) {
cout << p.first.first << " " << p.first.second << " " << p.second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > w, b, tv;
vector<int> x, y, z, m1, m2;
int p[100001], r[100001];
bool cmp(pair<int, int> a, pair<int, int> b) { return (a.second < b.second); }
int findSet(int x) {
if (x != p[x]) p[x] = findSet(p[x]);
return p[x];
}
void mergeSet(int x, int y) {
int px = findSet(x);
int py = findSet(y);
if (r[px] > r[py])
p[py] = px;
else
p[px] = py;
if (r[px] == r[py]) r[py]++;
}
void newEdge(int v1, int v2, int cost) {
x.push_back(v1);
y.push_back(v2);
z.push_back(cost);
mergeSet(v1, v2);
}
int main() {
int i, n, color, weight;
cin >> n;
for (i = 1; i <= n; i++) p[i] = i;
for (i = 0; i < n; i++) {
scanf("%d%d", &color, &weight);
if (color == 0) {
b.push_back(make_pair(i + 1, weight));
m1.push_back(i + 1);
} else {
w.push_back(make_pair(i + 1, weight));
m2.push_back((i + 1));
}
}
if (w.size() < b.size()) {
tv = w;
w = b;
b = tv;
}
int p = b.size() - 1;
for (i = 0; i < w.size(); i++) {
while (w[i].second > 0) {
int tmp = min(w[i].second, b[p].second);
newEdge(w[i].first, b[p].first, tmp);
w[i].second -= tmp;
b[p].second -= tmp;
if (b[p].second == 0) p--;
}
}
for (i = 0; i < m2.size(); i++) {
if (findSet(m1[0]) != findSet(m2[i])) newEdge(m1[0], m2[i], 0);
}
for (i = 0; i < m1.size(); i++) {
if (findSet(m2[0]) != findSet(m1[i])) newEdge(m2[0], m1[i], 0);
}
int size = x.size();
for (i = 0; i < size; i++) {
printf("%d %d %d\n", x[i], y[i], z[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(const T& a) {
return a * a;
}
template <typename T>
inline int sign(const T& a) {
return a < 0 ? -1 : a > 0;
}
void task();
int main() {
task();
return 0;
}
int n;
set<pair<int, int> > any;
set<pair<int, int> > t[2];
pair<int, int> a[int(1e5) + 10];
void task() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) {
int t, w;
cin >> t >> w;
a[i] = {t, w};
}
for (int i = 0; i < n; ++i)
any.insert({a[i].second, i}), t[a[i].first].insert({a[i].second, i});
for (int i = 0; i < n - 1; ++i) {
pair<int, int> p;
if (t[1].size() == 1)
p = *t[0].begin();
else if (t[0].size() == 1)
p = *t[1].begin();
else
p = min(*t[1].begin(), *t[0].begin());
cout << p.second + 1 << ' ';
if (p != *t[0].begin()) {
cout << t[0].begin()->second + 1 << ' ';
pair<int, int> sv = *t[0].begin();
t[0].erase(sv);
sv.first -= p.first;
t[0].insert(sv);
t[1].erase(t[1].begin());
} else {
cout << t[1].begin()->second + 1 << ' ';
pair<int, int> sv = *t[1].begin();
t[1].erase(sv);
sv.first -= p.first;
t[1].insert(sv);
t[0].erase(t[0].begin());
}
cout << p.first << "\n";
(void(1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, sa = 0, sb = 0;
struct ele {
int idx, v;
} a[100005], b[100005];
bool cmp(ele c, ele d) { return c.v > d.v; }
int main() {
int i, j, k, x, y, z;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
if (x) {
a[++sa].v = y;
a[sa].idx = i;
} else {
b[++sb].v = y;
b[sb].idx = i;
}
}
sort(a + 1, a + 1 + sa, cmp);
sort(b + 1, b + 1 + sb, cmp);
int p = 1, q = 1;
while (--n) {
if (q > sb) {
q--;
p++;
printf("%d %d %d\n", a[p].idx, b[q].idx, a[p].v);
b[q].v -= a[p].v;
q++;
} else if (a[p].v >= b[q].v) {
printf("%d %d %d\n", a[p].idx, b[q].idx, b[q].v);
a[p].v -= b[q].v;
q++;
} else {
printf("%d %d %d\n", a[p].idx, b[q].idx, a[p].v);
b[q].v -= a[p].v;
p++;
}
}
getchar();
getchar();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[2];
int main() {
int n, i, j, k, t;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &t, &k);
v[t].push_back(make_pair(k, i + 1));
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
for (i = j = 0; i < v[0].size() && j < v[1].size();) {
k = min(v[0][i].first, v[1][j].first);
printf("%d %d %d\n", v[0][i].second, v[1][j].second, k);
v[0][i].first -= k;
v[1][j].first -= k;
if (v[0][i].first)
j++;
else if (v[1][j].first)
i++;
else if (i < v[0].size() - 1)
i++;
else
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ad1, ad2, n;
struct node {
int su, id;
};
struct node a[100005], b[100005];
bool cmp(struct node x, struct node y) { return x.su < y.su; }
int main() {
scanf("%d", &n);
int col, su;
ad1 = ad2 = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &col, &su);
if (col) {
a[++ad1].su = su;
a[ad1].id = i;
} else {
b[++ad2].su = su;
b[ad2].id = i;
}
}
sort(a + 1, a + 1 + ad1, cmp);
sort(b + 1, b + 1 + ad2, cmp);
for (int i = 1, j = 1; i <= ad1 && j <= ad2;) {
int tmp = min(a[i].su, b[j].su);
printf("%d %d %d\n", a[i].id, b[j].id, tmp);
a[i].su -= tmp;
b[j].su -= tmp;
if (a[i].su)
j++;
else if (b[j].su)
i++;
else if (i < ad1)
i++;
else
j++;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.