text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
const int MAX_V = 3e5 + 5;
struct edge {
int to, cost, id;
};
vector<edge> G[MAX_V];
long long d[MAX_V], n, m;
int s, w[MAX_V], pa[MAX_V];
void solve() {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
que;
fill(d, d + n + 1, INF);
d[s] = 0;
que.push(pair<long long, int>(0, s));
while (!que.empty()) {
pair<long long, int> p = que.top();
que.pop();
int v = p.second;
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
pa[e.to] = e.id;
que.push(pair<long long, int>(d[e.to], e.to));
} else if (d[e.to] == d[v] + e.cost) {
if (w[pa[e.to]] > e.cost) pa[e.to] = e.id;
}
}
}
long long cost = 0;
for (int i = 1; i <= n; i++) cost += w[pa[i]];
cout << cost << endl;
for (int i = 1; i <= n; i++)
if (pa[i]) printf("%d ", pa[i]);
puts("");
}
int main() {
int u, v, c;
cin >> n >> m;
memset(pa, 0, sizeof(pa));
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &u, &v, &c);
G[u].push_back((edge){v, c, i});
G[v].push_back((edge){u, c, i});
w[i] = c;
}
scanf("%d", &s);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long to;
long long weight;
long long num_ari;
long long dist;
};
struct cmp {
bool operator()(const Node &a, const Node &b) {
if (a.dist == b.dist) return a.weight > b.weight;
return a.dist > b.dist;
}
};
vector<Node> ady[300000 + 10];
long long distancia[300000 + 10];
bool visitado[300000 + 10];
priority_queue<Node, vector<Node>, cmp> Q;
long long V;
long long previo[300000 + 10];
vector<long long> MST;
void init() {
for (int i = 0; i <= V; ++i) {
distancia[i] = 1 << 30;
visitado[i] = false;
previo[i] = -1;
}
}
void relajacion(long long actual, long long adyacente, long long peso,
long long arista) {
Q.push({ady[actual][adyacente].to, ady[actual][adyacente].weight, arista,
ady[actual][adyacente].weight + peso});
}
void dijkstra(long long inicial) {
long long total = 0;
init();
Q.push({inicial, 0, 0, 0});
long long actual, adyacente, peso, arista, dist_act, peso_del_nodo;
while (!Q.empty()) {
actual = Q.top().to;
dist_act = Q.top().dist;
peso_del_nodo = Q.top().weight;
arista = Q.top().num_ari;
Q.pop();
if (visitado[actual]) continue;
visitado[actual] = true;
if (arista != 0) {
MST.push_back(arista);
total += peso_del_nodo;
}
for (int i = 0; i < ady[actual].size(); ++i) {
adyacente = ady[actual][i].to;
peso = ady[actual][i].weight;
arista = ady[actual][i].num_ari;
if (!visitado[adyacente]) {
relajacion(actual, i, dist_act, arista);
}
}
}
sort(MST.begin(), MST.end());
cout << total << endl;
for (int i = 0; i < MST.size(); i++) {
if (i == MST.size() - 1)
cout << MST[i] << endl;
else
cout << MST[i] << " ";
}
}
int main() {
long long E, origen, destino, peso, inicial;
cin >> V >> E;
for (int i = 1; i <= E; i++) {
cin >> origen >> destino >> peso;
ady[origen - 1].push_back({destino - 1, peso, i, 1 << 30});
ady[destino - 1].push_back({origen - 1, peso, i, 1 << 30});
}
cin >> inicial;
dijkstra(inicial - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int src, dest;
long long int cost;
} node;
node create_node(int a, int b, long long int c) {
node ret;
ret.src = a;
ret.dest = b;
ret.cost = c;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<long long int> min_dist(n, LONG_LONG_MAX);
vector<int> parent(n);
for (int i = 0; i < n; i++) parent[i] = i;
vector<long long int> incoming_edge(n, LONG_LONG_MAX);
vector<pair<long long int, long long int> > graph[n];
vector<node> edges(m);
for (int i = 0; i < m; i++) {
int a, b;
long long int c;
cin >> a >> b >> c;
a -= 1;
b -= 1;
graph[a].push_back(make_pair(b, c));
graph[b].push_back(make_pair(a, c));
edges[i] = create_node(a, b, c);
}
int start;
cin >> start;
start -= 1;
min_dist[start] = incoming_edge[start] = 0;
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
pq;
pq.push(make_pair(0, start));
while (!pq.empty()) {
pair<long long int, long long int> t = pq.top();
pq.pop();
int v = (int)t.second;
long long int cost = t.first;
for (int i = 0; i < graph[v].size(); i++) {
int u = graph[v][i].first;
long long int temp = graph[v][i].second + cost;
if (temp < min_dist[u]) {
parent[u] = v;
min_dist[u] = temp;
incoming_edge[u] = temp - cost;
pq.push(make_pair(temp, u));
} else if (temp == min_dist[u]) {
if (incoming_edge[u] > (temp - cost)) {
incoming_edge[u] = temp - cost;
parent[u] = v;
}
}
}
}
long long int ans = 0;
for (int i = 0; i < n; i++) ans += incoming_edge[i];
cout << ans << endl;
for (int i = 0; i < m; i++) {
int a = edges[i].src;
int b = edges[i].dest;
if (parent[a] == b || parent[b] == a) cout << i + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 5;
bool res[N];
bool vis[N];
struct edge {
int f, to, w1;
long long w2;
int idx;
bool operator<(const edge &e) const {
if (w2 != e.w2) return w2 < e.w2;
if (w1 != e.w1) return w1 < e.w1;
return idx < e.idx;
}
};
int n, m, u;
vector<set<edge>> g(N);
long long sm = 0;
void relax(edge &e) {
for (auto &it : g[e.to]) {
auto tmp = it;
if (!vis[tmp.to]) {
tmp.w2 += e.w2;
g[u].insert(tmp);
}
}
}
void solve() {
int edges = 0;
vis[u] = 1;
while (edges < n - 1) {
edge tmp = *g[u].begin();
g[u].erase(g[u].begin());
if (vis[tmp.to]) continue;
res[tmp.idx] = 1;
vis[tmp.to] = 1;
sm += tmp.w1;
++edges;
relax(tmp);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int f, t, w;
scanf("%d%d%d", &f, &t, &w);
g[f].insert({f, t, w, w, i + 1});
g[t].insert({t, f, w, w, i + 1});
}
scanf("%d", &u);
solve();
cout << sm << '\n';
for (int i = 1; i <= m; ++i)
if (res[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::sort;
using std::string;
using std::swap;
struct xy {
int fr, go, num;
long long val;
void in() {
cin >> fr >> go >> val;
--fr;
--go;
}
} arr[400010];
bool operator<(xy a, xy b) { return a.val < b.val; }
std::vector<int> ans;
long long bfs(std::vector<std::pair<int, int> > *v, int n) {
std::queue<int> q;
long long ver[n];
for (int i = 0; i < n; ++i) ver[i] = LLONG_MAX;
int u;
cin >> u;
--u;
q.push(u);
ver[u] = 0;
while (q.size()) {
int now = q.front();
q.pop();
for (std::pair<int, int> &i : v[now])
if (ver[now] + arr[i.second].val < ver[i.first]) {
ver[i.first] = ver[now] + arr[i.second].val;
q.push(i.first);
}
}
ans = std::vector<int>();
long long sum = 0;
for (int j = 0; j < n; ++j) {
if (j == u) continue;
long long min = LLONG_MAX;
int now = -1;
for (std::pair<int, int> &i : v[j])
if (ver[j] - arr[i.second].val == ver[i.first] &&
arr[i.second].val < min) {
min = arr[now = i.second].val;
}
sum += min;
ans.push_back(now);
};
return sum;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
{
int n, m;
while (cin >> n >> m) {
std::vector<std::pair<int, int> > v[n];
for (int i = 0; i < m; ++i) {
arr[i].in();
arr[i].num = i;
v[arr[i].fr].push_back(std::make_pair(arr[i].go, i));
v[arr[i].go].push_back(std::make_pair(arr[i].fr, i));
}
cout << bfs(v, n) << endl;
for (int &i : ans) cout << i + 1 << " ";
cout << endl;
;
};
}
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, pair<long long int, long long int> > > gr[300010];
multiset<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >
s;
vector<long long int> edg;
long long int val[300010], ed[300010];
bool visit[300010];
long long int dist[300010], cost[300010];
int main() {
long long int n, m, i, j, u, v, w, st, e, vl;
long long int mn;
cin >> n >> m;
multiset<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >::iterator it;
memset(visit, 0, sizeof(visit));
for (i = 1; i <= m; i++) {
cin >> u >> v >> w;
gr[u].push_back(make_pair(w, make_pair(v, i)));
gr[v].push_back(make_pair(w, make_pair(u, i)));
}
cin >> st;
dist[st] = 0;
visit[st] = 1;
for (i = 1; i <= n; i++) {
if (i == st) continue;
s.insert(make_pair(make_pair((9000000000000000000), 2000000000),
make_pair(i, 0)));
cost[i] = (9000000000000000000);
val[i] = 2000000000;
ed[i] = 0;
}
for (i = 0; i < gr[st].size(); i++) {
v = gr[st][i].second.first;
if (!visit[v]) {
vl = gr[st][i].first;
w = vl + dist[st];
e = gr[st][i].second.second;
it = s.find(make_pair(make_pair(cost[v], val[v]), make_pair(v, ed[v])));
if ((w < cost[v]) || (w == cost[v] && vl < val[v])) {
s.erase(it);
s.insert(make_pair(make_pair(w, vl), make_pair(v, e)));
cost[v] = w;
val[v] = vl;
ed[v] = e;
}
}
}
mn = 0;
while (!s.empty()) {
it = s.begin();
st = (it->second).first;
mn += val[st];
edg.push_back(ed[st]);
dist[st] = cost[st];
s.erase(it);
visit[st] = 1;
for (i = 0; i < gr[st].size(); i++) {
v = gr[st][i].second.first;
if (!visit[v]) {
vl = gr[st][i].first;
w = vl + dist[st];
e = gr[st][i].second.second;
it = s.find(make_pair(make_pair(cost[v], val[v]), make_pair(v, ed[v])));
if ((w < cost[v]) || (w == cost[v] && vl < val[v])) {
s.erase(it);
s.insert(make_pair(make_pair(w, vl), make_pair(v, e)));
cost[v] = w;
val[v] = vl;
ed[v] = e;
}
}
}
}
cout << mn << endl;
for (i = 0; i < (n - 1); i++) cout << edg[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300005;
const long long int INF = 1e16;
vector<pair<pair<int, int>, int> > G[MAX];
int ans[MAX];
long long int last[MAX];
int edge[MAX];
long long int d[MAX];
void dijkstra(int start) {
long long int u, v, i, c, w;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
memset(d, 0x3f, sizeof d);
Q.push(pair<int, int>(0, start));
d[start] = 0;
last[start] = -1;
while (!Q.empty()) {
u = Q.top().second;
c = Q.top().first;
Q.pop();
if (d[u] < c) continue;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i].first.first;
w = G[u][i].first.second;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
last[v] = G[u][i].first.second;
ans[v] = G[u][i].second;
Q.push(pair<int, int>(d[v], v));
} else if (d[v] == (d[u] + w)) {
if (last[v] > w) {
last[v] = w;
ans[v] = G[u][i].second;
}
}
}
}
}
int main() {
long long int n, e, i, u, v, w, start;
while (scanf("%lld %lld", &n, &e) == 2) {
for (i = 1; i <= n; i++) G[i].clear();
for (i = 1; i <= e; i++) {
scanf("%lld %lld %lld", &u, &v, &w);
G[u].push_back(make_pair(pair<int, int>(v, w), i));
G[v].push_back(make_pair(pair<int, int>(u, w), i));
edge[i] = w;
}
scanf("%lld", &start);
dijkstra(start);
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i != start) sum += edge[ans[i]];
}
cout << sum << "\n";
for (int i = 1; i <= n; i++) {
if (i != start) cout << ans[i] << " ";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int mod = (int)1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1.0);
int n, m, k;
struct node {
int v;
long long cost, w;
int id;
node(int vv = 0, long long ww = 0, int nn = 0, long long cc = 0)
: v(vv), w(ww), cost(cc), id(nn) {}
bool operator<(node b) const { return w == b.w ? cost > b.cost : w > b.w; }
};
vector<node> edg[300010];
long long dis[300010];
bool vis[300010];
void dijkstra(int s) {
vector<int> ans;
priority_queue<node> q;
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) dis[i] = 1e18;
dis[s] = 0;
q.push(node(s));
long long cost = 0;
while (!q.empty()) {
node from = q.top();
q.pop();
int u = from.v;
if (vis[u]) continue;
vis[u] = true;
if (from.id > 0) ans.push_back(from.id);
cost += from.cost;
for (int i = 0; i < (int)edg[u].size(); i++) {
long long v = edg[u][i].v, w = edg[u][i].w, id = edg[u][i].id;
if (!vis[v] && dis[v] >= dis[u] + w) {
dis[v] = dis[u] + w;
q.push(node(v, dis[v], id, w));
}
}
}
cout << cost << endl;
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); i++) {
printf("%d%c", ans[i], " \n"[i == (int)ans.size() - 1]);
}
}
int main() {
while (cin >> n >> m) {
int u, v, w;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
edg[u].push_back(node(v, w, i));
edg[v].push_back(node(u, w, i));
}
cin >> u;
dijkstra(u);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
priority_queue<pair<long long, long long> > q;
int n, m;
long long ver[N << 1], edge[N << 1], pre[N << 1], nex[N << 1], head[N << 1],
tot, s;
long long pick[N], sum;
long long d[N];
void add(long long x, long long y, long long z) {
ver[++tot] = y;
edge[tot] = z;
nex[tot] = head[x];
head[x] = tot;
}
void dij() {
memset(d, 0x3f, sizeof(d));
d[s] = 0;
q.push({-d[s], s});
while (!q.empty()) {
long long x = q.top().second;
q.pop();
for (int i = head[x]; i; i = nex[i]) {
long long y = ver[i];
if (d[y] > d[x] + edge[i]) {
pick[y] = (i + 1) / 2;
d[y] = d[x] + edge[i];
q.push({-d[y], y});
} else if (d[y] == d[x] + edge[i]) {
if (edge[pick[y] * 2] > edge[i]) pick[y] = (i + 1) / 2;
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
cin >> s;
dij();
for (int i = 1; i <= n; i++)
if (i != s) sum += edge[pick[i] * 2];
cout << sum << endl;
for (int i = 1; i <= n; i++)
if (i != s) cout << pick[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int INF = 100000000000000000ll;
vector<pair<int, pair<int, int> > > graph[300005];
bool visited[300005], cons[300005];
long long dist[300005], dist1[300005], w, w1;
int edge[300005], num[300005];
set<pair<long long, int> > dijkstra;
vector<int> answer;
int main() {
int v, e, u, index, id, temp_v;
cin >> v >> e;
temp_v = v;
int a, b, c;
for (int i = 0; i < e; i++) {
cin >> a >> b >> c;
graph[a].push_back(make_pair(b, make_pair(c, i + 1)));
graph[b].push_back(make_pair(a, make_pair(c, i + 1)));
edge[i + 1] = c;
}
int s;
cin >> s;
for (int i = 1; i <= v; i++) {
dist[i] = INF;
dist1[i] = INF;
visited[i] = false;
num[i] = -1;
}
dist[s] = 0;
dist1[s] = 0;
dijkstra.insert(make_pair(0ll, s));
pair<long long, int> temp, t;
while (!dijkstra.empty()) {
t = *dijkstra.begin();
dijkstra.erase(t);
visited[t.second] = true;
w = t.first;
u = t.second;
for (int i = 0; i < graph[u].size(); i++) {
w1 = graph[u][i].second.first;
v = graph[u][i].first;
index = graph[u][i].second.second;
if (!visited[v]) {
if (w + w1 < dist[v] || (w + w1 == dist[v] && w1 < dist1[v])) {
if (dist[v] != INF) {
id = num[v];
cons[id] = false;
dijkstra.erase(make_pair(dist[v], v));
}
cons[index] = true;
num[v] = index;
dist[v] = w + w1;
dist1[v] = w1;
dijkstra.insert(make_pair(dist[v], v));
}
} else {
}
}
}
long long total = 0;
for (int i = 0; i <= e; i++)
if (cons[i]) {
total += edge[i];
answer.push_back(i);
}
cout << total << endl;
for (int i = 0; i < answer.size(); i++) {
cout << answer[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[300005];
vector<int> adj[300005], pos[300005];
vector<long long> adj_w[300005];
int main() {
int n, m, u;
long long results = 0;
vector<int> ans;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d %d %I64d", &u, &v, &w);
adj[u].push_back(v);
pos[u].push_back(i + 1);
adj[v].push_back(u);
pos[v].push_back(i + 1);
adj_w[u].push_back(w);
adj_w[v].push_back(w);
}
scanf("%d", &u);
for (int i = 1; i <= n; i++) dp[i] = -1;
queue<int> q;
q.push(u);
dp[u] = 0;
while (!q.empty()) {
int top = q.front();
q.pop();
for (int i = 0; i < adj[top].size(); i++) {
long long dist = dp[top] + adj_w[top][i];
if (dp[adj[top][i]] == -1 || dp[adj[top][i]] > dist) {
dp[adj[top][i]] = dist;
q.push(adj[top][i]);
}
}
}
for (int i = 1; i <= n; i++) {
if (i != u) {
int temp = -1;
for (int j = 0; j < adj[i].size(); j++) {
if (dp[i] == dp[adj[i][j]] + adj_w[i][j]) {
if (temp == -1 || adj_w[i][j] < adj_w[i][temp]) temp = j;
}
}
results += adj_w[i][temp];
ans.push_back(pos[i][temp]);
}
}
printf("%I64d\n", results);
for (int i = 0; i < ans.size(); i++) {
printf("%d", ans[i]);
if (i != ans.size() - 1)
printf(" ");
else
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<pair<int, int>, int> > > adj;
vector<int> ans, prev______;
vector<long long int> dist;
long long int dijkstra(int s) {
int n = ((int)((adj).size()));
dist.assign(n, 100000000000000000LL);
dist[s] = 0;
prev______.assign(n, -1);
prev______[s] = s;
priority_queue<pair<long long int, int>, vector<pair<long long int, int> >,
greater<pair<long long int, int> > >
pq;
pq.push(pair<long long int, int>(0, s));
while (!pq.empty()) {
auto front = pq.top();
pq.pop();
long long int d = front.first;
int u = front.second;
if (d == dist[u]) {
for (auto j = 0; j < (((int)((adj[u]).size()))); j++) {
auto a = adj[u][j];
int v = a.first.first, cst = a.first.second;
if (dist[u] + cst < dist[v]) {
dist[v] = dist[u] + cst;
prev______[v] = u;
pq.push(pair<long long int, int>(dist[v], v));
}
}
}
}
long long int res = 0;
for (auto u = 0; u < (n); u++) {
if (u != s) {
int k = -1;
for (auto j = 0; j < (((int)((adj[u]).size()))); j++) {
int v = adj[u][j].first.first, cst = adj[u][j].first.second;
if (dist[v] + cst == dist[u] &&
(k == -1 || cst < adj[u][k].first.second)) {
k = j;
}
}
res += adj[u][k].first.second;
ans.push_back(adj[u][k].second);
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, u;
cin >> n >> m;
adj.assign(n, vector<pair<pair<int, int>, int> >());
for (auto i = 0; i < (m); i++) {
int a, b, w;
cin >> a >> b >> w;
a--, b--;
adj[a].push_back(pair<pair<int, int>, int>(pair<int, int>(b, w), i + 1));
adj[b].push_back(pair<pair<int, int>, int>(pair<int, int>(a, w), i + 1));
}
cin >> u;
u--;
cout << dijkstra(u) << '\n';
for (auto& x : ans) cout << x << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9999999999999999;
long long n, m, u, v, w, nod, dis[300005], node, id, arr[300005], vis[300005],
sum, cost;
vector<pair<long long, long long> > adj[300005];
map<pair<long long, long long>, long long> mp;
vector<long long> ans;
priority_queue<pair<pair<long long, long long>, pair<long long, long long> > >
pq;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
cin >> u >> v >> w;
if (u > v) swap(u, v);
adj[u].push_back({v, w});
adj[v].push_back({u, w});
mp[{u, v}] = i;
arr[i] = w;
}
for (long long i = 1; i <= n; i++) dis[i] = inf;
cin >> nod;
dis[nod] = 0;
pq.push({{0, 0}, {0, nod}});
while (pq.size()) {
pair<pair<long long, long long>, pair<long long, long long> > p = pq.top();
pq.pop();
cost = -p.first.second;
id = p.second.first;
nod = p.second.second;
if (vis[nod]) continue;
vis[nod] = 1;
sum += cost;
ans.push_back(id);
for (auto x : adj[nod]) {
long long xx = x.first;
long long cc = x.second;
if (vis[xx]) continue;
if ((dis[nod] + cc) <= dis[xx]) {
dis[xx] = dis[nod] + cc;
pq.push({{-dis[xx], -arr[mp[{min(nod, xx), max(nod, xx)}]]},
{mp[{min(nod, xx), max(nod, xx)}], xx}});
}
}
}
cout << sum << endl;
for (long long i = 1; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v(300006);
set<tuple<long long, long long, long long, long long>> d;
long long n, m;
vector<vector<tuple<long long, long long, long long>>> adjl(300006);
vector<long long> res;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long a, b, c;
cin >> a >> b >> c;
adjl[a].push_back(tuple<long long, long long, long long>(b, c, i + 1));
adjl[b].push_back(tuple<long long, long long, long long>(a, c, i + 1));
}
long long u;
cin >> u;
d.insert(make_tuple(0, 0, u, 0));
long long sum = 0;
while (!d.empty()) {
auto a = d.begin();
long long node = get<2>(*a), dist = get<0>(*a), index = get<3>(*a),
eddsit = get<1>(*a);
d.erase(a);
if (v[node]) continue;
if (index) {
res.push_back(index);
sum += eddsit;
}
v[node] = 1;
for (auto i : adjl[node]) {
if (v[get<0>(i)] == 0)
d.emplace(dist + get<1>(i), get<1>(i), get<0>(i), get<2>(i));
}
}
cout << sum << "\n";
for (auto i : res) cout << i << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 100000000000000000;
const int MAXN = 300005;
const int MAXM = 300005;
struct edge {
int v, w, pre;
} e[MAXM << 1];
struct node {
int num;
long long dis;
bool operator<(const node &x) const { return dis > x.dis; }
};
priority_queue<node> Q;
int N, M, S, fst[MAXN];
long long dist[MAXN], f[MAXN], ans = 0;
int fr[MAXN], vis[MAXN];
int read() {
int o = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
o = (o << 3) + (o << 1) + (c & 15), c = getchar();
return o;
}
void adde(int a, int b, int c, int k) {
e[k] = (edge){b, c, fst[a]}, fst[a] = k;
return;
}
void toposort(int k) {
vis[k] = 1;
for (int o = fst[k]; o; o = e[o].pre) {
if (dist[k] + e[o].w == dist[e[o].v]) {
if (f[e[o].v] < dist[k] || !vis[e[o].v]) {
f[e[o].v] = dist[k], fr[e[o].v] = (o > M) ? o - M : o;
}
if (!vis[e[o].v]) toposort(e[o].v);
}
}
return;
}
int main() {
N = read(), M = read();
for (int i = 1; i <= M; i++) {
int a = read(), b = read(), c = read();
adde(a, b, c, i), adde(b, a, c, i + M);
}
S = read();
for (int i = 1; i <= N; i++) dist[i] = inf;
dist[S] = 0;
Q.push((node){S, 0});
while (!Q.empty()) {
node x = Q.top();
Q.pop();
if (x.dis <= dist[x.num]) {
for (int o = fst[x.num]; o; o = e[o].pre) {
if (dist[e[o].v] > x.dis + e[o].w) {
dist[e[o].v] = x.dis + e[o].w;
Q.push((node){e[o].v, dist[e[o].v]});
}
}
}
}
toposort(S);
for (int i = 1; i <= N; i++) ans += dist[i] - f[i];
printf("%lld\n", ans);
for (int i = 1; i <= N; i++)
if (i != S) printf("%d ", fr[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 300005;
long long n, E;
vector<tuple<long long, long long, long long> > adj[MX];
long long d[MX];
long long ls[MX];
long long vis[MX];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> E;
for (long long i = 0; i < E; ++i) {
long long x, y, w;
cin >> x >> y >> w;
adj[x].push_back(make_tuple(w, y, i + 1));
adj[y].push_back(make_tuple(w, x, i + 1));
}
for (long long i = 1; i <= n; ++i) sort(adj[i].begin(), adj[i].end());
long long s;
cin >> s;
memset(d, 0x3f, sizeof d);
memset(ls, 0x3f, sizeof ls);
d[s] = 0;
priority_queue<tuple<long long, long long, long long, long long>,
vector<tuple<long long, long long, long long, long long> >,
greater<tuple<long long, long long, long long, long long> > >
q;
q.push(make_tuple(0, 0, 0, s));
vector<long long> res;
long long ans = 0;
while (!q.empty()) {
long long x, w, l, r;
tie(w, l, r, x) = q.top();
q.pop();
if (vis[x] || d[x] != w) continue;
vis[x] = 1;
res.push_back(r);
ans += l;
for (long long i = 0; i < adj[x].size(); ++i) {
long long nx, nw, id;
tie(nw, nx, id) = adj[x][i];
if (d[nx] > w + nw) {
d[nx] = w + nw;
q.push(make_tuple(nw + w, nw, id, nx));
ls[nx] = nw;
} else if (d[nx] == w + nw && nw < ls[nx]) {
q.push(make_tuple(nw + w, nw, id, nx));
ls[nx] = nw;
}
}
}
cout << ans << "\n";
for (long long i = 1; i < res.size(); ++i) {
cout << res[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dadsadasda;
const int INF = 0x3f3f3f3f;
const long long LLINF = 1e18;
const int MAXN = 3e5 + 10;
struct EDGE {
int to, w, ind;
};
int N, M;
vector<EDGE> G[MAXN];
long long ans;
vector<int> ord;
long long D[MAXN];
pair<long long, long long> LST[MAXN];
priority_queue<pair<long long, long long>> pq;
void dijkstra(int s) {
for (int i = 0; i < N; i++)
D[i] = LLINF, LST[i].first = LST[i].second = LLINF;
pq.push({0, s});
D[s] = 0;
while (!pq.empty()) {
long long x = pq.top().second;
long long c = -pq.top().first;
pq.pop();
if (c != D[x]) continue;
for (auto aux : G[x]) {
long long y = aux.to;
long long w = aux.w;
long long i = aux.ind;
if (D[y] > D[x] + w) {
D[y] = D[x] + w;
pq.push({-D[y], y});
}
if (D[y] == D[x] + w) {
if (LST[y].first > w) {
LST[y].first = w;
LST[y].second = i;
}
}
}
}
}
int main() {
dadsadasda = scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int a, b, w;
dadsadasda = scanf("%d %d %d", &a, &b, &w);
--a, --b;
G[a].push_back({b, w, i});
G[b].push_back({a, w, i});
}
int s;
dadsadasda = scanf("%d", &s);
--s;
dijkstra(s);
for (int i = 0; i < N; i++) {
if (i != s) {
ord.push_back(LST[i].second + 1);
ans += LST[i].first;
}
}
printf("%lld\n", ans);
for (auto i : ord) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1000000000000000000;
struct Edge {
Edge() : u(INF), v(INF), id(INF), weight(INF) {}
Edge(int u1, int v1, long long int w1, int id1)
: u(u1), v(v1), weight(w1), id(id1) {}
int u;
int v;
int id;
long long int weight;
};
Edge def;
struct Item {
long long int distance;
Edge edge;
int u;
Item() : distance(INF), u(INF), edge(def) {}
Item(long long int d, int u1, Edge e) : distance(d), u(u1), edge(e) {}
bool operator<(const Item& item) const {
return pair<long long int, long long int>(distance, edge.weight) >
pair<long long int, long long int>(item.distance, item.edge.weight);
}
};
vector<Edge> graph[300010];
Item dist[300010];
priority_queue<Item> pq;
int N, M;
int main() {
cin >> N >> M;
long long int u, v, w;
for (int i = 0; i < M; i++) {
cin >> u >> v >> w;
graph[u].push_back(Edge(u, v, w, i + 1));
graph[v].push_back(Edge(v, u, w, i + 1));
}
cin >> u;
pq.push(Item(0, u, Edge()));
dist[u] = Item(0, u, Edge());
while (!pq.empty()) {
Item item = pq.top();
pq.pop();
if (item < dist[item.u]) continue;
for (auto edge : graph[item.u]) {
Item newitem = Item(item.distance + edge.weight, edge.v, edge);
if (dist[edge.v] < newitem) {
dist[edge.v] = newitem;
pq.push(newitem);
}
}
}
long long int sum = 0;
vector<int> soln;
for (int i = 1; i <= N; i++) {
if (dist[i].distance != INF and i != u) {
sum += dist[i].edge.weight;
soln.push_back(dist[i].edge.id);
}
}
cout << sum << endl;
for (int i = 0; i < soln.size(); i++) {
if (i != 0) cout << " ";
cout << soln[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const long long mod = 1e18 + 9;
long long n, m, s;
int minv[maxn];
bool vis[maxn];
struct edge {
int to, cost;
int id;
edge() {}
edge(int id, int to, int cost) {
this->id = id;
this->to = to;
this->cost = cost;
}
};
int f[maxn], t[maxn], cc[maxn];
vector<edge> g[maxn];
long long dis[maxn];
void spfa() {
vis[s] = 1;
queue<int> que;
que.push(s);
for (int i = 1; i <= n; i++) dis[i] = mod;
dis[s] = 0;
while (!que.empty()) {
int x = que.front();
que.pop();
vis[x] = 0;
int len = g[x].size();
for (int i = 0; i < len; i++) {
int to = g[x][i].to;
int cost = g[x][i].cost;
int id = g[x][i].id;
if (dis[to] > dis[x] + cost) {
dis[to] = dis[x] + cost;
minv[to] = id;
if (!vis[to]) {
que.push(to);
vis[to] = 0;
}
} else if (dis[to] == dis[x] + cost && cost < cc[minv[to]]) {
minv[to] = id;
}
}
}
return;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
cc[i] = c;
g[a].push_back(edge(i, b, c));
g[b].push_back(edge(i, a, c));
}
cin >> s;
spfa();
set<int> ss;
for (int i = 1; i <= n; i++) {
if (i == s) continue;
ss.insert(minv[i]);
}
long long sum = 0;
for (set<int>::iterator iter = ss.begin(); iter != ss.end(); iter++) {
sum += cc[*iter];
}
cout << sum << endl;
for (set<int>::iterator iter = ss.begin(); iter != ss.end(); iter++) {
if ((*iter) == 0) continue;
cout << (*iter) << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
typedef struct node {
int u, v, w;
} node;
node edge[maxn];
vector<long long> G[maxn], E[maxn];
long long dis[maxn], vis[maxn];
int n, m, parent[maxn];
bool flag[maxn];
void dij(int st) {
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0x3f, sizeof(vis));
priority_queue<pair<long long, long long> > pq;
dis[st] = 0;
vis[st] = 0;
pq.push(make_pair(0, st));
while (!pq.empty()) {
pair<long long, long long> e = pq.top();
pq.pop();
int u = e.second;
if (dis[u] + e.first != 0) continue;
for (int i = 0; i < G[u].size(); i++) {
if (dis[G[u][i]] > dis[u] + E[u][i] ||
(dis[G[u][i]] == dis[u] + E[u][i] && E[u][i] < vis[G[u][i]])) {
dis[G[u][i]] = dis[u] + E[u][i];
vis[G[u][i]] = E[u][i];
parent[G[u][i]] = u;
pq.push(make_pair(-dis[G[u][i]], G[u][i]));
}
}
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) G[i].clear(), E[i].clear();
for (int i = 1; i <= m; i++) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
G[a].push_back(b);
G[b].push_back(a);
E[a].push_back(w);
E[b].push_back(w);
edge[i].u = a, edge[i].v = b, edge[i].w = w;
}
int st;
scanf("%d", &st);
dij(st);
long long ans = 0;
memset(flag, false, sizeof(flag));
for (int i = 1; i <= m; i++) {
int u = edge[i].u, v = edge[i].v, w = edge[i].w;
if ((u == parent[v] && dis[u] + w == dis[v]) ||
(v == parent[u] && dis[v] + w == dis[u])) {
flag[i] = true;
ans += w;
}
}
printf("%I64d\n", ans);
for (int i = 1; i <= m; i++) {
if (flag[i]) printf("%d ", i);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 50;
const int MAXN = 3 * 100000 + 5;
int n, m;
int id[MAXN];
vector<long long> dist;
vector<pair<long long, int>> adj[MAXN];
void dijkstra(int source) {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
dist.assign(n, INF);
dist[source] = 0;
q.push(make_pair(0, source));
while (!q.empty()) {
long long d = q.top().first;
int v = q.top().second;
q.pop();
if (d <= dist[v]) {
for (auto p : adj[v]) {
int u = p.first;
int w = p.second;
if (dist[v] + w < dist[u]) {
dist[u] = dist[v] + w;
q.push(make_pair(dist[u], u));
}
}
}
}
}
struct Edge {
int v, u, w;
} edges[MAXN];
void add_edge(Edge e) {
adj[e.v].push_back(make_pair(e.u, e.w));
adj[e.u].push_back(make_pair(e.v, e.w));
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> edges[i].v >> edges[i].u >> edges[i].w;
--edges[i].v;
--edges[i].u;
add_edge(edges[i]);
}
int source;
cin >> source;
dijkstra(source - 1);
fill(id, id + MAXN, -1);
for (int i = 0; i < m; i++) {
int v = edges[i].v;
int u = edges[i].u;
int w = edges[i].w;
if (abs(dist[v] - dist[u]) == w) {
if (dist[v] < dist[u]) {
swap(v, u);
}
if (id[v] == -1 || w < edges[id[v]].w) {
id[v] = i;
}
}
}
long long ans = 0;
vector<int> roads;
for (int i = 0; i < n; i++) {
if (id[i] != -1) {
roads.push_back(id[i] + 1);
ans += edges[id[i]].w;
}
}
cout << ans << endl;
for (int r : roads) {
cout << r << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int ms = 312345;
const long long inf = 1e18;
long long parent[ms];
long long dist[ms];
map<pair<long long, long long>, long long> edges;
vector<pair<long long, long long>> adj[ms];
long long edgesUsed[ms];
set<long long> chosenEdges;
long long tt;
void dijkstra(long long v, long long total) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
heap;
for (int i = 1; i <= total; ++i) {
dist[i] = inf;
parent[i] = -1;
}
for (int i = 1; i <= total; ++i) {
edgesUsed[i] = inf;
}
heap.push({0, v});
dist[v] = 0;
edgesUsed[v] = 0;
while (!heap.empty()) {
pair<long long, long long> x = heap.top();
heap.pop();
long long vertex = x.second;
for (auto k : adj[vertex]) {
long long to = k.second;
long long w = k.first;
if (dist[to] > dist[vertex] + w) {
dist[to] = dist[vertex] + w;
edgesUsed[to] = w;
parent[to] = vertex;
heap.push({dist[to], to});
} else if (dist[to] == dist[vertex] + w) {
if (edgesUsed[to] > w) {
edgesUsed[to] = w;
parent[to] = vertex;
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed;
cout << setprecision(15);
long long n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
long long a, b;
long long w;
cin >> a >> b >> w;
edges[{min(a, b), max(a, b)}] = i + 1;
adj[a].push_back({w, b});
adj[b].push_back({w, a});
}
long long start;
cin >> start;
dijkstra(start, n);
tt = 0;
for (int i = 1; i <= n; ++i) {
tt += edgesUsed[i];
}
cout << tt << endl;
for (auto k : edges) {
pair<long long, long long> x = k.first;
if (parent[x.first] == x.second || parent[x.second] == x.first)
chosenEdges.insert(k.second);
}
for (auto x : chosenEdges) {
cout << x << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int w = INT_MAX, i, to;
unsigned long long accum;
bool operator<(edge const& e) const {
if (accum != e.accum) return accum > e.accum;
return w > e.w;
};
edge(int w, int i, int to) : w(w), i(i), to(to){};
};
vector<vector<edge>> graph;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
graph.resize(n + 1);
for (int i = 0; i < m; i++) {
int f, t, w;
cin >> f >> t >> w;
graph[f].push_back(edge(w, i + 1, t));
graph[t].push_back(edge(w, i + 1, f));
}
int k;
cin >> k;
vector<bool> vis(n + 1, 0);
vector<int> path;
priority_queue<edge> q;
for (edge e : graph[k]) {
e.accum = e.w;
q.push(e);
}
vis[k] = 1;
unsigned long long cost = 0;
while (!q.empty()) {
edge e = q.top();
q.pop();
if (vis[e.to]) continue;
vis[e.to] = 1;
path.push_back(e.i);
cost += e.w;
for (edge ne : graph[e.to]) {
if (vis[ne.to]) continue;
ne.accum = e.accum + ne.w;
q.push(ne);
}
}
cout << cost << '\n';
for (int a : path) cout << a << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
long long M = 1e16;
int u[N];
int v[N];
int w[N];
vector<int> g[N];
long long h[N];
int ind[N];
int mg[N];
set<pair<int, int> > s;
void dj() {
while (s.size()) {
int x = (*s.begin()).second;
s.erase(make_pair(h[x], x));
for (int e : g[x]) {
int y = u[e] ^ v[e] ^ x;
if (h[y] > h[x] + w[e]) {
mg[y] = w[e];
ind[y] = e;
s.erase(make_pair(h[y], y));
h[y] = h[x] + w[e];
s.insert(make_pair(h[y], y));
} else if (h[y] == h[x] + w[e]) {
if (w[e] < mg[y]) {
mg[y] = w[e];
ind[y] = e;
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int pp, nn, oo;
cin >> pp >> nn >> oo;
pp--;
nn--;
u[i] = pp;
v[i] = nn;
g[pp].push_back(i);
g[nn].push_back(i);
w[i] = oo;
}
int l;
cin >> l;
l--;
s.insert(make_pair(0, l));
for (int i = 0; i < n; i++) {
h[i] = M;
if (i != l) {
s.insert(make_pair(M, i));
}
}
h[l] = 0;
dj();
for (int i = 0; i < n; i++) {
}
long long kk = 0;
for (int i = 0; i < n; i++) {
if (i != l) {
kk += w[ind[i]];
}
}
cout << kk << "\n";
for (int i = 0; i < n; i++) {
if (i != l) {
cout << ind[i] + 1 << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const long long INF = 1e16;
struct E {
int v, next, w, id;
} edge[maxn * 2];
int N, M;
int st;
long long dis[maxn];
bool vis[maxn];
int W[maxn];
int head[maxn], tot;
int pre[maxn], cnt[maxn];
void init() {
tot = 0;
memset(head, -1, sizeof(head));
memset(pre, 0, sizeof(pre));
memset(cnt, 0, sizeof(cnt));
}
void add_edge(int u, int v, int w, int id) {
edge[tot].v = v;
edge[tot].next = head[u];
edge[tot].w = w;
edge[tot].id = id;
head[u] = tot++;
}
void SPFA() {
for (int i = 0; i <= N; i++) dis[i] = INF, vis[i] = 0;
queue<int> q;
q.push(st);
dis[st] = 0;
vis[st] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
int w = edge[i].w;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
pre[v] = edge[i].id;
if (!vis[v]) {
q.push(v);
vis[v] = 1;
}
} else if (dis[v] == dis[u] + w) {
if (w < W[pre[v]]) {
pre[v] = edge[i].id;
if (!vis[v]) {
q.push(v);
vis[v] = 1;
}
}
}
}
}
}
int main() {
scanf("%d%d", &N, &M);
init();
for (int i = 1; i <= M; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add_edge(u, v, w, i);
add_edge(v, u, w, i);
W[i] = w;
}
scanf("%d", &st);
SPFA();
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= N; i++) vis[pre[i]] = 1;
long long sum = 0;
for (int i = 1; i <= N; i++)
if (pre[i] > 0) sum += W[pre[i]];
cout << sum << endl;
for (int i = 1; i <= N; i++)
if (pre[i]) printf("%d ", pre[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, int> d[300500];
const int inf = (int)1e9;
long long s = 0;
vector<int> ans;
int n, m, u;
vector<pair<pair<int, int>, int> > g[300500];
priority_queue<pair<pair<long long, int>, pair<int, int> > > q;
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back(make_pair(make_pair(b, c), i + 1));
g[b].push_back(make_pair(make_pair(a, c), i + 1));
}
cin >> u;
for (int i = 1; i <= n; ++i) {
d[i] = make_pair(inf * -1ll * inf, -inf);
}
d[u] = make_pair(0, 0);
q.push(make_pair(make_pair(0, 0), make_pair(u, 0)));
while (!q.empty()) {
pair<pair<long long, int>, pair<int, int> > cur = q.top();
q.pop();
int v = cur.second.first;
pair<long long, int> cost = cur.first;
if (d[v] != cost) continue;
cost.first *= -1ll;
cost.second *= -1ll;
if (v != u) ans.push_back(cur.second.second);
s += cost.second;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i].first.first;
pair<long long, int> ncost = make_pair(
-d[v].first + g[v][i].first.second * 1ll, g[v][i].first.second);
pair<long long, int> oldcost =
make_pair(-1ll * d[to].first, -1ll * d[to].second);
if (ncost < oldcost) {
d[to] = make_pair(-1ll * ncost.first, -ncost.second);
q.push(make_pair(d[to], make_pair(to, g[v][i].second)));
}
}
}
cout << s << '\n';
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
class Scanner {
private:
static const int BUFFER_SIZE = 1 << 18;
char buff[BUFFER_SIZE];
char *buffPos, *buffLim;
FILE* file;
public:
Scanner(FILE* file) {
this->file = file;
buffLim = buff + fread(buff, 1, BUFFER_SIZE, file);
buffPos = buff;
}
private:
inline void flushBuff() {
buffLim = buff + fread(buff, 1, BUFFER_SIZE, file);
if (buffLim == buff) {
*buffLim++ = '\n';
}
buffPos = buff;
}
inline bool isWS(char t) { return t <= ' '; }
inline bool isDig(char t) { return t >= '0' && t <= '9'; }
inline void nextPos() {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
public:
inline char getchar() {
char ch = *buffPos;
nextPos();
return ch;
}
inline void next(char* s) {
while (isWS(*buffPos)) {
nextPos();
}
while (!isWS(*buffPos)) {
*s = *buffPos;
s++;
nextPos();
}
*s = '\0';
}
inline void nextLine(char* s) {
while (*buffPos != '\n') {
nextPos();
}
if (*buffPos == '\n') {
nextPos();
}
while (*buffPos != '\n') {
*s++ = *buffPos;
nextPos();
}
*s = '\0';
}
inline int nextInt() {
while (!isDig(*buffPos) && *buffPos != '-') {
nextPos();
}
int sign = (*buffPos == '-') ? nextPos(), -1 : 1;
int res = 0;
while (isDig(*buffPos)) {
res = res * 10 + *buffPos - '0';
nextPos();
}
return res * sign;
}
inline long long nextLong() {
while (!isDig(*buffPos) && *buffPos != '-') {
nextPos();
}
long long sign = (*buffPos == '-') ? nextPos(), -1 : 1;
long long res = 0;
while (isDig(*buffPos)) {
res = res * 10 + *buffPos - '0';
nextPos();
}
return res * sign;
}
inline int n() {
while (*buffPos < '0' || *buffPos > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
int res = 0;
while (*buffPos >= '0' && *buffPos <= '9') {
res = res * 10 + (*buffPos - '0');
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline long long nl() {
while (*buffPos < '0' || *buffPos > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
long long res = 0;
while (*buffPos >= '0' && *buffPos <= '9') {
res = res * 10 + (*buffPos - '0');
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline long long nlm(const int MOD) {
while (*buffPos < '0' || *buffPos > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
long long res = 0;
while (*buffPos >= '0' && *buffPos <= '9') {
res = (res * 10 + (*buffPos - '0')) % MOD;
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline double nextDouble() {
while (isWS(*buffPos)) {
nextPos();
}
int sign = (*buffPos == '-') ? nextPos(), -1 : 1;
double res = 0;
while (isDig(*buffPos)) {
res = res * 10 + *buffPos - '0';
nextPos();
}
if (*buffPos == '.') {
nextPos();
double ep = 1;
while (isDig(*buffPos)) {
ep *= 0.1;
res += ep * (*buffPos - '0');
nextPos();
}
}
return sign * res;
}
inline char nextChar() {
while (isWS(*buffPos)) nextPos();
char res = *buffPos;
nextPos();
return res;
}
~Scanner() { fclose(file); }
};
template <class __TyFirst, class __TySecond>
std::ostream& operator<<(std::ostream& out,
const std::pair<__TyFirst, __TySecond>& o) {
out << "(" << o.first << "," << o.second << ")";
return out;
}
template <typename _ForwardIterator>
void logArray(_ForwardIterator __begin, _ForwardIterator __end,
const char* __sep = 0) {}
template <class T>
inline bool checkMin(T& a, T b) {
return (a > b ? a = b, 1 : 0);
}
template <class T>
inline bool checkMax(T& a, T b) {
return (a < b ? a = b, 1 : 0);
}
void preInit();
void init();
void solve();
int32_t main() {
preInit();
init();
solve();
return 0;
}
constexpr long long N = 300005;
std::vector<std::tuple<long long, long long, long long>> e[N];
long long dis[N], w[N], pre[N], n, m, u;
void preInit() {}
void init() {
Scanner sc(stdin);
n = sc.n();
m = sc.n();
for (long long i = 1; i <= m; i++) {
long long u = sc.n(), v = sc.n(), w = sc.n();
e[u].push_back({v, w, i});
e[v].push_back({u, w, i});
::w[i] = w;
}
u = sc.n();
}
void solve() {
std::fill(dis + 1, dis + n + 1, std::numeric_limits<long long>::max());
dis[u] = 0;
std::priority_queue<std::pair<long long, long long>,
std::vector<std::pair<long long, long long>>,
std::greater<std::pair<long long, long long>>>
que;
que.push({0, u});
while (!que.empty()) {
const auto [uw, u] = que.top();
que.pop();
;
if (dis[u] != uw) {
continue;
}
for (const auto& [v, vw, vi] : e[u]) {
if (checkMin(dis[v], uw + vw)) {
;
que.push({dis[v], v});
pre[v] = vi;
} else if (dis[v] == uw + vw) {
pre[v] = vi;
}
}
}
long long ans = 0;
std::vector<long long> aids;
for (long long i = 1; i <= n; i++)
if (i != u) {
;
aids.push_back(pre[i]);
ans += w[pre[i]];
}
printf("%lld\n", ans);
std::sort(aids.begin(), aids.end());
std::ostream_iterator<long long> out(std::cout, " ");
std::copy(aids.begin(), aids.end(), out);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int from, to, len, nom;
Edge() {}
Edge(int from, int to, int len, int nom)
: from(from), to(to), len(len), nom(nom) {}
bool operator<(const Edge& u) const { return len < u.len; }
};
const int N = 1e6;
const long long INF = 1e18;
int n, m, st, pr[N];
vector<Edge> g[N];
vector<Edge> e;
long long dst[N];
bool used[N];
vector<int> v;
void dfs(int x) {
if (used[x]) return;
used[x] = true;
for (int i = 0; i < g[x].size(); i++) {
if (dst[x] + g[x][i].len == dst[g[x][i].to]) {
dfs(g[x][i].to);
}
}
v.push_back(x);
}
bool cmp(int x, int y) { return e[x] < e[y]; }
int fs(int x) {
if (pr[x] != x) pr[x] = fs(pr[x]);
return pr[x];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
--x;
--y;
e.push_back(Edge(x, y, z, i));
g[x].push_back(Edge(x, y, z, i));
g[y].push_back(Edge(y, x, z, i));
}
scanf("%d", &st);
--st;
for (int i = 0; i < n; i++) dst[i] = 1e18;
dst[st] = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, st));
while (!q.empty()) {
int x = q.top().second;
long long z = -q.top().first;
q.pop();
if (z != dst[x]) continue;
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i].to;
long long cur = z + g[x][i].len;
if (cur < dst[y]) {
dst[y] = cur;
q.push(make_pair(-cur, y));
}
}
}
dfs(st);
reverse(v.begin(), v.end());
long long sum = 0;
vector<int> ans;
memset(used, 0, sizeof(used));
used[st] = 1;
for (int it = 1; it < n; it++) {
int x = v[it];
used[x] = 1;
int cur = 1e9 + 1;
int nom = -1;
for (int j = 0; j < g[x].size(); j++) {
int y = g[x][j].to;
if ((dst[y] + g[x][j].len == dst[x]) && (used[y])) {
if (g[x][j].len < cur) {
cur = g[x][j].len;
nom = g[x][j].nom;
}
}
}
sum += cur;
ans.push_back(nom + 1);
}
cout << sum << endl;
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<list<pair<int, pair<int, int> > > > a(300001);
long long int dist[300001];
bool evaluated[300001];
int edged[300001];
bool pushed[300001];
long long int ans = 0;
long long int weight[300001];
struct COMPARE {
bool operator()(pair<int, long long int> a, pair<int, long long int> b) {
return a.second > b.second;
}
};
priority_queue<pair<int, long long int>, vector<pair<int, long long int> >,
COMPARE>
pq;
void initialisebool(int n, bool a[]) {
for (int i = 1; i <= n; i++) a[i] = false;
}
void initialiseint(int n, long long int a[], long long int b) {
for (int i = 1; i <= n; i++) a[i] = b;
}
void dijkstra(int i, int n) {
dist[i] = 0;
pq.push(make_pair(i, 0));
while (!pq.empty()) {
pair<int, long long int> aa = pq.top();
pq.pop();
int xx = aa.first;
long long int yy = aa.second;
if (evaluated[xx]) continue;
evaluated[xx] = true;
for (auto itr : a[xx]) {
int x = (itr).second.first;
long long int y = (itr).second.second;
int z = (itr).first;
if (!evaluated[x] && dist[x] > yy + y) {
dist[x] = yy + y;
pq.push(make_pair(x, dist[x]));
edged[x] = z;
ans += y - weight[x];
weight[x] = y;
} else if (dist[x] == yy + y) {
if (weight[x] > y) {
ans += y - weight[x];
edged[x] = z;
weight[x] = y;
}
}
}
}
}
int comb(int a) { return (a * (a - 1)) / 2; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int ai, bi, ci;
cin >> ai >> bi >> ci;
a[ai].push_back(make_pair(i, make_pair(bi, ci)));
a[bi].push_back(make_pair(i, make_pair(ai, ci)));
}
initialiseint(n, dist, 1e18);
initialiseint(n, weight, 0);
initialisebool(n, evaluated);
for (int i = 1; i <= n; i++) {
edged[i] = -1;
}
int u;
cin >> u;
dijkstra(u, n);
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (i != u) cout << edged[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 987654321098765;
vector<pair<long long int, pair<long long int, long long int> > > adj[300003];
long long int dist[300003];
bool visited[300003];
void dijkstra(int s) {
memset(dist, INF, sizeof(dist));
memset(visited, false, sizeof(visited));
dist[s] = 0;
priority_queue<pair<long long int, long long int>,
std::vector<pair<long long int, long long int> >,
std::greater<pair<long long int, long long int> > >
pq;
pq.push(make_pair(0, s));
while (!pq.empty()) {
pair<long long int, long long int> node = pq.top();
pq.pop();
long long int d = node.first;
long long int u = node.second;
if (visited[u]) continue;
visited[u] = true;
for (int i = 0; i < adj[u].size(); i++) {
long long int v = adj[u][i].first;
long long int wt = adj[u][i].second.first;
if (!visited[v] && wt + dist[u] < dist[v]) {
dist[v] = wt + dist[u];
pq.push(make_pair(dist[v], v));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m, x, y, z, s;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> z;
adj[x].push_back(make_pair(y, make_pair(z, i)));
adj[y].push_back(make_pair(x, make_pair(z, i)));
}
cin >> s;
dijkstra(s);
long long int ans = 0;
vector<long long int> edges;
for (int u = 1; u <= n; u++) {
if (u == s) continue;
long long int minm = INT_MAX;
long long int idx;
for (int i = 0; i < adj[u].size(); i++) {
long long int v = adj[u][i].first;
long long int wt = adj[u][i].second.first;
if (dist[v] + wt == dist[u]) {
if (wt < minm) {
minm = wt;
idx = adj[u][i].second.second;
}
}
}
ans += minm;
edges.push_back(idx);
}
cout << ans << "\n";
for (int i = 0; i < edges.size(); i++) {
cout << edges[i] << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 1e18 + 7;
const long long int MAXNN = 300005;
long long int int_pow(long long int base, long long int exp) {
long long int result = 1;
while (exp) {
if (exp & 1) result *= base;
exp /= 2;
base *= base;
}
return result;
}
vector<long long int> g[MAXNN];
vector<long long int> w[MAXNN];
set<pair<long long int, long long int> > st;
long long int dist[MAXNN];
long long int par[MAXNN];
bool mark[MAXNN];
map<pair<long long int, long long int>, long long int> mpw;
map<pair<long long int, long long int>, long long int> mpn;
void diekstra(long long int n, long long int s) {
fill_n(dist, MAXNN, MAXN);
dist[s] = 0;
for (long long int i = 1; i <= n; i++) st.insert({dist[i], i});
while (!st.empty()) {
set<pair<long long int, long long int> >::iterator it = st.begin();
long long int x = it->second;
mark[x] = 1;
st.erase(it);
for (long long int i = 0; i < (long long int)g[x].size(); i++) {
long long int y = g[x][i];
if (!mark[y]) {
st.erase({dist[y], y});
if (dist[y] >= dist[x] + w[x][i]) {
par[y] = x;
}
dist[y] = min(dist[y], dist[x] + w[x][i]);
st.insert({dist[y], y});
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(par, -1, sizeof par);
long long int n, m, u, v, z, stpoint = 0, ans = 0;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
cin >> u >> v >> z;
if (u > v) swap(u, v);
mpn[{u, v}] = i + 1;
mpw[{u, v}] = z;
g[u].push_back(v);
g[v].push_back(u);
w[u].push_back(z);
w[v].push_back(z);
}
cin >> stpoint;
diekstra(n, stpoint);
for (long long int i = 1; i <= n; i++) {
if (i == stpoint) continue;
u = i, v = par[i];
if (u > v) swap(u, v);
ans += mpw[{u, v}];
}
cout << ans << '\n';
for (long long int i = 1; i <= n; i++) {
if (i == stpoint) continue;
u = i, v = par[i];
if (u > v) swap(u, v);
cout << mpn[{u, v}] << '\n';
}
}
|
#include <bits/stdc++.h>
namespace chtholly {
char buf[1 << 23], *p1 = buf, *p2 = buf;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) putchar('-'), x = -x;
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int yuzu = 3e5, inf = 0x3f3f3f3f;
typedef int fuko[yuzu | 10];
typedef long long rize[yuzu | 10];
struct edge {
int to, cost, id;
} e[yuzu | 10];
vector<edge> lj[yuzu | 10];
vector<int> ans;
namespace {
rize dis;
fuko eid, vis;
void spfa(int s) {
memset(dis, 0x3f, sizeof dis);
queue<int> q;
dis[s] = 0, q.push(s);
for (; !q.empty();) {
int u = q.front();
q.pop();
vis[u] = 0;
for (edge i : lj[u]) {
int v = i.to;
long long c = i.cost;
if (dis[u] + c == dis[v] && e[eid[v]].cost > c) {
eid[v] = i.id;
if (!vis[v]) q.push(v), vis[v] = 1;
}
if (dis[v] > dis[u] + c) {
dis[v] = dis[u] + c;
eid[v] = i.id;
if (!vis[v]) q.push(v), vis[v] = 1;
}
}
}
}
} // namespace
int main() {
int i, n, m, u, v, c;
read(n), read(m);
for (i = 1; i <= m; ++i) {
read(u), read(v), read(c);
lj[u].push_back(edge{v, c, i});
lj[v].push_back(edge{u, c, i});
e[i] = edge{v, c, i};
}
e->cost = inf;
spfa(read());
long long llx = 0;
for (i = 1; i <= n; ++i)
if (eid[i]) ans.push_back(eid[i]), llx += e[eid[i]].cost;
cout << llx << endl;
for (auto p : ans) write(p), putchar(' ');
}
|
#include <bits/stdc++.h>
using namespace std;
long long const M = 1000000007;
double const pi = acos(-1);
long long const inf = 9e18;
long long const N = 300005;
vector<long long> u(N), v(N), w(N), dis(N, 0), par(N, 0);
vector<long long> g[N];
long long adj(long long x, long long vertex) { return vertex ^ u[x] ^ v[x]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, t, n, m, p, sum = 0;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> u[i] >> v[i] >> w[i];
g[u[i]].push_back(i);
g[v[i]].push_back(i);
}
for (i = 1; i <= n; i++) dis[i] = inf;
cin >> p;
dis[p] = 0;
set<pair<long long, long long> > s;
s.insert({0, p});
while (!s.empty()) {
auto node = *s.begin();
s.erase(node);
long long dist = (node).first;
long long vertex = (node).second;
for (auto x : g[vertex]) {
auto neigh = adj(x, vertex);
if (dis[neigh] > dist + w[x]) {
auto it = s.find({dis[neigh], neigh});
if (it != s.end()) s.erase(it);
par[neigh] = x;
dis[neigh] = dist + w[x];
s.insert({dist + w[x], neigh});
} else if (dis[neigh] == dist + w[x]) {
if (w[x] < w[par[neigh]]) par[neigh] = x;
}
}
}
for (i = 1; i <= n; i++)
if (i != p) sum += w[par[i]];
cout << sum << "\n";
for (i = 1; i <= n; i++)
if (i != p) cout << par[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
Edge() {}
Edge(int u, int v, int w) : u(u), v(v), w(w) {}
int u, v, w;
};
vector<vector<Edge> > ve;
map<pair<int, int>, int> edges;
int main() {
int n, m;
scanf("%d %d", &n, &m);
ve.resize(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
--u;
--v;
ve[u].push_back(Edge(u, v, w));
ve[v].push_back(Edge(v, u, w));
edges[make_pair(u, v)] = i + 1;
edges[make_pair(v, u)] = i + 1;
}
int io;
scanf("%d", &io);
--io;
vector<long long> d(n, 999999999999999LL);
vector<int> h(n, -1);
vector<int> w(n, 999999999);
d[io] = 0;
w[io] = 0;
priority_queue<pair<int, int> > q;
q.push(make_pair(0, io));
while (!q.empty()) {
int u = q.top().second;
q.pop();
for (int i = 0; i < ve[u].size(); ++i) {
int v = ve[u][i].v;
if ((d[u] + ve[u][i].w < d[v]) ||
(d[u] + ve[u][i].w == d[v] && ve[u][i].w < w[v])) {
d[v] = d[u] + ve[u][i].w;
h[v] = u;
w[v] = ve[u][i].w;
q.push(make_pair(-d[v], v));
}
}
}
long long sum = 0;
for (int i = 0; i < n; ++i) sum += w[i];
cout << sum << "\n";
for (int i = 0; i < n; ++i)
if (i != io) printf("%d ", edges[make_pair(i, h[i])]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 3e5 + 10, M = 1e6 + 10, inf = 2147483647;
const long long INF = 1e18 + 10, mod = 2147493647;
struct is {
int v, next, w, pos;
} edge[N << 1];
int head[N], edg;
void init() {
memset(head, -1, sizeof(head));
edg = 0;
}
void add(int u, int v, int w, int pos) {
edg++;
edge[edg].v = v;
edge[edg].w = w;
edge[edg].pos = pos;
edge[edg].next = head[u];
head[u] = edg;
}
struct mmp {
int s, pos, w;
long long dis;
mmp() {}
mmp(int ss, long long d, int p, int ww) {
s = ss, dis = d;
pos = p;
w = ww;
}
bool operator<(const mmp &b) const {
if (dis != b.dis) return dis > b.dis;
return w > b.w;
}
};
long long ans[N], sum;
int vis[N];
priority_queue<mmp> q;
vector<int> out;
void dij(int s) {
ans[s] = 0;
q.push(mmp(s, 0LL, 0, 0));
while (!q.empty()) {
mmp now = q.top();
q.pop();
if (vis[now.s]) continue;
sum += now.w;
out.push_back(now.pos);
vis[now.s] = 1;
for (int i = head[now.s]; i != -1; i = edge[i].next) {
int v = edge[i].v;
long long w = edge[i].w;
int p = edge[i].pos;
if (ans[v] >= ans[now.s] + w) {
q.push(mmp(v, ans[now.s] + w, p, w));
ans[v] = ans[now.s] + w;
}
}
}
}
int main() {
init();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
}
int s;
scanf("%d", &s);
for (int i = 1; i <= n; i++) ans[i] = INF;
dij(s);
printf("%lld\n", sum);
sort(out.begin(), out.end());
for (int i = 1; i < out.size(); i++) printf("%d ", out[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct node {
long long from;
long long to;
long long next;
long long val;
} edge[350010 << 1];
long long n, m, cnt, src, ans;
long long head[350010], visit[350010], dis[350010], pre[350010];
void init() {
memset(head, -1, sizeof(head));
cnt = 0;
}
void addedge(long long from, long long to, long long val) {
edge[++cnt].from = from;
edge[cnt].to = to;
edge[cnt].val = val;
edge[cnt].next = head[from];
head[from] = cnt;
}
void SPFA() {
memset(dis, 0x3f3f3f3f, sizeof(dis));
memset(visit, 0, sizeof(visit));
visit[src] = 1;
dis[src] = 0;
queue<int> Q;
Q.push(src);
while (!Q.empty()) {
long long u = Q.front();
Q.pop();
visit[u] = 0;
for (long long i = head[u]; i != -1; i = edge[i].next) {
long long v = edge[i].to;
if (dis[v] > dis[u] + edge[i].val) {
dis[v] = dis[u] + edge[i].val;
pre[v] = i;
if (!visit[v]) {
visit[v] = 1;
Q.push(v);
}
} else if (dis[v] == dis[u] + edge[i].val &&
edge[i].val < edge[pre[v]].val) {
pre[v] = i;
}
}
}
}
int main() {
init();
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= m; i++) {
long long a, b, c;
scanf("%lld%lld%lld", &a, &b, &c);
addedge(a, b, c);
addedge(b, a, c);
}
scanf("%lld", &src);
SPFA();
for (long long i = 1; i <= n; i++) {
if (pre[i]) ans += (edge[pre[i]].val);
}
printf("%lld\n", ans);
for (long long i = 1; i <= n; i++) {
if (pre[i]) printf("%lld ", (pre[i] + 1) / 2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 2e6 + 5, MOD = 1e9 + 7;
vector<pair<int, int> > h[N];
struct Edge {
int u, v, w, id;
} e[N];
long long dis[N];
int dis2[N], vis[N], n;
struct node {
int x;
long long d;
node() {}
node(int a, long long b) : x(a), d(b) {}
friend int operator<(const node &, const node &);
};
int operator<(const node &a, const node &b) {
if (a.d == b.d) return e[dis2[a.x]].w > e[dis2[b.x]].w;
return a.d > b.d;
}
priority_queue<node> que;
long long ans = 0;
void dijk(int u) {
for (int i = 1; i <= n; i++) vis[i] = 0, dis[i] = 1e18;
dis[u] = 0;
que.push(node(u, 0));
node x;
pair<int, int> t;
while (!que.empty()) {
x = que.top(), que.pop();
if (vis[x.x]) continue;
vis[x.x] = 1;
ans += e[dis2[x.x]].w;
for (int i = 0; i < h[x.x].size(); i++) {
t = h[x.x][i];
if (x.d + e[t.second].w < dis[t.first]) {
dis[t.first] = x.d + e[t.second].w;
dis2[t.first] = t.second;
que.push(node(t.first, dis[t.first]));
} else if (x.d + e[t.second].w == dis[t.first]) {
if (e[t.second].w < e[dis2[t.first]].w) dis2[t.first] = t.second;
que.push(node(t.first, dis[t.first]));
}
}
}
}
void add_edge(int u, int v, int w) {
h[u].push_back(make_pair(v, w));
h[v].push_back(make_pair(u, w));
}
void init() {
for (int i = 1; i <= n; i++) h[i].clear();
}
int Solve(int cas = 0) {
int m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
e[i].u = u, e[i].v = v, e[i].w = w;
e[i].id = i;
add_edge(u, v, i);
}
int u;
cin >> u;
dijk(u);
cout << ans << endl;
vector<int> lst;
for (int i = 1; i <= n; i++)
if (i != u) {
lst.push_back(dis2[i]);
}
sort((lst).begin(), (lst).end());
for (auto v : lst) cout << v << " ";
return 0;
}
void Pre() {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
Pre();
while (Solve())
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 3 * 100000 + 5;
const long long INF = 1LL << 50;
vector<pair<int, pair<int, int> > > g[MX];
long long E[MX];
long long D[MX];
long long e[MX];
void solve(int u) {
set<pair<int, int> > q;
D[u] = 0;
q.insert(pair<int, int>(0, u));
while (!q.empty()) {
pair<int, int> top = *q.begin();
q.erase(q.begin());
int v = top.second, d = top.first;
if (d <= D[v]) {
for (typeof((g[v]).begin()) it = (g[v]).begin(); it != (g[v]).end();
it++) {
int v2 = it->first, cost = it->second.first;
if (D[v2] >= D[v] + cost) {
if (D[v2] != INF) {
}
D[v2] = D[v] + cost;
q.insert(pair<int, int>(D[v2], v2));
E[v2] = it->second.second;
}
}
}
}
}
int main(int argc, char *argv[]) {
ios ::sync_with_stdio(false);
cin.tie(NULL);
int n, m, u, v, w;
cin >> n >> m;
for (int i = (0), _b = (m); i < (_b); ++i) {
cin >> u >> v >> w;
g[u].push_back(pair<int, pair<int, int> >(v, pair<int, int>(w, i + 1)));
g[v].push_back(pair<int, pair<int, int> >(u, pair<int, int>(w, i + 1)));
e[i + 1] = w;
}
cin >> u;
for (int i = (0), _b = (MX); i < (_b); ++i) D[i] = INF;
solve(u);
long long ans = 0;
vector<int> vv;
for (int i = (1), _b = (MX); i < (_b); ++i) {
if (E[i]) {
vv.push_back(E[i]);
ans += e[E[i]];
}
}
sort((vv).begin(), (vv).end());
cout << ans << '\n';
for (int i = (0), _b = (vv.size()); i < (_b); ++i) cout << vv[i] << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, long long> mb;
map<int, long long> ms;
map<int, long long>::iterator it;
map<int, long long>::reverse_iterator it2;
vector<pair<int, long long> > v;
int main() {
int n, s, i, p, q;
char ch;
cin >> n >> s;
for (i = 1; i <= n; i++) {
cin >> ch;
scanf("%d %d", &p, &q);
if (ch == 'B') {
mb[p] += q;
} else {
ms[p] += q;
}
}
for (it = ms.begin(), i = 1; it != ms.end() && i <= s; it++, i++) {
v.push_back(make_pair(it->first, it->second));
}
for (i = i - 2; i >= 0; i--) {
printf("S %d %d\n", v[i].first, v[i].second);
}
for (it2 = mb.rbegin(), i = 1; it2 != mb.rend() && i <= s; it2++, i++) {
printf("B %d %d\n", it2->first, it2->second);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:2560000000000")
using namespace std;
map<int, int> sell;
map<int, int> buy;
int main() {
int n, s;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
int p, d;
char c;
cin >> c >> p >> d;
if (c == 'S') {
sell[p] += d;
} else {
buy[-p] += d;
}
}
map<int, int>::iterator it = sell.begin();
vector<pair<int, int>> ans;
for (int i = 1; i <= s && it != sell.end(); i++) {
ans.push_back(make_pair(it->first, it->second));
it++;
}
for (int i = ans.size() - 1; i >= 0; i--) {
cout << "S " << ans[i].first << ' ' << ans[i].second << endl;
}
map<int, int>::iterator it1 = buy.begin();
for (int i = 1; i <= s && it1 != buy.end(); i++) {
cout << "B " << -it1->first << ' ' << it1->second << endl;
it1++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int inf = -INF;
const int N = 100005;
const int M = 2005;
const int mod = 1000000007;
const double pi = acos(-1.0);
int mp1[N], mp2[N];
int main() {
int n, m;
int d, p;
char s[2];
scanf("%d %d", &n, &m);
memset(mp1, 0, sizeof(mp1));
memset(mp2, 0, sizeof(mp2));
for (int i = 1; i <= n; i++) {
scanf("%s %d %d", &s, &p, &d);
if (s[0] == 'S')
mp1[p] += d;
else
mp2[p] += d;
}
int k = 0, t = 0;
for (int it = 0; it < N, t < m; it++) {
if (it > 100000) break;
if (mp1[it] > 0) t++, k = it;
}
for (int j = k; j >= 0; j--)
if (mp1[j] > 0) printf("S %d %d\n", j, mp1[j]);
t = 0;
for (int it = N; it >= 0 && t < m; it--) {
if (mp2[it] > 0) printf("B %d %d\n", it, mp2[it]), t++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
map<int, int> b, s;
void print(map<int, int>::iterator it, int x) {
if (x >= k || it == s.end()) return;
print(++it, x + 1);
it--;
printf("S %d %d\n", it->first, it->second);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
int p, q;
char c;
cin >> c >> p >> q;
if (c == 'B') {
b[p] += q;
} else {
s[p] += q;
}
}
print(s.begin(), 0);
int i = 0;
map<int, int>::reverse_iterator rt;
for (rt = b.rbegin(); i < k && rt != b.rend(); rt++, i++) {
printf("B %d %d\n", rt->first, rt->second);
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 7;
long long a[maxn];
long long b[maxn];
long long ans;
unsigned int countSetBits(long long n) {
unsigned int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int by(long long* arr, int s, int e, long long num) {
int mid = (s + e) / 2;
if (s > e) return mid;
if (arr[mid] == num) {
by(arr, mid + 1, e, num);
} else if (arr[mid] > num) {
by(arr, s, mid - 1, num);
} else {
by(arr, mid + 1, e, num);
}
}
using namespace std;
int main() {
int s, p;
cin >> p >> s;
map<long long, long long> m1, m2;
for (int i = 0; i < p; i++) {
char a;
long long asom, bsom;
cin >> a >> asom >> bsom;
if (a == 'B') {
m1[asom] += bsom;
} else
m2[asom] += bsom;
}
int z = s;
if (m2.size() != 0) {
auto it = m2.begin();
auto bt = m2.end();
vector<pair<long long, long long>> v;
int i = 0;
while (s--) {
v.push_back(make_pair(it->first, it->second));
it++;
if (it == bt) break;
i++;
}
s = z;
i = v.size() - 1;
while (i >= 0) {
cout << "S " << v[i].first << " " << v[i].second;
if (s) cout << endl;
i--;
}
}
if (m1.size() != 0) {
auto it = m1.end();
it--;
s = z;
auto bt = m1.begin();
bt--;
while (s--) {
if (s == z - 1) cout << endl;
cout << "B " << it->first << " " << it->second;
it--;
if (it == bt) break;
if (s) cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool f[1000007];
vector<int> pri;
void sieve() {
f[0] = f[1] = 1;
for (int i = 2; i < 1000007; ++i) {
if (f[i]) continue;
pri.push_back(i);
for (int j = i * i; i <= 10000 && j < 1000007; j += i) f[j] = 1;
}
}
vector<int> factor;
void GetFactor(int n) {
for (int i = 2; i <= n / i; ++i) {
while (n % i == 0) {
factor.push_back(i);
n /= i;
}
}
if (n != 1) factor.push_back(n);
}
int MaxSubarray(int arr[], int n) {
int best = 0, sum = 0;
for (int i = 0; i < n; ++i) {
sum = max(arr[i], arr[i] + sum);
best = max(best, sum);
}
return best;
}
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) { return a / GCD(a, b) * b; }
long long fast_power(long long b, long long p) {
long long res = 1;
while (p) {
if (p % 2) res = (res * b) % 1000000007;
b = (b * b) % 1000000007;
p /= 2;
}
return res;
}
int main() {
map<int, int> mp1, mp2;
int n, s, x, y;
char ty;
cin >> n >> s;
while (n--) {
cin >> ty >> x >> y;
if (ty == 'B')
mp1[x] += y;
else
mp2[x] += y;
}
map<int, int>::iterator it = mp2.begin();
int sz = mp2.size();
if (mp2.size())
for (advance(it, min(s - 1, sz - 1));; --it) {
cout << "S " << it->first << " " << it->second << "\n";
if (it == mp2.begin()) break;
}
int i = 0;
for (map<int, int>::reverse_iterator it = mp1.rbegin();
i < s && it != mp1.rend(); ++it, i++) {
cout << "B " << it->first << " " << it->second << "\n";
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long MOD = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double PI = 3.141592653589793116, EPS = 1e-9,
GOLD = ((1 + sqrt(5)) / 2);
vector<long long> HashMod = {1000000007LL, 1000000009LL, 1000000021LL,
1000000033LL};
template <class T>
int getbit(T s, int i) {
return (s >> 1) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
long long n, s;
map<long long, long long> MapB, MapS;
char d;
long long p, q;
void VarInput() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> s;
while (n--) {
cin >> d >> p >> q;
if (d == 'B')
MapB[-p] += q;
else
MapS[-p] += q;
}
}
void ProSolve() {
long long tmp = MapS.size();
for (auto it = MapS.begin(); it != MapS.end(); it++) {
tmp--;
if (tmp >= s) continue;
cout << "S " << -(it->first) << " " << (it->second) << '\n';
tmp--;
}
tmp = s;
for (auto it = MapB.begin(); it != MapB.end(); it++) {
if (tmp <= 0) break;
cout << "B " << -(it->first) << " " << (it->second) << '\n';
tmp--;
}
}
int main() {
VarInput();
ProSolve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2][100007];
int main() {
int n, s, p, q, h;
char ch;
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) {
getchar();
scanf("%c%*c%d%d", &ch, &p, &q);
if (ch == 'S')
h = 0;
else
h = 1;
a[h][p] += q;
}
vector<pair<int, int> > B[2];
for (int j = 0; j <= 1; j++)
for (int i = 0; i <= 100007 - 2; i++) {
if (a[j][i] > 0) {
B[j].push_back(make_pair(i, a[j][i]));
}
}
sort(B[0].begin(), B[0].end());
sort(B[1].begin(), B[1].end());
char res[] = "SB";
vector<pair<int, int> > A;
for (int j = 0; j <= 0; j++) {
int w = 0;
for (int i = 0; i <= (int)B[j].size() - 1; i++) {
w++;
A.push_back(make_pair(B[j][i].first, B[j][i].second));
if (w == s) break;
}
}
sort(A.begin(), A.end());
for (int j = 0; j <= 0; j++) {
int w = 0;
for (int i = (int)A.size() - 1; i >= 0; i--) {
w++;
printf("%c %d %d\n", res[j], A[i].first, A[i].second);
if (w == s) break;
}
}
for (int j = 1; j <= 1; j++) {
int w = 0;
for (int i = (int)B[j].size() - 1; i >= 0; i--) {
w++;
printf("%c %d %d\n", res[j], B[j][i].first, B[j][i].second);
if (w == s) break;
}
}
return 0;
}
|
#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;
int main() {
int n, s, bs = 0;
cin >> n >> s;
char d;
std::vector<std::pair<int, int>> pq;
int p, q;
for (int i = 0; i < n; ++i) {
cin >> d >> p >> q;
pq.push_back(std::make_pair(p, q));
if (d == 'B') {
++bs;
}
}
std::sort(pq.begin(), pq.end());
int s1 = s;
vector<pair<int, int>> aggregated;
for (int i = n - 1; i >= bs; --i) {
int curr_p = pq[i].first;
int curr_q = pq[i].second;
for (int j = i - 1; j >= bs; --j) {
if (pq[j].first == curr_p) {
curr_q += pq[j].second;
} else {
i = j + 1;
break;
}
if (j == bs) {
i = bs;
}
}
aggregated.push_back(make_pair(curr_p, curr_q));
}
int x;
if (s > aggregated.size()) {
x = 0;
} else {
x = aggregated.size() - s;
}
for (int i = x; i < aggregated.size(); ++i) {
cout << "S " << aggregated[i].first << " " << aggregated[i].second;
if (i == aggregated.size() - 1 && bs == 0) {
break;
}
cout << endl;
}
int s2 = s;
for (int i = bs - 1; i >= 0; --i) {
int curr_p = pq[i].first;
int curr_q = pq[i].second;
for (int j = i - 1; j >= 0; --j) {
if (pq[j].first == curr_p) {
curr_q += pq[j].second;
} else {
i = j + 1;
break;
}
if (j == 0) {
i = 0;
}
}
cout << "B " << curr_p << " " << curr_q;
--s2;
if (s2 == 0 || i == 0) {
break;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<pair<char, int>, int> mp;
int n, m, bb = 0, s = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
char t;
int a, b;
cin >> t >> a >> b;
if (t == 'S')
s++;
else
bb++;
if (mp[make_pair(t, a)] != 0 && t == 'B') bb--;
if (mp[make_pair(t, a)] != 0 && t == 'S') s--;
mp[make_pair(t, a)] += b;
}
map<pair<char, int>, int>::iterator it = mp.end();
it--;
int c = 0;
while (s > m) s--, it--;
while (c < m && s) {
c++;
s--;
cout << it->first.first << " " << it->first.second << " " << it->second
<< endl;
it--;
}
c = 0;
it = mp.begin();
while (bb > m) bb--, it++;
for (int i = 0; i < bb - 1; i++) it++;
while (c < bb) {
c++;
cout << it->first.first << " " << it->first.second << " " << it->second
<< endl;
it--;
}
return 0;
}
|
#include <bits/stdc++.h>
int b[100001], s[100001], stack[100000];
int main() {
int n, sno, temp, q, i, j;
char ch, waste;
scanf("%d%d", &n, &sno);
for (i = 0; i < n; i++) {
scanf("%c", &waste);
scanf("%c %d %d", &ch, &temp, &q);
if (ch == 'B')
b[temp] += q;
else
s[temp] += q;
}
i = 0;
for (j = 0; j < 100001; j++) {
if (s[j] > 0) {
stack[j] = s[j];
i++;
}
if (i == sno) break;
}
for (i = 100000; i >= 0; i--)
if (stack[i] > 0) printf("S %d %d\n", i, stack[i]);
j = 0;
for (i = 100000; i >= 0; i--) {
if (b[i] > 0) {
printf("B %d %d\n", i, b[i]);
j++;
}
if (j == sno) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
map<long int, long int> sell, buy, snew;
cin >> n >> s;
while (n--) {
int p, q;
char c;
cin >> c >> p >> q;
if (c == 'B') {
buy[p] = buy[p] + q;
} else {
sell[p] = sell[p] + q;
}
}
int count = 0;
for (map<long int, long int>::iterator i = sell.begin(); i != sell.end();
++i) {
if (count >= s)
break;
else {
snew[i->first] = i->second;
count++;
}
}
count = 0;
for (map<long int, long int>::reverse_iterator i = snew.rbegin();
i != snew.rend(); ++i) {
if (count >= s)
break;
else {
cout << "S"
<< " " << i->first << " " << i->second << endl;
count++;
}
}
count = 0;
for (map<long int, long int>::reverse_iterator i = buy.rbegin();
i != buy.rend(); ++i) {
if (count >= s)
break;
else {
cout << "B"
<< " " << i->first << " " << i->second << endl;
count++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int mx = 3e5 + 5;
const int md = 1e9 + 7;
const long long oo = 1e14;
const int N = 2e5 + 5;
int dy[] = {};
int dx[] = {};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, second;
cin >> n >> second;
char c;
int p, q;
deque<pair<int, int>> b, ss;
while (n--) {
cin >> c >> p >> q;
if (c == 'B')
b.push_back({p, q});
else
ss.push_back({p, q});
}
sort(b.rbegin(), b.rend());
sort(ss.begin(), ss.end());
for (int i = 1; i < int(ss.size()); ++i)
if (ss[i].first == ss[i - 1].first)
ss[i].second += ss[i - 1].second, ss.erase(ss.begin() + (--i));
for (int i = 1; i < int(b.size()); ++i)
if (b[i].first == b[i - 1].first)
b[i].second += b[i - 1].second, b.erase(b.begin() + (--i));
for (int i = min(second, int(ss.size())) - 1; i >= 0; --i)
cout << "S " << ss[i].first << " " << ss[i].second << "\n";
for (int i = 0; i < min(int(b.size()), second); ++i)
cout << "B " << b[i].first << " " << b[i].second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int b[100005], s[100005];
int main() {
for (int i = 0; i < 100005; i++) b[i] = s[i] = 0;
int n, S;
scanf("%d %d", &n, &S);
int p, q;
char d;
for (int i = 0; i < n; i++) {
scanf(" %c %d %d", &d, &p, &q);
if (d == 'B')
b[p] += q;
else
s[p] += q;
}
int k = 0, j = 0;
pair<int, int> buy[1003], sell[1003];
for (int i = 0; i < 100005; i++) {
if (b[i]) buy[k++] = make_pair(-i, b[i]);
if (s[i]) sell[j++] = make_pair(i, s[i]);
}
sort(buy, buy + k);
sort(sell, sell + j);
int t = min(j, S);
for (int i = 0; i < t; i++) sell[i].first = -sell[i].first;
sort(sell, sell + t);
for (int i = 0; i < t; i++)
printf("S %d %d\n", -sell[i].first, sell[i].second);
t = min(k, S);
for (int i = 0; i < t; i++) printf("B %d %d\n", -buy[i].first, buy[i].second);
}
|
#include <bits/stdc++.h>
int price_buy[1001], price_sell[1001];
int vol_sell[1001], vol_buy[1001];
int s, b;
int orders, depth;
void init() {
int i;
for (i = 0; i < b; i++) {
price_buy[i] = 0;
vol_buy[i] = 0;
}
for (i = 0; i < s; i++) {
price_sell[i] = 0;
vol_sell[i] = 0;
}
s = b = 0;
}
int partition(int low, int high, int A[1001], int B[1001]) {
int pivot, i, j, temp1, temp2;
pivot = A[low];
i = low;
j = high + 1;
while (1) {
do {
++i;
} while (A[i] <= pivot && i <= high);
do {
--j;
} while (A[j] > pivot);
if (i >= j) break;
temp1 = A[i];
temp2 = B[i];
A[i] = A[j];
B[i] = B[j];
A[j] = temp1;
B[j] = temp2;
}
temp1 = A[low];
temp2 = B[low];
A[low] = A[j];
B[low] = B[j];
A[j] = temp1;
B[j] = temp2;
return j;
}
void quicksort(int low, int high, int A[1001], int B[1001]) {
int j;
if (low < high) {
j = partition(low, high, A, B);
quicksort(low, j - 1, A, B);
quicksort(j + 1, high, A, B);
}
}
int check(int price, char ch) {
int i;
if (ch == 'B') {
for (i = 0; i < b; i++) {
if (price_buy[i] == price) {
return i;
}
}
return b;
} else {
for (i = 0; i < s; i++) {
if (price_sell[i] == price) {
return i;
}
}
return s;
}
}
void readcase() {
int i, index;
int price, vol;
char ch, enter;
for (i = 0; i < orders; i++) {
getchar();
scanf("%c %d %d", &ch, &price, &vol);
index = check(price, ch);
if (ch == 'B') {
price_buy[index] = price;
vol_buy[index] += vol;
if (index == b) b++;
} else {
price_sell[index] = price;
vol_sell[index] += vol;
if (index == s) s++;
}
}
}
void sort_ascending() {
quicksort(0, s - 1, price_sell, vol_sell);
quicksort(0, b - 1, price_buy, vol_buy);
}
void print_answer() {
int i;
if (s >= depth) {
for (i = depth - 1; i >= 0; i--) {
printf("S %d %d\n", price_sell[i], vol_sell[i]);
}
} else {
for (i = s - 1; i >= 0; i--) {
printf("S %d %d\n", price_sell[i], vol_sell[i]);
}
}
if (b >= depth) {
for (i = b - 1; depth > 0; i--, depth--) {
printf("B %d %d\n", price_buy[i], vol_buy[i]);
}
} else {
for (i = b - 1; i >= 0; i--) {
printf("B %d %d\n", price_buy[i], vol_buy[i]);
}
}
}
void solvecase() {
sort_ascending();
print_answer();
}
int main() {
while (scanf("%d %d", &orders, &depth) == 2) {
readcase();
solvecase();
init();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s;
char d[1005];
int p[1005] = {0};
int q[1005] = {0};
char fid[1005];
int fip[1005] = {0};
int fiq[1005] = {0};
int main() {
cin >> n >> s;
char di;
int pi, qi;
for (int i = 1; i <= n; i++) {
cin >> di >> pi >> qi;
d[i] = di;
p[i] = pi;
q[i] = qi;
}
int idx = 1;
int used[1005] = {0};
for (int i = 1; i <= n; i++) {
if (used[i] == 1) continue;
fid[idx] = d[i];
fip[idx] = p[i];
fiq[idx] = q[i];
for (int j = i; j <= n; j++) {
if (i != j && used[j] == 0 && d[i] == d[j] && p[i] == p[j]) {
fiq[idx] += q[j];
used[j] = 1;
}
}
idx++;
}
vector<pair<int, int> > sell;
vector<pair<int, int> > buy;
for (int i = 1; i < idx; i++) {
if (fid[i] == 'S') {
sell.push_back(make_pair(fip[i], fiq[i]));
}
}
for (int i = 1; i < idx; i++) {
if (fid[i] == 'B') {
buy.push_back(make_pair(fip[i], fiq[i]));
}
}
int k = s;
if (sell.size() != 0) {
sort(sell.begin(), sell.end(), std::less<pair<int, int> >());
if (k > sell.size()) k = sell.size();
for (int i = k - 1; i >= 0; i--) {
printf("S %d %d\n", sell[i].first, sell[i].second);
}
}
k = s;
if (buy.size() != 0) {
sort(buy.begin(), buy.end(), std::greater<pair<int, int> >());
if (k > buy.size()) k = buy.size();
for (int i = 0; i < k; i++) {
printf("B %d %d\n", buy[i].first, buy[i].second);
}
}
}
|
#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;
}
int pos = 0;
for (int i = 0, ts = s; i < 100001 && ts > 0; i++) {
if (sa[i] > 0) {
pos = i;
ts--;
}
}
for (int i = pos, ts = s; i >= 0 && ts > 0; i--) {
if (sa[i] > 0) {
printf("S %d %d\n", i, sa[i]);
ts--;
}
}
for (int i = 100000, ts = s; i >= 0 && ts > 0; i--) {
if (ba[i] > 0) {
printf("B %d %d\n", i, ba[i]);
ts--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Order {
int p;
int q;
int index;
Order(int a = 0, int b = 0, int c = 0) {
p = a;
q = b;
index = c;
}
};
Order b[1001], s[1001];
bool cmp_higher_price(const Order& a, const Order& b) { return a.p > b.p; }
bool cmp_lower_price(const Order& a, const Order& b) { return a.p < b.p; }
bool cmp_index(const Order& a, const Order& b) { return a.index < b.index; }
int main() {
int n, st, p, q;
char d;
scanf("%d %d", &n, &st);
int i, tb, ts, j;
tb = ts = 0;
for (i = 0; i < n; i++) {
scanf("\n%c %d %d", &d, &p, &q);
if (d == 'B') {
for (j = tb - 1; j >= 0; j--) {
if (b[j].p == p) {
b[j].q += q;
break;
}
}
if (j < 0) {
b[tb] = Order(p, q, tb);
tb++;
}
} else if (d == 'S') {
for (j = ts - 1; j >= 0; j--) {
if (s[j].p == p) {
s[j].q += q;
break;
}
}
if (j < 0) {
s[ts] = Order(p, q, ts);
ts++;
}
}
}
sort(b, b + tb, cmp_higher_price);
sort(s, s + ts, cmp_higher_price);
if (ts <= st) {
for (i = 0; i < ts; i++) {
printf("S %d %d\n", s[i].p, s[i].q);
}
} else {
for (i = ts - st; i < ts; i++) {
printf("S %d %d\n", s[i].p, s[i].q);
}
}
if (tb <= st) {
for (i = 0; i < tb; i++) {
printf("B %d %d\n", b[i].p, b[i].q);
}
} else {
for (i = 0; i < st; i++) {
printf("B %d %d\n", b[i].p, b[i].q);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> buyMap;
map<int, int> sellMap;
int main() {
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
char d;
int p, q;
cin >> d >> p >> q;
if (d == 'B')
buyMap[p] = (buyMap[p]) ? buyMap[p] + q : q;
else
sellMap[p] = (sellMap[p]) ? sellMap[p] + q : q;
}
map<int, int>::reverse_iterator rit;
int startIndex = s > sellMap.size() ? sellMap.size() : s;
int index = sellMap.size();
for (rit = sellMap.rbegin(); rit != sellMap.rend(); ++rit) {
if (startIndex < index--) continue;
cout << "S " << rit->first << " " << rit->second << endl;
}
index = 0;
for (rit = buyMap.rbegin(); rit != buyMap.rend(); ++rit) {
cout << "B " << rit->first << " " << rit->second << endl;
if (++index == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) { return (a.first > b.first); }
struct mycomp {
bool operator()(const int& a, const int& b) const { return (a > b); }
};
int main() {
int n, s;
cin >> n >> s;
map<int, int, mycomp> m1;
map<int, int> m2;
int q, p;
string tmp;
for (int i = 0; i < n; i++) {
cin >> tmp >> p >> q;
if (tmp[0] == 'B')
m1[p] += q;
else
m2[p] += q;
}
vector<pair<int, int> > a1, a2;
int count = 0;
for (auto it = m2.begin(); it != m2.end() && count < s; it++) {
a1.push_back({it->first, it->second});
count++;
}
count = 0;
for (auto it = m1.begin(); it != m1.end() && count < s; it++) {
a2.push_back({it->first, it->second});
count++;
}
sort(a1.begin(), a1.end(), comp);
sort(a2.begin(), a2.end(), comp);
for (auto& elem : a1)
cout << "S " << elem.first << " " << elem.second << endl;
for (auto& elem : a2)
cout << "B " << elem.first << " " << elem.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXP = 1e5;
long long int n, s, p, q, x, sell[MAXP + 5] = {0}, buy[MAXP + 5] = {0};
char d;
vector<pair<long long int, long long int> > ansell;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> d >> p >> q;
if (d == 'S')
sell[p] += q;
else
buy[p] += q;
}
x = 0;
for (int i = 0; i <= MAXP; i++) {
if (x == s) break;
if (sell[i]) {
ansell.push_back(make_pair(i, sell[i]));
x++;
}
}
for (int i = ((int(ansell.size()))) - 1; i >= 0; i--)
cout << "S " << ansell[i].first << " " << ansell[i].second << endl;
x = 0;
for (int i = MAXP; i >= 0; i--) {
if (x == s) break;
if (buy[i]) {
cout << "B " << i << " " << buy[i] << endl;
x++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num, s, ax[100010] = {0}, ay[100010] = {0}, p, q;
char ch;
int c = 0;
int atik[100010] = {0};
int main() {
cin >> num >> s;
for (int i = 0; i < num; i++) {
cin >> ch >> p >> q;
if (ch == 'S')
ax[p] += q;
else
ay[p] += q;
}
for (int i = 0; i < 100002; i++) {
if (ax[i] > 0) {
c++;
atik[i] = ax[i];
}
if (c == s) break;
}
c = 0;
for (int i = 100002; i >= 0; i--) {
if (atik[i] > 0) {
c++;
cout << "S " << i << " " << atik[i] << endl;
}
if (c == s) break;
}
c = 0;
for (int i = 100002; i >= 0; i--) {
if (ay[i] > 0) {
c++;
cout << "B " << i << " " << ay[i] << endl;
}
if (c == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> b, s;
int main() {
int n, x;
cin >> n >> x;
for (int i = 0; i < n; i++) {
char ch;
int p, v;
cin >> ch >> p >> v;
if (ch == 'B')
b[p] += v;
else
s[p] += v;
}
int cnt = 0;
while (s.size() > x) s.erase(--s.end());
while (b.size() > x) b.erase(b.begin());
map<int, int>::iterator it;
vector<pair<int, int> > bb, ss;
for (it = s.begin(); it != s.end(); it++)
ss.push_back({it->first, it->second});
for (it = b.begin(); it != b.end(); it++)
bb.push_back({it->first, it->second});
reverse(ss.begin(), ss.end());
reverse(bb.begin(), bb.end());
for (int i = 0; i < ss.size(); i++)
cout << "S " << ss[i].first << " " << ss[i].second << '\n';
for (int i = 0; i < bb.size(); i++)
cout << "B " << bb[i].first << " " << bb[i].second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct sort_pred {
bool operator()(const pair<int, int>& left, const pair<int, int>& right) {
return left.second < right.second;
}
};
struct convert {
void operator()(char& c) { c = toupper((unsigned char)c); }
};
struct convertd {
void operator()(char& c) { c = tolower((unsigned char)c); }
};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
vector<int> mark(302);
vector<set<int> > A;
const int MAX_N = 1;
int p[MAX_N];
int root_rank[MAX_N];
void make_set(int x) { p[x] = x; }
int find_root(int x) {
if (p[x] == x) return x;
return p[x] = find_root(p[x]);
}
void unite(int x, int y) {
x = find_root(x);
y = find_root(y);
if (root_rank[x] < root_rank[y])
p[x] = y;
else {
p[y] = x;
if (root_rank[x] == root_rank[y]) {
++root_rank[y];
}
}
}
const int N = 1;
int lp[N + 1];
void DFS(vector<vector<int> > edges, int start) {
stack<int> s;
set<int> _set;
s.push(start);
while (!s.empty()) {
int v = s.top();
s.pop();
vector<int>::iterator it;
for (it = edges[v].begin(); it != edges[v].end(); ++it) {
if (mark[*it] == 0) {
cout << mark[*it] << "!!"
<< "\n";
s.push(*it);
_set.insert(*it);
mark[*it] = 1;
}
}
}
if (_set.size()) A.push_back(_set);
}
vector<int> sieve(const int N) {
vector<int> pr;
for (int i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < (int)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
return pr;
}
map<pair<char, int>, int> m;
map<pair<char, int>, int> m2;
int main() {
ios::sync_with_stdio(false);
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
char d;
int q, p;
cin >> d >> p >> q;
if (d == 'B')
m[make_pair(d, p)] += q;
else {
m2[make_pair(d, p)] += q;
}
}
map<pair<char, int>, int>::iterator it;
map<pair<char, int>, int>::reverse_iterator it2;
int j = 0;
if (m2.size()) {
it2 = m2.rbegin();
int k = m2.size();
for (; it2 != m2.rend(); ++it2) {
if (k > s) {
k--;
} else {
cout << it2->first.first << " " << it2->first.second << " "
<< it2->second << "\n";
}
}
}
if (m.size()) {
j = 0;
if (m.size() <= s) {
s = m.size();
}
it = m.end();
--it;
for (; j < s; --it) {
cout << it->first.first << " " << it->first.second << " " << it->second
<< "\n";
j++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
void dump_reverse(const std::map<int, int>& map, int s, char c) {
int counter = 0;
for (auto it = map.rbegin(), end_it = map.rend(); it != end_it && counter < s;
++it) {
std::cout << c << ' ' << it->first << ' ' << it->second << std::endl;
++counter;
}
}
void dump_offset(const std::map<int, int>& map, int s, char c) {
size_t size = map.size();
if (s >= size) {
dump_reverse(map, s, c);
return;
}
auto it = map.rbegin();
while (size > s) {
++it;
--size;
}
for (auto end_it = map.rend(); it != end_it; ++it) {
std::cout << c << ' ' << it->first << ' ' << it->second << std::endl;
}
}
int main() {
std::ios::sync_with_stdio(false);
int n;
int s;
std::cin >> n;
std::cin >> s;
std::map<int, int> map_s;
std::map<int, int> map_b;
for (int i = 0; i < n; i++) {
char c;
int p;
int q;
std::cin >> c;
std::cin >> p;
std::cin >> q;
switch (c) {
case 'S': {
map_s[p] += q;
} break;
case 'B': {
map_b[p] += q;
} break;
default:
break;
}
}
dump_offset(map_s, s, 'S');
dump_reverse(map_b, s, 'B');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s, x, y, i, cnt, mem;
int tab[3][100001];
char znak;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> s;
for (int a = 1; a <= n; a++) {
cin >> znak >> x >> y;
if (znak == 'B')
i = 1;
else
i = 2;
tab[i][x] += y;
}
for (int a = 0; a <= 100000; a++) {
if (tab[2][a] && cnt < s) {
mem = a;
cnt++;
}
}
for (; mem >= 0; mem--) {
if (tab[2][mem]) cout << "S " << mem << " " << tab[2][mem] << endl;
}
cnt = 0;
for (int a = 100000; a >= 0; a--) {
if (tab[1][a] && cnt < s) {
cout << "B " << a << " " << tab[1][a] << endl;
cnt++;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s;
map<int, int> B, S;
void run(char x, function<bool(pair<int, int>, pair<int, int>)> f) {
vector<pair<int, int>> v;
auto m = (x == 'S') ? &S : &B;
for (auto iter = m->begin(); iter != m->end(); ++iter) {
v.push_back(*iter);
}
sort(v.begin(), v.end(), f);
sort(v.begin(), v.begin() + min(s, (int)v.size()), greater<pair<int, int>>());
for (int i = 0; i < min(s, (int)v.size()); ++i) {
cout << x << ' ' << v[i].first << ' ' << v[i].second << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> s;
while (n--) {
char t;
int p, q;
cin >> t >> p >> q;
if (t == 'S')
S[p] += q;
else
B[p] += q;
}
run('S', less<pair<int, int>>());
run('B', greater<pair<int, int>>());
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 1e3 + 5;
typedef struct {
char c = '\0';
int a = 0;
int b = 0;
} sss;
typedef struct {
char c = '\0';
int a = 0;
int b = 0;
} bbb;
sss st[maxm];
bbb bt[maxm];
int n, m;
int numb, nums;
int cmps(sss s1, sss s2) { return s1.a <= s2.a; }
int cmpb(bbb b1, bbb b2) { return b1.a >= b2.a; }
int isinb(int aa, int bb) {
for (int i = 0; i < numb; i++) {
if (bt[i].a == aa) {
bt[i].b += bb;
return 1;
}
}
return 0;
}
int isins(int aa, int bb) {
for (int i = 0; i < nums; i++) {
if (st[i].a == aa) {
st[i].b += bb;
return 1;
}
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
char c[5];
int x, y;
scanf("%s%d%d", c, &x, &y);
if (c[0] == 'B') {
if (isinb(x, y)) {
continue;
} else {
bt[numb].c = 'B';
bt[numb].a = x;
bt[numb].b = y;
numb++;
}
} else if (c[0] == 'S') {
if (isins(x, y)) {
continue;
} else {
st[nums].c = 'S';
st[nums].a = x;
st[nums].b = y;
nums++;
}
}
}
sort(bt, bt + numb, cmpb);
sort(st, st + nums, cmps);
if (nums < m) {
for (int i = nums - 1; i >= 0; i--) {
printf("S %d %d\n", st[i].a, st[i].b);
}
} else {
for (int j = m - 1; j >= 0; j--) {
printf("S %d %d\n", st[j].a, st[j].b);
}
}
if (numb < m) {
for (int i = 0; i < numb; i++) {
printf("B %d %d\n", bt[i].a, bt[i].b);
}
} else {
for (int j = 0; j < m; j++) {
printf("B %d %d\n", bt[j].a, bt[j].b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fmin(long long a, long long b) { return a < b ? a : b; }
long long fmax(long long a, long long b) { return a > b ? a : b; }
int getBit(int n, int pos) { return (n >> pos) & 1; }
vector<pair<long long, long long>> sell, buy;
bool sortSell(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
bool sortBuy(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int main() {
ios_base::sync_with_stdio(false);
int n, s;
cin >> n >> s;
long long a, b;
string st;
for (int i = 0; i < n; i++) {
cin >> st;
cin >> a >> b;
if (st == "S") {
int flag = 0;
for (int i = 0; i < sell.size(); i++)
if (sell[i].first == a) {
sell[i].second += b;
flag = 1;
}
if (flag == 1) continue;
sell.push_back(make_pair(a, b));
} else {
int flag = 0;
for (int i = 0; i < buy.size(); i++)
if (buy[i].first == a) {
buy[i].second += b;
flag = 1;
}
if (flag == 1) continue;
buy.push_back(make_pair(a, b));
}
}
sort(sell.begin(), sell.end(), sortSell);
sort(buy.begin(), buy.end(), sortBuy);
for (int i = fmin(s, sell.size()) - 1; i >= 0; i--)
cout << "S " << sell[i].first << " " << sell[i].second << endl;
for (int i = 0; i < fmin(s, buy.size()); i++)
cout << "B " << buy[i].first << " " << buy[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, y, z;
char x;
map<long long, long long> b, second;
map<long long, long long>::iterator it;
vector<pair<long long, long long> > l, r, ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x >> y >> z;
if (x == 'B')
b[y] += z;
else
second[y] += z;
}
for (it = b.begin(); it != b.end(); it++) {
l.push_back(make_pair(it->first, it->second));
}
for (it = second.begin(); it != second.end(); it++) {
r.push_back(make_pair(it->first, it->second));
}
sort(r.begin(), r.end());
reverse(l.begin(), l.end());
for (int i = 0; i < r.size(); i++) {
ans.push_back(make_pair(r[i].first, r[i].second));
if (i + 1 == m) break;
}
reverse(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << "S " << ans[i].first << ' ' << ans[i].second << endl;
}
for (int i = 0; i < l.size(); i++) {
cout << "B " << l[i].first << ' ' << l[i].second << endl;
if (i + 1 == m) break;
}
return 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int volume;
int value;
};
node S[100005];
node B[100005];
int cmp(node a, node b) { return a.value < b.value; }
int main() {
char s;
int n, m, ans, tmp, p, v, sum1, sum2;
while (scanf("%d%d", &n, &m) != EOF) {
sum1 = sum2 = 0;
memset(S, 0, sizeof(S));
memset(B, 0, sizeof(B));
for (int i = 0; i < n; i++) {
cin >> s >> p >> v;
if (s == 'B') {
B[p].volume += v;
} else
S[p].volume += v;
}
for (int i = 100005 - 1; i >= 0; i--) {
if (S[i].volume) {
sum1++;
}
}
if (sum1 > m) {
tmp = sum1 - m;
for (int i = 100005 - 1; i >= 0; i--) {
if (S[i].volume && tmp) {
S[i].volume = 0;
tmp--;
}
}
}
for (int i = 100005 - 1; i >= 0; i--) {
if (S[i].volume) cout << "S " << i << " " << S[i].volume << endl;
}
for (int i = 100005 - 1; i >= 0; i--) {
if (B[i].volume && sum2 < m) {
cout << "B " << i << " " << B[i].volume << endl;
sum2++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool op_gr(const pair<int, int>& left, const pair<int, int>& right) {
return left.first > right.first;
}
int main() {
int n, s;
scanf("%d %d", &n, &s);
char x;
map<int, int> M1;
map<int, int> M2;
vector<pair<int, int> > B(1000, make_pair(0, 0));
vector<pair<int, int> > S(1000, make_pair(0, 0));
int j, l;
int in_B = 0, in_S = 0;
for (int i = 0; i < n; ++i) {
scanf(" %c", &x);
if (x == 'B') {
scanf("%d %d", &j, &l);
if (M1.find(j) == M1.end()) {
M1[j] = in_B;
B[in_B++] = make_pair(j, l);
} else {
B[M1[j]].second += l;
}
} else {
scanf("%d %d", &j, &l);
if (M2.find(j) == M2.end()) {
M2[j] = in_S;
S[in_S++] = make_pair(j, l);
} else {
S[M2[j]].second += l;
}
}
}
int ct = 0;
int i = 0;
sort(S.begin(), S.end());
sort(B.begin(), B.end(), op_gr);
stack<pair<int, int> > st;
while (ct < s && i < S.size()) {
if (S[i].second > 0) {
st.push(S[i]);
ct++;
}
i++;
}
while (ct--) {
printf("%c %d %d\n", 'S', st.top().first, st.top().second);
st.pop();
}
ct = 0;
i = 0;
while (ct < s && i < B.size()) {
if (B[i].second > 0) {
printf("%c %d %d\n", 'B', B[i].first, B[i].second);
ct++;
}
i++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
map<int, int> sell;
map<int, int> buy;
for (int i = 0; i < n; i++) {
char a;
cin >> a;
int p, v;
cin >> p >> v;
if (a == 'B') {
buy[p] += v;
} else {
sell[p] += v;
}
}
map<int, int>::reverse_iterator it;
map<int, int>::iterator it1;
if (s < sell.size()) {
int x = s;
map<int, int> ans;
for (it1 = sell.begin(); x != 0; it1++, x--) {
ans[it1->first] = it1->second;
}
for (it = ans.rbegin(); it != ans.rend(); it++) {
cout << "S " << it->first << " " << it->second << endl;
}
} else {
map<int, int> ans;
for (it1 = sell.begin(); it1 != sell.end(); it1++) {
ans[it1->first] = it1->second;
}
for (it = ans.rbegin(); it != ans.rend(); it++) {
cout << "S " << it->first << " " << it->second << endl;
}
}
if (s < buy.size()) {
int x = s;
for (it = buy.rbegin(); x != 0; it++, x--) {
cout << "B " << it->first << " " << it->second << endl;
}
} else {
for (it = buy.rbegin(); it != buy.rend(); it++) {
cout << "B " << it->first << " " << it->second << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<char, map<int, int> > mp, mp1;
vector<pair<int, pair<char, int> > > B, S;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
int n, s;
cin >> n >> s;
vector<pair<char, pair<int, int> > > vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i].first >> vec[i].second.first >> vec[i].second.second;
mp[vec[i].first][vec[i].second.first] += vec[i].second.second;
}
for (int i = 0; i < n; i++) {
if (!mp1[vec[i].first][vec[i].second.first]) {
mp1[vec[i].first][vec[i].second.first] = 1;
if (vec[i].first == 'B') {
B.push_back(make_pair(
vec[i].second.first,
make_pair(vec[i].first, mp[vec[i].first][vec[i].second.first])));
} else {
S.push_back(make_pair(
vec[i].second.first,
make_pair(vec[i].first, mp[vec[i].first][vec[i].second.first])));
}
}
}
int c = 0;
sort(B.begin(), B.end());
sort(S.begin(), S.end());
if (S.size() != 0) {
if (S.size() <= s) {
for (int i = S.size() - 1; i >= 0; i--) {
cout << S[i].second.first << " " << S[i].first << " "
<< S[i].second.second << endl;
}
} else {
for (int i = s - 1; i >= 0; i--) {
cout << S[i].second.first << " " << S[i].first << " "
<< S[i].second.second << endl;
}
}
}
if (B.size() != 0) {
if (B.size() <= s) {
for (int i = B.size() - 1; i >= 0; i--) {
cout << B[i].second.first << " " << B[i].first << " "
<< B[i].second.second << endl;
}
} else {
for (int i = B.size() - 1; c < s; i--) {
cout << B[i].second.first << " " << B[i].first << " "
<< B[i].second.second << endl;
c++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct hi {
char sb;
int p;
int s;
} hi;
int main() {
int n, sq;
cin >> n >> sq;
hi lol[n];
for (int i = 0; i < n; i++) {
cin >> lol[i].sb >> lol[i].p >> lol[i].s;
}
long long si[100001] = {0};
long long bi[100001] = {0};
for (int i = 0; i < n; i++) {
if (lol[i].sb == 'S') {
si[lol[i].p] += lol[i].s;
} else {
bi[lol[i].p] += lol[i].s;
}
}
int count = 0;
hi qwerty[sq];
for (int i = 0; i <= 100000; i++) {
if (si[i] != 0) {
qwerty[count].sb = 'S';
qwerty[count].p = i;
qwerty[count].s = si[i];
count++;
if (count == sq) break;
}
}
for (int i = count - 1; i >= 0; i--) {
cout << qwerty[i].sb << " " << qwerty[i].p << " " << qwerty[i].s << endl;
}
int count1 = 0;
for (int i = 100000; i >= 0; i--) {
if (bi[i] != 0) {
cout << "B " << i << " " << bi[i] << endl;
count1++;
if (count1 == sq) break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
pair<int, int> buy[N], sell[N];
int main() {
map<pair<int, int>, int> m;
int n, s;
scanf("%d %d", &n, &s);
for (int i = 0; i < n; ++i) {
char c;
int p, q;
scanf(" %c %d %d", &c, &p, &q);
m[make_pair(c, p)] += q;
}
int ns = 0;
for (auto it = m.begin(); ns < s && it != m.end(); ++it) {
if (it->first.first == 'S') {
sell[ns].first = it->first.second;
sell[ns].second = it->second;
++ns;
}
}
int nb = 0;
for (auto it = m.rbegin(); nb < s && it != m.rend(); ++it) {
if (it->first.first == 'B') {
buy[nb].first = it->first.second;
buy[nb].second = it->second;
++nb;
}
}
sort(buy, buy + nb, greater<pair<int, int>>());
sort(sell, sell + ns, greater<pair<int, int>>());
for (int i = 0; i < ns; ++i) {
printf("S %d %d\n", sell[i].first, sell[i].second);
}
for (int i = 0; i < nb; ++i) {
printf("B %d %d\n", buy[i].first, buy[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
char a[2];
int p;
int q;
};
bool cmp1(node a, node b) { return a.p < b.p; }
bool cmp2(node a, node b) { return a.p > b.p; }
node a[1005], b[1005], c[1005];
int main() {
int n, s, p, q, x = 1, y = 1, i, j;
char tmp[2];
scanf("%d %d", &n, &s);
for (i = 0; i < n; i++) {
scanf("%s %d %d", a[i].a, &a[i].p, &a[i].q);
}
for (i = 0; i < n; i++) {
if (a[i].p != -1 && a[i].a[0] == 'S') {
b[x].p = a[i].p;
b[x].q = a[i].q;
x++;
}
if (a[i].p != -1 && a[i].a[0] == 'B') {
c[y].p = a[i].p;
c[y].q = a[i].q;
y++;
}
if (a[i].p != -1) {
for (j = i + 1; j < n; j++) {
if (a[j].p != -1) {
if (a[i].p == a[j].p && a[i].a[0] == a[j].a[0] && a[i].a[0] == 'S') {
b[x - 1].q += a[j].q;
a[j].p = -1;
}
if (a[i].p == a[j].p && a[i].a[0] == a[j].a[0] && a[i].a[0] == 'B') {
c[y - 1].q += a[j].q;
a[j].p = -1;
}
}
}
}
}
sort(b + 1, b + x, cmp1);
sort(c + 1, c + y, cmp2);
for (i = min(s, x - 1); i >= 1; i--) printf("S %d %d\n", b[i].p, b[i].q);
for (i = 1; i <= s && i < y; i++) printf("B %d %d\n", c[i].p, c[i].q);
}
|
#include <bits/stdc++.h>
using namespace std;
class Stock {
public:
Stock() {
p = -1;
q = -1;
}
static const int BUY = 0;
static const int SELL = 1;
int p;
int q;
};
vector<Stock> insert(vector<Stock> v, Stock stock, int d) {
for (int i = 0; i < v.size(); ++i) {
if (d == Stock::BUY) {
if (v[i].p == -1) {
v[i] = stock;
break;
}
if (v[i].p < stock.p) {
v.insert(v.begin() + i, stock);
break;
}
if (v[i].p == stock.p) {
v[i].q += stock.q;
break;
}
} else if (d == Stock::SELL) {
if (v[i].p == -1) {
v[i] = stock;
break;
}
if (v[i].p > stock.p) {
v.insert(v.begin() + i, stock);
break;
}
if (v[i].p == stock.p) {
v[i].q += stock.q;
break;
}
}
}
return v;
}
int main() {
int n, s;
cin >> n >> s;
vector<Stock> S(s, Stock()), B(s, Stock());
for (int i = 0; i < n; ++i) {
char d;
Stock stock;
cin >> d >> stock.p >> stock.q;
if (d == 'B') {
B = insert(B, stock, Stock::BUY);
} else if (d == 'S') {
S = insert(S, stock, Stock::SELL);
}
}
for (int i = s - 1; i >= 0; --i)
if (S[i].p != -1) cout << "S " << S[i].p << " " << S[i].q << endl;
for (int i = 0; i < s; ++i) {
if (B[i].p == -1) break;
cout << "B " << B[i].p << " " << B[i].q << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void prin(int n) { printf("%d\n", n); }
int main() {
int n, s, a, b;
map<int, int> B, S;
vector<pair<int, int> > b1, s1;
cin >> n >> s;
char ch;
for (int i = 0; i < (int)(n); ++i) {
cin >> ch >> a >> b;
if (ch == 'B')
B[a] += b;
else
S[a] += b;
}
for (auto x : B) b1.push_back(make_pair(x.first, x.second));
for (auto x : S) s1.push_back(make_pair(x.first, x.second));
for (int i = min(s - 1, ((int)((s1).size())) - 1); i >= 0; i--)
cout << "S " << s1[i].first << " " << s1[i].second << endl;
for (int i = ((int)((b1).size())) - 1; i >= 0 && s; i--, s--)
cout << "B " << b1[i].first << " " << b1[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
const int N = 100050;
int Q[N], K[N];
bool comp(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int main() {
int p, q, n, s, i;
char t;
scanf("%i %i", &n, &s);
while (n--) {
scanf("\n%c %i %i", &t, &p, &q);
if (t == 'B')
K[p] += q;
else
Q[p] += q;
}
int c = 0;
for (i = 0; i < N; i++)
if (Q[i] > 0 && c < s) v.push_back(make_pair(i, Q[i])), c++;
sort(v.begin(), v.end(), comp);
for (i = 0; i < v.size(); i++) printf("S %i %i\n", v[i].first, v[i].second);
c = 0;
for (i = N - 1; i >= 0; i--)
if (K[i] > 0 && c < s) printf("B %i %i\n", i, K[i]), c++;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005];
int n, s;
int main() {
int p, q, i, k, m;
char c[1];
while (scanf("%d %d", &n, &s) != EOF) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (i = 0; i < n; i++) {
scanf("%s%d%d", c, &p, &q);
if (c[0] == 'B')
a[p] += q;
else
b[p] += q;
}
k = 0;
m = 0;
for (i = 0; i <= 100000; i++) {
if (b[i] && k < s) {
k++;
m = i;
} else if (k >= s)
break;
}
for (i = m; i >= 0; i--) {
if (b[i]) {
printf("S %d %d\n", i, b[i]);
}
}
k = 0;
for (i = 100000; i >= 0; i--) {
if (a[i] && k < s) {
printf("B %d %d\n", i, a[i]);
k++;
} else if (k >= s)
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct order {
long long p;
long long q;
};
bool comp(order a, order b) { return a.p < b.p; }
int32_t main() {
long long n, s;
cin >> n >> s;
map<long long, long long> Buy, Sell;
char ch;
long long p, q;
for (long long i = 0; i < n; i++) {
cin >> ch >> p >> q;
if (ch == 'B') {
Buy[p] += q;
} else {
Sell[p] += q;
}
}
while (Sell.size() > s) {
Sell.erase(--Sell.end());
}
for (auto it = Sell.rbegin(); it != Sell.rend(); it++) {
cout << 'S' << ' ' << it->first;
cout << ' ' << it->second << "\n";
}
while (Buy.size() > s) {
Buy.erase(Buy.begin());
}
for (auto it = Buy.rbegin(); it != Buy.rend(); it++) {
cout << 'B' << ' ' << it->first;
cout << ' ' << it->second << "\n";
}
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;
struct stock {
int price;
int n;
};
int main() {
int t, i, s, j;
cin >> t >> s;
char d;
int temp_s[100005];
int temp_b[100005];
stock buy[1000];
stock sell[1000];
for (i = 0; i < 100005; i++) {
temp_s[i] = 0;
temp_b[i] = 0;
}
int p, num;
int count = 0;
for (i = 0, j = 0; i + j < t;) {
cin >> d >> p >> num;
if (d == 'S') {
sell[i].price = p;
sell[i].n = num;
if (temp_s[p] == 0) count++;
temp_s[p] += num;
i++;
} else {
buy[i].price = p;
buy[i].n = num;
temp_b[p] += num;
j++;
}
}
int count_s = 0;
int temp = 0;
int count_b = 0;
for (i = 100000; i >= 0; i--) {
if (count_s == s) break;
if (temp_s[i] != 0) {
if (count <= s) {
cout << "S ";
cout << i << " ";
cout << temp_s[i] << endl;
count_s++;
} else
count--;
}
}
for (i = 100000; i >= 0; i--) {
if (count_b == s) break;
if (temp_b[i] != 0) {
cout << "B ";
cout << i << " ";
cout << temp_b[i] << endl;
count_b++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void input() {}
const int N = 2e5 + 5, mod = 1e9 + 7;
int n, s, x, y;
char c;
map<int, int> mp1, mp2;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
input();
cin >> n >> s;
while (n--) {
cin >> c >> x >> y;
if (c == 'S')
mp1[x] += y;
else
mp2[x] += y;
}
int cnt = s;
vector<pair<int, int>> v;
for (auto it = mp1.begin(); it != mp1.end() && cnt > 0; it++, cnt--) {
v.push_back({it->first, it->second});
}
reverse(v.begin(), v.end());
for (auto p : v) cout << "S " << p.first << " " << p.second << endl;
cnt = s;
for (auto it = mp2.rbegin(); it != mp2.rend() && cnt > 0; it++, cnt--) {
cout << "B " << it->first << " " << it->second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, long> b, sl;
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;
if (sl.begin() != sl.end()) {
it = sl.begin();
for (i = 0; i < s; i++) {
it++;
if (it == sl.end()) break;
}
while (it != sl.begin()) {
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;
int main() {
int n, s, price, quantity, ss = 0, xD;
string type;
map<int, int, greater<int> > buy, sell;
cin >> n >> s;
while (n--) {
cin >> type >> price >> quantity;
if (type == "B")
buy[price] += quantity;
else if (type == "S")
sell[price] += quantity;
}
xD = sell.size() - s;
for (auto lol : sell) {
ss++;
if (ss > xD) cout << "S " << lol.first << " " << lol.second << endl;
}
for (auto lol : buy) {
if (s < 1) break;
cout << "B " << lol.first << " " << lol.second << endl;
s--;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<pair<char, int>, int> orders;
int n, s;
cin >> n >> s;
char c;
int p, q;
pair<char, pair<int, int> > A[n];
for (int i = 0; i < n; i++) {
cin >> c >> p >> q;
orders[make_pair(c, p)] += q;
}
vector<pair<int, int> > B, S;
for (auto it = orders.begin(); it != orders.end(); it++) {
if (it->first.first == 'B')
B.push_back(make_pair(it->first.second, it->second));
else
S.push_back(make_pair(it->first.second, it->second));
}
sort(B.begin(), B.end(), greater<pair<int, int> >());
sort(S.begin(), S.end(), less<pair<int, int> >());
for (int i = min(s - 1, (int)S.size() - 1); i >= 0; i--)
cout << "S " << S[i].first << " " << S[i].second << endl;
for (int i = 0; i < min(s, (int)B.size()); i++)
cout << "B " << B[i].first << " " << B[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;
string dir;
int p, q;
for (int i = 0; i < n; i++) {
cin >> dir >> p >> q;
if (dir[0] == 'B')
buy[p] += q;
else
sell[p] += q;
}
int cnt = 0;
vector<pair<int, int> > v;
for (auto it = sell.begin(); cnt < s and it != sell.end(); it++, cnt++)
v.push_back(make_pair(it->first, it->second));
sort(v.rbegin(), v.rend());
for (int i = 0; i < (int)v.size(); i++)
cout << "S " << v[i].first << ' ' << v[i].second << '\n';
cnt = 0;
for (auto it = buy.rbegin(); cnt < s and it != buy.rend(); it++, cnt++)
cout << "B " << it->first << ' ' << it->second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ssort(pair<long long, long long> a, pair<long long, long long> b) {
return (a.first < b.first);
}
bool bsort(pair<long long, long long> a, pair<long long, long long> b) {
return (a.first > b.first);
}
int main() {
long long n, s, q, p;
char d;
cin >> n >> s;
set<pair<long long, long long> > ss, bs;
map<long long, long long> sm, bm;
for (int i = 0; i < n; ++i) {
cin >> d >> p >> q;
if (d == 'S') {
if (sm[p] == 0) {
sm[p] += q;
ss.insert(make_pair(p, q));
} else {
ss.erase(make_pair(p, sm[p]));
sm[p] += q;
ss.insert(make_pair(p, sm[p]));
}
} else {
if (bm[p] == 0) {
bm[p] += q;
bs.insert(make_pair(p, q));
} else {
bs.erase(make_pair(p, bm[p]));
bm[p] += q;
bs.insert(make_pair(p, bm[p]));
}
}
}
vector<pair<long long, long long> > bv, sv;
for (auto it = ss.begin(); it != ss.end(); ++it) {
sv.push_back(*it);
}
for (auto it = bs.begin(); it != bs.end(); ++it) {
bv.push_back(*it);
}
sort(sv.begin(), sv.end(), ssort);
sort(sv.begin(), sv.begin() + min(s, (long long)sv.size()), bsort);
sort(bv.begin(), bv.end(), bsort);
for (int i = 0; i < min((long long)sv.size(), s); ++i) {
cout << "S " << sv[i].first << " " << sv[i].second << endl;
}
for (int i = 0; i < min((long long)bv.size(), s); ++i) {
cout << "B " << bv[i].first << " " << bv[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100010], b[100010], c[100010];
int main() {
int n, i, s, y, z, k = 0, j = 0;
char x;
scanf("%d%d", &n, &s);
for (i = 1; i <= n; i++) {
scanf(" %c%d%d", &x, &y, &z);
if (x == 'S')
a[y] += z;
else
b[y] += z;
}
for (i = 0; i <= 100000; i++) {
if (a[i] > 0) {
k++;
c[++j] = i;
}
if (k == s) break;
}
for (i = j; i >= 1; i--) printf("S %d %d\n", c[i], a[c[i]]);
k = 0;
for (i = 100000; i >= 0; i--) {
if (b[i] > 0) {
k++;
printf("B %d %d\n", i, b[i]);
}
if (k == s) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s, S[100010], B[100010], a, b;
string ch;
vector<pair<int, int> > v, vv;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> ch >> a >> b;
if (ch == "B")
B[a] += b;
else
S[a] += b;
}
for (int i = 0; i < 100010; i++)
if (S[i]) v.push_back(make_pair(i, S[i]));
for (int i = 100010 - 1; i >= 0; i--)
if (B[i]) vv.push_back(make_pair(i, B[i]));
for (int i = min((int)v.size(), s) - 1; i >= 0; i--)
cout << "S " << v[i].first << " " << v[i].second << endl;
for (int i = 0; i < min((int)vv.size(), s); i++)
cout << "B " << vv[i].first << " " << vv[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int bq[100001] = {0};
int sq[100001] = {0};
vector<int> buys;
vector<int> sells;
int n;
size_t s;
cin >> n >> s;
while (n--) {
char c;
int p, q;
cin >> c >> p >> q;
if (c == 'B') {
buys.push_back(p);
bq[p] += q;
} else {
sells.push_back(p);
sq[p] += q;
}
}
sort(begin(sells), end(sells));
sells.erase(unique(begin(sells), end(sells)), end(sells));
int ssz = min(sells.size(), s);
for (int i = ssz - 1; i >= 0; --i) {
int p = sells[i];
cout << "S " << p << " " << sq[p] << endl;
}
sort(begin(buys), end(buys));
buys.erase(unique(begin(buys), end(buys)), end(buys));
int bsz = min(buys.size(), s);
for (auto rit = buys.rbegin(); rit != buys.rbegin() + bsz; ++rit) {
int p = *rit;
cout << "B " << p << " " << bq[p] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int S[100002], B[100002];
int main() {
int n, s, i, p, q, k;
char d;
cin >> n >> s;
while (n--) {
cin >> d >> p >> q;
if (d == 'S')
S[p] += q;
else
B[p] += q;
}
for (i = 0, k = 0; k < s && i <= 100000; i++) {
if (S[i] != 0) k++;
}
for (; i >= 0; i--) {
if (S[i] != 0) cout << "S " << i << " " << S[i] << endl;
}
for (k = 0, i = 100000; k < s && i >= 0; i--) {
if (B[i] != 0) {
k++;
cout << "B " << i << " " << B[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, vend = 0;
scanf("%d %d", &n, &s);
map<long int, long int> venda;
map<long int, long int> compra;
for (int i = 0; i < n; i++) {
char c;
long int p, q;
scanf(" %c %d %d", &c, &p, &q);
if (c == 'B') compra[p] += q;
if (c == 'S') {
if (venda[p] == 0) vend++;
venda[p] += q;
}
}
map<long int, long int>::reverse_iterator rit;
int i = 0;
rit = venda.rbegin();
for (i = 0; i < vend - s; i++) ++rit;
for (i = 0; i < s && rit != venda.rend(); ++rit) {
i++;
long int a = rit->first;
long int b = rit->second;
printf("S %d %d\n", a, b);
}
for (rit = compra.rbegin(), i = 0; i < s && rit != compra.rend(); ++rit) {
i++;
long int a = rit->first;
long int b = rit->second;
printf("B %ld %ld\n", a, b);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
map<int, int> buy;
map<int, int> sell;
for (int i = 0; i < n; i++) {
char d;
int p, q;
scanf(" %c %d %d", &d, &p, &q);
if (d == 'B')
buy[p] += q;
else
sell[p] += q;
}
map<int, int>::iterator itr;
vector<pair<int, int> > arr;
for (itr = sell.begin(); itr != sell.end(); itr++) {
arr.push_back(make_pair(itr->first, itr->second));
}
sort(arr.begin(), arr.end(), greater<pair<int, int> >());
for (int i = 0; i < arr.size(); i++) {
if (arr.size() - i <= s) {
printf("S %d %d\n", arr[i].first, arr[i].second);
}
}
arr.clear();
for (itr = buy.begin(); itr != buy.end(); itr++) {
arr.push_back(make_pair(itr->first, itr->second));
}
sort(arr.begin(), arr.end(), greater<pair<int, int> >());
for (int i = 0; i < arr.size(); i++) {
if (i < s) {
printf("B %d %d\n", arr[i].first, arr[i].second);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, S;
int bArray[100011], sArray[100011];
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> S;
for (int i = 0; i < N; ++i) {
char dir;
int p, q;
cin >> dir >> p >> q;
if (dir == 'B') {
bArray[p] += q;
} else {
sArray[p] += q;
}
}
vector<pair<int, int> > Bp, Sp;
int cntB = 0, cntS = 0;
for (int i = 100000; i >= 0 && cntB < S; --i) {
if (bArray[i] != 0) {
cntB++;
Bp.push_back(make_pair(i, bArray[i]));
}
}
for (int i = 0; i < 100001 && cntS < S; ++i) {
if (sArray[i] != 0) {
cntS++;
Sp.push_back(make_pair(i, sArray[i]));
}
}
for (int i = Sp.size() - 1; i >= 0; --i) {
cout << "S " << Sp[i].first << " " << Sp[i].second << '\n';
}
for (int i = 0; i < Bp.size(); ++i) {
cout << "B " << Bp[i].first << " " << Bp[i].second << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
char c;
int pp, qq;
map<int, int> buys;
map<int, int> sells;
for (int i = 0; i < n; i++) {
cin >> c >> pp >> qq;
if (c == 'B') {
buys[pp] += qq;
} else {
sells[pp] += qq;
}
}
int p[1001], q[1001];
int psize = 0;
int qsize = 0;
map<int, int>::iterator i;
for (i = sells.begin(); i != sells.end(); i++) {
p[psize++] = (*i).first;
q[qsize++] = (*i).second;
}
if (psize < s) {
for (int i = psize - 1; i >= 0; i--)
cout << "S"
<< " " << p[i] << " " << q[i] << endl;
} else {
for (int i = s - 1; i >= 0; i--)
cout << "S"
<< " " << p[i] << " " << q[i] << endl;
}
psize = 0;
qsize = 0;
for (i = buys.begin(); i != buys.end(); i++) {
p[psize++] = (*i).first;
q[qsize++] = (*i).second;
}
for (int i = 0; i < s and i < psize; i++) {
cout << "B"
<< " " << p[psize - 1 - i] << " " << q[psize - 1 - i];
if (i + 1 < s and i + 1 < psize) cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int size;
int n;
int p;
char d;
int q;
int s;
map<int, int, greater<int> > sell, buy;
map<int, int, greater<int> >::iterator itr;
int main() {
scanf("%d%d", &n, &s);
for (int i = 0; i < n; i++) {
scanf(" %c", &d);
scanf("%d%d", &p, &q);
if (d == 'S') {
sell[p] += q;
} else if (d == 'B') {
buy[p] += q;
}
}
itr = sell.begin();
size = sell.size();
for (int i = 0; itr != sell.end(); i++) {
if (size - s <= i) {
printf("S %d %d\n", itr->first, itr->second);
}
itr++;
}
itr = buy.begin();
for (int i = 0; itr != buy.end() && i < s; i++) {
printf("B %d %d\n", itr->first, itr->second);
itr++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Order {
char d;
int p;
int q;
};
int main() {
int n, s;
Order a[1001];
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> a[i].d >> a[i].p >> a[i].q;
}
map<int, int> bmp, smp;
for (int i = 0; i < n; i++) {
if (a[i].d == 'B') {
bmp[a[i].p] += a[i].q;
} else {
smp[a[i].p] += a[i].q;
}
}
vector<pair<int, int> > bv;
for (map<int, int>::iterator it = bmp.begin(); it != bmp.end(); it++) {
bv.push_back(make_pair(it->first, it->second));
}
vector<pair<int, int> > sv;
for (map<int, int>::iterator it = smp.begin(); it != smp.end(); it++) {
sv.push_back(make_pair(it->first, it->second));
}
sort(bv.begin(), bv.end());
sort(sv.begin(), sv.end());
reverse(bv.begin(), bv.end());
int n1 = min(s, (int)bv.size());
int n2 = min(s, (int)sv.size());
vector<pair<int, int> > resv;
for (int i = 0; i < n2; i++) {
resv.push_back(sv[i]);
}
reverse(resv.begin(), resv.end());
for (int i = 0; i < n2; i++) {
cout << "S " << resv[i].first << " " << resv[i].second << "\n";
}
for (int i = 0; i < n1; i++) {
cout << "B " << bv[i].first << " " << bv[i].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s;
vector<vector<int> > aggregate;
vector<int> sell, buy;
int main() {
cin >> n >> s;
aggregate.resize(2);
aggregate[0].resize(100001);
aggregate[1].resize(100001);
for (int i = 0; i < n; i++) {
char direction;
int price, q, newdir;
cin >> direction >> price >> q;
if (direction == 'B') {
newdir = 0;
buy.push_back(price);
} else if (direction == 'S') {
newdir = 1;
sell.push_back(price);
}
aggregate[newdir][price] += q;
}
sort(buy.begin(), buy.end());
buy.erase(unique(buy.begin(), buy.end()), buy.end());
sort(sell.begin(), sell.end());
sell.erase(unique(sell.begin(), sell.end()), sell.end());
for (int i = 1; i <= s; i++) {
if (s - i < sell.size())
cout << 'S' << " " << sell[s - i] << " " << aggregate[1][sell[s - i]]
<< endl;
}
for (int i = 0; i < s && i < buy.size(); i++) {
if (buy.size() - i - 1 >= 0)
cout << 'B' << " " << buy[buy.size() - i - 1] << " "
<< aggregate[0][buy[buy.size() - i - 1]] << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.