text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
s.erase(unique(s.begin(), s.end()), s.end());
if (s.length() % 2 == 0) {
cout << "CHAT WITH HER!"
<< "\n";
} else {
cout << "IGNORE HIM!"
<< "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[27];
int main() {
string s = "";
cin >> s;
for (int i = 0; i < s.length(); i++) {
a[s[i] - 97]++;
}
int ans = 0;
for (int i = 0; i < 27; i++) {
if (a[i] > 0) {
ans++;
}
}
if (ans % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
string s;
char arr[100];
set<char> myset;
cin >> arr;
int l = strlen(arr);
for (int i = 0; i < l; i++) {
myset.insert(arr[i]);
}
if (myset.size() % 2 != 0)
cout << "IGNORE HIM!" << endl;
else
cout << "CHAT WITH HER!" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string ss;
cin >> ss;
int count[27] = {0};
int ans = 0;
for (int loop = 0; loop < ss.length(); loop++) {
if (count[ss[loop] - 'a']) {
ans--;
}
count[ss[loop] - 'a']++;
ans++;
}
if (ans % 2 == 0) {
cout << "CHAT WITH HER!\n";
} else {
cout << "IGNORE HIM!\n";
}
}
|
#include <bits/stdc++.h>
void Merge(char A[], int left, int Right, int mid) {
int n1, n2, i, j, k;
n1 = mid - left + 1;
n2 = Right - mid;
char L[n1], R[n2];
for (i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (j = 0; j < n2; j++) {
R[j] = A[mid + 1 + j];
}
i = 0;
j = 0;
k = left;
while (i < n1 & j < n2) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
A[k] = L[i];
i++;
k++;
}
while (j < n2) {
A[k] = R[j];
j++;
k++;
}
}
void Mergesort(char A[], int left, int Right) {
int mid;
if (left < Right) {
mid = (left + Right) / 2;
Mergesort(A, left, mid);
Mergesort(A, mid + 1, Right);
Merge(A, left, Right, mid);
}
}
int main() {
char ch[101];
scanf("%s", &ch);
int n, count = 0, i;
n = strlen(ch);
Mergesort(ch, 0, n - 1);
for (i = 0; i < n; i++) {
if (ch[i] != ch[i + 1]) count++;
}
if (count % 2 == 1)
printf("IGNORE HIM!\n");
else
printf("CHAT WITH HER!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> x;
for (int i = 0; i < s.size(); i++) {
char m = s[i];
x.insert(m);
}
if (x.size() % 2 == 0) {
cout << "CHAT WITH HER!";
return 0;
} else {
cout << "IGNORE HIM!";
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long A = 100000000000000LL, N = 10000;
string a;
long long o, i, j, n, b[26], m;
int main() {
cin >> a;
n = a.size();
for (i = 0; i < n; i++) b[a[i] - 'a'] = 1;
for (i = 0; i < 26; i++) o += b[i];
if (o % 2)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> st;
for (int i = 0; i < s.size(); i++) {
st.insert(s[i]);
}
if (st.size() % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else
cout << "IGNORE HIM!" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string input;
cin >> input;
std::unordered_map<char, int> m;
for (int i = 0; i < input.length(); i++) {
m[input[i]]++;
}
if (m.size() % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char buffer;
set<char> dict;
while (cin >> buffer) {
dict.insert(buffer);
}
if (dict.size() % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string n;
long long int l, t, t1;
int main() {
cin >> n;
l = n.size();
sort(n.begin(), n.end());
for (int e = l; e >= 0; e--) {
t = n[e];
t1 = n[e - 1];
if (t == t1) {
n.erase(e, e);
l--;
}
}
if (l % 2 == 0) {
cout << "CHAT WITH HER!";
}
if (l % 2 > 0) {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[256], sum;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
cnt[int(s[i])]++;
}
for (int i = 97; i <= 122; i++) {
if (cnt[i] > 1) {
sum += cnt[i];
sum--;
}
}
if ((s.size() - sum) % 2 == 0) {
cout << "CHAT WITH HER!";
return 0;
}
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main(int argc, char* argv[]) {
string s;
set<char> pos;
cin >> s;
for (char c : s) {
pos.insert(c);
}
if (pos.size() % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
}
|
#include <bits/stdc++.h>
int main() {
char str[100];
int i, j, temp;
scanf("%s", str);
int l;
l = strlen(str);
for (i = 0; i < l - 1; i++) {
for (j = i; j < l; j++) {
if (str[i] > str[j]) {
temp = str[i];
str[i] = str[j];
str[j] = temp;
}
}
}
int c = 0;
for (i = 0; i < l; i++) {
if (str[i] != str[i + 1]) c++;
}
if (c % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int dist = 1;
for (int i = 1; i < str.length(); i++) {
for (int j = i - 1; j >= 0; j--) {
if (str[i] == str[j])
break;
else if (j == 0)
dist++;
}
}
if (dist % 2 != 0)
cout << "IGNORE HIM!";
else {
cout << "CHAT WITH HER!";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, f;
string a;
cin >> a;
for (int i = 0; i < a.size(); i++) {
for (int j = i - 1; j >= 0; j--) {
if (a[i] == a[j]) {
f = 1;
break;
}
}
if (f == 0) d++;
f = 0;
}
if (d % 2 == 0)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
}
|
#include <bits/stdc++.h>
int main() {
char s[100];
scanf("%s", s);
int sum = 0;
int len = strlen(s);
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
if (s[i] == s[j]) s[j] = '\0';
}
}
int l = 0;
for (int i = 0; i < len; i++) {
if (s[i] != '\0') {
l++;
}
}
if (l % 2 == 0) {
printf("CHAT WITH HER!");
}
if (l % 2 != 0) {
printf("IGNORE HIM!");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<char> seen;
int score = 0;
int placer = 0;
string in;
cin >> in;
for (int c = 0; c < in.size(); c++) {
if (find(seen.begin(), seen.end(), in[c]) != seen.end()) {
placer += 1;
} else {
score += 1;
seen.push_back(in[c]);
}
}
if (score % 2 == 0) {
cout << "CHAT WITH HER!" << endl;
} else {
cout << "IGNORE HIM!" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[105];
int n, i;
map<char, int> m;
scanf(" %s", str);
n = strlen(str);
for (i = 0; i < n; i++) m[str[i]]++;
n = m.size();
if (n % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long z = 0, y = 0;
char arr[101];
cin.get(arr, 101);
for (int i = 0; int(arr[i]) >= 97 && int(arr[i]) <= 122; i++) {
z++;
}
sort(arr, arr + z);
for (int i = 0; i < z; i++) {
for (int j = i + 1; j < z; j++) {
if (arr[i] != arr[j]) {
y++;
break;
} else {
break;
}
}
}
y++;
if (y % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char s[101];
scanf("%s", s);
int a[26], i;
for (i = 0; i < 26; i++) a[i] = 0;
for (i = 0; i < strlen(s); i++) {
a[(int)s[i] - 97]++;
}
int c = 0;
for (i = 0; i < 26; i++) {
if (a[i] != 0) {
c++;
}
}
if (c % 2 == 0)
printf("CHAT WITH HER!");
else
printf("IGNORE HIM!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int a[100];
int main() {
int n = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
a[s[i] - 'a']++;
}
for (int j = 0; j < 26; j++) {
if (a[j] != 0) n++;
}
if (n % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ch['z' + 1] = {0};
string res[2] = {"CHAT WITH HER!", "IGNORE HIM!"};
int main() {
string str;
cin >> str;
int t = 0;
for (int i = 0; i < str.size(); i++) {
if (!ch[str[i]]) {
t++;
ch[str[i]] = true;
}
}
cout << res[t % 2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int alp[26] = {}, count = 0;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) alp[(int)s[i] - 97]++;
for (int i = 0; i < 26; i++)
if (alp[i] != 0) count++;
if (count % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<int> dic(26, 0);
cin >> s;
for (int i = 0; i < (s.length()); ++i) dic[s[i] - 'a']++;
int c = 0;
for (int i = 0; i < (26); ++i)
if (dic[i] != 0) c++;
cout << ((c % 2) == 1 ? "IGNORE HIM!" : "CHAT WITH HER!") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
set<char> se;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
se.insert(s[i]);
}
if (se.size() % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else
cout << "IGNORE HIM!" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string name;
cin >> name;
unordered_set<char> st;
for (int i = 0; i < name.length(); i++) {
st.insert(name[i]);
}
cout << (st.size() % 2 == 0 ? "CHAT WITH HER!" : "IGNORE HIM!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int DistinctChars(const string& name) {
map<char, int> lmap;
for (size_t it = 0; it < name.size(); ++it) {
lmap[name[it]]++;
}
return lmap.size();
}
int main() {
string name;
cin >> name;
if (DistinctChars(name) & 1) {
cout << "IGNORE HIM!" << endl;
} else {
cout << "CHAT WITH HER!" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char name[101];
cin >> name;
int count = 0;
char temp;
for (int i = 0; i < strlen(name); ++i) {
if (name[i] != '0') {
temp = name[i];
for (int j = i; j < strlen(name); ++j) {
if (name[j] == temp) {
name[j] = '0';
}
}
count++;
}
}
if (count % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
char a[100];
int b[500], cnt;
int main() {
gets(a);
memset(b, 0, 500);
int x = strlen(a);
cnt = 0;
for (int i = 0; i < x; ++i) {
b[(int)a[i]] += 1;
if (b[(int)a[i]] == 1) cnt++;
}
if (cnt % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
unordered_set<char> u;
for (int i = 0; i < s.length(); ++i) {
u.insert(s[i]);
}
if (u.size() % 2 == 0) {
cout << "CHAT WITH HER!" << endl;
} else {
cout << "IGNORE HIM!" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, ofs = 0;
bool flag = true;
char nickname[100] = "0";
set<char> symbols;
cin >> nickname;
while (flag) {
if (nickname[i] > 0) {
if (!symbols.count(nickname[i])) {
symbols.insert(nickname[i]);
ofs++;
}
i++;
} else {
flag = false;
}
}
if (ofs % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int f;
char g;
string o;
cin >> o;
f = o.size();
for (int i = 0; i < o.size(); i++) {
g = o[i];
for (int q = o.size(); q > i + 1; q--)
if (o[q - 1] == g && o[q - 1] != '5') {
f--;
o[q - 1] = '5';
}
}
if (f % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else
cout << "IGNORE HIM!" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<int> abc(26);
for (auto &a : abc) a = 0;
for (auto letter : s) abc[int(letter - 'a')]++;
int count = 0;
for (auto a : abc)
if (a != 0) count++;
if (count % 2 == 1)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int sum = 0;
cin >> s;
int tab[26] = {0};
for (int i = 0; i < s.length(); i++) tab[(int)s[i] - 97] = 1;
for (int i = 0; i < 26; i++) sum += tab[i];
if (sum % 2 == 0)
cout << "CHAT WITH HER!\n";
else
cout << "IGNORE HIM!\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string name;
cin >> name;
vector<int> v;
for (int i = 0; i < 26; i++) {
v.push_back(0);
}
for (int i = 0; i < name.length(); i++) {
v[name[i] - 'a'] = 1;
}
int c = 0;
for (int i = 0; i < 26; i++) {
if (v[i] == 1) c++;
}
if (c % 2 == 1)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int t = 0;
bool a = true;
char n;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ' ')
continue;
else
t++;
n = s[i];
for (int j = i; j < s.length(); j++) {
if (s[j] == n) s[j] = ' ';
}
}
if (t % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, c = 1;
char s[100];
cin >> s;
l = strlen(s);
sort(s, s + l);
for (int i = 0; i < l - 1; i++) {
if (s[i] != s[i + 1]) c++;
}
if (c % 2 == 1)
cout << "IGNORE HIM!";
else
cout << "CHAT WITH HER!";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> a;
set<char>::iterator itr;
for (int i = 0; i < s.size(); i++) {
a.insert(s[i]);
}
itr = a.begin();
cout << ((a.size() % 2 == 0) ? "CHAT WITH HER!" : "IGNORE HIM!");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int len, i, counter = 1;
char str[101];
scanf("%s", &str);
len = strlen(str);
sort(str, str + len);
for (i = 0; i < len - 1; i++) {
if (str[i] == str[i + 1]) {
} else {
counter++;
}
}
if (counter % 2 == 1)
printf("IGNORE HIM!\n");
else
printf("CHAT WITH HER!\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int hash[26];
int count = 0;
memset(hash, 0, sizeof(hash));
for (int i = 0; i < str.length(); i++) {
hash[str[i] - 97]++;
}
for (int i = 0; i < 26; i++) {
if (hash[i] > 0) count++;
}
if (count % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < s.length(); i++) {
for (int j = 0; j < i; j++) {
if (s[i] == s[j]) {
n--;
break;
}
}
}
if (n % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string re;
cin >> re;
int seen[26] = {0};
int dif = 0;
for (auto va : re) {
if (!seen[va - 'a']) ++dif, seen[va - 'a'] = 1;
}
if (dif & 1)
puts("IGNORE HIM!");
else
puts("CHAT WITH HER!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[1000];
bool c[100] = {false};
int count = 0, i;
cin >> s;
int l = strlen(s);
for (i = 0; i < l; i++) {
if (c[s[i] - 'a'] == false) {
count++;
c[s[i] - 'a'] = true;
}
}
if (count % 2 == 0)
cout << "CHAT WITH HER!\n";
else
cout << "IGNORE HIM!\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand_seed() {
long long a = rng();
return a;
}
int n;
vector<pair<int, int> > val[3];
struct muchii {
int a, b, c;
};
muchii v[100002];
int nr = 0;
int drop[100002];
struct cmp {
bool operator()(pair<int, int> a, pair<int, int> b) {
return drop[a.second] < drop[b.second];
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, cmp> d;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
int un = 0, ze = 0;
for (int i = 1; i <= n; ++i) {
int a, b;
cin >> a >> b;
drop[i] = b;
val[a].push_back({b, i});
}
for (int i = 0; i <= 1; ++i) {
sort(val[i].begin(), val[i].end());
reverse(val[i].begin(), val[i].end());
}
d.push({0, val[0][0].second});
int a = 1;
int b = 0;
int edg = 0;
while (!d.empty()) {
pair<int, int> x = d.top();
d.pop();
int nul = (drop[x.second] == 0);
if (x.first == 0) {
if (b == val[1].size()) continue;
int xx = min(drop[x.second], drop[val[1][b].second]);
v[++edg] = {x.second, val[1][b].second, xx};
drop[x.second] -= xx;
drop[val[1][b].second] -= xx;
d.push({1, val[1][b].second});
++b;
d.push({0, x.second});
} else {
if (a == val[0].size()) continue;
int xx = min(drop[x.second], drop[val[0][a].second]);
v[++edg] = {x.second, val[0][a].second, xx};
drop[x.second] -= xx;
drop[val[0][a].second] -= xx;
d.push({0, val[0][a].second});
++a;
d.push({1, x.second});
}
}
for (int i = 1; i < n; ++i)
cout << v[i].a << " " << v[i].b << " " << v[i].c << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int c[maxn], s[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> c[i] >> s[i];
set<pair<int, int>> st[2];
for (int i = 0; i < n; ++i) st[c[i]].insert(make_pair(s[i], i));
vector<tuple<int, int, int>> ans;
int t = n - 1;
while (t--) {
int cur = -1;
if (st[0].size() == 1)
cur = 1;
else if (st[1].size() == 1)
cur = 0;
else
cur = (st[0].begin()->first < st[1].begin()->first ? 0 : 1);
int z, w;
tie(w, z) = *st[cur].begin();
st[cur].erase(make_pair(w, z));
int y, x;
tie(y, x) = *st[cur ^ 1].lower_bound(make_pair(w, -1));
ans.emplace_back(z, x, w);
st[cur ^ 1].erase(make_pair(y, x));
st[cur ^ 1].insert(make_pair(y - w, x));
}
for (auto i : ans) {
int a, b, c;
tie(a, b, c) = i;
cout << a + 1 << ' ' << b + 1 << ' ' << c << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dblcmp(double x) { return fabs(x) < 1e-8 ? 0 : x > 0 ? 1 : -1; }
bool insize(int c, int l, int r) {
if (c >= l && c <= r) return true;
return false;
}
template <class T>
inline void checkmin(T &a, T b) {
if (a == -1 || a > b) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (a < b) a = b;
}
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
const int N = 100001;
const int NN = 500500;
const int INF = 0x3f3f3f3f;
const int maxn = 2222;
template <class T>
inline void SD(T &x) {
char c;
int mul = 1;
while ((c = getchar()) != EOF) {
if (c == '-') mul = -1;
if (c >= '0' && c <= '9') {
x = c - '0';
break;
}
}
if (c == EOF) {
x = EOF;
return;
}
while ((c = getchar())) {
if (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c - '0');
} else
break;
}
x *= mul;
};
set<pair<int, int> > a, b;
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int bo, v;
scanf("%d%d", &bo, &v);
if (bo)
a.insert(make_pair(v, i));
else
b.insert(make_pair(v, i));
}
while (a.size() + b.size() > 1) {
if (a.begin()->first < b.begin()->first ||
(a.begin()->first == b.begin()->first && a.size() >= b.size())) {
int v = a.begin()->first;
printf("%d %d %d\n", a.begin()->second, b.begin()->second, v);
a.erase(a.begin());
pair<int, int> x = *b.begin();
b.erase(b.begin());
x.first -= v;
b.insert(x);
} else {
int v = b.begin()->first;
printf("%d %d %d\n", a.begin()->second, b.begin()->second, v);
b.erase(b.begin());
pair<int, int> x = *a.begin();
a.erase(a.begin());
x.first -= v;
a.insert(x);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int v;
int id;
bool operator<(const node& W) const { return v > W.v; }
};
priority_queue<node> q0, q1;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int c, v;
cin >> c >> v;
if (c == 0)
q0.push({v, i});
else
q1.push({v, i});
}
int id0, id1;
int cnt = 0;
while (q0.size() && q1.size()) {
auto t1 = q0.top();
auto t2 = q1.top();
int v1 = t1.v, v2 = t2.v;
q0.pop();
q1.pop();
id0 = t1.id, id1 = t2.id;
if (v1 < v2) {
cnt++;
cout << id0 << " " << id1 << " " << v1 << endl;
v2 -= v1;
if (q0.size()) q1.push({v2, t2.id});
} else {
v1 -= v2;
cnt++;
cout << id0 << ' ' << id1 << " " << v2 << endl;
if (q1.size()) q0.push({v1, t1.id});
}
}
while (q0.size() && cnt < n - 1) {
cnt++;
auto t1 = q0.top();
q0.pop();
int v = t1.v;
cout << t1.id << " " << id1 << " " << v << endl;
}
while (q1.size() && cnt < n - 1) {
cnt++;
auto t1 = q1.top();
q1.pop();
int v = t1.v;
cout << t1.id << " " << id0 << " " << v << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NN = (int)1e5 + 5;
const int MOD = 1e9 + 7;
const int INF = (long long)1e9 + 5;
vector<int> a[2];
int L[2];
int R[2];
int sum[NN];
bool cmp(const int& A, const int& B) { return sum[A] < sum[B]; }
int main() {
ios_base::sync_with_stdio(0);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int c, v;
scanf("%d%d", &c, &v);
a[c].push_back(i);
sum[i] = v;
}
sort(a[0].begin(), a[0].end(), cmp);
sort(a[1].begin(), a[1].end(), cmp);
R[0] = (int)a[0].size() - 1, R[1] = (int)a[1].size() - 1;
L[0] = L[1] = 0;
int node = a[0][R[0]--];
int c = 0;
vector<vector<int> > ans;
for (; ans.size() < n - 1;) {
int& idx_other = L[c ^ 1];
while (idx_other < R[c ^ 1] && (sum[a[c ^ 1][idx_other]] == 0 ||
sum[node] - sum[a[c ^ 1][idx_other]] > 0)) {
ans.push_back({node, a[c ^ 1][idx_other], sum[a[c ^ 1][idx_other]]});
sum[node] -= sum[a[c ^ 1][idx_other]];
sum[a[c ^ 1][idx_other]] = 0;
idx_other++;
}
int pre = node;
node = a[c ^ 1][R[c ^ 1]--];
ans.push_back({node, pre, sum[pre]});
sum[node] -= sum[pre];
sum[pre] = 0;
c = c ^ 1;
}
for (auto& x : ans) {
printf("%d %d %d\n", x[0], x[1], x[2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > v[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(pair<int, int>(y, i));
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
int sz0 = v[0].size();
int sz1 = v[1].size();
for (int p0 = 0, p1 = 0; p0 < sz0 && p1 < sz1;) {
int mn = min(v[0][p0].first, v[1][p1].first);
v[0][p0].first -= mn;
v[1][p1].first -= mn;
printf("%d %d %d\n", v[0][p0].second, v[1][p1].second, mn);
if (!v[0][p0].first && v[1][p1].first)
p0++;
else if (v[0][p0].first && !v[1][p1].first)
p1++;
else if (p0 + 1 < sz0)
p0++;
else
p1++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct mycmp {
bool operator()(const pair<int, int> a, const pair<int, int> b) {
return a.first < b.first;
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, mycmp> s1, s2;
int n;
int main() {
scanf("%d", &n);
int c, v;
for (int i = 1, _c = n; i <= _c; i++) {
scanf("%d%d", &c, &v);
if (c == 0)
s1.push(pair<int, int>(v, i));
else
s2.push(pair<int, int>(v, i));
}
for (int index = 0, _a = (n - 1); index < _a; ++index) {
pair<int, int> a = s1.top(), b = s2.top();
if (a.first < b.first ||
(a.first == b.first && int(s1.size()) > int(s2.size()))) {
printf("%d %d %d\n", a.second, b.second, a.first);
s1.pop();
s2.pop();
b.first -= a.first;
s2.push(b);
} else {
printf("%d %d %d\n", a.second, b.second, b.first);
s1.pop();
s2.pop();
a.first -= b.first;
s1.push(a);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct node {
int v, id;
bool operator<(const node &a) const { return v < a.v; }
};
vector<node> white, black;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int c, s;
scanf("%d%d", &c, &s);
if (c)
white.push_back({s, i});
else
black.push_back({s, i});
}
sort(white.begin(), white.end());
sort(black.begin(), black.end());
int i = 0, j = 0;
while (i < white.size() && j < black.size()) {
int minv = min(white[i].v, black[j].v);
printf("%d %d %d\n", white[i].id, black[j].id, minv);
white[i].v -= minv;
black[j].v -= minv;
if (white[i].v)
j++;
else if (black[j].v)
i++;
else if (i < white.size() - 1)
i++;
else
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > black, white;
int n, color, weight, iw = 0, ib = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &color, &weight);
if (color == 1)
black.push_back(make_pair(weight, i));
else
white.push_back(make_pair(weight, i));
}
for (int i = 0; i < n - 1; ++i) {
if ((white[iw].first < black[ib].first) ||
(white[iw].first == black[ib].first && iw + 1 != white.size())) {
printf("%d %d %d\n", white[iw].second, black[ib].second, white[iw].first);
black[ib].first -= white[iw++].first;
} else {
printf("%d %d %d\n", white[iw].second, black[ib].second, black[ib].first);
white[iw].first -= black[ib++].first;
}
}
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++;
}
}
w++;
b++;
while (b <= B[0]) {
{ cout << B[b] << " " << W[1] << " " << 0 << endl; }
b++;
}
while (w <= W[0]) {
{ cout << B[1] << " " << W[w] << " " << 0 << endl; }
w++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double E = exp(1.0);
const int INF = 0x3f3f3f3f;
bool scan_d(long long &s_num) {
char s_in;
int s_sign;
double s_bit = 0.1;
if (s_in = getchar(), s_in == EOF) return false;
while (s_in != '-' && s_in != '.' && (s_in < '0' || s_in > '9'))
s_in = getchar();
if (s_in == '-') {
s_sign = -1;
s_num = 0;
} else {
s_sign = 1;
s_num = s_in - '0';
}
while (s_in = getchar(), s_in >= '0' && s_in <= '9')
s_num = s_num * 10 + (s_in - '0');
if (s_in == ' ' || s_in == '\n') {
s_num *= s_sign;
return true;
}
while (s_in = getchar(), s_in >= '0' && s_in <= '9') {
s_num = (s_in - '0') * s_bit;
s_bit /= 10;
}
s_num *= s_sign;
return true;
}
int n;
int wss;
int bs;
struct node {
int v, id;
const bool operator<(node _x) const { return v < _x.v; }
} w[100005], b[100005];
int x, y;
int main() {
scanf("%d", &n);
wss = 0;
bs = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
if (x == 0) {
w[wss].id = i;
w[wss++].v = y;
} else {
b[bs].id = i;
b[bs++].v = y;
}
}
sort(w, w + wss);
sort(b, b + bs);
x = 0;
y = 0;
int no = 0;
int tmp = w[0].v;
int cnt;
while (x < wss && y < bs) {
if (no == 0) {
cnt = b[y].v;
while (y < bs && cnt <= tmp) {
printf("%d %d %d\n", w[x].id, b[y].id, b[y].v);
y++;
cnt += b[y].v;
}
if (y == bs) y--;
if (cnt != tmp) {
tmp = cnt - tmp;
printf("%d %d %d\n", w[x].id, b[y].id, b[y].v - tmp);
}
x++;
} else {
cnt = w[x].v;
while (x < wss && cnt <= tmp) {
printf("%d %d %d\n", b[y].id, w[x].id, w[x].v);
x++;
cnt += w[x].v;
}
if (x == wss) x--;
if (cnt != tmp) {
tmp = cnt - tmp;
printf("%d %d %d\n", b[y].id, w[x].id, w[x].v - tmp);
}
y++;
}
no ^= 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > white;
vector<pair<int, int> > black;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int c, s;
cin >> c >> s;
if (c)
black.push_back(pair<int, int>(s, i));
else
white.push_back(pair<int, int>(s, i));
}
n--;
pair<int, int> w, b;
while (white.size() && black.size()) {
w = white.back();
b = black.back();
int mn = min(w.first, b.first);
w.first -= mn;
b.first -= mn;
if (w.first == 0) {
black[black.size() - 1] = b;
white.pop_back();
} else if (b.first == 0) {
white[white.size() - 1] = w;
black.pop_back();
}
cout << w.second << ' ' << b.second << ' ' << mn << endl;
}
if (white.size()) {
for (auto idx : white)
if (idx.second != w.second)
cout << idx.second << ' ' << b.second << ' ' << endl;
}
if (black.size()) {
for (auto idx : black)
if (idx.second != b.second)
cout << idx.second << ' ' << w.second << ' ' << 0 << endl;
}
return 0;
}
|
#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 dsget(int v) { return (v == ds[v]) ? v : (ds[v] = dsget(ds[v])); }
void dsunion(int a, int b) {
a = dsget(a);
b = dsget(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;
dsunion(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 = dsget(ww);
for (int i = 0; i < n; i++)
if (dsget(i) != r && c[i] != c[ww]) {
u[nn] = i;
v[nn] = ww;
w[nn] = 0;
dsunion(u[nn], v[nn]);
r = dsget(ww);
nn++;
}
r = dsget(bb);
for (int i = 0; i < n; i++)
if (dsget(i) != r && c[i] != c[bb]) {
u[nn] = i;
v[nn] = bb;
w[nn] = 0;
dsunion(u[nn], v[nn]);
r = dsget(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;
bool compare(const pair<int, int> &pr1, const pair<int, int> &pr2) {
return pr1.second > pr2.second;
}
int main() {
int N;
cin >> N;
vector<pair<int, int> > black, white;
for (int i = 0; i < N; i++) {
int col, wgt;
cin >> col >> wgt;
if (col == 0) {
white.push_back({i, wgt});
} else {
black.push_back({i, wgt});
}
}
sort(white.begin(), white.end(), compare);
sort(black.begin(), black.end(), compare);
while (black.size() + white.size() > 1) {
int bs = black.size(), ws = white.size();
while (bs > 0 && ws > 0 && black[bs - 1].second >= white[ws - 1].second) {
if (ws == 1 && bs > 1) {
break;
}
cout << white[ws - 1].first + 1 << " " << black[bs - 1].first + 1 << " "
<< white[ws - 1].second << endl;
black[bs - 1].second -= white[ws - 1].second;
white.pop_back();
ws = white.size();
}
while (ws > 0 && bs > 0 && white[ws - 1].second >= black[bs - 1].second) {
if (bs == 1 && ws > 1) {
break;
}
cout << white[ws - 1].first + 1 << " " << black[bs - 1].first + 1 << " "
<< black[bs - 1].second << endl;
white[ws - 1].second -= black[bs - 1].second;
black.pop_back();
bs = black.size();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
int n, uf[MAXN];
vector<pair<int, int>> v[2];
vector<tuple<int, int, int>> ans;
inline int find(int x) { return uf[x] ? uf[x] = find(uf[x]) : x; }
void join(int x, int y) {
if ((x = find(x)) == (y = find(y))) return;
uf[y] = x;
}
int main() {
scanf("%d", &n);
for (int i = 1, c, s; i <= n; ++i)
scanf("%d %d", &c, &s), v[c].emplace_back(s, i);
sort(v[0].begin(), v[0].end()), sort(v[1].begin(), v[1].end());
for (int i = 0, j = 0, s, id, x, s_, id_; i < v[0].size(); ++i) {
tie(s, id) = v[0][i];
while (s > 0) {
tie(s_, id_) = v[1][j];
x = min(s, s_);
s -= x, s_ -= x;
join(id, id_);
v[1][j] = make_pair(s_, id_);
ans.emplace_back(id, id_, x);
if (s_ == 0) j++;
}
}
for (int i = 0, id; i < v[0].size(); ++i) {
tie(ignore, id) = v[0][i];
if (find(id) != find(v[1][0].second))
join(id, v[1][0].second), ans.emplace_back(id, v[1][0].second, 0);
}
for (int i = 0, id; i < v[1].size(); ++i) {
tie(ignore, id) = v[1][i];
if (find(id) != find(v[0][0].second))
join(id, v[0][0].second), ans.emplace_back(id, v[0][0].second, 0);
}
for (const auto& [u, v, w] : ans) printf("%d %d %d\n", u, v, w);
}
|
#include <bits/stdc++.h>
using namespace std;
struct s {
long long index;
long long value;
bool color;
};
struct yal {
long long from, to;
long long wazn;
};
vector<yal> ans;
priority_queue<s> black;
priority_queue<s> white;
s arr[100005];
int root[100005];
bool operator<(const s &s1, const s &s2) { return s1.value < s2.value; }
int findFather(int a) {
if (root[a] == a) return root[a];
root[a] = findFather(root[a]);
return root[a];
}
void mer(int u, int v) {
if (findFather(v) < findFather(u))
root[findFather(u)] = findFather(v);
else
root[findFather(v)] = findFather(u);
}
int main() {
long long n, a, b;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a >> b;
s temp;
temp.index = i;
temp.value = b;
if (a == 1) {
temp.color = false;
black.push(temp);
} else {
temp.color = true;
white.push(temp);
}
arr[i] = temp;
root[i] = i;
}
while (black.size() > 0 && white.size() > 0) {
s x = black.top();
s y = white.top();
yal temp;
temp.from = x.index;
temp.to = y.index;
temp.wazn = min(x.value, y.value);
ans.push_back(temp);
if (x.value < y.value) {
black.pop();
y.value -= x.value;
white.pop();
white.push(y);
} else if (x.value > y.value) {
white.pop();
x.value -= y.value;
black.pop();
black.push(x);
} else {
black.pop();
white.pop();
}
int u = findFather(x.index);
int v = findFather(y.index);
if (u != v) mer(u, v);
}
for (int i = 1; i <= n; i++) {
if (findFather(i) != 1) {
int c;
for (int j = 1; j <= n; j++) {
if (arr[j].color != arr[i].color && arr[j].index != arr[i].index) {
c = j;
break;
}
}
yal temp;
temp.from = arr[i].index;
temp.to = arr[c].index;
temp.wazn = 0;
ans.push_back(temp);
mer(i, c);
}
}
for (long long i = 0; i < ans.size(); i++)
cout << ans[i].from << " " << ans[i].to << " " << ans[i].wazn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const int maxm = 2000010;
const int INF = 1e9;
const int mod1 = 1e9 + 7;
const int mod2 = 123456701;
int n, m;
struct Node {
int id;
int val;
} a[maxn], b[maxn];
int cnta;
int cntb;
int main() {
int i, j;
scanf("%d", &n);
cnta = 0;
cntb = 0;
for (i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x) {
a[cnta].id = i;
a[cnta].val = y;
cnta++;
} else {
b[cntb].id = i;
b[cntb].val = y;
cntb++;
}
}
int fx = 0;
int fy = 0;
for (i = 1; i < n; i++) {
printf("%d %d %d\n", a[fx].id, b[fy].id, min(a[fx].val, b[fy].val));
if (a[fx].val >= b[fy].val && fy < cntb - 1) {
a[fx].val -= b[fy].val;
fy++;
} else {
b[fy].val -= a[fx].val;
fx++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 999999999;
const double EPSILON = 0.00000001;
const long long MOD = 1000000007;
int p[100005], lv[100005];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void merge(int x, int y) {
x = find(x), y = find(y);
if (lv[x] < lv[y]) swap(x, y);
p[y] = x;
if (lv[x] == lv[y]) lv[x]++;
}
struct node {
int i, val;
bool col;
};
bool operator<(const node& self, const node& other) {
return self.val < other.val;
}
struct edge {
int a, b;
int val;
};
bool operator<(const edge& self, const edge& other) {
return self.val < other.val;
}
int main() {
int n;
cin >> n;
vector<node> nodes;
int w, b;
for (int i = 0; i < n; i++) {
node z;
z.i = i;
scanf("%d", &z.col);
scanf("%d", &z.val);
nodes.push_back(z);
p[i] = i;
if (z.col)
w = i;
else
b = i;
}
sort(nodes.begin(), nodes.end());
vector<edge> edges;
multiset<edge> black, white;
for (int i = 0; i < n; i++) {
node h = nodes[i];
if (h.col == 1) {
edge e;
e.a = h.i;
e.b = -1;
e.val = h.val;
multiset<edge>::iterator it = black.begin();
bool z = true;
for (; it != black.end(); it++) {
if (find(it->a) == find(e.a)) continue;
if (it->val > e.val) {
edge e2;
e2.a = it->a;
e2.b = e.a;
e2.val = e.val;
edges.push_back(e2);
merge(e2.a, e2.b);
e2 = *it;
e2.val -= e.val;
black.erase(black.begin(), ++it);
black.insert(e2);
z = false;
break;
}
e.val -= it->val;
edge e2;
e2.a = h.i;
e2.b = it->a;
e2.val = it->val;
edges.push_back(e2);
merge(e2.a, e2.b);
}
if (z) {
white.insert(e);
int a = black.begin()->a;
black.erase(black.begin(), it);
}
} else {
edge e;
e.a = h.i;
e.b = -1;
e.val = h.val;
multiset<edge>::iterator it = white.begin();
bool z = true;
for (; it != white.end(); it++) {
if (find(it->a) == find(e.a)) continue;
if (it->val > e.val) {
edge e2;
e2.a = it->a;
e2.b = e.a;
e2.val = e.val;
edges.push_back(e2);
merge(e2.a, e2.b);
e2 = *it;
e2.val -= e.val;
white.erase(white.begin(), ++it);
white.insert(e2);
z = false;
break;
}
e.val -= it->val;
edge e2;
e2.a = h.i;
e2.b = it->a;
e2.val = it->val;
edges.push_back(e2);
merge(e2.a, e2.b);
}
if (z) {
black.insert(e);
int a = white.begin()->a;
white.erase(white.begin(), it);
}
}
}
for (multiset<edge>::iterator it = black.begin(); it != black.end(); it++) {
if (find(it->a) != find(w)) {
edges.push_back((edge){it->a, w, 0});
merge(it->a, w);
}
}
for (multiset<edge>::iterator it = white.begin(); it != white.end(); it++) {
if (find(it->a) != find(b)) {
edges.push_back((edge){it->a, b, 0});
merge(it->a, b);
}
}
for (vector<edge>::iterator it = edges.begin(); it != edges.end(); it++) {
printf("%d %d %d\n", it->a + 1, it->b + 1, it->val);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
while (~scanf("%d", &n)) {
queue<pair<int, int> > B, W;
int c, s;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c, &s);
if (c == 0)
B.push(make_pair(s, i));
else
W.push(make_pair(s, i));
}
pair<int, int> w, b;
int cnt = 0;
while (cnt < n - 1) {
w = W.front(), b = B.front();
W.pop(), B.pop();
if (w.first > b.first) {
printf("%d %d %d\n", b.second, w.second, b.first);
w.first -= b.first;
W.push(w);
} else if (w.first < b.first) {
printf("%d %d %d\n", w.second, b.second, w.first);
b.first -= w.first;
B.push(b);
} else {
printf("%d %d %d\n", b.second, w.second, b.first);
if (W.empty())
W.push(make_pair(0, w.second));
else
B.push(make_pair(0, b.second));
}
cnt++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[2];
int main() {
int n, c, s;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c >> s;
v[c].push_back(make_pair(s, i));
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
for (int i = 0, j = 0; i < (int)v[0].size() && j < (int)v[1].size();) {
int t = min(v[0][i].first, v[1][j].first);
cout << v[0][i].second << ' ' << v[1][j].second << ' ' << t << endl;
v[0][i].first -= t;
v[1][j].first -= t;
if (v[0][i].first)
j++;
else if (v[1][j].first)
i++;
else if (i < (int)v[0].size() - 1)
i++;
else
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 25;
struct compare {
bool operator()(const pair<int, int> &p1, const pair<int, int> &p2) {
return p1.first < p2.first;
}
};
int main(int argc, char *argv[]) {
int n, c, s;
cin >> n;
priority_queue<pair<int, int> > B, W;
for (int i = (0), _b = (n); i < (_b); ++i) {
cin >> c >> s;
if (c)
B.push(pair<int, int>(s, i + 1));
else
W.push(pair<int, int>(s, i + 1));
}
vector<pair<pair<int, int>, int> > ans;
while (!W.empty() && !B.empty()) {
pair<int, int> w = W.top(), b = B.top();
W.pop(), B.pop();
int v = min(w.first, b.first);
ans.push_back(
pair<pair<int, int>, int>(pair<int, int>(w.second, b.second), v));
w.first -= v, b.first -= v;
if (!w.first && !b.first) {
if (W.size() > B.size())
B.push(b);
else
W.push(w);
} else if (w.first)
W.push(w);
else
B.push(b);
}
for (int i = (0), _b = (ans.size()); i < (_b); ++i) {
pair<pair<int, int>, int> x = ans[i];
cout << x.first.first << " " << x.first.second << " " << x.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int ind, val;
};
bool operator<(const node &a, const node &b) {
if (a.val != b.val) return a.val > b.val;
return a.ind > b.ind;
}
priority_queue<node> one, zero;
struct triple {
int v, u, w;
};
vector<triple> res;
int main() {
int n, c, s, o, z;
triple x;
node temp;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &c, &s);
temp.ind = i;
temp.val = s;
if (c) {
one.push(temp);
} else {
zero.push(temp);
}
}
while (!one.empty() && !zero.empty()) {
if (one.top().val < zero.top().val) {
o = one.top().ind;
z = zero.top().ind;
x.u = one.top().ind;
x.v = zero.top().ind;
x.w = one.top().val;
res.push_back(x);
one.pop();
temp = zero.top();
zero.pop();
temp.val -= x.w;
zero.push(temp);
} else {
o = one.top().ind;
z = zero.top().ind;
x.u = one.top().ind;
x.v = zero.top().ind;
x.w = zero.top().val;
res.push_back(x);
zero.pop();
temp = one.top();
one.pop();
temp.val -= x.w;
one.push(temp);
}
}
if (!one.empty()) one.pop();
while (!one.empty()) {
x.u = one.top().ind;
x.v = z;
x.w = 0;
res.push_back(x);
one.pop();
}
if (!zero.empty()) zero.pop();
while (!zero.empty()) {
x.u = zero.top().ind;
x.v = o;
x.w = 0;
res.push_back(x);
zero.pop();
}
for (int i = 0; i < n - 1; i++)
printf("%d %d %d\n", res[i].u + 1, res[i].v + 1, res[i].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
priority_queue<pair<int, int> > que;
int sum[MAXN], col[MAXN], del[MAXN];
int cnt[2], ans, n;
int white, black;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &col[i], &sum[i]), black += col[i];
white = n - black;
for (int i = 1; i <= n; ++i) que.push(make_pair(-sum[i], i));
cnt[0] = cnt[1] = 1;
while (!que.empty()) {
if (white == 1 || black == 1) {
int t = (black == 1);
int &u = cnt[t];
while (col[u] != t || del[u]) ++u;
for (int v = cnt[t ^ 1]; v <= n; ++v)
if (col[v] == (t ^ 1) && !del[v]) printf("%d %d %d\n", u, v, sum[v]);
break;
}
int u = que.top().second, t = -que.top().first;
que.pop();
if (t != sum[u] || del[u]) continue;
int &v = cnt[col[u] ^ 1];
while (col[v] != (col[u] ^ 1) || del[v]) ++v;
printf("%d %d %d\n", u, v, t);
del[u] = true;
if (col[u] == 0)
--white;
else
--black;
sum[u] -= t, sum[v] -= t;
que.push(make_pair(-sum[v], v));
if (++ans == n - 1) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 123;
int N, val[maxn];
vector<int> v[2];
int main() {
scanf("%d", &N);
for (int i = 1, a; i <= N; i++) {
scanf("%d%d", &a, &val[i]);
v[a].push_back(i);
}
for (int i = 0, j = 0, k = 1; k < N; k++) {
int a = v[0][i], b = v[1][j];
int x = min(val[a], val[b]);
printf("%d %d %d\n", a, b, x);
val[a] -= x;
val[b] -= x;
if (!val[a] and i + 1 < (int)v[0].size())
i++;
else
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ts, kk = 1, _DB = 1;
inline int LEN(string a) { return a.length(); }
inline int LEN(char a[]) { return strlen(a); }
template <class T>
inline T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
inline T _max(T a, T b) {
return (a > b ? a : b);
}
template <class T>
inline T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
inline T _sq(T x) {
return x * x;
}
template <class T>
inline T _sqrt(T x) {
return (T)sqrt((double)x);
}
template <class T>
inline T _pow(T x, T y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= x;
}
return z;
}
template <class T>
inline T _gcd(T a, T b) {
a = _abs(a);
b = _abs(b);
if (!b) return a;
return _gcd(b, a % b);
}
template <class T>
inline T _lcm(T a, T b) {
a = _abs(a);
b = _abs(b);
return (a / _gcd(a, b)) * b;
}
template <class T>
inline T _extended(T a, T b, T &x, T &y) {
a = _abs(a);
b = _abs(b);
T g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = _extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
template <class T>
inline T getbit(T x, T i) {
T t = 1;
return (x & (t << i));
}
template <class T>
inline T setbit(T x, T i) {
T t = 1;
return (x | (t << i));
}
template <class T>
inline T resetbit(T x, T i) {
T t = 1;
return (x & (~(t << i)));
}
template <class T>
inline T _bigmod(T n, T m) {
T ans = 1, mult = n % 1000000007;
while (m) {
if (m & 1) ans = (ans * mult) % 1000000007;
m >>= 1;
mult = (mult * mult) % 1000000007;
}
ans %= 1000000007;
return ans;
}
template <class T>
inline T _modinv(T x) {
return _bigmod(x, (T)(1000000007 - 2)) % 1000000007;
}
vector<pair<int, int> > vv[2];
int main() {
int n, col, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> col >> x;
vv[col].push_back(make_pair(x, i));
}
while (!vv[0].empty() && !vv[1].empty()) {
int mn = _min(vv[0].back().first, vv[1].back().first);
for (int i = 0; i <= 1; i++)
cout << vv[i].back().second << " ", vv[i].back().first -= mn;
cout << mn << endl;
if (vv[0].back().first < vv[1].back().first ||
(vv[0].back().first == vv[1].back().first &&
vv[0].size() > vv[1].size()))
vv[0].pop_back();
else
vv[1].pop_back();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int abs(int n) {
if (n > 0) {
return n;
} else {
return -n;
}
}
int binpow(int a, int n) {
int res = 1;
int base = a;
while (n != 0) {
if (n % 2 == 0) {
base *= base;
n /= 2;
} else {
res *= base;
n--;
}
}
return res;
}
int main() {
int N;
cin >> N;
int curb, curw;
priority_queue<pair<int, int> > w, b;
pair<int, int> A[N];
bool usedw = false, usedb = false;
int numw = -1, numb = -1;
int numbi = -1, numwi = -1;
bool usedwi = false, usedbi = false;
for (int i = 0; i < N; i++) {
cin >> A[i].first >> A[i].second;
if (A[i].first == 0 && !usedw && A[i].second != 0) {
usedw = true;
numw = i;
}
if (A[i].first == 1 && !usedb && A[i].second != 0) {
usedb = true;
numb = i;
}
if (A[i].first == 0 && !usedwi) {
usedwi = true;
numwi = i;
}
if (A[i].first == 1 && !usedbi) {
usedbi = true;
numbi = i;
}
}
for (int i = 0; i < N; i++) {
if (A[i].first == 0)
if (A[i].second != 0)
w.push(make_pair(A[i].second, i));
else {
if (numb >= 0)
cout << numb + 1 << " " << i + 1 << " " << 0 << endl;
else
cout << numbi + 1 << " " << i + 1 << " " << 0 << endl;
}
else {
if (A[i].second != 0)
b.push(make_pair(A[i].second, i));
else {
if (numb >= 0)
cout << numw + 1 << " " << i + 1 << " " << 0 << endl;
else {
if (i != numbi) cout << numwi + 1 << " " << i + 1 << " " << 0 << endl;
}
}
}
}
int cw, cb, lw = 0, lb = 1, lcw, lcb;
if (!w.empty() && !b.empty()) {
cw = w.top().first;
cb = b.top().first;
curw = w.top().second;
curb = b.top().second;
if (cw > cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cb
<< endl;
w.pop();
b.pop();
w.push(make_pair(cw - cb, curw));
} else {
if (cw < cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
w.pop();
b.pop();
b.push(make_pair(cb - cw, curb));
} else {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
w.pop();
b.pop();
lw = cw;
lb = cb;
lcw = curw;
lcb = curb;
}
}
}
while (!w.empty() && !b.empty()) {
cw = w.top().first;
cb = b.top().first;
curw = w.top().second;
curb = b.top().second;
if (cw > cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cb
<< endl;
w.pop();
b.pop();
w.push(make_pair(cw - cb, curw));
} else {
if (cw < cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
w.pop();
b.pop();
b.push(make_pair(cb - cw, curb));
} else {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
if (lw == lb) {
cout << w.top().second + 1 << " " << lcb + 1 << " " << 0 << endl;
}
w.pop();
b.pop();
lw = cw;
lb = cb;
lcw = curw;
lcb = curb;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > G[1000000];
int check, i, j, c, s, n, sum;
bool flag1, flag2;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d %d", &c, &s);
sum += s;
G[c].push_back(make_pair(s, i + 1));
}
sort(G[0].begin(), G[0].end());
sort(G[1].begin(), G[1].end());
i = 0;
j = 0;
check = -1;
while (i < G[0].size() && j < G[1].size()) {
if (G[0][i].first == G[1][j].first) {
cout << G[0][i].second << " " << G[1][j].second << " " << G[1][j].first
<< endl;
if (G[0].size() - i >= G[1].size() - j) {
G[1][j].first = 0;
i++;
} else {
G[0][i].first = 0;
j++;
}
continue;
}
if (G[0][i].first > G[1][j].first) {
cout << G[0][i].second << " " << G[1][j].second << " " << G[1][j].first
<< endl;
G[0][i].first -= G[1][j].first;
j++;
} else {
cout << G[0][i].second << " " << G[1][j].second << " " << G[0][i].first
<< endl;
G[1][j].first -= G[0][i].first;
i++;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > S[3];
int main() {
int n, c, s, w, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c >> s;
if (c == 0)
S[0].insert(make_pair(s, i + 1));
else
S[1].insert(make_pair(s, i + 1));
}
for (int i = 0; i < n - 1; i++) {
w = (S[1].size() < S[0].size());
b = (w == 0);
pair<int, int> v1 = *(S[b].begin()), v2 = *(--S[w].end());
S[b].erase(v1);
S[w].erase(v2);
cout << v1.second << " " << v2.second << " " << v1.first << endl;
S[w].insert(make_pair(v2.first - v1.first, v2.second));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t1, t2, p;
vector<pair<int, int> > black, white;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t1 >> t2;
if (t1)
black.push_back(pair<int, int>(i + 1, t2));
else
white.push_back(pair<int, int>(i + 1, t2));
}
for (int i = 0; i < black.size(); i++) {
int ind = black[i].first;
int cost = black[i].second;
if (!cost) {
cout << ind << " " << white[0].first << " " << 0 << endl;
continue;
}
while (cost) {
if (white[p].second < cost) {
cost -= white[p].second;
cout << ind << " " << white[p].first << " " << white[p].second << endl;
p++;
} else {
white[p].second -= cost;
cout << ind << " " << white[p].first << " " << cost << endl;
cost = 0;
}
}
}
if (p != white.size() - 1) {
for (int i = p + 1; i < white.size(); i++) {
cout << black[0].first << " " << white[i].first << " " << 0 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 55;
vector<int> ve[2];
int s[MAXN], c[MAXN];
int n;
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &s[i]);
ve[c[i]].push_back(i);
}
int l = 0, r = 0;
for (int i = 1; i <= n - 1; i++) {
int u = ve[0][l], v = ve[1][r];
int x = min(s[u], s[v]);
s[u] -= x, s[v] -= x;
if (!s[u] and l + 1 < ((int)ve[0].size()))
l++;
else
r++;
printf("%d %d %d\n", u, v, x);
}
}
|
#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];
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]) {
if (S[B[b]] < S[W[w]]) {
cout << B[b] << " " << W[w] << " " << S[B[b]] << endl;
S[W[w]] -= S[B[b]];
b++;
} else if (S[B[b]] > S[W[w]]) {
cout << B[b] << " " << W[w] << " " << S[W[w]] << endl;
S[B[b]] -= S[W[w]];
w++;
} else if (b == B[0]) {
cout << B[b] << " " << W[w] << " " << S[W[w]] << endl;
S[B[b]] -= S[W[w]];
w++;
} else {
cout << B[b] << " " << W[w] << " " << S[B[b]] << endl;
S[W[w]] -= S[B[b]];
b++;
}
}
}
|
#include <bits/stdc++.h>
const long long oo = 0x3f3f3f3f;
const int _cnt = 1000 * 1000;
const int _p = 1000 * 1000 * 1000 + 7;
long long o(long long x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
using namespace std;
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
int n, c, s, p, q, cnt = 0;
struct ttype {
int s, id;
ttype() {}
ttype(int _s, int _id) {
s = _s;
id = _id;
}
};
vector<ttype> V[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c, &s);
V[c].push_back(ttype(s, i));
}
p = V[0].back().id;
q = V[1].back().id;
while (!V[0].empty() && !V[1].empty()) {
if (V[0].back().s >= V[1].back().s) {
V[0].back().s -= V[1].back().s;
printf("%d %d% d\n", V[0].back().id, V[1].back().id, V[1].back().s);
V[1].pop_back();
cnt++;
continue;
}
if (V[1].back().s >= V[0].back().s) {
V[1].back().s -= V[0].back().s;
printf("%d %d% d\n", V[0].back().id, V[1].back().id, V[0].back().s);
V[0].pop_back();
cnt++;
}
}
if (!V[0].empty()) V[0].pop_back();
if (!V[1].empty()) V[1].pop_back();
while (!V[0].empty()) {
if (cnt >= n - 1) break;
printf("%d %d% d\n", V[0].back().id, q, 0);
cnt++;
V[0].pop_back();
}
while (!V[1].empty()) {
if (cnt >= n - 1) break;
printf("%d %d% d\n", V[1].back().id, p, 0);
V[1].pop_back();
cnt++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0, ch = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (f) x = -x;
}
struct Point {
int x, id;
bool operator<(const Point &A) const { return x > A.x; };
};
priority_queue<Point> v0, v1;
struct Edge {
int x, y;
};
vector<Edge> g[100005];
int main() {
int n;
read(n);
for (int i = 1, x, y; i <= n; i++) {
read(x), read(y);
if (x == 0) v0.push((Point){y, i});
if (x == 1) v1.push((Point){y, i});
}
int tot = 1;
while (v0.size() + v1.size() > 1) {
if (!v0.size() || !v1.size()) return puts("-1"), 0;
Point c0 = v0.top(), c1 = v1.top();
v0.pop(), v1.pop();
if (c0.x < c1.x || (c0.x == c1.x && v0.size() > v1.size())) {
c1.x -= c0.x, v1.push(c1);
g[c1.id].push_back((Edge){c0.id, c0.x});
} else {
c0.x -= c1.x, v0.push(c0);
g[c0.id].push_back((Edge){c1.id, c1.x});
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++)
cout << i << " " << g[i][j].x << " " << g[i][j].y << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, g[2] = {0};
int die[520233] = {0};
struct XY {
int v, pos;
} tp, q[2][520233];
int main() {
int x, y;
scanf("%d", &n);
g[0] = g[1] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
q[x][++g[x]] = (XY){y, i};
}
int p0 = 1, p1 = 1;
for (int nnd = 1; nnd < n; nnd++) {
if (q[0][p0].v < q[1][p1].v || p1 == g[1]) {
printf("%d %d %d\n", q[0][p0].pos, q[1][p1].pos, q[0][p0].v);
q[1][p1].v -= q[0][p0].v;
p0++;
} else {
printf("%d %d %d\n", q[0][p0].pos, q[1][p1].pos, q[1][p1].v);
q[0][p0].v -= q[1][p1].v;
p1++;
}
}
for (; clock() < 998;)
;
return 0;
}
|
#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;
const int maxn = 1e5 + 10;
int c[maxn], s[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> c[i] >> s[i];
set<pair<int, int>> st[2];
for (int i = 0; i < n; ++i) st[c[i]].insert(make_pair(s[i], i));
vector<tuple<int, int, int>> ans;
int t = n - 1;
while (t--) {
int cur = -1;
if (st[0].size() == 1)
cur = 1;
else if (st[1].size() == 1)
cur = 0;
else
cur = (st[0].begin()->first < st[1].begin()->first ? 0 : 1);
int z, w;
tie(w, z) = *st[cur].begin();
st[cur].erase(make_pair(w, z));
int y, x;
tie(y, x) = *st[cur ^ 1].lower_bound(make_pair(w, -1));
ans.emplace_back(z, x, w);
st[cur ^ 1].erase(make_pair(y, x));
st[cur ^ 1].insert(make_pair(y - w, x));
}
for (auto i : ans) {
int a, b, c;
tie(a, b, c) = i;
cout << a + 1 << ' ' << b + 1 << ' ' << c << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 3e5;
struct node {
int val, u;
} a[N];
vector<node> g[N];
bool f(node a, node b) { return a.val < b.val; }
int sz(vector<node> &a) { return (int)a.size(); }
void out(int x, int y, int z) { printf("%d %d %d\n", x, y, z); }
struct tem {
pair<pair<int, int>, int> A[N];
int cur;
tem() { cur = 0; }
void push_back(pair<pair<int, int>, int> x) { A[cur++] = x; }
};
int main() {
int i, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
int x;
node a;
scanf("%d", &x);
scanf("%d", &a.val);
a.u = i + 1;
g[x].push_back(a);
}
sort(g[0].begin(), g[0].end(), f);
sort(g[1].begin(), g[1].end(), f);
int cnt0 = sz(g[0]) - 1;
int cnt1 = 0;
tem res;
int l0, l1;
while (cnt1 < sz(g[1]) and cnt0 > -1) {
node &f0 = g[0][cnt0];
node &f1 = g[1][cnt1];
l0 = f0.u;
l1 = f1.u;
if (f0.val >= f1.val) {
res.push_back({{f0.u, f1.u}, f1.val});
f0.val -= f1.val;
cnt1++;
continue;
}
res.push_back({{f0.u, f1.u}, f0.val});
f1.val -= f0.val;
cnt0--;
}
if (cnt1 >= sz(g[1]))
cnt0--;
else if (cnt0 < 0)
cnt1++;
while (cnt1 < sz(g[1])) res.push_back({{g[1][cnt1++].u, l0}, 0});
while (cnt0 > -1) res.push_back({{g[0][cnt0--].u, l1}, 0});
for (int i = 0; i < res.cur; i++) {
pair<pair<int, int>, int> edge = res.A[i];
out(edge.first.first, edge.first.second, edge.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ts, kk = 1, _DB = 1;
inline int LEN(string a) { return a.length(); }
inline int LEN(char a[]) { return strlen(a); }
template <class T>
inline T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
inline T _max(T a, T b) {
return (a > b ? a : b);
}
template <class T>
inline T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
inline T _sq(T x) {
return x * x;
}
template <class T>
inline T _sqrt(T x) {
return (T)sqrt((double)x);
}
template <class T>
inline T _pow(T x, T y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= x;
}
return z;
}
template <class T>
inline T _gcd(T a, T b) {
a = _abs(a);
b = _abs(b);
if (!b) return a;
return _gcd(b, a % b);
}
template <class T>
inline T _lcm(T a, T b) {
a = _abs(a);
b = _abs(b);
return (a / _gcd(a, b)) * b;
}
template <class T>
inline T _extended(T a, T b, T &x, T &y) {
a = _abs(a);
b = _abs(b);
T g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = _extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
template <class T>
inline T getbit(T x, T i) {
T t = 1;
return (x & (t << i));
}
template <class T>
inline T setbit(T x, T i) {
T t = 1;
return (x | (t << i));
}
template <class T>
inline T resetbit(T x, T i) {
T t = 1;
return (x & (~(t << i)));
}
template <class T>
inline T _bigmod(T n, T m) {
T ans = 1, mult = n % 1000000007;
while (m) {
if (m & 1) ans = (ans * mult) % 1000000007;
m >>= 1;
mult = (mult * mult) % 1000000007;
}
ans %= 1000000007;
return ans;
}
template <class T>
inline T _modinv(T x) {
return _bigmod(x, (T)(1000000007 - 2)) % 1000000007;
}
queue<pair<int, int> > q[2];
int main() {
int n, col, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> col >> x;
q[col].push(make_pair(x, i));
}
while (!q[0].empty() && !q[1].empty()) {
pair<int, int> a[2];
int mn = _min(q[0].front().first, q[1].front().first), p = 1;
for (int i = 0; i <= 1; i++)
a[i] = q[i].front(), q[i].pop(), cout << a[i].second << " ",
a[i].first -= mn;
cout << mn << endl;
if (a[0].first > a[1].first ||
(a[0].first == a[1].first && q[0].size() < q[1].size()))
p = 0;
q[p].push(a[p]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
queue<pair<int, int> > qu[2];
vector<pair<pair<int, int>, int> > ans;
vector<pair<int, int> > e[2];
int main() {
int n, x, val;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &val);
e[x].push_back(make_pair(val, i));
}
sort(e[0].begin(), e[0].end());
sort(e[1].begin(), e[1].end());
for (int i = 0; i < (int)e[0].size(); i++) {
qu[0].push(make_pair(e[0][i].second, e[0][i].first));
}
for (int i = 0; i < (int)e[1].size(); i++) {
qu[1].push(make_pair(e[1][i].second, e[1][i].first));
}
int root = qu[0].front().first, k = 1;
val = qu[0].front().second;
qu[0].pop();
while (!qu[0].empty() || !qu[1].empty()) {
while (1) {
if (val >= qu[k].front().second) {
val -= qu[k].front().second;
int t = qu[k].front().first;
ans.push_back(make_pair(make_pair(root, qu[k].front().first),
qu[k].front().second));
qu[k].pop();
if (qu[k].empty()) {
val = 0;
root = t;
break;
}
} else {
ans.push_back(make_pair(make_pair(root, qu[k].front().first), val));
root = qu[k].front().first;
val = qu[k].front().second - val;
qu[k].pop();
break;
}
}
k = !k;
}
for (int i = 0; i < (int)ans.size(); i++) {
printf("%d %d %d\n", ans[i].first.first, ans[i].first.second,
ans[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int u, v, w;
};
vector<node> edges;
const int maxin = 100000;
class criteria {
public:
bool operator()(pair<int, int> x, pair<int, int> y) {
if (x.first > y.first)
return true;
else if (x.first < y.first)
return false;
return x.second < y.second;
}
};
int main() {
int n, nb, nw;
pair<int, int> w[maxin], b[maxin];
scanf("%d", &n);
int x, y;
nb = 0;
nw = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
if (x == 1) {
b[nb++] = make_pair(y, i + 1);
} else {
w[nw++] = make_pair(y, i + 1);
}
}
sort(w, w + nw, criteria());
sort(b, b + nb, criteria());
int p1 = 0, p2 = 0;
node q;
while (p1 < nw && p2 < nb) {
if (w[p1].first < b[p2].first) {
q.u = w[p1].second;
q.v = b[p2].second;
q.w = w[p1].first;
b[p2].first -= w[p1].first;
p1++;
} else {
q.u = w[p1].second;
q.v = b[p2].second;
q.w = b[p2].first;
w[p1].first -= b[p2].first;
p2++;
}
edges.push_back(q);
}
++p1;
++p2;
while (p1 < nw) {
q.u = w[p1].second;
q.v = b[0].second;
q.w = 0;
edges.push_back(q);
p1++;
}
while (p2 < nb) {
q.u = b[p2].second;
q.v = w[0].second;
q.w = 0;
edges.push_back(q);
p2++;
}
int s = edges.size();
for (int i = 0; i < s; i++) {
printf("%d %d %d \n", edges[i].u, edges[i].v, edges[i].w);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, b, w, c[100005], s, p[100005];
vector<pair<int, int>> node[2];
vector<pair<int, pair<int, int>>> edgeList;
int findSet(int i) { return p[i] == i ? i : p[i] = findSet(p[i]); }
void unionSet(int i, int j) {
int a = findSet(i), b = findSet(j);
if (a != b) {
p[a] = b;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
p[i] = i;
cin >> c[i] >> s;
if (c[i] == 0) {
b = i;
} else {
w = i;
}
node[c[i]].push_back({i, s});
}
sort(node[0].begin(), node[0].end());
sort(node[1].begin(), node[1].end());
int id1 = 0, id2 = 0;
while (id1 < node[0].size() && id2 < node[1].size()) {
int u = node[0][id1].first, v = node[1][id2].first,
w = min(node[0][id1].second, node[1][id2].second);
edgeList.push_back({u, {v, w}});
node[0][id1].second -= w;
node[1][id2].second -= w;
unionSet(u, v);
if (node[0][id1].second == 0) {
id1++;
}
if (node[1][id2].second == 0) {
id2++;
}
}
for (int i = 1; i <= n; i++) {
if (c[b] != c[i] && findSet(b) != findSet(i)) {
edgeList.push_back({b, {i, 0}});
unionSet(b, i);
}
}
for (int i = 1; i <= n; i++) {
if (c[w] != c[i] && findSet(w) != findSet(i)) {
edgeList.push_back({w, {i, 0}});
unionSet(w, i);
}
}
for (int i = 0; i < edgeList.size(); i++) {
cout << edgeList[i].first << " " << edgeList[i].second.first << " "
<< edgeList[i].second.second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 25;
int main(int argc, char *argv[]) {
int n, c, s;
cin >> n;
set<pair<int, int>, greater<pair<int, int> > > B, W;
for (int i = (0), _b = (n); i < (_b); ++i) {
cin >> c >> s;
if (c)
B.insert(pair<int, int>(s, i + 1));
else
W.insert(pair<int, int>(s, i + 1));
}
vector<pair<pair<int, int>, int> > ans;
while (!W.empty() && !B.empty()) {
pair<int, int> w = *W.begin(), b = *B.begin();
W.erase(w), B.erase(b);
int v = min(w.first, b.first);
ans.push_back(
pair<pair<int, int>, int>(pair<int, int>(w.second, b.second), v));
w.first -= v, b.first -= v;
if (!w.first && !b.first) {
if (W.size() > B.size())
B.insert(b);
else
W.insert(w);
} else if (w.first)
W.insert(w);
else
B.insert(b);
}
for (int i = (0), _b = (ans.size()); i < (_b); ++i) {
pair<pair<int, int>, int> x = ans[i];
cout << x.first.first << " " << x.first.second << " " << x.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ts, kk = 1, _DB = 1;
inline int LEN(string a) { return a.length(); }
inline int LEN(char a[]) { return strlen(a); }
template <class T>
inline T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
inline T _max(T a, T b) {
return (a > b ? a : b);
}
template <class T>
inline T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
inline T _sq(T x) {
return x * x;
}
template <class T>
inline T _sqrt(T x) {
return (T)sqrt((double)x);
}
template <class T>
inline T _pow(T x, T y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= x;
}
return z;
}
template <class T>
inline T _gcd(T a, T b) {
a = _abs(a);
b = _abs(b);
if (!b) return a;
return _gcd(b, a % b);
}
template <class T>
inline T _lcm(T a, T b) {
a = _abs(a);
b = _abs(b);
return (a / _gcd(a, b)) * b;
}
template <class T>
inline T _extended(T a, T b, T &x, T &y) {
a = _abs(a);
b = _abs(b);
T g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = _extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
template <class T>
inline T getbit(T x, T i) {
T t = 1;
return (x & (t << i));
}
template <class T>
inline T setbit(T x, T i) {
T t = 1;
return (x | (t << i));
}
template <class T>
inline T resetbit(T x, T i) {
T t = 1;
return (x & (~(t << i)));
}
template <class T>
inline T _bigmod(T n, T m) {
T ans = 1, mult = n % 1000000007;
while (m) {
if (m & 1) ans = (ans * mult) % 1000000007;
m >>= 1;
mult = (mult * mult) % 1000000007;
}
ans %= 1000000007;
return ans;
}
template <class T>
inline T _modinv(T x) {
return _bigmod(x, (T)(1000000007 - 2)) % 1000000007;
}
vector<pair<int, int> > vv[2];
int main() {
int n, col, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> col >> x;
vv[col].push_back(make_pair(x, i));
}
while (!vv[0].empty() && !vv[1].empty()) {
pair<int, int> a[2];
int mn = _min(vv[0].back().first, vv[1].back().first), p = 1;
for (int i = 0; i <= 1; i++)
a[i] = vv[i].back(), vv[i].pop_back(), cout << a[i].second << " ",
a[i].first -= mn;
cout << mn << endl;
if (a[0].first > a[1].first ||
(a[0].first == a[1].first && vv[0].size() < vv[1].size()))
p = 0;
vv[p].push_back(a[p]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
const int INF = 1e9;
const long long LINF = 1e18;
long long mod_sum() { return 0LL; }
template <typename T, typename... Args>
T mod_sum(T a, Args... args) {
return ((a + mod_sum(args...)) % mod + mod) % mod;
}
long long mod_prod() { return 1LL; }
template <typename T, typename... Args>
T mod_prod(T a, Args... args) {
return (a * mod_prod(args...)) % mod;
}
struct ast {
long long u, v, len;
};
vector<ast> ans;
long long solve() {
long long n;
cin >> n;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq1;
for (long long i = 0; i < n; i++) {
long long which, s;
cin >> which >> s;
if (which == 0)
pq0.push({s, i});
else
pq1.push({s, i});
}
long long atlast0 = pq0.top().second, atlast1 = pq1.top().second;
while (!pq0.empty() && !pq1.empty()) {
if (pq0.top().first < pq1.top().first) {
long long v = pq0.top().second;
long long u = pq1.top().second;
long long len = pq0.top().first;
ans.push_back({u, v, len});
long long temp = pq1.top().first - len;
pq0.pop(), pq1.pop();
pq1.push({temp, u});
} else {
long long v = pq1.top().second;
long long u = pq0.top().second;
long long len = pq1.top().first;
ans.push_back({u, v, len});
long long temp = pq0.top().first - len;
pq0.pop(), pq1.pop();
pq0.push({temp, u});
}
}
if ((long long)ans.size() < n - 1 && !pq0.empty()) {
pq0.pop();
while (!pq0.empty())
ans.push_back({atlast1, pq0.top().second, 0}), pq0.pop();
} else if ((long long)ans.size() < n - 1 && !pq1.empty()) {
pq1.pop();
while (!pq1.empty())
ans.push_back({atlast0, pq1.top().second, 0}), pq1.pop();
}
for (auto xxx : ans)
cout << xxx.u + 1 << " " << xxx.v + 1 << " " << xxx.len << '\n';
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> s;
vector<int> c;
vector<pair<int, int> > bl;
vector<pair<int, int> > wt;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int cc, w;
cin >> cc >> w;
c.push_back(cc);
s.push_back(w);
};
for (int i = 0; i < n; ++i) {
if (c[i] == 0) {
bl.push_back(make_pair(-s[i], i + 1));
} else {
wt.push_back(make_pair(-s[i], i + 1));
}
}
sort(bl.begin(), bl.end());
sort(wt.begin(), wt.end());
vector<pair<int, int> >::iterator blc = bl.begin();
vector<pair<int, int> >::iterator wtc = wt.begin();
while (blc != bl.end() && wtc != wt.end()) {
if (blc->first < wtc->first && wt.end() - wtc > 1 || bl.end() - blc == 1) {
cout << blc->second << ' ' << wtc->second << ' ' << -wtc->first << endl;
blc->first -= wtc->first;
++wtc;
} else {
cout << blc->second << ' ' << wtc->second << ' ' << -blc->first << endl;
wtc->first -= blc->first;
++blc;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int par[1000001], col[1000001], sum[1000001];
set<pair<long long int, long long int> > white, black;
vector<long long int> parent;
vector<pair<pair<long long int, long long int>, long long int> > edge;
vector<long long int> comp[100001][2];
long long int find(long long int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
int main() {
long long int i, j, n, x, y, xs, ys, zs, xp, yp;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> col[i] >> sum[i];
if (col[i] == 0)
white.insert(make_pair(sum[i], i));
else
black.insert(make_pair(sum[i], i));
}
while (white.size() >= 1 && black.size() >= 1) {
x = (*(white.begin())).second;
xs = (*(white.begin())).first;
y = (*(black.begin())).second;
ys = (*(black.begin())).first;
white.erase(white.begin());
black.erase(black.begin());
zs = min(xs, ys);
edge.push_back(make_pair(make_pair(x, y), zs));
xs -= zs;
ys -= zs;
if (xs > 0) white.insert(make_pair(xs, x));
if (ys > 0) black.insert(make_pair(ys, y));
}
for (i = 1; i <= n; i++) par[i] = i;
for (i = 0; i < edge.size(); i++) {
x = edge[i].first.first;
y = edge[i].first.second;
xp = find(x);
yp = find(y);
if (xp != yp) par[xp] = yp;
}
for (i = 1; i <= n; i++) {
if (par[i] == i) parent.push_back(i);
}
for (i = 1; i <= n; i++) {
xp = find(i);
if (col[i] == 0)
comp[xp][0].push_back(i);
else
comp[xp][1].push_back(i);
}
vector<long long int> both, w, b;
for (i = 0; i < parent.size(); i++) {
if (comp[parent[i]][0].size() && comp[parent[i]][1].size())
both.push_back(parent[i]);
else if (comp[parent[i]][0].size() && !comp[parent[i]][1].size())
w.push_back(parent[i]);
else
b.push_back(parent[i]);
}
long long int bl, wh;
if (both.size()) {
wh = comp[both[0]][0][0];
bl = comp[both[0]][1][0];
for (i = 0; i < b.size(); i++)
edge.push_back(make_pair(make_pair(wh, b[i]), 0));
for (i = 0; i < w.size(); i++)
edge.push_back(make_pair(make_pair(bl, w[i]), 0));
for (i = 1; i < both.size(); i++) {
long long int node = comp[both[i]][0][0];
edge.push_back(make_pair(make_pair(node, bl), 0));
}
} else {
bl = b[0];
for (i = 0; i < w.size(); i++)
edge.push_back(make_pair(make_pair(w[i], bl), 0));
wh = w[0];
for (i = 1; i < b.size(); i++)
edge.push_back(make_pair(make_pair(b[i], wh), 0));
}
for (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;
const double pi = acos(-1.0);
const double eps = 1e-8;
template <class T>
inline void read(T &i) {
bool minus = false;
char c;
for (c = getchar(); (c < '0' || c > '9') && (c != '-'); c = getchar())
;
if (c == '-') {
minus = true;
c = '0';
}
for (i = 0; c >= '0' && c <= '9'; c = getchar())
i = (i << 3) + (i << 1) + (c - 48);
if (minus) i = (~i) + 1;
}
int gcd(int a, int b) {
if (a == b) return b;
if (b < a) return gcd(a % b, b);
return gcd(a, b % a);
}
vector<string> parse(string s, string c) {
int len = c.length(), p = -len, np;
vector<string> ans;
do {
np = s.find(c, p + len);
ans.push_back(s.substr(p + len, np - p - len));
p = np;
} while (p != string::npos);
return ans;
}
int main() {
int n, x, y;
cin >> n;
priority_queue<pair<int, int> > q[2];
for (int i = 1; i <= n; i++) {
cin >> x >> y;
q[x].push(make_pair(-y, i));
}
for (int i = 1; i <= n - 1; i++) {
pair<int, int> p1 = q[0].top(), p2 = q[1].top();
q[0].pop();
q[1].pop();
x = -p1.first;
y = -p2.first;
cout << p1.second << " " << p2.second << " " << min(x, y) << endl;
;
if ((x > y && (not q[1].empty())) || q[0].empty())
q[0].push(make_pair(-(x - y), p1.second));
else
q[1].push(make_pair(-(y - x), p2.second));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ts, kk = 1, _DB = 1;
inline int LEN(string a) { return a.length(); }
inline int LEN(char a[]) { return strlen(a); }
template <class T>
inline T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
inline T _max(T a, T b) {
return (a > b ? a : b);
}
template <class T>
inline T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
inline T _sq(T x) {
return x * x;
}
template <class T>
inline T _sqrt(T x) {
return (T)sqrt((double)x);
}
template <class T>
inline T _pow(T x, T y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= x;
}
return z;
}
template <class T>
inline T _gcd(T a, T b) {
a = _abs(a);
b = _abs(b);
if (!b) return a;
return _gcd(b, a % b);
}
template <class T>
inline T _lcm(T a, T b) {
a = _abs(a);
b = _abs(b);
return (a / _gcd(a, b)) * b;
}
template <class T>
inline T _extended(T a, T b, T &x, T &y) {
a = _abs(a);
b = _abs(b);
T g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = _extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
template <class T>
inline T getbit(T x, T i) {
T t = 1;
return (x & (t << i));
}
template <class T>
inline T setbit(T x, T i) {
T t = 1;
return (x | (t << i));
}
template <class T>
inline T resetbit(T x, T i) {
T t = 1;
return (x & (~(t << i)));
}
template <class T>
inline T _bigmod(T n, T m) {
T ans = 1, mult = n % 1000000007;
while (m) {
if (m & 1) ans = (ans * mult) % 1000000007;
m >>= 1;
mult = (mult * mult) % 1000000007;
}
ans %= 1000000007;
return ans;
}
template <class T>
inline T _modinv(T x) {
return _bigmod(x, (T)(1000000007 - 2)) % 1000000007;
}
priority_queue<pair<int, int> > q[2];
int main() {
int n, col, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> col >> x;
q[col].push(make_pair(x, i));
}
while (!q[0].empty() && !q[1].empty()) {
pair<int, int> a[2];
for (int i = 0; i <= 1; i++)
a[i] = q[i].top(), q[i].pop(), cout << a[i].second << " ";
int mn = _min(a[0].first, a[1].first), p;
cout << mn << endl;
for (int i = 0; i <= 1; i++) a[i].first -= mn;
if (a[0].first > a[1].first ||
(a[0].first == a[1].first && q[0].size() < q[1].size()))
p = 0;
else
p = 1;
q[p].push(a[p]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
int N, w, W[100100], b, B[100100], C[100100], S[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++] = i;
else
W[w++] = i;
}
w--, b--;
while (w >= 0 && b >= 0) {
int s = min(S[W[w]], S[B[b]]);
cout << W[w] << " " << B[b] << " " << s << endl;
S[W[w]] -= s;
S[B[b]] -= s;
if (S[B[b]])
w--;
else
b--;
}
w--;
b--;
while (w >= 0) cout << W[w] << " " << B[0] << " " << 0 << endl, w--;
while (b >= 0) cout << W[0] << " " << B[b] << " " << 0 << endl, b--;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
int 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;
}
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]]) {
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++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int maxm = 1e6 + 100;
vector<pair<int, int> > a[2];
vector<pair<pair<int, int>, int> > ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int c, s;
cin >> c >> s;
a[c].push_back({s, i});
}
sort(a[0].begin(), a[0].end());
sort(a[1].begin(), a[1].end());
int i = 0, j = 0;
while (i < a[0].size() && j < a[1].size()) {
if (a[0][i].first < a[1][j].first) {
ans.push_back({{a[0][i].second, a[1][j].second}, a[0][i].first});
a[1][j].first -= a[0][i].first;
a[0][i].first = 0;
i++;
} else {
ans.push_back({{a[0][i].second, a[1][j].second}, a[1][j].first});
a[0][i].first -= a[1][j].first;
a[1][j].first = 0;
j++;
}
}
if (i == a[0].size()) {
j++;
while (j < a[1].size()) {
ans.push_back({{a[0][i - 1].second, a[1][j].second}, 0});
j++;
}
} else {
i++;
while (i < a[0].size()) {
ans.push_back({{a[1][j - 1].second, a[0][i].second}, 0});
i++;
}
}
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first.first + 1 << ' ' << ans[i].first.second + 1 << ' '
<< ans[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const double g = 10.0, eps = 1e-4;
const int N = 100000 + 10, maxn = 500 + 100, inf = 0x3f3f3f;
pair<int, int> v[2][N];
int vv[2];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int c, s;
cin >> c >> s;
v[c][++vv[c]] = make_pair(s, i);
}
sort(v[0] + 1, v[0] + 1 + vv[0]);
sort(v[1] + 1, v[1] + 1 + vv[1]);
for (int i = 1, j = 1; i <= vv[0] && j <= vv[1];) {
int t = min(v[0][i].first, v[1][j].first);
cout << v[0][i].second << " " << v[1][j].second << " " << t << endl;
v[0][i].first -= t;
v[1][j].first -= t;
if (v[0][i].first)
j++;
else if (v[1][j].first)
i++;
else if (i < vv[0])
i++;
else
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int pos, sum;
} node;
bool cmp(node x, node y) { return x.sum > y.sum; }
node c1[100009], c0[100009];
int main() {
int n;
scanf("%d", &n);
int tot0 = 0, tot1 = 0;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x == 0) {
c0[tot0].pos = i;
c0[tot0].sum = y;
tot0++;
} else {
c1[tot1].pos = i;
c1[tot1].sum = y;
tot1++;
}
}
sort(c1, c1 + tot1, cmp);
sort(c0, c0 + tot0, cmp);
int cur = c0[0].pos;
int sum = c0[0].sum;
int c = 0;
int i = 1, j = 0;
while (i < tot0 || j < tot1) {
if (c == 0) {
int pos = c1[j].pos;
int tmp = c1[j].sum;
if (j >= tot1) break;
j++;
printf("%d %d %d\n", cur, pos, min(tmp, sum));
if (tmp < sum) {
sum -= tmp;
} else {
sum = tmp - sum;
c = 1;
cur = pos;
}
} else {
int pos = c0[i].pos;
int tmp = c0[i].sum;
if (i >= tot0) break;
i++;
printf("%d %d %d\n", cur, pos, min(tmp, sum));
if (tmp < sum)
sum -= tmp;
else {
sum = tmp - sum;
c = 0;
cur = pos;
}
}
}
for (; i < tot0; i++) printf("%d %d 0\n", c0[i].pos, c1[0].pos);
for (; j < tot1; j++) printf("%d %d 0\n", c1[j].pos, c0[0].pos);
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, x, y, t, a1, b1;
struct data {
int x, id;
} a[101001], b[101001];
bool cmp(const data& a, const data& b) { return a.x > b.x; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &k);
if (k == 0) {
scanf("%d", &a[++a1].x);
a[a1].id = i;
} else {
scanf("%d", &b[++b1].x);
b[b1].id = i;
}
}
sort(a + 1, a + 1 + a1, cmp);
sort(b + 1, b + 1 + b1, cmp);
i = j = 1;
while (i <= a1 && j <= b1) {
printf("%d %d %d\n", a[i].id, b[j].id, min(a[i].x, b[j].x));
x = min(a[i].x, b[j].x);
a[i].x -= x;
b[j].x -= x;
if (a[i].x)
j++;
else if (b[j].x)
i++;
else {
if (i < a1)
i++;
else
j++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 25;
struct compare {
bool operator()(const pair<int, int> &p1, const pair<int, int> &p2) {
return p1.first > p2.first;
}
};
int main(int argc, char *argv[]) {
int n, c, s;
cin >> n;
priority_queue<pair<int, int>, vector<pair<int, int> >, compare> B, W;
for (int i = (0), _b = (n); i < (_b); ++i) {
cin >> c >> s;
if (c)
B.push(pair<int, int>(s, i + 1));
else
W.push(pair<int, int>(s, i + 1));
}
vector<pair<pair<int, int>, int> > ans;
while (!W.empty() && !B.empty()) {
pair<int, int> w = W.top(), b = B.top();
W.pop(), B.pop();
int v = min(w.first, b.first);
ans.push_back(
pair<pair<int, int>, int>(pair<int, int>(w.second, b.second), v));
w.first -= v, b.first -= v;
if (!w.first && !b.first) {
if (W.size() > B.size())
B.push(b);
else
W.push(w);
} else if (w.first)
W.push(w);
else
B.push(b);
}
for (int i = (0), _b = (ans.size()); i < (_b); ++i) {
pair<pair<int, int>, int> x = ans[i];
cout << x.first.first << " " << x.first.second << " " << x.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int v, s;
node() { v = s = 0; }
node(int vv, int ss) {
v = vv;
s = ss;
}
bool operator<(const node& b) const {
return s < b.s || (s == b.s && v < b.v);
}
};
int n, s, c;
set<node> w, b;
node getmax(set<node>& a) {
set<node>::iterator i = a.end();
i--;
node ans = *i;
a.erase(i);
return ans;
}
node getmin(set<node>& a) {
set<node>::iterator i = a.begin();
node ans = *i;
a.erase(i);
return ans;
}
int main() {
scanf("%d\n", &n);
w.clear();
b.clear();
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c, &s);
if (c == 0)
w.insert(node(i, s));
else
b.insert(node(i, s));
}
for (int i = 1; i < n; i++) {
if (((*b.begin()).s < (*w.begin()).s && b.size() != 1) || w.size() == 1) {
node x = getmin(b);
node y = getmax(w);
printf("%d %d %d\n", x.v, y.v, x.s);
w.insert(node(y.v, y.s - x.s));
} else {
node x = getmin(w);
node y = getmax(b);
printf("%d %d %d\n", x.v, y.v, x.s);
b.insert(node(y.v, y.s - x.s));
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.