text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned short nrOrders;
unsigned short depth;
scanf("%hu %hu", &nrOrders, &depth);
map<unsigned, unsigned, greater<unsigned>> bid;
map<unsigned, unsigned> ask;
map<unsigned, unsigned>::iterator it;
char direction;
unsigned price;
unsigned short quantity;
for (unsigned short o = 0; o < nrOrders; ++o) {
scanf(" %c %u %hu", &direction, &price, &quantity);
if (direction == 'B') {
if ((it = bid.find(price)) != bid.end())
it->second += quantity;
else
bid.insert(make_pair(price, quantity));
}
if (direction == 'S') {
if ((it = ask.find(price)) != ask.end())
it->second += quantity;
else
ask.insert(make_pair(price, quantity));
}
}
unsigned short counter;
counter = 0;
it = ask.begin();
while (it != ask.end() && counter < depth) {
++it;
++counter;
}
while (counter) {
--it;
--counter;
printf("S %u %u\n", it->first, it->second);
}
counter = 0;
it = bid.begin();
while (it != bid.end() && counter < depth) {
printf("B %u %u\n", it->first, it->second);
++it;
++counter;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p1[10002], p2[10002];
int n, s, i, z, z1, p[10002], q[10002], mark[10002], j;
char k[10002];
int main() {
cin >> n >> s;
for (i = 1; i <= n; i++) cin >> k[i] >> p[i] >> q[i];
for (i = 1; i <= n; i++) {
if (mark[i] == 0)
for (j = i + 1; j <= n; j++) {
if (k[i] == k[j] && p[i] == p[j]) {
q[i] += q[j];
mark[j] = 1;
}
}
}
for (i = 1; i <= n; i++) {
if (k[i] == 'S' && mark[i] == 0) {
z++;
p1[z] = make_pair(p[i], q[i]);
}
if (k[i] == 'B' && mark[i] == 0) {
z1++;
p2[z1] = make_pair(p[i], q[i]);
}
}
sort(p1 + 1, p1 + z + 1);
sort(p2 + 1, p2 + z1 + 1);
for (i = s; i >= 1; i--)
if (z < i)
continue;
else
cout << "S"
<< " " << p1[i].first << " " << p1[i].second << endl;
for (i = z1; i >= z1 - s + 1; i--)
if (i <= 0)
break;
else
cout << "B"
<< " " << p2[i].first << " " << p2[i].second << endl;
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T POW(T x, T y) {
T ret = 1;
while (y--) {
ret *= x;
}
return ret;
}
template <class T>
inline bool EQUAL(T x, T y) {
if (fabs(x - y) < 1e-9) return true;
return false;
}
struct Data {
int p, q;
} buy[1004], buy2[1004], sell[1004], sell2[1004];
bool cmp(Data a, Data b) { return a.p < b.p; }
bool cmp2(Data a, Data b) { return a.p > b.p; }
int main() {
int n, s, pi, qi, mn;
char di;
cin >> n >> s;
int bb = 0, ss = 0;
for (int i = 0; i < n; i++) {
cin >> di >> pi >> qi;
if (di == 'B') {
buy[bb].p = pi;
buy[bb].q = qi;
bb++;
}
if (di == 'S') {
sell[ss].p = pi;
sell[ss].q = qi;
ss++;
}
}
sort(buy, buy + bb, cmp2);
sort(sell, sell + ss, cmp);
int idx;
if (ss) {
idx = 1;
sell2[0] = sell[0];
for (int i = 1; i < ss; i++) {
if (sell[i].p == sell2[idx - 1].p)
sell2[idx - 1].q += sell[i].q;
else {
sell2[idx] = sell[i];
idx++;
}
}
mn = min(s, idx);
sort(sell2, sell2 + mn, cmp2);
for (int i = 0; i < mn; i++) printf("S %d %d\n", sell2[i].p, sell2[i].q);
}
if (bb) {
idx = 1;
buy2[0] = buy[0];
for (int i = 1; i < bb; i++) {
if (buy[i].p == buy2[idx - 1].p)
buy2[idx - 1].q += buy[i].q;
else {
buy2[idx] = buy[i];
idx++;
}
}
mn = min(s, idx);
for (int i = 0; i < mn; i++) printf("B %d %d\n", buy2[i].p, buy2[i].q);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ta, tb;
char x[10];
map<int, int> y[2];
map<int, int>::iterator it;
int main() {
scanf("%d%d", &n, &m);
while (n--) {
scanf("%s%d%d", x, &ta, &tb);
y[x[0] == 'B'][ta] += tb;
}
it = y[0].begin();
for (int a = 0; a < m; a++)
if (it != y[0].end()) it++;
while (1) {
if (it != y[0].begin())
it--;
else
break;
printf("S %d %d\n", it->first, it->second);
}
it = y[1].end();
for (int a = 0; a < m; a++) {
if (it != y[1].begin())
it--;
else
break;
printf("B %d %d\n", it->first, it->second);
}
return 0;
}
|
#include <bits/stdc++.h>
int cmpfunc(const void* a, const void* b) { return (*(int*)b - *(int*)a); }
int main() {
int n, s, p[1009], q[1009], i, j, k, m, buy[100009] = {0}, sell[100009] = {0},
count;
char d[1009];
scanf("%d %d", &n, &s);
for (i = 1; i <= n; i++) {
getchar();
scanf("%c %d %d", &d[i], &p[i], &q[i]);
}
for (i = 1; i <= n; i++) {
if (d[i] == 'B') {
buy[p[i]] += q[i];
} else {
sell[p[i]] += q[i];
}
}
count = s;
for (i = 0; i <= 100000 && count; i++) {
if (sell[i] > 0) {
count--;
}
}
for (i = i - 1; i >= 1; i--) {
if (sell[i] > 0) {
printf("S %d %d\n", i, sell[i]);
}
}
count = s;
for (i = 100000; i >= 0 && count; i--) {
if (buy[i] > 0) {
printf("B %d %d\n", i, buy[i]);
count--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, S;
struct sell {
long long int p;
long long int q;
} s[1010];
struct buy {
long long int p;
long long int q;
} b[1010];
bool cmp1(sell s1, sell s2) { return s1.p < s2.p; }
bool cmp2(buy b1, buy b2) { return b1.p > b2.p; }
bool cmp3(sell s1, sell s2) { return s1.p > s2.p; }
int main() {
cin >> N >> S;
char d;
int l1 = 0, l2 = 0;
for (int i = 0; i < N; i++) {
cin >> d;
if (d == 'S') {
cin >> s[l1].p >> s[l1].q;
l1++;
} else {
cin >> b[l2].p >> b[l2].q;
l2++;
}
}
sort(s, s + l1, cmp1);
sort(b, b + l2, cmp2);
vector<sell> vs;
vector<buy> vb;
for (int i = 1; i < l1; i++) {
if (s[i].p == s[i - 1].p) {
s[i].q += s[i - 1].q;
} else {
vs.push_back(s[i - 1]);
}
}
if (s[l1 - 1].p == s[l1 - 2].p) vs.push_back(s[l1 - 1]);
if (s[l1 - 1].p != s[l1 - 2].p) vs.push_back(s[l1 - 1]);
for (int i = 1; i < l2; i++) {
if (b[i].p == b[i - 1].p) {
b[i].q += b[i - 1].q;
} else {
vb.push_back(b[i - 1]);
}
}
if (b[l2 - 1].p == b[l2 - 2].p) vb.push_back(b[l2 - 1]);
if (b[l2 - 1].p != b[l2 - 2].p) vb.push_back(b[l2 - 1]);
if (S < vs.size())
sort(vs.begin(), vs.begin() + S, cmp3);
else
sort(vs.begin(), vs.end(), cmp3);
for (int i = 0; i < S && i < vs.size(); i++)
if (vs[i].p > 0 || vs[i].q > 0) {
cout << "S " << vs[i].p << " " << vs[i].q << endl;
}
for (int i = 0; i < vb.size() && i < S; i++)
if (vb[i].p > 0 || vb[i].q > 0)
cout << "B " << vb[i].p << " " << vb[i].q << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, s;
cin >> n >> s;
map<long long, long long> b, se;
for (long long i = 0; i < n; i++) {
char c;
cin >> c;
long long p, q;
cin >> p >> q;
if (c == 'B')
b[p] += q;
else
se[p] += q;
}
while (se.size() > s) se.erase(--se.end());
for (auto it = se.rbegin(); it != se.rend(); it++) {
cout << "S ";
cout << it->first << ' ' << it->second << '\n';
}
while (b.size() > s) b.erase(b.begin());
for (auto it = b.rbegin(); it != b.rend(); it++) {
cout << "B ";
cout << it->first << ' ' << it->second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct order {
char d;
int p;
int q;
};
bool myComp(order a, order b) {
if (a.d == 'S' && b.d == 'B')
return true;
else if (a.d == 'B' && b.d == 'S')
return false;
else if (a.d == b.d)
return a.p > b.p;
}
int merge(order A[], int n) {
int k;
order B[n];
B[0] = A[0];
k = 1;
for (int i = 0; i < n - 1; i++) {
if (A[i].d == A[i + 1].d && A[i].p == A[i + 1].p) {
B[k - 1].q += A[i + 1].q;
} else {
B[k] = A[i + 1];
k++;
}
}
for (int i = 0; i < k; i++) A[i] = B[i];
return k;
}
int main() {
std::ios::sync_with_stdio(false);
int n, s;
order A[1000];
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> A[i].d;
cin >> A[i].p;
cin >> A[i].q;
}
sort(A, A + n, myComp);
int new_size = merge(A, n);
int Scount = 0, Bcount = 0;
for (int i = 0; i < new_size; i++) {
if (A[i].d == 'S')
Scount++;
else
Bcount++;
}
for (int i = (Scount <= s ? 0 : Scount - s); i < Scount; i++)
cout << A[i].d << " " << A[i].p << " " << A[i].q << endl;
for (int i = Scount; i < Scount + (Bcount >= s ? s : Bcount); i++)
cout << A[i].d << " " << A[i].p << " " << A[i].q << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> b;
map<int, int> s;
map<int, int> e;
int i = 0, t2, t3, f1 = m, f2 = m;
char t1;
for (i = 0; i < n; i++) {
cin >> t1 >> t2 >> t3;
if (t1 == 'B') {
b[t2] += t3;
} else {
s[t2] += t3;
}
}
int cnt = m;
map<int, int>::reverse_iterator it;
map<int, int>::iterator it2;
if (m >= s.size()) {
for (it = s.rbegin(); it != s.rend(); it++) {
cout << "S"
<< " " << it->first << " " << it->second << "\n";
}
}
cnt = m;
if (m < s.size()) {
for (it2 = s.begin(); it2 != s.end(); it2++) {
if (cnt > 0) {
e[it2->first] = it2->second;
cnt--;
} else {
break;
}
}
for (it = e.rbegin(); it != e.rend(); it++) {
cout << "S"
<< " " << it->first << " " << it->second << "\n";
}
}
if (m >= b.size()) {
for (it = b.rbegin(); it != b.rend(); it++) {
cout << "B"
<< " " << it->first << " " << it->second << "\n";
}
}
cnt = m;
if (m < b.size()) {
for (it = b.rbegin(); it != b.rend(); it++) {
if (cnt > 0) {
cout << "B"
<< " " << it->first << " " << it->second << "\n";
cnt--;
} else {
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> s, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int cntb, cnts;
cntb = cnts = 0;
for (int i = 1; i <= n; i++) {
char x;
int q, w;
cin >> x >> q >> w;
if (x == 'B') {
if (!b[-q]) {
cntb++;
}
b[-q] += w;
} else {
if (!s[-q]) {
cnts++;
}
s[-q] += w;
}
}
cntb = min(cntb, m);
if (cnts >= m) {
cnts -= m;
} else
cnts = 0;
for (map<int, int>::iterator i = s.begin(); i != s.end(); i++) {
if (cnts) {
cnts--;
continue;
}
cout << "S " << -i->first << " " << i->second << '\n';
}
for (map<int, int>::iterator i = b.begin(); i != b.end(); i++) {
cout << "B " << -i->first << " " << i->second << '\n';
cntb--;
if (!cntb) {
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int buy[100005], sell[100005];
int main() {
int n, s, p, q, i, j;
char d;
cin >> n >> s;
for (i = 0; i < n; i++) {
cin >> d >> p >> q;
if (d == 'B')
buy[p] += q;
else
sell[p] += q;
}
vector<pair<int, int> > S, B;
for (i = 0; i < 100005; i++) {
if (sell[i]) {
S.push_back(make_pair(i, sell[i]));
}
}
for (i = 0; i < 100005; i++) {
if (buy[i]) {
B.push_back(make_pair(i, buy[i]));
}
}
for (i = min(s - 1, (int)S.size() - 1); i >= 0; i--) {
cout << "S"
<< " " << S[i].first << " " << S[i].second << endl;
}
for (i = B.size() - 1, j = 0; i >= 0 && j < s; i--, j++) {
cout << "B"
<< " " << B[i].first << " " << B[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, M, i, tip, p, v, cnt;
int m[2][100010];
int main() {
scanf("%d %d\n", &n, &M);
for (i = 1; i <= n; ++i) {
scanf("%c %d %d\n", &tip, &p, &v);
if (tip == 'S')
m[1][p] += v;
else
m[0][p] += v;
}
cnt = 0;
for (i = 0; i <= 100000; ++i) {
if (m[1][i] != 0) cnt++;
if (cnt == M) break;
}
for (; i >= 0; --i)
if (m[1][i] != 0) printf("S %d %d\n", i, m[1][i]);
cnt = 0;
for (i = 100000; i >= 0; --i)
if (m[0][i] != 0) {
cnt++;
printf("B %d %d\n", i, m[0][i]);
if (cnt == M) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s, p, q;
char ch;
vector<pair<int, int>> v;
map<int, int> B, S;
int main() {
cin >> n >> s;
while (n--) {
cin >> ch >> p >> q;
if (ch == 'B')
B[p] += q;
else
S[p] += q;
}
for (auto it : S) v.push_back({it.first, it.second});
sort(v.begin(), v.end());
reverse(v.begin(), min(v.begin() + s, v.end()));
for (int i = 0; i < min(int(v.size()), s); i++)
cout << "S " << v[i].first << " " << v[i].second << endl;
v.clear();
for (auto it : B) v.push_back({it.first, it.second});
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < min(int(v.size()), s); i++)
cout << "B " << v[i].first << " " << v[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
char o;
map<int, int> s;
map<int, int> b;
map<int, int>::iterator its;
map<int, int>::iterator itb;
for (int i = 0; i < n; i++) {
cin >> o;
int p, d;
cin >> p >> d;
if (o == 'S') {
s[p] += d;
}
if (o == 'B') {
b[p] += d;
}
}
if (!s.empty()) {
its = s.begin();
if (d < s.size())
for (int i = 0; i < d - 1; i++) {
its++;
}
else {
its = s.end();
its--;
}
}
if (!b.empty()) {
itb = b.end();
itb--;
}
if (!s.empty())
for (int i = 0; i < d && i < s.size(); i++) {
cout << 'S' << ' ' << its->first << ' ' << its->second << endl;
its--;
}
if (!b.empty())
for (int i = 0; i < d && i < b.size(); i++) {
cout << 'B' << ' ' << itb->first << ' ' << itb->second << endl;
itb--;
}
return 0;
}
|
#include <bits/stdc++.h>
int i, j, s, a, p, q, sz, st[100002], x[100002], y[100002];
char S[1];
int main() {
scanf("%d%d", &a, &s);
for (i = 0; i < a; i++) {
scanf("%s%d%d", S, &p, &q);
if (S[0] == 'B')
x[p] += q;
else
y[p] += q;
}
sz = 0;
for (i = 0; i <= 100000; i++) {
if (sz >= s) break;
if (y[i]) {
st[sz++] = i;
}
}
for (i = sz - 1; i >= 0; i--) printf("S %d %d\n", st[i], y[st[i]]);
sz = 0;
for (i = 100000; i >= 0; i--) {
if (sz >= s) break;
if (x[i]) {
printf("B %d %d\n", i, x[i]);
sz++;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, s, p, q;
map<int, int> sell, buy;
vector<pair<int, int>> v;
char d;
cin >> n >> s;
while (n--) {
cin >> d >> p >> q;
if (d == 'B') {
if (buy.find(p) == buy.end()) {
buy[p] = q;
} else {
buy[p] += q;
}
} else {
if (sell.find(p) == sell.end())
sell[p] = q;
else
sell[p] += q;
}
}
map<int, int>::iterator it;
int len = sell.size();
if (len) {
n = min(s, (int)sell.size());
it = sell.begin();
advance(it, n - 1);
for (int i = 0; i < n; i++) {
cout << "S " << it->first << " " << it->second << endl;
it--;
}
}
len = buy.size();
if (len) {
n = min(s, (int)buy.size());
it = buy.end();
it--;
for (int i = 0; i < n; i++) {
cout << "B " << it->first << " " << it->second << endl;
it--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
void fast() {
ios_base::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
}
void online_judge() {}
const int flag_max = 0x3f3f3f3f;
const long long OO = 2e9 + 10;
const double EPS = (1e-8);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
const long long MOD = 1e9 + 7;
long long Power(long long n, long long deg) {
if (!deg)
return 1;
else if (deg & 1)
return (Power(n, deg - 1) * n) % MOD;
else {
long long half = Power(n, deg / 2) % MOD;
return ((half * half) % MOD);
}
return 0;
}
map<pair<char, long long>, long long> order;
int main() {
fast();
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
char a;
int x, y;
cin >> a >> x >> y;
order[{a, x}] += y;
}
vector<pair<long long, long long> > out, in;
for (auto x : order) {
if (x.first.first == 'S') {
in.push_back({x.first.second, x.second});
} else {
out.push_back({x.first.second, x.second});
}
}
sort(((in).begin()), ((in).end()));
sort(out.rbegin(), out.rend());
if (s > in.size()) {
for (int i = in.size() - 1; i >= 0; i--)
cout << 'S' << " " << in[i].first << " " << in[i].second << '\n';
} else {
for (int i = s - 1; i >= 0; i--)
cout << "S " << in[i].first << " " << in[i].second << '\n';
}
for (int i = 0; i < out.size() && i < s; i++)
cout << "B " << out[i].first << " " << out[i].second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
map<int, int> by, sl;
for (int i = 0; i < n; i++) {
int p, q;
char a;
cin >> a >> p >> q;
if (a == 'B') {
by[p] += q;
} else
sl[p] += q;
}
int cnt = 0;
while (sl.size() > s) {
auto it = sl.end();
it--;
sl.erase(it);
}
if (!sl.empty()) {
auto it = sl.end();
it--;
while (it != sl.begin()) {
cout << "S " << it->first << " " << it->second << endl;
it--;
}
cout << "S " << it->first << " " << it->second << endl;
}
if (!by.empty()) {
auto it = by.end();
it--;
while (cnt != s && it != by.begin()) {
cout << "B"
<< " " << it->first << " " << it->second << endl;
cnt++;
it--;
}
if (cnt != s) cout << "B " << it->first << " " << it->second;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, s;
map<long long, long long> B, S;
cin >> n >> s;
while (n--) {
long long p, q;
char c;
cin >> c >> p >> q;
if (c == 'B')
B[p] += q;
else {
S[p] += q;
}
}
int i = 1, j = 1;
vector<pair<int, int> > AS;
map<long long, long long>::iterator it = S.begin();
while (i <= s && it != S.end()) {
AS.push_back(make_pair(it->first, it->second));
it++;
i++;
}
for (int i = AS.size() - 1; i >= 0; i--) {
cout << "S " << AS[i].first << " " << AS[i].second << endl;
}
for (map<long long, long long>::reverse_iterator it2 = B.rbegin();
it2 != B.rend(); it2++) {
if (j > s) break;
cout << "B " << it2->first << " " << it2->second << endl;
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long volume[100001][2];
vector<long long> sell, buy;
int main() {
long long n, s;
cin >> n >> s;
for (long long i = 0; i < n; i++) {
char a;
long long b, c, d;
cin >> a >> b >> c;
if (a == 'B')
d = 1;
else
d = 0;
if (volume[b][d] == 0) {
if (d == 0)
sell.push_back(b);
else
buy.push_back(b);
}
volume[b][d] += c;
}
sort(buy.begin(), buy.end());
sort(sell.begin(), sell.end());
for (long long i = 0; i < s; i++) {
if (s - i - 1 < sell.size() && s - i - 1 >= 0)
cout << "S " << sell[s - i - 1] << " " << volume[sell[s - i - 1]][0]
<< endl;
}
for (long long i = 0; i < s; i++) {
if (buy.size() - i - 1 >= 0)
cout << "B " << buy[buy.size() - i - 1] << " "
<< volume[buy[buy.size() - i - 1]][1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool f1(pair<long long, long long> a, pair<long long, long long> b) {
return a.first > b.first;
}
bool f2(pair<long long, long long> a, pair<long long, long long> b) {
return a.first * a.second < b.first * b.second;
}
int main() {
long long n, s;
cin >> n >> s;
map<long long, long long> buy, sell;
for (int i = 0; i < n; i++) {
string t;
long long p, q;
cin >> t >> p >> q;
if (t == "B") {
buy[p] += q;
} else {
sell[p] += q;
}
}
vector<pair<long long, long long> > bv, sv;
for (auto it = buy.begin(); it != buy.end(); it++) {
bv.push_back({(*it).first, (*it).second});
}
for (auto it = sell.begin(); it != sell.end(); it++) {
sv.push_back({(*it).first, (*it).second});
}
sort(bv.begin(), bv.end(), f1);
sort(sv.begin(), sv.end(), f1);
for (int i = max(0, (int)sv.size() - (int)s); i < sv.size(); i++) {
cout << "S " << sv[i].first << " " << sv[i].second << endl;
}
for (int i = 0; i < s && i < bv.size(); i++) {
cout << "B " << bv[i].first << " " << bv[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long abss(long long x) {
if (x < 0) return -x;
return x;
}
vector<int> sell, b;
vector<pair<int, long long> > bdob, sdob, fin;
long long freb[100001], fres[100001];
int main() {
int n, s, p, q;
cin >> n >> s;
char ch;
for (int i = 0; i < n; ++i) {
cin >> ch >> p >> q;
if (ch == 'B') {
if (freb[p] == 0) b.push_back(p);
freb[p] += q;
} else {
if (fres[p] == 0) sell.push_back(p);
fres[p] += q;
}
}
for (int i = 0; i < b.size(); ++i)
bdob.push_back(make_pair(b[i], freb[b[i]]));
for (int i = 0; i < sell.size(); ++i)
sdob.push_back(make_pair(sell[i], fres[sell[i]]));
sort(bdob.begin(), bdob.end());
sort(sdob.begin(), sdob.end());
reverse(bdob.begin(), bdob.end());
int temp = s, z = 0;
while (temp && z < sdob.size()) {
fin.push_back(make_pair(sdob[z].first, sdob[z].second));
z++;
temp--;
}
sort(fin.begin(), fin.end());
reverse(fin.begin(), fin.end());
for (int i = 0; i < fin.size(); ++i) {
cout << "S " << fin[i].first << " " << fin[i].second << endl;
}
temp = s, z = 0;
while (temp && z < bdob.size()) {
cout << "B " << bdob[z].first << " " << bdob[z].second << endl;
z++;
temp--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct stock {
char c;
long long a, b;
} a[100005];
bool cmp(stock A, stock B) {
if (A.c == B.c) return A.a > B.a;
return A.c > B.c;
}
map<long long, int> mp, mp1;
int main() {
long long n, s, aa, bb, j = 0;
char c[3];
scanf("%lld %lld", &n, &s);
for (long long i = 1; i <= n; i++) {
scanf("%s %lld %lld", c, &aa, &bb);
if (c[0] == 'B') {
if (mp[aa] == 0) {
mp[aa] = ++j;
a[j].c = c[0];
a[j].a = aa;
a[j].b = bb;
} else {
a[mp[aa]].b += bb;
}
} else {
if (mp1[aa] == 0) {
mp1[aa] = ++j;
a[j].c = c[0];
a[j].a = aa;
a[j].b = bb;
} else {
a[mp1[aa]].b += bb;
}
}
}
sort(a + 1, a + n + 1, cmp);
int q = 0, p = 0;
stack<int> st;
for (long long i = n; i >= 1; i--) {
if (a[i].c == 'S' && p < s) {
st.push(i);
p++;
}
}
while (!st.empty()) {
int u = st.top();
st.pop();
printf("%c %lld %lld\n", a[u].c, a[u].a, a[u].b);
}
for (long long i = 1; i <= n; i++) {
if (a[i].c == 'B' && q < s) {
printf("%c %lld %lld\n", a[i].c, a[i].a, a[i].b);
q++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, int> B, S;
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
string side;
cin >> side;
int p, q;
cin >> p >> q;
if (side == "B") {
B[p] += q;
} else {
S[p] += q;
}
}
vector<pair<int, int> > buy, sell;
for (auto it : B) buy.push_back({it.first, it.second});
for (auto it : S) sell.push_back({it.first, it.second});
sort(buy.begin(), buy.end(),
[](const pair<int, int>& a, const pair<int, int>& b) {
return a.first > b.first;
});
sort(sell.begin(), sell.end(),
[](const pair<int, int>& a, const pair<int, int>& b) {
return a.first < b.first;
});
vector<int> fin;
for (int i = 0; i < s && i < sell.size(); i++) {
fin.push_back(i);
}
for (int i = fin.size() - 1; i >= 0; i--) {
printf("S %d %d\n", sell[i].first, sell[i].second);
}
for (int i = 0; i < s && i < buy.size(); i++) {
printf("B %d %d\n", buy[i].first, buy[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, o;
cin >> n >> o;
vector<pair<int, int> > b;
vector<pair<int, int> > s;
while (n--) {
char c;
int x, y;
cin >> c >> x >> y;
if (c == 'B')
b.push_back({x, y});
else
s.push_back({x, y});
}
sort(b.rbegin(), b.rend());
sort(s.begin(), s.end());
int cnt = 0;
vector<pair<int, int> > an;
for (int i = 0; i < (int)s.size(); i++) {
if (cnt == o) break;
int cur = s[i].second;
while (i + 1 < (int)s.size() && s[i].first == s[i + 1].first) {
cur += s[i + 1].second;
i++;
}
an.push_back({s[i].first, cur});
cnt++;
}
for (int i = (int)an.size() - 1; i >= 0; i--)
cout << "S " << an[i].first << ' ' << an[i].second << endl;
cnt = 0;
for (int i = 0; i < (int)b.size(); i++) {
if (cnt == o) break;
int cur = b[i].second;
cout << "B " << b[i].first << ' ';
while (i + 1 < (int)b.size() && b[i].first == b[i + 1].first) {
cur += b[i + 1].second;
i++;
}
cout << cur << endl;
cnt++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void sc(int& a) { scanf("%d", &a); }
void sc(long long int& a) { scanf("%lld", &a); }
void sc(int& a, int& b) {
sc(a);
sc(b);
}
void sc(long long int& a, long long int& b) {
sc(a);
sc(b);
}
void sc(int& a, int& b, int& c) {
sc(a, b);
sc(c);
}
void sc(long long int& a, long long int& b, long long int& c) {
sc(a, b);
sc(c);
}
void write(int a) { printf("%d", a); }
void write(long long int a) { printf("%lld", a); }
int mod = 1000000007;
long long int modpow(long long int a, long long int b, long long int mod) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b / 2;
}
return res % mod;
}
map<int, int> mp1, mp2;
vector<pair<int, int> > v;
int main() {
int n, s, i, k = 0;
int x, y;
char str[10];
sc(n, s);
for (i = 0; i < n; i++) {
getchar();
scanf("%s %d %d", str, &x, &y);
if (str[0] == 'B')
mp1[x] += y;
else
mp2[x] += y;
}
k = 0;
for (auto it = mp2.begin(); it != mp2.end() and k < s; it++, k++) {
v.push_back(make_pair(it->first, it->second));
}
for (auto it = v.rbegin(); it != v.rend(); it++)
printf("S %d %d\n", it->first, it->second);
k = 0;
for (auto it = mp1.rbegin(); it != mp1.rend() and k < s; it++, k++) {
printf("B %d %d\n", it->first, it->second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> s;
map<int, int> b;
int main() {
int n, ss;
char dir;
int p, q, cnt;
map<int, int>::reverse_iterator iter;
while (~scanf("%d %d", &n, &ss)) {
s.clear();
b.clear();
getchar();
for (int i = 0; i < n; ++i) {
scanf("%c %d %d", &dir, &p, &q);
getchar();
switch (dir) {
case 'B':
b[p] += q;
break;
case 'S':
s[p] += q;
break;
}
}
cnt = 0;
int len = (int)s.size();
iter = s.rbegin();
while (len > ss) {
++iter;
--len;
}
for (; iter != s.rend(); ++iter) {
printf("S %d %d\n", iter->first, iter->second);
++cnt;
if (cnt == ss) break;
}
cnt = 0;
for (iter = b.rbegin(); iter != b.rend(); ++iter) {
printf("B %d %d\n", iter->first, iter->second);
++cnt;
if (cnt == ss) break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 9;
const long long int MOD = 1e9 + 7;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, 1, -1};
bool comp1(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
bool comp2(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
vector<pair<int, int> > buy;
vector<pair<int, int> > sell;
long long int hash1[100009];
long long int hash2[100009];
int main() {
memset(hash1, 0, sizeof hash1);
memset(hash2, 0, sizeof hash2);
int n, s;
scanf("%d%d", &n, &s);
char d;
int p, q;
for (int i = 0; i < n; i++) {
cin >> d >> p >> q;
if (d == 'B') {
buy.push_back(make_pair(p, q));
hash1[p] += q;
} else {
sell.push_back(make_pair(p, q));
hash2[p] += q;
}
}
sort(buy.begin(), buy.end(), comp1);
sort(sell.begin(), sell.end(), comp1);
vector<pair<int, long long int> > ans1;
vector<pair<int, long long int> > ans2;
for (int i = 0; i < buy.size(); i++) {
if (hash1[buy[i].first] != -1) {
ans1.push_back(make_pair(buy[i].first, hash1[buy[i].first]));
hash1[buy[i].first] = -1;
}
}
for (int i = 0; i < sell.size(); i++) {
if (hash2[sell[i].first] != -1) {
ans2.push_back(make_pair(sell[i].first, hash2[sell[i].first]));
hash2[sell[i].first] = -1;
}
}
reverse(ans2.begin(), ans2.end());
int temp = s;
if (ans2.size() < s) s = ans2.size();
for (int i = s - 1; i >= 0; i--) {
printf("S %d %lld", ans2[i].first, ans2[i].second);
printf("\n");
}
s = temp;
if (ans1.size() < s) s = ans1.size();
for (int i = 0; i < s; i++) {
printf("B %d %lld", ans1[i].first, ans1[i].second);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, s, p, q;
cin >> n >> s;
char c;
map<long long int, long long int, greater<long long int> > b, se;
for (long long int i = 0; i < n; i++) {
cin >> c >> p >> q;
if (c == 'B') {
if (b.find(p) == b.end()) b.insert({p, 0});
b[p] += q;
} else {
if (se.find(p) == se.end()) se.insert({p, 0});
se[p] += q;
}
}
long long int i = 0;
map<long long int, long long int>::iterator it;
if (se.size() > s)
it = prev(se.end(), s);
else
it = se.begin();
while (i < fmin(s, se.size())) {
cout << "S"
<< " " << it->first << " " << it->second << endl;
it++;
i++;
}
i = 0;
it = b.begin();
while (i < fmin(s, b.size())) {
cout << "B"
<< " " << it->first << " " << it->second << endl;
it++;
i++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<char, int>, int> m1, m2;
int main() {
int n, s;
char c;
int price, qtde;
while (cin >> n >> s) {
while (n--) {
cin >> c >> price >> qtde;
pair<char, int> p(c, price);
if (c == 'S') {
m1[p] += qtde;
} else {
m2[p] += qtde;
}
}
map<pair<char, int>, int>::reverse_iterator it2;
map<pair<char, int>, int>::iterator it;
it = m1.begin();
vector<pair<pair<char, int>, int> > v;
for (int i = 0; i < s && it != m1.end(); ++i, ++it) {
v.push_back(make_pair(it->first, it->second));
}
for (int i = v.size() - 1; i >= 0; --i)
cout << v[i].first.first << ' ' << v[i].first.second << ' ' << v[i].second
<< '\n';
v.clear();
it2 = m2.rbegin();
for (int i = 0; i < s && it2 != m2.rend(); ++i) {
pair<char, int> p = (it2->first);
cout << p.first << ' ' << p.second << ' ' << it2->second << '\n';
++it2;
}
m1.clear();
m2.clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int ts[100005];
int tb[100005];
int pp[100];
int main() {
char d[2];
int n, s, maxb, maxs;
int i, j, a, b, ms, mb;
scanf("%d%d", &n, &s);
memset(ts, -1, sizeof(ts));
memset(tb, -1, sizeof(tb));
maxb = maxs = 0;
for (i = 0; i < n; i++) {
scanf("%s%d%d", d, &a, &b);
if (d[0] == 'S') {
if (ts[a] == -1) {
ms++;
ts[a] = 0;
}
maxs = maxs > a ? maxs : a;
ts[a] += b;
} else {
if (tb[a] == -1) {
tb[a] = 0;
mb++;
}
maxb = maxb > a ? maxb : a;
tb[a] += b;
}
}
j = 0;
for (i = 0; i <= maxs && j < ms; i++) {
if (ts[i] != -1 && j < s) {
pp[j++] = i;
}
}
for (i = j - 1; i >= 0; i--) {
printf("S %d %d\n", pp[i], ts[pp[i]]);
}
j = 0;
for (i = maxb; i >= 0 && j < mb; i--) {
if (tb[i] != -1 && j < s) {
printf("B %d %d\n", i, tb[i]);
j++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> arr1(100005, 0);
vector<int> arr2(100005, 0);
pair<int, int> arr3[50001];
int main() {
int n, s, p, q, i, l1 = 0, l2 = 0, c;
char ch;
cin >> n >> s;
while (n--) {
cin >> ch >> p >> q;
if (ch == 'S')
arr1[p] += q;
else
arr2[p] += q;
}
c = 0, i = 0;
while (i < 100005 && c < s) {
if (arr1[i] != 0) {
arr3[l1].first = i;
arr3[l1].second = arr1[i];
l1++;
c++;
}
i++;
}
for (i = l1 - 1; i >= 0; i--) {
cout << "S"
<< " " << arr3[i].first << " " << arr3[i].second << "\n";
}
i = 100005;
c = 0;
while (i >= 0 && c < s) {
if (arr2[i] != 0) {
cout << "B"
<< " " << i << " " << arr2[i] << "\n";
c++;
}
i--;
}
return 0;
}
|
#include <bits/stdc++.h>
struct order {
int price;
int quality;
};
int compare(const void *a, const void *b) {
return ((struct order *)a)->price - ((struct order *)b)->price;
}
void sort(struct order a[], int size) {
qsort(a, size, sizeof(struct order), compare);
}
int main() {
int n, s;
scanf("%d%d", &n, &s);
struct order buy[1000];
struct order sell[1000];
int nb = 0;
int ns = 0;
int i, j;
for (i = 0; i < n; i++) {
getchar();
char d = getchar();
if (d == 'B') {
scanf("%d%d", &(buy[nb].price), &(buy[nb].quality));
nb++;
} else if (d == 'S') {
scanf("%d%d", &(sell[ns].price), &(sell[ns].quality));
ns++;
} else {
printf("读入数据出现了问题\n");
return 1;
}
}
struct order aggregated_buy[1000];
int nnb = 0;
for (i = 0; i < nb; i++) {
if (buy[i].price >= 0) {
int sum = buy[i].quality;
for (j = i + 1; j < nb; j++) {
if (buy[i].price == buy[j].price) {
sum += buy[j].quality;
buy[j].price = (-1);
}
}
aggregated_buy[nnb].price = buy[i].price;
aggregated_buy[nnb].quality = sum;
nnb++;
}
}
struct order aggregated_sell[1000];
int nns = 0;
for (i = 0; i < ns; i++) {
if (sell[i].price >= 0) {
int sum = sell[i].quality;
for (j = i + 1; j < ns; j++) {
if (sell[i].price == sell[j].price) {
sum += sell[j].quality;
sell[j].price = (-1);
}
}
aggregated_sell[nns].price = sell[i].price;
aggregated_sell[nns].quality = sum;
nns++;
}
}
sort(aggregated_sell, nns);
int start = s - 1;
if (nns < s) start = nns - 1;
for (i = start; i >= 0; i--) {
printf("S %d %d\n", aggregated_sell[i].price, aggregated_sell[i].quality);
}
start = nnb - 1;
int end = nnb - s;
if (nnb < s) {
start = nnb - 1;
end = 0;
}
sort(aggregated_buy, nnb);
for (i = start; i >= end; i--) {
printf("B %d %d\n", aggregated_buy[i].price, aggregated_buy[i].quality);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, s, sell[MAXN], buy[MAXN];
int main(int argc, char const *argv[]) {
scanf("%d%d", &n, &s);
for (int i = 0; i < n; ++i) {
char op[2];
int p, q;
scanf("%s%d%d", op, &p, &q);
if (op[0] == 'S')
sell[p] += q;
else
buy[p] += q;
}
int num = s, i;
for (i = 0; i < MAXN && num; ++i)
if (sell[i]) num--;
for (int j = i - 1; j >= 0; --j)
if (sell[j]) printf("S %d %d\n", j, sell[j]);
for (int j = MAXN - 1; j >= 0; --j)
if (buy[j] && s) {
printf("B %d %d\n", j, buy[j]);
s--;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
map<int, long long> sale;
map<int, long long> buy;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
if (c == 'B') {
int price, num;
cin >> price >> num;
buy[price] += num;
} else {
int price, num;
cin >> price >> num;
sale[price] += num;
}
}
auto itb = sale.begin();
stack<pair<long long, long long>> answ;
for (int i = 0; i < min(int(sale.size()), s); i++) {
answ.push((*itb));
itb++;
}
while (!answ.empty()) {
cout << "S"
<< " " << answ.top().first << " " << answ.top().second << endl;
answ.pop();
}
auto its = buy.end();
for (int i = 0; i < min(int(buy.size()), s); i++) {
its--;
cout << 'B' << " " << (*its).first << " " << (*its).second << endl;
}
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toStr(const T &x) {
stringstream s;
s << x;
return s.str();
}
template <class T>
int toInt(const T &x) {
stringstream s;
s << x;
int r;
s >> r;
return r;
}
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int main() {
int n, s;
cin >> n >> s;
map<int, int> sell;
map<int, int> buy;
char d;
int p, q;
for (int i = 0; i < n; ++i) {
cin >> d >> p >> q;
if (d == 'S')
sell[p] += q;
else
buy[p] += q;
}
vector<pair<int, pair<int, int> > > v;
vector<pair<int, pair<int, int> > > vv;
for (__typeof(sell).begin() x = (sell).begin(); x != (sell).end(); ++x) {
int tot = x->first;
v.push_back(make_pair(tot, make_pair(x->first, x->second)));
}
for (__typeof(buy).begin() x = (buy).begin(); x != (buy).end(); ++x) {
int tot = x->first;
vv.push_back(make_pair(tot, make_pair(x->first, x->second)));
}
sort(v.begin(), v.end());
sort(vv.begin(), vv.end());
vector<string> ans;
int tot = s;
for (int i = 0; i < v.size() && tot-- > 0; ++i) {
ans.push_back("S " + toStr(v[i].second.first) + " " +
toStr(v[i].second.second));
}
for (int i = ans.size() - 1; i >= 0; --i) cout << ans[i] << '\n';
tot = s;
for (int i = vv.size() - 1; i >= 0 and tot-- > 0; --i) {
cout << "B " << vv[i].second.first << " " << vv[i].second.second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, b[100001], s[100001], mins = 1000000000, minb = 1000000000, maxb,
maxs, p, v, nr1, nr2;
char ch;
struct stock {
int pret, val;
} B[100001], S[100001];
inline bool cmp1(stock x, stock y) {
if (x.pret > y.pret) return true;
return false;
}
inline bool cmp2(stock x, stock y) {
if (x.pret < y.pret) return true;
return false;
}
inline bool cmp(stock x, stock y) {
if (x.pret > y.pret) return true;
return false;
}
int main() {
int i;
cin >> n >> q;
cin.get();
for (i = 1; i <= n; ++i) {
cin >> ch >> p >> v;
cin.get();
if (ch == 'B') {
b[p] += v;
minb = min(minb, p);
maxb = max(maxb, p);
} else {
s[p] += v;
mins = min(mins, p);
maxs = max(maxs, p);
}
}
for (i = minb; i <= maxb; ++i)
if (b[i] != 0) {
B[++nr1].pret = i;
B[nr1].val = b[i];
}
for (i = mins; i <= maxs; ++i)
if (s[i] != 0) {
S[++nr2].pret = i;
S[nr2].val = s[i];
}
if (nr2 >= q) sort(S + 1, S + nr2 + 1, cmp2);
if (nr1 >= q) sort(B + 1, B + nr1 + 1, cmp1);
sort(S + 1, S + min(q, nr2) + 1, cmp);
sort(B + 1, B + min(q, nr1) + 1, cmp);
for (i = 1; i <= min(q, nr2); ++i)
cout << "S " << S[i].pret << ' ' << S[i].val << '\n';
for (i = 1; i <= min(q, nr1); ++i)
cout << "B " << B[i].pret << ' ' << B[i].val << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int agg[2][100001];
pair<long long int, long long int> srt[100001];
const int N = 100000;
void task() {
int n, s;
cin >> n >> s;
char d;
long long int p, q;
for (int i = 0; i < n; i++) {
cin >> d;
if (d == 'S')
d = 0;
else
d = 1;
cin >> p;
cin >> q;
agg[d][p] += q;
}
int cnt = 0;
for (int i = 0; i <= N; i++) {
if (agg[0][i] != 0 && cnt < s) {
srt[cnt] = make_pair(i, agg[0][i]);
cnt++;
}
}
for (int i = cnt - 1; i >= 0; i--) {
cout << 'S' << " " << srt[i].first << " " << srt[i].second << "\n";
}
cnt = 0;
for (int i = N; i >= 0; i--) {
if (agg[1][i] != 0 && cnt < s) {
cout << 'B' << " " << i << " " << agg[1][i] << "\n";
cnt++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
task();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 17;
const int INF = 1e9 + 17;
int n, s, x, y;
vector<pair<int, int> > v, V, vv, VV;
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; ++i) {
char c;
cin >> c >> x >> y;
if (c == 'S')
v.push_back(make_pair(x, y));
else
V.push_back(make_pair(x, y));
}
sort(v.begin(), v.end());
sort(V.begin(), V.end());
for (int i = 0; i < v.size(); ++i) {
int k = i, Sum = 0;
while (k + 1 < v.size()) {
if (v[i].first == v[k + 1].first)
k++, Sum += v[k].second;
else
break;
}
VV.push_back(make_pair(v[i].first, Sum + v[i].second));
i = k;
}
sort(VV.begin(), VV.end());
for (int i = min(s, int(VV.size())) - 1; i >= 0; --i)
printf("S %d %d\n", VV[i].first, VV[i].second);
for (int i = 0; i < V.size(); ++i) {
int k = i, Sum = 0;
while (k + 1 < V.size()) {
if (V[i].first == V[k + 1].first)
k++, Sum += V[k].second;
else
break;
}
vv.push_back(make_pair(V[i].first, Sum + V[i].second));
i = k;
}
sort(vv.begin(), vv.end());
reverse(vv.begin(), vv.end());
for (int i = 0; i < min(s, int(vv.size())); ++i)
printf("B %d %d\n", vv[i].first, vv[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, s;
cin >> n >> s;
map<int, long long> S, B;
for (int a_ : vector<char>(n)) {
char c;
int p, q;
cin >> c >> p >> q;
if (c == 'S')
S[p] += q;
else
B[p] += q;
}
int i = 0;
while (s < S.size()) S.erase(--S.end());
for (auto x = S.rbegin(); x != S.rend(); ++x) {
cout << "S " << x->first << " " << x->second << '\n';
}
i = 0;
for (auto x = B.rbegin(); x != B.rend(); ++x) {
i++;
cout << "B " << x->first << " " << x->second << '\n';
if (i == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
const int N = 1e5 + 20;
int main() {
file();
fast();
int n, s;
cin >> n >> s;
map<int, vector<pair<pair<int, int>, int>>> sel, bu;
map<int, int> meg_sel, meg_bu;
for (int i = 0; i < n; i++) {
char ch;
int p, q;
cin >> ch >> p >> q;
if (ch == 'B') {
meg_bu[p] += q;
bu[p].push_back({{i, p}, q});
} else {
meg_sel[p] += q;
sel[p].push_back({{i, p}, q});
}
}
vector<pair<int, pair<int, int>>> ans;
if (meg_bu.size() >= 1) {
auto it = bu.end();
it--;
for (int i = 0; i < s; i++) {
int price = it->first;
int valum = meg_bu[it->first];
ans.push_back({-1 * price, {valum, 1}});
if (it == bu.begin()) {
break;
}
it--;
}
}
if (sel.size() >= 1) {
auto it = sel.begin();
for (int i = 0; i < s && it != sel.end(); i++) {
int idx = it->second[0].first.first;
int price = it->first;
int valum = meg_sel[it->first];
ans.push_back({-1 * price, {valum, 0}});
it++;
}
}
sort(((ans).begin()), ((ans).end()));
for (int i = 0; i < ans.size(); i++) {
int pr = ans[i].first;
int val = ans[i].second.first;
int who = ans[i].second.second;
if (who) {
cout << 'B' << " " << -1 * pr << " " << val << "\n";
} else {
cout << 'S' << " " << -1 * pr << " " << val << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, s, p, q;
char d;
vector<tuple<char, long long, long long>> b;
cin >> n >> s;
while (n--) {
cin >> d >> p >> q;
b.push_back(make_tuple(d, p, q));
}
sort(b.begin(), b.end(),
[](const tuple<char, long long, long long> &left,
const tuple<char, long long, long long> &right) {
return get<0>(left) > get<0>(right);
});
vector<tuple<char, long long, long long>>::iterator i = b.begin(), j;
i = find_if(b.begin(), b.end(),
[](const tuple<char, long long, long long> &e) {
return get<0>(e) == 'B';
});
sort(b.begin(), i,
[](const tuple<char, long long, long long> &left,
const tuple<char, long long, long long> &right) {
return get<1>(left) < get<1>(right);
});
sort(i, b.end(),
[](const tuple<char, long long, long long> &left,
const tuple<char, long long, long long> &right) {
return get<1>(left) > get<1>(right);
});
for (j = b.begin() + 1; j < i; j++)
if (get<1>(*j) == get<1>(*(j - 1))) {
get<2>(*j) += get<2>(*(j - 1));
b.erase(j - 1);
i--;
j--;
}
for (j = i + 1; j < b.end(); j++)
if (get<1>(*j) == get<1>(*(j - 1))) {
get<2>(*j) += get<2>(*(j - 1));
b.erase(j - 1);
j--;
}
for (j = b.begin(), n = 0; j != i && n < s; j++, n++)
;
for (j = j - 1; j >= b.begin(); j--)
cout << get<0>(*j) << " " << get<1>(*j) << " " << get<2>(*j) << "\n";
for (j = i, n = 0; j != b.end() && n < s; j++, n++)
cout << get<0>(*j) << " " << get<1>(*j) << " " << get<2>(*j) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> buy, sell;
int main() {
int q, s;
cin >> q >> s;
for (int i = 0; i < q; i++) {
string d;
int p, v;
cin >> d >> p >> v;
if (d == "B")
buy[-p] += v;
else
sell[p] += v;
}
int cb = 0, cs = 0;
vector<pair<int, int> > v;
for (auto vv : sell) {
if (cs == s) break;
v.push_back(make_pair(vv.first, vv.second));
++cs;
}
for (int i = v.size() - 1; i >= 0; i--)
cout << "S " << v[i].first << " " << v[i].second << endl;
for (auto u : buy) {
if (cb == s) break;
cout << "B " << -u.first << " " << u.second << endl;
++cb;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long s[maxn + 1], b[maxn + 1];
int main() {
char a;
int n, fi, se, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a >> fi >> se;
if (a == 'B')
b[fi] += se;
else
s[fi] += se;
}
int p = 0, idx = 0;
for (int i = 0; i <= maxn; i++) {
if (p == k) break;
if (s[i] > 0) {
p++;
idx = i;
}
}
for (int i = idx; i >= 0; i--)
if (s[i] > 0) cout << 'S' << " " << i << " " << s[i] << endl;
for (int i = maxn, x = 0; i >= 0; i--) {
if (x == k) break;
if (b[i] > 0) {
cout << 'B' << " " << i << " " << b[i] << endl;
x++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
int a[100005], b[100005];
int aa[100005], bb[100005];
int main() {
int n, s;
cin >> n >> s;
char ch;
int q, p;
vector<int> v, vv;
for (int i = 0; i < n; i++) {
cin >> ch >> p >> q;
if (ch == 'S') {
if (!a[p]) {
a[p] = 1;
v.push_back(p);
aa[p] = q;
} else {
aa[p] += q;
}
} else {
if (!b[p]) {
b[p] = 1;
vv.push_back(p);
bb[p] = q;
} else
bb[p] += q;
}
}
sort(v.rbegin(), v.rend());
sort(vv.rbegin(), vv.rend());
vector<int> tmp;
for (int i = v.size() - 1, k = 0; k < s && i >= 0; i--, k++)
tmp.push_back(v[i]);
for (int i = tmp.size() - 1; i >= 0; i--)
printf("S %d %d\n", tmp[i], aa[tmp[i]]);
for (int i = 0, k = 0; k < s && i < vv.size(); i++, k++)
printf("B %d %d\n", vv[i], bb[vv[i]]);
return 0;
}
|
#include <bits/stdc++.h>
const double EPS = 1e-24;
const long long int MOD = 1000000007ll;
const double PI = 3.14159265359;
int INF = 2147483645;
long long int INFINF = 9223372036854775807;
template <class T>
T Max2(T a, T b) {
return a < b ? b : a;
}
template <class T>
T Min2(T a, T b) {
return a < b ? a : b;
}
template <class T>
T Max3(T a, T b, T c) {
return Max2(Max2(a, b), c);
}
template <class T>
T Min3(T a, T b, T c) {
return Min2(Min2(a, b), c);
}
template <class T>
T Max4(T a, T b, T c, T d) {
return Max2(Max2(a, b), Max2(c, d));
}
template <class T>
T Min4(T a, T b, T c, T d) {
return Min2(Min2(a, b), Max2(c, d));
}
using namespace std;
int n, s;
unordered_map<int, int> m[2];
vector<pair<int, int> > B, S;
int f(char c) {
if (c == 'B') return 0;
return 1;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> s;
for (int i = 1; i <= n; i++) {
char c;
int p, q;
cin >> c >> p >> q;
m[f(c)][p] += q;
}
for (unordered_map<int, int>::iterator it = m[0].begin(); it != m[0].end();
it++) {
B.push_back({it->first, it->second});
}
for (unordered_map<int, int>::iterator it = m[1].begin(); it != m[1].end();
it++) {
S.push_back({it->first, it->second});
}
sort(B.begin(), B.end());
sort(S.begin(), S.end());
reverse(B.begin(), B.end());
reverse(S.begin(), S.end());
for (int i = Max2(0, (int)S.size() - s); i < S.size(); i++)
cout << "S " << S[i].first << " " << S[i].second << "\n";
for (int i = 0; i < Min2(s, (int)B.size()); i++)
cout << "B " << B[i].first << " " << B[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Order {
int p;
int q;
Order(){};
Order(int price, int volume) : p(price), q(volume){};
};
int n, s;
vector<Order> ob, os;
void merge(char d, int p, int q) {
if (d == 'B') {
for (int i = 0; i < ob.size(); ++i) {
if (ob[i].p == p) {
ob[i].q += q;
return;
}
}
ob.push_back(Order(p, q));
} else {
for (int i = 0; i < os.size(); ++i) {
if (os[i].p == p) {
os[i].q += q;
return;
}
}
os.push_back(Order(p, q));
}
}
void read() {
cin >> n >> s;
for (int i = 0; i < n; ++i) {
char d;
int p, q;
cin >> d >> p >> q;
merge(d, p, q);
}
}
bool desc(Order a, Order b) { return a.p > b.p; }
bool cresc(Order a, Order b) { return a.p < b.p; }
int main() {
read();
sort(ob.begin(), ob.end(), desc);
sort(os.begin(), os.end(), cresc);
if (ob.size() >= s) {
ob.erase(ob.begin() + s, ob.end());
}
if (os.size() >= s) {
os.erase(os.begin() + s, os.end());
}
for (int i = (int)(os.size() - 1); i >= 0; --i) {
cout << "S " << os[i].p << " " << os[i].q << "\n";
}
for (int i = 0; i < ob.size(); ++i) {
cout << "B " << ob[i].p << " " << ob[i].q << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, s, i, p, q;
char c;
map<long long, long long> m1, m2;
map<long long, long long>::reverse_iterator rit;
map<long long, long long>::iterator it;
vector<pair<long long, long long> > v;
int main() {
cin >> n >> s;
for (i = 0; i < n; i++) {
cin >> c >> p >> q;
if (c == 'B')
m1[p] += q;
else
m2[p] += q;
}
for (it = m2.begin(), i = 0; it != m2.end() && i < s; it++, i++) {
v.push_back(make_pair(it->first, it->second));
}
for (i = v.size(); i > 0; i--) {
cout << "S " << v[i - 1].first << " " << v[i - 1].second << endl;
}
for (rit = m1.rbegin(), i = 0; rit != m1.rend() && i < s; rit++, i++) {
cout << "B " << rit->first << " " << rit->second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(INT_MAX - 100);
const int N = (int)(1e+5);
const long long mod = (int)(1e+9 + 7);
int v[2][N + 1];
int main() {
int n, s;
cin >> n >> s;
int p, q;
char d;
for (int it1 = 0; it1 < n; it1++) {
cin >> d >> p >> q;
v[(d == 'B')][p] += q;
}
int k = 0;
vector<pair<int, int> > v2;
for (int p = (0); p <= (N); p++) {
if (v[0][p] > 0) {
v2.push_back({p, v[0][p]});
k++;
}
if (k == s) break;
}
for (int it1 = int(v2.size()) - 1; it1 >= 0; it1--)
cout << "S " << v2[it1].first << " " << v2[it1].second << '\n';
k = 0;
for (int p = (N); p >= (0); p--) {
if (v[1][p] > 0) {
cout << "B " << p << " " << v[1][p] << '\n';
k++;
}
if (k == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, long> b, sl, tmp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, s;
cin >> n >> s;
char c;
for (int i = 0; i < n; i++) {
int p, q;
cin >> c >> p >> q;
if (c == 'B')
b[-p] += q;
else
sl[p] += q;
}
map<int, long>::iterator it;
int i = 0;
for (it = sl.begin(); it != sl.end() && i < s; i++, it++)
tmp[-(it->first)] = it->second;
for (it = tmp.begin(); it != tmp.end(); it++)
cout << 'S' << " " << -(it->first) << " " << it->second << '\n';
i = 0;
for (it = b.begin(); it != b.end() && i < s; i++, it++)
cout << 'B' << " " << -(it->first) << " " << it->second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000 + 3;
int n, s;
map<int, int> a, b;
int main() {
cin >> n >> s;
int as = 0, bs = 0;
vector<pair<int, int>> ass, bss;
for (int i = 0; i < n; i++) {
char ch;
int v, u;
cin >> ch >> v >> u;
if (ch == 'B')
if (a[v])
a[v] += u;
else
a[v] = u, as++;
else if (ch == 'S')
if (b[v])
b[v] += u;
else
b[v] = u, bs++;
}
for (auto it = a.begin(); it != a.end(); it++) {
ass.push_back({it->first, it->second});
}
for (auto it = b.begin(); it != b.end(); it++) {
bss.push_back({it->first, it->second});
}
sort(ass.rbegin(), ass.rend());
sort(bss.rbegin(), bss.rend());
int st = max(0, (int)bss.size() - s);
for (int i = st; i < (int)bss.size(); i++) {
cout << "S " << bss[i].first << " " << bss[i].second << endl;
}
for (int i = 0; i < min(s, (int)ass.size()); i++) {
cout << "B " << ass[i].first << " " << ass[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
map<int, int> buy, sell;
while (n--) {
int a, b;
char ch;
cin >> ch >> a >> b;
if (ch == 'B')
buy[a] += b;
else
sell[a] += b;
}
vector<pair<int, int> > ans1, ans2;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq2;
for (auto x : sell) pq2.push(x);
for (int i = 0; i < s && !pq2.empty(); i++)
ans1.push_back(pq2.top()), pq2.pop();
priority_queue<pair<int, int> > pq;
for (auto x : buy) pq.push(x);
for (int i = 0; i < s && !pq.empty(); i++) ans2.push_back(pq.top()), pq.pop();
sort(ans1.begin(), ans1.end());
reverse(ans1.begin(), ans1.end());
sort(ans2.begin(), ans2.end());
reverse(ans2.begin(), ans2.end());
for (int i = 0; i < ans1.size(); i++)
cout << "S " << ans1[i].first << " " << ans1[i].second << endl;
for (int i = 0; i < ans2.size(); i++)
cout << "B " << ans2[i].first << " " << ans2[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int buy[maxn], sell[maxn];
int main() {
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
char ch;
int p, q;
cin >> ch >> p >> q;
if (ch == 'B')
buy[p] += q;
else
sell[p] += q;
}
int cnt = 0;
vector<int> tmp;
for (int i = 0; i < maxn; i++) {
if (cnt == s) break;
if (sell[i]) cnt++, tmp.push_back(i);
}
reverse(tmp.begin(), tmp.end());
for (auto x : tmp) printf("S %d %d\n", x, sell[x]);
cnt = 0;
for (int i = maxn - 1; i >= 0; i--) {
if (cnt == s) break;
if (buy[i]) cnt++, printf("B %d %d\n", i, buy[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
const double pi = acos(-1.0);
const int mod = 1000000007;
const int maxn = 200100;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, s;
cin >> n >> s;
map<int, int> BB;
map<int, int> SS;
for (int i = 0; i < n; i++) {
char c;
int p, q;
cin >> c >> p >> q;
if (c == 'B') {
BB[p] = BB[p] + q;
} else
SS[p] = SS[p] + q;
}
stack<string> st;
int i = 0;
for (auto it = SS.begin(); it != SS.end() && i < s; it++, i++) {
stringstream second;
second << "S " << it->first << " " << it->second;
st.push(second.str());
}
while (!st.empty()) {
cout << st.top() << "\n";
st.pop();
}
i = 0;
for (auto it = BB.rbegin(); it != BB.rend() && i < s; it++, i++) {
cout << "B " << it->first << " " << it->second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, x;
cin >> n >> x;
set<long long> ss, sb;
map<long long, long long> ms, mb;
while (n--) {
char d;
long long p, q;
cin >> d >> p >> q;
if (d == 'S') {
ss.insert(p);
ms[p] += q;
}
if (d == 'B') {
sb.insert(p);
mb[p] += q;
}
}
if (ss.size() != 0) {
auto it = ss.begin();
long long sz = x;
if (x > ss.size()) sz = ss.size();
advance(it, sz - 1);
for (int i = 0; i < sz; i++) {
if (i >= ss.size()) break;
cout << "S " << *it << " " << ms[*it] << endl;
it--;
}
}
if (sb.size() != 0) {
auto it = sb.end();
it--;
for (int i = 0; i < x; i++) {
if (sb.size() == 0 || i >= sb.size()) break;
cout << "B " << *it << " " << mb[*it] << endl;
it--;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char d[1005];
pair<int, long long> p[1005];
vector<pair<int, pair<long long, char> > > SS, BB;
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) cin >> d[i] >> p[i].first >> p[i].second;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (d[i] == d[j] && p[i].first == p[j].first) {
p[i].second += p[j].second;
d[j] = 'Z';
}
}
}
for (int i = 0; i < n; i++) {
if (d[i] == 'S') {
SS.push_back(make_pair(p[i].first, make_pair(p[i].second, d[i])));
} else if (d[i] == 'B') {
BB.push_back(make_pair(p[i].first, make_pair(p[i].second, d[i])));
}
}
sort(SS.begin(), SS.end());
sort(BB.rbegin(), BB.rend());
for (int i = s - 1; i >= 0; --i) {
if (i < SS.size())
cout << SS[i].second.second << " " << SS[i].first << " "
<< SS[i].second.first << endl;
}
for (int i = 0; i < s && i < BB.size(); i++)
cout << BB[i].second.second << " " << BB[i].first << " "
<< BB[i].second.first << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline double min(double a, double b) {
if (a < b) return a;
return b;
}
int n, k;
int arr1[100010];
int arr2[100010];
struct cmp {
bool operator()(int str1, int str2) const { return str1 > str2; }
};
int main() {
map<int, int> sellMap;
map<int, int, cmp> buyMap;
cin >> n >> k;
for (int(i) = (0); (i) < (n); i++) {
char ops;
int price;
int vol;
cin >> ops >> price >> vol;
if (ops == 'B') {
if (buyMap.count(price) == 0)
buyMap.insert(make_pair(price, vol));
else
buyMap[price] += vol;
} else {
if (sellMap.count(price) == 0)
sellMap.insert(make_pair(price, vol));
else
sellMap[price] += vol;
}
}
vector<pair<int, int> > temp;
int cnt = 0;
for (auto i = sellMap.begin(); i != sellMap.end() && cnt < k; i++, cnt++) {
temp.push_back(*i);
}
for (int i = temp.size() - 1; i >= 0; i--) {
cout << "S"
<< " " << temp[i].first << " " << temp[i].second << endl;
}
cnt = 0;
for (auto i = buyMap.begin(); i != buyMap.end() && cnt < k; i++, cnt++)
cout << "B"
<< " " << i->first << " " << i->second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> sell;
map<int, int> bu;
stack<pair<int, int> > ss;
struct compare {
bool operator()(pair<int, int> a, pair<int, int> b) {
return b.first < a.first;
}
};
struct compare2 {
bool operator()(pair<int, int> a, pair<int, int> b) {
return b.first > a.first;
}
};
int main() {
int n, s, i, p, q;
cin >> n >> s;
char c;
for (i = 0; i < n; i++) {
cin >> c >> p >> q;
if (c == 'S')
sell[p] += q;
else
bu[p] += q;
}
priority_queue<pair<int, int>, std::vector<pair<int, int> >, compare2> P;
priority_queue<pair<int, int>, std::vector<pair<int, int> >, compare> Q;
map<int, int>::iterator ii;
pair<int, int> pp;
for (ii = sell.begin(); ii != sell.end(); ii++)
Q.push(make_pair(ii->first, ii->second));
for (ii = bu.begin(); ii != bu.end(); ii++)
P.push(make_pair(ii->first, ii->second));
for (i = 0; i < s && !Q.empty(); i++) {
pp = Q.top();
Q.pop();
ss.push(pp);
}
while (!ss.empty()) {
pp = ss.top();
ss.pop();
cout << "S"
<< " " << pp.first << " " << pp.second << endl;
}
for (i = 0; i < s && !P.empty(); i++) {
pp = P.top();
P.pop();
cout << "B"
<< " " << pp.first << " " << pp.second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = +100500;
const long long INF = 1e18;
map<long long, long long> b;
map<long long, long long> s;
int main() {
long long n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char t;
cin >> t;
long long x, y;
cin >> x >> y;
if (t == 'S') {
s[x] += y;
} else {
b[x] += y;
}
}
long long cnt = 0;
long long cur = 0;
vector<pair<long long, long long> > ans;
while (cur <= MAXN && cnt < k) {
if (s[cur] > 0) {
ans.push_back(make_pair(cur, s[cur]));
cnt++;
}
cur++;
}
for (int i = ans.size() - 1; i >= 0; i--) {
cout << "S " << ans[i].first << " " << ans[i].second << endl;
}
cur = MAXN;
cnt = 0;
while (cur >= 0 && cnt < k) {
if (b[cur] > 0) {
cout << 'B' << " " << cur << " " << b[cur] << endl;
cnt++;
}
cur--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[2][100001];
stack<int> print;
int main() {
int n, s, pr, vol, max1 = 0, min1 = 1000000, i, stock;
char sign;
cin >> n >> s;
for (i = 0; i < n; i++) {
cin >> sign >> pr >> vol;
if (sign == 'B') {
cnt[0][pr] += vol;
max1 = max(max1, pr);
}
if (sign == 'S') {
cnt[1][pr] += vol;
min1 = min(min1, pr);
}
}
stock = 0;
for (i = min1; i <= 100000; i++) {
if (stock == s) break;
if (cnt[1][i] == 0) continue;
stock++;
print.push(i);
}
for (;;) {
if (print.empty() == 1) break;
printf("S %d %d\n", print.top(), cnt[1][print.top()]);
print.pop();
}
stock = 0;
for (i = max1; i >= 0; i--) {
if (stock == s) break;
if (cnt[0][i] == 0) continue;
stock++;
printf("B %d %d\n", i, cnt[0][i]);
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
class IntegerIterator
: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
explicit IntegerIterator(int value) : value(value) {}
IntegerIterator& operator++() {
++value;
return *this;
}
IntegerIterator operator++(int) {
IntegerIterator copy = *this;
++value;
return copy;
}
IntegerIterator& operator--() {
--value;
return *this;
}
IntegerIterator operator--(int) {
IntegerIterator copy = *this;
--value;
return copy;
}
T operator*() const { return value; }
bool operator==(IntegerIterator rhs) { return value == rhs.value; }
bool operator!=(IntegerIterator rhs) { return !(*this == rhs); }
private:
T value;
};
template <typename T>
class IntegerRange {
public:
IntegerRange(T begin, T end) : begin_(begin), end_(end) {}
IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }
private:
T begin_;
T end_;
};
template <typename T>
class ReversedIntegerRange {
public:
ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) {}
std::reverse_iterator<IntegerIterator<T>> begin() const {
return std::reverse_iterator<IntegerIterator<T>>(
IntegerIterator<T>(begin_));
}
std::reverse_iterator<IntegerIterator<T>> end() const {
return std::reverse_iterator<IntegerIterator<T>>(IntegerIterator<T>(end_));
}
private:
T begin_;
T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
;
return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
;
return IntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
;
return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
;
return ReversedIntegerRange<T>(from, to);
}
template <typename T>
class Range {
public:
Range(T begin, T end) : begin_(std::move(begin)), end_(std::move(end)) {}
T begin() { return begin_; }
T end() { return end_; }
private:
T begin_;
T end_;
};
template <typename T>
Range<T> make_range(T begin, T end) {
return Range<T>(begin, end);
}
using namespace std;
class OrderBook {
public:
int readInt(std::istream& in) {
int res;
in >> res;
return res;
}
void outputInt(std::ostream& out, int s) { out << s; }
void solve(std::istream& in, std::ostream& out) {
int n, s;
in >> n >> s;
map<int, int> buy, sell;
for (int i : range(n)) {
char c;
in >> c;
int cost = readInt(in);
int q;
in >> q;
if (c == 'B') {
buy[cost] += q;
} else {
sell[cost] += q;
}
}
while (sell.size() > s) {
sell.erase(--sell.end());
}
for (auto it : make_range(sell.rbegin(), sell.rend())) {
out << 'S' << ' ';
outputInt(out, it.first);
out << ' ' << it.second << "\n";
}
while (buy.size() > s) {
buy.erase(buy.begin());
}
for (auto it : make_range(buy.rbegin(), buy.rend())) {
out << 'B' << ' ';
outputInt(out, it.first);
out << ' ' << it.second << "\n";
}
}
};
int main() {
std::ios_base::sync_with_stdio(false);
OrderBook solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
in.tie(0);
out << std::fixed;
out.precision(20);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sa[100001], ba[100001];
int n, s;
int main() {
scanf("%d %d", &n, &s);
for (int i = 0; i < n; i++) {
char c;
int p, q;
scanf("%c", &c);
scanf("%c %d %d", &c, &p, &q);
if (c == 'B')
ba[p] += q;
else
sa[p] += q;
}
vector<pair<int, int> > sv, bv;
for (int i = 0; i < 100001; i++) {
if (sa[i] > 0) sv.push_back(make_pair(i, sa[i]));
if (ba[i] > 0) bv.push_back(make_pair(i, ba[i]));
}
sort(sv.rbegin(), sv.rend());
sort(bv.rbegin(), bv.rend());
int start = 0;
if (sv.size() > s) start = sv.size() - s;
for (int i = start, idx = 0; idx < s; i++, idx++) {
if (i == sv.size()) break;
printf("S %d %d\n", sv[i].first, sv[i].second);
}
for (int i = 0; i < s; i++) {
if (i == bv.size()) break;
printf("B %d %d\n", bv[i].first, bv[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long int n, s, p, q;
char d;
map<long long int, long long int> p1, p2;
cin >> n >> s;
for (long long int i = 1; i <= n; i++) {
cin >> d >> p >> q;
if (d == 'B')
p1[p] += q;
else if (d == 'S')
p2[p] += q;
}
map<long long int, long long int>::reverse_iterator rit;
map<long long int, long long int>::iterator it;
vector<pair<long long int, long long int> > p3;
long long int cnt = 0;
for (it = p2.begin(); it != p2.end(); it++) {
if (cnt < s) {
p3.push_back(make_pair(it->first, it->second));
cnt++;
}
}
cnt = 0;
reverse(p3.begin(), p3.end());
vector<pair<long long int, long long int> >::iterator it2;
for (it2 = p3.begin(); it2 != p3.end(); ++it2) {
if (cnt < s) {
cout << "S"
<< " " << it2->first << " " << it2->second << endl;
cnt++;
}
}
cnt = 0;
for (rit = p1.rbegin(); rit != p1.rend(); ++rit) {
if (cnt < s) {
cout << "B"
<< " " << rit->first << " " << rit->second << endl;
cnt++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long m, n, temp, sum, i, j, lenbb, lenss, x, y, z, ans, res;
map<long long, long long> bmp, smp, vs1, vb1;
map<long long, long long>::iterator it;
vector<long long> vs, vb;
char c, ch;
int main() {
cin >> n >> m;
while (n--) {
cin >> c >> i >> j;
if (c == 'S') {
smp[i] += j;
vs1.insert(make_pair(i, smp[i]));
} else {
bmp[i] += j;
vb1.insert(make_pair(i, bmp[i]));
}
}
lenbb = bmp.size();
lenss = smp.size();
i = 0;
for (it = smp.begin(); it != smp.end(); it++) {
if (i < m) vs.push_back(it->first);
i++;
}
for (it = bmp.begin(); it != bmp.end(); it++) vb.push_back(it->first);
sort(vs.begin(), vs.end());
sort(vb.begin(), vb.end());
j = m;
if (j > vs.size()) j = vs.size();
for (i = j - 1; i >= 0; i--)
cout << "S " << vs[i] << " " << smp[vs[i]] << endl;
i = vb.size();
j = 0;
for (i = i - 1; i >= 0; i--) {
if (j < m) cout << "B " << vb[i] << " " << bmp[vb[i]] << endl;
j++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int b[100100], s[100100];
deque<pair<int, int> > qb, qs;
int main() {
int n, ss;
while (~scanf("%d%d", &n, &ss)) {
char op[3];
memset(b, 0, sizeof(b));
memset(s, 0, sizeof(s));
int maxp = 0;
for (int i = 0; i < n; i++) {
int p, q;
scanf("%s%d%d", op, &p, &q);
if (op[0] == 'S')
s[p] += q;
else
b[p] += q;
maxp = max(maxp, p);
}
while (!qb.empty()) qb.pop_front();
while (!qs.empty()) qs.pop_front();
for (int i = maxp; i >= 0 && (int)qb.size() < ss; i--)
if (b[i]) qb.push_back(make_pair(i, b[i]));
for (int i = 0; i <= maxp && (int)qs.size() < ss; i++)
if (s[i]) qs.push_front(make_pair(i, s[i]));
while (!qs.empty()) {
printf("S %d %d\n", qs.front().first, qs.front().second);
qs.pop_front();
}
while (!qb.empty()) {
printf("B %d %d\n", qb.front().first, qb.front().second);
qb.pop_front();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
map<long long, long long> mb, ms;
while (n--) {
string a;
long long p, q;
cin >> a >> p >> q;
if (a[0] == 'B') {
if (mb.find(p) == mb.end())
mb[p] = q;
else
mb[p] += q;
}
if (a[0] == 'S') {
if (ms.find(p) == ms.end())
ms[p] = q;
else
ms[p] += q;
}
}
map<long long, long long>::iterator it;
vector<pair<long long, long long> > bs;
int i;
for (it = ms.begin(), i = 0; i < s && it != ms.end(); it++, i++)
bs.push_back(make_pair(it->first, it->second));
reverse(bs.begin(), bs.end());
int sz = bs.size();
for (int i = 0; i < sz; i++)
cout << "S " << bs[i].first << " " << bs[i].second << endl;
if (mb.begin() != mb.end())
for (it = mb.end(), it--, i = 0; i < s; it--, i++) {
cout << "B " << it->first << " " << it->second << endl;
if (it == mb.begin()) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
const int N = 1e5 + 20;
int main() {
file();
fast();
int n, s;
cin >> n >> s;
map<int, int> meg_sel, meg_bu;
for (int i = 0; i < n; i++) {
char ch;
int p, q;
cin >> ch >> p >> q;
if (ch == 'B') {
meg_bu[p] += q;
} else {
meg_sel[p] += q;
}
}
vector<pair<int, pair<int, int>>> ans;
if (meg_bu.size() >= 1) {
auto it = --meg_bu.end();
for (int i = 0; i < s; i++) {
int price = it->first;
int valum = meg_bu[it->first];
ans.push_back({-1 * price, {valum, 1}});
if (it == meg_bu.begin()) {
break;
}
it--;
}
}
if (meg_sel.size() >= 1) {
auto it = meg_sel.begin();
for (int i = 0; i < s && it != meg_sel.end(); i++) {
int price = it->first;
int valum = meg_sel[it->first];
ans.push_back({-1 * price, {valum, 0}});
it++;
}
}
sort(((ans).begin()), ((ans).end()));
for (int i = 0; i < ans.size(); i++) {
int pr = ans[i].first;
int val = ans[i].second.first;
int who = ans[i].second.second;
if (who) {
cout << 'B' << " " << -1 * pr << " " << val << "\n";
} else {
cout << 'S' << " " << -1 * pr << " " << val << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool compare(pair<long long int, long long int>& a,
pair<long long int, long long int>& b) {
return (a.first <= b.first);
}
int main() {
long long int n, s, i, j;
cin >> n >> s;
vector<pair<long long int, long long int> > buy;
vector<pair<long long int, long long int> > sell;
set<long long int> s1;
set<long long int> s2;
for (i = 0; i < n; i++) {
char ch;
cin >> ch;
long long int a, b;
if (ch == 'B') {
cin >> a >> b;
if (s1.find(a) == s1.end()) {
s1.insert(a);
buy.push_back(make_pair(a, b));
} else {
for (j = 0; j < buy.size(); j++) {
if (buy[j].first == a) break;
}
buy[j].second += b;
}
} else {
cin >> a >> b;
if (s2.find(a) == s2.end()) {
s2.insert(a);
sell.push_back(make_pair(a, b));
} else {
for (j = 0; j < sell.size(); j++) {
if (sell[j].first == a) break;
}
sell[j].second += b;
}
}
}
if (buy.size() != 0) sort(buy.begin(), buy.end(), compare);
if (sell.size() != 0) sort(sell.begin(), sell.end(), compare);
long long int x = s - 1;
long long int k, l;
k = sell.size();
l = buy.size();
x = min(s - 1, k - 1);
for (i = x; i >= 0; i--) {
cout << "S"
<< " " << sell[i].first << " " << sell[i].second;
cout << endl;
}
i = l - 1;
while (i >= 0 && s != 0) {
cout << "B"
<< " " << buy[i].first << " " << buy[i].second;
cout << endl;
i--;
s--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
const int MAXS = 50;
const int MAXP = 100000;
const int BUY = 0;
const int SELL = 1;
int n, s;
int p, q;
char d;
int orders[MAXP + 5][2];
vector<pair<int, int> > to_sell, to_buy;
int main() {
scanf("%d %d", &n, &s);
for (int i = 0; i < n; ++i) {
scanf(" %c %d %d", &d, &p, &q);
if (d == 'B')
orders[p][BUY] += q;
else
orders[p][SELL] += q;
}
for (int i = 0; i <= MAXP; ++i) {
if (orders[i][BUY] > 0) to_buy.push_back(make_pair(i, orders[i][BUY]));
if (orders[i][SELL] > 0) to_sell.push_back(make_pair(i, orders[i][SELL]));
}
sort(to_buy.begin(), to_buy.end());
sort(to_sell.begin(), to_sell.end());
int sell_limit = min(s, (int)to_sell.size());
for (int i = sell_limit - 1; i >= 0; --i) {
printf("S %d %d\n", to_sell[i].first, to_sell[i].second);
}
int buy_limit = min(s, (int)to_buy.size());
reverse(to_buy.begin(), to_buy.end());
for (int i = 0; i < buy_limit; ++i) {
printf("B %d %d\n", to_buy[i].first, to_buy[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, s;
cin >> n >> s;
map<int, int> buy;
map<int, int> sell;
char type;
int price, quantity;
for (int i = 0; i < n; i++) {
cin >> type >> price >> quantity;
if (type == 'S') {
sell[price] += quantity;
} else if (type == 'B') {
buy[price] += quantity;
}
}
int temp1 = 0;
if (s > sell.size())
temp1 = sell.size();
else
temp1 = s;
int count1, count2;
bool flag1 = 1, flag2 = 1;
count1 = sell.size();
if (count1 == 0) flag1 = 0;
if (count1 > s) count1 = s;
int temp = 0;
if (flag1 == 1) {
map<int, int>::iterator it = sell.begin();
advance(it, temp1 - 1);
for (; temp < count1; temp++, it--) {
cout << "S " << it->first << " " << it->second << "\n";
}
}
temp = 0;
count2 = buy.size();
if (count2 == 0) flag2 = 0;
if (count2 > s) count2 = s;
if (flag2 == 1) {
map<int, int>::iterator jt = buy.end();
jt--;
for (; temp < count2; temp++, jt--) {
cout << "B " << jt->first << " " << jt->second << " \n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
map<int, int> b, s;
int n, t, t_1;
char c;
int main(void) {
scanf("%d%d", &n, &t);
for (int x, y, i = 1; i <= n; ++i) {
cin >> c;
scanf("%d%d", &x, &y);
if (c == 'B')
b[x] = b[x] + y;
else
s[x] = s[x] + y;
}
vector<pair<int, int>> ans, ans_1;
t_1 = t;
for (auto it = s.begin(); it != s.end() && t; ++it) {
ans.push_back({it->first, it->second});
t = t - 1;
}
for (auto it = b.rbegin(); it != b.rend() && t_1; ++it) {
ans_1.push_back({it->first, it->second});
t_1 = t_1 - 1;
}
sort(ans.rbegin(), ans.rend());
sort(ans_1.rbegin(), ans_1.rend());
for (int i = 0; i < ans.size(); ++i) {
printf("S %d %d\n", ans[i].first, ans[i].second);
}
for (int i = 0; i < ans_1.size(); ++i) {
printf("B %d %d\n", ans_1[i].first, ans_1[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<char, map<int, int> > x;
vector<pair<int, int> > ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, d, p, q;
cin >> n >> d;
for (__typeof(n) i = 0; i < (n); ++i) {
char ch;
cin >> ch >> p >> q;
x[ch][p] += q;
}
for (int i = 0, j = 0; i < 100001 && j < d; i++) {
if (x['S'][i]) {
j++;
ans.push_back(make_pair(i, x['S'][i]));
}
}
for (__typeof(0) i = (int)ans.size() - 1; i >= 0; i--)
cout << "S " << ans[i].first << " " << ans[i].second << '\n';
for (int i = 100001, j = 0; i >= 0 && j < d; i--) {
if (x['B'][i]) {
j++;
cout << "B " << i << " " << x['B'][i] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
int p[1001], q[1001];
char d[1001];
int M[1001];
pair<int, long long> pp;
map<pair<char, long long>, int> m;
pair<char, long long> pa;
vector<pair<long long, long long> > Vs, Vb;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
long long n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> d[i] >> p[i] >> q[i];
}
for (int i = 0; i < n; i++) {
long long sum = q[i];
bool T = false;
pa.first = d[i];
pa.second = p[i];
if (!m[pa])
for (int j = i + 1; j < n; j++) {
if (d[i] == d[j] && p[i] == p[j]) {
T = true;
sum += q[j];
}
}
if (T) {
pp.first = p[i];
pp.second = sum;
if (d[i] == 'S') {
Vs.push_back(pp);
} else {
Vb.push_back(pp);
}
}
if (!T && !m[pa]) {
pp.first = p[i];
pp.second = q[i];
if (d[i] == 'S') {
Vs.push_back(pp);
} else {
Vb.push_back(pp);
}
}
m[pa] = 1;
}
sort(Vs.begin(), Vs.end());
sort(Vb.rbegin(), Vb.rend());
for (int i = min((long long)Vs.size(), s) - 1; i >= 0; i--) {
cout << 'S' << " " << Vs[i].first << " " << Vs[i].second << endl;
}
for (int i = 0; i < min((long long)Vb.size(), s); i++) {
cout << 'B' << " " << Vb[i].first << " " << Vb[i].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long z, n, s, a, b, ks, kb;
char x;
long long buy[1000005], sell[1000005];
long long bylob[1000005], bylos[1000005];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> x >> a >> b;
if (x == 'B' || x == 'b') {
if (bylob[a] == 0) {
bylob[a] += b;
buy[kb] = a;
kb++;
} else
bylob[a] += b;
} else {
if (bylos[a] == 0) {
bylos[a] += b;
sell[ks] = a;
ks++;
} else
bylos[a] += b;
}
}
sort(buy, buy + kb);
sort(sell, sell + ks);
z = 0;
for (int i = min(s - 1, ks - 1); i >= 0; i--) {
cout << "S " << sell[i] << " " << bylos[sell[i]] << "\n";
z++;
if (z == s) break;
}
z = 0;
for (int i = kb - 1; i >= 0; i--) {
cout << "B " << buy[i] << " " << bylob[buy[i]] << "\n";
z++;
if (z == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
int n, s;
cin >> n >> s;
map<int, int, greater<int>> buy;
map<int, int> sell;
vector<pair<int, int>> vt;
for (int i = 0; i < n; i++) {
char d;
int p, q;
cin >> d >> p >> q;
if (d == 'B') {
buy[p] += q;
} else {
sell[p] += q;
}
}
int a = 0, b = 0;
for (auto [i, j] : sell) {
vt.emplace_back(i, j);
a++;
if (a == s) break;
}
sort(vt.rbegin(), vt.rend());
for (auto [i, j] : vt) {
cout << "S " << i << ' ' << j << endl;
}
for (auto [i, j] : buy) {
cout << "B " << i << ' ' << j << endl;
b++;
if (b == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int B[100001], S[100001];
vector<pair<int, int> > buy;
vector<pair<int, int> > sell;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, s;
cin >> n >> s;
int countS = 0;
int countB = 0;
while (n--) {
char ch;
cin >> ch;
if (ch == 'B') {
countB++;
int a, b;
cin >> a >> b;
B[a] += b;
} else {
countS++;
int a, b;
cin >> a >> b;
S[a] += b;
}
}
int cur = 0;
for (int i = 0; i < 100001 && cur != s; i++) {
if (S[i] != 0) {
sell.push_back(make_pair(i, S[i]));
cur++;
}
}
sort(sell.begin(), sell.end(), greater<pair<int, int> >());
for (int i = 0; i < sell.size(); i++) {
cout << "S " << sell[i].first << " " << sell[i].second << endl;
}
cur = 0;
for (int i = 100000; i >= 0 && cur != s; i--) {
if (B[i] != 0) {
cout << "B " << i << " " << B[i] << endl;
cur++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, S;
scanf("%d", &n);
scanf("%d", &S);
string st;
map<int, int> b, s;
for (int i = 0; i < n; i++) {
cin >> st;
int p, q;
scanf("%d", &p);
scanf("%d", &q);
if (st[0] == 'B') {
b[p] += q;
} else {
s[p] += q;
}
}
int ct = max(0, (int)s.size() - S);
for (map<int, int>::reverse_iterator it = s.rbegin(); it != s.rend(); it++) {
if (ct) {
ct--;
continue;
}
cout << "S " << it->first << " " << it->second << endl;
}
ct = 0;
for (map<int, int>::reverse_iterator it = b.rbegin(); it != b.rend(); it++) {
cout << "B " << it->first << " " << it->second << endl;
ct++;
if (ct == S) break;
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e5;
using namespace std;
int n, s, x, y, z;
int sp[maxn + 5], bp[maxn + 5];
int S[maxn + 5], Scnt;
char op[3];
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) {
scanf("%s%d%d", op, &x, &y);
if (op[0] == 'S') {
sp[x] += y;
} else if (op[0] == 'B') {
bp[x] += y;
}
}
int scnt = 0, bcnt = 0;
for (int i = 1; i <= maxn && scnt < s; i++) {
if (sp[i]) S[++scnt] = i;
}
for (int i = scnt; i >= 1; i--) printf("S %d %d\n", S[i], sp[S[i]]);
for (int i = maxn; i >= 0 && bcnt < s; i--) {
if (bp[i]) printf("B %d %d\n", i, bp[i]), bcnt++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, i;
};
bool cmp1(node a, node b) { return a.x < b.x; }
bool cmp2(node a, node b) { return a.x > b.x; }
int main(void) {
int n, s, i;
node a[1100], b[1100];
node ans1[1100], ans2[1100];
while (scanf("%d%d", &n, &s) == 2) {
int cnt1, cnt2;
cnt1 = cnt2 = 0;
for (i = 1; i <= n; i++) {
char t[5];
int x, y;
scanf("%s%d%d", t, &x, &y);
if (t[0] == 'S') {
a[cnt1].i = i;
a[cnt1].x = x;
a[cnt1++].y = y;
} else {
b[cnt2].i = i;
b[cnt2].x = x;
b[cnt2++].y = y;
}
}
sort(a, a + cnt1, cmp1);
sort(b, b + cnt2, cmp2);
int t = 0;
int ti = 0;
int c1 = 0;
for (i = 0; i < cnt1; i++) {
if (t == 0) ti = a[i].i;
t += a[i].y;
if (i == cnt1 - 1 || a[i].x != a[i + 1].x) {
ans1[c1].x = a[i].x;
ans1[c1].y = t;
ans1[c1].i = ti;
c1++;
t = 0;
}
if (c1 >= s) break;
}
int c2 = 0;
t = 0;
for (i = 0; i < cnt2; i++) {
if (t == 0) ti = b[i].i;
t += b[i].y;
if (i == cnt2 - 1 || b[i].x != b[i + 1].x) {
ans2[c2].x = b[i].x;
ans2[c2].y = t;
ans2[c2].i = ti;
c2++;
t = 0;
}
if (c2 >= s) break;
}
sort(ans1, ans1 + c1, cmp2);
sort(ans2, ans2 + c2, cmp2);
for (i = 0; i < c1; i++) printf("S %d %d\n", ans1[i].x, ans1[i].y);
for (i = 0; i < c2; i++) printf("B %d %d\n", ans2[i].x, ans2[i].y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool pairCompare1(const pair<int, int>& firstElem,
const pair<int, int>& secondElem) {
return firstElem.first < secondElem.first;
}
bool pairCompare2(const pair<int, int>& firstElem,
const pair<int, int>& secondElem) {
return firstElem.first > secondElem.first;
}
int main() {
vector<int> buy;
set<int> s1, s2;
map<int, int> a, b;
vector<int> sell;
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
char c;
int p, q;
cin >> c;
cin >> p >> q;
if (c == 'B') {
s1.insert(p);
a[p] += q;
} else {
s2.insert(p);
b[p] += q;
}
}
buy.assign(s1.begin(), s1.end());
sell.assign(s2.begin(), s2.end());
sort(buy.begin(), buy.end());
sort(sell.begin(), sell.end());
if (sell.size() < s && buy.size() >= s) {
for (int i = 0; i < sell.size(); i++) {
cout << "S " << sell[sell.size() - 1 - i] << " "
<< b[sell[sell.size() - 1 - i]] << endl;
}
for (int i = 0; i < s; i++) {
cout << "B " << buy[buy.size() - 1 - i] << " "
<< a[buy[buy.size() - 1 - i]] << endl;
}
} else if (buy.size() < s && sell.size() >= s) {
for (int i = sell.size() - s; i < sell.size(); i++) {
cout << "S " << sell[sell.size() - 1 - i] << " "
<< b[sell[sell.size() - 1 - i]] << endl;
}
for (int i = 0; i < buy.size(); i++) {
cout << "B " << buy[buy.size() - 1 - i] << " "
<< a[buy[buy.size() - 1 - i]] << endl;
}
} else if (buy.size() < s && sell.size() < s) {
for (int i = 0; i < sell.size(); i++) {
cout << "S " << sell[sell.size() - 1 - i] << " "
<< b[sell[sell.size() - 1 - i]] << endl;
}
for (int i = 0; i < buy.size(); i++) {
cout << "B " << buy[buy.size() - 1 - i] << " "
<< a[buy[buy.size() - 1 - i]] << endl;
}
} else {
for (int i = sell.size() - s; i < sell.size(); i++) {
cout << "S " << sell[sell.size() - 1 - i] << " "
<< b[sell[sell.size() - 1 - i]] << endl;
}
for (int i = 0; i < s; i++) {
cout << "B " << buy[buy.size() - 1 - i] << " "
<< a[buy[buy.size() - 1 - i]] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-6;
const int INF = (int)(INT_MAX - 100);
const long long mod = (int)(1e+9 + 7);
const int N = (int)(1e5);
map<int, int> V, C;
int main() {
int n, s;
cin >> n >> s;
int p, k;
char d;
for (int i = 0; i < n; i++) {
cin >> d >> p >> k;
if (d == 'B')
C[p] += k;
else
V[p] += k;
}
k = 0;
vector<pair<int, int> > ans;
for (auto it = V.begin(); it != V.end(); it++, k++) {
if (k == s) break;
ans.push_back({(*it).first, (*it).second});
}
reverse(ans.begin(), ans.end());
for (auto x : ans) cout << "S " << x.first << " " << x.second << '\n';
k = 0;
for (auto it = C.rbegin(); it != C.rend(); it++, k++) {
if (k == s) break;
cout << "B " << (*it).first << " " << (*it).second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, x, y, j = 100001 - 1;
cin >> n >> k;
string a;
vector<long long int> b(100001);
vector<long long int> s(100001);
for (i = 0; i < n; i++) {
cin >> a >> x >> y;
if (a[0] == 'B')
b[x] = b[x] + y;
else
s[x] = s[x] + y;
}
x = 0;
for (i = 0; i < 100001 && x < k; i++) {
if (s[i] != 0) {
j = i;
x++;
}
}
for (; j >= 0; j--) {
if (s[j] != 0)
cout << "S"
<< " " << j << " " << s[j] << endl;
}
x = 0;
for (i = 100001 - 1; i >= 0 && x < k; i--) {
if (b[i] != 0) {
cout << "B"
<< " " << i << " " << b[i] << endl;
x++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[1000][2];
int s[1000][2];
int main() {
int n, ss;
cin >> n >> ss;
char d1;
int d2, d3;
int z = 0;
int q = 0;
for (int i = 0; i < n; i++) {
cin >> d1 >> d2 >> d3;
if (d1 == 'B') {
b[z][0] = d2;
b[z++][1] = d3;
} else {
s[q][0] = d2;
s[q++][1] = d3;
}
}
for (int i = 0; i < z - 1; i++) {
for (int j = i + 1; j < z; j++) {
if (b[i][0] < b[j][0]) {
swap(b[i][0], b[j][0]);
swap(b[i][1], b[j][1]);
} else if (b[i][0] == b[j][0]) {
b[i][1] = b[i][1] + b[j][1];
b[j][0] = -1;
}
}
}
for (int i = 0; i < q - 1; i++) {
for (int j = i + 1; j < q; j++) {
if (s[i][0] > s[j][0]) {
swap(s[i][0], s[j][0]);
swap(s[i][1], s[j][1]);
} else if (s[i][0] == s[j][0]) {
s[i][1] = s[i][1] + s[j][1];
s[j][0] = 1000000;
}
}
}
if (ss >= q) {
for (int i = q - 1; i >= 0; i--) {
if (s[i][0] != 1000000) {
cout << "S " << s[i][0] << " " << s[i][1] << endl;
}
}
} else {
for (int i = ss - 1; i >= 0; i--) {
if (s[i][0] != 1000000) {
cout << "S " << s[i][0] << " " << s[i][1] << endl;
}
}
}
if (ss >= z) {
for (int i = 0; i < z; i++) {
if (b[i][0] == -1) {
break;
}
cout << "B " << b[i][0] << " " << b[i][1] << endl;
}
} else {
for (int i = 0; i < ss; i++) {
if (b[i][0] == -1) {
break;
}
cout << "B " << b[i][0] << " " << b[i][1] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
vector<int> sell(10e5 + 1, 0), buy(10e5 + 1, 0);
for (int i = 0; i < n; i++) {
char d;
int p, g;
cin >> d >> p >> g;
if (d == 'S')
sell[p] += g;
else
buy[p] += g;
}
vector<pair<int, int>> vs, vb;
for (int i = 0; i < 10e5; i++) {
if (sell[i] != 0) vs.push_back(make_pair(i, sell[i]));
if (buy[i] != 0) vb.push_back(make_pair(i, buy[i]));
}
sort(vs.begin(), vs.end());
for (int i = s; i < vs.size(); i++) vs[i] = make_pair(0, 0);
sort(vs.rbegin(), vs.rend());
sort(vb.rbegin(), vb.rend());
for (int i = 0; i < vs.size() && vs[i].second != 0; i++)
cout << "S " << vs[i].first << " " << vs[i].second << "\n";
for (int i = 0; i < s && i < vb.size(); i++)
cout << "B " << vb[i].first << " " << vb[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, ct = 0, x, i, y, j;
char c;
cin >> n >> s;
map<int, int> buy, sell;
for (i = 0; i < n; i++) {
cin >> c >> x >> y;
if (c == 'B') {
buy[x] += y;
}
if (c == 'S') {
sell[x] += y;
}
}
map<int, int>::reverse_iterator rit;
ct = 1;
for (rit = sell.rbegin(); rit != sell.rend(); rit++) {
if (distance(rit, sell.rend()) > s) {
continue;
}
cout << "S"
<< " " << rit->first << " " << rit->second << endl;
}
ct = 1;
for (rit = buy.rbegin(); rit != buy.rend() && s--; rit++) {
cout << "B"
<< " " << rit->first << " " << rit->second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<char, long long>, long long> m;
map<pair<char, long long>, long long>::iterator it;
int main() {
stack<pair<long long, long long> > qb, qs;
long long n, s, a, b;
cin >> n >> s;
char c;
for (int i = 0; i < (int)(n); i++) {
cin >> c >> a >> b;
m[make_pair(c, a)] += b;
}
for (it = m.begin(); it != m.end(); it++) {
if (it->first.first == 'S') {
if (qs.size() < s) qs.push(make_pair(it->first.second, it->second));
} else
qb.push(make_pair(it->first.second, it->second));
}
int i = s;
while (i > 0 && !qs.empty()) {
cout << "S " << qs.top().first << " " << qs.top().second << endl;
qs.pop();
i--;
}
while (s > 0 && !qb.empty()) {
cout << "B " << qb.top().first << " " << qb.top().second << endl;
qb.pop();
s--;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s;
struct order {
char d;
int p, q;
bool operator<(const order& rgt) const {
if (d != rgt.d) return d == 'S';
if (d == 'S')
return p < rgt.p;
else
return p > rgt.p;
}
bool operator==(const order& rgt) const { return d == rgt.d && p == rgt.p; }
} od[1010];
int st[1010];
int main() {
while (scanf("%d%d", &n, &s) != EOF) {
for (int i = 0; i < n; ++i) cin >> od[i].d >> od[i].p >> od[i].q;
sort(od, od + n);
for (int i = 0; i < n - 1; ++i) {
if (od[i] == od[i + 1]) {
if (od[i].q == -1) {
for (int j = i - 1; j >= 0; --j)
if (od[j] == od[i] && od[j].q != -1) {
od[j].q += od[i + 1].q;
od[i + 1].q = -1;
break;
}
} else {
od[i].q = od[i].q + od[i + 1].q;
od[i + 1].q = -1;
}
}
}
int cur = 0;
int cnt = 0;
for (int i = 0; i < n; ++i)
if (od[i].d == 'S') {
if (cnt >= s) break;
if (od[i].q != -1) {
st[cur++] = i;
++cnt;
}
}
for (int i = cur - 1; i >= 0; --i)
printf("%c %d %d\n", od[st[i]].d, od[st[i]].p, od[st[i]].q);
cnt = 0;
for (int i = 0; i < n; ++i)
if (od[i].d == 'B') {
if (cnt >= s) break;
if (od[i].q != -1) {
printf("%c %d %d\n", od[i].d, od[i].p, od[i].q);
++cnt;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> p, q;
vector<char> d;
int main() {
cin >> n >> k;
p.resize(n);
q.resize(n);
d.resize(n);
for (int i = 0; i < n; i++) {
cin >> d[i] >> p[i] >> q[i];
}
map<int, int> b, s;
for (int i = 0; i < n; i++) {
if (d[i] == 'S') {
if (s.find(p[i]) == s.end())
s[p[i]] = q[i];
else
s[p[i]] += q[i];
} else {
if (b.find(-p[i]) == b.end())
b[-p[i]] = q[i];
else
b[-p[i]] += q[i];
}
}
int cnt = s.size();
for (map<int, int>::reverse_iterator it = s.rbegin(); it != s.rend(); it++) {
if (cnt <= k) {
cout << "S " << it->first << " " << it->second << "\n";
}
cnt--;
}
cnt = 0;
for (map<int, int>::iterator it = b.begin(); it != b.end(); it++) {
if (cnt < k) {
cout << "B " << -it->first << " " << it->second << "\n";
} else
break;
cnt++;
}
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, s, p, q;
char d;
map<long long, long long> buy_stock, sell_stock;
cin >> n >> s;
while (n--) {
cin >> d >> p >> q;
(d == 'B' ? buy_stock : sell_stock)[p] += q;
}
map<long long, long long>::iterator it;
vector<pair<long long, long long> > tans;
for (p = 0, it = sell_stock.begin(); p < s && it != sell_stock.end();
p++, it++)
tans.push_back(make_pair(it->first, it->second));
for (p = (int)tans.size() - 1; p >= 0; p--)
cout << "S " << tans[p].first << " " << tans[p].second << "\n";
map<long long, long long>::reverse_iterator rit;
for (p = 0, rit = buy_stock.rbegin(); p < s && rit != buy_stock.rend();
p++, rit++)
cout << "B " << rit->first << " " << rit->second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, x, y;
string op;
map<int, int> b, s;
cin >> n >> q;
while (n--) {
cin >> op >> x >> y;
if (op == "B")
b[x] += y;
else
s[x] += y;
}
vector<pair<int, int> > sell, buy;
for (__typeof((s).begin()) i = (s).begin(); i != (s).end(); i++) {
sell.push_back(make_pair(i->first, i->second));
if (sell.size() == q) break;
}
for (__typeof((b).begin()) i = (b).begin(); i != (b).end(); i++)
buy.push_back(make_pair(i->first, i->second));
reverse(buy.begin(), buy.end());
reverse(sell.begin(), sell.end());
for (int i = 0; i < sell.size() && i < q; i++)
cout << "S"
<< " " << sell[i].first << " " << sell[i].second << '\n';
for (int i = 0; i < buy.size() && i < q; i++)
cout << "B"
<< " " << buy[i].first << " " << buy[i].second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
void merge(int a[][1002], int x, int y, int z) {
int s1 = y - x + 1, s2 = z - y;
int b[2][s1], c[2][s2], i, j, k;
for (i = x, j = 0; i <= y; i++) {
b[0][j] = a[0][i];
b[1][j] = a[1][i];
j++;
}
for (i = y + 1, j = 0; i <= z; i++) {
c[0][j] = a[0][i];
c[1][j] = a[1][i];
j++;
}
for (i = x, j = 0, k = 0; i <= z; i++) {
if (b[0][j] < c[0][k]) {
a[0][i] = b[0][j];
a[1][i] = b[1][j];
j++;
if (j == s1) break;
} else {
a[0][i] = c[0][k];
a[1][i] = c[1][k];
k++;
if (k == s2) break;
}
}
while (j < s1) {
i++;
a[0][i] = b[0][j];
a[1][i] = b[1][j];
j++;
}
while (k < s2) {
i++;
a[0][i] = c[0][k];
a[1][i] = c[1][k];
k++;
}
}
void mergesort(int a[][1002], int start, int end) {
if (start < end) {
int mid = (start + end) / 2;
mergesort(a, start, mid);
mergesort(a, mid + 1, end);
merge(a, start, mid, end);
}
}
int main() {
int i, n, se, j = 0, k = 0;
scanf("%d %d", &n, &se);
char ch[3];
int b[2][1002], s[2][1002], newb[2][1002], news[2][1002];
for (i = 0; i < n; i++) {
scanf("%s", ch);
if (strcmp(ch, "B") == 0) {
scanf("%d %d", &b[0][j], &b[1][j]);
j++;
} else {
scanf("%d %d", &s[0][k], &s[1][k]);
k++;
}
}
mergesort(b, 0, j - 1);
int x, s1 = 0, s2 = 0;
;
if (j > 0) {
x = b[0][0];
newb[0][0] = x, newb[1][0] = b[1][0];
for (i = 1; i < j; i++) {
if (b[0][i] == x)
newb[1][s1] += b[1][i];
else {
s1++;
newb[0][s1] = b[0][i];
newb[1][s1] = b[1][i];
x = b[0][i];
}
}
}
mergesort(s, 0, k - 1);
if (k > 0) {
x = s[0][0];
news[0][0] = x, news[1][0] = s[1][0];
for (i = 1; i < k; i++) {
if (s[0][i] == x)
news[1][s2] += s[1][i];
else {
s2++;
news[0][s2] = s[0][i];
news[1][s2] = s[1][i];
x = s[0][i];
}
}
}
int temp;
if (k > 0) {
if ((s2 + 1) < se)
temp = s2;
else
temp = se - 1;
for (i = 0; i <= temp; i++) {
printf("S %d %d\n", news[0][temp - i], news[1][temp - i]);
}
}
if (j > 0) {
if ((s1 + 1) < se)
temp = s1;
else
temp = se - 1;
for (i = 0; i <= temp; i++) {
printf("B %d %d\n", newb[0][s1 - i], newb[1][s1 - i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > buy;
vector<pair<int, int> > sell;
int main() {
int i, j, k, s, n, l, n1, n2, m;
char ch;
cin >> n >> s;
for (i = 0; i < n; i++) {
cin >> ch >> n1 >> n2;
if (ch == 'B') {
int f = 0;
for (j = 0; j < buy.size(); j++) {
if (buy[j].first == n1) {
buy[j].second += n2;
f = 1;
}
}
if (f == 0) buy.push_back(make_pair(n1, n2));
} else {
int f = 0;
for (j = 0; j < sell.size(); j++) {
if (sell[j].first == n1) {
sell[j].second += n2;
f = 1;
}
}
if (f == 0) sell.push_back(make_pair(n1, n2));
}
}
sort(buy.begin(), buy.end());
sort(sell.begin(), sell.end());
int cnt = 0, len;
if (sell.size() <= s)
len = sell.size() - 1;
else
len = s - 1;
for (i = len; i >= 0; i--) {
cout << "S"
<< " " << sell[i].first << " " << sell[i].second << endl;
}
cnt = 0;
for (i = buy.size() - 1; i >= 0; i--) {
cout << "B"
<< " " << buy[i].first << " " << buy[i].second << endl;
cnt++;
if (cnt == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
const long long LINF = numeric_limits<long long>::max();
const double DINF = numeric_limits<double>::max();
double eps = 1e-2;
struct call {
char type;
long long p;
long long q;
};
bool cmpb(call a, call b) { return a.p >= b.p; }
bool cmps(call a, call b) { return a.p <= b.p; }
void solve() {
int n, s;
cin >> n >> s;
vector<call> by, sl;
for (int i = 0; i < n; ++i) {
char t;
long long pr, qu;
cin >> t >> pr >> qu;
call temp;
temp.type = t;
temp.p = pr;
temp.q = qu;
if (t == 'B') {
bool is = false;
int wh = 0;
for (int i = 0; i < (int)by.size(); ++i) {
if (by[i].p == pr) {
is = true;
wh = i;
}
}
if (!is)
by.push_back(temp);
else
by[wh].q += qu;
} else if (t == 'S') {
bool is = false;
int wh = 0;
for (int i = 0; i < (int)sl.size(); ++i) {
if (sl[i].p == pr) {
is = true;
wh = i;
}
}
if (!is)
sl.push_back(temp);
else
sl[wh].q += qu;
}
}
sort(by.begin(), by.end(), &cmpb);
sort(sl.begin(), sl.end(), &cmps);
vector<call> slans;
for (int i = 0; i < (int)sl.size() && i < s; ++i) slans.push_back(sl[i]);
sort(slans.begin(), slans.end(), &cmpb);
for (int i = 0; i < (int)slans.size(); ++i)
cout << slans[i].type << ' ' << slans[i].p << ' ' << slans[i].q << "\n";
for (int i = 0; i < (int)by.size() && i < s; ++i)
cout << by[i].type << ' ' << by[i].p << ' ' << by[i].q << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int k = 0; k < t; ++k) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s;
char ch[2];
pair<int, int> sell[60], buy[60];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
sl;
priority_queue<pair<int, int> > by;
int main() {
while (scanf("%d%d", &n, &s) != EOF) {
memset(sell, 0, sizeof sell);
memset(buy, 0, sizeof buy);
int u = -1, v = -1;
while (n--) {
int x, y;
scanf("%s%d%d", ch, &x, &y);
if (ch[0] == 'B') {
by.push(make_pair(x, y));
} else {
sl.push(make_pair(x, y));
}
}
if (!sl.empty()) {
u++;
sell[u] = sl.top();
sl.pop();
while (!sl.empty()) {
if (sl.top().first == sell[u].first) {
sell[u].second += sl.top().second;
sl.pop();
} else if (u + 1 < s) {
sell[++u] = sl.top();
sl.pop();
} else
break;
}
}
if (!by.empty()) {
v++;
buy[v] = by.top();
by.pop();
while (!by.empty()) {
if (by.top().first == buy[v].first) {
buy[v].second += by.top().second;
by.pop();
} else if (v + 1 < s) {
buy[++v] = by.top();
by.pop();
} else
break;
}
}
while (!sl.empty()) sl.pop();
while (!by.empty()) by.pop();
for (int i = u; i >= 0; i--) {
printf("S %d %d\n", sell[i].first, sell[i].second);
}
for (int i = 0; i <= v; i++) {
printf("B %d %d\n", buy[i].first, buy[i].second);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
int B[100000 + 5];
int S[100000 + 5];
int main() {
int k, n;
cin >> n >> k;
for (int i = 0; i < n; i++) {
char c;
int a, b;
cin >> c >> a >> b;
if (c == 'B') {
B[a] += b;
} else {
S[a] += b;
}
}
int t = k;
stack<int> SS, SSS;
for (int i = 0; i <= 100000 + 4 && t; i++) {
if (S[i]) SS.push(i), SSS.push(S[i]), t--;
}
while (!SS.empty()) {
int a = SS.top(), b = SSS.top();
SS.pop();
SSS.pop();
printf("S %d %d\n", a, b);
}
t = k;
for (int i = 100000 + 4; i >= 0 && t; i--) {
if (B[i]) printf("B %d %d\n", i, B[i]), t--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, t, n, m, a, b, c, x, y, z, s;
cin >> n >> s;
char ch;
map<long long int, long long int> map1;
map<long long int, long long int> map2;
for (i = 1; i <= n; i++) {
cin >> ch >> x >> y;
if (ch == 'B') {
map1[x] += y;
} else
map2[x] += y;
}
map<long long int, long long int>::reverse_iterator it;
long long int cnt = 0;
if (map2.size() <= s) {
for (it = map2.rbegin(); it != map2.rend(); it++) {
cnt++;
cout << "S"
<< " " << it->first << " " << it->second;
printf("\n");
if (cnt >= s) break;
}
} else {
long long int t1 = map2.size() - s;
it = map2.rbegin();
if (t1) {
for (; it != map2.rend();) {
it++;
t1--;
if (t1 <= 0) break;
}
}
for (; it != map2.rend(); it++) {
cnt++;
cout << "S"
<< " " << it->first << " " << it->second;
printf("\n");
if (cnt >= s) break;
}
}
map<long long int, long long int>::reverse_iterator it1;
cnt = 0;
for (it1 = map1.rbegin(); it1 != map1.rend(); it1++) {
cnt++;
cout << "B"
<< " " << it1->first << " " << it1->second;
printf("\n");
if (cnt >= s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Z {
char status;
long price, quantity;
};
bool compare(Z a, Z b) { return (a.price > b.price); }
int main() {
int n, s;
cin >> n >> s;
vector<Z> myVector;
for (int i = 0; i < n; i++) {
Z single;
bool flag = true;
cin >> single.status >> single.price >> single.quantity;
for (int j = 0; j < myVector.size(); j++) {
if (myVector[j].status == single.status &&
myVector[j].price == single.price) {
myVector[j].quantity = myVector[j].quantity + single.quantity;
flag = false;
break;
}
}
if (flag) {
myVector.push_back(single);
}
}
sort(myVector.begin(), myVector.end(), compare);
int b = myVector.size();
for (int i = 0; i < myVector.size(); i++) {
if (myVector[i].status == 'B') {
b = i;
break;
}
}
for (int i = max(0, b - s); i < min(int(myVector.size()), b + s); i++) {
cout << myVector[i].status << " " << myVector[i].price << " "
<< myVector[i].quantity << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int partition2(vector<int> &A, vector<int> &B, int p, int r) {
int x = A[p];
int i = p;
int j = r;
while (true) {
while (A[i] > x) {
i++;
}
while (A[j] < x) {
j--;
}
if (i < j) {
int temp = A[i];
A[i] = A[j];
A[j] = temp;
swap(B[i], B[j]);
i++;
j--;
} else {
return j;
}
}
}
void quicksort2(vector<int> &A, vector<int> &B, int p, int r) {
if (p < r) {
int q = partition2(A, B, p, r);
quicksort2(A, B, p, q);
quicksort2(A, B, q + 1, r);
}
}
int partition1(vector<int> &A, vector<int> &B, int p, int r) {
int x = A[p];
int i = p;
int j = r;
while (true) {
while (A[i] < x) {
i++;
}
while (A[j] > x) {
j--;
}
if (i < j) {
int temp = A[i];
A[i] = A[j];
A[j] = temp;
swap(B[i], B[j]);
i++;
j--;
} else {
return j;
}
}
}
void quicksort1(vector<int> &A, vector<int> &B, int p, int r) {
if (p < r) {
int q = partition1(A, B, p, r);
quicksort1(A, B, p, q);
quicksort1(A, B, q + 1, r);
}
}
int main() {
int n, s;
cin >> n >> s;
vector<int> buy, sell, buy_vol, sell_vol;
char c;
int a, b;
for (int i = 0; i < n; i++) {
cin >> c >> a >> b;
if (c == 'B') {
buy.push_back(a);
buy_vol.push_back(b);
} else {
sell.push_back(a);
sell_vol.push_back(b);
}
}
quicksort2(buy, buy_vol, 0, buy.size() - 1);
quicksort1(sell, sell_vol, 0, sell.size() - 1);
vector<int> sbook[2], bbook[2];
int j = 0, k;
for (int i = 0; j < sell.size(); i++) {
int temp = sell[j];
sbook[0].push_back(temp);
sbook[1].push_back(sell_vol[j]);
j++;
while (sell[j] == temp) {
sbook[1][i] += sell_vol[j];
j++;
}
}
vector<int> temp[2];
k = s < sbook[0].size() ? s : sbook[0].size();
for (int i = 0; i < k; i++) {
temp[0].push_back(sbook[0][i]);
temp[1].push_back(sbook[1][i]);
}
quicksort2(temp[0], temp[1], 0, temp[0].size() - 1);
for (int i = 0; i < temp[0].size(); i++) {
cout << "S " << temp[0][i] << " " << temp[1][i] << endl;
}
j = 0;
for (int i = 0; j < buy.size(); i++) {
int temp = buy[j];
bbook[0].push_back(temp);
bbook[1].push_back(buy_vol[j]);
j++;
while (buy[j] == temp) {
bbook[1][i] += buy_vol[j];
j++;
}
}
k = s < bbook[0].size() ? s : bbook[0].size();
for (int i = 0; i < k; i++)
cout << "B " << bbook[0][i] << " " << bbook[1][i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 512345, lgN = 20, rootN = 1123;
map<long long, long long> sell, buy;
vector<long long> vec;
int main() {
long long n, s, p, q;
char c;
cin >> n >> s;
assert(n <= 1000);
for (int i = 1; i <= n; ++i) {
cin >> c >> p >> q;
assert(q <= 10000);
if (c == 'B') {
buy[-p] += q;
} else if (c == 'S') {
sell[p] += q;
} else {
assert(false);
}
}
{
for (auto it = sell.begin(); it != sell.end(); ++it) {
vec.push_back(it->first);
}
int start = min((long long)s - 1, (long long)vec.size() - 1);
for (int i = start, ct = 0; ct < s && i >= 0; --i, ++ct) {
printf("S %lld %lld\n", vec[i], sell[vec[i]]);
}
}
{
int ct = 0;
for (auto it = buy.begin(); it != buy.end() && ct < s; ++it, ++ct) {
printf("B %lld %lld\n", -1 * (it->first), it->second);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1010][2], b[1010][2];
int main() {
int n, s, p, q, c, d;
char dir;
c = d = 0;
scanf("%d%d", &n, &s);
getchar();
while (n--) {
scanf("%c%d%d", &dir, &p, &q);
getchar();
if (dir == 'S') {
int i;
for (i = 0; i < c; i++) {
if (a[i][0] == p) {
a[i][1] += q;
break;
}
}
if (i == c) {
a[c][0] = p;
a[c][1] = q;
c++;
}
} else {
int i;
for (i = 0; i < d; i++) {
if (b[i][0] == p) {
b[i][1] += q;
break;
}
}
if (i == d) {
b[d][0] = p;
b[d][1] = q;
d++;
}
}
}
for (int i = 0; i < c - 1; i++) {
int k = i;
for (int j = i + 1; j < c; j++) {
if (a[j][0] <= a[k][0]) k = j;
}
if (i != k) {
swap(a[i][0], a[k][0]);
swap(a[i][1], a[k][1]);
}
}
for (int i = 0; i < d - 1; i++) {
int k = i;
for (int j = i + 1; j < d; j++) {
if (b[j][0] >= b[k][0]) k = j;
}
if (i != k) {
swap(b[i][0], b[k][0]);
swap(b[i][1], b[k][1]);
}
}
for (int i = min(s, c) - 1; i >= 0; i--) {
printf("S %d %d\n", a[i][0], a[i][1]);
}
for (int i = 0; i < s && i < d; i++) {
printf("B %d %d\n", b[i][0], b[i][1]);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.