text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct item {
string name;
char type;
int size;
int param;
bool operator<(const item &sec) const { return type < sec.type; }
} arr[1005];
int q1, q2, q3;
struct man {
string name, home;
int tough;
bool operator<(const man &sec) const { return tough > sec.tough; }
};
man r1[1005];
man r2[1005];
man r3[1005];
void output(string name) {
for (int i = 0; i < q1; i++) {
if (r1[i].home == name) {
cout << r1[i].name << " ";
}
}
for (int i = 0; i < q2; i++) {
if (r2[i].home == name) {
cout << r2[i].name << " ";
}
}
for (int i = 0; i < q3; i++) {
if (r3[i].home == name) {
cout << r3[i].name << " ";
}
}
}
int main() {
int n, m, space = 0;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
int a, d, o;
cin >> arr[i].name >> s >> a >> d >> o >> arr[i].size;
space += arr[i].size;
if (s == "weapon") {
arr[i].type = 0;
arr[i].param = a;
} else if (s == "armor") {
arr[i].type = 1;
arr[i].param = d;
} else if (s == "orb") {
arr[i].type = 2;
arr[i].param = o;
} else {
throw "Wrong format Exception";
}
}
cin >> m;
for (int i = 0; i < m; i++) {
string name;
string type;
int tough;
string home;
cin >> name >> type >> tough >> home;
if (type == "gladiator") {
r1[q1].name = name;
r1[q1].tough = tough;
r1[q1].home = home;
q1++;
} else if (type == "sentry") {
r2[q2].name = name;
r2[q2].tough = tough;
r2[q2].home = home;
q2++;
} else if (type == "physician") {
r3[q3].name = name;
r3[q3].tough = tough;
r3[q3].home = home;
q3++;
} else {
throw "Wrong format Exception";
}
}
if (space == m) {
for (int i = 0; i < q1; i++) {
for (int j = 0; j < n; j++) {
if (r1[i].home == arr[j].name && arr[j].type == 0) {
arr[j].param += r1[i].tough;
}
}
}
for (int i = 0; i < q2; i++) {
for (int j = 0; j < n; j++) {
if (r2[i].home == arr[j].name && arr[j].type == 1) {
arr[j].param += r2[i].tough;
}
}
}
for (int i = 0; i < q3; i++) {
for (int j = 0; j < n; j++) {
if (r3[i].home == arr[j].name && arr[j].type == 2) {
arr[j].param += r3[i].tough;
}
}
}
int b1 = -1, b2 = -1, b3 = -1;
for (int i = 0; i < n; i++) {
if (arr[i].type == 0) {
if (b1 == -1 || arr[b1].param < arr[i].param) {
b1 = i;
}
} else if (arr[i].type == 1) {
if (b2 == -1 || arr[b2].param < arr[i].param) {
b2 = i;
}
} else {
if (b3 == -1 || arr[b3].param < arr[i].param) {
b3 = i;
}
}
}
cout << arr[b1].name << " " << arr[b1].size << " ";
output(arr[b1].name);
cout << endl;
cout << arr[b2].name << " " << arr[b2].size << " ";
output(arr[b2].name);
cout << endl;
cout << arr[b3].name << " " << arr[b3].size << " ";
output(arr[b3].name);
cout << endl;
} else {
sort(arr, arr + n);
sort(r1, r1 + q1);
sort(r2, r2 + q2);
sort(r3, r3 + q3);
int b1 = -1, b2 = -1, b3 = -1;
for (int i = 0; i < n; i++) {
if (arr[i].type == 0) {
for (int j = 0; j < min(q1, arr[i].size); j++) {
arr[i].param += r1[j].tough;
}
if (b1 == -1 || arr[i].param > arr[b1].param) {
b1 = i;
}
} else if (arr[i].type == 1) {
for (int j = 0; j < min(q2, arr[i].size); j++) {
arr[i].param += r2[j].tough;
}
if (b2 == -1 || arr[i].param > arr[b2].param) {
b2 = i;
}
} else if (arr[i].type == 2) {
for (int j = 0; j < min(q3, arr[i].size); j++) {
arr[i].param += r3[j].tough;
}
if (b3 == -1 || arr[i].param > arr[b3].param) {
b3 = i;
}
}
}
int l1 = max(0, q1 - arr[b1].size);
int l2 = max(0, q2 - arr[b2].size);
int l3 = max(0, q3 - arr[b3].size);
int bf1 = arr[b1].size, bf2 = arr[b2].size, bf3 = arr[b3].size;
cout << arr[b1].name << " " << min(arr[b1].size, q1 + l2 + l3) << " ";
for (int i = 0; i < min(arr[b1].size, q1); i++) {
cout << r1[i].name << " ";
}
while (arr[b1].size > q1 && l2 != 0) {
cout << r2[bf2 + l2 - 1].name << " ";
arr[b1].size--;
l2--;
}
while (arr[b1].size > q1 && l3 != 0) {
cout << r3[bf3 + l3 - 1].name << " ";
arr[b1].size--;
l3--;
}
cout << endl;
cout << arr[b2].name << " " << min(arr[b2].size, q2 + l1 + l3) << " ";
for (int i = 0; i < min(arr[b2].size, q2); i++) {
cout << r2[i].name << " ";
}
while (arr[b2].size > q2 && l1 != 0) {
cout << r1[bf1 + l1 - 1].name << " ";
arr[b2].size--;
l1--;
}
while (arr[b2].size > q2 && l3 != 0) {
cout << r3[bf3 + l3 - 1].name << " ";
arr[b2].size--;
l3--;
}
cout << endl;
cout << arr[b3].name << " " << min(arr[b3].size, q3 + l1 + l2) << " ";
for (int i = 0; i < min(arr[b3].size, q3); i++) {
cout << r3[i].name << " ";
}
while (arr[b3].size > q3 && l1 != 0) {
cout << r1[bf1 + l1 - 1].name << " ";
arr[b3].size--;
l1--;
}
while (arr[b3].size > q3 && l2 != 0) {
cout << r2[bf2 + l2 - 1].name << " ";
arr[b3].size--;
l2--;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
string name;
int att, def, res, size, now;
vector<string> ans;
};
struct node3 {
int k, type;
};
struct node2 {
string name;
int id, type, data;
node3 belong;
};
node a[3][120];
node2 b[3][1200], ball[1200];
int ttp[1200], ttq[1200];
int n, m, n1, n2, n3, m1, m2, m3, nn;
int ans1, ans2, ans3;
map<string, node3> ma;
void out(int p, int k) {
int tmp;
cout << a[p][k].name << ' ' << a[p][k].now;
for (int i = 0; i < a[p][k].now; ++i) cout << ' ' << a[p][k].ans[i];
cout << endl;
}
bool cmp(node2 a, node2 b) { return a.data > b.data; }
void gao(node2 aa) {
if (a[0][ans1].now < a[0][ans1].size) {
a[0][ans1].now++;
a[0][ans1].ans.push_back(aa.name);
return;
}
if (a[1][ans2].now < a[1][ans2].size) {
a[1][ans2].now++;
a[1][ans2].ans.push_back(aa.name);
return;
}
if (a[2][ans3].now < a[2][ans3].size) {
a[2][ans3].now++;
a[2][ans3].ans.push_back(aa.name);
return;
}
}
int main() {
ma.clear();
n1 = n2 = n3 = 0;
scanf("%d", &n);
node tmp;
string type;
node3 tk;
for (int i = 1; i <= n; ++i) {
cin >> tmp.name >> type;
scanf("%d%d%d%d", &tmp.att, &tmp.def, &tmp.res, &tmp.size);
tmp.ans.clear();
tmp.now = 0;
if (type == "weapon") {
a[0][++n1] = tmp;
tk.type = 0;
tk.k = n1;
}
if (type == "armor") {
a[1][++n2] = tmp;
tk.type = 1;
tk.k = n2;
}
if (type == "orb") {
a[2][++n3] = tmp;
tk.type = 2;
tk.k = n3;
}
ma[tmp.name] = tk;
}
scanf("%d", &m);
node2 tp;
int ll;
string belong;
for (int i = 1; i <= m; ++i) {
cin >> tp.name >> type >> tp.data >> belong;
tp.id = i;
tk = ma[belong];
tp.belong = tk;
a[tk.type][tk.k].now++;
if (type == "gladiator") {
tp.type = 0;
b[0][++m1] = tp;
}
if (type == "sentry") {
tp.type = 1;
b[1][++m2] = tp;
}
if (type == "physician") {
tp.type = 2;
b[2][++m3] = tp;
}
}
sort(b[0] + 1, b[0] + m1 + 1, cmp);
sort(b[1] + 1, b[1] + m2 + 1, cmp);
sort(b[2] + 1, b[2] + m3 + 1, cmp);
bool bbi = true;
for (int i = 1; i <= n1; ++i)
if (a[0][i].size > a[0][i].now) bbi = false;
for (int i = 1; i <= n2; ++i)
if (a[1][i].size > a[1][i].now) bbi = false;
for (int i = 1; i <= n3; ++i)
if (a[2][i].size > a[2][i].now) bbi = false;
bool bi[3][1002];
memset(bi, true, sizeof(bi));
a[0][0].att = a[1][0].def = a[2][0].res = -1;
ans1 = ans2 = ans3 = 0;
if (bbi == false) {
for (int i = 1; i <= n1; ++i) {
a[0][i].now = min(m1, a[0][i].size);
for (int j = 1; j <= min(m1, a[0][i].size); ++j) {
a[0][i].ans.push_back(b[0][j].name);
a[0][i].att += b[0][j].data;
}
if (a[0][i].att > a[0][ans1].att) ans1 = i;
}
for (int i = 1; i <= n2; ++i) {
a[1][i].now = min(m2, a[1][i].size);
for (int j = 1; j <= min(m2, a[1][i].size); ++j) {
a[1][i].ans.push_back(b[1][j].name);
a[1][i].def += b[1][j].data;
}
if (a[1][i].def > a[1][ans2].def) ans2 = i;
}
for (int i = 1; i <= n3; ++i) {
a[2][i].now = min(m3, a[2][i].size);
for (int j = 1; j <= min(m3, a[2][i].size); ++j) {
a[2][i].ans.push_back(b[2][j].name);
a[2][i].res += b[2][j].data;
}
if (a[2][i].res > a[2][ans3].res) ans3 = i;
}
for (int i = 1; i <= a[0][ans1].now; ++i) bi[0][i] = false;
for (int i = 1; i <= a[1][ans2].now; ++i) bi[1][i] = false;
for (int i = 1; i <= a[2][ans3].now; ++i) bi[2][i] = false;
for (int i = 1; i <= m1; ++i)
if (bi[0][i]) gao(b[0][i]);
for (int i = 1; i <= m2; ++i)
if (bi[1][i]) gao(b[1][i]);
for (int i = 1; i <= m3; ++i)
if (bi[2][i]) gao(b[2][i]);
} else {
for (int i = 1; i <= m1; ++i) {
tk = b[0][i].belong;
a[tk.type][tk.k].ans.push_back(b[0][i].name);
if (tk.type == 0) a[tk.type][tk.k].att += b[0][i].data;
}
for (int i = 1; i <= m2; ++i) {
tk = b[1][i].belong;
a[tk.type][tk.k].ans.push_back(b[1][i].name);
if (tk.type == 1) a[tk.type][tk.k].def += b[1][i].data;
}
for (int i = 1; i <= m3; ++i) {
tk = b[2][i].belong;
a[tk.type][tk.k].ans.push_back(b[2][i].name);
if (tk.type == 2) a[tk.type][tk.k].res += b[2][i].data;
}
for (int i = 1; i <= n1; ++i)
if (a[0][i].att > a[0][ans1].att) ans1 = i;
for (int i = 1; i <= n2; ++i)
if (a[1][i].def > a[1][ans2].def) ans2 = i;
for (int i = 1; i <= n3; ++i)
if (a[2][i].res > a[2][ans3].res) ans3 = i;
}
out(0, ans1);
out(1, ans2);
out(2, ans3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int maxn = 111;
const int maxk = 1111;
const string Item[] = {"weapon", "armor", "orb"};
const string Res[] = {"gladiator", "sentry", "physician"};
struct T {
string name;
int type, score, size;
};
struct P {
string name;
int type, score, pos;
};
vector<int> have[maxn];
T A[maxn];
P B[maxk];
int N, K;
void inputData() {
cin >> N;
for (int i = 0; i < N; ++i) {
int a[3];
string CL;
cin >> A[i].name >> CL;
A[i].type = find(Item, Item + 3, CL) - Item;
for (int k = 0; k < 3; ++k) cin >> a[k];
cin >> A[i].size;
A[i].score = a[A[i].type];
}
cin >> K;
for (int i = 0; i < K; ++i) {
string CL, str;
cin >> B[i].name >> CL;
B[i].type = find(Res, Res + 3, CL) - Res;
cin >> B[i].score;
cin >> str;
for (int k = 0; k < N; ++k)
if (str == A[k].name) {
have[k].push_back(i);
B[i].pos = k;
break;
}
}
}
int score[maxn];
void Output(int x) {
cout << A[x].name << " " << (int(have[x].size()));
for (int i = 0; i < (int(have[x].size())); ++i)
cout << " " << B[have[x][i]].name;
cout << endl;
}
void calc(int type) {
int x = -1;
for (int i = 0; i < N; ++i)
if (A[i].type == type) {
score[i] = A[i].score;
for (int j = 0; j < (int(have[i].size())); ++j)
if (B[have[i][j]].type == type) {
score[i] += B[have[i][j]].score;
}
if (x == -1 || score[i] > score[x]) {
x = i;
}
}
Output(x);
}
int ans[3];
bool mark[maxk];
void solve(int type) {
vector<pair<int, int> > a;
for (int i = 0; i < K; ++i)
if (B[i].type == type) {
a.push_back(make_pair(-B[i].score, i));
}
sort(a.begin(), a.end());
int x = -1;
for (int i = 0; i < N; ++i)
if (A[i].type == type) {
score[i] = A[i].score;
have[i].clear();
for (int j = 0; j < A[i].size && j < (int(a.size())); ++j) {
score[i] += B[a[j].second].score;
have[i].push_back(a[j].second);
}
if (x == -1 || score[i] > score[x]) {
x = i;
}
}
ans[type] = x;
for (int i = 0; i < (int(have[x].size())); ++i) mark[have[x][i]] = true;
}
void main2() {
int capa = 0;
for (int i = 0; i < N; ++i) capa += A[i].size;
if (capa == K) {
for (int type = 0; type < 3; ++type) calc(type);
return;
}
memset(mark, false, sizeof mark);
for (int type = 0; type < 3; ++type) {
solve(type);
}
for (int i = 0; i < K; ++i)
if (!mark[i]) {
for (int j = 0; j < N; ++j)
if ((int(have[j].size())) < A[j].size) {
have[j].push_back(i);
break;
}
}
for (int type = 0; type < 3; ++type) {
Output(ans[type]);
}
}
int main() {
ios::sync_with_stdio(false);
inputData();
main2();
}
|
#include <bits/stdc++.h>
using namespace std;
struct item_t {
string name, cls;
int atk, def, res;
int sz;
friend istream& operator>>(istream& in, item_t& t) {
return in >> t.name >> t.cls >> t.atk >> t.def >> t.res >> t.sz;
}
};
struct person_t {
string name, type, home;
int bonus;
friend istream& operator>>(istream& in, person_t& p) {
return in >> p.name >> p.type >> p.bonus >> p.home;
}
bool operator<(const person_t& p) const {
if (bonus == p.bonus) return name < p.name;
return bonus < p.bonus;
}
};
map<string, int> item_ids;
item_t item[105];
int taken[105];
set<int> orig[105];
int base_sum[105];
map<string, int> person_ids;
person_t person[1005];
int vg[1005], sg;
int vs[1005], ss;
int vp[1005], sp;
bool matches(string s, string t) {
assert(s == "weapon" || s == "armor" || s == "orb");
assert(t == "gladiator" || t == "sentry" || t == "physician");
if (s == "weapon" && t == "gladiator") return true;
if (s == "armor" && t == "sentry") return true;
if (s == "orb" && t == "physician") return true;
return false;
}
int main() {
int N, K;
cin >> N;
for (int i = 0; i < (N); ++i) {
cin >> item[i], taken[i] = 0, item_ids[item[i].name] = i;
}
cin >> K;
for (int j = 0; j < (K); ++j) cin >> person[j];
sort(person, person + K);
reverse(person, person + K);
for (int j = 0; j < (K); ++j) {
int id = item_ids[person[j].home];
taken[id]++;
orig[id].insert(j);
if (matches(item[id].cls, person[j].type)) base_sum[id] += person[j].bonus;
}
for (int i = 0; i < (N); ++i) assert((int)orig[i].size() == taken[i]);
for (int j = 0; j < (K); ++j) person_ids[person[j].name] = j;
for (int j = 0; j < (K); ++j) {
if (person[j].type == "gladiator") {
sg++;
vg[sg] = ((sg) ? vg[(sg)-1] : 0) + person[j].bonus;
;
} else if (person[j].type == "sentry") {
ss++;
vs[ss] = ((ss) ? vs[(ss)-1] : 0) + person[j].bonus;
;
} else if (person[j].type == "physician") {
sp++;
vp[sp] = ((sp) ? vp[(sp)-1] : 0) + person[j].bonus;
;
} else {
assert(false);
}
}
assert(sg + ss + sp == K);
bool has_free = false;
for (int i = 0; i < (N); ++i) {
assert(taken[i] <= item[i].sz);
if (taken[i] < item[i].sz) has_free = true;
}
int wep = -1, wepval = 0;
int arm = -1, armval = 0;
int orb = -1, orbval = 0;
for (int i = 0; i < (N); ++i) {
if (item[i].cls == "weapon") {
int val = item[i].atk;
if (has_free)
val += vg[min(sg, item[i].sz)];
else
val += base_sum[i];
if (wep < 0 || wepval < val) wep = i, wepval = val;
} else if (item[i].cls == "armor") {
int val = item[i].def;
if (has_free)
val += vs[min(ss, item[i].sz)];
else
val += base_sum[i];
if (arm < 0 || armval < val) arm = i, armval = val;
} else if (item[i].cls == "orb") {
int val = item[i].res;
if (has_free)
val += vp[min(sp, item[i].sz)];
else
val += base_sum[i];
if (orb < 0 || orbval < val) orb = i, orbval = val;
} else {
assert(false);
}
}
if (!has_free) {
cout << item[wep].name << " " << taken[wep];
for (set<int>::iterator it = orig[wep].begin(); it != orig[wep].end(); it++)
cout << " " << person[*it].name;
cout << endl;
cout << item[arm].name << " " << taken[arm];
for (set<int>::iterator it = orig[arm].begin(); it != orig[arm].end(); it++)
cout << " " << person[*it].name;
cout << endl;
cout << item[orb].name << " " << taken[orb];
for (set<int>::iterator it = orig[orb].begin(); it != orig[orb].end(); it++)
cout << " " << person[*it].name;
cout << endl;
} else {
set<int> pwep, parm, porb, leftover;
for (int j = 0; j < (K); ++j) {
if (person[j].type == "gladiator") {
if ((int)pwep.size() < item[wep].sz)
pwep.insert(j);
else
leftover.insert(j);
} else if (person[j].type == "sentry") {
if ((int)parm.size() < item[arm].sz)
parm.insert(j);
else
leftover.insert(j);
} else if (person[j].type == "physician") {
if ((int)porb.size() < item[orb].sz)
porb.insert(j);
else
leftover.insert(j);
} else {
assert(false);
}
}
for (set<int>::iterator it = leftover.begin(); it != leftover.end(); ++it) {
int j = *it;
if ((int)pwep.size() < item[wep].sz)
pwep.insert(j);
else if ((int)parm.size() < item[arm].sz)
parm.insert(j);
else if ((int)porb.size() < item[orb].sz)
porb.insert(j);
}
cout << item[wep].name << " " << pwep.size();
for (set<int>::iterator it = pwep.begin(); it != pwep.end(); it++)
cout << " " << person[*it].name;
cout << endl;
cout << item[arm].name << " " << parm.size();
for (set<int>::iterator it = parm.begin(); it != parm.end(); it++)
cout << " " << person[*it].name;
cout << endl;
cout << item[orb].name << " " << porb.size();
for (set<int>::iterator it = porb.begin(); it != porb.end(); it++)
cout << " " << person[*it].name;
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const string CLASES[] = {"weapon", "armor", "orb"};
const string BICHOS[] = {"gladiator", "sentry", "physician"};
int n, m, clase[104], skill[3][104], sup[104], libre[104];
map<string, int> name, bicho;
map<int, string> inv;
set<pair<int, string> > monst[3];
int main() {
name.clear();
inv.clear();
bicho.clear();
for (int i = 0; i < (3); ++i) monst[i].clear();
cin >> n;
for (int i = 0; i < (n); ++i) {
string str;
cin >> str;
int pos = name.size();
name[str] = pos;
inv[pos] = str;
cin >> str >> skill[0][pos] >> skill[1][pos] >> skill[2][pos] >> sup[pos];
libre[pos] = sup[pos];
for (int i = 0; i < (3); ++i)
if (CLASES[i] == str) clase[pos] = i;
}
cin >> m;
for (int i = 0; i < (m); ++i) {
string nome, tipo, casa;
int bonus;
cin >> nome >> tipo >> bonus >> casa;
int id = name[casa];
libre[id]--;
bicho[nome] = id;
for (int i = 0; i < (3); ++i)
if (BICHOS[i] == tipo) monst[i].insert(make_pair(bonus, nome));
}
bool espacio = false;
for (int i = 0; i < (n); ++i)
if (libre[i] > 0) espacio = true;
if (!espacio)
for (int i = 0; i < (3); ++i) {
for (typeof((monst[i]).begin()) it = (monst[i]).begin();
it != (monst[i]).end(); ++it)
skill[i][bicho[it->second]] += it->first;
int pb = 0, best = 0;
for (int j = 0; j < (n); ++j)
if (clase[j] == i) {
if (best < skill[i][j]) {
best = skill[i][j];
pb = j;
}
}
cout << inv[pb] << " ";
set<string> ms;
for (int k = 0; k < (3); ++k)
for (typeof((monst[k]).begin()) it = (monst[k]).begin();
it != (monst[k]).end(); ++it)
if (bicho[it->second] == pb) ms.insert(it->second);
cout << ms.size();
for (typeof((ms).begin()) it = (ms).begin(); it != (ms).end(); ++it)
cout << " " << *it;
cout << endl;
}
else {
string rets[3];
set<string> ms[3];
int cc[3];
for (int i = 0; i < (3); ++i) {
int pb = 0, best = 0;
for (int j = 0; j < (n); ++j)
if (clase[j] == i) {
int plus = 0, count = sup[j];
for (typeof((monst[i]).rbegin()) it = (monst[i]).rbegin();
it != (monst[i]).rend(); ++it) {
if (count == 0) break;
count--;
plus += it->first;
}
if (plus + skill[i][j] > best) {
best = plus + skill[i][j];
pb = j;
}
}
rets[i] = inv[pb];
cc[i] = sup[pb];
for (typeof((monst[i]).rbegin()) it = (monst[i]).rbegin();
it != (monst[i]).rend(); ++it) {
if (cc[i] == 0) break;
cc[i]--;
ms[i].insert(it->second);
}
}
for (int i = 0; i < (3); ++i) {
for (int j = 0; j < (3); ++j)
for (typeof((monst[j]).begin()) it = (monst[j]).begin();
it != (monst[j]).end(); ++it) {
if (cc[i] == 0) break;
bool puedo = true;
for (int k = 0; k < (3); ++k)
if (ms[k].count(it->second)) puedo = false;
if (!puedo) continue;
ms[i].insert(it->second);
cc[i]--;
}
cout << rets[i] << " " << ms[i].size();
for (typeof((ms[i]).begin()) it = (ms[i]).begin(); it != (ms[i]).end();
++it)
cout << " " << *it;
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
string name;
int param;
int size;
item(const string& n, int p, int s) : name(n), param(p), size(s) {}
};
struct resident {
string name;
int bonus;
string home;
resident(const string& n, int b, const string& h)
: name(n), bonus(b), home(h) {}
bool operator>(const resident& that) const { return bonus > that.bonus; }
};
int main() {
int n;
cin >> n;
vector<item> items[3];
int total_size = 0;
for (int i = 0; i < n; i++) {
string name, type;
int atk, def, res, size;
cin >> name >> type >> atk >> def >> res >> size;
if (type == "weapon") {
items[0].push_back(item(name, atk, size));
} else if (type == "armor") {
items[1].push_back(item(name, def, size));
} else {
items[2].push_back(item(name, res, size));
}
total_size += size;
}
int k;
cin >> k;
if (k == total_size) {
map<string, pair<int, vector<string> > > ms[3];
for (int i = 0; i < 3; i++) {
for (vector<item>::const_iterator it = items[i].begin();
it != items[i].end(); ++it) {
ms[i].insert(
make_pair(it->name, make_pair(it->param, vector<string>())));
}
}
for (int i = 0; i < k; i++) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
if (ms[0].count(home)) {
if (type == "gladiator") {
ms[0][home].first += bonus;
}
ms[0][home].second.push_back(name);
} else if (ms[1].count(home)) {
if (type == "sentry") {
ms[1][home].first += bonus;
}
ms[1][home].second.push_back(name);
} else {
if (type == "physician") {
ms[2][home].first += bonus;
}
ms[2][home].second.push_back(name);
}
}
int params[3] = {0, 0, 0};
string keys[3];
vector<string> ans[3];
for (int i = 0; i < 3; i++) {
for (map<string, pair<int, vector<string> > >::const_iterator it =
ms[i].begin();
it != ms[i].end(); ++it) {
if (it->second.first > params[i]) {
params[i] = it->second.first;
keys[i] = it->first;
ans[i] = it->second.second;
}
}
}
for (int i = 0; i < 3; i++) {
cout << keys[i] << ' ' << ans[i].size();
for (vector<string>::const_iterator it = ans[i].begin();
it != ans[i].end(); ++it) {
cout << ' ' << *it;
}
cout << endl;
}
} else {
vector<resident> rs[3];
for (int i = 0; i < k; i++) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
if (type == "gladiator") {
rs[0].push_back(resident(name, bonus, home));
} else if (type == "sentry") {
rs[1].push_back(resident(name, bonus, home));
} else {
rs[2].push_back(resident(name, bonus, home));
}
}
for (int i = 0; i < 3; i++) {
sort(rs[i].begin(), rs[i].end(), greater<resident>());
}
int max_params[3] = {-1, -1, -1};
vector<item>::const_iterator ans_iter[3];
vector<string> ans[3];
vector<resident>::const_iterator jts[3];
for (int i = 0; i < 3; i++) {
for (vector<item>::const_iterator it = items[i].begin();
it != items[i].end(); ++it) {
vector<resident>::const_iterator jt = rs[i].begin();
int param = it->param;
vector<string> tmp;
while (tmp.size() < it->size && jt != rs[i].end()) {
param += jt->bonus;
tmp.push_back(jt->name);
++jt;
}
if (param > max_params[i]) {
max_params[i] = param;
ans_iter[i] = it;
ans[i] = tmp;
jts[i] = jt;
}
}
}
for (int i = 0; i < 3; i++) {
while (ans[i].size() < ans_iter[i]->size &&
(jts[0] != rs[0].end() || jts[1] != rs[1].end() ||
jts[2] != rs[2].end())) {
if (jts[0] != rs[0].end()) {
ans[i].push_back(jts[0]->name);
++jts[0];
} else if (jts[1] != rs[1].end()) {
ans[i].push_back(jts[1]->name);
++jts[1];
} else if (jts[2] != rs[2].end()) {
ans[i].push_back(jts[2]->name);
++jts[2];
}
}
cout << ans_iter[i]->name << ' ' << ans[i].size();
for (vector<string>::const_iterator it = ans[i].begin();
it != ans[i].end(); ++it) {
cout << ' ' << *it;
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool MOVE = false;
struct hero {
string name;
int val, size;
vector<string> live, use;
hero(string _name = "", int _val = 0, int _size = 0) {
name = _name;
val = _val;
size = _size;
}
};
struct power {
string name;
int val;
power(string _name = "", int _val = 0) {
name = _name;
val = _val;
}
bool operator<(const power& w) const { return val > w.val; }
};
int n, m;
vector<hero> H[3];
vector<power> P[3];
map<string, int> INP[3];
map<string, pair<int, int> > POS;
vector<string> ALL;
int PALL = 0;
void read() {
cin >> n;
for (int i = 0; i < n; ++i) {
string name, type;
int pw, pa, po, size;
cin >> name >> type >> pw >> pa >> po >> size;
if (type == "weapon") {
H[0].push_back(hero(name, pw, size));
POS[name] = make_pair(0, H[0].size() - 1);
}
if (type == "armor") {
H[1].push_back(hero(name, pa, size));
POS[name] = make_pair(1, H[1].size() - 1);
}
if (type == "orb") {
H[2].push_back(hero(name, po, size));
POS[name] = make_pair(2, H[2].size() - 1);
}
}
cin >> m;
for (int i = 0; i < m; ++i) {
string name, type, place;
int val;
cin >> name >> type >> val >> place;
ALL.push_back(name);
H[POS[place].first][POS[place].second].live.push_back(name);
if (type == "gladiator") {
P[0].push_back(power(name, val));
INP[0][name] = val;
}
if (type == "sentry") {
P[1].push_back(power(name, val));
INP[1][name] = val;
}
if (type == "physician") {
P[2].push_back(power(name, val));
INP[2][name] = val;
}
}
sort(P[0].begin(), P[0].end());
sort(P[1].begin(), P[1].end());
sort(P[2].begin(), P[2].end());
for (int i = 0; i < H[0].size(); ++i)
if (H[0][i].live.size() < H[0][i].size) MOVE = true;
for (int i = 0; i < H[1].size(); ++i)
if (H[1][i].live.size() < H[1][i].size) MOVE = true;
for (int i = 0; i < H[2].size(); ++i)
if (H[2][i].live.size() < H[2][i].size) MOVE = true;
}
hero BW("", -1), BA("", -1), BO("", -1);
hero POWER_WEAPON(hero w) {
for (int i = 0; i < P[0].size(); ++i) {
if (w.use.size() >= w.size) break;
w.val += P[0][i].val;
w.use.push_back(P[0][i].name);
}
return w;
}
hero POWER_ARMOR(hero w) {
for (int i = 0; i < P[1].size(); ++i) {
if (w.use.size() >= w.size) break;
w.val += P[1][i].val;
w.use.push_back(P[1][i].name);
}
return w;
}
hero POWER_ORB(hero w) {
for (int i = 0; i < P[2].size(); ++i) {
if (w.use.size() >= w.size) break;
w.val += P[2][i].val;
w.use.push_back(P[2][i].name);
}
return w;
}
set<string> BAN;
int main() {
read();
if (!MOVE) {
for (int i = 0; i < H[0].size(); ++i)
for (int j = 0; j < H[0][i].live.size(); ++j)
H[0][i].val += INP[0][H[0][i].live[j]];
for (int i = 0; i < H[1].size(); ++i)
for (int j = 0; j < H[1][i].live.size(); ++j)
H[1][i].val += INP[1][H[1][i].live[j]];
for (int i = 0; i < H[2].size(); ++i)
for (int j = 0; j < H[2][i].live.size(); ++j)
H[2][i].val += INP[2][H[2][i].live[j]];
for (int i = 0; i < H[0].size(); ++i)
if (BW.val < H[0][i].val) BW = H[0][i];
for (int i = 0; i < H[1].size(); ++i)
if (BA.val < H[1][i].val) BA = H[1][i];
for (int i = 0; i < H[2].size(); ++i)
if (BO.val < H[2][i].val) BO = H[2][i];
cout << BW.name << ' ' << BW.live.size();
for (int i = 0; i < BW.live.size(); ++i) cout << ' ' << BW.live[i];
cout << '\n';
cout << BA.name << ' ' << BA.live.size();
for (int i = 0; i < BA.live.size(); ++i) cout << ' ' << BA.live[i];
cout << '\n';
cout << BO.name << ' ' << BO.live.size();
for (int i = 0; i < BO.live.size(); ++i) cout << ' ' << BO.live[i];
cout << '\n';
} else {
for (int i = 0; i < H[0].size(); ++i) {
hero neo = POWER_WEAPON(H[0][i]);
if (neo.val > BW.val) BW = neo;
}
for (int i = 0; i < H[1].size(); ++i) {
hero neo = POWER_ARMOR(H[1][i]);
if (neo.val > BA.val) BA = neo;
}
for (int i = 0; i < H[2].size(); ++i) {
hero neo = POWER_ORB(H[2][i]);
if (neo.val > BO.val) BO = neo;
}
for (int i = 0; i < BW.use.size(); ++i) BAN.insert(BW.use[i]);
for (int i = 0; i < BA.use.size(); ++i) BAN.insert(BA.use[i]);
for (int i = 0; i < BO.use.size(); ++i) BAN.insert(BO.use[i]);
while (BW.use.size() < BW.size && PALL < ALL.size()) {
if (BAN.count(ALL[PALL])) {
++PALL;
continue;
}
BW.use.push_back(ALL[PALL]);
++PALL;
}
while (BA.use.size() < BA.size && PALL < ALL.size()) {
if (BAN.count(ALL[PALL])) {
++PALL;
continue;
}
BA.use.push_back(ALL[PALL]);
++PALL;
}
while (BO.use.size() < BO.size && PALL < ALL.size()) {
if (BAN.count(ALL[PALL])) {
++PALL;
continue;
}
BO.use.push_back(ALL[PALL]);
++PALL;
}
cout << BW.name << ' ' << BW.use.size();
for (int i = 0; i < BW.use.size(); ++i) cout << ' ' << BW.use[i];
cout << '\n';
cout << BA.name << ' ' << BA.use.size();
for (int i = 0; i < BA.use.size(); ++i) cout << ' ' << BA.use[i];
cout << '\n';
cout << BO.name << ' ' << BO.use.size();
for (int i = 0; i < BO.use.size(); ++i) cout << ' ' << BO.use[i];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, pair<int, int> > weapons, armors, orbs;
map<string, pair<int, int> >::iterator it;
map<string, string> homes;
map<string, string>::iterator it1;
vector<pair<int, string> > glads, sentrs, phys;
map<string, int> itemsmap;
map<string, int> itemstype;
string answ, ansa, anso;
vector<string> answitems, ansaitems, ansoitems, nonused;
int main(void) {
int i, n, m, totalsize, cur, val, a, b, c, d, bonus;
string home, name, type;
cin >> n;
totalsize = 0;
for (i = 0; i < n; i++) {
cin >> name >> type >> a >> b >> c >> d;
if (type == "weapon") {
weapons[name] = make_pair(a, d);
} else if (type == "armor") {
armors[name] = make_pair(b, d);
} else {
orbs[name] = make_pair(c, d);
}
totalsize += d;
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> name >> type >> bonus >> home;
homes[name] = home;
itemsmap[name] = bonus;
if (type == "gladiator") {
glads.push_back(make_pair(bonus, name));
itemstype[name] = 0;
} else if (type == "sentry") {
sentrs.push_back(make_pair(bonus, name));
itemstype[name] = 1;
} else {
phys.push_back(make_pair(bonus, name));
itemstype[name] = 2;
}
}
if (totalsize == m) {
val = -1;
for (it = weapons.begin(); it != weapons.end(); it++) {
cur = (it->second).first;
for (it1 = homes.begin(); it1 != homes.end(); it1++) {
if (it1->second == it->first) {
if (itemstype[it1->first] == 0) {
cur += itemsmap[it1->first];
}
}
}
if (val < cur) {
val = cur;
answ = it->first;
}
}
val = -1;
for (it = armors.begin(); it != armors.end(); it++) {
cur = (it->second).first;
for (it1 = homes.begin(); it1 != homes.end(); it1++) {
if (it1->second == it->first) {
if (itemstype[it1->first] == 1) {
cur += itemsmap[it1->first];
}
}
}
if (val < cur) {
val = cur;
ansa = it->first;
}
}
val = -1;
for (it = orbs.begin(); it != orbs.end(); it++) {
cur = (it->second).first;
for (it1 = homes.begin(); it1 != homes.end(); it1++) {
if (it1->second == it->first) {
if (itemstype[it1->first] == 2) {
cur += itemsmap[it1->first];
}
}
}
if (val < cur) {
val = cur;
anso = it->first;
}
}
cout << answ << " " << weapons[answ].second << " ";
for (it1 = homes.begin(); it1 != homes.end(); it1++) {
if (it1->second == answ) {
cout << it1->first << " ";
}
}
cout << endl;
cout << ansa << " " << armors[ansa].second << " ";
for (it1 = homes.begin(); it1 != homes.end(); it1++) {
if (it1->second == ansa) {
cout << it1->first << " ";
}
}
cout << endl;
cout << anso << " " << orbs[anso].second << " ";
for (it1 = homes.begin(); it1 != homes.end(); it1++) {
if (it1->second == anso) {
cout << it1->first << " ";
}
}
cout << endl;
return 0;
}
sort(glads.rbegin(), glads.rend());
sort(sentrs.rbegin(), sentrs.rend());
sort(phys.rbegin(), phys.rend());
val = -1;
for (it = weapons.begin(); it != weapons.end(); it++) {
cur = (it->second).first;
for (i = 0; i < (min((it->second).second, (int)glads.size())); i++) {
cur += glads[i].first;
}
if (val < cur) {
val = cur;
answ = it->first;
}
}
val = -1;
for (it = armors.begin(); it != armors.end(); it++) {
cur = (it->second).first;
for (i = 0; i < (min((it->second).second, (int)sentrs.size())); i++) {
cur += sentrs[i].first;
}
if (val < cur) {
val = cur;
ansa = it->first;
}
}
val = -1;
for (it = orbs.begin(); it != orbs.end(); it++) {
cur = (it->second).first;
for (i = 0; i < (min((it->second).second, (int)phys.size())); i++) {
cur += phys[i].first;
}
if (val < cur) {
val = cur;
anso = it->first;
}
}
for (i = 0; i < glads.size(); i++) {
if (i < weapons[answ].second) {
answitems.push_back(glads[i].second);
} else {
nonused.push_back(glads[i].second);
}
}
for (i = 0; i < sentrs.size(); i++) {
if (i < armors[ansa].second) {
ansaitems.push_back(sentrs[i].second);
} else {
nonused.push_back(sentrs[i].second);
}
}
for (i = 0; i < phys.size(); i++) {
if (i < orbs[anso].second) {
ansoitems.push_back(phys[i].second);
} else {
nonused.push_back(phys[i].second);
}
}
int j = 0;
while (j < nonused.size() && answitems.size() < weapons[answ].second) {
answitems.push_back(nonused[j++]);
}
while (j < nonused.size() && ansaitems.size() < armors[ansa].second) {
ansaitems.push_back(nonused[j++]);
}
while (j < nonused.size() && ansoitems.size() < orbs[anso].second) {
ansoitems.push_back(nonused[j++]);
}
cout << answ << " " << answitems.size() << " ";
for (i = 0; i < answitems.size(); i++) {
cout << answitems[i] << " ";
}
cout << endl;
cout << ansa << " " << ansaitems.size() << " ";
for (i = 0; i < ansaitems.size(); i++) {
cout << ansaitems[i] << " ";
}
cout << endl;
cout << anso << " " << ansoitems.size() << " ";
for (i = 0; i < ansoitems.size(); i++) {
cout << ansoitems[i] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Resident {
string name_;
int inc_;
int val_;
Resident(string name, string tipe, int val) {
name_ = name;
val_ = val;
if (tipe == "gladiator") {
inc_ = 0;
} else if (tipe == "sentry") {
inc_ = 1;
} else {
inc_ = 2;
}
used_ = 0;
}
int used_;
};
struct Item {
string name_;
int jenis_;
int stats_[4];
int size_;
Item(string name, string c, int atk, int def, int res, int uk) {
name_ = name;
if (c == "weapon")
jenis_ = 0;
else if (c == "armor")
jenis_ = 1;
else
jenis_ = 2;
stats_[0] = atk;
stats_[1] = def;
stats_[2] = res;
size_ = uk;
}
vector<Resident*> isi_;
};
map<string, Item*> mit;
map<string, Resident*> mres;
void Print(Item* barang) {
cout << barang->name_ << " " << ((int)barang->isi_.size());
for (int(i) = 0; (i) < (((int)barang->isi_.size())); ++(i)) {
cout << " " << barang->isi_[i]->name_;
}
cout << endl;
}
vector<Resident*> residents;
vector<Item*> items;
Item* a[3];
vector<pair<int, string> > resort[3];
int main() {
int item, resident;
cin >> item;
for (int(i) = 0; (i) < (item); ++(i)) {
string nama, tipe;
int atk, def, res, uk;
cin >> nama >> tipe >> atk >> def >> res >> uk;
mit[nama] = new Item(nama, tipe, atk, def, res, uk);
items.push_back(mit[nama]);
}
cin >> resident;
for (int(i) = 0; (i) < (resident); ++(i)) {
string nama, tipe;
int val;
string origin;
cin >> nama >> tipe >> val >> origin;
mres[nama] = new Resident(nama, tipe, val);
residents.push_back(mres[nama]);
mit[origin]->isi_.push_back(mres[nama]);
resort[mres[nama]->inc_].push_back(
make_pair(mres[nama]->val_, mres[nama]->name_));
}
int isfull = 1;
for (int(i) = 0; (i) < (item); ++(i)) {
if (items[i]->size_ != ((int)items[i]->isi_.size())) {
isfull = 0;
}
}
if (isfull) {
vector<int> best(3, -1);
vector<string> ret(3, "-1");
for (int(i) = 0; (i) < (item); ++(i)) {
Item* itu = items[i];
for (int(j) = 0; (j) < (((int)itu->isi_.size())); ++(j)) {
Resident* res = itu->isi_[j];
itu->stats_[res->inc_] += res->val_;
}
}
for (int(i) = 0; (i) < (item); ++(i))
for (int(j) = 0; (j) < (item); ++(j))
for (int(k) = 0; (k) < (item); ++(k)) {
if (i == j || j == k || k == i) continue;
if (items[i]->jenis_ != 0 || items[j]->jenis_ != 1 ||
items[k]->jenis_ != 2)
continue;
vector<int> attr;
attr.push_back(items[i]->stats_[0]);
attr.push_back(items[j]->stats_[1]);
attr.push_back(items[k]->stats_[2]);
if (attr > best) {
best = attr;
ret[0] = items[i]->name_;
ret[1] = items[j]->name_;
ret[2] = items[k]->name_;
}
}
Print(mit[ret[0]]);
Print(mit[ret[1]]);
Print(mit[ret[2]]);
} else {
for (int(i) = 0; (i) < (3); ++(i)) sort(resort[i].begin(), resort[i].end());
for (int(i) = 0; (i) < (3); ++(i))
reverse(resort[i].begin(), resort[i].end());
for (int(i) = 0; (i) < (item); ++(i)) items[i]->isi_.clear();
for (int(i) = 0; (i) < (item); ++(i)) {
Item* it = items[i];
for (int(j) = 0; (j) < (min(it->size_, ((int)resort[it->jenis_].size())));
++(j)) {
it->isi_.push_back(mres[resort[it->jenis_][j].second]);
it->stats_[mres[resort[it->jenis_][j].second]->inc_] +=
mres[resort[it->jenis_][j].second]->val_;
}
}
vector<int> best(3, -1);
vector<string> ret(3, "-1");
for (int(i) = 0; (i) < (item); ++(i))
for (int(j) = 0; (j) < (item); ++(j))
for (int(k) = 0; (k) < (item); ++(k)) {
if (i == j || j == k || k == i) continue;
if (items[i]->jenis_ != 0 || items[j]->jenis_ != 1 ||
items[k]->jenis_ != 2)
continue;
vector<int> attr;
attr.push_back(items[i]->stats_[0]);
attr.push_back(items[j]->stats_[1]);
attr.push_back(items[k]->stats_[2]);
if (attr > best) {
best = attr;
ret[0] = items[i]->name_;
ret[1] = items[j]->name_;
ret[2] = items[k]->name_;
}
}
for (int(i) = 0; (i) < (3); ++(i)) {
Item* it = mit[ret[i]];
for (int(j) = 0; (j) < (((int)it->isi_.size())); ++(j)) {
it->isi_[j]->used_ = 1;
}
}
vector<Item*> ass(3);
for (int(i) = 0; (i) < (3); ++(i)) ass[i] = mit[ret[i]];
for (int(i) = 0; (i) < (resident); ++(i)) {
Resident* res = residents[i];
if (res->used_) continue;
for (int(j) = 0; (j) < (3); ++(j)) {
if (ass[j]->size_ == ((int)ass[j]->isi_.size())) continue;
ass[j]->isi_.push_back(res);
break;
}
}
Print(ass[0]);
Print(ass[1]);
Print(ass[2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int s[3][1001], par[1001], cur[1001], was[1001];
string item[100], name[1000], type[100], clss[1000];
int atk[100], def[100], res[100], num[100], cnt[100];
vector<pair<int, int> > v[3];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> item[i] >> type[i] >> atk[i] >> def[i] >> res[i] >> num[i];
cin >> m;
for (int i = 0; i < m; i++) {
string tmp;
cin >> name[i] >> clss[i] >> par[i] >> tmp;
int nc;
if (clss[i] == "gladiator") nc = 0;
if (clss[i] == "sentry") nc = 1;
if (clss[i] == "physician") nc = 2;
v[nc].push_back(make_pair(par[i], i));
for (int j = 0; j < n; j++)
if (tmp == item[j]) {
cnt[j]++;
cur[i] = j;
}
}
int free = 0;
for (int i = 0; i < n; i++)
if (cnt[i] < num[i]) free = 1;
if (free) {
for (int i = 0; i < 3; i++) {
sort((v[i]).begin(), (v[i]).end());
reverse((v[i]).begin(), (v[i]).end());
}
s[0][0] = s[1][0] = s[2][0];
for (int j = 0; j < 3; j++)
for (int i = 0; i < ((int)(v[j]).size()); i++)
s[j][i + 1] = s[j][i] + v[j][i].first;
int a1 = -1, a2 = -1, a3 = -1, b1 = 0, b2 = 0, b3 = 0;
for (int i = 0; i < n; i++)
if (type[i] == "weapon")
for (int j = 0; j < n; j++)
if (type[j] == "armor")
for (int k = 0; k < n; k++)
if (type[k] == "orb") {
int c1 = atk[i] + s[0][min(((int)(v[0]).size()), num[i])];
int c2 = def[j] + s[1][min(((int)(v[1]).size()), num[j])];
int c3 = res[k] + s[2][min(((int)(v[2]).size()), num[k])];
if (c1 > a1 || c1 == a1 && c2 > a2 ||
c1 == a1 && c2 == a2 && c3 > a3) {
a1 = c1;
a2 = c2;
a3 = c3;
b1 = i;
b2 = j;
b3 = k;
}
}
int rem = m;
for (int i = 0; i < min(num[b1], ((int)(v[0]).size())); i++, rem--)
was[v[0][i].second] = 1;
for (int i = 0; i < min(num[b2], ((int)(v[1]).size())); i++, rem--)
was[v[1][i].second] = 1;
for (int i = 0; i < min(num[b3], ((int)(v[2]).size())); i++, rem--)
was[v[2][i].second] = 1;
int tmp = min(num[b1], ((int)(v[0]).size()));
cout << item[b1] << " " << tmp + min(num[b1] - tmp, rem);
for (int i = 0; i < num[b1] && i < ((int)(v[0]).size()); i++)
cout << " " << name[v[0][i].second];
for (int i = 0; i < m && tmp < num[b1]; i++)
if (was[i] == 0) {
was[i] = 1;
tmp++;
rem--;
cout << " " << name[i];
}
cout << endl;
tmp = min(num[b2], ((int)(v[1]).size()));
cout << item[b2] << " " << tmp + min(num[b2] - tmp, rem);
for (int i = 0; i < num[b2] && i < ((int)(v[1]).size()); i++)
cout << " " << name[v[1][i].second];
for (int i = 0; i < m && tmp < num[b2]; i++)
if (was[i] == 0) {
was[i] = 1;
tmp++;
rem--;
cout << " " << name[i];
}
cout << endl;
tmp = min(num[b3], ((int)(v[2]).size()));
cout << item[b3] << " " << tmp + min(num[b3] - tmp, rem);
for (int i = 0; i < num[b3] && i < ((int)(v[2]).size()); i++)
cout << " " << name[v[2][i].second];
for (int i = 0; i < m && tmp < num[b3]; i++)
if (was[i] == 0) {
was[i] = 1;
tmp++;
rem--;
cout << " " << name[i];
}
cout << endl;
} else {
for (int i = 0; i < ((int)(v[0]).size()); i++)
atk[cur[v[0][i].second]] += v[0][i].first;
for (int i = 0; i < ((int)(v[1]).size()); i++)
def[cur[v[1][i].second]] += v[1][i].first;
for (int i = 0; i < ((int)(v[2]).size()); i++)
res[cur[v[2][i].second]] += v[2][i].first;
int a1 = -1, a2 = -1, a3 = -1, b1 = 0, b2 = 0, b3 = 0;
for (int i = 0; i < n; i++)
if (type[i] == "weapon")
for (int j = 0; j < n; j++)
if (type[j] == "armor")
for (int k = 0; k < n; k++)
if (type[k] == "orb") {
int c1 = atk[i];
int c2 = def[j];
int c3 = res[k];
if (c1 > a1 || c1 == a1 && c2 > a2 ||
c1 == a1 && c2 == a2 && c3 > a3) {
a1 = c1;
a2 = c2;
a3 = c3;
b1 = i;
b2 = j;
b3 = k;
}
}
cout << item[b1] << " " << num[b1];
for (int i = 0; i < m; i++)
if (cur[i] == b1) cout << " " << name[i];
cout << endl;
cout << item[b2] << " " << num[b2];
for (int i = 0; i < m; i++)
if (cur[i] == b2) cout << " " << name[i];
cout << endl;
cout << item[b3] << " " << num[b3];
for (int i = 0; i < m; i++)
if (cur[i] == b3) cout << " " << name[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct resident {
string name, type, home;
int idx, bonus;
resident(int n1) {
idx = n1;
cin >> name >> type >> bonus >> home;
}
};
struct item {
string name, type;
int atk, def, res;
int size;
item() { cin >> name >> type >> atk >> def >> res >> size; }
int getScore(vector<resident> v) {
int score = 0;
if (type == "weapon")
score = atk;
else if (type == "armor")
score = def;
else
score = res;
for (int i = 0; i < v.size(); i++) {
if (type == "weapon" && v[i].type == "gladiator")
score += v[i].bonus;
else if (type == "armor" && v[i].type == "sentry")
score += v[i].bonus;
else if (type == "orb" && v[i].type == "physician")
score += v[i].bonus;
}
return score;
}
void show(vector<resident> v) {
cout << name << " " << v.size();
for (int i = 0; i < v.size(); i++) cout << " " << v[i].name;
cout << endl;
}
};
vector<item> items;
vector<resident> residents;
bool orden(int a, int b) { return residents[a].bonus > residents[b].bonus; }
int main() {
int n, k;
while (cin >> n) {
items.clear();
residents.clear();
vector<int> W, A, O;
int total = 0;
map<string, int> itemIndex;
for (int i = 0; i < n; i++) {
items.push_back(item());
if (items[i].type == "weapon")
W.push_back(i);
else if (items[i].type == "armor")
A.push_back(i);
else
O.push_back(i);
itemIndex[items[i].name] = i;
total += items[i].size;
}
vector<vector<resident> > adj(n);
cin >> k;
vector<int> G, S, P;
for (int i = 0; i < k; i++) {
residents.push_back(resident(i));
if (residents[i].type == "gladiator")
G.push_back(i);
else if (residents[i].type == "sentry")
S.push_back(i);
else
P.push_back(i);
adj[itemIndex[residents[i].home]].push_back(residents[i]);
}
if (total == k) {
int wIndex = -1, aIndex = -1, oIndex = -1;
int maxAtk = -1, maxDef = -1, maxRes = -1;
for (int i = 0; i < W.size(); i++) {
int atk = items[W[i]].getScore(adj[W[i]]);
if (atk > maxAtk) {
wIndex = W[i];
maxAtk = atk;
}
}
for (int j = 0; j < A.size(); j++) {
int def = items[A[j]].getScore(adj[A[j]]);
if (def > maxDef) {
aIndex = A[j];
maxDef = def;
}
}
for (int k = 0; k < O.size(); k++) {
int res = items[O[k]].getScore(adj[O[k]]);
if (res > maxRes) {
oIndex = O[k];
maxRes = res;
}
}
items[wIndex].show(adj[wIndex]);
items[aIndex].show(adj[aIndex]);
items[oIndex].show(adj[oIndex]);
} else {
sort(G.begin(), G.end(), orden);
sort(S.begin(), S.end(), orden);
sort(P.begin(), P.end(), orden);
int wIndex = -1, aIndex = -1, oIndex = -1;
int maxAtk = -1, maxDef = -1, maxRes = -1;
vector<resident> g, s, p;
for (int i = 0; i < W.size(); i++) {
vector<resident> tmp;
for (int j = 0; j < min((int)G.size(), items[W[i]].size); j++)
tmp.push_back(residents[G[j]]);
int score = items[W[i]].getScore(tmp);
if (score > maxAtk) {
wIndex = W[i];
maxAtk = score;
g = tmp;
}
}
for (int i = 0; i < A.size(); i++) {
vector<resident> tmp;
for (int j = 0; j < min((int)S.size(), items[A[i]].size); j++)
tmp.push_back(residents[S[j]]);
int score = items[A[i]].getScore(tmp);
if (score > maxDef) {
aIndex = A[i];
maxDef = score;
s = tmp;
}
}
for (int i = 0; i < O.size(); i++) {
vector<resident> tmp;
for (int j = 0; j < min((int)P.size(), items[O[i]].size); j++)
tmp.push_back(residents[P[j]]);
int score = items[O[i]].getScore(tmp);
if (score > maxRes) {
oIndex = O[i];
maxRes = score;
p = tmp;
}
}
vector<bool> used(k, 0);
for (int i = 0; i < g.size(); i++) used[g[i].idx] = 1;
for (int i = 0; i < s.size(); i++) used[s[i].idx] = 1;
for (int i = 0; i < p.size(); i++) used[p[i].idx] = 1;
for (int i = 0; i < k; i++) {
if (!used[i]) {
if (items[wIndex].size > g.size())
g.push_back(residents[i]);
else if (items[aIndex].size > s.size())
s.push_back(residents[i]);
else if (items[oIndex].size > p.size())
p.push_back(residents[i]);
}
}
items[wIndex].show(g);
items[aIndex].show(s);
items[oIndex].show(p);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tot, n, m, atk, def, res, ans[3];
string type;
struct arr {
string s;
int type;
int num, siz, size;
} a[110];
struct arrr {
string s, in;
int type;
int num, inn;
} b[1010];
vector<arrr> lis[3];
bool comp(arrr a, arrr b) { return a.num < b.num; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].s >> type >> atk >> def >> res >> a[i].siz;
if (type[0] == 'w')
a[i].num = atk, a[i].type = 0;
else if (type[0] == 'a')
a[i].num = def, a[i].type = 1;
else
a[i].num = res, a[i].type = 2;
tot += a[i].siz;
a[i].size = a[i].siz;
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> b[i].s >> type >> b[i].num >> b[i].in;
if (type[0] == 'g')
b[i].type = 0;
else if (type[0] == 's')
b[i].type = 1;
else
b[i].type = 2;
}
if (m == tot) {
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (b[i].in == a[j].s && b[i].type == a[j].type) a[j].num += b[i].num;
for (int j = 1; j <= n; j++)
if (ans[a[j].type] == 0 || a[j].num > a[ans[a[j].type]].num)
ans[a[j].type] = j;
for (int i = 0; i < 3; i++) {
cout << a[ans[i]].s << ' ' << a[ans[i]].siz;
for (int j = 1; j <= m; j++)
if (b[j].in == a[ans[i]].s) cout << ' ' << b[j].s;
cout << endl;
}
} else {
for (int i = 1; i <= m; i++) lis[b[i].type].push_back(b[i]);
for (int i = 0; i < 3; i++) sort(lis[i].begin(), lis[i].end(), comp);
for (int j = 1; j <= n; j++) {
int k = a[j].type;
for (int i = lis[k].size() - 1; i >= 0 && a[j].siz; i--) {
a[j].siz--;
a[j].num += lis[k][i].num;
}
}
for (int j = 1; j <= n; j++)
if (ans[a[j].type] == 0 || a[j].num > a[ans[a[j].type]].num)
ans[a[j].type] = j;
for (int j = 1; j <= n; j++) a[j].siz = a[j].size;
for (int k = 0; k < 3; k++)
for (int i = lis[k].size() - 1; i >= 0 && a[ans[k]].siz; i--) {
a[ans[k]].siz--;
lis[k][i].inn = k + 1;
}
for (int k = 0; k < 3; k++)
for (int j = 0; j < 3; j++)
for (int i = lis[j].size() - 1; i >= 0 && a[ans[k]].siz; i--)
if (!lis[j][i].inn) {
a[ans[k]].siz--;
lis[j][i].inn = k + 1;
}
for (int i = 0; i < 3; i++) {
cout << a[ans[i]].s << ' ' << a[ans[i]].size - a[ans[i]].siz;
for (int j = 0; j < 3; j++)
for (int k = lis[j].size() - 1; k >= 0; k--)
if (lis[j][k].inn == i + 1) cout << ' ' << lis[j][k].s;
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> th;
map<string, int> rs;
struct thing {
string name;
int cl;
int atk, def, res;
int size;
vector<int> resid;
int full;
void read(int id) {
full = 0;
cin >> name;
string s;
cin >> s;
if (s == "weapon")
cl = 1;
else if (s == "armor")
cl = 2;
else
cl = 3;
cin >> atk >> def >> res >> size;
th[name] = id;
}
};
thing a[200];
struct resident {
string name;
int typ;
string home;
int bonus;
int id;
void read(int _id) {
cin >> name;
string s;
cin >> s;
if (s == "gladiator")
typ = 1;
else if (s == "sentry")
typ = 2;
else
typ = 3;
cin >> bonus;
cin >> home;
int x = th[home];
rs[name] = _id;
a[x].resid.push_back(_id);
a[x].full++;
id = _id;
}
};
resident x[2200];
int n;
int m;
int empty = 1;
vector<int> ans[3];
int anss[4];
int xx[4];
int used[2210];
vector<resident> tt[4];
void update(int i, int j, int k) {
if (empty) {
int cur[4];
memset(cur, 0, sizeof(cur));
int px[3];
px[0] = i, px[1] = j, px[2] = k;
for (int t = 0; t < 3; t++) {
int tek = px[t];
if (a[tek].cl == 1) cur[1] += a[tek].atk;
if (a[tek].cl == 2) cur[2] += a[tek].def;
if (a[tek].cl == 3) cur[3] += a[tek].res;
for (int i = 0; i < a[tek].resid.size(); i++)
if (a[tek].cl == x[a[tek].resid[i]].typ)
cur[a[tek].cl] += x[a[tek].resid[i]].bonus;
}
int ok = 0;
for (int i = 1; i < 4; i++)
if (cur[i] > anss[i]) {
ok = 1;
break;
} else if (cur[i] < anss[i])
break;
if (ok) {
for (int i = 1; i < 4; i++) anss[i] = cur[i];
xx[1] = i, xx[2] = j, xx[3] = k;
for (int i = 0; i < 3; i++) {
ans[i].clear();
int tek = px[i];
for (int j = 0; j < a[tek].resid.size(); j++)
ans[i].push_back(a[tek].resid[j]);
}
}
} else {
int cur[4];
memset(cur, 0, sizeof(cur));
int px[3];
px[0] = i, px[1] = j, px[2] = k;
memset(used, 0, sizeof(used));
for (int i = 0; i < 3; i++) {
int tek = px[i];
if (a[tek].cl == 1) cur[1] += a[tek].atk;
if (a[tek].cl == 2) cur[2] += a[tek].def;
if (a[tek].cl == 3) cur[3] += a[tek].res;
for (int j = 0; j < min((int)a[tek].size, (int)tt[a[tek].cl].size()); j++)
cur[a[tek].cl] += tt[a[tek].cl][j].bonus;
}
int ok = 0;
for (int i = 1; i < 4; i++)
if (cur[i] > anss[i]) {
ok = 1;
break;
} else if (cur[i] < anss[i])
break;
if (ok) {
for (int i = 1; i < 4; i++) anss[i] = cur[i];
xx[1] = i, xx[2] = j, xx[3] = k;
for (int i = 0; i < 3; i++) {
int tek = px[i];
ans[i].clear();
for (int j = 0; j < min((int)a[tek].size, (int)tt[a[tek].cl].size());
j++) {
ans[i].push_back(tt[a[tek].cl][j].id);
used[ans[i].back()] = 1;
}
}
for (int i = 0; i < 3; i++) {
int tek = px[i];
for (int j = 0; j < m && ans[i].size() < a[tek].full; j++)
if (!used[j]) ans[i].push_back(j), used[j] = 1;
}
}
}
}
int cmp(resident a, resident b) { return a.bonus > b.bonus; }
int main() {
xx[1] = xx[2] = xx[3] = -1;
anss[1] = anss[2] = anss[3] = -1;
cin >> n;
for (int i = 0; i < n; i++) a[i].read(i);
cin >> m;
for (int i = 0; i < m; i++) x[i].read(i);
for (int i = 0; i < n; i++)
if (a[i].size != a[i].full) empty = 0;
for (int i = 0; i < m; i++) {
tt[x[i].typ].push_back(x[i]);
}
for (int i = 1; i <= 3; i++) sort(tt[i].begin(), tt[i].end(), cmp);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++) {
int us[4];
us[1] = us[2] = us[3] = 0;
us[a[i].cl] = 1;
us[a[j].cl] = 1;
us[a[k].cl] = 1;
if (us[1] + us[2] + us[3] == 3) {
us[a[i].cl] = i;
us[a[j].cl] = j;
us[a[k].cl] = k;
update(us[1], us[2], us[3]);
}
}
for (int i = 0; i < 3; i++) {
cout << a[xx[i + 1]].name << " " << ans[i].size();
for (int j = 0; j < ans[i].size(); j++) cout << " " << x[ans[i][j]].name;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
string clase;
int val, size, acum, num;
};
struct resident {
string clase, home;
int bonus;
};
map<string, item> mapitem;
map<string, resident> mapresident;
string buscamaximo(string clase) {
string sol;
int acum = -1;
for (map<string, item>::iterator it = mapitem.begin(); it != mapitem.end();
it++) {
if (it->second.clase == clase and it->second.acum > acum) {
sol = it->first;
acum = it->second.acum;
}
}
return sol;
}
void escribeelems(string name) {
cout << mapitem[name].num;
for (map<string, resident>::iterator it = mapresident.begin();
it != mapresident.end(); it++) {
if (it->second.home == name) cout << " " << it->first;
}
cout << endl;
}
map<string, pair<string, vector<string> > > sol;
void escribeclase(string clase) {
string name = sol[clase].first;
vector<string> &v = sol[clase].second;
cout << name << " " << int(v.size());
for (int i = 0; i < int(v.size()); i++) cout << " " << v[i];
cout << endl;
}
void obtenmaximoclase(string clase) {
vector<pair<int, string> > v;
for (map<string, resident>::iterator it = mapresident.begin();
it != mapresident.end(); it++)
if (it->second.clase == clase)
v.push_back(pair<int, string>(it->second.bonus, it->first));
sort(v.begin(), v.end());
string name;
int maximo = -1;
int nummaximo;
for (map<string, item>::iterator it = mapitem.begin(); it != mapitem.end();
it++) {
if (it->second.clase == clase) {
int acum = it->second.val;
int size = it->second.size;
int num = 0;
for (int i = int(v.size()) - 1; i >= 0 and num < size; i--) {
acum += v[i].first;
num++;
}
if (maximo < acum) {
maximo = acum;
name = it->first;
nummaximo = num;
}
}
}
sol[clase].first = name;
for (int i = 0; i < nummaximo; i++) {
sol[clase].second.push_back(v[int(v.size()) - 1 - i].second);
mapresident.erase(v[int(v.size()) - 1 - i].second);
}
}
void rellenasolucion(string clase) {
string name = sol[clase].first;
vector<string> &v = sol[clase].second;
while (int(v.size()) < mapitem[name].size and int(mapresident.size()) > 0) {
string nameres = (mapresident.begin())->first;
mapresident.erase(nameres);
v.push_back(nameres);
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string name, clase;
int val1, val2, val3, size;
cin >> name >> clase >> val1 >> val2 >> val3 >> size;
item it;
it.clase = clase;
if (clase == "weapon") {
it.val = val1;
} else if (clase == "armor") {
it.val = val2;
} else {
it.val = val3;
}
it.size = size;
it.acum = it.val;
it.num = 0;
mapitem[name] = it;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
string name, clase, home;
int bonus;
cin >> name >> clase >> bonus >> home;
resident res;
if (clase == "gladiator") {
clase = "weapon";
} else if (clase == "sentry") {
clase = "armor";
} else {
clase = "orb";
}
res.clase = clase;
res.bonus = bonus;
res.home = home;
mapresident[name] = res;
if (mapitem[home].clase == clase) {
mapitem[home].acum += bonus;
}
mapitem[home].num++;
}
bool completo = true;
for (map<string, item>::iterator it = mapitem.begin(); it != mapitem.end();
it++) {
if (it->second.size != it->second.num) completo = false;
}
if (completo) {
string name;
name = buscamaximo("weapon");
cout << name << " ";
escribeelems(name);
name = buscamaximo("armor");
cout << name << " ";
escribeelems(name);
name = buscamaximo("orb");
cout << name << " ";
escribeelems(name);
} else {
obtenmaximoclase("weapon");
obtenmaximoclase("armor");
obtenmaximoclase("orb");
rellenasolucion("weapon");
rellenasolucion("armor");
rellenasolucion("orb");
escribeclase("weapon");
escribeclase("armor");
escribeclase("orb");
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
const int N = 1e3;
int n, m;
struct Eqp {
string name;
int atk, def, spd, size;
vector<string> in;
};
vector<Eqp> atk, def, spd;
struct Props {
string name;
int up;
};
vector<Props> patk, pdef, pspd;
int tot;
int sum[N + 1];
vector<string> ans[4];
int nowatk, nowdef, nowspd;
inline bool compare1(Props x, Props y) { return x.up > y.up; }
inline bool compare2(Eqp x, Eqp y) { return x.atk > y.atk; }
inline bool compare3(Eqp x, Eqp y) { return x.def > y.def; }
inline bool compare4(Eqp x, Eqp y) { return x.spd > y.spd; }
int main() {
n = read();
for (int i = 1; i <= n; i++) {
string name, type;
cin >> name >> type;
if (type == "weapon") {
atk.push_back(Eqp{name, read(), read(), read(), read()});
tot += atk[atk.size() - 1].size;
}
if (type == "armor") {
def.push_back(Eqp{name, read(), read(), read(), read()});
tot += def[def.size() - 1].size;
}
if (type == "orb") {
spd.push_back(Eqp{name, read(), read(), read(), read()});
tot += spd[spd.size() - 1].size;
}
}
m = read();
for (int i = 1; i <= m; i++) {
string name, type, in;
cin >> name >> type;
int up = read();
if (type == "gladiator") patk.push_back(Props{name, up});
if (type == "sentry") pdef.push_back(Props{name, up});
if (type == "physician") pspd.push_back(Props{name, up});
cin >> in;
if (tot == m) {
for (int j = 0; j < atk.size(); j++) {
if (atk[j].name == in) {
atk[j].in.push_back(name);
if (type == "gladiator") atk[j].atk += up;
}
}
for (int j = 0; j < def.size(); j++) {
if (def[j].name == in) {
def[j].in.push_back(name);
if (type == "sentry") def[j].def += up;
}
}
for (int j = 0; j < spd.size(); j++) {
if (spd[j].name == in) {
spd[j].in.push_back(name);
if (type == "physician") spd[j].spd += up;
}
}
}
}
if (tot == m) {
sort(atk.begin(), atk.end(), compare2);
sort(def.begin(), def.end(), compare3);
sort(spd.begin(), spd.end(), compare4);
cout << atk[0].name;
printf(" %d ", atk[0].in.size());
for (int i = 0; i < atk[0].in.size(); i++) cout << atk[0].in[i] << " ";
printf("\n");
cout << def[0].name;
printf(" %d ", def[0].in.size());
for (int i = 0; i < def[0].in.size(); i++) cout << def[0].in[i] << " ";
printf("\n");
cout << spd[0].name;
printf(" %d ", spd[0].in.size());
for (int i = 0; i < spd[0].in.size(); i++) cout << spd[0].in[i] << " ";
printf("\n");
return 0;
}
sort(patk.begin(), patk.end(), compare1);
for (int i = 1; i <= patk.size(); i++) sum[i] = sum[i - 1] + patk[i - 1].up;
for (int i = 0; i < atk.size(); i++)
atk[i].atk += sum[min(atk[i].size, (int)patk.size())];
sort(atk.begin(), atk.end(), compare2);
sort(pdef.begin(), pdef.end(), compare1);
for (int i = 1; i <= pdef.size(); i++) sum[i] = sum[i - 1] + pdef[i - 1].up;
for (int i = 0; i < def.size(); i++)
def[i].def += sum[min(def[i].size, (int)pdef.size())];
sort(def.begin(), def.end(), compare3);
sort(pspd.begin(), pspd.end(), compare1);
for (int i = 1; i <= pspd.size(); i++) sum[i] = sum[i - 1] + pspd[i - 1].up;
for (int i = 0; i < spd.size(); i++)
spd[i].spd += sum[min(spd[i].size, (int)pspd.size())];
sort(spd.begin(), spd.end(), compare4);
nowatk = min(atk[0].size, (int)patk.size());
nowdef = min(def[0].size, (int)pdef.size());
nowspd = min(spd[0].size, (int)pspd.size());
for (int i = 0; i < nowatk; i++) ans[1].push_back(patk[i].name);
for (int i = 0; i < nowdef; i++) ans[2].push_back(pdef[i].name);
for (int i = 0; i < nowspd; i++) ans[3].push_back(pspd[i].name);
if (ans[1].size() < atk[0].size) {
for (; nowatk < patk.size() && ans[1].size() < atk[0].size; nowatk++)
ans[1].push_back(patk[nowatk].name);
if (ans[1].size() < atk[0].size) {
for (; nowdef < pdef.size() && ans[1].size() < atk[0].size; nowdef++)
ans[1].push_back(pdef[nowdef].name);
if (ans[1].size() < atk[0].size)
for (; nowspd < pspd.size() && ans[1].size() < atk[0].size; nowspd++)
ans[1].push_back(pspd[nowspd].name);
}
}
if (ans[2].size() < def[0].size) {
for (; nowatk < patk.size() && ans[2].size() < def[0].size; nowatk++)
ans[2].push_back(patk[nowatk].name);
if (ans[2].size() < def[0].size) {
for (; nowdef < pdef.size() && ans[2].size() < def[0].size; nowdef++)
ans[2].push_back(pdef[nowdef].name);
if (ans[2].size() < def[0].size)
for (; nowspd < pspd.size() && ans[2].size() < def[0].size; nowspd++)
ans[2].push_back(pspd[nowspd].name);
}
}
if (ans[3].size() < spd[0].size) {
for (; nowatk < patk.size() && ans[3].size() < spd[0].size; nowatk++)
ans[3].push_back(patk[nowatk].name);
if (ans[3].size() < spd[0].size) {
for (; nowdef < pdef.size() && ans[3].size() < spd[0].size; nowdef++)
ans[3].push_back(pdef[nowdef].name);
if (ans[3].size() < spd[0].size)
for (; nowspd < pspd.size() && ans[3].size() < spd[0].size; nowspd++)
ans[3].push_back(pspd[nowspd].name);
}
}
cout << atk[0].name;
printf(" %d ", ans[1].size());
for (int i = 0; i < ans[1].size(); i++) cout << ans[1][i] << " ";
printf("\n");
cout << def[0].name;
printf(" %d ", ans[2].size());
for (int i = 0; i < ans[2].size(); i++) cout << ans[2][i] << " ";
printf("\n");
cout << spd[0].name;
printf(" %d ", ans[3].size());
for (int i = 0; i < ans[3].size(); i++) cout << ans[3][i] << " ";
printf("\n");
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
inline bool isPrime(long long int n) {
if (n <= 1) {
return false;
}
if (n <= 3) {
return true;
}
if (n % 2 == 0 || n % 3 == 0) {
return false;
}
for (int i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
const int MAX = 1000005;
struct item {
string name, type;
int atk, def, res, size;
};
struct resident {
string name, type;
int bonus;
string home;
};
int N, K;
item items[MAX];
resident residents[MAX];
bool used[MAX];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> items[i].name >> items[i].type >> items[i].atk >> items[i].def >>
items[i].res >> items[i].size;
if (items[i].type == "weapon")
items[i].type = "atk";
else if (items[i].type == "armor")
items[i].type = "def";
else if (items[i].type == "orb")
items[i].type = "res";
else
assert(false);
}
cin >> K;
for (int i = 0; i < K; i++) {
cin >> residents[i].name >> residents[i].type >> residents[i].bonus >>
residents[i].home;
if (residents[i].type == "gladiator")
residents[i].type = "atk";
else if (residents[i].type == "sentry")
residents[i].type = "def";
else if (residents[i].type == "physician")
residents[i].type = "res";
else
assert(false);
}
int sum_size = 0;
for (int i = 0; i < N; i++) sum_size += items[i].size;
if (sum_size == K) {
int atk_total = -1, def_total = -1, res_total = -1;
int best_atk = -1, best_def = -1, best_res = -1;
for (int i = 0; i < N; i++)
if (items[i].type == "atk") {
int total = items[i].atk;
for (int j = 0; j < K; j++)
if (residents[j].home == items[i].name && residents[j].type == "atk")
total += residents[j].bonus;
if (total > atk_total) {
atk_total = total;
best_atk = i;
}
} else if (items[i].type == "def") {
int total = items[i].def;
for (int j = 0; j < K; j++)
if (residents[j].home == items[i].name && residents[j].type == "def")
total += residents[j].bonus;
if (total > def_total) {
def_total = total;
best_def = i;
}
} else if (items[i].type == "res") {
int total = items[i].res;
for (int j = 0; j < K; j++)
if (residents[j].home == items[i].name && residents[j].type == "res")
total += residents[j].bonus;
if (total > res_total) {
res_total = total;
best_res = i;
}
} else
assert(false);
cout << items[best_atk].name;
int reside = 0;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_atk].name) reside++;
cout << ' ' << reside;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_atk].name)
cout << ' ' << residents[i].name;
cout << '\n';
cout << items[best_def].name;
reside = 0;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_def].name) reside++;
cout << ' ' << reside;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_def].name)
cout << ' ' << residents[i].name;
cout << '\n';
cout << items[best_res].name;
reside = 0;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_res].name) reside++;
cout << ' ' << reside;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_res].name)
cout << ' ' << residents[i].name;
cout << '\n';
return 0;
}
vector<pair<int, int> > atk, def, res;
for (int i = 0; i < K; i++)
if (residents[i].type == "atk")
atk.push_back(make_pair(residents[i].bonus, i));
else if (residents[i].type == "def")
def.push_back(make_pair(residents[i].bonus, i));
else if (residents[i].type == "res")
res.push_back(make_pair(residents[i].bonus, i));
else
assert(false);
sort(atk.rbegin(), atk.rend());
sort(def.rbegin(), def.rend());
sort(res.rbegin(), res.rend());
int atk_total = -1, def_total = -1, res_total = -1;
int best_atk = -1, best_def = -1, best_res = -1;
for (int i = 0; i < N; i++)
if (items[i].type == "atk") {
int total = items[i].atk;
for (int j = 0; j < min(items[i].size, (int)atk.size()); j++)
total += atk[j].first;
if (total > atk_total) {
atk_total = total;
best_atk = i;
}
} else if (items[i].type == "def") {
int total = items[i].def;
for (int j = 0; j < min(items[i].size, (int)def.size()); j++)
total += def[j].first;
if (total > def_total) {
def_total = total;
best_def = i;
}
} else if (items[i].type == "res") {
int total = items[i].res;
for (int j = 0; j < min(items[i].size, (int)res.size()); j++)
total += res[j].first;
if (total > res_total) {
res_total = total;
best_res = i;
}
}
vector<int> atk_answer, def_answer, res_answer;
for (int i = 0; i < min(items[best_atk].size, (int)atk.size()); i++) {
atk_answer.push_back(atk[i].second);
used[atk[i].second] = true;
}
for (int i = 0; i < min(items[best_def].size, (int)def.size()); i++) {
def_answer.push_back(def[i].second);
used[def[i].second] = true;
}
for (int i = 0; i < min(items[best_res].size, (int)res.size()); i++) {
res_answer.push_back(res[i].second);
used[res[i].second] = true;
}
while ((int)atk_answer.size() < items[best_atk].size) {
int unused = -1;
for (int i = 0; i < K; i++)
if (!used[i]) unused = i;
if (unused == -1) break;
atk_answer.push_back(unused);
used[unused] = true;
}
while ((int)def_answer.size() < items[best_def].size) {
int unused = -1;
for (int i = 0; i < K; i++)
if (!used[i]) unused = i;
if (unused == -1) break;
def_answer.push_back(unused);
used[unused] = true;
}
while ((int)res_answer.size() < items[best_res].size) {
int unused = -1;
for (int i = 0; i < K; i++)
if (!used[i]) unused = i;
if (unused == -1) break;
res_answer.push_back(unused);
used[unused] = true;
}
cout << items[best_atk].name << ' ' << atk_answer.size();
for (int i = 0; i < (int)atk_answer.size(); i++)
cout << ' ' << residents[atk_answer[i]].name;
cout << '\n';
cout << items[best_def].name << ' ' << def_answer.size();
for (int i = 0; i < (int)def_answer.size(); i++)
cout << ' ' << residents[def_answer[i]].name;
cout << '\n';
cout << items[best_res].name << ' ' << res_answer.size();
for (int i = 0; i < (int)res_answer.size(); i++)
cout << ' ' << residents[res_answer[i]].name;
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string weapon = "weapon", armor = "armor", orb = "orb";
struct resident {
string type, name;
int bonus;
};
struct item {
string type, name;
vector<resident> what;
int val, size;
};
int n, k, sumVolume = 0;
vector<item> a;
item bestArmor, bestWeapon, bestOrb;
vector<resident> b;
set<string> used;
vector<resident> weaponRes, armorRes, orbRes;
bool betterBy_weapon(const resident &a, const resident &b) {
if (a.type == weapon && b.type != weapon) return true;
if (a.type == weapon && b.type == weapon) return a.bonus > b.bonus;
if (a.type != weapon && b.type == weapon) return false;
if (a.type != weapon && b.type != weapon) return false;
}
bool betterBy_armor(const resident &a, const resident &b) {
if (a.type == armor && b.type != armor) return true;
if (a.type == armor && b.type == armor) return a.bonus > b.bonus;
if (a.type != armor && b.type == armor) return false;
if (a.type != armor && b.type != armor) return false;
}
bool betterBy_orb(const resident &a, const resident &b) {
if (a.type == orb && b.type != orb) return true;
if (a.type == orb && b.type == orb) return a.bonus > b.bonus;
if (a.type != orb && b.type == orb) return false;
if (a.type != orb && b.type != orb) return false;
}
void print(item &t) {
cout << t.name << ' ' << t.what.size() << ' ';
for (int i = 0; i < t.what.size(); i++) cout << t.what[i].name << ' ';
cout << endl;
}
item findBest(const string &type) {
item res;
int ma = -1;
for (int i = 0; i < n; i++) {
if (a[i].type == type) {
int val = a[i].val;
for (int j = 0; j < min(k, a[i].size) && b[j].type == type; j++)
val += b[j].bonus;
if (val > ma) {
ma = val;
res = a[i];
}
}
}
for (int j = 0; j < min(k, res.size) && b[j].type == type; j++) {
used.insert(b[j].name);
res.what.push_back(b[j]);
}
return res;
}
void filll(item &t) {
for (int i = 0; i < k; i++) {
if (t.what.size() == t.size) return;
if (used.find(b[i].name) == used.end()) {
used.insert(b[i].name);
t.what.push_back(b[i]);
}
}
}
item findBest2(const string &type) {
item res;
int ma = -1;
for (int i = 0; i < n; i++) {
if (a[i].type == type) {
int val = a[i].val;
for (int j = 0; j < a[i].what.size(); j++)
if (a[i].what[j].type == type) val += a[i].what[j].bonus;
if (val > ma) {
res = a[i];
ma = val;
}
}
}
return res;
}
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i].name >> a[i].type;
int atk, def, res;
cin >> atk >> def >> res >> a[i].size;
sumVolume += a[i].size;
if (a[i].type == weapon)
a[i].val = atk;
else if (a[i].type == armor)
a[i].val = def;
else
a[i].val = res;
}
cin >> k;
b.resize(k);
for (int i = 0; i < k; i++) {
string home;
cin >> b[i].name >> b[i].type >> b[i].bonus >> home;
if (b[i].type[0] == 'g')
b[i].type = weapon;
else if (b[i].type[0] == 's')
b[i].type = armor;
else
b[i].type = orb;
for (int j = 0; j < n; j++)
if (a[j].name == home) {
a[j].what.push_back(b[i]);
break;
}
}
if (k == sumVolume) {
item bestWeapon = findBest2(weapon);
item bestArmor = findBest2(armor);
item bestOrb = findBest2(orb);
print(bestWeapon);
print(bestArmor);
print(bestOrb);
return 0;
}
for (int i = 0; i < n; i++) a[i].what.clear();
sort(b.begin(), b.end(), betterBy_weapon);
item bestWeapon = findBest(weapon);
sort(b.begin(), b.end(), betterBy_armor);
item bestArmor = findBest(armor);
sort(b.begin(), b.end(), betterBy_orb);
bestOrb = findBest(orb);
filll(bestWeapon);
filll(bestArmor);
filll(bestOrb);
print(bestWeapon);
print(bestArmor);
print(bestOrb);
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int N = 110;
const int M = 1010;
int n, m, ans[3];
bool vis[M];
struct iteam {
string name;
int type, val[3], size;
vector<int> have;
void get() {
char buf[100];
scanf("%s", buf);
name = buf;
scanf("%s", buf);
if (buf[0] == 'w')
type = 0;
else if (buf[0] == 'a')
type = 1;
else
type = 2;
for (int i = 0; i < (int)(3); ++i) scanf("%d", val + i);
scanf("%d", &size);
have.clear();
}
void add(int v) { val[type] += v; }
} t[N];
struct resident {
string name, home;
int type, bonus;
void get() {
char buf[100];
scanf("%s", buf);
name = buf;
scanf("%s", buf);
if (buf[0] == 'g')
type = 0;
else if (buf[0] == 's')
type = 1;
else
type = 2;
scanf("%d%s", &bonus, buf);
home = buf;
}
bool operator<(const resident& u) const { return bonus < u.bonus; }
} p[M];
void print() {
for (int i = 0; i < (int)(3); ++i) {
iteam& z = t[ans[i]];
printf("%s %d", z.name.c_str(), ((int)z.have.size()));
for (int j = 0; j < (int)(((int)z.have.size())); ++j) {
printf(" %s", p[z.have[j]].name.c_str());
}
puts("");
}
}
void solve() {
int cnt = 0;
for (int i = 0; i < (int)(n); ++i) {
t[i].get();
cnt += t[i].size;
}
scanf("%d", &m);
for (int i = 0; i < (int)(m); ++i) p[i].get();
memset(ans, -1, sizeof(ans));
if (cnt == m) {
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j)
if (t[i].name == p[j].home) {
t[i].have.push_back(j);
if (t[i].type == p[j].type) t[i].add(p[j].bonus);
}
int type = t[i].type;
if (ans[type] == -1)
ans[type] = i;
else {
int z = ans[type];
if (t[z].val[type] < t[i].val[type]) ans[type] = i;
}
}
print();
return;
}
for (int i = 0; i < (int)(n); ++i) t[i].have.clear();
sort(p, p + m);
reverse(p, p + m);
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j)
if (t[i].type == p[j].type) {
if (t[i].size == 0) continue;
t[i].add(p[j].bonus);
t[i].size--;
t[i].have.push_back(j);
}
int type = t[i].type;
if (ans[type] == -1)
ans[type] = i;
else {
int z = ans[type];
if (t[z].val[type] < t[i].val[type]) ans[type] = i;
}
}
memset(vis, 0, sizeof(vis));
for (int i = 0; i < (int)(3); ++i) {
int z = ans[i];
for (int j = 0; j < (int)(((int)t[z].have.size())); ++j)
vis[t[z].have[j]] = 1;
}
for (int i = 0; i < (int)(3); ++i) {
for (int j = 0; j < (int)(m); ++j)
if (!vis[j]) {
int z = ans[i];
if (t[z].size == 0) break;
t[z].have.push_back(j);
t[z].size--;
vis[j] = 1;
}
}
print();
}
int main() {
while (~scanf("%d", &n)) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num_item;
int sum_of_space;
string item_name[120], item_type[120];
int att[120], def[120], res[120], size[120];
int num_atr;
string atr_name[1200], atr_type[1200];
int bonus[1200];
string dummy[1200];
int get_max(int item_id, int used_list[], int *used_num) {
int i;
int mx;
int sz = 0;
string nm;
if (item_type[item_id] == "weapon") mx = att[item_id], nm = "gladiator";
if (item_type[item_id] == "armor") mx = def[item_id], nm = "sentry";
if (item_type[item_id] == "orb") mx = res[item_id], nm = "physician";
for (i = 0; i < num_atr; i++)
if (atr_type[i] == nm) {
if (sz >= size[item_id]) break;
mx += bonus[i];
used_list[sz++] = i;
}
*used_num = sz;
return mx;
}
int get_status(int item_id, int used_list[], int *used_num) {
int i;
int mx;
int sz = 0;
string nm;
if (item_type[item_id] == "weapon") mx = att[item_id], nm = "gladiator";
if (item_type[item_id] == "armor") mx = def[item_id], nm = "sentry";
if (item_type[item_id] == "orb") mx = res[item_id], nm = "physician";
for (i = 0; i < num_atr; i++)
if (dummy[i] == item_name[item_id]) {
if (atr_type[i] == nm) mx += bonus[i];
used_list[sz++] = i;
}
*used_num = sz;
return mx;
}
int main() {
int i, j, k, l, m, n;
int used[1200];
int used_list[1200], used_size;
int res1, res2, res3;
int res1_list[1200], res1_size;
int res2_list[1200], res2_size;
int res3_list[1200], res3_size;
int mx, tmp;
pair<string, pair<int, string> > for_sort[1200];
while (scanf("%d", &num_item) == 1) {
sum_of_space = 0;
for (i = 0; i < num_item; i++) {
cin >> item_name[i] >> item_type[i] >> att[i] >> def[i] >> res[i] >>
size[i];
sum_of_space += size[i];
}
scanf("%d", &num_atr);
for (i = 0; i < num_atr; i++) {
cin >> atr_name[i] >> atr_type[i] >> bonus[i] >> dummy[i];
}
if (sum_of_space == num_atr) {
mx = -1;
for (i = 0; i < num_item; i++)
if (item_type[i] == "weapon") {
tmp = get_status(i, used_list, &used_size);
if (mx < tmp) mx = tmp, res1 = i;
}
mx = -1;
for (i = 0; i < num_item; i++)
if (item_type[i] == "armor") {
tmp = get_status(i, used_list, &used_size);
if (mx < tmp) mx = tmp, res2 = i;
}
mx = -1;
for (i = 0; i < num_item; i++)
if (item_type[i] == "orb") {
tmp = get_status(i, used_list, &used_size);
if (mx < tmp) mx = tmp, res3 = i;
}
get_status(res1, res1_list, &res1_size);
get_status(res2, res2_list, &res2_size);
get_status(res3, res3_list, &res3_size);
} else {
for (i = 0; i < num_atr; i++)
for_sort[i] = make_pair(atr_type[i], make_pair(-bonus[i], atr_name[i]));
sort(for_sort, for_sort + num_atr);
for (i = 0; i < num_atr; i++) {
atr_type[i] = for_sort[i].first;
bonus[i] = -for_sort[i].second.first;
atr_name[i] = for_sort[i].second.second;
}
for (i = 0; i < num_atr; i++) used[i] = 0;
mx = -1;
for (i = 0; i < num_item; i++)
if (item_type[i] == "weapon") {
tmp = get_max(i, used_list, &used_size);
if (mx < tmp) res1 = i, mx = tmp;
}
mx = -1;
for (i = 0; i < num_item; i++)
if (item_type[i] == "armor") {
tmp = get_max(i, used_list, &used_size);
if (mx < tmp) res2 = i, mx = tmp;
}
mx = -1;
for (i = 0; i < num_item; i++)
if (item_type[i] == "orb") {
tmp = get_max(i, used_list, &used_size);
if (mx < tmp) res3 = i, mx = tmp;
}
get_max(res1, res1_list, &res1_size);
get_max(res2, res2_list, &res2_size);
get_max(res3, res3_list, &res3_size);
for (i = 0; i < res1_size; i++) used[res1_list[i]] = 1;
for (i = 0; i < res2_size; i++) used[res2_list[i]] = 1;
for (i = 0; i < res3_size; i++) used[res3_list[i]] = 1;
for (i = 0; i < num_atr; i++)
if (!used[i]) {
if (size[res1] > res1_size) {
res1_list[res1_size++] = i;
used[i] = 1;
continue;
}
if (size[res2] > res2_size) {
res2_list[res2_size++] = i;
used[i] = 1;
continue;
}
if (size[res3] > res3_size) {
res3_list[res3_size++] = i;
used[i] = 1;
continue;
}
}
}
printf("%s %d", item_name[res1].c_str(), res1_size);
for (i = 0; i < res1_size; i++)
printf(" %s", atr_name[res1_list[i]].c_str());
puts("");
printf("%s %d", item_name[res2].c_str(), res2_size);
for (i = 0; i < res2_size; i++)
printf(" %s", atr_name[res2_list[i]].c_str());
puts("");
printf("%s %d", item_name[res3].c_str(), res3_size);
for (i = 0; i < res3_size; i++)
printf(" %s", atr_name[res3_list[i]].c_str());
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Item {
string name;
int value;
int size;
Item() {}
Item(string name, int value, int size)
: name(name), value(value), size(size) {}
};
struct Resident {
string name;
string home;
string type;
int bonus;
bool used;
Resident() {}
Resident(string name, string home, string type, int bonus)
: name(name), home(home), type(type), bonus(bonus) {
used = false;
}
bool operator<(const Resident &ot) const { return bonus > ot.bonus; }
};
vector<Item> weapons, armors, orbs;
vector<Resident> residents, weaponResidents, armorResidents, orbResidents;
int n, k;
int totalSize;
int usedSize;
Item getBest(vector<Item> &items, vector<Resident> &rr, string type) {
int ibest = -1;
int bestValue;
if (totalSize != k) {
for (int i = 0; i < items.size(); i++) {
int value = items[i].value;
int limite = items[i].size;
for (int j = 0; j < residents.size() && limite > 0; j++) {
if (residents[j].type == type) {
value += residents[j].bonus;
limite--;
}
}
if (ibest == -1 || bestValue < value) {
bestValue = value;
ibest = i;
}
}
int limite = items[ibest].size;
for (int j = 0; j < residents.size() && limite > 0; j++) {
if (residents[j].type == type) {
rr.push_back(residents[j]);
residents[j].used = true;
limite--;
}
}
} else {
for (int i = 0; i < items.size(); i++) {
int value = items[i].value;
for (int j = 0; j < residents.size(); j++) {
if (residents[j].home == items[i].name && residents[j].type == type) {
value += residents[j].bonus;
}
}
if (ibest == -1 || bestValue < value) {
bestValue = value;
ibest = i;
}
}
for (int j = 0; j < residents.size(); j++) {
if (residents[j].home == items[ibest].name) {
rr.push_back(residents[j]);
residents[j].used = true;
}
}
}
return items[ibest];
}
int main() {
scanf("%d", &n);
totalSize = 0;
usedSize = 0;
for (int i = 0; i < n; i++) {
char name[12], classe[12];
int atk, def, orbVal;
int size;
scanf("%s%s%d%d%d%d", name, classe, &atk, &def, &orbVal, &size);
if (classe[0] == 'w') {
weapons.push_back(Item(string(name), atk, size));
} else if (classe[0] == 'a') {
armors.push_back(Item(string(name), def, size));
} else {
orbs.push_back(Item(string(name), orbVal, size));
}
totalSize += size;
}
scanf("%d", &k);
for (int i = 0; i < k; i++) {
char name[12], type[12], home[12];
int bonus;
scanf("%s%s%d%s", name, type, &bonus, home);
residents.push_back(
Resident(string(name), string(home), string(type), bonus));
}
Item weapon, armor, orb;
sort(residents.begin(), residents.end());
weapon = getBest(weapons, weaponResidents, string("gladiator"));
armor = getBest(armors, armorResidents, string("sentry"));
orb = getBest(orbs, orbResidents, string("physician"));
if (totalSize != k) {
int usedRes =
weaponResidents.size() + armorResidents.size() + orbResidents.size();
int usedSlots = weapon.size + armor.size + orb.size;
if (k - usedRes > totalSize - usedSlots) {
int adicionais = (k - usedRes) - (totalSize - usedSlots);
for (int i = 0; i < residents.size() && adicionais > 0 &&
weaponResidents.size() < weapon.size;
i++) {
if (!residents[i].used) {
residents[i].used = true;
weaponResidents.push_back(residents[i]);
adicionais--;
}
}
for (int i = 0; i < residents.size() && adicionais > 0 &&
armorResidents.size() < armor.size;
i++) {
if (!residents[i].used) {
residents[i].used = true;
armorResidents.push_back(residents[i]);
adicionais--;
}
}
for (int i = 0; i < residents.size() && adicionais > 0 &&
orbResidents.size() < orb.size;
i++) {
if (!residents[i].used) {
residents[i].used = true;
orbResidents.push_back(residents[i]);
adicionais--;
}
}
}
}
printf("%s ", weapon.name.c_str());
printf("%d", weaponResidents.size());
for (int i = 0; i < weaponResidents.size(); i++) {
printf(" %s", weaponResidents[i].name.c_str());
}
printf("\n");
printf("%s ", armor.name.c_str());
printf("%d", armorResidents.size());
for (int i = 0; i < armorResidents.size(); i++) {
printf(" %s", armorResidents[i].name.c_str());
}
printf("\n");
printf("%s ", orb.name.c_str());
printf("%d", orbResidents.size());
for (int i = 0; i < orbResidents.size(); i++) {
printf(" %s", orbResidents[i].name.c_str());
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
struct item {
int val, size;
char name[24];
int type;
};
struct worm {
int type;
int home;
char name[24];
int add;
};
struct item a[128];
struct worm b[1024];
int add[128][10];
int pp[128];
int n, m;
int t[3][1024];
int p[3];
int v[1024];
int cmp(const void *x, const void *y) {
return b[*(int *)y].add - b[*(int *)x].add;
}
void out(int idx) {
int i, j;
for (i = pp[idx]; i < a[idx].size; i++) {
for (j = 0; j < m && v[j]; j++)
;
if (j < m)
add[idx][pp[idx]++] = j, v[j] = 1;
else
break;
}
printf("%s %d", a[idx].name, pp[idx]);
for (i = 0; i < pp[idx]; i++) printf(" %s", b[add[idx][i]].name);
puts("");
}
int main() {
int i, j, s = 0, weapon = -1, armor = -1, orb = -1;
char str[128];
scanf("%d", &n);
for (i = 0; i < n; i++) {
int atk, def, res;
scanf("%s %s %d %d %d %d", a[i].name, str, &atk, &def, &res, &a[i].size);
s += a[i].size;
if (str[0] == 'w')
a[i].type = 0, a[i].val = atk;
else if (str[0] == 'a')
a[i].type = 1, a[i].val = def;
else
a[i].type = 2, a[i].val = res;
pp[i] = 0;
}
scanf("%d", &m);
p[0] = p[1] = p[2] = 0;
for (i = 0; i < m; i++) {
scanf("%s %s %d", b[i].name, str, &b[i].add);
if (str[0] == 'g')
t[0][p[0]++] = i, b[i].type = 0;
else if (str[0] == 's')
t[1][p[1]++] = i, b[i].type = 1;
else
t[2][p[2]++] = i, b[i].type = 2;
scanf("%s", str);
for (j = 0; j < n; j++)
if (strcmp(str, a[j].name) == 0) break;
b[i].home = j;
}
qsort(t[0], p[0], sizeof(t[0][0]), cmp);
qsort(t[1], p[1], sizeof(t[1][0]), cmp);
qsort(t[2], p[2], sizeof(t[2][0]), cmp);
if (s == m) {
for (j = 0; j < m; j++) {
i = b[j].home;
add[i][pp[i]++] = j;
if (b[j].type == a[i].type) a[i].val += b[j].add;
}
} else {
for (i = 0; i < n; i++)
for (j = 0; j < a[i].size && j < p[a[i].type]; j++) {
add[i][pp[i]++] = t[a[i].type][j];
a[i].val += b[t[a[i].type][j]].add;
}
}
for (i = 0; i < n; i++) {
if (a[i].type == 0) {
if (weapon < 0 || a[i].val > a[weapon].val) weapon = i;
} else if (a[i].type == 1) {
if (armor < 0 || a[i].val > a[armor].val) armor = i;
} else {
if (orb < 0 || a[i].val > a[orb].val) orb = i;
}
}
memset(v, 0, sizeof(v));
for (i = 0; i < pp[weapon]; i++) v[add[weapon][i]] = 1;
for (i = 0; i < pp[armor]; i++) v[add[armor][i]] = 1;
for (i = 0; i < pp[orb]; i++) v[add[orb][i]] = 1;
out(weapon);
out(armor);
out(orb);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:32000000")
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int ST = 10000005;
const int ST1 = 20000100;
const long long MOD = 1000000007;
struct Resident {
string name;
string type;
int bonus;
string home;
int homeIndex;
};
struct Thing {
string name;
string type;
int value;
int size;
vector<Resident> citizen;
};
int n, k, freeSlots;
Thing thing, bestW, bestA, bestO;
vector<Thing> t;
vector<Resident> r;
vector<int> wap, def, orb, other;
int col[15];
bool sortW(int a, int b) {
if (r[a].type != "weapon") {
return false;
}
if (r[b].type != "weapon") {
return true;
}
return (r[a].bonus > r[b].bonus);
}
bool sortA(int a, int b) {
if (r[a].type != "armor") {
return false;
}
if (r[b].type != "armor") {
return true;
}
return (r[a].bonus > r[b].bonus);
}
bool sortO(int a, int b) {
if (r[a].type != "orb") {
return false;
}
if (r[b].type != "orb") {
return true;
}
return (r[a].bonus > r[b].bonus);
}
int GetThingIndex(string name) {
for (int i = 0; true; ++i) {
if (t[i].name == name) {
return i;
}
}
}
void ReadThings() {
cin >> n;
Thing thing;
string name;
string type;
int atk;
int def;
int res;
int sz;
for (int i = 0; i < n; ++i) {
cin >> name >> type >> atk >> def >> res >> sz;
thing.name = name;
thing.type = type;
thing.size = sz;
thing.citizen.clear();
if (type == "weapon") {
thing.value = atk;
}
if (type == "armor") {
thing.value = def;
}
if (type == "orb") {
thing.value = res;
}
t.push_back(thing);
freeSlots += thing.size;
}
}
void ReadResidents() {
cin >> k;
freeSlots -= k;
Resident rz;
string name;
string type;
string home;
int bonus;
for (int i = 0; i < k; ++i) {
wap.push_back(i);
cin >> name >> type >> bonus >> home;
if (type == "gladiator") {
type = "weapon";
}
if (type == "sentry") {
type = "armor";
}
if (type == "physician") {
type = "orb";
}
rz.type = type;
rz.name = name;
rz.bonus = bonus;
rz.home = home;
rz.homeIndex = GetThingIndex(home);
r.push_back(rz);
t[rz.homeIndex].citizen.push_back(rz);
}
}
void WriteResults() {
cout << bestW.name << " " << bestW.citizen.size() << " ";
for (int i = 0; i < bestW.citizen.size(); ++i) {
if (i > 0) {
cout << " ";
}
cout << bestW.citizen[i].name;
}
cout << endl;
cout << bestA.name << " " << bestA.citizen.size() << " ";
for (int i = 0; i < bestA.citizen.size(); ++i) {
if (i > 0) {
cout << " ";
}
cout << bestA.citizen[i].name;
}
cout << endl;
cout << bestO.name << " " << bestO.citizen.size() << " ";
for (int i = 0; i < bestO.citizen.size(); ++i) {
if (i > 0) {
cout << " ";
}
cout << bestO.citizen[i].name;
}
cout << endl;
}
int main() {
ReadThings();
ReadResidents();
if (freeSlots > 0) {
bestW.value = -1;
bestA.value = -1;
bestO.value = -1;
sort(wap.begin(), wap.end(), sortW);
for (int i = 0; i <= 10; ++i) {
col[i] = 0;
}
for (int i = 1; i <= 10; ++i) {
col[i] = col[i - 1];
if ((i - 1 < wap.size()) && (r[wap[i - 1]].type == "weapon")) {
col[i] += r[wap[i - 1]].bonus;
}
}
for (int i = 0; i < t.size(); ++i) {
t[i].citizen.clear();
if ((t[i].type == "weapon") &&
(t[i].value + col[t[i].size] > bestW.value + col[bestW.size])) {
bestW = t[i];
}
}
int ind = 0;
while ((ind < wap.size()) && (r[wap[ind]].type == "weapon") &&
(ind < bestW.size)) {
bestW.citizen.push_back(r[wap[ind]]);
++ind;
}
for (int i = ind; i < wap.size(); ++i) {
def.push_back(wap[i]);
}
sort(def.begin(), def.end(), sortA);
for (int i = 0; i <= 10; ++i) {
col[i] = 0;
}
for (int i = 1; i <= 10; ++i) {
col[i] = col[i - 1];
if ((i - 1 < def.size()) && (r[def[i - 1]].type == "armor")) {
col[i] += r[def[i - 1]].bonus;
}
}
for (int i = 0; i < t.size(); ++i) {
t[i].citizen.clear();
if ((t[i].type == "armor") &&
(t[i].value + col[t[i].size] > bestA.value + col[bestA.size])) {
bestA = t[i];
}
}
ind = 0;
while ((ind < def.size()) && (r[def[ind]].type == "armor") &&
(ind < bestA.size)) {
bestA.citizen.push_back(r[def[ind]]);
++ind;
}
for (int i = ind; i < def.size(); ++i) {
orb.push_back(def[i]);
}
sort(orb.begin(), orb.end(), sortO);
for (int i = 0; i <= 10; ++i) {
col[i] = 0;
}
for (int i = 1; i <= 10; ++i) {
col[i] = col[i - 1];
if ((i - 1 < orb.size()) && (r[orb[i - 1]].type == "orb")) {
col[i] += r[orb[i - 1]].bonus;
}
}
for (int i = 0; i < t.size(); ++i) {
t[i].citizen.clear();
if ((t[i].type == "orb") &&
(t[i].value + col[t[i].size] > bestO.value + col[bestO.size])) {
bestO = t[i];
}
}
ind = 0;
while ((ind < orb.size()) && (r[orb[ind]].type == "orb") &&
(ind < bestO.size)) {
bestO.citizen.push_back(r[orb[ind]]);
++ind;
}
for (int i = ind; i < orb.size(); ++i) {
other.push_back(orb[i]);
}
ind = 0;
while ((ind < other.size()) && (bestW.citizen.size() != bestW.size)) {
bestW.citizen.push_back(r[other[ind]]);
++ind;
}
while ((ind < other.size()) && (bestA.citizen.size() != bestA.size)) {
bestA.citizen.push_back(r[other[ind]]);
++ind;
}
while ((ind < other.size()) && (bestO.citizen.size() != bestO.size)) {
bestO.citizen.push_back(r[other[ind]]);
++ind;
}
} else {
bestW.value = -1;
bestA.value = -1;
bestO.value = -1;
for (int i = 0; i < t.size(); ++i) {
int val = t[i].value;
for (int j = 0; j < t[i].citizen.size(); ++j) {
if (t[i].type == t[i].citizen[j].type) {
val += t[i].citizen[j].bonus;
}
}
if ((t[i].type == "weapon") && (bestW.value < val)) {
bestW = t[i];
bestW.value = val;
}
if ((t[i].type == "armor") && (bestA.value < val)) {
bestA = t[i];
bestA.value = val;
}
if ((t[i].type == "orb") && (bestO.value < val)) {
bestO = t[i];
bestO.value = val;
}
}
}
WriteResults();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : (-x);
}
template <class T>
T sqr(T x) {
return x * x;
}
bool cmp(pair<string, int> p, pair<string, int> q) {
return p.second > q.second;
}
int main() {
int n;
cin >> n;
map<string, vector<int> > w;
int sum = 0;
for (int i = 0; i < n; ++i) {
string name, s;
cin >> name >> s;
int t;
if (s == "weapon")
t = 0;
else if (s == "armor")
t = 1;
else if (s == "orb")
t = 2;
int a, d, r, si;
cin >> a >> d >> r >> si;
vector<int> v;
v.push_back(t);
v.push_back(a);
v.push_back(d);
v.push_back(r);
v.push_back(si);
w[name] = v;
sum += si;
}
int k;
cin >> k;
vector<pair<string, int> > gems[3];
vector<string> homes[3];
for (int i = 0; i < k; ++i) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
int t;
if (type == "gladiator")
t = 0;
else if (type == "sentry")
t = 1;
else if (type == "physician")
t = 2;
homes[t].push_back(home);
gems[t].push_back(make_pair(name, bonus));
}
if (k < sum) {
vector<string> r(3);
vector<int> val(3, -1);
for (int i = 0; i < 3; ++i) sort((gems[i]).begin(), (gems[i]).end(), cmp);
for (map<string, vector<int> >::iterator it = w.begin(); it != w.end();
++it) {
int t = w[it->first][0];
int x = w[it->first][1 + t];
int S = w[it->first][4];
for (int i = 0; i < ((int)(gems[t]).size()) && i < S; ++i)
x += gems[t][i].second;
if (x > val[t]) val[t] = x, r[t] = it->first;
}
queue<pair<int, int> > q;
for (int t = 0; t < 3; ++t) {
string s = r[t];
int S = w[s][4];
for (int i = 0; i < ((int)(gems[t]).size()); ++i) {
if (i < S)
homes[t][i] = s;
else {
homes[t][i] = '.';
q.push(pair<int, int>(t, i));
}
}
}
for (int t = 0; t < 3; ++t) {
string s = r[t];
int S = w[s][4];
for (int i = ((int)(gems[t]).size()); i < S; ++i) {
if (q.empty()) break;
int a = q.front().first;
int b = q.front().second;
q.pop();
homes[a][b] = s;
}
}
}
vector<string> r(3);
vector<int> val(3, -1);
for (map<string, vector<int> >::iterator it = w.begin(); it != w.end();
++it) {
int t = w[it->first][0];
int x = w[it->first][1 + t];
for (int i = 0; i < ((int)(gems[t]).size()); ++i)
if (homes[t][i] == it->first) x += gems[t][i].second;
if (x > val[t]) val[t] = x, r[t] = it->first;
}
for (int t = 0; t < 3; ++t) {
cout << r[t] << " ";
vector<string> v;
for (int tt = 0; tt < 3; ++tt)
for (int i = 0; i < ((int)(gems[tt]).size()); ++i)
if (homes[tt][i] == r[t]) v.push_back(gems[tt][i].first);
cout << ((int)(v).size());
sort((v).begin(), (v).end());
for (int i = 0; i < ((int)(v).size()); ++i) printf(" %s", v[i].c_str());
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double epsilon = 1e-9;
class weapon {
public:
string name;
string type;
int atk, def, res;
int space;
vector<string> residents;
friend ostream& operator<<(ostream& out, const weapon& w);
};
ostream& operator<<(ostream& out, const weapon& w) {
out << w.name << " " << w.residents.size();
for (int i = 0; i < w.residents.size(); i++) out << " " << w.residents[i];
return out;
}
class resident {
public:
string name;
string type;
int amount;
int idx;
};
void increase(weapon& w, const resident& r) {
w.residents.push_back(r.name);
if (r.type == "gladiator")
w.atk += r.amount;
else if (r.type == "sentry")
w.def += r.amount;
else
w.res += r.amount;
}
weapon bestWeapon(const vector<weapon>& v) {
int best = -1;
int bestIdx = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i].type == "weapon" && v[i].atk > best) {
best = v[i].atk;
bestIdx = i;
}
}
return v[bestIdx];
}
weapon bestArmor(const vector<weapon>& v) {
int best = -1;
int bestIdx = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i].type == "armor" && v[i].def > best) {
best = v[i].def;
bestIdx = i;
}
}
return v[bestIdx];
}
weapon bestOrb(const vector<weapon>& v) {
int best = -1;
int bestIdx = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i].type == "orb" && v[i].res > best) {
best = v[i].res;
bestIdx = i;
}
}
return v[bestIdx];
}
vector<bool> used;
vector<resident> findBestResidents(const weapon& w, const vector<resident>& v) {
string type;
if (w.type == "weapon")
type = "gladiator";
else if (w.type == "armor")
type = "sentry";
else
type = "physician";
int sz = w.space;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
for (int i = 0; i < v.size(); i++) {
if (v[i].type == type && (q.size() < sz || v[i].amount > q.top().first)) {
q.push(make_pair(v[i].amount, i));
if (q.size() > sz) q.pop();
}
}
vector<resident> toRet;
while (!q.empty()) {
toRet.push_back(v[q.top().second]);
q.pop();
}
return toRet;
}
int estimateWeapon(const weapon& w, const vector<resident>& v) {
vector<resident> res(findBestResidents(w, v));
int rs = 0;
if (w.type == "weapon")
rs = w.atk;
else if (w.type == "armor")
rs = w.def;
else
rs = w.res;
for (int i = 0; i < res.size(); i++) rs += res[i].amount;
return rs;
}
void addToWeapon(weapon& w, const vector<resident>& v) {
vector<resident> res(findBestResidents(w, v));
for (int i = 0; i < res.size(); i++) {
w.residents.push_back(res[i].name);
used[res[i].idx] = true;
}
}
int main() {
int n;
cin >> n;
vector<weapon> v(n);
map<string, int> weaponMap;
int totalSpace = 0;
for (int i = 0; i < n; i++) {
cin >> v[i].name >> v[i].type >> v[i].atk >> v[i].def >> v[i].res >>
v[i].space;
totalSpace += v[i].space;
weaponMap[v[i].name] = i;
}
int m;
cin >> m;
vector<resident> residents(m);
if (m == totalSpace) {
string owner;
for (int i = 0; i < m; i++) {
cin >> residents[i].name >> residents[i].type >> residents[i].amount >>
owner;
increase(v[weaponMap[owner]], residents[i]);
}
cout << bestWeapon(v) << endl;
cout << bestArmor(v) << endl;
cout << bestOrb(v) << endl;
return 0;
}
string owner;
for (int i = 0; i < m; i++) {
cin >> residents[i].name >> residents[i].type >> residents[i].amount >>
owner;
residents[i].idx = i;
}
used.resize(m, false);
int bestW = -1, bestA = -1, bestO = -1;
int bestWIdx, bestAIdx, bestOIdx;
for (int i = 0; i < v.size(); i++) {
int est = estimateWeapon(v[i], residents);
if (v[i].type == "weapon") {
if (bestW < est) {
bestW = est;
bestWIdx = i;
}
} else if (v[i].type == "armor") {
if (bestA < est) {
bestA = est;
bestAIdx = i;
}
} else {
if (bestO < est) {
bestO = est;
bestOIdx = i;
}
}
}
addToWeapon(v[bestWIdx], residents);
addToWeapon(v[bestAIdx], residents);
addToWeapon(v[bestOIdx], residents);
for (int i = 0; i < residents.size(); i++) {
if (!used[i]) {
if (v[bestWIdx].residents.size() < v[bestWIdx].space)
v[bestWIdx].residents.push_back(residents[i].name);
else if (v[bestAIdx].residents.size() < v[bestAIdx].space)
v[bestAIdx].residents.push_back(residents[i].name);
else if (v[bestOIdx].residents.size() < v[bestOIdx].space)
v[bestOIdx].residents.push_back(residents[i].name);
}
}
cout << v[bestWIdx] << endl;
cout << v[bestAIdx] << endl;
cout << v[bestOIdx] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[50], s2[50], s3[50];
struct P {
int v, s;
};
map<string, P> mp[3];
int a[3][200];
char s[100];
int main() {
int i, j, k, m, n;
int tt = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
int atk, def, res, si;
scanf("%s%s", s1, s2);
scanf("%d%d%d%d", &atk, &def, &res, &si);
if (s2[0] == 'w') {
mp[0][s1].v = atk;
mp[0][s1].s = si;
} else if (s2[0] == 'a') {
mp[1][s1].v = def;
mp[1][s1].s = si;
} else {
mp[2][s1].v = res;
mp[2][s1].s = si;
}
tt += si;
}
scanf("%d", &k);
vector<pair<int, string> > v[3], v2[3];
for (i = 0; i < k; i++) {
int val;
scanf("%s%s%d%s", s1, s2, &val, s3);
if (s2[0] == 'g') {
v[0].push_back(make_pair(val, s3));
v2[0].push_back(make_pair(val, s1));
} else if (s2[0] == 's') {
v[1].push_back(make_pair(val, s3));
v2[1].push_back(make_pair(val, s1));
} else {
v[2].push_back(make_pair(val, s3));
v2[2].push_back(make_pair(val, s1));
}
}
if (k == tt) {
for (i = 0; i < 3; i++) {
for (j = 0; j < v[i].size(); j++) {
if (mp[i].count(v[i][j].second))
mp[i][v[i][j].second].v += v[i][j].first;
}
map<string, P>::iterator it2 = mp[i].begin();
for (map<string, P>::iterator it = mp[i].begin(); it != mp[i].end(); it++)
if (it->second.v > it2->second.v) it2 = it;
vector<string> ans;
for (int l = 0; l < 3; l++) {
for (j = 0; j < v[l].size(); j++) {
if (it2->first == v[l][j].second) ans.push_back(v2[l][j].second);
}
}
printf("%s %d", it2->first.c_str(), ans.size());
for (j = 0; j < ans.size(); j++) printf(" %s", ans[j].c_str());
puts("");
}
} else {
vector<string> ans[3];
string name[3];
set<string> st;
for (i = 0; i < 3; i++) {
sort(v2[i].begin(), v2[i].end());
map<string, P>::iterator it2 = mp[i].begin();
for (map<string, P>::iterator it = mp[i].begin(); it != mp[i].end();
it++) {
int t = 0;
for (j = v2[i].size() - 1; j >= 0 && t < it->second.s; j--, t++) {
it->second.v += v2[i][j].first;
}
if (it->second.v > it2->second.v) it2 = it;
}
name[i] = it2->first;
for (j = v2[i].size() - 1; j >= 0 && ans[i].size() < it2->second.s; j--) {
ans[i].push_back(v2[i][j].second);
st.insert(v2[i][j].second);
}
}
for (i = 0; i < 3; i++)
for (j = 0; j < v2[i].size(); j++)
if (!st.count(v2[i][j].second)) {
for (int l = 0; l < 3; l++)
if (ans[l].size() < mp[l][name[l]].s) {
ans[l].push_back(v2[i][j].second);
st.insert(v2[i][j].second);
break;
}
}
for (i = 0; i < 3; i++) {
printf("%s %d", name[i].c_str(), ans[i].size());
for (j = 0; j < ans[i].size(); j++) printf(" %s", ans[i][j].c_str());
puts("");
}
}
scanf("%*d");
}
|
#include <bits/stdc++.h>
using namespace std;
enum ItemType { WEAPON, ARMOR, ORB };
enum PersonType { GLADIATOR, SENTRY, PHYSICIAN };
struct Item {
string name;
ItemType type;
vector<int> skills;
int size;
};
struct Person {
string name;
PersonType type;
int bonus;
string home;
};
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int n;
cin >> n;
map<string, Item> items;
vector<string> itemTypes[3];
for (int i = (0); i < ((n)); ++i) {
Item item;
string type;
cin >> item.name >> type;
if (type == "weapon")
item.type = WEAPON;
else if (type == "armor")
item.type = ARMOR;
else
item.type = ORB;
item.skills.resize(3);
for (int j = (0); j < ((3)); ++j) cin >> item.skills[j];
cin >> item.size;
items[item.name] = item;
itemTypes[item.type].push_back(item.name);
}
int m;
cin >> m;
map<string, Person> persons;
map<string, vector<int> > bonuses;
map<string, vector<string> > itemsPersons;
vector<string> personTypes[3];
int fullItems = 0;
vector<pair<int, string> > personBonuses[3];
set<string> remaining;
set<pair<vector<int>, string>, greater<pair<vector<int>, string> > > rem;
for (int i = (0); i < ((m)); ++i) {
Person p;
string type;
cin >> p.name >> type;
if (type == "gladiator")
p.type = GLADIATOR;
else if (type == "sentry")
p.type = SENTRY;
else
p.type = PHYSICIAN;
cin >> p.bonus >> p.home;
persons[p.name] = p;
bonuses[p.home].resize(3);
bonuses[p.home][p.type] += p.bonus;
itemsPersons[p.home].push_back(p.name);
if ((int)itemsPersons[p.home].size() == items[p.home].size) {
++fullItems;
}
remaining.insert(p.name);
personTypes[p.type].push_back(p.name);
personBonuses[p.type].push_back(make_pair(p.bonus, p.name));
vector<int> skills(3);
skills[p.type] = p.bonus;
rem.insert(make_pair(skills, p.name));
}
if (fullItems == n) {
for (int itemType = (0); itemType < ((3)); ++itemType) {
vector<int> bestBonus(3);
string bestItem;
for (map<string, Item>::const_iterator it = items.begin();
it != items.end(); ++it) {
Item const& item = it->second;
if (item.type != itemType) continue;
vector<int> skills = item.skills;
skills[itemType] += bonuses[item.name][itemType];
if (bestBonus[itemType] < skills[itemType] ||
bestBonus[itemType] == skills[itemType] && bestBonus < skills ||
bestItem.empty()) {
bestBonus = skills;
bestItem = item.name;
}
}
vector<string> const& p = itemsPersons[bestItem];
cout << bestItem << " " << (int)p.size();
for (int i = (0); i < (((int)p.size())); ++i) cout << " " << p[i];
cout << endl;
}
return 0;
}
for (int i = (0); i < ((3)); ++i) {
for (int j = (0); j < (((int)personTypes[i].size())); ++j)
persons[personTypes[i][j]].home = "";
sort(personBonuses[i].begin(), personBonuses[i].end());
reverse(personBonuses[i].begin(), personBonuses[i].end());
}
string resultNames[3];
vector<string> result[3];
for (int itemType = (0); itemType < ((3)); ++itemType) {
vector<string> const& cand = personTypes[itemType];
string bestItem;
vector<int> bestSkills(3);
for (int itemIndex = (0); itemIndex < (((int)itemTypes[itemType].size()));
++itemIndex) {
Item const& currentItem = items[itemTypes[itemType][itemIndex]];
int skills = 0;
for (int i = (0); i < ((min((int)cand.size(), currentItem.size))); ++i) {
skills += personBonuses[itemType][i].first;
}
vector<int> newSkills = currentItem.skills;
newSkills[itemType] += skills;
if (bestSkills[itemType] < newSkills[itemType] ||
bestSkills[itemType] == newSkills[itemType] &&
bestSkills < newSkills ||
bestItem.empty()) {
bestSkills = newSkills;
bestItem = currentItem.name;
}
}
int added = 0;
Item const& currentItem = items[bestItem];
for (int i = (0); i < ((min((int)cand.size(), currentItem.size))); ++i) {
string const& pname = personBonuses[itemType][i].second;
Person const& pp = persons[pname];
persons[pname].home = bestItem;
vector<int> skills(3);
skills[pp.type] = pp.bonus;
remaining.erase(pname);
result[itemType].push_back(pname);
rem.erase(rem.find(make_pair(skills, pp.name)));
++added;
}
items[bestItem].size -= added;
resultNames[itemType] = bestItem;
}
for (int itemType = (0); itemType < ((3)); ++itemType) {
Item& item = items[resultNames[itemType]];
while (!remaining.empty() && item.size) {
string const& pname = rem.begin()->second;
persons[pname].home = item.name;
result[item.type].push_back(pname);
remaining.erase(pname);
rem.erase(rem.begin());
--item.size;
}
}
for (map<string, Item>::iterator it = items.begin(); it != items.end();
++it) {
Item& item = it->second;
while (!remaining.empty() && item.size > 0) {
string const& pname = rem.begin()->second;
persons[pname].home = item.name;
rem.erase(rem.begin());
remaining.erase(pname);
--item.size;
}
}
for (int i = (0); i < ((3)); ++i) {
cout << resultNames[i] << " " << (int)result[i].size();
for (int j = (0); j < (((int)result[i].size())); ++j)
cout << " " << result[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct resident {
string name;
int type;
int bonus;
int home;
int ind;
bool operator<(const resident& b) const { return bonus > b.bonus; }
};
struct item {
int ind;
int clas;
int atk;
int def;
int res;
string name;
int basebonus;
vector<resident> residents;
int size;
bool operator<(const item& b) const {
if (clas == 0) return atk + basebonus > b.atk + b.basebonus;
if (clas == 1) return def + basebonus > b.def + b.basebonus;
if (clas == 2) return res + basebonus > b.res + b.basebonus;
}
};
int n;
int m;
item items[111];
vector<item> iatk;
vector<item> idef;
vector<item> ires;
resident residents[1111];
vector<resident> ratk;
vector<resident> rdef;
vector<resident> rres;
int sizesum;
bool read() {
if (scanf("%d", &n) == EOF) return false;
sizesum = 0;
iatk.clear();
idef.clear();
ires.clear();
ratk.clear();
rdef.clear();
rres.clear();
for (int i = 0; i < n; i++) {
item a;
a.ind = i;
a.basebonus = 0;
a.residents.clear();
string clas;
cin >> a.name >> clas >> a.atk >> a.def >> a.res >> a.size;
if (clas == "weapon")
a.clas = 0;
else if (clas == "armor")
a.clas = 1;
else
a.clas = 2;
sizesum += a.size;
items[i] = a;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
resident a;
string type;
string home;
cin >> a.name >> type >> a.bonus >> home;
if (type == "gladiator") a.type = 0;
if (type == "sentry") a.type = 1;
if (type == "physician") a.type = 2;
for (int i = 0; i < n; i++)
if (items[i].name == home) a.home = i;
if (items[a.home].clas == a.type) items[a.home].basebonus += a.bonus;
items[a.home].residents.push_back(a);
if (a.type == 0) ratk.push_back(a);
if (a.type == 1) rdef.push_back(a);
if (a.type == 2) rres.push_back(a);
}
for (int i = 0; i < n; i++) {
item a = items[i];
if (a.clas == 0) iatk.push_back(a);
if (a.clas == 1) idef.push_back(a);
if (a.clas == 2) ires.push_back(a);
}
return true;
}
void print_item(item a) {
cout << a.name << " ";
cout << a.residents.size();
for (int i = 0; i < a.residents.size(); i++)
cout << " " << a.residents[i].name;
cout << endl;
}
void process() {
sort(iatk.begin(), iatk.end());
sort(idef.begin(), idef.end());
sort(ires.begin(), ires.end());
sort(ratk.begin(), ratk.end());
sort(rdef.begin(), rdef.end());
sort(rres.begin(), rres.end());
item batk, bdef, bres;
batk.clas = 0;
batk.atk = -100000;
batk.basebonus = 0;
bdef.clas = 1;
bdef.def = -100000;
bdef.basebonus = 0;
bres.clas = 2;
bres.res = -100000;
bres.basebonus = 0;
if (sizesum == m) {
print_item(iatk[0]);
print_item(idef[0]);
print_item(ires[0]);
} else {
for (int i = 0; i < iatk.size(); i++) {
item a = iatk[i];
a.residents.clear();
a.basebonus = 0;
for (int j = 0; j < a.size && j < ratk.size(); j++) {
a.residents.push_back(ratk[j]);
a.basebonus += ratk[j].bonus;
}
if (a < batk) {
batk = a;
}
}
for (int i = 0; i < idef.size(); i++) {
item a = idef[i];
a.residents.clear();
a.basebonus = 0;
for (int j = 0; j < a.size && j < rdef.size(); j++) {
a.residents.push_back(rdef[j]);
a.basebonus += rdef[j].bonus;
}
if (a < bdef) bdef = a;
}
for (int i = 0; i < ires.size(); i++) {
item a = ires[i];
a.residents.clear();
a.basebonus = 0;
for (int j = 0; j < a.size && j < rres.size(); j++) {
a.residents.push_back(rres[j]);
a.basebonus += rres[j].bonus;
}
if (a < bres) bres = a;
}
vector<resident> homeless;
for (int i = batk.residents.size(); i < ratk.size(); i++)
homeless.push_back(ratk[i]);
for (int i = bdef.residents.size(); i < rdef.size(); i++)
homeless.push_back(rdef[i]);
for (int i = bres.residents.size(); i < rres.size(); i++)
homeless.push_back(rres[i]);
while (homeless.size() > 0 && batk.size > batk.residents.size()) {
batk.residents.push_back(homeless[homeless.size() - 1]);
homeless.pop_back();
}
while (homeless.size() > 0 && bdef.size > bdef.residents.size()) {
bdef.residents.push_back(homeless[homeless.size() - 1]);
homeless.pop_back();
}
while (homeless.size() > 0 && bres.size > bres.residents.size()) {
bres.residents.push_back(homeless[homeless.size() - 1]);
homeless.pop_back();
}
print_item(batk);
print_item(bdef);
print_item(bres);
}
}
int main() {
while (read()) process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string a1[3] = {"weapon", "armor", "orb"},
a2[4] = {"gladiator", "sentry", "physician"};
struct ww {
int a, b, id;
} b[1010], c[1010];
int i, j, k, n, m, t, S, sheng;
int zhi[1010], id[1010], in[1010], an[3], re[3], F[1010];
string s[1010], p[1010];
inline int get1() {
string ss;
cin >> ss;
int i;
for (i = 1; i <= n; i++)
if (s[i] == ss) return i;
}
inline int get2() {
int i;
string s;
cin >> s;
for (i = 0; i <= 2; i++)
if (a1[i] == s) return i;
}
inline int get3() {
int i;
string s;
cin >> s;
for (i = 0; i <= 2; i++)
if (a2[i] == s) return i;
}
inline void Pan() {
for (i = 0; i <= 2; i++) {
int ma = -1, id;
for (j = 1; j <= n; j++)
if (b[j].id == i && zhi[j] > ma) ma = zhi[j], id = j;
cout << s[id];
printf(" %d", in[id]);
for (j = 1; j <= m; j++)
if (c[j].b == id) cout << " " << p[j];
printf("\n");
}
exit(0);
}
inline bool cc1(const int &A, const int &B) { return c[A].a > c[B].a; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
cin >> s[i];
int B = get2(), c[3], x;
for (j = 0; j <= 2; j++) scanf("%d", &c[j]);
scanf("%d", &x);
b[i] = (ww){c[B], x, B};
zhi[i] = c[B];
S += x;
}
scanf("%d", &m);
for (i = 1; i <= m; i++) {
cin >> p[i];
int A = get3(), x;
scanf("%d", &x);
int B = get1();
if (A == b[B].id) zhi[B] += x;
c[i] = (ww){x, B, A};
id[i] = i;
in[B]++;
}
if (S == m) Pan();
sort(id + 1, id + m + 1, cc1);
sheng = m;
for (i = 0; i <= 2; i++) {
int ma = -1, Id, ge;
for (j = 1; j <= n; j++)
if (b[j].id == i) {
int s = b[j].a, Size = b[j].b;
for (k = 1; k <= m; k++) {
int A = id[k];
if (c[A].id == i && Size) {
Size--;
s += c[A].a;
}
}
if (s > ma) ma = s, Id = j, ge = b[j].b - Size;
}
an[i] = Id;
re[i] = ge;
{
int Size = b[Id].b;
for (k = 1; k <= m; k++) {
int A = id[k];
if (c[A].id == i && Size) {
Size--;
F[A] = i + 1;
sheng--;
}
}
}
}
for (i = 0; i <= 2; i++) {
int Sh = min(b[an[i]].b - re[i], sheng);
cout << s[an[i]];
printf(" %d", re[i] + Sh);
for (j = 1; j <= m; j++)
if (!F[j] && Sh) {
cout << " " << p[j];
Sh--;
sheng--;
F[j] = -1;
}
for (j = 1; j <= m; j++)
if (F[j] == i + 1) cout << " " << p[j];
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
string name;
int type;
int num[3];
int size;
vector<pair<int, int> > has;
};
Node node[102];
int n;
int getName(string str) {
for (int i = 0; i < n; i++) {
if (node[i].name == str) {
return i;
}
}
return -1;
}
string type[6] = {"weapon", "armor", "orb", "gladiator", "sentry", "physician"};
int getType(string str) {
for (int i = 0; i < 6; i++) {
if (type[i] == str) {
return i % 3;
}
}
return -1;
}
struct Res {
string name;
int plus;
bool inUsed;
bool operator<(Res o) const { return plus > o.plus; }
};
vector<Res> res[3];
int getNodeNum(int n, int t) {
int ret = node[n].num[t];
int size = node[n].has.size();
for (int i = 0; i < size; i++) {
pair<int, int> j = node[n].has[i];
if (j.first == t) {
ret += res[t][j.second].plus;
}
}
return ret;
}
void printNode(int n) {
int size = node[n].has.size();
cout << node[n].name << " " << size;
for (int i = 0; i < size; i++) {
pair<int, int> j = node[n].has[i];
cout << " " << res[j.first][j.second].name;
}
cout << endl;
}
int main() {
while (cin >> n) {
string tmp;
int size = 0;
for (int i = 0; i < n; i++) {
cin >> node[i].name >> tmp;
for (int j = 0; j < 3; j++) {
cin >> node[i].num[j];
}
cin >> node[i].size;
node[i].type = getType(tmp);
size += node[i].size;
}
int k;
cin >> k;
Res t;
for (int i = 0; i < k; i++) {
t.inUsed = false;
cin >> t.name >> tmp >> t.plus;
int type = getType(tmp);
cin >> tmp;
int name = getName(tmp);
res[type].push_back(t);
node[name].has.push_back(pair<int, int>(type, res[type].size() - 1));
}
if (size == k) {
for (int i = 0; i < 3; i++) {
int maxNum = -1;
int maxIndex = -1;
for (int j = 0; j < n; j++) {
if (node[j].type != i) {
continue;
}
int tt = getNodeNum(j, i);
if (tt > maxNum) {
maxIndex = j;
maxNum = tt;
}
}
printNode(maxIndex);
}
} else {
int maxNum[102];
int choice[3];
for (int i = 0; i < 3; i++) {
sort(res[i].begin(), res[i].end());
int maxNumber = -1;
int maxIndex = -1;
for (int j = 0; j < n; j++) {
if (node[j].type != i) {
continue;
}
maxNum[j] = node[j].num[i];
int size = res[i].size();
size = min(size, node[j].size);
for (int k = 0; k < size; k++) {
maxNum[j] += res[i][k].plus;
}
if (maxNum[j] > maxNumber) {
maxNumber = maxNum[j];
maxIndex = j;
}
}
choice[i] = maxIndex;
node[maxIndex].has.clear();
int size = res[i].size();
size = min(size, node[maxIndex].size);
for (int k = 0; k < size; k++) {
res[i][k].inUsed = true;
node[maxIndex].has.push_back(pair<int, int>(i, k));
}
}
for (int i = 0; i < 3; i++) {
int j = choice[i];
int cnt = node[j].size - node[j].has.size();
for (int ii = 0; ii < 3 && cnt != 0; ii++) {
int size = res[ii].size();
for (int jj = 0; jj < size && cnt != 0; jj++) {
if (res[ii][jj].inUsed == false) {
node[j].has.push_back(pair<int, int>(ii, jj));
res[ii][jj].inUsed = true;
cnt--;
}
}
}
}
for (int i = 0; i < 3; i++) {
printNode(choice[i]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
template <class T>
bool INRANGE(T x, T a, T b) {
return a <= x && x <= b;
}
enum ECLASS {
ATK,
DEF,
RES,
NUM_CLASS,
};
int main() {
int N;
scanf("%d ", &N);
map<pair<int, string>, int> items[NUM_CLASS];
map<string, int> items_simple[NUM_CLASS];
int whole_size = 0;
for (int i = 0; i < N; i++) {
string name, clas;
int atk, def, res, sz;
cin >> name >> clas >> atk >> def >> res >> sz;
ECLASS eclass;
int tuyosa;
if (clas == "weapon") {
eclass = ATK;
tuyosa = atk;
} else if (clas == "armor") {
eclass = DEF;
tuyosa = def;
} else if (clas == "orb") {
eclass = RES;
tuyosa = res;
}
items[eclass][make_pair(sz, name)] = tuyosa;
items_simple[eclass][name] = tuyosa;
whole_size += sz;
}
int K;
scanf("%d ", &K);
vector<pair<int, string> > yousei[NUM_CLASS];
map<string, vector<string> > resi_info;
set<string> unused_yousei_name;
for (int i = 0; i < K; i++) {
int bonus;
string name, clas, item_name;
cin >> name >> clas >> bonus >> item_name;
ECLASS eclass;
if (clas == "gladiator") {
eclass = ATK;
} else if (clas == "sentry") {
eclass = DEF;
} else if (clas == "physician") {
eclass = RES;
}
yousei[eclass].push_back(make_pair(bonus, name));
resi_info[item_name].push_back(name);
unused_yousei_name.insert(name);
if (items_simple[eclass].count(item_name)) {
items_simple[eclass][item_name] += bonus;
}
}
if (whole_size == K) {
for (int i = 0; i < NUM_CLASS; i++) {
string best_name;
int best_tsuyosa = (-1);
for (map<string, int>::iterator it = items_simple[i].begin();
it != items_simple[i].end(); it++) {
if (it->second > best_tsuyosa) {
best_tsuyosa = it->second;
best_name = it->first;
}
}
printf("%s %d ", best_name.c_str(), ((int)resi_info[best_name].size()));
for (int k = 0; k < ((int)resi_info[best_name].size()); k++) {
printf("%s ", resi_info[best_name][k].c_str());
}
printf("\n");
}
} else {
pair<int, string> best_name[NUM_CLASS];
vector<string> best_youseis[NUM_CLASS];
for (int i = 0; i < NUM_CLASS; i++) {
sort(yousei[i].rbegin(), yousei[i].rend());
int best_tsuyosa = (-1);
int best_num_yousei = (-1);
int now_size = 0;
int now_sum_bonus = 0;
for (map<pair<int, string>, int>::iterator it = items[i].begin();
it != items[i].end(); it++) {
while (it->first.first > now_size &&
((int)yousei[i].size()) > now_size) {
now_sum_bonus += yousei[i][now_size].first;
now_size++;
}
const int now_tsuyosa = it->second + now_sum_bonus;
if (now_tsuyosa > best_tsuyosa) {
best_tsuyosa = now_tsuyosa;
best_name[i] = it->first;
best_num_yousei = now_size;
}
}
for (int k = 0; k < best_num_yousei; k++) {
best_youseis[i].push_back(yousei[i][k].second);
unused_yousei_name.erase(yousei[i][k].second);
}
}
for (int i = 0; i < NUM_CLASS; i++) {
while (((int)unused_yousei_name.size()) &&
best_name[i].first > ((int)best_youseis[i].size())) {
best_youseis[i].push_back(*unused_yousei_name.begin());
unused_yousei_name.erase(unused_yousei_name.begin());
}
printf("%s %d ", best_name[i].second.c_str(),
((int)best_youseis[i].size()));
for (int k = 0; k < ((int)best_youseis[i].size()); k++) {
printf("%s ", best_youseis[i][k].c_str());
}
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool checkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
map<string, int> wid, rid;
string wname[110], rname[1100];
int inc[1100], val[110], wtype[1100], rtype[1100], sz[1100], loc[1100],
cnt[1100];
vector<int> item[3], res[3];
bool used[1100];
pair<int, int> best[3];
vector<int> ans[110];
inline int get_wtype(const string &s) {
if (s == "weapon") return 0;
if (s == "armor") return 1;
return 2;
}
inline int get_rtype(const string &s) {
if (s == "gladiator") return 0;
if (s == "sentry") return 1;
return 2;
}
inline bool cmp_val(const int &l, const int &r) { return val[l] > val[r]; }
inline bool cmp_inc(const int &l, const int &r) { return inc[l] > inc[r]; }
int main() {
int N, M;
cin >> N;
for (int i = 0; i < (N); ++i) {
string type;
int atk, def, res;
cin >> wname[i] >> type >> atk >> def >> res >> sz[i];
wid[wname[i]] = i;
int tmp;
item[tmp = wtype[i] = get_wtype(type)].push_back(i);
if (tmp == 0) {
val[i] = atk;
} else if (tmp == 1) {
val[i] = def;
} else {
val[i] = res;
}
}
cin >> M;
for (int i = 0; i < (M); ++i) {
string type, locname;
cin >> rname[i] >> type >> inc[i] >> locname;
loc[i] = wid[locname];
cnt[loc[i]]++;
res[rtype[i] = get_rtype(type)].push_back(i);
}
bool found = false;
for (int i = 0; i < (N); ++i) {
if (cnt[i] < sz[i]) {
found = true;
break;
}
}
if (found) {
for (int i = 0; i < (3); ++i) {
sort(res[i].begin(), res[i].end(), cmp_inc);
}
for (int i = 0; i < (N); ++i) {
ans[i].clear();
}
memset(used, false, sizeof(bool) * M);
for (int type = 0; type < (3); ++type) {
best[type] = make_pair((-1), (-1));
for (int i = 0; i < (((int)(item[type].size()))); ++i) {
int sum = val[item[type][i]];
for (int j = 0; j < ((int)(res[type].size())) && j < sz[item[type][i]];
++j) {
sum += inc[res[type][j]];
}
checkmax(best[type], make_pair((sum), (item[type][i])));
}
for (int j = 0;
j < ((int)(res[type].size())) && j < sz[best[type].second]; ++j) {
ans[best[type].second].push_back(res[type][j]);
used[res[type][j]] = true;
}
}
for (int i = 0; i < (M); ++i) {
if (!used[i]) {
for (int j = 0; j < (N); ++j) {
if (((int)(ans[j].size())) < sz[j]) {
ans[j].push_back(i);
break;
}
}
}
}
for (int i = 0; i < (3); ++i) {
cout << wname[best[i].second] << " "
<< ((int)(ans[best[i].second].size()));
for (int j = 0; j < (((int)(ans[best[i].second].size()))); ++j) {
cout << " " << rname[ans[best[i].second][j]];
}
cout << endl;
}
} else {
for (int i = 0; i < (3); ++i) {
for (int j = 0; j < (((int)(res[i].size()))); ++j) {
if (wtype[loc[res[i][j]]] == i) {
val[loc[res[i][j]]] += inc[res[i][j]];
}
}
}
for (int type = 0; type < (3); ++type) {
sort(item[type].begin(), item[type].end(), cmp_val);
cout << wname[item[type][0]] << " " << cnt[item[type][0]];
for (int i = 0; i < (3); ++i) {
for (int j = 0; j < (((int)(res[i].size()))); ++j) {
if (loc[res[i][j]] == item[type][0]) cout << " " << rname[res[i][j]];
}
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, orr[1111], now[1333], sz[3133], d[3133], nor[1111], dd[1111];
string na[1111], ty[1111], nam[1111], typ[1111], g;
vector<string> v[3133];
map<string, int> M;
set<string> B;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> na[i] >> ty[i] >> x >> y >> z >> sz[i];
M[na[i]] = i;
if (ty[i][0] == 'w') orr[i] = x;
if (ty[i][0] == 'a') orr[i] = y;
if (ty[i][0] == 'o') orr[i] = z;
nor[i] = orr[i];
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> nam[i] >> typ[i] >> d[i] >> g;
int o = M[g];
v[o].push_back(nam[i]);
if (ty[o][0] == 'w' && typ[i][0] == 'g' ||
ty[o][0] == 'a' && typ[i][0] == 's' ||
ty[o][0] == 'o' && typ[i][0] == 'p')
nor[o] += d[i];
}
int t = 0;
for (int i = 0; i < n; i++)
if (v[i].size() < sz[i]) t = 1;
if (!t) {
int oo = -1, l = 0;
for (int i = 0; i < n; i++)
if (ty[i][0] == 'w' && nor[i] > oo) oo = nor[i], l = i;
cout << na[l] << " " << v[l].size();
for (int i = 0; i < v[l].size(); i++) cout << " " << v[l][i];
puts("");
oo = -1, l = 0;
for (int i = 0; i < n; i++)
if (ty[i][0] == 'a' && nor[i] > oo) oo = nor[i], l = i;
cout << na[l] << " " << v[l].size();
for (int i = 0; i < v[l].size(); i++) cout << " " << v[l][i];
puts("");
oo = -1, l = 0;
for (int i = 0; i < n; i++)
if (ty[i][0] == 'o' && nor[i] > oo) oo = nor[i], l = i;
cout << na[l] << " " << v[l].size();
for (int i = 0; i < v[l].size(); i++) cout << " " << v[l][i];
puts("");
return 0;
}
int oo = -1, l1 = 0, l2 = 0, l3 = 0;
vector<pair<int, string> > uu1, uu2, uu3;
for (int i = 0; i < m; i++)
if (typ[i][0] == 'g') uu1.push_back(make_pair(d[i], nam[i]));
if (uu1.size()) {
sort(uu1.rbegin(), uu1.rend());
dd[0] = uu1[0].first;
for (int i = 1; i < uu1.size(); i++) dd[i] = dd[i - 1] + uu1[i].first;
for (int i = 0; i < n; i++)
if (ty[i][0] == 'w' && orr[i] + dd[min(sz[i], (int)uu1.size()) - 1] > oo)
oo = orr[i] + dd[min(sz[i], (int)uu1.size()) - 1], l1 = i;
} else
for (int i = 0; i < n; i++)
if (ty[i][0] == 'w' && orr[i] > oo) oo = orr[i], l1 = i;
for (int i = 0; i < m; i++)
if (typ[i][0] == 's') uu2.push_back(make_pair(d[i], nam[i]));
oo = -1;
if (uu2.size()) {
sort(uu2.rbegin(), uu2.rend());
dd[0] = uu2[0].first;
for (int i = 1; i < uu2.size(); i++) dd[i] = dd[i - 1] + uu2[i].first;
for (int i = 0; i < n; i++)
if (ty[i][0] == 'a' && orr[i] + dd[min(sz[i], (int)uu2.size()) - 1] > oo)
oo = orr[i] + dd[min(sz[i], (int)uu2.size()) - 1], l2 = i;
} else
for (int i = 0; i < n; i++)
if (ty[i][0] == 'a' && orr[i] > oo) oo = orr[i], l2 = i;
for (int i = 0; i < m; i++)
if (typ[i][0] == 'p') uu3.push_back(make_pair(d[i], nam[i]));
oo = -1;
if (uu3.size()) {
sort(uu3.rbegin(), uu3.rend());
dd[0] = uu3[0].first;
for (int i = 1; i < uu3.size(); i++) dd[i] = dd[i - 1] + uu3[i].first;
for (int i = 0; i < n; i++)
if (ty[i][0] == 'o' && orr[i] + dd[min(sz[i], (int)uu3.size()) - 1] > oo)
oo = orr[i] + dd[min(sz[i], (int)uu3.size()) - 1], l3 = i;
} else
for (int i = 0; i < n; i++)
if (ty[i][0] == 'o' && orr[i] > oo) oo = orr[i], l3 = i;
for (int i = min(sz[l1], (int)uu1.size()); i < uu1.size(); i++)
B.insert(uu1[i].second);
for (int i = min(sz[l2], (int)uu2.size()); i < uu2.size(); i++)
B.insert(uu2[i].second);
for (int i = min(sz[l3], (int)uu3.size()); i < uu3.size(); i++)
B.insert(uu3[i].second);
while (uu1.size() < sz[l1]) {
if (B.begin() == B.end()) break;
uu1.push_back(make_pair(0, *B.begin()));
B.erase(B.begin());
}
while (uu2.size() < sz[l2]) {
if (B.begin() == B.end()) break;
uu2.push_back(make_pair(0, *B.begin()));
B.erase(B.begin());
}
while (uu3.size() < sz[l3]) {
if (B.begin() == B.end()) break;
uu3.push_back(make_pair(0, *B.begin()));
B.erase(B.begin());
}
cout << na[l1] << " " << min(sz[l1], (int)uu1.size());
for (int i = 0; i < min(sz[l1], (int)uu1.size()); i++)
cout << " " << uu1[i].second;
puts("");
cout << na[l2] << " " << min(sz[l2], (int)uu2.size());
for (int i = 0; i < min(sz[l2], (int)uu2.size()); i++)
cout << " " << uu2[i].second;
puts("");
cout << na[l3] << " " << min(sz[l3], (int)uu3.size());
for (int i = 0; i < min(sz[l3], (int)uu3.size()); i++)
cout << " " << uu3[i].second;
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, e, l, n, m, t, xx, K[3];
char ss[22], tt[22];
string st;
vector<string> s[3], p[3];
vector<int> em, a[3], x[3], y[3], z[3], q[3], sr[3], su[3], o, v, cur, curv;
vector<vector<int> > b[3], c[3];
bool cmp(int x, int y) { return q[j][x] > q[j][y]; }
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", ss);
scanf("%s", tt);
if (tt[0] == 'w')
t = 0;
else if (tt[0] == 'a')
t = 1;
else
t = 2;
s[t].push_back(ss);
scanf("%d", &xx);
x[t].push_back(xx);
scanf("%d", &xx);
y[t].push_back(xx);
scanf("%d", &xx);
z[t].push_back(xx);
scanf("%d", &xx);
a[t].push_back(xx);
b[t].push_back(em);
c[t].push_back(em);
}
scanf("%d", &m);
while (m--) {
scanf("%s", ss);
scanf("%s", tt);
if (tt[0] == 'g')
t = 0;
else if (tt[0] == 's')
t = 1;
else
t = 2;
p[t].push_back(ss);
scanf("%d", &xx);
q[t].push_back(xx);
scanf("%s", ss);
st = ss;
sr[t].push_back(q[t].size() - 1);
su[t].push_back(0);
for (j = 0; j < 3; j++) {
for (i = 0; i < s[j].size(); i++)
if (s[j][i] == st) break;
if (i < s[j].size()) {
b[j][i].push_back(t);
c[j][i].push_back(q[t].size() - 1);
break;
}
}
}
for (j = 0; j < 3; j++) {
for (i = 0; i < s[j].size(); i++)
if (b[j][i].size() < a[j][i]) break;
if (i < s[j].size()) break;
}
if (j < 3) {
for (j = 0; j < 3; j++) {
if (sr[j].size() > 0) {
sort(sr[j].begin(), sr[j].end(), cmp);
su[j][0] = q[j][sr[j][0]];
for (i = 1; i < sr[j].size(); i++)
su[j][i] = su[j][i - 1] + q[j][sr[j][i]];
}
for (k = e = i = 0; i < s[j].size(); i++) {
if (j == 0)
xx = x[j][i];
else if (j == 1)
xx = y[j][i];
else
xx = z[j][i];
if (su[j].size() > 0) {
if (a[j][i] < su[j].size())
xx += su[j][a[j][i] - 1];
else
xx += su[j][su[j].size() - 1];
}
if (xx > e) {
e = xx;
k = i;
}
}
K[j] = k;
for (i = a[j][k]; i < sr[j].size(); i++) {
o.push_back(j);
v.push_back(sr[j][i]);
}
}
for (xx = j = 0; j < 3; j++) {
cur.clear();
curv.clear();
for (i = 0; i < sr[j].size() && i < a[j][K[j]]; i++) {
cur.push_back(j);
curv.push_back(sr[j][i]);
}
for (; i < a[j][K[j]] && xx < o.size(); i++, xx++) {
cur.push_back(o[xx]);
curv.push_back(v[xx]);
}
printf("%s %d", s[j][K[j]].c_str(), cur.size());
for (i = 0; i < cur.size(); i++)
printf(" %s", p[cur[i]][curv[i]].c_str());
puts("");
}
} else
for (j = 0; j < 3; j++) {
for (k = e = i = 0; i < s[j].size(); i++) {
if (j == 0)
xx = x[j][i];
else if (j == 1)
xx = y[j][i];
else
xx = z[j][i];
for (l = 0; l < c[j][i].size(); l++)
if (b[j][i][l] == j) xx += q[b[j][i][l]][c[j][i][l]];
if (xx > e) {
e = xx;
k = i;
}
}
printf("%s %d", s[j][k].c_str(), c[j][k].size());
for (l = 0; l < c[j][k].size(); l++)
printf(" %s", p[b[j][k][l]][c[j][k][l]].c_str());
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ItemType {
string Name;
int A, B, C, Size, Type;
};
struct ElfType {
string Name, Place;
int Value, Type;
};
bool operator<(ElfType A, ElfType B) {
return (A.Type == B.Type) ? (A.Value > B.Value) : (A.Type < B.Type);
}
ItemType Item[100];
ElfType Elf[1000];
bool Used[1000];
void Output1(int T, int M) {
cout << Item[T].Name << ' ';
int Count = 0;
string A[10];
for (int i = 0; i < M; i++)
if (Elf[i].Place == Item[T].Name) A[Count++] = Elf[i].Name;
cout << Count;
for (int i = 0; i < Count; i++) cout << ' ' << A[i];
putchar('\n');
}
void Output2(int T, int M, int N) {
cout << Item[T].Name << ' ';
int Count = 0;
string A[10];
for (int i = 0; i < M; i++)
if (Elf[i].Type == Item[T].Type && Count < N) A[Count++] = Elf[i].Name;
for (int i = 0; i < M; i++)
if (!Used[i] && Count < Item[T].Size) {
Used[i] = true;
A[Count++] = Elf[i].Name;
}
cout << Count;
for (int i = 0; i < Count; i++) cout << ' ' << A[i];
putchar('\n');
}
int main() {
int N;
cin >> N;
int TotalSize = 0;
map<string, int> Number;
for (int i = 0; i < N; i++) {
string T;
cin >> Item[i].Name >> T >> Item[i].A >> Item[i].B >> Item[i].C >>
Item[i].Size;
Number[Item[i].Name] = i;
if (T == "weapon")
Item[i].Type = 0;
else if (T == "armor")
Item[i].Type = 1;
else if (T == "orb")
Item[i].Type = 2;
TotalSize += Item[i].Size;
}
int M;
cin >> M;
for (int i = 0; i < M; i++) {
string T;
cin >> Elf[i].Name >> T >> Elf[i].Value >> Elf[i].Place;
if (T == "gladiator")
Elf[i].Type = 0;
else if (T == "sentry")
Elf[i].Type = 1;
else if (T == "physician")
Elf[i].Type = 2;
}
if (TotalSize == M) {
for (int i = 0; i < M; i++) {
if (Elf[i].Type == 0) Item[Number[Elf[i].Place]].A += Elf[i].Value;
if (Elf[i].Type == 1) Item[Number[Elf[i].Place]].B += Elf[i].Value;
if (Elf[i].Type == 2) Item[Number[Elf[i].Place]].C += Elf[i].Value;
}
int Ans0, Ans1, Ans2, Max0 = -1, Max1 = -1, Max2 = -1;
for (int i = 0; i < N; i++) {
if (Item[i].Type == 0 && Item[i].A > Max0) {
Max0 = Item[i].A;
Ans0 = i;
}
if (Item[i].Type == 1 && Item[i].B > Max1) {
Max1 = Item[i].B;
Ans1 = i;
}
if (Item[i].Type == 2 && Item[i].C > Max2) {
Max2 = Item[i].C;
Ans2 = i;
}
}
Output1(Ans0, M);
Output1(Ans1, M);
Output1(Ans2, M);
} else {
sort(Elf, Elf + M);
int Count0 = 0, Count1 = 0, Count2 = 0;
int Sum0[1001], Sum1[1001], Sum2[1001];
Sum0[0] = Sum1[0] = Sum2[0] = 0;
for (int i = 0; i < M; i++) {
if (Elf[i].Type == 0) {
Count0++;
Sum0[Count0] = Sum0[Count0 - 1] + Elf[i].Value;
}
if (Elf[i].Type == 1) {
Count1++;
Sum1[Count1] = Sum1[Count1 - 1] + Elf[i].Value;
}
if (Elf[i].Type == 2) {
Count2++;
Sum2[Count2] = Sum2[Count2 - 1] + Elf[i].Value;
}
}
int Ans0, Ans1, Ans2, Max0 = -1, Max1 = -1, Max2 = -1;
for (int i = 0; i < N; i++) {
int T;
if (Item[i].Type == 0) {
T = Item[i].A + Sum0[min(Count0, Item[i].Size)];
if (T > Max0) {
Max0 = T;
Ans0 = i;
}
}
if (Item[i].Type == 1) {
T = Item[i].B + Sum1[min(Count1, Item[i].Size)];
if (T > Max1) {
Max1 = T;
Ans1 = i;
}
}
if (Item[i].Type == 2) {
T = Item[i].C + Sum2[min(Count2, Item[i].Size)];
if (T > Max2) {
Max2 = T;
Ans2 = i;
}
}
}
memset(Used, 0, sizeof(Used));
int P = 0;
for (int i = 0; i < min(Item[Ans0].Size, Count0); i++) Used[P + i] = true;
while (P < M && Elf[P].Type == 0) P++;
for (int i = 0; i < min(Item[Ans1].Size, Count1); i++) Used[P + i] = true;
while (P < M && Elf[P].Type == 1) P++;
for (int i = 0; i < min(Item[Ans2].Size, Count2); i++) Used[P + i] = true;
Output2(Ans0, M, min(Item[Ans0].Size, Count0));
Output2(Ans1, M, min(Item[Ans1].Size, Count1));
Output2(Ans2, M, min(Item[Ans2].Size, Count2));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1005;
struct item {
string name, type;
int atk, def, res, size;
};
struct resident {
string name, type;
int bonus;
string home;
};
int N, K;
item items[MAX];
resident residents[MAX];
bool used[MAX];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> items[i].name >> items[i].type >> items[i].atk >> items[i].def >>
items[i].res >> items[i].size;
if (items[i].type == "weapon")
items[i].type = "atk";
else if (items[i].type == "armor")
items[i].type = "def";
else if (items[i].type == "orb")
items[i].type = "res";
else
assert(false);
}
cin >> K;
for (int i = 0; i < K; i++) {
cin >> residents[i].name >> residents[i].type >> residents[i].bonus >>
residents[i].home;
if (residents[i].type == "gladiator")
residents[i].type = "atk";
else if (residents[i].type == "sentry")
residents[i].type = "def";
else if (residents[i].type == "physician")
residents[i].type = "res";
else
assert(false);
}
int sum_size = 0;
for (int i = 0; i < N; i++) sum_size += items[i].size;
if (sum_size == K) {
int atk_total = -1, def_total = -1, res_total = -1;
int best_atk = -1, best_def = -1, best_res = -1;
for (int i = 0; i < N; i++)
if (items[i].type == "atk") {
int total = items[i].atk;
for (int j = 0; j < K; j++)
if (residents[j].home == items[i].name && residents[j].type == "atk")
total += residents[j].bonus;
if (total > atk_total) {
atk_total = total;
best_atk = i;
}
} else if (items[i].type == "def") {
int total = items[i].def;
for (int j = 0; j < K; j++)
if (residents[j].home == items[i].name && residents[j].type == "def")
total += residents[j].bonus;
if (total > def_total) {
def_total = total;
best_def = i;
}
} else if (items[i].type == "res") {
int total = items[i].res;
for (int j = 0; j < K; j++)
if (residents[j].home == items[i].name && residents[j].type == "res")
total += residents[j].bonus;
if (total > res_total) {
res_total = total;
best_res = i;
}
} else
assert(false);
cout << items[best_atk].name;
int reside = 0;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_atk].name) reside++;
cout << ' ' << reside;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_atk].name)
cout << ' ' << residents[i].name;
cout << '\n';
cout << items[best_def].name;
reside = 0;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_def].name) reside++;
cout << ' ' << reside;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_def].name)
cout << ' ' << residents[i].name;
cout << '\n';
cout << items[best_res].name;
reside = 0;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_res].name) reside++;
cout << ' ' << reside;
for (int i = 0; i < K; i++)
if (residents[i].home == items[best_res].name)
cout << ' ' << residents[i].name;
cout << '\n';
return 0;
}
vector<pair<int, int> > atk, def, res;
for (int i = 0; i < K; i++)
if (residents[i].type == "atk")
atk.push_back(make_pair(residents[i].bonus, i));
else if (residents[i].type == "def")
def.push_back(make_pair(residents[i].bonus, i));
else if (residents[i].type == "res")
res.push_back(make_pair(residents[i].bonus, i));
else
assert(false);
sort(atk.rbegin(), atk.rend());
sort(def.rbegin(), def.rend());
sort(res.rbegin(), res.rend());
int atk_total = -1, def_total = -1, res_total = -1;
int best_atk = -1, best_def = -1, best_res = -1;
for (int i = 0; i < N; i++)
if (items[i].type == "atk") {
int total = items[i].atk;
for (int j = 0; j < min(items[i].size, (int)atk.size()); j++)
total += atk[j].first;
if (total > atk_total) {
atk_total = total;
best_atk = i;
}
} else if (items[i].type == "def") {
int total = items[i].def;
for (int j = 0; j < min(items[i].size, (int)def.size()); j++)
total += def[j].first;
if (total > def_total) {
def_total = total;
best_def = i;
}
} else if (items[i].type == "res") {
int total = items[i].res;
for (int j = 0; j < min(items[i].size, (int)res.size()); j++)
total += res[j].first;
if (total > res_total) {
res_total = total;
best_res = i;
}
}
vector<int> atk_answer, def_answer, res_answer;
for (int i = 0; i < min(items[best_atk].size, (int)atk.size()); i++) {
atk_answer.push_back(atk[i].second);
used[atk[i].second] = true;
}
for (int i = 0; i < min(items[best_def].size, (int)def.size()); i++) {
def_answer.push_back(def[i].second);
used[def[i].second] = true;
}
for (int i = 0; i < min(items[best_res].size, (int)res.size()); i++) {
res_answer.push_back(res[i].second);
used[res[i].second] = true;
}
while ((int)atk_answer.size() < items[best_atk].size) {
int unused = -1;
for (int i = 0; i < K; i++)
if (!used[i]) unused = i;
if (unused == -1) break;
atk_answer.push_back(unused);
used[unused] = true;
}
while ((int)def_answer.size() < items[best_def].size) {
int unused = -1;
for (int i = 0; i < K; i++)
if (!used[i]) unused = i;
if (unused == -1) break;
def_answer.push_back(unused);
used[unused] = true;
}
while ((int)res_answer.size() < items[best_res].size) {
int unused = -1;
for (int i = 0; i < K; i++)
if (!used[i]) unused = i;
if (unused == -1) break;
res_answer.push_back(unused);
used[unused] = true;
}
cout << items[best_atk].name << ' ' << atk_answer.size();
for (int i = 0; i < (int)atk_answer.size(); i++)
cout << ' ' << residents[atk_answer[i]].name;
cout << '\n';
cout << items[best_def].name << ' ' << def_answer.size();
for (int i = 0; i < (int)def_answer.size(); i++)
cout << ' ' << residents[def_answer[i]].name;
cout << '\n';
cout << items[best_res].name << ' ' << res_answer.size();
for (int i = 0; i < (int)res_answer.size(); i++)
cout << ' ' << residents[res_answer[i]].name;
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> id;
class Item {
public:
string name, type;
int atk, def, res, siz, free;
void read(int i) {
cin >> name >> type >> atk >> def >> res >> siz;
if (type == "weapon") def = res = -1000000;
if (type == "armor") atk = res = -1000000;
if (type == "orb") atk = def = -1000000;
free = siz;
id[name] = i;
}
} item[105];
class Resident {
public:
string name, type, home;
int bonus;
void read() { cin >> name >> type >> bonus >> home; }
} resident[1005];
int n, m;
int val[3][105];
void solve1() {
for (int i = 0; i < n; i++) {
val[0][i] = item[i].atk;
val[1][i] = item[i].def;
val[2][i] = item[i].res;
}
for (int i = 0; i < m; i++) {
if (resident[i].type == "gladiator")
val[0][id[resident[i].home]] += resident[i].bonus;
if (resident[i].type == "sentry")
val[1][id[resident[i].home]] += resident[i].bonus;
if (resident[i].type == "physician")
val[2][id[resident[i].home]] += resident[i].bonus;
}
int a[3];
for (int i = 0; i < 3; i++) a[i] = max_element(val[i], val[i] + n) - val[i];
for (int i = 0; i < 3; i++) {
cout << item[a[i]].name << ' ' << item[a[i]].siz;
for (int j = 0; j < m; j++)
if (id[resident[j].home] == a[i]) cout << ' ' << resident[j].name;
cout << endl;
}
}
bool cmp(int x, int y) { return resident[x].bonus > resident[y].bonus; }
void solve2() {
vector<int> v[3];
for (int i = 0; i < m; i++) {
if (resident[i].type == "gladiator") v[0].push_back(i);
if (resident[i].type == "sentry") v[1].push_back(i);
if (resident[i].type == "physician") v[2].push_back(i);
}
for (int i = 0; i < 3; i++) sort(v[i].begin(), v[i].end(), cmp);
for (int i = 0; i < n; i++) {
val[0][i] = item[i].atk;
val[1][i] = item[i].def;
val[2][i] = item[i].res;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < item[i].siz && k < (int)v[j].size(); k++)
val[j][i] += resident[v[j][k]].bonus;
int a[3];
for (int i = 0; i < 3; i++) a[i] = max_element(val[i], val[i] + n) - val[i];
for (int i = 0; i < 3; i++) {
int s = min(item[a[i]].siz, (int)v[i].size());
item[a[i]].free = item[a[i]].siz - s;
for (int j = 0; j < s; j++) resident[v[i][j]].home = item[a[i]].name;
for (int j = s; j < (int)v[i].size(); j++) resident[v[i][j]].home = "-";
}
for (int i = 0; i < m; i++)
if (resident[i].home == "-") {
for (int j = 0; j < 3; j++)
if (item[a[j]].free > 0) {
--item[a[j]].free;
resident[i].home = item[a[j]].name;
break;
}
}
for (int i = 0; i < 3; i++) {
cout << item[a[i]].name << ' ' << (item[a[i]].siz - item[a[i]].free);
for (int j = 0; j < m; j++)
if (id.find(resident[j].home) != id.end() && id[resident[j].home] == a[i])
cout << ' ' << resident[j].name;
cout << endl;
}
}
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) item[i].read(i);
cin >> m;
for (int i = 0; i < m; i++) {
resident[i].read();
item[id[resident[i].home]].free--;
}
int ok = 0;
for (int i = 0; i < n; i++)
if (item[i].free > 0) ok = 1;
if (!ok)
solve1();
else
solve2();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
map<string, int> classes;
map<string, int> itemnum;
map<string, int> typesresident;
vector<pair<int, string> > residents[3];
bool used[3][1005];
vector<string> resnoswap[105];
string itemnames[105];
vector<string> sola;
vector<string> solb;
vector<string> solc;
int types[105];
int szes[105];
int atk[105];
int def[105];
int res[105];
int cursums[105][3];
int curszes[105];
int main() {
cin >> n;
classes.insert({"weapon", 0});
classes.insert({"armor", 1});
classes.insert({"orb", 2});
typesresident.insert({"gladiator", 0});
typesresident.insert({"sentry", 1});
typesresident.insert({"physician", 2});
string s1, s2;
int indw, inda, indo;
int maxw = 0, maxa = 0, maxo = 0;
int a, b, c, d;
for (int i = 0; i < n; i++) {
cin >> s1 >> s2;
itemnum.insert({s1, i});
itemnames[i] = s1;
types[i] = classes[s2];
cin >> a >> b >> c >> d;
atk[i] = a;
def[i] = b;
res[i] = c;
szes[i] = d;
if (types[i] == 0) {
indw = i;
} else if (types[i] == 1) {
inda = i;
} else {
indo = i;
}
}
cin >> k;
string s3;
for (int i = 0; i < k; i++) {
cin >> s1 >> s2 >> a >> s3;
residents[typesresident[s2]].push_back({a, s1});
cursums[itemnum[s3]][typesresident[s2]] += a;
curszes[itemnum[s3]]++;
resnoswap[itemnum[s3]].push_back(s1);
}
for (int i = 0; i < 3; i++) {
sort(residents[i].begin(), residents[i].end());
reverse(residents[i].begin(), residents[i].end());
for (int j = 1; j < residents[i].size(); j++) {
residents[i][j].first += residents[i][j - 1].first;
}
}
bool posswap = false;
for (int i = 0; i < n; i++) {
if (curszes[i] < szes[i]) {
posswap = true;
}
}
if (posswap) {
for (int i = 0; i < n; i++) {
if (types[i] == 0) {
if (szes[i] > 0 && !residents[0].empty() &&
atk[i] +
residents[0][min(szes[i], (int)residents[0].size() - 1) - 1]
.first >
maxw) {
maxw = atk[i] +
residents[0][min(szes[i], (int)residents[0].size() - 1) - 1]
.first;
indw = i;
} else if (atk[i] > maxw) {
maxw = atk[i];
indw = i;
}
} else if (types[i] == 1) {
if (szes[i] > 0 && !residents[1].empty() &&
def[i] +
residents[1][min(szes[i], (int)residents[1].size() - 1) - 1]
.first >
maxa) {
maxa = def[i] +
residents[1][min(szes[i], (int)residents[1].size() - 1) - 1]
.first;
inda = i;
} else if (def[i] > maxa) {
maxa = def[i];
inda = i;
}
} else {
if (szes[i] > 0 && !residents[2].empty() &&
res[i] +
residents[2][min(szes[i], (int)residents[2].size() - 1) - 1]
.first >
maxo) {
maxo = res[i] +
residents[2][min(szes[i], (int)residents[2].size() - 1) - 1]
.first;
indo = i;
} else if (res[i] > maxo) {
maxo = res[i];
indo = i;
}
}
}
for (int i = 0; i < min(szes[indw], (int)residents[0].size()); i++) {
sola.push_back(residents[0][i].second);
used[0][i] = true;
}
for (int i = 0; i < min(szes[inda], (int)residents[1].size()); i++) {
solb.push_back(residents[1][i].second);
used[1][i] = true;
}
for (int i = 0; i < min(szes[indo], (int)residents[2].size()); i++) {
solc.push_back(residents[2][i].second);
used[2][i] = true;
}
for (int i = 0; i < residents[0].size(); i++) {
if (!used[0][i]) {
if (solb.size() < szes[inda]) {
solb.push_back(residents[0][i].second);
used[0][i] = true;
} else if (solc.size() < szes[indo]) {
solc.push_back(residents[0][i].second);
used[0][i] = true;
} else {
break;
}
}
}
for (int i = 0; i < residents[1].size(); i++) {
if (!used[1][i]) {
if (sola.size() < szes[indw]) {
sola.push_back(residents[1][i].second);
used[1][i] = true;
} else if (solc.size() < szes[indo]) {
solc.push_back(residents[1][i].second);
used[1][i] = true;
} else {
break;
}
}
}
for (int i = 0; i < residents[2].size(); i++) {
if (!used[2][i]) {
if (sola.size() < szes[indw]) {
sola.push_back(residents[2][i].second);
used[2][i] = true;
} else if (solb.size() < szes[inda]) {
sola.push_back(residents[2][i].second);
used[2][i] = true;
} else {
break;
}
}
}
sort(sola.begin(), sola.end());
sort(solb.begin(), solb.end());
sort(solc.begin(), solc.end());
cout << itemnames[indw] << " " << sola.size() << " ";
for (int i = 0; i < sola.size(); i++) {
cout << sola[i] << " ";
}
cout << endl;
cout << itemnames[inda] << " " << solb.size() << " ";
for (int i = 0; i < solb.size(); i++) {
cout << solb[i] << " ";
}
cout << endl;
cout << itemnames[indo] << " " << solc.size() << " ";
for (int i = 0; i < solc.size(); i++) {
cout << solc[i] << " ";
}
cout << endl;
} else {
for (int i = 0; i < n; i++) {
if (types[i] == 0) {
if (atk[i] + cursums[i][0] > maxw) {
maxw = atk[i] + cursums[i][0];
indw = i;
}
} else if (types[i] == 1) {
if (def[i] + cursums[i][1] > maxa) {
maxa = def[i] + cursums[i][1];
inda = i;
}
} else {
if (res[i] + cursums[i][2] > maxo) {
maxo = res[i] + cursums[i][2];
indo = i;
}
}
}
cout << itemnames[indw] << " " << szes[indw] << " ";
for (int i = 0; i < szes[indw]; i++) {
cout << resnoswap[indw][i] << " ";
}
cout << endl;
cout << itemnames[inda] << " " << szes[inda] << " ";
for (int i = 0; i < szes[inda]; i++) {
cout << resnoswap[inda][i] << " ";
}
cout << endl;
cout << itemnames[indo] << " " << szes[indo] << " ";
for (int i = 0; i < szes[indo]; i++) {
cout << resnoswap[indo][i] << " ";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Person {
string name, type;
int bonus;
string home;
Person(string _name, string _type, int _bonus, string _home)
: name(_name), type(_type), bonus(_bonus), home(_home) {}
};
struct Item {
string name, type;
int atk, def, res, size;
Item(string _name, string _type, int _atk, int _def, int _res, int _size)
: name(_name),
type(_type),
atk(_atk),
def(_def),
res(_res),
size(_size) {}
vector<Person*> people;
void getAway() { people.clear(); }
void habitWith(Person* pers) {
if (people.size() < size) people.push_back(pers);
}
void habitWith(vector<Person*>& pers) {
while (!pers.empty() && people.size() < size)
people.push_back(pers.back()), pers.pop_back();
}
void considerPeople() {
for (int i = 0; i < people.size(); i++) {
if (people[i]->type == "gladiator") atk += people[i]->bonus;
if (people[i]->type == "sentry") def += people[i]->bonus;
if (people[i]->type == "physician") res += people[i]->bonus;
}
}
void print() {
cout << name << ' ' << people.size();
for (int i = 0; i < people.size(); i++) cout << ' ' << people[i]->name;
cout << '\n';
}
};
bool cmp(Person* a, Person* b) { return a->bonus < b->bonus; }
void chooseBest(const vector<Item*> items, int& bestWeapon, int& bestArmor,
int& bestOrb) {
for (int i = 0; i < items.size(); i++) {
if (items[i]->type == "weapon" &&
(bestWeapon == -1 || items[i]->atk > items[bestWeapon]->atk))
bestWeapon = i;
if (items[i]->type == "armor" &&
(bestArmor == -1 || items[i]->def > items[bestArmor]->def))
bestArmor = i;
if (items[i]->type == "orb" &&
(bestOrb == -1 || items[i]->res > items[bestOrb]->res))
bestOrb = i;
}
}
int getBonusSum(const vector<Person*> pers, int nTake) {
int sum = 0;
for (int i = pers.size() - 1; i >= (int)pers.size() - nTake; i--)
sum += pers[i]->bonus;
return sum;
}
int main() {
int n;
cin >> n;
int totalSize = 0;
int bestWeapon = -1, bestArmor = -1, bestOrb = -1;
vector<Item*> items(n);
for (int i = 0; i < n; i++) {
string name, type;
int atk, def, res, size;
cin >> name >> type >> atk >> def >> res >> size;
totalSize += size;
items[i] = new Item(name, type, atk, def, res, size);
}
int k;
cin >> k;
vector<Person*> gla, sen, phy;
for (int i = 0; i < k; i++) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
Person* pers = new Person(name, type, bonus, home);
int id = -1;
for (int j = 0; j < n; j++)
if (items[j]->name == home) id = j;
items[id]->habitWith(pers);
if (type == "gladiator") gla.push_back(pers);
if (type == "sentry") sen.push_back(pers);
if (type == "physician") phy.push_back(pers);
}
if (totalSize > k) {
sort(gla.begin(), gla.end(), cmp);
sort(sen.begin(), sen.end(), cmp);
sort(phy.begin(), phy.end(), cmp);
for (int i = 0; i < n; i++)
if (items[i]->type == "weapon") {
int nTake = min((int)gla.size(), items[i]->size);
items[i]->atk += getBonusSum(gla, nTake);
} else if (items[i]->type == "armor") {
int nTake = min((int)sen.size(), items[i]->size);
items[i]->def += getBonusSum(sen, nTake);
} else {
int nTake = min((int)phy.size(), items[i]->size);
items[i]->res += getBonusSum(phy, nTake);
}
chooseBest(items, bestWeapon, bestArmor, bestOrb);
for (int i = 0; i < n; i++) items[i]->getAway();
items[bestWeapon]->habitWith(gla);
items[bestArmor]->habitWith(sen);
items[bestOrb]->habitWith(phy);
for (int i = 0; i < n; i++)
items[i]->habitWith(gla), items[i]->habitWith(sen),
items[i]->habitWith(phy);
} else {
for (int i = 0; i < n; i++) items[i]->considerPeople();
chooseBest(items, bestWeapon, bestArmor, bestOrb);
}
items[bestWeapon]->print();
items[bestArmor]->print();
items[bestOrb]->print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int values;
char name[20];
int size;
};
struct data1 {
int bonus;
char name[20];
char str[20];
};
struct data2 {
char str[20];
};
vector<data> item[3];
vector<data1> residents[3];
vector<data2> anstr[3];
int sum[3][1005];
int cmp1(data a, data b) { return a.values > b.values; }
int cmp(data1 a, data1 b) { return a.bonus > b.bonus; }
int n, atk, def, res, size, m, b;
char name[20], classes[20], str[20];
int main() {
while (scanf("%d", &n) != EOF) {
int cnt = 0;
for (int i = 0; i < n; i++) {
scanf("%s%s%d%d%d%d", name, classes, &atk, &def, &res, &size);
data tmp;
cnt += size;
strcpy(tmp.name, name);
tmp.size = size;
if (classes[0] == 'w') {
tmp.values = atk;
item[0].push_back(tmp);
} else {
if (classes[0] == 'a') {
tmp.values = def;
item[1].push_back(tmp);
} else {
tmp.values = res;
item[2].push_back(tmp);
}
}
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%s%s%d%s", name, classes, &b, str);
data1 tmp;
strcpy(tmp.name, name);
strcpy(tmp.str, str);
tmp.bonus = b;
if (classes[0] == 'g') {
residents[0].push_back(tmp);
} else {
if (classes[0] == 's') {
residents[1].push_back(tmp);
} else {
residents[2].push_back(tmp);
}
}
}
for (int i = 0; i < 3; i++) {
sort(item[i].begin(), item[i].end(), cmp1);
sort(residents[i].begin(), residents[i].end(), cmp);
}
if (cnt == m) {
for (int i = 0; i < 3; i++) {
int ma = -1;
int a;
for (int j = 0; j < item[i].size(); j++) {
int tmp = item[i][j].values;
for (int k = 0; k < residents[i].size(); k++) {
if (strcmp(item[i][j].name, residents[i][k].str) == 0) {
tmp += residents[i][k].bonus;
}
}
if (ma < tmp) {
ma = tmp;
a = j;
}
}
char str[20];
strcpy(str, item[i][a].name);
for (int i1 = 0; i1 < 3; i1++) {
for (int j = 0; j < residents[i1].size(); j++) {
if (strcmp(residents[i1][j].str, str) == 0) {
data2 t;
strcpy(t.str, residents[i1][j].name);
anstr[i].push_back(t);
}
}
}
printf("%s", item[i][a].name);
printf(" %d", anstr[i].size());
for (int j = 0; j < anstr[i].size(); j++) {
printf(" %s", anstr[i][j].str);
}
printf("\n");
}
} else {
for (int i = 0; i < 3; i++) {
if (residents[i].size() != 0) {
sum[i][0] = residents[i][0].bonus;
for (int j = 1; j < residents[i].size(); j++) {
sum[i][j] = sum[i][j - 1] + residents[i][j].bonus;
}
}
}
int ans[3];
int s[3];
memset(ans, -1, sizeof(ans));
for (int i = 0; i < 3; i++) {
int ma = -1;
for (int j = 0; j < item[i].size(); j++) {
int tmp = item[i][j].values;
if (item[i][j].size < residents[i].size()) {
tmp += sum[i][item[i][j].size - 1];
} else {
tmp += sum[i][residents[i].size() - 1];
}
if (ma < tmp) {
ans[i] = j;
ma = tmp;
s[i] = item[i][j].size < residents[i].size() ? item[i][j].size
: residents[i].size();
}
}
}
for (int i = 0; i < 3; i++) {
int s1 = residents[i].size() > item[i][ans[i]].size
? item[i][ans[i]].size
: residents[i].size();
for (int j = 0; j < s1; j++) {
data2 tmp;
strcpy(tmp.str, residents[i][j].name);
anstr[i].push_back(tmp);
}
if (anstr[i].size() < item[i][ans[i]].size) {
for (int j = 0; j < 3; j++) {
for (; s[j] < residents[j].size(); s[j]++) {
if (anstr[i].size() == item[i][ans[i]].size) {
break;
}
data2 tmp;
strcpy(tmp.str, residents[j][s[j]].name);
anstr[i].push_back(tmp);
}
}
}
}
for (int i = 0; i < 3; i++) {
printf("%s %d", item[i][ans[i]].name, anstr[i].size());
for (int j = 0; j < anstr[i].size(); j++) {
printf(" %s", anstr[i][j].str);
}
printf("\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
const int maxk = 1000 + 10;
const string Item[] = {"weapon", "armor", "orb"};
const string Res[] = {"gladiator", "sentry", "physician"};
struct T {
string name;
int type, score, size;
};
struct P {
string name;
int type, score, pos;
};
vector<int> have[maxn];
T A[maxn];
P B[maxk];
int N, K;
void inputData() {
cin >> N;
for (int i = 0; i < N; ++i) {
int a[3];
string CL;
cin >> A[i].name >> CL;
A[i].type = find(Item, Item + 3, CL) - Item;
for (int k = 0; k < 3; ++k) cin >> a[k];
cin >> A[i].size;
A[i].score = a[A[i].type];
}
cin >> K;
for (int i = 0; i < K; ++i) {
string CL, str;
cin >> B[i].name >> CL;
B[i].type = find(Res, Res + 3, CL) - Res;
cin >> B[i].score;
cin >> str;
for (int k = 0; k < N; ++k)
if (str == A[k].name) {
have[k].push_back(i);
B[i].pos = k;
break;
}
}
}
int score[maxn];
void Output(int x) {
cout << A[x].name << " " << ((int)(have[x].size()));
for (int i = 0; i < ((int)(have[x].size())); ++i)
cout << " " << B[have[x][i]].name;
cout << endl;
}
void calc(int type) {
int x = -1;
for (int i = 0; i < N; ++i)
if (A[i].type == type) {
score[i] = A[i].score;
for (int j = 0; j < ((int)(have[i].size())); ++j)
if (B[have[i][j]].type == type) {
score[i] += B[have[i][j]].score;
}
if (x == -1 || score[i] > score[x]) {
x = i;
}
}
Output(x);
}
int ans[3];
bool mark[maxk];
void solve(int type) {
vector<pair<int, int> > a;
for (int i = 0; i < K; ++i)
if (B[i].type == type) {
a.push_back(make_pair(-B[i].score, i));
}
sort(a.begin(), a.end());
int x = -1;
for (int i = 0; i < N; ++i)
if (A[i].type == type) {
score[i] = A[i].score;
have[i].clear();
for (int j = 0; j < A[i].size && j < ((int)(a.size())); ++j) {
score[i] += B[a[j].second].score;
have[i].push_back(a[j].second);
}
if (x == -1 || score[i] > score[x]) {
x = i;
}
}
ans[type] = x;
for (int i = 0; i < ((int)(have[x].size())); ++i) mark[have[x][i]] = true;
}
void main2() {
int capa = 0;
for (int i = 0; i < N; ++i) capa += A[i].size;
if (capa == K) {
for (int type = 0; type < 3; ++type) calc(type);
return;
}
memset(mark, false, sizeof mark);
for (int type = 0; type < 3; ++type) {
solve(type);
}
for (int i = 0; i < K; ++i)
if (!mark[i]) {
for (int j = 0; j < N; ++j)
if (((int)(have[j].size())) < A[j].size) {
have[j].push_back(i);
break;
}
}
for (int type = 0; type < 3; ++type) {
Output(ans[type]);
}
}
int main() {
ios::sync_with_stdio(false);
inputData();
main2();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n;
struct item {
string name;
int type, pts[3], num;
} A[105];
map<string, int> itemIdx;
int cap[105];
struct add {
string name, equip;
int type, bonus;
} B[1005];
bool mark[1005];
bool cmp(int fa, int fb) { return B[fa].bonus < B[fb].bonus; }
int main() {
scanf("%d", &m);
for (int i = 0; i < m; i++) {
string X;
cin >> A[i].name >> X >> A[i].pts[0] >> A[i].pts[1] >> A[i].pts[2] >>
A[i].num;
itemIdx[A[i].name] = i;
if (X == "weapon")
A[i].type = 0;
else if (X == "armor")
A[i].type = 1;
else
A[i].type = 2;
}
scanf("%d", &n);
for (int i = 0; i < n; i++) {
string X;
cin >> B[i].name >> X >> B[i].bonus >> B[i].equip;
cap[itemIdx[B[i].equip]]++;
if (X == "gladiator")
B[i].type = 0;
else if (X == "sentry")
B[i].type = 1;
else
B[i].type = 2;
}
bool availMove = false;
for (int i = 0; i < m; i++)
if (cap[i] < A[i].num) availMove = true;
int final[3];
vector<int> store[3];
int sum[3] = {-1, -1, -1};
for (int i = 0; i < m; i++) {
int value = A[i].pts[A[i].type];
vector<int> v;
if (availMove) {
for (int j = 0; j < n; j++)
if (B[j].type == A[i].type) v.push_back(j);
sort(v.rbegin(), v.rend(), cmp);
while (v.size() > A[i].num) v.pop_back();
for (int j = 0; j < v.size(); j++) value += B[v[j]].bonus;
} else {
for (int j = 0; j < n; j++)
if (B[j].equip == A[i].name) {
v.push_back(j);
if (B[j].type == A[i].type) value += B[j].bonus;
}
}
if (value > sum[A[i].type]) {
sum[A[i].type] = value;
final[A[i].type] = i;
store[A[i].type] = v;
}
}
for (int i = 0; i < 3; i++)
for (int j = 0; j < store[i].size(); j++) mark[store[i][j]] = true;
int pos = 0;
for (int i = 0; i < 3; i++) {
int cnt = (int)store[i].size();
while (pos < n && cnt < A[final[i]].num) {
while (pos < n && mark[pos]) pos++;
if (pos >= n) break;
store[i].push_back(pos);
pos++;
cnt++;
}
}
for (int i = 0; i < 3; i++) {
cout << A[final[i]].name << ' ' << (int)store[i].size() << ' ';
for (int j = 0; j < store[i].size(); j++)
cout << B[store[i][j]].name << ' ';
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct bonus {
int type;
string name;
int val[3];
};
int g;
struct comp {
bool operator()(const bonus &A, const bonus &B) {
int pos = g;
while (pos < 3 && A.val[pos] == B.val[pos]) pos++;
if (pos == g)
return A.val[pos] > B.val[pos];
else if (pos < 3)
return A.val[pos] <= B.val[pos];
return 0;
}
};
struct item {
int type;
string name;
int val[3];
int size;
vector<bonus> B;
};
vector<item> IT;
vector<bonus> Bonus;
map<string, bool> used;
int main() {
scanf("%d", &n);
for (int i = 0, _n = (n); i < _n; i++) {
item it;
int p[3], size;
string Class;
cin >> it.name >> Class;
scanf("%d%d%d%d", &it.val[0], &it.val[1], &it.val[2], &it.size);
if (Class == "weapon") it.type = 0;
if (Class == "armor") it.type = 1;
if (Class == "orb") it.type = 2;
IT.push_back(it);
}
scanf("%d", &k);
for (int i = 0, _n = (k); i < _n; i++) {
bonus bn;
string Class, home;
int bon;
cin >> bn.name >> Class >> bon >> home;
if (Class == "gladiator") bn.type = 0;
if (Class == "sentry") bn.type = 1;
if (Class == "physician") bn.type = 2;
for (int j = 0, _n = (3); j < _n; j++) bn.val[j] = 0;
bn.val[bn.type] = bon;
for (int j = 0, _n = (n); j < _n; j++) {
if (IT[j].name == home) {
IT[j].B.push_back(bn);
break;
}
}
Bonus.push_back(bn);
}
bool flag = 0;
for (int i = 0, _n = (n); i < _n; i++) {
if (IT[i].size != IT[i].B.size()) {
flag = 1;
break;
}
}
if (flag == 0) {
item bt[3];
for (int i = 0, _n = (3); i < _n; i++) bt[i].val[i] = -100000000;
for (int j = 0, _n = (3); j < _n; j++) {
int bestpar = -10000000;
for (int i = 0, _n = (n); i < _n; i++) {
if (IT[i].type == j) {
int par = IT[i].val[j];
for (int r = 0, _n = (IT[i].B.size()); r < _n; r++)
par += IT[i].B[r].val[j];
if (par > bestpar) {
bt[j] = IT[i];
bestpar = par;
}
}
}
}
for (int i = 0, _n = (3); i < _n; i++) {
cout << bt[i].name << " " << bt[i].B.size();
for (int j = 0, _n = (bt[i].B.size()); j < _n; j++) {
cout << " " << bt[i].B[j].name;
}
cout << endl;
}
} else {
for (int j = 0, _n = (3); j < _n; j++) {
g = j;
vector<bonus> bestb;
bestb.clear();
int bestnum = -1;
int bestpar = -1;
for (int i = 0, _n = (n); i < _n; i++) {
if (IT[i].type == j) {
int par = IT[i].val[j];
int sz = IT[i].size;
vector<bonus> tempb;
tempb.clear();
sort(Bonus.begin(), Bonus.end(), comp());
for (int r = 0, _n = (k); r < _n; r++) {
if (sz && !used[Bonus[r].name] && Bonus[r].type <= j) {
used[Bonus[r].name] = 1;
par += Bonus[r].val[j];
tempb.push_back(Bonus[r]);
sz--;
}
}
if (par > bestpar) {
bestpar = par;
bestnum = i;
bestb.clear();
for (int r = 0, _n = (tempb.size()); r < _n; r++)
bestb.push_back(tempb[r]);
}
for (int r = 0, _n = (tempb.size()); r < _n; r++)
used[tempb[r].name] = 0;
}
}
cout << IT[bestnum].name << " " << bestb.size();
for (int i = 0, _n = (bestb.size()); i < _n; i++) {
cout << " " << bestb[i].name;
used[bestb[i].name] = 1;
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<string, pair<int, int> > > w, b, o;
vector<pair<int, string> > v1, v2, v3;
map<string, vector<pair<string, pair<string, int> > > > mm;
vector<int> was1, was2, was3;
int main() {
int n;
cin >> n;
int tot = 0;
for (int i = (0); i < (n); ++i) {
string name, cl;
int at, def, res, sz;
cin >> name >> cl >> at >> def >> res >> sz;
if (cl[0] == 'w')
w.push_back(make_pair(name, make_pair(at, sz)));
else if (cl[0] == 'a')
b.push_back(make_pair(name, make_pair(def, sz)));
else
o.push_back(make_pair(name, make_pair(res, sz)));
tot += sz;
}
int k;
cin >> k;
for (int i = (0); i < (k); ++i) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
mm[home].push_back(make_pair(name, make_pair(type, bonus)));
if (type[0] == 'g')
v1.push_back(make_pair(bonus, name));
else if (type[0] == 's')
v2.push_back(make_pair(bonus, name));
else
v3.push_back(make_pair(bonus, name));
}
if (k == tot) {
pair<int, pair<int, int> > res =
make_pair(-2000000000, make_pair(-2000000000, -2000000000));
int v1, v2, v3;
for (int i = (0); i < (w.size()); ++i)
for (int j = (0); j < (b.size()); ++j)
for (int c = (0); c < (o.size()); ++c) {
pair<int, pair<int, int> > now =
make_pair(w[i].second.first,
make_pair(b[j].second.first, o[c].second.first));
for (int it = (0); it < (mm[w[i].first].size()); ++it)
if (mm[w[i].first][it].second.first[0] == 'g')
now.first += mm[w[i].first][it].second.second;
for (int it = (0); it < (mm[b[j].first].size()); ++it)
if (mm[b[j].first][it].second.first[0] == 's')
now.second.first += mm[b[j].first][it].second.second;
for (int it = (0); it < (mm[o[c].first].size()); ++it)
if (mm[o[c].first][it].second.first[0] == 'p')
now.second.second += mm[o[c].first][it].second.second;
if (now > res) {
res = now;
v1 = i;
v2 = j;
v3 = c;
}
}
cout << w[v1].first << " " << w[v1].second.second;
for (int i = (0); i < (mm[w[v1].first].size()); ++i) {
cout << " " << mm[w[v1].first][i].first;
}
cout << endl;
cout << b[v2].first << " " << b[v2].second.second;
for (int i = (0); i < (mm[b[v2].first].size()); ++i) {
cout << " " << mm[b[v2].first][i].first;
}
cout << endl;
cout << o[v3].first << " " << o[v3].second.second;
for (int i = (0); i < (mm[o[v3].first].size()); ++i) {
cout << " " << mm[o[v3].first][i].first;
}
cout << endl;
} else {
sort(v1.rbegin(), v1.rend());
sort(v2.rbegin(), v2.rend());
sort(v3.rbegin(), v3.rend());
pair<int, pair<int, int> > res =
make_pair(-2000000000, make_pair(-2000000000, -2000000000));
int vv1 = -1, vv2 = -1, vv3 = -1;
for (int i = (0); i < (w.size()); ++i)
for (int j = (0); j < (b.size()); ++j)
for (int c = (0); c < (o.size()); ++c) {
int val1 = w[i].second.first;
for (int it = (0);
it < (((v1.size() < w[i].second.second) ? (v1.size())
: (w[i].second.second)));
++it)
val1 += v1[it].first;
int val2 = b[j].second.first;
for (int it = (0);
it < (((v2.size() < b[j].second.second) ? (v2.size())
: (b[j].second.second)));
++it)
val2 += v2[it].first;
int val3 = o[c].second.first;
for (int it = (0);
it < (((v3.size() < o[c].second.second) ? (v3.size())
: (o[c].second.second)));
++it)
val3 += v3[it].first;
pair<int, pair<int, int> > now =
make_pair(val1, make_pair(val2, val3));
if (now > res) {
res = now;
vv1 = i;
vv2 = j;
vv3 = c;
}
}
vector<string> out1, out2, out3;
was1.resize(v1.size(), 0);
was2.resize(v2.size(), 0);
was3.resize(v3.size(), 0);
int sz1 = w[vv1].second.second;
int sz2 = b[vv2].second.second;
int sz3 = o[vv3].second.second;
for (int i = (0); i < (v1.size()); ++i)
if ((was1[i] == 0) && (sz1 > 0)) {
sz1--;
was1[i] = 1;
out1.push_back(v1[i].second);
}
for (int i = (0); i < (v2.size()); ++i)
if ((was2[i] == 0) && (sz2 > 0)) {
sz2--;
was2[i] = 1;
out2.push_back(v2[i].second);
}
for (int i = (0); i < (v3.size()); ++i)
if ((was3[i] == 0) && (sz3 > 0)) {
sz3--;
was3[i] = 1;
out3.push_back(v3[i].second);
}
for (int i = (0); i < (v1.size()); ++i)
if ((was1[i] == 0) && (sz2 > 0)) {
sz2--;
was1[i] = 1;
out2.push_back(v1[i].second);
}
for (int i = (0); i < (v1.size()); ++i)
if ((was1[i] == 0) && (sz3 > 0)) {
sz3--;
was1[i] = 1;
out3.push_back(v1[i].second);
}
for (int i = (0); i < (v2.size()); ++i)
if ((was2[i] == 0) && (sz1 > 0)) {
sz1--;
was2[i] = 1;
out1.push_back(v2[i].second);
}
for (int i = (0); i < (v2.size()); ++i)
if ((was2[i] == 0) && (sz3 > 0)) {
sz3--;
was2[i] = 1;
out3.push_back(v2[i].second);
}
for (int i = (0); i < (v3.size()); ++i)
if ((was3[i] == 0) && (sz1 > 0)) {
sz1--;
was3[i] = 1;
out1.push_back(v3[i].second);
}
for (int i = (0); i < (v3.size()); ++i)
if ((was3[i] == 0) && (sz2 > 0)) {
sz2--;
was3[i] = 1;
out2.push_back(v3[i].second);
}
cout << w[vv1].first << " " << out1.size();
for (int i = (0); i < (out1.size()); ++i) cout << " " << out1[i];
cout << endl;
cout << b[vv2].first << " " << out2.size();
for (int i = (0); i < (out2.size()); ++i) cout << " " << out2[i];
cout << endl;
cout << o[vv3].first << " " << out3.size();
for (int i = (0); i < (out3.size()); ++i) cout << " " << out3[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string a1[3] = {"weapon", "armor", "orb"},
a2[4] = {"gladiator", "sentry", "physician"};
struct ww {
int a, b, id;
} b[1010], c[1010];
int i, j, k, n, m, t, S, sheng;
int zhi[1010], id[1010], in[1010], an[3], re[3], F[1010];
string s[1010], p[1010];
inline int get1() {
string ss;
cin >> ss;
int i;
for (i = 1; i <= n; i++)
if (s[i] == ss) return i;
}
inline int get2() {
int i;
string s;
cin >> s;
for (i = 0; i <= 2; i++)
if (a1[i] == s) return i;
}
inline int get3() {
int i;
string s;
cin >> s;
for (i = 0; i <= 2; i++)
if (a2[i] == s) return i;
}
inline void Pan() {
for (i = 0; i <= 2; i++) {
int ma = -1, id;
for (j = 1; j <= n; j++)
if (b[j].id == i && zhi[j] > ma) ma = zhi[j], id = j;
cout << s[id];
printf(" %d", in[id]);
for (j = 1; j <= m; j++)
if (c[j].b == id) cout << " " << p[j];
printf("\n");
}
exit(0);
}
inline bool cc1(const int &A, const int &B) { return c[A].a > c[B].a; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
cin >> s[i];
int B = get2(), c[3], x;
for (j = 0; j <= 2; j++) scanf("%d", &c[j]);
scanf("%d", &x);
b[i] = (ww){c[B], x, B};
zhi[i] = c[B];
S += x;
}
scanf("%d", &m);
for (i = 1; i <= m; i++) {
cin >> p[i];
int A = get3(), x;
scanf("%d", &x);
int B = get1();
if (A == b[B].id) zhi[B] += x;
c[i] = (ww){x, B, A};
id[i] = i;
in[B]++;
}
if (S == m) Pan();
sort(id + 1, id + m + 1, cc1);
sheng = m;
for (i = 0; i <= 2; i++) {
int ma = -1, Id, ge;
for (j = 1; j <= n; j++)
if (b[j].id == i) {
int s = b[j].a, Size = b[j].b;
for (k = 1; k <= m; k++) {
int A = id[k];
if (c[A].id == i && Size) {
Size--;
s += c[A].a;
}
}
if (s > ma) ma = s, Id = j, ge = b[j].b - Size;
}
an[i] = Id;
re[i] = ge;
{
int Size = b[Id].b;
for (k = 1; k <= m; k++) {
int A = id[k];
if (c[A].id == i && Size) {
Size--;
F[A] = i + 1;
sheng--;
}
}
}
}
for (i = 0; i <= 2; i++) {
int Sh = min(b[an[i]].b - re[i], sheng);
cout << s[an[i]];
printf(" %d", re[i] + Sh);
for (j = 1; j <= m; j++)
if (!F[j] && Sh) {
cout << " " << p[j];
Sh--;
sheng--;
F[j] = -1;
}
for (j = 1; j <= m; j++)
if (F[j] == i + 1) cout << " " << p[j];
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
int type2Int(string type) {
if (type == "gladiator")
return 0;
else if (type == "sentry")
return 1;
else if (type == "physician")
return 2;
if (type == "weapon")
return 0;
else if (type == "armor")
return 1;
else if (type == "orb")
return 2;
return 0;
}
map<string, pair<int, int> > wresidents;
vector<vector<pair<int, string> > > residents(3);
struct sobject {
string name;
string type;
mutable int score;
int atk, def, res;
int size;
int get(int t) const {
if (t == 0) return atk;
if (t == 1) return def;
if (t == 2) return res;
}
int get() const { return get(type2Int(type)); }
vector<string> residents;
sobject() { score = -1; }
sobject(string name, string type, int atk, int def, int res, int size)
: name(name), type(type), atk(atk), def(def), res(res), size(size) {
score = -1;
}
int calc_residents() const {
if (score != -1) return score;
score = get();
for (int i = 0; i < residents.size(); ++i) {
pair<int, int> wh = wresidents[residents[i]];
if (wh.first != type2Int(type)) continue;
score += ::residents[wh.first][wh.second].first;
}
return score;
}
};
vector<vector<sobject> > objects(3);
map<string, pair<int, int> > wobjects;
bool cmp_objects(const sobject &a, const sobject &b) {
return a.calc_residents() < b.calc_residents();
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string name, type;
int atk, def, res, size;
cin >> name >> type >> atk >> def >> res >> size;
objects[type2Int(type)].push_back(sobject(name, type, atk, def, res, size));
wobjects[name] =
make_pair(type2Int(type), objects[type2Int(type)].size() - 1);
}
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
residents[type2Int(type)].push_back(make_pair(bonus, name));
pair<int, int> wh = wobjects[home];
if (wh.second > objects[wh.first].size()) return 0;
objects[wh.first][wh.second].residents.push_back(name);
wresidents[name] =
make_pair(type2Int(type), residents[type2Int(type)].size() - 1);
}
bool free = false;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < objects[i].size(); ++j)
if (objects[i][j].size > objects[i][j].residents.size()) free = true;
if (!free) {
for (int i = 0; i < 3; ++i) {
if (objects[i].size() == 0) return 0;
sobject p =
*max_element(objects[i].begin(), objects[i].end(), cmp_objects);
cout << p.name << " " << p.residents.size();
for (int i = 0; i < p.residents.size(); ++i)
cout << " " << p.residents[i];
cout << endl;
}
return 0;
}
for (int i = 0; i < 3; ++i) sort(residents[i].rbegin(), residents[i].rend());
vector<vector<int> > sum(3);
for (int i = 0; i < 3; ++i) {
sum[i].resize(residents[i].size() + 1);
for (int j = 0; j < residents[i].size(); ++j)
sum[i][j + 1] = sum[i][j] + residents[i][j].first;
}
vector<int> best_idx(3, -1), best_score(3, -1);
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < objects[i].size(); ++j) {
int cur_score = objects[i][j].get();
int sz = min((int)residents[i].size(), objects[i][j].size);
cur_score += sum[i][sz];
if (cur_score > best_score[i]) {
best_score[i] = cur_score;
best_idx[i] = j;
}
}
}
set<string> available;
for (map<string, pair<int, int> >::iterator it = wresidents.begin();
it != wresidents.end(); ++it)
available.insert(it->first);
vector<sobject> answer(3);
for (int i = 0; i < 3; ++i) {
if (best_idx[i] == -1) return 0;
answer[i] = objects[i][best_idx[i]];
answer[i].residents.clear();
int sz = min((int)residents[i].size(), answer[i].size);
for (int k = 0; k < sz; ++k) {
answer[i].residents.push_back(residents[i][k].second);
available.erase(residents[i][k].second);
}
}
for (set<string>::iterator it = available.begin(); it != available.end();
++it) {
for (int i = 0; i < 3; ++i)
if (answer[i].size > answer[i].residents.size()) {
answer[i].residents.push_back(*it);
break;
}
}
for (int i = 0; i < 3; ++i) {
cout << answer[i].name << " " << answer[i].residents.size();
for (int j = 0; j < answer[i].residents.size(); ++j)
cout << " " << answer[i].residents[j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j;
struct R {
int bonus;
string name, type;
R() {}
R(int b, string n, string t) : bonus(b), name(n), type(t) {}
bool operator<(const R &r) const { return bonus > r.bonus; }
};
struct I {
int atk, def, res, size;
string name, cls;
I() {}
I(int a, int d, int r, int s, string n, string c)
: atk(a), def(d), res(r), size(s), name(n), cls(c) {}
vector<R> rs;
};
I item[100];
R resi[1000];
vector<R> gs, ss, ps;
int n, k;
void pv(int p) {
cout << item[p].name << " " << item[p].rs.size();
for (i = 0; i < item[p].rs.size(); ++i) cout << " " << item[p].rs[i].name;
cout << endl;
}
void run() {
cin >> n;
int sum = 0;
for (i = 0; i < n; ++i) {
int a, d, r, s;
string n, c;
cin >> n >> c >> a >> d >> r >> s;
item[i] = I(a, d, r, s, n, c);
sum += s;
}
cin >> k;
for (i = 0; i < k; ++i) {
int b;
string nm, t, h;
cin >> nm >> t >> b >> h;
resi[i] = R(b, nm, t);
for (j = 0; j < n; ++j)
if (item[j].name == h) item[j].rs.push_back(resi[i]);
if (t[0] == 'g')
gs.push_back(resi[i]);
else if (t[0] == 's')
ss.push_back(resi[i]);
else
ps.push_back(resi[i]);
}
if (sum == k) {
int mxw, mxa, mxo;
int w = -1, a = -1, o = -1;
for (i = 0; i < n; ++i)
if (item[i].cls[0] == 'w') {
int s = item[i].atk;
for (j = 0; j < item[i].rs.size(); ++j)
if (item[i].rs[j].type[0] == 'g') s += item[i].rs[j].bonus;
if (s > w) w = s, mxw = i;
} else if (item[i].cls[0] == 'a') {
int s = item[i].def;
for (j = 0; j < item[i].rs.size(); ++j)
if (item[i].rs[j].type[0] == 's') s += item[i].rs[j].bonus;
if (s > a) a = s, mxa = i;
} else if (item[i].cls[0] == 'o') {
int s = item[i].res;
for (j = 0; j < item[i].rs.size(); ++j)
if (item[i].rs[j].type[0] == 'p') s += item[i].rs[j].bonus;
if (s > o) o = s, mxo = i;
}
pv(mxw);
pv(mxa);
pv(mxo);
return;
}
sort(gs.begin(), gs.end());
sort(ss.begin(), ss.end());
sort(ps.begin(), ps.end());
for (i = 0; i < n; ++i) item[i].rs.clear();
int mxw, mxa, mxo, w = -1, a = -1, o = -1;
for (i = 0; i < n; ++i)
if (item[i].cls[0] == 'w') {
int s = item[i].atk;
for (j = 0; j < min(item[i].size, (int)gs.size()); ++j) s += gs[j].bonus;
if (s > w) w = s, mxw = i;
} else if (item[i].cls[0] == 'a') {
int s = item[i].def;
for (j = 0; j < min(item[i].size, (int)ss.size()); ++j) s += ss[j].bonus;
if (s > a) a = s, mxa = i;
} else if (item[i].cls[0] == 'o') {
int s = item[i].res;
for (j = 0; j < min(item[i].size, (int)ps.size()); ++j) s += ps[j].bonus;
if (s > o) o = s, mxo = i;
}
for (i = 0; i < min(item[mxw].size, (int)gs.size()); ++i)
item[mxw].rs.push_back(gs[i]);
for (i = 0; i < min(item[mxa].size, (int)ss.size()); ++i)
item[mxa].rs.push_back(ss[i]);
for (i = 0; i < min(item[mxo].size, (int)ps.size()); ++i)
item[mxo].rs.push_back(ps[i]);
vector<R> v;
for (int i = min(item[mxw].size, (int)gs.size()); i < gs.size(); i++)
v.push_back(gs[i]);
for (int i = min(item[mxa].size, (int)ss.size()); i < ss.size(); i++)
v.push_back(ss[i]);
for (int i = min(item[mxo].size, (int)ps.size()); i < ps.size(); i++)
v.push_back(ps[i]);
int k = 0;
while (k < v.size() && item[mxw].rs.size() < item[mxw].size)
item[mxw].rs.push_back(v[k++]);
while (k < v.size() && item[mxa].rs.size() < item[mxa].size)
item[mxa].rs.push_back(v[k++]);
while (k < v.size() && item[mxo].rs.size() < item[mxo].size)
item[mxo].rs.push_back(v[k++]);
pv(mxw);
pv(mxa);
pv(mxo);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string ITEM_TYPENAME[3] = {"weapon", "armor", "orb"};
inline int c2n(const string &s) {
switch (s[0]) {
case 'g':
return 0;
case 's':
return 1;
case 'p':
return 2;
}
return -1;
}
inline int i2n(const string &s) {
switch (s[0]) {
case 'w':
return 0;
case 'a':
return 1;
case 'o':
return 2;
}
return -1;
}
struct Creatrue {
string name;
int tp, bonus;
};
map<string, vector<Creatrue> > live;
vector<Creatrue> creatrues[3];
struct Item {
string name;
int size, para[3];
};
vector<Item> items[3];
bool can_move() {
for (int n_ = (3), tp = 0; tp < n_; ++tp) {
for (__typeof__(items[tp].begin()) _it = items[tp].begin();
_it != items[tp].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = items[tp].end(), --_it) : _it)
for (__typeof__(*_it) &it = *_it; _once && !(_once = 0); _done = 1) {
if (size_t(it.size) > live[it.name].size()) return true;
}
}
return false;
}
inline bool b_cmp(const Creatrue &l, const Creatrue &r) {
return l.bonus > r.bonus;
}
vector<Creatrue> ans[3], res;
Item ans_item[3];
void work() {
if (can_move()) {
res.clear();
for (int n_ = (3), tp = 0; tp < n_; ++tp)
sort((creatrues[tp]).begin(), (creatrues[tp]).end(), b_cmp);
for (int n_ = (3), tp = 0; tp < n_; ++tp) {
Item &max_item = ans_item[tp];
int maxi = -1;
for (__typeof__(items[tp].begin()) _it = items[tp].begin();
_it != items[tp].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = items[tp].end(), --_it) : _it)
for (__typeof__(*_it) &item = *_it; _once && !(_once = 0);
_done = 1) {
int b = item.para[tp];
for (int i = 0; i < item.size && i < int(creatrues[tp].size()); i++)
b += creatrues[tp][i].bonus;
if (b > maxi) {
maxi = b;
max_item = item;
}
}
ans[tp].assign(creatrues[tp].begin(),
creatrues[tp].begin() +
min(int(creatrues[tp].size()), max_item.size));
res.insert(
res.end(),
creatrues[tp].begin() + min(int(creatrues[tp].size()), max_item.size),
creatrues[tp].end());
}
for (int n_ = (3), tp = 0; tp < n_; ++tp) {
while (!res.empty() && int(ans[tp].size()) < ans_item[tp].size) {
ans[tp].push_back(res.back());
res.pop_back();
}
cout << ans_item[tp].name << " " << ans[tp].size();
for (__typeof__(ans[tp].begin()) _it = ans[tp].begin();
_it != ans[tp].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = ans[tp].end(), --_it) : _it)
for (__typeof__(*_it) &a = *_it; _once && !(_once = 0); _done = 1)
cout << " " << a.name;
cout << endl;
}
} else {
for (int n_ = (3), tp = 0; tp < n_; ++tp) {
Item max_item;
int maxi = -1;
for (__typeof__(items[tp].begin()) _it = items[tp].begin();
_it != items[tp].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = items[tp].end(), --_it) : _it)
for (__typeof__(*_it) &item = *_it; _once && !(_once = 0);
_done = 1) {
int b = item.para[tp];
for (__typeof__(live[item.name].begin()) _it =
live[item.name].begin();
_it != live[item.name].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = live[item.name].end(), --_it) : _it)
for (__typeof__(*_it) &creatrue = *_it; _once && !(_once = 0);
_done = 1) {
if (creatrue.tp == tp) {
b += creatrue.bonus;
}
}
if (b > maxi) {
maxi = b;
max_item = item;
}
}
cout << max_item.name << " " << live[max_item.name].size();
for (__typeof__(live[max_item.name].begin()) _it =
live[max_item.name].begin();
_it != live[max_item.name].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = live[max_item.name].end(), --_it) : _it)
for (__typeof__(*_it) &creatrue = *_it; _once && !(_once = 0);
_done = 1)
cout << " " << creatrue.name;
cout << endl;
}
}
}
void myin() {
int tn;
cin >> tn;
for (int n_ = (3), i = 0; i < n_; ++i) items[i].clear();
while (tn--) {
Item item;
string ts;
cin >> item.name >> ts;
for (int n_ = (3), i = 0; i < n_; ++i) cin >> item.para[i];
cin >> item.size;
int tp = i2n(ts);
items[tp].push_back(item);
}
cin >> tn;
for (int n_ = (3), i = 0; i < n_; ++i) creatrues[i].clear();
live.clear();
while (tn--) {
Creatrue creatrue;
string ts, ls;
cin >> creatrue.name >> ts >> creatrue.bonus >> ls;
creatrue.tp = c2n(ts);
if (live.count(ls))
live[ls].push_back(creatrue);
else
live[ls] = vector<Creatrue>(1, creatrue);
creatrues[creatrue.tp].push_back(creatrue);
}
}
int main() {
myin();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct R {
string name;
int c, a;
} r;
bool operator<(R r1, R r2) { return r1.a > r2.a; }
struct A {
int a, n, c;
vector<R> v;
string name;
} a[300];
map<string, int> mm;
vector<R> b[3];
char s[20000];
int c[10], ind[10], u[10];
int main() {
int n, i, j, x, m, cap = 0;
bool ok = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", &s);
a[i].name = s;
scanf("%s", &s);
a[i].c = 2 * (s[0] == 'o') + (s[0] == 'a');
for (j = 0; j < 3; j++) {
scanf("%d", &x);
if (j == a[i].c) a[i].a = x;
}
scanf("%d", &a[i].n);
mm[a[i].name] = i;
cap += a[i].n;
}
scanf("%d", &m);
if (cap == m) ok = 0;
while (m--) {
scanf("%s", &s);
r.name = s;
scanf("%s", &s);
r.c = 2 * (s[0] == 'p') + (s[0] == 's');
scanf("%d", &r.a);
scanf("%s", &s);
a[mm[s]].v.push_back(r);
b[r.c].push_back(r);
}
if (!ok) {
for (i = 0; i < n; i++)
for (j = 0; j < a[i].v.size(); j++)
if (a[i].c == a[i].v[j].c) a[i].a += a[i].v[j].a;
for (i = 0; i < n; i++)
if (a[i].a > c[a[i].c]) {
c[a[i].c] = a[i].a;
ind[a[i].c] = i;
}
for (i = 0; i < 3; i++) {
printf("%s %d", a[ind[i]].name.c_str(), a[ind[i]].n);
for (j = 0; j < a[ind[i]].n; j++)
printf(" %s", a[ind[i]].v[j].name.c_str());
printf("\n");
}
return 0;
}
for (i = 0; i < 3; i++) sort(b[i].begin(), b[i].end());
for (i = 0; i < n; i++) {
x = a[i].a;
for (j = 0; j < a[i].n && j < b[a[i].c].size(); j++) x += b[a[i].c][j].a;
if (x > c[a[i].c]) {
c[a[i].c] = x;
ind[a[i].c] = i;
}
}
for (j = 0; j < 3; j++) {
a[ind[j]].v.clear();
for (i = 0; i < a[ind[j]].n && i < b[j].size(); i++) {
a[ind[j]].v.push_back(b[j][i]);
u[j] = i;
}
}
m = 0;
for (i = 0; i < 3; i++)
for (j = u[i] + 1; j < b[i].size(); j++) {
while (m < 3 && a[ind[m]].v.size() == a[ind[m]].n) m++;
if (m == 3) {
i = 5;
break;
}
a[ind[m]].v.push_back(b[i][j]);
}
for (i = 0; i < 3; i++) {
printf("%s %d", a[ind[i]].name.c_str(), a[ind[i]].v.size());
for (j = 0; j < a[ind[i]].v.size(); j++)
printf(" %s", a[ind[i]].v[j].name.c_str());
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string item_name[105];
int item_type[105];
string resi_name[1005];
int resi_type[1005];
int bonus[1005];
int resi_pos[1005];
int p[105][3];
int q[105][3];
int sz[105];
int s[10005];
vector<string> res[3];
string res_name[3];
int can_add[3];
vector<string> extra;
vector<pair<int, string>> a[3];
bool cmp(pair<int, string> &lhs, pair<int, string> &rhs) {
return lhs.first < rhs.first;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int tot_sz = 0;
for (int i = 0; i < n; i++) {
cin >> item_name[i];
string s;
cin >> s;
if (s[0] == 'w')
item_type[i] = 0;
else if (s[0] == 'a')
item_type[i] = 1;
else
item_type[i] = 2;
for (int j = 0; j < 3; j++) {
cin >> p[i][j];
}
cin >> sz[i];
tot_sz += sz[i];
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> resi_name[i];
string s;
cin >> s;
if (s[0] == 'g')
resi_type[i] = 0;
else if (s[0] == 's')
resi_type[i] = 1;
else
resi_type[i] = 2;
cin >> bonus[i] >> s;
for (int j = 0; j < n; j++) {
if (s == item_name[j]) resi_pos[i] = j;
}
q[resi_pos[i]][resi_type[i]] += bonus[i];
}
if (tot_sz == k) {
for (int j = 0; j < 3; j++) {
int u = 0;
while (item_type[u] != j) u++;
for (int i = u + 1; i < n; i++) {
if (item_type[i] == j && p[i][j] + q[i][j] > p[u][j] + q[u][j]) {
u = i;
}
}
cout << item_name[u] << ' ';
int cnt = 0;
for (int i = 0; i < k; i++) {
if (resi_pos[i] == u) cnt++;
}
cout << cnt;
for (int i = 0; i < k; i++) {
if (resi_pos[i] == u) {
cout << ' ' << resi_name[i];
}
}
cout << "\n";
}
return 0;
}
for (int i = 0; i < k; i++) {
a[resi_type[i]].push_back({bonus[i], resi_name[i]});
}
for (int j = 0; j < 3; j++) {
sort(a[j].begin(), a[j].end(), cmp);
reverse(a[j].begin(), a[j].end());
s[0] = 0;
for (int i = 0; i < a[j].size(); i++) {
s[i + 1] = s[i] + a[j][i].first;
}
int u = 0;
while (item_type[u] != j) {
u++;
}
int best = p[u][j];
if (sz[u] > a[j].size())
best += s[a[j].size()];
else
best += s[sz[u]];
for (int i = u + 1; i < n; i++) {
if (item_type[i] != j) continue;
int curr = p[i][j];
if (sz[i] > a[j].size())
curr += s[a[j].size()];
else
curr += s[sz[i]];
if (curr > best) {
best = curr;
u = i;
}
}
res_name[j] = item_name[u];
for (int i = 0; i < min(sz[u], int(a[j].size())); i++) {
res[j].push_back(a[j][i].second);
}
can_add[j] = sz[u] - res[j].size();
for (int i = sz[u]; i < a[j].size(); i++) {
extra.push_back(a[j][i].second);
}
}
for (int j = 0; j < 3; j++) {
while (extra.size() > 0 && can_add[j] > 0) {
res[j].push_back(extra.back());
extra.pop_back();
can_add[j]--;
}
cout << res_name[j] << ' ';
cout << res[j].size();
for (int i = 0; i < res[j].size(); i++) {
cout << ' ' << res[j][i];
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
string type, name;
int atk, def, res, size;
void read() { cin >> name >> type >> atk >> def >> res >> size; }
};
struct resident {
string name, type, belong;
int strength;
void read() { cin >> name >> type >> strength >> belong; }
};
vector<item> weapon, armor, orb;
vector<resident> atk, def, res;
map<string, vector<resident> > keep;
int N, M;
bool greater1(resident x, resident y) { return x.strength > y.strength; }
int sum(const vector<resident> &v, const std::string &a) {
int S = 0;
for (int i = 0; i < v.size(); i++)
if (v[i].type == a) S += v[i].strength;
return S;
}
bool sortatk(item x, item y) {
int Sx = x.atk + sum(keep[x.name], "gladiator"),
Sy = y.atk + sum(keep[y.name], "gladiator");
return Sx > Sy;
}
bool sortdef(item x, item y) {
int Sx = x.def + sum(keep[x.name], "sentry"),
Sy = y.def + sum(keep[y.name], "sentry");
return Sx > Sy;
}
bool sortres(item x, item y) {
int Sx = x.res + sum(keep[x.name], "physician"),
Sy = y.res + sum(keep[y.name], "physician");
return Sx > Sy;
}
void sort1() {
sort(weapon.begin(), weapon.end(), sortatk);
sort(armor.begin(), armor.end(), sortdef);
sort(orb.begin(), orb.end(), sortres);
}
void sort2() {
sort(atk.begin(), atk.end(), greater1);
sort(def.begin(), def.end(), greater1);
sort(res.begin(), res.end(), greater1);
}
void prepare(const vector<item> &s, const vector<resident> &t) {
for (int i = 0; i < s.size(); i++) {
keep[s[i].name].clear();
for (int j = 0; j < min(s[i].size, (int)t.size()); j++)
keep[s[i].name].push_back(t[j]);
}
}
void solve2() {
sort2();
prepare(weapon, atk);
prepare(armor, def);
prepare(orb, res);
sort1();
string _weapon(weapon[0].name), _aromr(armor[0].name), _orb(orb[0].name);
map<string, int> used;
for (int i = 0; i < keep[_weapon].size(); i++)
used[keep[_weapon][i].name] = 1;
for (int i = 0; i < keep[_orb].size(); i++) used[keep[_orb][i].name] = 1;
for (int i = 0; i < keep[_aromr].size(); i++) used[keep[_aromr][i].name] = 1;
vector<resident> unu;
for (int i = 0; i < atk.size(); i++)
if (!used[atk[i].name]) unu.push_back(atk[i]);
for (int i = 0; i < def.size(); i++)
if (!used[def[i].name]) unu.push_back(def[i]);
for (int i = 0; i < res.size(); i++)
if (!used[res[i].name]) unu.push_back(res[i]);
int ii = 0;
int x = weapon[0].size - keep[_weapon].size();
for (int i = 0; i < x && ii < unu.size(); i++)
keep[_weapon].push_back(unu[ii++]);
int y = armor[0].size - keep[_aromr].size();
for (int i = 0; i < y && ii < unu.size(); i++)
keep[_aromr].push_back(unu[ii++]);
int z = orb[0].size - keep[_orb].size();
for (int i = 0; i < z && ii < unu.size(); i++)
keep[_orb].push_back(unu[ii++]);
}
int main() {
scanf("%d", &N);
int sum = 0;
for (int i = 0; i < N; i++) {
item tmp;
tmp.read();
sum += tmp.size;
if (tmp.type == "weapon")
weapon.push_back(tmp);
else if (tmp.type == "armor")
armor.push_back(tmp);
else
orb.push_back(tmp);
}
scanf("%d", &M);
for (int i = 0; i < M; i++) {
resident tmp;
tmp.read();
if (tmp.type == "gladiator")
atk.push_back(tmp);
else if (tmp.type == "sentry")
def.push_back(tmp);
else
res.push_back(tmp);
keep[tmp.belong].push_back(tmp);
}
(sum == M) ? (sort1()) : (solve2());
cout << weapon[0].name << " " << keep[weapon[0].name].size();
for (int i = 0; i < keep[weapon[0].name].size(); i++)
cout << " " << keep[weapon[0].name][i].name;
cout << "\n";
cout << armor[0].name << " " << keep[armor[0].name].size();
for (int i = 0; i < keep[armor[0].name].size(); i++)
cout << " " << keep[armor[0].name][i].name;
cout << "\n";
cout << orb[0].name << " " << keep[orb[0].name].size();
for (int i = 0; i < keep[orb[0].name].size(); i++)
cout << " " << keep[orb[0].name][i].name;
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926535897932384626433832795;
int const inf = (int)1e9;
long long const inf64 = (long long)2e18;
const string pname = "c";
const int NMAX = 1010;
const string TYPE[3] = {"gladiator", "sentry", "physician"};
const string ZN[3] = {"weapon", "armor", "orb"};
int n, m;
string name[NMAX], zn[NMAX], hero[NMAX], type[NMAX], home[NMAX];
int param[NMAX][3], places[NMAX], bonus[NMAX], extra[NMAX];
void answer(int x, int y, int z) {
cout << name[x] << " " << places[x];
for (int i = 0; i < (int)m; i++)
if (home[i] == name[x]) cout << " " << hero[i];
cout << endl;
cout << name[y] << " " << places[y];
for (int i = 0; i < (int)m; i++)
if (home[i] == name[y]) cout << " " << hero[i];
cout << endl;
cout << name[z] << " " << places[z];
for (int i = 0; i < (int)m; i++)
if (home[i] == name[z]) cout << " " << hero[i];
cout << endl;
exit(0);
}
int get(int now) {
int best = -1, ans = -1;
for (int i = 0; i < (int)n; i++)
if (zn[i] == ZN[now] && best < param[i][now]) best = param[i][now], ans = i;
return ans;
}
vector<pair<int, int> > q[3];
int ans[3];
int sum[NMAX];
void solve(int now) {
memset(sum, 0, sizeof(sum));
sum[0] = 0;
for (int i = 0; i < (int)q[now].size(); i++)
sum[i + 1] = sum[i] - q[now][i].first;
int best = -1, ind = -1;
for (int i = 0; i < (int)n; i++)
if (zn[i] == ZN[now]) {
int tmp = param[i][now] + sum[min((int)q[now].size(), places[i])];
if (best < tmp) {
best = tmp;
ind = i;
}
}
int cnt = min((int)q[now].size(), places[ind]);
extra[ind] = places[ind] - cnt;
places[ind] = cnt;
for (int i = 0; i < (int)cnt; i++) home[q[now][i].second] = name[ind];
ans[now] = ind;
}
int main() {
cin >> n;
int sum = 0;
for (int i = 0; i < (int)n; i++) {
cin >> name[i] >> zn[i];
for (int j = 0; j < (int)3; j++) cin >> param[i][j];
cin >> places[i];
sum += places[i];
}
cin >> m;
for (int i = 0; i < (int)m; i++)
cin >> hero[i] >> type[i] >> bonus[i] >> home[i];
if (sum == m) {
for (int i = 0; i < (int)m; i++)
for (int j = 0; j < (int)n; j++)
if (name[j] == home[i])
for (int f = 0; f < (int)3; f++)
if (TYPE[f] == type[i]) param[j][f] += bonus[i];
answer(get(0), get(1), get(2));
}
for (int i = 0; i < (int)m; i++)
for (int j = 0; j < (int)3; j++)
if (type[i] == TYPE[j]) q[j].push_back(make_pair(-bonus[i], i));
for (int j = 0; j < (int)3; j++) sort((q[j]).begin(), (q[j]).end());
for (int i = 0; i < (int)m; i++) home[i] = "";
for (int j = 0; j < (int)3; j++) solve(j);
for (int i = 0; i < (int)n; i++)
if (i != ans[0] && i != ans[1] && i != ans[2]) {
extra[i] = places[i];
places[i] = 0;
}
int yl = 0;
for (int i = 0; i < (int)m; i++)
if (home[i] == "") {
while (extra[yl] == 0) yl++;
home[i] = name[yl];
extra[yl]--;
places[yl]++;
}
answer(ans[0], ans[1], ans[2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const bool debug = true;
struct obj {
int val, cap;
string name;
obj(int nval, int ncap, string nname) : val(nval), cap(ncap), name(nname) {}
};
struct man {
int val;
string name, home;
man(int nval, string nname, string nhome)
: val(nval), name(nname), home(nhome) {}
bool operator<(const man &m) const { return val > m.val; }
};
int n, k;
vector<obj> inv[3];
vector<man> men[3];
int main() {
cin >> n;
map<string, int> est_cap;
for (int i = 0; i < n; i++) {
string name, c;
int a, d, r, cap;
cin >> name >> c >> a >> d >> r >> cap;
if (c == "weapon")
inv[0].push_back(obj(a, cap, name));
else if (c == "armor")
inv[1].push_back(obj(d, cap, name));
else if (c == "orb")
inv[2].push_back(obj(r, cap, name));
est_cap[name] = cap;
}
cin >> k;
set<string> unused;
for (int i = 0; i < k; i++) {
string name, c, h;
int b;
cin >> name >> c >> b >> h;
unused.insert(name);
est_cap[h]--;
if (c == "gladiator")
men[0].push_back(man(b, name, h));
else if (c == "sentry")
men[1].push_back(man(b, name, h));
else if (c == "physician")
men[2].push_back(man(b, name, h));
}
bool can = false;
for (map<string, int>::iterator it = est_cap.begin(); it != est_cap.end();
it++)
can |= it->second != 0;
if (!can) {
int best[3] = {-1, -1, -1};
for (int i = 0; i < 3; i++) {
best[i] = 0;
for (size_t j = 0; j < inv[i].size(); j++) {
for (size_t z = 0; z < men[i].size(); z++)
if (inv[i][j].name == men[i][z].home) inv[i][j].val += men[i][z].val;
if (inv[i][j].val > inv[i][best[i]].val) best[i] = j;
}
}
for (int i = 0; i < 3; i++) {
obj c = inv[i][best[i]];
cout << c.name << " " << c.cap - est_cap[c.name];
for (int z = 0; z < 3; z++)
for (size_t j = 0; j < men[z].size(); j++)
if (c.name == men[z][j].home) cout << " " << men[z][j].name;
cout << endl;
}
return 0;
}
for (int i = 0; i < 3; i++) sort(men[i].begin(), men[i].end());
vector<string> answer[3];
int ec[3] = {-1, -1, -1}, best[3] = {-1, -1, -1};
for (int i = 0; i < 3; i++) {
int bestval = -1;
for (size_t j = 0; j < inv[i].size(); j++) {
int value = inv[i][j].val;
for (int k = 0; k < min(inv[i][j].cap, (int)men[i].size()); k++)
value += men[i][k].val;
if (value > bestval) best[i] = j, bestval = value;
}
for (int k = 0; k < min(inv[i][best[i]].cap, (int)men[i].size()); k++)
answer[i].push_back(men[i][k].name), unused.erase(men[i][k].name);
ec[i] = inv[i][best[i]].cap - min(inv[i][best[i]].cap, (int)men[i].size());
}
for (int i = 0; i < 3; i++) {
while (unused.size() && ec[i])
answer[i].push_back(*unused.begin()), unused.erase(unused.begin()),
ec[i]--;
cout << inv[i][best[i]].name << " " << answer[i].size();
for (size_t j = 0; j < answer[i].size(); j++) cout << " " << answer[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string ItemNames[] = {"weapon", "armor", "orb"};
string ResNames[] = {"gladiator", "sentry", "physician"};
int GetIndex(const string &s, string *pArr) {
for (int i = 0; i < 3; i++)
if (pArr[i] == s) return i;
assert(0);
return -1;
}
struct Item {
string name;
int type;
int params[3];
int size;
};
struct Res {
string name;
int type;
int home;
int bonus;
inline bool operator<(const Res &other) const { return bonus > other.bonus; }
};
bool Cmp(int *a, int *b) {
for (int q = 0; q < 3; q++)
if (a[q] != b[q]) return a[q] < b[q];
return false;
}
int n, k;
Item items[128];
Res resids[1024];
int roparams[128][3];
vector<string> rohas[128];
int params[3];
vector<string> has[3];
int ansparams[3];
int best[3];
vector<string> bestres[3];
char buff[1 << 20];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
Item &it = items[i];
scanf("%s", buff);
it.name = buff;
scanf("%s", buff);
it.type = GetIndex(buff, ItemNames);
for (int u = 0; u < 3; u++) scanf("%d", &it.params[u]);
scanf("%d", &it.size);
}
scanf("%d", &k);
for (int i = 0; i < k; i++) {
Res &rs = resids[i];
scanf("%s", buff);
rs.name = buff;
scanf("%s", buff);
rs.type = GetIndex(buff, ResNames);
scanf("%d", &rs.bonus);
scanf("%s", buff);
rs.home = -1;
for (int j = 0; j < n; j++)
if (buff == items[j].name) rs.home = j;
}
int sumplace = 0;
for (int i = 0; i < n; i++) sumplace += items[i].size;
bool ro = (sumplace == k);
vector<Res> srt[3];
if (ro) {
for (int v = 0; v < n; v++)
memcpy(roparams[v], items[v].params, sizeof(roparams[0]));
for (int v = 0; v < k; v++) {
const Res &rs = resids[v];
roparams[rs.home][rs.type] += rs.bonus;
rohas[rs.home].push_back(rs.name);
}
} else {
for (int i = 0; i < k; i++) srt[resids[i].type].push_back(resids[i]);
for (int i = 0; i < 3; i++) sort(srt[i].begin(), srt[i].end());
}
memset(ansparams, -63, sizeof(ansparams));
for (int i = 0; i < n; i++)
if (items[i].type == 0)
for (int j = 0; j < n; j++)
if (items[j].type == 1)
for (int u = 0; u < n; u++)
if (items[u].type == 2) {
int a[3] = {i, j, u};
if (ro) {
for (int q = 0; q < 3; q++) {
params[q] = roparams[a[q]][q];
has[q] = rohas[a[q]];
}
} else {
for (int q = 0; q < 3; q++) {
params[q] = items[a[q]].params[q];
has[q].clear();
for (int j = 0; j < min(int(srt[q].size()), items[a[q]].size);
j++) {
params[q] += srt[q][j].bonus;
has[q].push_back(srt[q][j].name);
}
}
}
if (Cmp(ansparams, params)) {
for (int q = 0; q < 3; q++) {
ansparams[q] = params[q];
best[q] = a[q];
bestres[q] = has[q];
}
}
}
for (int i = 0; i < k; i++) {
bool used = false;
for (int q = 0; q < 3; q++)
for (int j = 0; j < bestres[q].size(); j++)
if (bestres[q][j] == resids[i].name) used = true;
for (int q = 0; q < 3; q++)
if (!used && bestres[q].size() < items[best[q]].size) {
bestres[q].push_back(resids[i].name);
used = true;
}
}
for (int q = 0; q < 3; q++) {
printf("%s %d", items[best[q]].name.c_str(), bestres[q].size());
for (int i = 0; i < bestres[q].size(); i++)
printf(" %s", bestres[q][i].c_str());
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string Name[1 << 10];
string Resident[1 << 10];
int Class[1 << 10];
int Type[1 << 10];
int A[1 << 10][4];
int Size[1 << 10];
int Home[1 << 10];
int Bonus[1 << 10];
int Sum[1 << 10][4];
int GetClass(string s) {
if (s == "weapon") return 0;
if (s == "armor") return 1;
if (s == "orb") return 2;
if (s == "gladiator") return 0;
if (s == "sentry") return 1;
if (s == "physician") return 2;
return -1;
}
int main() {
int i, j, ii, jj, kk;
int n;
scanf("%d", &n);
int cnt = 0;
for (i = (0); i < (n); ++i) {
char buf1[32];
char buf2[32];
int a, b, c, d;
scanf("%s%s%d%d%d%d", buf1, buf2, &a, &b, &c, &d);
Name[i] = buf1;
Class[i] = GetClass(buf2);
A[i][0] = a;
A[i][1] = b;
A[i][2] = c;
Size[i] = d;
cnt += Size[i];
}
int m;
scanf("%d", &m);
memset(Sum, 0, sizeof(Sum));
for (i = (0); i < (m); ++i) {
char buf1[32];
char buf2[32];
char buf3[32];
int a;
scanf("%s%s%d%s", buf1, buf2, &a, buf3);
Resident[i] = buf1;
Type[i] = GetClass(buf2);
for (j = (0); j < (n); ++j)
if (Name[j] == buf3) break;
Home[i] = j;
Bonus[i] = a;
Sum[Home[i]][Type[i]] += Bonus[i];
}
vector<int> ret[4];
int pos[] = {-1, -1, -1};
if (cnt == m) {
for (i = (0); i < (n); ++i)
for (j = (0); j < (3); ++j) Sum[i][j] += A[i][j];
for (i = (0); i < (3); ++i)
for (j = (0); j < (n); ++j)
if (Class[j] == i && (pos[i] == -1 || Sum[j][i] > Sum[pos[i]][i]))
pos[i] = j;
for (i = (0); i < (3); ++i)
for (j = (0); j < (m); ++j)
if (Home[j] == pos[i]) ret[i].push_back(j);
} else {
vector<pair<int, int> > v[3];
for (i = (0); i < (m); ++i)
v[Type[i]].push_back(pair<int, int>(Bonus[i], i));
for (i = (0); i < (3); ++i) {
sort((v[i]).begin(), (v[i]).end());
reverse((v[i]).begin(), (v[i]).end());
}
vector<int> res(3, -1);
for (ii = (0); ii < (11); ++ii)
for (jj = (0); jj < (11); ++jj)
for (kk = (0); kk < (11); ++kk) {
int size[] = {ii, jj, kk};
int add[] = {0, 0, 0};
for (i = (0); i < (3); ++i)
for (j = (0); j < (size[i]); ++j)
if (int((v[i]).size()) > j) add[i] += v[i][j].first;
vector<int> r;
int p[] = {-1, -1, -1};
for (i = (0); i < (3); ++i) {
int wh = -1;
for (j = (0); j < (n); ++j)
if (Class[j] == i && Size[j] == size[i] &&
(wh == -1 || A[wh][i] < A[j][i]))
wh = j;
if (wh != -1) {
r.push_back(A[wh][i] + add[i]);
p[i] = wh;
}
}
if (int((r).size()) == 3 && r > res) {
res = r;
pos[0] = p[0];
pos[1] = p[1];
pos[2] = p[2];
}
}
vector<int> free;
for (i = (0); i < (3); ++i)
for (j = (0); j < (int((v[i]).size())); ++j)
if (Size[pos[i]] > j)
ret[i].push_back(v[i][j].second);
else
free.push_back(v[i][j].second);
for (i = (0); i < (int((free).size())); ++i) {
for (j = (0); j < (3); ++j)
if (int((ret[j]).size()) < Size[pos[j]]) break;
if (j == 3) break;
ret[j].push_back(free[i]);
}
}
for (i = (0); i < (3); ++i) {
printf("%s %d", Name[pos[i]].c_str(), int((ret[i]).size()));
for (j = (0); j < (int((ret[i]).size())); ++j)
printf(" %s", Resident[ret[i][j]].c_str());
printf("\n");
}
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
int N, M, size[9999], mom[9999], ab[9999], inc[9999], t1[9999], t2[9999], sum,
target[3];
char buf[99], buf2[99];
string name1[9999], name2[9999];
map<string, int> num1, num2, type;
bool chk[9999];
vector<pair<int, int> > A[9], B[9];
vector<int> lst[9999];
void output() {
int i, k;
for (i = 1, k = 0; i <= N; i++)
if (t1[i] == 0) {
if (ab[k] < ab[i]) k = i;
}
printf("%s %d ", name1[k].c_str(), lst[k].size());
for (i = lst[k].size(); i--;) {
printf("%s ", name2[lst[k][i]].c_str());
}
puts("");
for (i = 1, k = 0; i <= N; i++)
if (t1[i] == 1) {
if (ab[k] < ab[i]) k = i;
}
printf("%s %d ", name1[k].c_str(), lst[k].size());
for (i = lst[k].size(); i--;) {
printf("%s ", name2[lst[k][i]].c_str());
}
puts("");
for (i = 1, k = 0; i <= N; i++)
if (t1[i] == 2) {
if (ab[k] < ab[i]) k = i;
}
printf("%s %d ", name1[k].c_str(), lst[k].size());
for (i = lst[k].size(); i--;) {
printf("%s ", name2[lst[k][i]].c_str());
}
}
int main() {
int i, j, k;
ab[0] = -1e9;
type["weapon"] = 0, type["armor"] = 1, type["orb"] = 2;
type["gladiator"] = 0, type["sentry"] = 1, type["physician"] = 2;
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%s%s", buf, buf2);
name1[i] = buf;
num1[buf] = i;
t1[i] = type[buf2];
switch (t1[i]) {
case 0:
scanf("%d%*d%*d", ab + i);
break;
case 1:
scanf("%*d%d%*d", ab + i);
break;
case 2:
scanf("%*d%*d%d", ab + i);
break;
}
scanf("%d", size + i);
A[t1[i]].push_back(pair<int, int>(ab[i], i));
sum += size[i];
}
scanf("%d", &M);
for (i = 1; i <= M; i++) {
scanf("%s%s", buf, buf2);
name2[i] = buf;
num2[buf] = i;
t2[i] = type[buf2];
scanf("%d%s", inc + i, buf);
mom[i] = num1[buf];
B[t2[i]].push_back(pair<int, int>(inc[i], i));
}
if (M == sum) {
for (i = 1; i <= M; i++) {
if (t1[mom[i]] == t2[i]) {
ab[mom[i]] += inc[i];
}
lst[mom[i]].push_back(i);
}
output();
return 0;
}
for (i = 0; i < 3; i++)
sort(A[i].begin(), A[i].end(), greater<pair<int, int> >()),
sort(B[i].begin(), B[i].end(), greater<pair<int, int> >());
for (i = 0; i < 3; i++) {
int mx = -1e9, tar = 0;
for (j = 0; j < A[i].size(); j++) {
int n = A[i][j].second, sz = size[n], v = ab[n];
for (k = 0; k < B[i].size() && sz > 0; k++) {
v += B[i][k].first;
sz--;
}
if (mx < v) mx = v, tar = n;
}
target[i] = tar;
for (j = 0; j < B[i].size() && size[tar] > 0; j++) {
ab[tar] += B[i][j].first;
lst[tar].push_back(B[i][j].second);
chk[B[i][j].second] = 1;
size[tar]--;
}
}
for (i = 0; i < 3; i++) {
k = target[i];
for (j = 1; j <= M && size[k] > 0; j++)
if (!chk[j]) {
chk[j] = 1;
size[k]--;
lst[k].push_back(j);
}
}
output();
}
|
#include <bits/stdc++.h>
using namespace std;
struct Resident {
string name, type, home;
int bonus;
bool operator<(const Resident &o) const { return bonus > o.bonus; }
};
struct Item {
string name, type;
int atk, def, res, size;
vector<Resident> residents;
Item() { atk = def = res = -100000000; }
int get_atk() const {
int ret = atk;
for (int i = 0; i < ((int)residents.size()); ++i) {
if (residents[i].type[0] == 'g') {
ret += residents[i].bonus;
}
}
return ret;
}
int get_def() const {
int ret = def;
for (int i = 0; i < ((int)residents.size()); ++i) {
if (residents[i].type[0] == 's') {
ret += residents[i].bonus;
}
}
return ret;
}
int get_res() const {
int ret = res;
for (int i = 0; i < ((int)residents.size()); ++i) {
if (residents[i].type[0] == 'p') {
ret += residents[i].bonus;
}
}
return ret;
}
};
vector<Resident> atk, def, res;
vector<Item> weapon, armor, orb;
int n, m;
void output(Item i) {
cout << i.name << ' ' << ((int)i.residents.size());
for (int j = 0; j < ((int)i.residents.size()); ++j) {
cout << ' ' << i.residents[j].name;
}
cout << endl;
}
int main() {
int tot_size = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
Item cur;
cin >> cur.name >> cur.type;
cin >> cur.atk >> cur.def >> cur.res;
cin >> cur.size;
tot_size += cur.size;
if (cur.type == "weapon") {
weapon.push_back(cur);
} else if (cur.type == "armor") {
armor.push_back(cur);
} else if (cur.type == "orb") {
orb.push_back(cur);
}
}
cin >> m;
for (int i = 0; i < m; ++i) {
Resident cur;
cin >> cur.name >> cur.type >> cur.bonus >> cur.home;
for (int j = 0; j < ((int)weapon.size()); ++j) {
if (weapon[j].name == cur.home) {
weapon[j].residents.push_back(cur);
}
}
for (int j = 0; j < ((int)armor.size()); ++j) {
if (armor[j].name == cur.home) {
armor[j].residents.push_back(cur);
}
}
for (int j = 0; j < ((int)orb.size()); ++j) {
if (orb[j].name == cur.home) {
orb[j].residents.push_back(cur);
}
}
if (cur.type == "gladiator") {
atk.push_back(cur);
} else if (cur.type == "sentry") {
def.push_back(cur);
} else if (cur.type == "physician") {
res.push_back(cur);
}
}
sort(atk.begin(), atk.end());
sort(def.begin(), def.end());
sort(res.begin(), res.end());
bool has_space = tot_size > m;
if (has_space) {
for (int i = 0; i < ((int)weapon.size()); ++i) {
weapon[i].residents.clear();
for (int j = 0; j < weapon[i].size && j < ((int)atk.size()); ++j) {
weapon[i].residents.push_back(atk[j]);
}
}
for (int i = 0; i < ((int)armor.size()); ++i) {
armor[i].residents.clear();
for (int j = 0; j < armor[i].size && j < ((int)def.size()); ++j) {
armor[i].residents.push_back(def[j]);
}
}
for (int i = 0; i < ((int)orb.size()); ++i) {
orb[i].residents.clear();
for (int j = 0; j < orb[i].size && j < ((int)res.size()); ++j) {
orb[i].residents.push_back(res[j]);
}
}
}
Item best_weapon = weapon[0];
for (int i = 0; i < ((int)weapon.size()); ++i) {
if (weapon[i].get_atk() > best_weapon.get_atk()) {
best_weapon = weapon[i];
}
}
Item best_armor = armor[0];
for (int i = 0; i < ((int)armor.size()); ++i) {
if (armor[i].get_def() > best_armor.get_def()) {
best_armor = armor[i];
}
}
Item best_orb = orb[0];
for (int i = 0; i < ((int)orb.size()); ++i) {
if (orb[i].get_res() > best_orb.get_res()) {
best_orb = orb[i];
}
}
if (has_space) {
Item item[3] = {best_weapon, best_armor, best_orb};
vector<Resident> all(atk.begin(), atk.end());
all.insert(all.end(), def.begin(), def.end());
all.insert(all.end(), res.begin(), res.end());
set<string> exist;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < ((int)item[i].residents.size()); ++j) {
exist.insert(item[i].residents[j].name);
}
}
for (int i = 0; i < ((int)all.size()); ++i) {
if (exist.count(all[i].name)) {
continue;
}
for (int j = 0; j < 3; ++j) {
if (((int)item[j].residents.size()) < item[j].size) {
item[j].residents.push_back(all[i]);
break;
}
}
}
best_weapon = item[0];
best_armor = item[1];
best_orb = item[2];
}
output(best_weapon);
output(best_armor);
output(best_orb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 105;
const int Maxk = 1005;
struct weapon {
string name, clas;
int atk, def, res, siz;
vector<int> V;
} W[Maxn];
struct resid {
string name, type, home;
int bonus;
} R[Maxk];
int n, k;
bool pl;
int w, wp = -1, a, ap = -1, o, op = -1;
int Find(const string &s) {
for (int i = 0; i < n; i++)
if (W[i].name == s) return i;
return -1;
}
int Points(const string &t, const resid &r) {
if (t == "weapon" && r.type == "gladiator" ||
t == "armor" && r.type == "sentry" || t == "orb" && r.type == "physician")
return r.bonus;
return 0;
}
void Build(weapon &w) {
priority_queue<pair<int, int> > Q;
for (int i = 0; i < k; i++)
if (w.name == R[i].home) Q.push(make_pair(-Points(w.clas, R[i]), i));
for (int i = 0; i < k; i++)
if (w.name != R[i].home) {
int p = Points(w.clas, R[i]);
if (p == 0) continue;
if (w.siz > 0) {
W[Find(R[i].home)].siz++;
w.siz--;
R[i].home = w.name;
Q.push(make_pair(-p, i));
} else if (!Q.empty() && p > -Q.top().first) {
R[Q.top().second].home = R[i].home;
R[i].home = w.name;
Q.pop();
Q.push(make_pair(-p, i));
}
}
}
void Get(const string &name, vector<int> &V) {
V.clear();
for (int i = 0; i < k; i++)
if (name == R[i].home) V.push_back(i);
}
int getPoints(const weapon &w) {
int p = w.clas == "weapon" ? w.atk : w.clas == "armor" ? w.def : w.res;
for (int i = 0; i < w.V.size(); i++) p += Points(w.clas, R[w.V[i]]);
return p;
}
int main() {
std::ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++)
cin >> W[i].name >> W[i].clas >> W[i].atk >> W[i].def >> W[i].res >>
W[i].siz;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> R[i].name >> R[i].type >> R[i].bonus >> R[i].home;
W[Find(R[i].home)].siz--;
}
pl = false;
for (int i = 0; i < n && !pl; i++) pl = W[i].siz > 0;
for (int i = 0; i < n; i++)
if (W[i].clas == "weapon") {
if (pl) Build(W[i]);
Get(W[i].name, W[i].V);
int cand = getPoints(W[i]);
if (cand > wp) {
wp = cand;
w = i;
}
}
for (int i = 0; i < n; i++)
if (W[i].clas == "armor") {
if (pl) Build(W[i]);
Get(W[i].name, W[i].V);
int cand = getPoints(W[i]);
if (cand > ap) {
ap = cand;
a = i;
}
}
for (int i = 0; i < n; i++)
if (W[i].clas == "orb") {
if (pl) Build(W[i]);
Get(W[i].name, W[i].V);
int cand = getPoints(W[i]);
if (cand > op) {
op = cand;
o = i;
}
}
if (pl) Build(W[w]);
Get(W[w].name, W[w].V);
cout << W[w].name << " " << W[w].V.size();
for (int i = 0; i < W[w].V.size(); i++) cout << " " << R[W[w].V[i]].name;
cout << endl;
if (pl) Build(W[a]);
Get(W[a].name, W[a].V);
cout << W[a].name << " " << W[a].V.size();
for (int i = 0; i < W[a].V.size(); i++) cout << " " << R[W[a].V[i]].name;
cout << endl;
if (pl) Build(W[o]);
Get(W[o].name, W[o].V);
cout << W[o].name << " " << W[o].V.size();
for (int i = 0; i < W[o].V.size(); i++) cout << " " << R[W[o].V[i]].name;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, sum = 0;
cin >> n;
vector<string> RES[3][100];
vector<pair<string, pair<long long, long long> > > eq[3];
vector<pair<long long, string> > res[3];
map<string, int> mp;
mp["weapon"] = 0;
mp["armor"] = 1;
mp["orb"] = 2;
mp["gladiator"] = 0;
mp["sentry"] = 1;
mp["physician"] = 2;
for (long long i = 0; i < ((long long)n); i++) {
string name, type;
long long a[3], num;
cin >> name >> type >> a[0] >> a[1] >> a[2] >> num;
sum += num;
eq[mp[type]].push_back(make_pair(name, make_pair(a[mp[type]], num)));
}
cin >> m;
if (sum == m) {
for (long long i = 0; i < ((long long)m); i++) {
string name, type, owner;
long long power;
cin >> name >> type >> power >> owner;
for (long long j = 0; j < ((long long)3); j++)
for (long long k = 0; k < ((long long)((long long)(eq[j]).size())); k++)
if (eq[j][k].first == owner) {
RES[j][k].push_back(name);
if (mp[type] == j) eq[j][k].second.first += power;
}
}
for (long long i = 0; i < ((long long)3); i++) {
long long best = 0;
for (long long j = 0; j < ((long long)((long long)(eq[i]).size())); j++)
if (eq[i][best].second.first < eq[i][j].second.first) best = j;
cout << eq[i][best].first << " " << ((long long)(RES[i][best]).size())
<< " ";
for (long long j = 0; j < ((long long)((long long)(RES[i][best]).size()));
j++)
cout << RES[i][best][j] << " ";
cout << endl;
}
} else {
vector<string> names;
bool used[1005];
for (long long i = 0; i < ((long long)1005); i++) used[i] = false;
for (long long i = 0; i < ((long long)m); i++) {
string name, type, owner;
long long power;
cin >> name >> type >> power >> owner;
res[mp[type]].push_back(make_pair(power, name));
names.push_back(name);
}
for (long long i = 0; i < ((long long)3); i++)
sort(res[i].begin(), res[i].end());
for (long long i = 0; i < ((long long)3); i++)
reverse(res[i].begin(), res[i].end());
for (long long i = 0; i < ((long long)3); i++) {
long long best = 0;
for (long long j = 0; j < ((long long)((long long)(eq[i]).size())); j++) {
long long sum0 = eq[i][best].second.first;
for (long long k = 0; k < ((long long)min(((long long)(res[i]).size()),
eq[i][best].second.second));
k++)
sum0 += res[i][k].first;
long long sum1 = eq[i][j].second.first;
for (long long k = 0; k < ((long long)min(((long long)(res[i]).size()),
eq[i][j].second.second));
k++)
sum1 += res[i][k].first;
if (sum0 < sum1) best = j;
}
for (long long j = 0; j < ((long long)min(((long long)(res[i]).size()),
eq[i][best].second.second));
j++) {
for (long long k = 0; k < ((long long)m); k++)
if (res[i][j].second == names[k]) used[k] = true;
}
}
for (long long i = 0; i < ((long long)3); i++) {
long long best = 0;
for (long long j = 0; j < ((long long)((long long)(eq[i]).size())); j++) {
long long sum0 = eq[i][best].second.first;
for (long long k = 0; k < ((long long)min(((long long)(res[i]).size()),
eq[i][best].second.second));
k++)
sum0 += res[i][k].first;
long long sum1 = eq[i][j].second.first;
for (long long k = 0; k < ((long long)min(((long long)(res[i]).size()),
eq[i][j].second.second));
k++)
sum1 += res[i][k].first;
if (sum0 < sum1) best = j;
}
vector<string> ans;
cout << eq[i][best].first << " ";
for (long long j = 0; j < ((long long)min(((long long)(res[i]).size()),
eq[i][best].second.second));
j++)
ans.push_back(res[i][j].second);
for (long long j = 0; j < ((long long)eq[i][best].second.second -
((long long)(res[i]).size()));
j++) {
for (long long k = 0; k < ((long long)m); k++)
if (!used[k]) {
ans.push_back(names[k]);
used[k] = true;
break;
}
}
cout << ((long long)(ans).size()) << " ";
for (long long j = 0; j < ((long long)((long long)(ans).size())); j++)
cout << ans[j] << " ";
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point(double x, double y) : x(x), y(y) {}
point() { x = y = 0.0; }
point operator+(point q) { return point(x + q.x, y + q.y); }
point operator-(point q) { return point(x - q.x, y - q.y); }
point operator*(double t) { return point(x * t, y * t); }
point operator/(double t) { return point(x / t, y / t); }
double operator*(point q) { return q.x * x + q.y * y; }
double operator%(point q) { return x * q.y - y * q.x; }
};
const double PI = 2.0 * acos(0.0);
inline int getInt() {
int x;
scanf("%d", &x);
return x;
}
inline long long getLL() {
long long x;
scanf("%lld", &x);
return x;
};
inline int NUM(char c) { return (int)c - 48; }
inline char CHR(int n) { return (char)(n + 48); }
template <class T>
inline T MAX(T a, T b) {
if (a > b) return a;
return b;
}
template <class T>
inline T MIN(T a, T b) {
if (a < b) return a;
return b;
}
inline int BPM(int a, int b, int MOD) {
if (a == 0) return 0;
if (b == 0) return 1 % MOD;
if (b % 2 == 1) return (int)((long long)BPM(a, b - 1, MOD) * a % MOD);
int tmp = BPM(a, b / 2, MOD);
return (int)((long long)tmp * tmp % MOD);
}
inline int phi(int N) {
int ret = N;
for (int i = 2; N > 1; i++) {
if (i * i > N) {
ret -= ret / N;
break;
}
if (N % i == 0) {
ret -= ret / i;
while (N % i == 0) N /= i;
}
}
return ret;
}
inline void OPEN(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
typedef struct {
string name;
string type;
int atk, def, res, sz;
} eqtype;
typedef struct {
string name;
string type;
string home;
int bonus;
} residtype;
eqtype eq[100 + 5];
residtype rr[1000 + 5];
char ss[1000];
int N, M;
map<string, int> MAP, TYPE;
int A[100 + 5], D[100 + 5], R[100 + 5];
vector<pair<int, string> > gladiator, sentry, physician;
int totglad[1000 + 5], totsen[1000 + 5], totphy[1000 + 5];
vector<string> buang, weap, arm, orb;
int main() {
scanf("%d", &N);
int tot = 0;
for (int i = 0, _n = (N); i < _n; i++) {
scanf("%s", ss);
eq[i].name = ss;
scanf("%s", ss);
eq[i].type = ss;
scanf("%d%d%d%d", &eq[i].atk, &eq[i].def, &eq[i].res, &eq[i].sz);
tot += eq[i].sz;
MAP[eq[i].name] = i;
}
scanf("%d", &M);
for (int i = 0, _n = (M); i < _n; i++) {
scanf("%s", ss);
rr[i].name = ss;
scanf("%s", ss);
rr[i].type = ss;
scanf("%d", &rr[i].bonus);
scanf("%s", ss);
rr[i].home = ss;
int tmp = MAP[rr[i].home];
if (rr[i].type == "gladiator") {
A[tmp] += rr[i].bonus;
} else if (rr[i].type == "sentry") {
D[tmp] += rr[i].bonus;
} else {
R[tmp] += rr[i].bonus;
}
}
if (tot == M) {
int mx, idx;
mx = -1000000005;
idx = -1;
for (int i = 0, _n = (N); i < _n; i++) {
if (eq[i].type == "weapon") {
if (eq[i].atk + A[i] > mx) {
mx = eq[i].atk + A[i];
idx = i;
}
}
}
int ctr = 0;
for (int i = 0, _n = (M); i < _n; i++) {
if (rr[i].home == eq[idx].name) {
ctr++;
}
}
printf("%s %d", (eq[idx].name).c_str(), ctr);
for (int i = 0, _n = (M); i < _n; i++) {
if (rr[i].home == eq[idx].name) {
printf(" %s", (rr[i].name).c_str());
}
}
puts("");
mx = -1000000005;
idx = -1;
for (int i = 0, _n = (N); i < _n; i++) {
if (eq[i].type == "armor") {
if (eq[i].def + D[i] > mx) {
mx = eq[i].def + D[i];
idx = i;
}
}
}
ctr = 0;
for (int i = 0, _n = (M); i < _n; i++) {
if (rr[i].home == eq[idx].name) {
ctr++;
}
}
printf("%s %d", (eq[idx].name).c_str(), ctr);
for (int i = 0, _n = (M); i < _n; i++) {
if (rr[i].home == eq[idx].name) {
printf(" %s", (rr[i].name).c_str());
}
}
puts("");
mx = -1000000005;
idx = -1;
for (int i = 0, _n = (N); i < _n; i++) {
if (eq[i].type == "orb") {
if (eq[i].res + R[i] > mx) {
mx = eq[i].res + R[i];
idx = i;
}
}
}
ctr = 0;
for (int i = 0, _n = (M); i < _n; i++) {
if (rr[i].home == eq[idx].name) {
ctr++;
}
}
printf("%s %d", (eq[idx].name).c_str(), ctr);
for (int i = 0, _n = (M); i < _n; i++) {
if (rr[i].home == eq[idx].name) {
printf(" %s", (rr[i].name).c_str());
}
}
puts("");
} else {
for (int i = 0, _n = (M); i < _n; i++) {
if (rr[i].type == "gladiator")
gladiator.push_back(make_pair(rr[i].bonus, rr[i].name));
else if (rr[i].type == "sentry")
sentry.push_back(make_pair(rr[i].bonus, rr[i].name));
else
physician.push_back(make_pair(rr[i].bonus, rr[i].name));
}
sort((gladiator).begin(), (gladiator).end(), greater<pair<int, string> >());
sort((sentry).begin(), (sentry).end(), greater<pair<int, string> >());
sort((physician).begin(), (physician).end(), greater<pair<int, string> >());
for (int i = 0, _n = ((gladiator).size()); i < _n; i++) {
if (i == 0)
totglad[i] = gladiator[i].first;
else
totglad[i] = gladiator[i].first + totglad[i - 1];
}
for (int i = 0, _n = ((sentry).size()); i < _n; i++) {
totsen[i] = sentry[i].first;
if (i != 0) totsen[i] += totsen[i - 1];
}
for (int i = 0, _n = ((physician).size()); i < _n; i++) {
totphy[i] = physician[i].first;
if (i != 0) totphy[i] += totphy[i - 1];
}
int idx = -1, mx = -1000000005;
int gsz = (gladiator).size();
int ssz = (sentry).size();
int psz = (physician).size();
idx = -1, mx = -1000000005;
for (int i = 0, _n = (N); i < _n; i++) {
if (eq[i].type == "weapon") {
if (eq[i].atk + (gsz > 0 ? totglad[MIN(eq[i].sz, gsz) - 1] : 0) > mx) {
idx = i;
mx = eq[i].atk + (gsz > 0 ? totglad[MIN(eq[i].sz, gsz) - 1] : 0);
}
}
}
int widx = idx;
for (int i = 0, _n = (gsz); i < _n; i++) {
if (i < eq[idx].sz) {
weap.push_back(gladiator[i].second);
} else
buang.push_back(gladiator[i].second);
}
idx = -1, mx = -1000000005;
for (int i = 0, _n = (N); i < _n; i++) {
if (eq[i].type == "armor") {
if (eq[i].def + (ssz > 0 ? totsen[MIN(eq[i].sz, ssz) - 1] : 0) > mx) {
idx = i;
mx = eq[i].def + (ssz > 0 ? totsen[MIN(eq[i].sz, ssz) - 1] : 0);
}
}
}
int aidx = idx;
for (int i = 0, _n = (ssz); i < _n; i++) {
if (i < eq[idx].sz) {
arm.push_back(sentry[i].second);
} else
buang.push_back(sentry[i].second);
}
idx = -1, mx = -1000000005;
for (int i = 0, _n = (N); i < _n; i++) {
if (eq[i].type == "orb") {
if (eq[i].res + (psz > 0 ? totphy[MIN(eq[i].sz, psz) - 1] : 0) > mx) {
idx = i;
mx = eq[i].res + (psz > 0 ? totphy[MIN(eq[i].sz, psz) - 1] : 0);
}
}
}
int oidx = idx;
for (int i = 0, _n = (psz); i < _n; i++) {
if (i < eq[idx].sz) {
orb.push_back(physician[i].second);
} else
buang.push_back(physician[i].second);
}
for (int i = 0, _n = ((buang).size()); i < _n; i++) {
if ((weap).size() < eq[widx].sz)
weap.push_back(buang[i]);
else if ((arm).size() < eq[aidx].sz)
arm.push_back(buang[i]);
else if ((orb).size() < eq[oidx].sz)
orb.push_back(buang[i]);
else
break;
}
printf("%s %d", eq[widx].name.c_str(), (weap).size());
for (int i = 0, _n = ((weap).size()); i < _n; i++)
printf(" %s", weap[i].c_str());
puts("");
printf("%s %d", eq[aidx].name.c_str(), (arm).size());
for (int i = 0, _n = ((arm).size()); i < _n; i++)
printf(" %s", arm[i].c_str());
puts("");
printf("%s %d", eq[oidx].name.c_str(), (orb).size());
for (int i = 0, _n = ((orb).size()); i < _n; i++)
printf(" %s", orb[i].c_str());
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct P {
string name;
vector<int> val;
int sz;
vector<string> resis;
};
struct Q {
string name;
vector<int> adder;
string home;
bool operator<(const Q &rhs) const { return adder < rhs.adder; }
};
vector<P> item[3];
vector<P> ites[3];
vector<Q> resk[3];
vector<int> make(int a, int b, int c) {
vector<int> vi(3);
vi[0] = a, vi[1] = b, vi[2] = c;
return vi;
}
int main() {
int N;
while (cin >> N) {
for (int j = 0; j < (int)(3); ++j) item[j].clear(), ites[j].clear();
int szsum = 0;
for (int i = 0; i < (int)(N); ++i) {
string name, type;
int a, d, r, s;
cin >> name >> type >> a >> d >> r >> s;
int j = -166;
if (type == "weapon") j = 0;
if (type == "armor") j = 1;
if (type == "orb") j = 2;
item[j].push_back((P){name, make(a, d, r), s});
ites[j].push_back((P){name, make(a, d, r), s});
szsum += s;
}
int M;
cin >> M;
for (int k = 0; k < (int)(3); ++k) resk[k].clear();
for (int i = 0; i < (int)(M); ++i) {
string name, type, home;
int velo;
cin >> name >> type >> velo >> home;
int j = -166;
if (type == "gladiator") j = 0;
if (type == "sentry") j = 1;
if (type == "physician") j = 2;
vector<int> adder = make(0, 0, 0);
adder[j] += velo;
resk[j].push_back((Q){name, adder, home});
for (int k = 0; k < (int)(3); ++k)
for (__typeof((ites[k]).begin()) it = (ites[k]).begin();
it != (ites[k]).end(); ++it)
if (home == it->name) {
for (int l = 0; l < (int)(3); ++l) it->val[l] += adder[l];
it->resis.push_back(name);
}
}
if (M == szsum) {
vector<int> best = make(-1, -1, -1);
for (int k = 0; k < (int)(3); ++k) {
for (__typeof((ites[k]).begin()) it = (ites[k]).begin();
it != (ites[k]).end(); ++it)
best[k] = max(best[k], it->val[k]);
}
for (int k = 0; k < (int)(3); ++k) {
for (__typeof((ites[k]).begin()) it = (ites[k]).begin();
it != (ites[k]).end(); ++it)
if (best[k] == it->val[k]) {
vector<string> ret = it->resis;
cout << (it->name) << " " << (int)((ret).size());
for (__typeof((ret).begin()) vt = (ret).begin(); vt != (ret).end();
++vt)
cout << " " << (*vt);
cout << endl;
break;
}
}
} else {
for (int k = 0; k < (int)(3); ++k) {
sort(resk[k].begin(), resk[k].end());
reverse(resk[k].begin(), resk[k].end());
}
vector<int> best = make(-1, -1, -1);
P ret[3];
vector<string> vs[3];
vector<string> remain[3];
for (int k = 0; k < (int)(3); ++k) {
for (__typeof((item[k]).begin()) it = (item[k]).begin();
it != (item[k]).end(); ++it) {
int u = it->val[k];
vector<string> temp;
for (int itr = 0; itr < (int)(it->sz); ++itr) {
if (itr >= (int)((resk[k]).size())) break;
u += resk[k][itr].adder[k];
temp.push_back(resk[k][itr].name);
}
if (best[k] < u) {
best[k] = u;
vs[k] = temp;
ret[k] = *it;
remain[k].clear();
for (int itr = (it->sz); itr < (int)((int)((resk[k]).size()));
++itr)
remain[k].push_back(resk[k][itr].name);
}
}
}
vector<string> rem;
for (int k = 0; k < (int)(3); ++k)
rem.insert(rem.end(), remain[k].begin(), remain[k].end());
for (int k = 0; k < (int)(3); ++k) {
while ((int)((vs[k]).size()) < ret[k].sz && (int)((rem).size())) {
vs[k].push_back(rem.back());
rem.pop_back();
}
}
for (int k = 0; k < (int)(3); ++k) {
cout << ret[k].name << " " << (int)((vs[k]).size());
for (__typeof((vs[k]).begin()) vt = (vs[k]).begin();
vt != (vs[k]).end(); ++vt)
cout << " " << (*vt);
cout << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> wnames;
vector<string> anames;
vector<string> onames;
vector<int> wsize;
vector<int> asize;
vector<int> osize;
vector<int> watk;
vector<int> adef;
vector<int> ores;
map<string, int> weaponbase;
map<string, int> armorbase;
map<string, int> orbbase;
map<string, string> tite;
map<string, vector<string> > residents;
vector<pair<int, string> > rw, ra, ro;
int main() {
int N;
int a, d, r, s;
string name, clas;
cin >> N;
int total = 0;
for (int i = 0; i < N; i++) {
cin >> name >> clas >> a >> d >> r >> s;
tite[name] = clas;
total += s;
residents[name].clear();
if (clas == "weapon") {
wnames.push_back(name);
watk.push_back(a);
wsize.push_back(s);
weaponbase[name] = a;
}
if (clas == "armor") {
anames.push_back(name);
adef.push_back(d);
asize.push_back(s);
armorbase[name] = d;
}
if (clas == "orb") {
onames.push_back(name);
ores.push_back(r);
osize.push_back(s);
orbbase[name] = r;
}
}
int K;
cin >> K;
string home;
int b;
map<string, bool> esta;
for (int i = 0; i < K; i++) {
cin >> name >> clas >> b >> home;
esta[name] = true;
residents[home].push_back(name);
if (clas == "gladiator") {
rw.push_back(make_pair(-b, name));
if (tite[home] == "weapon") weaponbase[home] += b;
}
if (clas == "sentry") {
ra.push_back(make_pair(-b, name));
if (tite[home] == "armor") armorbase[home] += b;
}
if (clas == "physician") {
ro.push_back(make_pair(-b, name));
if (tite[home] == "orb") orbbase[home] += b;
}
}
if (K == total) {
map<string, int>::iterator it;
int max = -1;
string pw;
for (it = weaponbase.begin(); it != weaponbase.end(); ++it) {
if ((*it).second > max) {
max = (*it).second;
pw = (*it).first;
}
}
string pa;
max = -1;
for (it = armorbase.begin(); it != armorbase.end(); ++it) {
if ((*it).second > max) {
max = (*it).second;
pa = (*it).first;
}
}
string po;
max = -1;
for (it = orbbase.begin(); it != orbbase.end(); ++it) {
if ((*it).second > max) {
max = (*it).second;
po = (*it).first;
}
}
cout << pw << " " << residents[pw].size();
for (int i = 0; i < residents[pw].size(); i++) {
cout << " " << residents[pw][i];
}
cout << endl;
cout << pa << " " << residents[pa].size();
for (int i = 0; i < residents[pa].size(); i++) {
cout << " " << residents[pa][i];
}
cout << endl;
cout << po << " " << residents[po].size();
for (int i = 0; i < residents[po].size(); i++) {
cout << " " << residents[po][i];
}
cout << endl;
return 0;
}
int wcant = wnames.size();
int acant = anames.size();
int ocant = onames.size();
sort((rw).begin(), (rw).end());
sort((ra).begin(), (ra).end());
sort((ro).begin(), (ro).end());
int latk = -1;
int lwpos;
int matk = -1;
for (int i = 0; i < wcant; i++) {
latk = watk[i];
for (int j = 0; j < min((int)rw.size(), wsize[i]); j++) {
latk += (-rw[j].first);
}
if (latk > matk) {
matk = latk;
lwpos = i;
}
}
int ldef, lapos;
int mdef = -1;
for (int i = 0; i < acant; i++) {
ldef = adef[i];
for (int j = 0; j < min((int)ra.size(), asize[i]); j++) {
ldef += (-ra[j].first);
}
if (ldef > mdef) {
mdef = ldef;
lapos = i;
}
}
int lres, lopos;
int mres = -1;
for (int i = 0; i < ocant; i++) {
lres = ores[i];
for (int j = 0; j < min((int)ro.size(), osize[i]); j++) {
lres += (-ro[j].first);
}
if (lres > mres) {
mres = lres;
lopos = i;
}
}
vector<string> libres;
int contlibres = 0;
for (int i = 0; i < min((int)ro.size(), osize[lopos]); i++) {
esta[ro[i].second] = false;
}
for (int i = 0; i < min((int)ra.size(), asize[lapos]); i++) {
esta[ra[i].second] = false;
}
for (int i = 0; i < min((int)rw.size(), wsize[lwpos]); i++) {
esta[rw[i].second] = false;
}
map<string, bool>::iterator it;
for (it = esta.begin(); it != esta.end(); ++it) {
if ((*it).second) {
libres.push_back((*it).first);
}
}
int cl = libres.size() - contlibres;
cout << wnames[lwpos] << " "
<< min((int)rw.size(), wsize[lwpos]) +
min(max(0, wsize[lwpos] - (int)rw.size()), cl);
for (int i = 0; i < min((int)rw.size(), wsize[lwpos]); i++) {
cout << " " << rw[i].second;
}
for (int i = 0; i < min(cl, wsize[lwpos] - (int)rw.size()); i++) {
cout << " " << libres[contlibres];
contlibres++;
}
cout << endl;
cl = libres.size() - contlibres;
cout << anames[lapos] << " "
<< min((int)ra.size(), asize[lapos]) +
min(max(0, asize[lapos] - (int)ra.size()), cl);
for (int i = 0; i < min((int)ra.size(), asize[lapos]); i++) {
cout << " " << ra[i].second;
}
for (int i = 0; i < min(cl, asize[lapos] - (int)ra.size()); i++) {
cout << " " << libres[contlibres];
contlibres++;
}
cout << endl;
cl = libres.size() - contlibres;
cout << onames[lopos] << " "
<< min((int)ro.size(), osize[lopos]) +
min(max(0, osize[lopos] - (int)ro.size()), cl);
for (int i = 0; i < min((int)ro.size(), osize[lopos]); i++) {
cout << " " << ro[i].second;
}
for (int i = 0; i < min(cl, osize[lopos] - (int)ro.size()); i++) {
cout << " " << libres[contlibres];
contlibres++;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct thing {
string name, type;
int atk, def, res, d, sum, count;
};
struct rez {
string name, type;
int bonus, on;
};
int n, k;
vector<thing> A;
vector<rez> B;
bool W[1024];
bool Comp1(int i, int j) { return (B[i].bonus > B[j].bonus); }
int main() {
cin >> n;
for (int(i) = (0); (i) < (n); ++(i)) {
thing t;
cin >> t.name >> t.type >> t.atk >> t.def >> t.res >> t.d;
if (t.type == "weapon")
t.sum = t.atk;
else if (t.type == "armor")
t.sum = t.def;
else if (t.type == "orb")
t.sum = t.res;
t.count = 0;
A.push_back(t);
}
cin >> k;
for (int(i) = (0); (i) < (k); ++(i)) {
rez t;
string s;
cin >> t.name >> t.type >> t.bonus >> s;
for (int(j) = (0); (j) < (n); ++(j))
if (A[j].name == s) t.on = j;
A[t.on].count++;
if (A[t.on].type == "weapon" && t.type == "gladiator")
A[t.on].sum += t.bonus;
if (A[t.on].type == "armor" && t.type == "sentry") A[t.on].sum += t.bonus;
if (A[t.on].type == "orb" && t.type == "physician") A[t.on].sum += t.bonus;
B.push_back(t);
}
bool ok = false;
for (int(i) = (0); (i) < (n); ++(i))
if (A[i].count < A[i].d) ok = true;
if (!ok) {
int r1 = -1, r2 = -1, r3 = -1;
for (int(i) = (0); (i) < (n); ++(i))
if (A[i].type == "weapon" && (r1 == -1 || A[r1].sum < A[i].sum)) r1 = i;
for (int(i) = (0); (i) < (n); ++(i))
if (A[i].type == "armor" && (r2 == -1 || A[r2].sum < A[i].sum)) r2 = i;
for (int(i) = (0); (i) < (n); ++(i))
if (A[i].type == "orb" && (r3 == -1 || A[r3].sum < A[i].sum)) r3 = i;
cout << A[r1].name << ' ' << A[r1].count << ' ';
for (int(j) = (0); (j) < (k); ++(j))
if (B[j].on == r1) cout << B[j].name << ' ';
cout << endl;
cout << A[r2].name << ' ' << A[r2].count << ' ';
for (int(j) = (0); (j) < (k); ++(j))
if (B[j].on == r2) cout << B[j].name << ' ';
cout << endl;
cout << A[r3].name << ' ' << A[r3].count << ' ';
for (int(j) = (0); (j) < (k); ++(j))
if (B[j].on == r3) cout << B[j].name << ' ';
cout << endl;
return 0;
}
int r1, r2, r3;
vector<int> Q1, Q2, Q3;
int x = -1, maxSum = -1;
vector<int> Q;
for (int(i) = (0); (i) < (n); ++(i))
if (A[i].type == "weapon") {
vector<int> T;
for (int(j) = (0); (j) < (k); ++(j))
if (B[j].type == "gladiator") T.push_back(j);
sort((T).begin(), (T).end(), Comp1);
int sum = A[i].atk;
for (int(j) = (0); (j) < (min((int)T.size(), A[i].d)); ++(j))
sum += B[T[j]].bonus;
if (sum > maxSum) {
maxSum = sum;
x = i;
Q = T;
}
}
r1 = x;
Q1 = Q;
for (int(i) = (0); (i) < (min((int)Q.size(), A[x].d)); ++(i)) W[Q[i]] = true;
x = -1, maxSum = -1;
for (int(i) = (0); (i) < (n); ++(i))
if (A[i].type == "armor") {
vector<int> T;
for (int(j) = (0); (j) < (k); ++(j))
if (B[j].type == "sentry") T.push_back(j);
sort((T).begin(), (T).end(), Comp1);
int sum = A[i].def;
for (int(j) = (0); (j) < (min((int)T.size(), A[i].d)); ++(j))
sum += B[T[j]].bonus;
if (sum > maxSum) {
maxSum = sum;
x = i;
Q = T;
}
}
r2 = x;
Q2 = Q;
for (int(i) = (0); (i) < (min((int)Q.size(), A[x].d)); ++(i)) W[Q[i]] = true;
x = -1, maxSum = -1;
for (int(i) = (0); (i) < (n); ++(i))
if (A[i].type == "orb") {
vector<int> T;
for (int(j) = (0); (j) < (k); ++(j))
if (B[j].type == "physician") T.push_back(j);
sort((T).begin(), (T).end(), Comp1);
int sum = A[i].res;
for (int(j) = (0); (j) < (min((int)T.size(), A[i].d)); ++(j))
sum += B[T[j]].bonus;
if (sum > maxSum) {
maxSum = sum;
x = i;
Q = T;
}
}
r3 = x;
Q3 = Q;
for (int(i) = (0); (i) < (min((int)Q.size(), A[x].d)); ++(i)) W[Q[i]] = true;
while (Q1.size() < A[r1].d) {
int t = -1;
for (int(i) = (0); (i) < (k); ++(i))
if (W[i] == false) t = i;
if (t == -1) break;
W[t] = true;
Q1.push_back(t);
}
while (Q2.size() < A[r2].d) {
int t = -1;
for (int(i) = (0); (i) < (k); ++(i))
if (W[i] == false) t = i;
if (t == -1) break;
W[t] = true;
Q2.push_back(t);
}
while (Q3.size() < A[r3].d) {
int t = -1;
for (int(i) = (0); (i) < (k); ++(i))
if (W[i] == false) t = i;
if (t == -1) break;
W[t] = true;
Q3.push_back(t);
}
cout << A[r1].name << ' ' << min(A[r1].d, (int)Q1.size()) << ' ';
for (int(i) = (0); (i) < (min((int)Q1.size(), A[r1].d)); ++(i))
cout << B[Q1[i]].name << ' ';
cout << endl;
cout << A[r2].name << ' ' << min(A[r2].d, (int)Q2.size()) << ' ';
for (int(i) = (0); (i) < (min((int)Q2.size(), A[r2].d)); ++(i))
cout << B[Q2[i]].name << ' ';
cout << endl;
cout << A[r3].name << ' ' << min(A[r3].d, (int)Q3.size()) << ' ';
for (int(i) = (0); (i) < (min((int)Q3.size(), A[r3].d)); ++(i))
cout << B[Q3[i]].name << ' ';
cout << endl;
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> Size, atk, def, res, Left;
map<string, string> Kind;
set<string> used;
map<string, vector<string> > M;
string weapon, armor, orb;
string C[1010], Tp[1010], Home[1010];
int n, m, Bonus[1010], Flag;
void doit(string weapon) {
for (; M[weapon].size() < Size[weapon];) {
Flag = 0;
for (int i = 1; i <= m; i++)
if (!used.count(C[i])) {
Flag = 1;
used.insert(C[i]);
M[weapon].push_back(C[i]);
break;
}
if (!Flag) break;
}
cout << M[weapon].size();
for (int i = 0; i < M[weapon].size(); i++) cout << " " << M[weapon][i];
cout << endl;
}
void check(int Bonus, string Tp, string Home) {
if (Kind[Home] == "weapon" && Tp == "gladiator") atk[Home] += Bonus;
if (Kind[Home] == "armor" && Tp == "sentry") def[Home] += Bonus;
if (Kind[Home] == "orb" && Tp == "physician") res[Home] += Bonus;
}
void Sp() {
for (int i = 1; i <= m; i++) check(Bonus[i], Tp[i], Home[i]);
for (map<string, string>::iterator i = Kind.begin(); i != Kind.end(); i++)
if (i->second == "weapon") {
if (weapon == "" || atk[i->first] > atk[weapon]) weapon = i->first;
} else if (i->second == "armor") {
if (armor == "" || def[i->first] > def[armor]) armor = i->first;
} else if (orb == "" || res[i->first] > res[orb])
orb = i->first;
int tot;
cout << weapon << " ";
tot = 0;
for (int i = 1; i <= m; i++)
if (Home[i] == weapon) tot++;
cout << tot;
for (int i = 1; i <= m; i++)
if (Home[i] == weapon) cout << " " << C[i];
cout << endl;
cout << armor << " ";
tot = 0;
for (int i = 1; i <= m; i++)
if (Home[i] == armor) tot++;
cout << tot;
for (int i = 1; i <= m; i++)
if (Home[i] == armor) cout << " " << C[i];
cout << endl;
cout << orb << " ";
tot = 0;
for (int i = 1; i <= m; i++)
if (Home[i] == orb) tot++;
cout << tot;
for (int i = 1; i <= m; i++)
if (Home[i] == orb) cout << " " << C[i];
cout << endl;
}
void work(string &s, string s1, string s2) {
int Max = 0;
vector<pair<int, string> > v;
v.clear();
for (int i = 1; i <= m; i++)
if (Tp[i] == s2) v.push_back(make_pair(-Bonus[i], C[i]));
sort(v.begin(), v.end());
for (map<string, string>::iterator i = Kind.begin(); i != Kind.end(); i++)
if (i->second == s1) {
int cur;
if (s1 == "weapon") cur = atk[i->first];
if (s1 == "armor") cur = def[i->first];
if (s1 == "orb") cur = res[i->first];
for (int j = 1; j <= min(Size[i->first], (int)v.size()); j++)
cur += (-v[j - 1].first);
if (s == "" || cur > Max) s = i->first, Max = cur;
}
M[s].clear();
for (int j = 1; j <= min(Size[s], (int)v.size()); j++)
M[s].push_back(v[j - 1].second), used.insert(v[j - 1].second);
}
int main() {
cin >> n;
weapon = armor = orb = "";
Size.clear();
atk.clear();
def.clear();
res.clear();
Kind.clear();
Left.clear();
used.clear();
M.clear();
for (int i = 1; i <= n; i++) {
string Name, Type;
int Atk, Def, Res, size;
cin >> Name >> Type >> Atk >> Def >> Res >> size;
atk[Name] = Atk;
def[Name] = Def;
res[Name] = Res;
Size[Name] = size;
Kind[Name] = Type;
Left[Name] = size;
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> C[i] >> Tp[i] >> Bonus[i] >> Home[i];
Left[Home[i]]--;
}
Flag = 0;
for (map<string, int>::iterator i = Left.begin(); i != Left.end(); i++)
if (i->second) Flag = 1;
if (!Flag) {
Sp();
return 0;
}
work(weapon, "weapon", "gladiator");
work(armor, "armor", "sentry");
work(orb, "orb", "physician");
cout << weapon << " ";
doit(weapon);
cout << armor << " ";
doit(armor);
cout << orb << " ";
doit(orb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct T {
string name;
int type;
int par;
int size;
vector<string> v;
void read() {
string sType;
int x, y, z;
cin >> name >> sType >> x >> y >> z >> size;
if (sType == "weapon") {
type = 0;
par = x;
}
if (sType == "armor") {
type = 1;
par = y;
}
if (sType == "orb") {
type = 2;
par = z;
}
}
};
T pr[1000];
map<string, int> getInd;
vector<pair<int, string> > res[3];
map<string, pair<int, int> > resInd;
int sum[3][1100];
int n, m;
int best[3] = {-1, -1, -1};
int best_par[3];
int pos[1100];
void output() {
int ind[3] = {-1, -1, -1};
for (int i = 0; i < n; i++) {
for (int j = 0; j < pr[i].v.size(); j++)
if (pr[i].type == resInd[pr[i].v[j]].first)
pr[i].par += res[pr[i].type][resInd[pr[i].v[j]].second].first;
}
for (int i = 0; i < n; i++) {
if (ind[pr[i].type] == -1 || pr[ind[pr[i].type]].par < pr[i].par)
ind[pr[i].type] = i;
}
for (int i = 0; i < 3; i++) {
int t = ind[i];
cout << pr[t].name << " " << pr[t].v.size();
for (int j = 0; j < pr[t].v.size(); j++) cout << " " << pr[t].v[j];
cout << endl;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
pr[i].read();
getInd[pr[i].name] = i;
}
cin >> m;
for (int i = 0; i < m; i++) {
string name, type, home;
int par;
cin >> name >> type >> par >> home;
int ind = 0;
if (type == "gladiator") ind = 0;
if (type == "sentry") ind = 1;
if (type == "physician") ind = 2;
res[ind].push_back(make_pair(par, name));
pr[getInd[home]].v.push_back(name);
resInd[name] = make_pair(ind, res[ind].size() - 1);
}
int count = 0;
for (int i = 0; i < n; i++) {
count += pr[i].size;
}
if (count == m) {
output();
return 0;
}
for (int i = 0; i < 3; i++) {
sort(res[i].begin(), res[i].end());
reverse(res[i].begin(), res[i].end());
}
for (int i = 0; i < 3; i++) {
sum[i][0] = 0;
for (int j = 0; j < res[i].size(); j++)
sum[i][j + 1] = res[i][j].first + sum[i][j];
}
for (int i = 0; i < n; i++) {
int count = res[pr[i].type].size();
if (count > pr[i].size) count = pr[i].size;
int S = sum[pr[i].type][count] + pr[i].par;
if (best[pr[i].type] == -1 || best_par[pr[i].type] < S) {
best_par[pr[i].type] = S;
best[pr[i].type] = i;
}
}
for (int i = 0; i < 3; i++) {
int ind = best[i];
pr[ind].v.clear();
int count = res[i].size();
if (count > pr[ind].size) count = pr[ind].size;
for (int j = 0; j < count; j++) {
pr[ind].v.push_back(res[i][j].second);
}
pos[i] = count;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
while (pr[i].v.size() < pr[i].size && pos[j] < res[j].size()) {
pr[i].v.push_back(res[j][pos[j]].second);
pos[j]++;
}
}
}
for (int i = 0; i < 3; i++) {
int ind = best[i];
cout << pr[ind].name << " " << pr[ind].v.size();
for (int j = 0; j < pr[ind].v.size(); j++) cout << " " << pr[ind].v[j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
A cvt(B x) {
stringstream ss;
ss << x;
A y;
ss >> y;
return y;
}
typedef struct {
string name;
int c;
int p[3];
int size;
int room;
} item;
typedef struct {
string name;
int c;
int bonus;
string home;
} resident;
int n, k;
map<string, item> items;
map<string, vector<string> > itres;
map<string, resident> residents;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string name, c;
int a, d, r, s;
cin >> name >> c >> a >> d >> r >> s;
if (c == "weapon") items[name] = (item){name, 0, {a, d, r}, s, s};
if (c == "armor") items[name] = (item){name, 1, {a, d, r}, s, s};
if (c == "orb") items[name] = (item){name, 2, {a, d, r}, s, s};
}
cin >> k;
for (int i = 0; i < k; i++) {
string name, c, home;
int b;
cin >> name >> c >> b >> home;
if (c == "gladiator") residents[name] = (resident){name, 0, b, home};
if (c == "sentry") residents[name] = (resident){name, 1, b, home};
if (c == "physician") residents[name] = (resident){name, 2, b, home};
items[home].room--;
itres[home].push_back(name);
}
int move = 0;
for (typeof(items.begin()) it = items.begin(); it != items.end(); it++)
if (it->second.room > 0) move = 1;
if (!move) {
vector<pair<int, pair<int, string> > > v;
for (typeof(items.begin()) it = items.begin(); it != items.end(); it++) {
string name = it->first;
int cl = it->second.c;
int val = it->second.p[cl];
for (typeof(itres[name].begin()) itr = itres[name].begin();
itr != itres[name].end(); itr++) {
if (residents[*itr].c == cl) val += residents[*itr].bonus;
}
v.push_back(make_pair(cl, make_pair(-val, name)));
}
sort(v.begin(), v.end());
int i = 0;
for (int t = 0; t < 3; t++) {
while (v[i].first != t) i++;
string name = v[i].second.second;
cout << name << " " << itres[name].size();
for (typeof(itres[name].begin()) itr = itres[name].begin();
itr != itres[name].end(); itr++)
cout << " " << *itr;
cout << endl;
}
} else {
vector<pair<int, string> > r[3];
for (typeof(residents.begin()) itr = residents.begin();
itr != residents.end(); itr++) {
r[itr->second.c].push_back(make_pair(itr->second.bonus, itr->first));
}
int sum[3][1005];
for (int t = 0; t < 3; t++) {
sort(r[t].begin(), r[t].end());
reverse(r[t].begin(), r[t].end());
sum[t][0] = 0;
for (int i = 1; i <= r[t].size(); i++) {
sum[t][i] = sum[t][i - 1] + r[t][i - 1].first;
}
}
pair<int, pair<int, int> > best = make_pair(-1, make_pair(-1, -1));
pair<string, vector<string> > out[3];
set<string> used;
for (typeof(items.begin()) it0 = items.begin(); it0 != items.end(); it0++)
if (it0->second.c == 0)
for (typeof(items.begin()) it1 = items.begin(); it1 != items.end();
it1++)
if (it1->second.c == 1)
for (typeof(items.begin()) it2 = items.begin(); it2 != items.end();
it2++)
if (it2->second.c == 2) {
int sz0 = min(it0->second.size, (int)r[0].size());
int sz1 = min(it1->second.size, (int)r[1].size());
int sz2 = min(it2->second.size, (int)r[2].size());
pair<int, pair<int, int> > rez =
make_pair(it0->second.p[0] + sum[0][sz0],
make_pair(it1->second.p[1] + sum[1][sz1],
it2->second.p[2] + sum[2][sz2]));
if (rez > best) {
best = rez;
used.clear();
vector<string> x0, x1, x2;
for (int i = 0; i < sz0; i++) {
x0.push_back(r[0][i].second);
used.insert(r[0][i].second);
}
for (int i = 0; i < sz1; i++) {
x1.push_back(r[1][i].second);
used.insert(r[1][i].second);
}
for (int i = 0; i < sz2; i++) {
x2.push_back(r[2][i].second);
used.insert(r[2][i].second);
}
out[0] = make_pair(it0->first, x0);
out[1] = make_pair(it1->first, x1);
out[2] = make_pair(it2->first, x2);
}
}
for (int t = 0; t < 3; t++) {
for (typeof(residents.begin()) itr = residents.begin();
itr != residents.end(); itr++) {
if (out[t].second.size() == items[out[t].first].size) break;
if (used.count(itr->first) == 0) {
out[t].second.push_back(itr->first);
used.insert(itr->first);
}
}
cout << out[t].first << " " << out[t].second.size();
for (int i = 0; i < out[t].second.size(); i++)
cout << " " << out[t].second[i];
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1050;
struct resid {
resid() {}
char type;
string name;
int bonus;
friend bool operator<(resid a, resid b) {
if (a.type != b.type) return a.type < b.type;
return a.bonus > b.bonus;
}
resid(char _type, int _bonus) {
type = _type;
bonus = _bonus;
}
} R[N];
struct thing {
int v;
int s;
string name;
char type;
int _g;
int get() {
if (_g == -1) {
_g = 0;
for (int i = 0; i < C.size(); i++)
_g += R[C[i]].bonus * (R[C[i]].type == type);
}
return _g;
}
vector<int> C;
thing(char _type, int _v) : type(_type), v(_v) { _g = -1; }
friend bool operator<(thing a, thing b) {
if (a.type != b.type) return a.type < b.type;
return a.v + a.get() > b.v + b.get();
}
thing() { _g = -1; }
} T[N];
map<string, int> things;
map<string, int> resids;
int n;
void print(thing t) {
cout << t.name;
cout << ' ';
cout << t.C.size() << ' ';
for (int i = 0; i < t.C.size(); i++) cout << R[t.C[i]].name << ' ';
cout << endl;
}
void stup() {
sort(T, T + n);
thing *a = lower_bound(T, T + n, thing('a', 1e9));
thing *d = lower_bound(T, T + n, thing('d', 1e9));
thing *r = lower_bound(T, T + n, thing('r', 1e9));
print(*a);
print(*d);
print(*r);
}
int k;
vector<int> VA;
vector<int> VR;
vector<int> VS;
bool was[N];
void clever() {
sort(R, R + k);
resid *a = lower_bound(R, R + k, resid('a', 1e9));
resid *d = lower_bound(R, R + k, resid('d', 1e9));
resid *r = lower_bound(R, R + k, resid('r', 1e9));
resid *an = d;
resid *dn = r;
resid *rn = R + k;
for (int i = 0; i < n; i++) {
T[i].C.resize(0);
if (T[i].type == 'a')
for (int j = 0; j < T[i].s && (a + j) != an; j++)
T[i].C.push_back((a + j) - R);
if (T[i].type == 'd')
for (int j = 0; j < T[i].s && (d + j) != dn; j++)
T[i].C.push_back((d + j) - R);
if (T[i].type == 'r')
for (int j = 0; j < T[i].s && (r + j) != rn; j++)
T[i].C.push_back((r + j) - R);
}
sort(T, T + n);
thing *aa = lower_bound(T, T + n, thing('a', 1e9));
thing *dd = lower_bound(T, T + n, thing('d', 1e9));
thing *rr = lower_bound(T, T + n, thing('r', 1e9));
for (int i = 0; i < aa->C.size(); i++) was[aa->C[i]] = 1;
for (int i = 0; i < dd->C.size(); i++) was[dd->C[i]] = 1;
for (int i = 0; i < rr->C.size(); i++) was[rr->C[i]] = 1;
for (int i = 0; i < k; i++) {
if (!was[i]) {
if (aa->C.size() != aa->s)
aa->C.push_back(i);
else if (dd->C.size() != dd->s)
dd->C.push_back(i);
else if (rr->C.size() != rr->s)
rr->C.push_back(i);
}
}
print(*aa);
print(*dd);
print(*rr);
}
int main() {
cin >> n;
string name, clas;
int a, d, r, s;
for (int i = 0; i < n; i++) {
cin >> name >> clas >> a >> d >> r >> s;
T[i].name = name;
switch (clas[0]) {
case 'w':
clas[0] = 'a';
T[i].v = a;
break;
case 'a':
clas[0] = 'd';
T[i].v = d;
break;
case 'o':
clas[0] = 'r';
T[i].v = r;
break;
}
T[i].type = clas[0];
T[i].s = s;
things[name] = i;
}
cin >> k;
int bonus;
int th;
string in;
for (int i = 0; i < k; i++) {
cin >> name >> clas;
cin >> bonus >> in;
th = things[in];
T[th].C.push_back(i);
R[i].bonus = bonus;
R[i].name = name;
switch (clas[0]) {
case 'g':
clas[0] = 'a';
break;
case 's':
clas[0] = 'd';
break;
case 'p':
clas[0] = 'r';
break;
}
R[i].type = clas[0];
}
bool good = false;
for (int i = 0; i < n; i++) good |= T[i].C.size() != T[i].s;
if (!good) {
stup();
} else {
clever();
}
}
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-8;
struct equip {
string name;
int param;
int size;
};
int main() {
istream &fin = cin;
ostream &fout = cout;
FILE *fpin = stdin;
FILE *fpout = stdout;
int n;
fin >> n;
vector<equip> wea, arm, orb;
int totsz = 0;
for (int i = 0; i < n; i++) {
string name, clas;
int atk, def, res, sz;
fin >> name >> clas >> atk >> def >> res >> sz;
equip e;
e.name = name;
e.size = sz;
if (clas[0] == 'w') {
e.param = atk;
wea.push_back(e);
} else if (clas[0] == 'a') {
e.param = def;
arm.push_back(e);
} else {
e.param = res;
orb.push_back(e);
}
totsz += sz;
}
int k;
fin >> k;
if (k == totsz) {
vector<vector<string> > wear(wea.size()), armr(arm.size()),
orbr(orb.size());
for (int i = 0; i < k; i++) {
string name, typ, home;
int bonus;
fin >> name >> typ >> bonus >> home;
for (int j = 0; j < (int)wea.size(); j++) {
if (wea[j].name == home) {
if (typ[0] == 'g') wea[j].param += bonus;
wear[j].push_back(name);
}
}
for (int j = 0; j < (int)arm.size(); j++) {
if (arm[j].name == home) {
if (typ[0] == 's') arm[j].param += bonus;
armr[j].push_back(name);
}
}
for (int j = 0; j < (int)orb.size(); j++) {
if (orb[j].name == home) {
if (typ[0] == 'p') orb[j].param += bonus;
orbr[j].push_back(name);
}
}
}
int maxi = 0, maxparam = 0;
for (int i = 0; i < (int)wea.size(); i++) {
if (wea[i].param > maxparam) {
maxi = i;
maxparam = wea[i].param;
}
}
fout << wea[maxi].name << " " << wear[maxi].size();
for (int i = 0; i < (int)wear[maxi].size(); i++)
fout << " " << wear[maxi][i];
fout << endl;
maxi = 0;
maxparam = 0;
for (int i = 0; i < (int)arm.size(); i++) {
if (arm[i].param > maxparam) {
maxi = i;
maxparam = arm[i].param;
}
}
fout << arm[maxi].name << " " << armr[maxi].size();
for (int i = 0; i < (int)armr[maxi].size(); i++)
fout << " " << armr[maxi][i];
fout << endl;
maxi = 0;
maxparam = 0;
for (int i = 0; i < (int)orb.size(); i++) {
if (orb[i].param > maxparam) {
maxi = i;
maxparam = orb[i].param;
}
}
fout << orb[maxi].name << " " << orbr[maxi].size();
for (int i = 0; i < (int)orbr[maxi].size(); i++)
fout << " " << orbr[maxi][i];
fout << endl;
} else {
vector<pair<int, string> > wear, armr, orbr;
for (int i = 0; i < k; i++) {
string name, typ, home;
int bonus;
fin >> name >> typ >> bonus >> home;
if (typ[0] == 'g') {
wear.push_back(make_pair(bonus, name));
} else if (typ[0] == 's') {
armr.push_back(make_pair(bonus, name));
} else {
orbr.push_back(make_pair(bonus, name));
}
}
sort(wear.begin(), wear.end(), greater<pair<int, string> >());
sort(armr.begin(), armr.end(), greater<pair<int, string> >());
sort(orbr.begin(), orbr.end(), greater<pair<int, string> >());
int maxiw = 0, maxparam = 0;
for (int i = 0; i < (int)wea.size(); i++) {
int bonus = 0;
for (int j = 0; j < min((int)wea[i].size, (int)wear.size()); j++) {
bonus += wear[j].first;
}
if (wea[i].param + bonus > maxparam) {
maxiw = i;
maxparam = wea[i].param + bonus;
}
}
int maxia = 0;
maxparam = 0;
for (int i = 0; i < (int)arm.size(); i++) {
int bonus = 0;
for (int j = 0; j < min((int)arm[i].size, (int)armr.size()); j++) {
bonus += armr[j].first;
}
if (arm[i].param + bonus > maxparam) {
maxia = i;
maxparam = arm[i].param + bonus;
}
}
int maxio = 0;
maxparam = 0;
for (int i = 0; i < (int)orb.size(); i++) {
int bonus = 0;
for (int j = 0; j < min((int)orb[i].size, (int)orbr.size()); j++) {
bonus += orbr[j].first;
}
if (orb[i].param + bonus > maxparam) {
maxio = i;
maxparam = orb[i].param + bonus;
}
}
vector<string> rem;
for (int i = wea[maxiw].size; i < (int)wear.size(); i++)
rem.push_back(wear[i].second);
for (int i = arm[maxia].size; i < (int)armr.size(); i++)
rem.push_back(armr[i].second);
for (int i = orb[maxio].size; i < (int)orbr.size(); i++)
rem.push_back(orbr[i].second);
int plusw = 0, plusa = 0, pluso = 0;
int remi = 0;
for (int i = wear.size();
i < (int)wea[maxiw].size && remi < (int)rem.size(); i++, remi++)
plusw++;
for (int i = armr.size();
i < (int)arm[maxia].size && remi < (int)rem.size(); i++, remi++)
plusa++;
for (int i = orbr.size();
i < (int)orb[maxio].size && remi < (int)rem.size(); i++, remi++)
pluso++;
remi = 0;
fout << wea[maxiw].name << " "
<< min((int)wea[maxiw].size, (int)wear.size()) + plusw;
for (int i = 0; i < min((int)wea[maxiw].size, (int)wear.size()); i++)
fout << " " << wear[i].second;
for (int i = wear.size();
i < (int)wea[maxiw].size && remi < (int)rem.size(); i++, remi++)
fout << " " << rem[remi];
fout << endl;
fout << arm[maxia].name << " "
<< min((int)arm[maxia].size, (int)armr.size()) + plusa;
for (int i = 0; i < min((int)arm[maxia].size, (int)armr.size()); i++)
fout << " " << armr[i].second;
for (int i = armr.size();
i < (int)arm[maxia].size && remi < (int)rem.size(); i++, remi++)
fout << " " << rem[remi];
fout << endl;
fout << orb[maxio].name << " "
<< min((int)orb[maxio].size, (int)orbr.size()) + pluso;
for (int i = 0; i < min((int)orb[maxio].size, (int)orbr.size()); i++)
fout << " " << orbr[i].second;
for (int i = orbr.size();
i < (int)orb[maxio].size && remi < (int)rem.size(); i++, remi++)
fout << " " << rem[remi];
fout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, string> > items[3];
vector<pair<int, string> > resid[3];
int bestid[3];
int best[3] = {0, 0, 0};
int rus[3] = {0, 0, 0};
int rus2[3] = {0, 0, 0};
int main() {
int in;
cin >> in;
int totalsize = 0;
for (int i = 0; i < in; i++) {
string name, type;
int siz;
int par[3];
cin >> name >> type >> par[0] >> par[1] >> par[2] >> siz;
int t2 = 0;
if (type[0] == 'a')
t2 = 1;
else if (type[0] == 'o')
t2 = 2;
items[t2].push_back(
pair<pair<int, int>, string>(pair<int, int>(par[t2], siz), name));
totalsize += siz;
}
int k;
cin >> k;
if (k < totalsize) {
for (int i = 0; i < k; i++) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
int t2 = 0;
if (type[0] == 's')
t2 = 1;
else if (type[0] == 'p')
t2 = 2;
resid[t2].push_back(pair<int, string>(bonus, name));
}
sort(resid[0].begin(), resid[0].end());
sort(resid[1].begin(), resid[1].end());
sort(resid[2].begin(), resid[2].end());
for (int j = 0; j < 3; j++) {
for (int i = resid[j].size() - 2; i > -1; i--) {
resid[j][i].first += resid[j][i + 1].first;
}
}
for (int j = 0; j < 3; j++) {
for (int i = 0; i < items[j].size(); i++) {
int t = items[j][i].first.first;
int tu = 0;
if (items[j][i].first.second > resid[j].size()) {
tu = resid[j].size();
} else {
tu = items[j][i].first.second;
}
if (tu) t += resid[j][resid[j].size() - tu].first;
if (t > best[j]) {
best[j] = t;
bestid[j] = i;
rus[j] = tu;
rus2[j] = tu;
}
}
}
int rl = resid[0].size() + resid[1].size() + resid[2].size() - rus[0] -
rus[1] - rus[2];
for (int j = 0; j < 3; j++) {
int t = rus[j];
int cid = bestid[j];
cout << items[j][cid].second;
if (rl >= items[j][cid].first.second - t)
t = items[j][cid].first.second;
else
t += rl;
rl -= t - rus[j];
cout << " " << t;
for (int i = 0; i < rus[j]; i++) {
cout << " " << resid[j][resid[j].size() - 1 - i].second;
}
t -= rus[j];
while (t) {
if (rus2[0] < resid[0].size()) {
rus2[0]++;
cout << " " << resid[0][resid[0].size() - rus2[0]].second;
} else if (rus2[1] < resid[1].size()) {
rus2[1]++;
cout << " " << resid[1][resid[1].size() - rus2[1]].second;
} else if (rus2[2] < resid[2].size()) {
rus2[2]++;
cout << " " << resid[2][resid[2].size() - rus2[2]].second;
}
t--;
}
cout << endl;
}
} else {
vector<string> resname;
vector<string> reshome;
for (int i = 0; i < 3; i++)
for (int j = 0; j < items[i].size(); j++) items[i][j].first.second = 0;
for (int i = 0; i < k; i++) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
int t2 = 0;
if (type[0] == 's')
t2 = 1;
else if (type[0] == 'p')
t2 = 2;
for (int j = 0; j < 3; j++) {
for (int i = 0; i < items[j].size(); i++) {
if (items[j][i].second == home) {
if (j == t2) items[j][i].first.first += bonus;
items[j][i].first.second++;
}
}
}
resname.push_back(name);
reshome.push_back(home);
}
sort(items[0].begin(), items[0].end());
sort(items[1].begin(), items[1].end());
sort(items[2].begin(), items[2].end());
pair<pair<int, int>, string> bs[3];
for (int i = 0; i < 3; i++) bs[i] = items[i][items[i].size() - 1];
for (int i = 0; i < 3; i++) {
cout << bs[i].second << " " << bs[i].first.second;
for (int j = 0; j < reshome.size(); j++) {
if (reshome[j] == bs[i].second) cout << " " << resname[j];
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a[150];
map<string, int> K;
vector<string> res[150];
int t[150], p[150];
int S, s[150];
pair<int, string> b[3][1005];
int Nt[3];
int best[3];
string bestn[3];
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> a[i];
string type;
cin >> type;
if (type == "weapon")
t[i] = 0;
else if (type == "orb")
t[i] = 2;
else
t[i] = 1;
int A[3];
cin >> A[0] >> A[1] >> A[2] >> s[i];
p[i] = A[t[i]];
S += s[i];
K[a[i]] = i;
}
int M;
cin >> M;
for (int i = 0; i < M; ++i) {
string name, type, weapon;
int power;
cin >> name >> type >> power >> weapon;
int number = 0;
if (type == "sentry")
number = 1;
else if (type == "physician")
number = 2;
if (M == S) {
if (t[K[weapon]] == number) p[K[weapon]] += power;
res[K[weapon]].push_back(name);
}
b[number][++Nt[number]] = make_pair(power, name);
}
for (int i = 0; i < 3; ++i) sort(b[i] + 1, b[i] + Nt[i] + 1);
best[0] = best[1] = best[2] = -1;
if (M == S) {
for (int i = 0; i < N; ++i)
if (best[t[i]] < p[i]) best[t[i]] = p[i], bestn[t[i]] = a[i];
for (int i = 0; i < 3; ++i) {
cout << bestn[i] << " ";
cout << res[K[bestn[i]]].size() << " ";
for (vector<string>::iterator it = res[K[bestn[i]]].begin();
it != res[K[bestn[i]]].end(); ++it)
cout << *it << " ";
cout << "\n";
}
return 0;
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < N; ++j)
if (t[j] == i) {
int temp = p[j];
for (int k = Nt[i]; k > 0 && k > Nt[i] - s[j]; --k)
temp += b[i][k].first;
if (temp > best[i]) best[i] = temp, bestn[i] = a[j];
}
int who = K[bestn[i]];
while (Nt[i] > 0 && s[who] > 0)
res[who].push_back(b[i][Nt[i]--].second), --s[who];
}
for (int i = 0; i < 3; ++i) {
int who = K[bestn[i]];
while (s[who] > 0) {
if (Nt[0] == 0 && Nt[1] == 0 && Nt[2] == 0) break;
for (int j = 0; j < 3; ++j)
if (Nt[j] > 0) {
res[who].push_back(b[j][Nt[j]--].second);
break;
}
--s[who];
}
}
for (int i = 0; i < 3; ++i) {
cout << bestn[i] << " ";
cout << res[K[bestn[i]]].size() << " ";
for (vector<string>::iterator it = res[K[bestn[i]]].begin();
it != res[K[bestn[i]]].end(); ++it)
cout << *it << " ";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 25;
const double eps = 1e-9;
struct Resident {
string name, type;
int bonus;
Resident(string name, string type, int bonus)
: name(name), type(type), bonus(bonus) {}
bool operator<(const Resident& other) const { return bonus < other.bonus; }
};
struct Equip {
string name, type;
int stat, size;
int addStat;
vector<Resident> residents;
void AddResident(const Resident& res) {
if (residents.size() >= size) throw 0;
residents.push_back(res);
addStat += (res.type == type) * res.bonus;
}
bool IsFull() const { return size == residents.size(); }
void ClearResidents() {
residents.clear();
addStat = 0;
}
void Pick(const vector<Resident>& residents) {
for (int i = 0; i < residents.size() && i < size; ++i)
AddResident(residents[i]);
}
string toString() const {
stringstream res;
res << name << " " << residents.size();
for (int i = (0); i < ((int)residents.size()); ++i)
res << " " << residents[i].name;
return res.str();
}
Equip() {
stat = -inf;
addStat = 0;
}
Equip(string name, string type, int stat, int size)
: name(name), type(type), stat(stat), size(size), addStat(0) {}
int cntStat() const { return stat + addStat; }
bool operator<(const Equip& other) const {
return cntStat() < other.cntStat();
}
bool Contains(const Resident& res) const {
for (int i = (0); i < ((int)residents.size()); ++i)
if (residents[i].name == res.name) return true;
return false;
}
};
const int WEAPON = 0, SHIELD = 1, ORB = 2;
int StoType(const string& s) {
switch (s[0]) {
case 'w':
return WEAPON;
case 'a':
return SHIELD;
default:
return ORB;
}
}
string eqTypes[] = {"weapon", "armor", "orb"};
string convertResToEqType(string type) {
switch (type[0]) {
case 'g':
return eqTypes[WEAPON];
case 's':
return eqTypes[SHIELD];
default:
return eqTypes[ORB];
}
}
int main() {
int n, k;
cin >> n;
vector<Equip> equip[3];
map<string, pair<int, int> > equipMap;
for (int i = (0); i < (n); ++i) {
string name, cls;
int size;
int stats[3];
cin >> name >> cls >> stats[0] >> stats[1] >> stats[2] >> size;
equip[StoType(cls)].push_back(Equip(name, cls, stats[StoType(cls)], size));
equipMap[name] =
pair<int, int>(StoType(cls), equip[StoType(cls)].size() - 1);
}
cin >> k;
vector<Resident> residents[3];
vector<Resident> allRes;
for (int i = (0); i < (k); ++i) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
type = convertResToEqType(type);
Resident curRes(name, type, bonus);
equip[equipMap[home].first][equipMap[home].second].AddResident(curRes);
allRes.push_back(curRes);
residents[StoType(type)].push_back(Resident(name, type, bonus));
}
Equip optimal[3];
bool hasNotFull = false;
for (int i = (0); i < (3); ++i)
for (int j = (0); j < ((int)equip[i].size()); ++j)
hasNotFull = hasNotFull || !equip[i][j].IsFull(),
optimal[i] = max(optimal[i], equip[i][j]);
if (hasNotFull) {
for (int i = (0); i < (3); ++i) {
optimal[i].ClearResidents();
sort(residents[i].begin(), residents[i].end());
reverse(residents[i].begin(), residents[i].end());
for (int j = (0); j < ((int)equip[i].size()); ++j) {
Equip cur = equip[i][j];
cur.ClearResidents();
cur.Pick(residents[i]);
optimal[i] = max(optimal[i], cur);
}
}
}
vector<bool> equippedResidents(allRes.size(), false);
for (int i = (0); i < ((int)equippedResidents.size()); ++i)
for (int j = (0); j < (3); ++j)
if (optimal[j].Contains(allRes[i])) equippedResidents[i] = true;
for (int i = (0); i < ((int)equippedResidents.size()); ++i)
if (!equippedResidents[i])
for (int j = (0); j < (3); ++j)
if (!optimal[j].IsFull()) {
optimal[j].AddResident(allRes[i]);
break;
}
for (int i = (0); i < (3); ++i) cout << optimal[i].toString() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item_t {
int category;
int skills[3];
int size;
};
struct res_t {
int type, bonus;
string home;
};
map<string, item_t> item_map;
map<string, res_t> res_map;
void solve() {
map<string, int> class_map, skill_map, type_map;
class_map["weapon"] = 0;
skill_map["atk"] = 0;
type_map["gladiator"] = 0;
class_map["armor"] = 1;
skill_map["def"] = 1;
type_map["sentry"] = 1;
class_map["orb"] = 2;
skill_map["res"] = 2;
type_map["physician"] = 2;
int n;
cin >> n;
item_map.clear();
res_map.clear();
map<string, int> cnt;
for (int i = 0; i < n; ++i) {
string name, category;
int skills[3], size;
cin >> name >> category >> skills[0] >> skills[1] >> skills[2] >> size;
item_t item;
item.category = class_map[category];
for (int k = 0; k < 3; ++k) item.skills[k] = skills[k];
item.size = size;
item_map[name] = item;
cnt[name] = 0;
}
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
res_t res;
res.type = type_map[type];
res.bonus = bonus;
res.home = home;
res_map[name] = res;
}
bool istight = true;
for (map<string, res_t>::const_iterator cit = res_map.begin();
cit != res_map.end(); ++cit) {
string home = cit->second.home;
cnt[home]++;
}
for (map<string, int>::const_iterator cit = cnt.begin(); cit != cnt.end();
++cit) {
if (item_map[cit->first].size > cit->second) {
istight = false;
break;
}
}
if (istight) {
string id[3];
int score[3] = {0};
for (map<string, item_t>::const_iterator cit = item_map.begin();
cit != item_map.end(); ++cit) {
string home = cit->first;
int category = cit->second.category;
int curr = cit->second.skills[category];
for (map<string, res_t>::const_iterator it2 = res_map.begin();
it2 != res_map.end(); ++it2) {
if (it2->second.home == home) {
int type = it2->second.type;
int bonus = it2->second.bonus;
if (category == type) curr += bonus;
}
}
if (curr > score[category]) {
id[category] = home;
score[category] = curr;
}
}
for (int i = 0; i < 3; ++i) {
string home = id[i];
cout << home << ' ' << item_map[home].size;
for (map<string, res_t>::const_iterator it = res_map.begin();
it != res_map.end(); ++it) {
if (it->second.home == home) cout << ' ' << it->first;
}
cout << endl;
}
} else {
vector<pair<int, string> > vec[3];
for (map<string, res_t>::const_iterator it = res_map.begin();
it != res_map.end(); ++it) {
string name = it->first;
int type = it->second.type;
int bonus = it->second.bonus;
vec[type].push_back(pair<int, string>(bonus, name));
}
for (int i = 0; i < 3; ++i) sort(vec[i].begin(), vec[i].end());
map<string, bool> used;
for (map<string, res_t>::const_iterator it = res_map.begin();
it != res_map.end(); ++it) {
used[it->first] = false;
}
string id[3];
int score[3] = {0};
for (map<string, item_t>::const_iterator it = item_map.begin();
it != item_map.end(); ++it) {
string home = it->first;
int category = it->second.category;
int size = it->second.size;
int curr = it->second.skills[category];
for (int k = vec[category].size() - 1, s = size; k >= 0 && s > 0;
--k, --s) {
curr += vec[category][k].first;
}
if (curr >= score[category]) {
id[category] = home;
score[category] = curr;
}
}
vector<string> ans[3];
for (int i = 0; i < 3; ++i) {
for (int k = vec[i].size() - 1, s = item_map[id[i]].size; k >= 0 && s > 0;
--k, --s) {
string name = vec[i][k].second;
ans[i].push_back(name);
used[name] = true;
}
}
for (int i = 0; i < 3; ++i) {
for (int k = int(ans[i].size()); k < item_map[id[i]].size; ++k)
for (map<string, bool>::iterator it = used.begin(); it != used.end();
++it) {
if (!it->second) {
ans[i].push_back(it->first);
it->second = true;
break;
}
}
}
for (int i = 0; i < 3; ++i) {
cout << id[i] << ' ' << ans[i].size();
for (size_t k = 0; k < ans[i].size(); ++k) cout << ' ' << ans[i][k];
cout << endl;
}
}
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int Wa[111], Wd[111], Wr[111], Ws[111], Aa[111], Ad[111], Ar[111], As[111],
Oa[111], Od[111], Or[111], Os[111], a, d, r, si;
int N, M, SI, W, A, O, bestW, bestA, bestO;
string Wn[111], An[111], On[111], n, t, h;
typedef struct resident {
string name, type, home;
int bonus;
bool used;
} R;
R res[1111], g[1111], s[1111], p[1111];
int G, S, P;
vector<string> tmp;
vector<string> Gn, Sn, Pn;
bool mycompare(R x, R y) { return x.bonus > y.bonus; }
int main(int argc, char *argv[]) {
int i, j;
SI = 0;
W = 0;
A = 0;
O = 0;
G = 0;
S = 0;
P = 0;
scanf("%d", &N);
for (i = 0; i < N; i++) {
cin >> n >> t >> a >> d >> r >> si;
SI += si;
if (t[0] == 'w') {
Wa[W] = a;
Wd[W] = d;
Wr[W] = r;
Ws[W] = si;
Wn[W++] = n;
}
if (t[0] == 'a') {
Aa[A] = a;
Ad[A] = d;
Ar[A] = r;
As[A] = si;
An[A++] = n;
}
if (t[0] == 'o') {
Oa[O] = a;
Od[O] = d;
Or[O] = r;
Os[O] = si;
On[O++] = n;
}
}
scanf("%d", &M);
for (i = 0; i < M; i++) {
cin >> n >> t >> a >> h;
res[i].name = n;
res[i].type = t;
res[i].home = h;
res[i].bonus = a;
if (t[0] == 'g') {
g[G].name = n;
g[G].type = t;
g[G].home = h;
g[G++].bonus = a;
}
if (t[0] == 's') {
s[S].name = n;
s[S].type = t;
s[S].home = h;
s[S++].bonus = a;
}
if (t[0] == 'p') {
p[P].name = n;
p[P].type = t;
p[P].home = h;
p[P++].bonus = a;
}
}
sort(g, g + G, mycompare);
sort(s, s + S, mycompare);
sort(p, p + P, mycompare);
int best = 0, sum;
if (SI == M) {
bestW = 0;
best = 0;
for (i = 0; i < W; i++) {
sum = Wa[i];
for (j = 0; j < M; j++)
if (Wn[i] == res[j].home && res[j].type[0] == 'g') sum += res[j].bonus;
if (sum > best) {
best = sum;
bestW = i;
}
}
for (j = 0; j < M; j++)
if (Wn[bestW] == res[j].home) tmp.push_back(res[j].name);
cout << Wn[bestW] << " " << tmp.size();
for (i = 0; i < tmp.size(); i++) cout << " " << tmp[i];
printf("\n");
bestA = 0;
best = 0;
for (i = 0; i < A; i++) {
sum = Ad[i];
for (j = 0; j < M; j++)
if (An[i] == res[j].home && res[j].type[0] == 's') sum += res[j].bonus;
if (sum > best) {
best = sum;
bestA = i;
}
}
tmp.clear();
for (j = 0; j < M; j++)
if (An[bestA] == res[j].home) tmp.push_back(res[j].name);
cout << An[bestA] << " " << tmp.size();
for (i = 0; i < tmp.size(); i++) cout << " " << tmp[i];
printf("\n");
bestO = 0;
best = 0;
for (i = 0; i < O; i++) {
sum = Or[i];
for (j = 0; j < M; j++)
if (On[i] == res[j].home && res[j].type[0] == 'p') sum += res[j].bonus;
if (sum > best) {
best = sum;
bestO = i;
}
}
tmp.clear();
for (j = 0; j < M; j++)
if (On[bestO] == res[j].home) tmp.push_back(res[j].name);
cout << On[bestO] << " " << tmp.size();
for (i = 0; i < tmp.size(); i++) cout << " " << tmp[i];
printf("\n");
return 0;
}
bestW = 0;
best = 0;
for (i = 0; i < W; i++) {
sum = Wa[i];
for (j = 0; j < min(G, Ws[i]); j++) sum += g[j].bonus;
if (sum > best) {
best = sum;
bestW = i;
Gn.clear();
for (j = 0; j < min(G, Ws[i]); j++) Gn.push_back(g[j].name);
}
}
bestA = 0;
best = 0;
for (i = 0; i < A; i++) {
sum = Ad[i];
for (j = 0; j < min(S, As[i]); j++) sum += s[j].bonus;
if (sum > best) {
best = sum;
bestA = i;
Sn.clear();
for (j = 0; j < min(S, As[i]); j++) Sn.push_back(s[j].name);
}
}
bestO = 0;
best = 0;
for (i = 0; i < O; i++) {
sum = Or[i];
for (j = 0; j < min(P, Os[i]); j++) sum += p[j].bonus;
if (sum > best) {
best = sum;
bestO = i;
Pn.clear();
for (j = 0; j < min(P, Os[i]); j++) Pn.push_back(p[j].name);
}
}
for (i = 0; i < Gn.size(); i++)
for (j = 0; j < M; j++)
if (res[j].name == Gn[i]) res[j].used = true;
for (i = 0; i < Sn.size(); i++)
for (j = 0; j < M; j++)
if (res[j].name == Sn[i]) res[j].used = true;
for (i = 0; i < Pn.size(); i++)
for (j = 0; j < M; j++)
if (res[j].name == Pn[i]) res[j].used = true;
for (i = 0; i < M; i++)
if (!res[i].used && Gn.size() != Ws[bestW]) {
Gn.push_back(res[i].name);
res[i].used = true;
}
for (i = 0; i < M; i++)
if (!res[i].used && Sn.size() != As[bestA]) {
Sn.push_back(res[i].name);
res[i].used = true;
}
for (i = 0; i < M; i++)
if (!res[i].used && Pn.size() != Os[bestO]) {
Pn.push_back(res[i].name);
res[i].used = true;
}
cout << Wn[bestW] << " " << Gn.size();
for (i = 0; i < Gn.size(); i++) cout << " " << Gn[i];
printf("\n");
cout << An[bestA] << " " << Sn.size();
for (i = 0; i < Sn.size(); i++) cout << " " << Sn[i];
printf("\n");
cout << On[bestO] << " " << Pn.size();
for (i = 0; i < Pn.size(); i++) cout << " " << Pn[i];
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
string name;
int capacity, type;
vector<string> need;
vector<string> already;
int a[3];
} a[111];
struct cell {
int bonus, type;
string name;
bool busy;
int home;
bool operator<(const cell& A) const { return bonus > A.bonus; }
};
int n, k;
vector<int> g[3];
vector<cell> b[3];
int busy[111], sons[111];
map<string, int> itemId;
int s[3][1111];
struct sans {
int id[3];
int a[3];
bool operator<(const sans& A) const {
for (int i = 0; i < 3; i++)
if (a[i] != A.a[i]) return a[i] < A.a[i];
return false;
}
} ans;
bool test = false;
int main() {
int n;
cin >> n;
test = false;
for (int i = 0; i < n; i++) {
cin.ignore();
string cl;
cin >> a[i].name >> cl;
if (cl[0] == 'w') a[i].type = 0;
if (cl[0] == 'a') a[i].type = 1;
if (cl[0] == 'o') a[i].type = 2;
cin >> a[i].a[0] >> a[i].a[1] >> a[i].a[2] >> a[i].capacity;
itemId[a[i].name] = i;
}
for (int i = 0; i < n; i++) g[a[i].type].push_back(i);
int k;
cin >> k;
while (k--) {
cin.ignore();
cell cur;
cur.busy = false;
string cl, home;
cin >> cur.name >> cl >> cur.bonus >> home;
if (cl[0] == 'g') cur.type = 0;
if (cl[0] == 's') cur.type = 1;
if (cl[0] == 'p') cur.type = 2;
int id = itemId[home];
busy[id]++;
a[id].already.push_back(cur.name);
if (cur.type == a[id].type) sons[id] += cur.bonus;
b[cur.type].push_back(cur);
}
bool cool = false;
for (int i = 0; i < n; i++)
if (busy[i] < a[i].capacity) cool = true;
if (cool) {
for (int i = 0; i < 3; i++) {
if (b[i].size() == 0) continue;
sort(b[i].begin(), b[i].end());
s[i][0] = b[i][0].bonus;
for (int j = 1; j < b[i].size(); j++)
s[i][j] = s[i][j - 1] + b[i][j].bonus;
for (int j = b[i].size(); j <= 10; j++) s[i][j] = s[i][j - 1];
}
if (test) return 5;
for (int i = 0; i < 3; i++) ans.a[i] = -100;
for (int i = 0; i < g[0].size(); i++)
for (int j = 0; j < g[1].size(); j++)
for (int k = 0; k < g[2].size(); k++) {
sans res;
res.id[0] = g[0][i];
res.id[1] = g[1][j];
res.id[2] = g[2][k];
for (int q = 0; q < 3; q++) res.a[q] = 0;
for (int q = 0; q < 3; q++)
if (a[res.id[q]].capacity != 0)
res.a[q] = a[res.id[q]].a[q] + s[q][a[res.id[q]].capacity - 1];
else
res.a[q] = a[res.id[q]].a[q];
if (ans < res) ans = res;
}
if (test) return 4;
for (int i = 0; i < 3; i++) {
int num = ans.id[i];
int lim = min((int)b[i].size(), a[num].capacity);
for (int j = 0; j < lim; j++) {
a[num].need.push_back(b[i][j].name);
b[i][j].busy = true;
}
}
if (test) return 3;
vector<string> free;
for (int i = 0; i < 3; i++)
for (int j = 0; j < b[i].size(); j++)
if (!b[i][j].busy) free.push_back(b[i][j].name);
if (test) return 2;
for (int i = 0; i < 3; i++) {
int num = ans.id[i];
while (free.size() > 0 && a[num].need.size() < a[num].capacity) {
a[num].need.push_back(free[(int)free.size() - 1]);
free.pop_back();
}
}
if (test) return 1;
for (int i = 0; i < 3; i++) {
int num = ans.id[i];
cout << a[num].name << " " << a[num].need.size();
for (int j = 0; j < a[num].need.size(); j++)
cout << " " << a[num].need[j];
cout << endl;
}
} else {
for (int i = 0; i < 3; i++) {
int num = g[i][0];
for (int j = 0; j < g[i].size(); j++) {
int cand = g[i][j];
if (a[cand].a[i] + sons[cand] > a[num].a[i] + sons[num]) num = cand;
}
cout << a[num].name << " " << a[num].already.size();
for (int j = 0; j < a[num].already.size(); j++)
cout << " " << a[num].already[j];
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[10000] = {0};
vector<string> item_names;
vector<int> item_class;
vector<int> item_atk;
vector<int> item_def;
vector<int> item_res;
vector<int> item_size;
vector<string> resid_name;
vector<int> resid_type;
vector<int> bonus;
vector<int> resid_here[1000];
vector<pair<int, int> > res_ability;
vector<int> sum_ability;
map<string, int> name_to_idx;
vector<int> act_atk;
vector<int> act_def;
vector<int> act_res;
bool pushed[2000] = {0};
void calculate_act() {
int i = 0, j = 0;
act_atk.resize(item_atk.size());
act_def.resize(item_def.size());
act_res.resize(item_res.size());
int n = item_atk.size();
for (i = 0; i < n; i++) {
act_atk[i] = item_atk[i];
act_def[i] = item_def[i];
act_res[i] = item_res[i];
for (j = 0; j < resid_here[i].size(); j++) {
int r = resid_here[i][j];
if (resid_type[r] == 0)
act_atk[i] += bonus[r];
else if (resid_type[r] == 1)
act_def[i] += bonus[r];
else if (resid_type[r] == 2)
act_res[i] += bonus[r];
}
}
}
void calc_res_ability(int type) {
int i = 0;
res_ability.resize(0);
for (i = 0; i < resid_type.size(); i++)
if (resid_type[i] == type) res_ability.push_back(make_pair(bonus[i], i));
sort(res_ability.begin(), res_ability.end());
reverse(res_ability.begin(), res_ability.end());
sum_ability.resize(res_ability.size() + 1);
sum_ability[0] = 0;
for (i = 1; i < res_ability.size() + 1; i++)
sum_ability[i] = sum_ability[i - 1] + res_ability[i - 1].first;
}
void output_item(int i) {
int j = 0;
printf("%s %d", item_names[i].c_str(), resid_here[i].size());
for (j = 0; j < resid_here[i].size(); j++)
printf(" %s", resid_name[resid_here[i][j]].c_str());
printf("\n");
}
int main() {
int i = 0, j = 0;
int n_items = 0, n_resid = 0;
int buf = 0;
scanf("%d", &n_items);
for (i = 0; i < n_items; i++) {
scanf("%s", s);
item_names.push_back(s);
name_to_idx[s] = i;
scanf("%s", s);
if (strcmp(s, "weapon") == 0)
item_class.push_back(0);
else if (strcmp(s, "armor") == 0)
item_class.push_back(1);
else if (strcmp(s, "orb") == 0)
item_class.push_back(2);
scanf("%d", &buf);
item_atk.push_back(buf);
scanf("%d", &buf);
item_def.push_back(buf);
scanf("%d", &buf);
item_res.push_back(buf);
scanf("%d", &buf);
item_size.push_back(buf);
}
scanf("%d", &n_resid);
for (i = 0; i < n_resid; i++) {
scanf("%s", s);
resid_name.push_back(s);
scanf("%s", s);
if (strcmp(s, "gladiator") == 0)
resid_type.push_back(0);
else if (strcmp(s, "sentry") == 0)
resid_type.push_back(1);
else if (strcmp(s, "physician") == 0)
resid_type.push_back(2);
scanf("%d", &buf);
bonus.push_back(buf);
scanf("%s", s);
resid_here[name_to_idx[s]].push_back(i);
}
int sum_sizes = 0;
for (i = 0; i < n_items; i++) sum_sizes += item_size[i];
if (sum_sizes <= n_resid) {
calculate_act();
int m1 = -1, m2 = -1, m3 = -1;
for (i = 0; i < n_items; i++) {
if (item_class[i] == 0 && (m1 == -1 || act_atk[i] > act_atk[m1]))
m1 = i;
else if (item_class[i] == 1 && (m2 == -1 || act_def[i] > act_def[m2]))
m2 = i;
else if (item_class[i] == 2 && (m3 == -1 || act_res[i] > act_res[m3]))
m3 = i;
}
output_item(m1);
output_item(m2);
output_item(m3);
} else {
int m1 = -1, m2 = -1, m3 = -1;
int mm = 0;
calc_res_ability(0);
for (i = 0; i < n_items; i++) {
if (item_class[i] != 0) continue;
int max_ability = item_atk[i];
if (sum_ability.size() > item_size[i])
max_ability += sum_ability[item_size[i]];
else
max_ability += sum_ability[sum_ability.size() - 1];
if (m1 == -1 || mm < max_ability) {
m1 = i;
mm = max_ability;
resid_here[i].resize(0);
for (j = 0; j < item_size[i] && j < res_ability.size(); j++) {
resid_here[i].push_back(res_ability[j].second);
pushed[res_ability[j].second] = true;
}
}
}
mm = 0;
calc_res_ability(1);
for (i = 0; i < n_items; i++) {
if (item_class[i] != 1) continue;
int max_ability = item_def[i];
if (sum_ability.size() > item_size[i])
max_ability += sum_ability[item_size[i]];
else
max_ability += sum_ability[sum_ability.size() - 1];
if (m2 == -1 || mm < max_ability) {
m2 = i;
mm = max_ability;
resid_here[i].resize(0);
for (j = 0; j < item_size[i] && j < res_ability.size(); j++) {
resid_here[i].push_back(res_ability[j].second);
pushed[res_ability[j].second] = true;
}
}
}
mm = 0;
calc_res_ability(2);
for (i = 0; i < n_items; i++) {
if (item_class[i] != 2) continue;
int max_ability = item_res[i];
if (sum_ability.size() > item_size[i])
max_ability += sum_ability[item_size[i]];
else
max_ability += sum_ability[sum_ability.size() - 1];
if (m3 == -1 || mm < max_ability) {
m3 = i;
mm = max_ability;
resid_here[i].resize(0);
for (j = 0; j < item_size[i] && j < res_ability.size(); j++) {
resid_here[i].push_back(res_ability[j].second);
pushed[res_ability[j].second] = true;
}
}
}
for (i = 0; i < n_resid && resid_here[m1].size() < item_size[m1]; i++) {
if (pushed[i]) continue;
resid_here[m1].push_back(i);
pushed[i] = true;
}
for (i = 0; i < n_resid && resid_here[m2].size() < item_size[m2]; i++) {
if (pushed[i]) continue;
resid_here[m2].push_back(i);
pushed[i] = true;
}
for (i = 0; i < n_resid && resid_here[m3].size() < item_size[m3]; i++) {
if (pushed[i]) continue;
resid_here[m3].push_back(i);
pushed[i] = true;
}
output_item(m1);
output_item(m2);
output_item(m3);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, K = 1010;
int n, k;
string item[N], resi[K], resi_home[K];
int type[N], para[N][3], size[N];
int resi_type[K], resi_bonus[K];
bool used[K];
int myfunc(const int &a, const pair<int, int> &b) { return a + b.first; }
int ans[3];
vector<int> ansv[3];
void iter(int ctrl) {
vector<pair<int, int> > v;
for (int i = 0; i < (int)(k); ++i) {
if ((not used[i]) and resi_type[i] == ctrl) {
v.push_back(make_pair(resi_bonus[i], i));
}
}
sort(v.begin(), v.end(), greater<pair<int, int> >());
int maxi = -1, maxi_id = -1;
for (int i = 0; i < (int)(n); ++i) {
if (type[i] == ctrl) {
int sum = accumulate(v.begin(), v.begin() + min(size[i], (int)v.size()),
0, myfunc) +
para[i][ctrl];
if (maxi < sum) {
maxi = sum;
maxi_id = i;
}
}
}
int sz = min(size[maxi_id], (int)v.size());
ans[ctrl] = maxi_id;
for (int i = 0; i < sz; i++) {
used[v[i].second] = true;
ansv[ctrl].push_back(v[i].second);
}
}
void iter2(int ctrl) {
int maxi = -1, maxi_id = -1;
for (int i = 0; i < (int)(n); ++i) {
if (type[i] == ctrl) {
int s = para[i][ctrl];
for (int j = 0; j < (int)(k); ++j) {
if (item[i] == resi_home[j] and resi_type[j] == ctrl) {
s += resi_bonus[j];
}
}
if (maxi < s) {
maxi = s;
maxi_id = i;
}
}
}
cout << item[maxi_id] << " " << size[maxi_id] << " ";
for (int j = 0; j < (int)(k); ++j) {
if (resi_home[j] == item[maxi_id]) {
cout << resi[j] << " ";
}
}
cout << endl;
}
int main() {
int size_num = 0;
cin >> n;
for (int i = 0; i < (int)(n); ++i) {
string types;
cin >> item[i] >> types;
if (types == "weapon") {
type[i] = 0;
} else if (types == "armor") {
type[i] = 1;
} else if (types == "orb") {
type[i] = 2;
} else {
assert(false);
}
cin >> para[i][0] >> para[i][1] >> para[i][2] >> size[i];
size_num += size[i];
}
cin >> k;
for (int i = 0; i < (int)(k); ++i) {
string types;
cin >> resi[i] >> types;
if (types == "gladiator") {
resi_type[i] = 0;
} else if (types == "sentry") {
resi_type[i] = 1;
} else if (types == "physician") {
resi_type[i] = 2;
} else {
assert(false);
}
cin >> resi_bonus[i] >> resi_home[i];
}
if (size_num > k) {
memset(used, false, sizeof(used));
vector<pair<int, int> > v;
iter(0);
iter(1);
iter(2);
for (int i = 0; i < (int)(3); ++i) {
int id = ans[i];
while ((ansv[i].size() < size[id]) and
ansv[0].size() + ansv[1].size() + ansv[2].size() < k) {
for (int j = 0; j < (int)(k); ++j) {
if (not used[j]) {
ansv[i].push_back(j);
used[j] = true;
break;
}
}
}
}
for (int i = 0; i < (int)(3); ++i) {
int id = ans[i];
cout << item[id] << " " << ansv[i].size() << " ";
for (int j = 0; j < (int)(ansv[i].size()); ++j) {
cout << resi[ansv[i][j]] << " ";
}
cout << endl;
}
} else {
iter2(0);
iter2(1);
iter2(2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Item {
char name[10 + 1];
int typ, val, now;
int size, left;
};
struct Resident {
char name[10 + 1], home[10 + 1];
int typ, bonus;
friend bool operator<(const Resident &a, const Resident &b) {
return a.bonus > b.bonus;
}
};
vector<Item> item[3];
vector<Resident> resident[3];
const char classes[][7] = {"weapon", "armor", "orb"};
inline int find_class(char *name) {
for (int i = 0; i < 3; ++i)
if (strcmp(classes[i], name) == 0) return i;
return 0;
}
const char residents[][10] = {"gladiator", "sentry", "physician"};
inline int find_resident(char *name) {
for (int i = 0; i < 3; ++i)
if (strcmp(residents[i], name) == 0) return i;
return 0;
}
int cnt = 0;
inline void org_resident(char *name, const Resident &p) {
for (int i = 0; i < 3; ++i) {
for (size_t j = 0; j < item[i].size(); ++j) {
if (strcmp(name, item[i][j].name) == 0) {
if (i == p.typ) item[i][j].now += p.bonus;
if (--item[i][j].left == 0) ++cnt;
}
}
}
}
bool readin() {
char tmp[10 + 1];
int val[3];
int n, m;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
Item p;
scanf("%s%s%d%d%d%d", p.name, tmp, val, val + 1, val + 2, &p.size);
p.left = p.size;
p.typ = find_class(tmp);
p.val = p.now = val[p.typ];
item[p.typ].push_back(p);
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
Resident p;
scanf("%s%s%d%s", p.name, tmp, &p.bonus, p.home);
p.typ = find_resident(tmp);
org_resident(p.home, p);
resident[p.typ].push_back(p);
}
for (int i = 0; i < 3; ++i) sort(resident[i].begin(), resident[i].end());
return n == cnt;
}
vector<int> rem;
void putitem() {
int ans[3];
for (int i = 0; i < 3; ++i) {
for (size_t j = 0; j < resident[i].size(); ++j) resident[i][j].home[0] = 0;
}
for (int i = 0; i < 3; ++i) {
int tmp = -1;
for (size_t j = 0; j < item[i].size(); ++j) {
item[i][j].now = item[i][j].val;
for (int k = 0; k < min(item[i][j].size, (int)resident[i].size()); ++k) {
item[i][j].now += resident[i][k].bonus;
}
if (item[i][j].now > tmp) {
tmp = item[i][j].now;
ans[i] = j;
}
}
}
for (int i = 0; i < 3; ++i) {
item[i][ans[i]].left = item[i][ans[i]].size;
for (size_t j = 0; j < resident[i].size(); ++j) {
if (item[i][ans[i]].left > 0) {
strcpy(resident[i][j].home, item[i][ans[i]].name);
--item[i][ans[i]].left;
} else {
rem.push_back(i * 1000 + j);
}
}
}
for (int i = 0; i < 3; ++i) {
while (item[i][ans[i]].left > 0 && !rem.empty()) {
int val = rem.back();
rem.pop_back();
strcpy(resident[val / 1000][val % 1000].home, item[i][ans[i]].name);
--item[i][ans[i]].left;
}
}
}
void output() {
for (int i = 0; i < 3; ++i) {
int tmp = -1, id = 0;
for (size_t j = 0; j < item[i].size(); ++j) {
if (item[i][j].now > tmp) {
tmp = item[i][j].now;
id = j;
}
}
printf("%s %d", item[i][id].name, item[i][id].size - item[i][id].left);
for (int j = 0; j < 3; ++j) {
for (size_t k = 0; k < resident[j].size(); ++k) {
if (strcmp(resident[j][k].home, item[i][id].name) == 0) {
printf(" %s", resident[j][k].name);
}
}
}
puts("");
}
}
int main() {
if (!readin()) {
putitem();
}
output();
return 0;
}
|
#include <bits/stdc++.h>
struct wpn {
char name[20];
int v1, v2, v3, type, size;
} wp[105];
struct par {
char name[20];
int v;
} pr[4][1005];
int m[105][1005], top[105], n, tp[4], sum[4][1005];
int cmp(const void *c1, const void *c2) {
return strcmp(((wpn *)c1)->name, ((wpn *)c2)->name);
}
int cmp1(const void *c1, const void *c2) {
return ((par *)c2)->v - ((par *)c1)->v;
}
int bin_search(char *nm) {
int i, p, q, tmp;
for (p = 0, q = n - 1; p <= q;) {
i = (p + q) / 2;
tmp = strcmp(wp[i].name, nm);
if (!tmp) return i;
if (tmp < 0)
p = i + 1;
else
q = i - 1;
}
return -1;
}
int main() {
int k, i, j, tmp, ind, max[4], maxi[4], s = 0, cur, max_num[4], i1, j1,
tp2[4];
char c[20], c1[20], nm[1005][20];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s %s %d %d %d %d", &wp[i].name, &c, &wp[i].v1, &wp[i].v2, &wp[i].v3,
&tmp);
if (c[0] == 'w') wp[i].type = 1;
if (c[0] == 'a') wp[i].type = 2;
if (c[0] == 'o') wp[i].type = 3;
wp[i].size = tmp;
s += tmp;
}
qsort(wp, n, sizeof(wpn), cmp);
scanf("%d", &k);
if (k == s) {
for (i = 0; i < k; i++) {
scanf("%s %s %d %s", &nm[i], &c, &tmp, &c1);
ind = bin_search(c1);
m[ind][top[ind]++] = i;
if (c[0] == 'g') wp[ind].v1 += tmp;
if (c[0] == 's') wp[ind].v2 += tmp;
if (c[0] == 'p') wp[ind].v3 += tmp;
}
for (i = 1; i < 4; i++) max[i] = -1;
for (i = 0; i < n; i++) {
if (wp[i].type == 1) {
if (max[1] < wp[i].v1) {
max[1] = wp[i].v1;
maxi[1] = i;
}
}
if (wp[i].type == 2) {
if (max[2] < wp[i].v2) {
max[2] = wp[i].v2;
maxi[2] = i;
}
}
if (wp[i].type == 3) {
if (max[3] < wp[i].v3) {
max[3] = wp[i].v3;
maxi[3] = i;
}
}
}
for (i = 1; i < 4; i++) {
printf("%s %d ", wp[maxi[i]].name, top[maxi[i]]);
for (j = 0; j < top[maxi[i]]; j++) printf("%s ", nm[m[maxi[i]][j]]);
putchar('\n');
}
return 0;
}
for (i = 0; i < k; i++) {
scanf("%s %s %d %s", &nm[i], &c, &tmp, &c1);
if (c[0] == 'g') {
strcpy(pr[1][tp[1]].name, nm[i]);
pr[1][tp[1]++].v = tmp;
}
if (c[0] == 's') {
strcpy(pr[2][tp[2]].name, nm[i]);
pr[2][tp[2]++].v = tmp;
}
if (c[0] == 'p') {
strcpy(pr[3][tp[3]].name, nm[i]);
pr[3][tp[3]++].v = tmp;
}
}
for (j = 1; j < 4; j++) {
qsort(pr[j], tp[j], sizeof(par), cmp1);
sum[j][0] = 0;
for (i = 1; i <= tp[j]; i++) sum[j][i] = sum[j][i - 1] + pr[j][i - 1].v;
}
for (i = 1; i < 4; i++) max[i] = -1;
for (i = 0; i < n; i++) {
if (wp[i].type == 1) {
tmp = (wp[i].size > tp[1] ? tp[1] : wp[i].size);
cur = wp[i].v1 + sum[1][tmp];
if (cur > max[1]) {
max[1] = cur;
maxi[1] = i;
}
}
if (wp[i].type == 2) {
tmp = (wp[i].size > tp[2] ? tp[2] : wp[i].size);
cur = wp[i].v2 + sum[2][tmp];
if (cur > max[2]) {
max[2] = cur;
maxi[2] = i;
}
}
if (wp[i].type == 3) {
tmp = (wp[i].size > tp[3] ? tp[3] : wp[i].size);
cur = wp[i].v3 + sum[3][tmp];
if (cur > max[3]) {
max[3] = cur;
maxi[3] = i;
}
}
}
for (i = 1; i < 4; i++) {
max_num[i] = wp[maxi[i]].size >= tp[i] ? tp[i] : wp[maxi[i]].size;
tp2[i] = max_num[i];
}
for (i = 1; i < 4; i++)
for (j = 0; j < max_num[i]; j++) m[i][top[i]++] = i * 10000 + j;
for (i = 1; i < 4; i++)
if (max_num[i] < wp[maxi[i]].size) {
for (j = 1; j < 4; j++)
for (i1 = tp2[j]; i1 < tp[j] && max_num[i] < wp[maxi[i]].size; i1++) {
m[i][top[i]++] = 10000 * j + i1;
max_num[i]++;
tp2[j]++;
}
}
for (i = 1; i < 4; i++) {
printf("%s %d ", wp[maxi[i]].name, max_num[i]);
for (j = 0; j < max_num[i]; j++)
printf("%s ", pr[m[i][j] / 10000][m[i][j] % 10000].name);
putchar('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
string type, name;
int atk, def, res, size;
};
struct resident {
string name;
string type;
int strength;
string belong;
};
vector<item> weapon, armor, orb;
vector<resident> atk, def, res;
map<string, vector<resident> > mp;
int N, M;
int sum = 0;
map<string, int> used;
void scan() {
cin >> N;
for (int i = 0; i < N; ++i) {
item tmp;
cin >> tmp.name >> tmp.type >> tmp.atk >> tmp.def >> tmp.res >> tmp.size;
sum += tmp.size;
if (tmp.type == "weapon")
weapon.push_back(tmp);
else if (tmp.type == "armor")
armor.push_back(tmp);
else
orb.push_back(tmp);
}
cin >> M;
for (int i = 0; i < M; ++i) {
resident tmp;
string nimaibe;
cin >> tmp.name >> tmp.type >> tmp.strength >> tmp.belong;
if (tmp.type == "gladiator")
atk.push_back(tmp);
else if (tmp.type == "sentry")
def.push_back(tmp);
else
res.push_back(tmp);
mp[tmp.belong].push_back(tmp);
}
}
bool fatk(item t1, item t2) {
int sum1 = t1.atk, sum2 = t2.atk;
for (int i = 0; i < mp[t1.name].size(); ++i)
if (mp[t1.name][i].type == "gladiator") sum1 += mp[t1.name][i].strength;
for (int i = 0; i < mp[t2.name].size(); ++i)
if (mp[t2.name][i].type == "gladiator") sum2 += mp[t2.name][i].strength;
return sum1 > sum2;
}
bool fdef(item t1, item t2) {
int sum1 = t1.def, sum2 = t2.def;
for (int i = 0; i < mp[t1.name].size(); ++i)
if (mp[t1.name][i].type == "sentry") sum1 += mp[t1.name][i].strength;
for (int i = 0; i < mp[t2.name].size(); ++i)
if (mp[t2.name][i].type == "sentry") sum2 += mp[t2.name][i].strength;
return sum1 > sum2;
}
bool fres(item t1, item t2) {
int sum1 = t1.res, sum2 = t2.res;
for (int i = 0; i < mp[t1.name].size(); ++i)
if (mp[t1.name][i].type == "physician") sum1 += mp[t1.name][i].strength;
for (int i = 0; i < mp[t2.name].size(); ++i)
if (mp[t2.name][i].type == "physician") sum2 += mp[t2.name][i].strength;
return sum1 > sum2;
}
void solve1() {
sort(weapon.begin(), weapon.end(), fatk);
sort(armor.begin(), armor.end(), fdef);
sort(orb.begin(), orb.end(), fres);
cout << weapon[0].name << " ";
cout << mp[weapon[0].name].size();
for (int i = 0; i < mp[weapon[0].name].size(); ++i)
cout << " " << mp[weapon[0].name][i].name;
cout << endl;
cout << armor[0].name << " ";
cout << mp[armor[0].name].size();
for (int i = 0; i < mp[armor[0].name].size(); ++i)
cout << " " << mp[armor[0].name][i].name;
cout << endl;
cout << orb[0].name << " ";
cout << mp[orb[0].name].size();
for (int i = 0; i < mp[orb[0].name].size(); ++i)
cout << " " << mp[orb[0].name][i].name;
cout << endl;
}
bool f(resident t1, resident t2) { return t1.strength > t2.strength; }
void solve2() {
sort(atk.begin(), atk.end(), f);
sort(def.begin(), def.end(), f);
sort(res.begin(), res.end(), f);
for (int i = 0; i < weapon.size(); ++i) {
mp[weapon[i].name].erase(mp[weapon[i].name].begin(),
mp[weapon[i].name].end());
for (int j = 0; j < min((int)atk.size(), weapon[i].size); ++j)
mp[weapon[i].name].push_back(atk[j]);
}
for (int i = 0; i < armor.size(); ++i) {
mp[armor[i].name].erase(mp[armor[i].name].begin(), mp[armor[i].name].end());
for (int j = 0; j < min((int)def.size(), armor[i].size); ++j)
mp[armor[i].name].push_back(def[j]);
}
for (int i = 0; i < orb.size(); ++i) {
mp[orb[i].name].erase(mp[orb[i].name].begin(), mp[orb[i].name].end());
for (int j = 0; j < min((int)res.size(), orb[i].size); ++j)
mp[orb[i].name].push_back(res[j]);
}
sort(weapon.begin(), weapon.end(), fatk);
sort(armor.begin(), armor.end(), fdef);
sort(orb.begin(), orb.end(), fres);
string w = weapon[0].name, a = armor[0].name, o = orb[0].name;
for (int i = 0; i < mp[w].size(); ++i) used[mp[w][i].name] = 1;
for (int i = 0; i < mp[o].size(); ++i) used[mp[o][i].name] = 1;
for (int i = 0; i < mp[a].size(); ++i) used[mp[a][i].name] = 1;
vector<resident> free;
for (int i = 0; i < atk.size(); ++i)
if (!used[atk[i].name]) free.push_back(atk[i]);
for (int i = 0; i < def.size(); ++i)
if (!used[def[i].name]) free.push_back(def[i]);
for (int i = 0; i < res.size(); ++i)
if (!used[res[i].name]) free.push_back(res[i]);
int idx = 0;
int x = weapon[0].size - mp[w].size();
for (int i = 0; i < x; ++i) {
if (idx == free.size()) break;
mp[w].push_back(free[idx++]);
}
int y = armor[0].size - mp[a].size();
for (int i = 0; i < y; ++i) {
if (idx == free.size()) break;
mp[a].push_back(free[idx++]);
}
int z = orb[0].size - mp[o].size();
for (int i = 0; i < z; ++i) {
if (idx == free.size()) break;
mp[o].push_back(free[idx++]);
}
cout << weapon[0].name << " ";
cout << mp[weapon[0].name].size();
for (int i = 0; i < mp[weapon[0].name].size(); ++i)
cout << " " << mp[weapon[0].name][i].name;
cout << endl;
cout << armor[0].name << " ";
cout << mp[armor[0].name].size();
for (int i = 0; i < mp[armor[0].name].size(); ++i)
cout << " " << mp[armor[0].name][i].name;
cout << endl;
cout << orb[0].name << " ";
cout << mp[orb[0].name].size();
for (int i = 0; i < mp[orb[0].name].size(); ++i)
cout << " " << mp[orb[0].name][i].name;
cout << endl;
}
int main() {
scan();
if (sum == M)
solve1();
else
solve2();
}
|
#include <bits/stdc++.h>
struct ite {
char name[15];
int val;
int size;
};
struct bon {
char name[15];
char where[15];
int val;
};
void sort(struct bon a[1005], int l, int r) {
if (r <= l) return;
int i, j, x;
struct bon y;
i = l;
j = r;
x = a[(l + r) / 2].val;
while (i <= j) {
while (a[i].val > x) i++;
while (a[j].val < x) j--;
if (i <= j) {
y = a[i];
a[i] = a[j];
a[j] = y;
i++;
j--;
}
}
if (l < j) sort(a, l, j);
if (i < r) sort(a, i, r);
}
int main() {
static struct ite w[1005];
int wc = 0;
static struct ite a[1005];
int ac = 0;
static struct ite o[1005];
int oc = 0;
static struct bon g[1005];
int gc = 0;
static struct bon s[1005];
int sc = 0;
static struct bon p[1005];
int pc = 0;
static char name[15];
static char type[15];
static char useless[15];
int x, y, z, sz;
int N, M;
int S = 0;
scanf("%d\n", &N);
int i, j;
for (i = 0; i < N; i++) {
scanf("%s %s %d %d %d %d\n", name, type, &x, &y, &z, &sz);
S += sz;
if (type[0] == 'w') {
memcpy(w[wc].name, name, sizeof(name));
w[wc].val = x;
w[wc].size = sz;
wc++;
} else if (type[0] == 'a') {
memcpy(a[ac].name, name, sizeof(name));
a[ac].val = y;
a[ac].size = sz;
ac++;
} else {
memcpy(o[oc].name, name, sizeof(name));
o[oc].val = z;
o[oc].size = sz;
oc++;
}
}
scanf("%d\n", &M);
for (i = 0; i < M; i++) {
scanf("%s %s %d %s\n", name, type, &sz, useless);
if (type[0] == 'g') {
memcpy(g[gc].name, name, sizeof(name));
memcpy(g[gc].where, useless, sizeof(useless));
g[gc].val = sz;
gc++;
} else if (type[0] == 's') {
memcpy(s[sc].name, name, sizeof(name));
memcpy(s[sc].where, useless, sizeof(useless));
s[sc].val = sz;
sc++;
} else {
memcpy(p[pc].name, name, sizeof(name));
memcpy(p[pc].where, useless, sizeof(useless));
p[pc].val = sz;
pc++;
}
}
static struct bon bg[1005];
int bgc;
if (S == M) {
int res, resw, cnt, temp;
bgc = 0;
for (i = 0; i < gc; i++) {
bg[bgc] = g[i];
bgc++;
}
for (i = 0; i < sc; i++) {
bg[bgc] = s[i];
bgc++;
}
for (i = 0; i < pc; i++) {
bg[bgc] = p[i];
bgc++;
}
res = -1;
resw = -1;
for (i = 0; i < wc; i++) {
temp = w[i].val;
for (j = 0; j < gc; j++) {
if (strcmp(w[i].name, g[j].where) == 0) temp += g[j].val;
}
if (temp > res) {
res = temp;
resw = i;
}
}
cnt = 0;
for (i = 0; i < bgc; i++) {
if (strcmp(w[resw].name, bg[i].where) == 0) cnt++;
}
printf("%s %d", w[resw].name, cnt);
for (i = 0; i < bgc; i++) {
if (strcmp(w[resw].name, bg[i].where) == 0) printf(" %s", bg[i].name);
}
printf("\n");
res = -1;
resw = -1;
for (i = 0; i < ac; i++) {
temp = a[i].val;
for (j = 0; j < sc; j++) {
if (strcmp(a[i].name, s[j].where) == 0) temp += s[j].val;
}
if (temp > res) {
res = temp;
resw = i;
}
}
cnt = 0;
for (i = 0; i < bgc; i++) {
if (strcmp(a[resw].name, bg[i].where) == 0) cnt++;
}
printf("%s %d", a[resw].name, cnt);
for (i = 0; i < bgc; i++) {
if (strcmp(a[resw].name, bg[i].where) == 0) printf(" %s", bg[i].name);
}
printf("\n");
res = -1;
resw = -1;
for (i = 0; i < oc; i++) {
temp = o[i].val;
for (j = 0; j < pc; j++) {
if (strcmp(o[i].name, p[j].where) == 0) temp += p[j].val;
}
if (temp > res) {
res = temp;
resw = i;
}
}
cnt = 0;
for (i = 0; i < bgc; i++) {
if (strcmp(o[resw].name, bg[i].where) == 0) cnt++;
}
printf("%s %d", o[resw].name, cnt);
for (i = 0; i < bgc; i++) {
if (strcmp(o[resw].name, bg[i].where) == 0) printf(" %s", bg[i].name);
}
printf("\n");
} else {
sort(g, 0, gc - 1);
sort(s, 0, sc - 1);
sort(p, 0, pc - 1);
int temp, lim;
int resw = -1;
int resw_w = -1;
int resw_c = 0;
for (i = 0; i < wc; i++) {
temp = w[i].val;
lim = w[i].size;
if (gc < lim) lim = gc;
for (j = 0; j < lim; j++) temp += g[j].val;
if (temp > resw) {
resw = temp;
resw_w = i;
resw_c = lim;
}
}
int resa = -1;
int resa_w = -1;
int resa_c = 0;
for (i = 0; i < ac; i++) {
temp = a[i].val;
lim = a[i].size;
if (sc < lim) lim = sc;
for (j = 0; j < lim; j++) temp += s[j].val;
if (temp > resa) {
resa = temp;
resa_w = i;
resa_c = lim;
}
}
int reso = -1;
int reso_w = -1;
int reso_c = 0;
for (i = 0; i < oc; i++) {
temp = o[i].val;
lim = o[i].size;
if (pc < lim) lim = pc;
for (j = 0; j < lim; j++) temp += p[j].val;
if (temp > reso) {
reso = temp;
reso_w = i;
reso_c = lim;
}
}
bgc = 0;
for (i = resw_c; i < gc; i++) {
bg[bgc] = g[i];
bgc++;
}
for (i = resa_c; i < sc; i++) {
bg[bgc] = s[i];
bgc++;
}
for (i = reso_c; i < pc; i++) {
bg[bgc] = p[i];
bgc++;
}
lim = resw_c + bgc;
if (w[resw_w].size < lim) lim = w[resw_w].size;
printf("%s %d", w[resw_w].name, lim);
for (i = 0; i < resw_c; i++) printf(" %s", g[i].name);
for (i = resw_c; i < lim; i++) {
bgc--;
printf(" %s", bg[bgc].name);
}
printf("\n");
lim = resa_c + bgc;
if (a[resa_w].size < lim) lim = a[resa_w].size;
printf("%s %d", a[resa_w].name, lim);
for (i = 0; i < resa_c; i++) printf(" %s", s[i].name);
for (i = resa_c; i < lim; i++) {
bgc--;
printf(" %s", bg[bgc].name);
}
printf("\n");
lim = reso_c + bgc;
if (o[reso_w].size < lim) lim = o[reso_w].size;
printf("%s %d", o[reso_w].name, lim);
for (i = 0; i < reso_c; i++) printf(" %s", p[i].name);
for (i = reso_c; i < lim; i++) {
bgc--;
printf(" %s", bg[bgc].name);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
struct Item {
string name;
int type;
int base;
int size;
vector<string> monsters;
void print() {
cout << name << " " << monsters.size();
for (string s : monsters) {
cout << " " << s;
}
cout << endl;
}
void read() {
string s;
cin >> name >> s;
int a, b, c;
cin >> a >> b >> c;
cin >> size;
if (s == "weapon") {
type = 0;
base = a;
} else if (s == "armor") {
type = 1;
base = b;
} else if (s == "orb") {
type = 2;
base = c;
} else {
assert(false);
}
}
};
struct Monster {
string name;
int type;
int bonus;
string home;
void read() {
string s;
cin >> name >> s >> bonus >> home;
if (s[0] == 'g') {
type = 0;
} else if (s[0] == 's') {
type = 1;
} else if (s[0] == 'p') {
type = 2;
} else {
assert(false);
}
}
};
int main() {
int n;
cin >> n;
vector<Item> items(n);
for (Item& item : items) {
item.read();
}
int k;
cin >> k;
vector<Monster> monsters(k);
for (Monster& monster : monsters) {
monster.read();
}
int places = 0;
for (Item item : items) {
places += item.size;
}
bool special = false;
if (places == k) {
special = true;
}
set<string> taken;
vector<Item> answer(3);
for (int type = 0; type < 3; ++type) {
vector<pair<int, string>> they;
for (Monster monster : monsters) {
if (monster.type == type) {
they.emplace_back(monster.bonus, monster.name);
}
}
sort(they.rbegin(), they.rend());
Item best = items[0];
for (Item item : items) {
if (item.type == type) {
if (!special) {
for (int i = 0; i < min(item.size, (int)they.size()); ++i) {
item.monsters.push_back(they[i].second);
item.base += they[i].first;
}
} else {
for (Monster monster : monsters) {
if (monster.home == item.name) {
item.monsters.push_back(monster.name);
if (monster.type == item.type) {
item.base += monster.bonus;
}
}
}
}
if (best.type != type || item.base > best.base) {
best = item;
}
}
}
answer[type] = best;
for (string s : best.monsters) {
taken.insert(s);
}
}
for (Item item : answer) {
for (Monster m : monsters) {
if ((int)item.monsters.size() < item.size && !taken.count(m.name)) {
taken.insert(m.name);
item.monsters.push_back(m.name);
}
}
item.print();
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
int n, k;
map<string, pair<int, int> > w[3];
map<string, pair<int, string> > w1[3];
pair<pair<string, int>, vector<string> > calc(int x, bool change) {
pair<pair<string, int>, vector<string> > res;
res.first.second = -inf;
for (map<string, pair<int, int> >::iterator it = w[x].begin();
it != w[x].end(); it++) {
pair<pair<string, int>, vector<string> > tmp;
tmp.first.first = it->first;
tmp.first.second = it->second.first;
if (!change) {
for (int i = 0; i < (int)(3); i++)
for (map<string, pair<int, string> >::iterator jt = w1[i].begin();
jt != w1[i].end(); jt++)
if (jt->second.second == tmp.first.first) {
tmp.second.push_back(jt->first);
if (i == x) tmp.first.second += jt->second.first;
}
} else {
vector<pair<int, string> > tmpvec;
for (map<string, pair<int, string> >::iterator jt = w1[x].begin();
jt != w1[x].end(); jt++)
tmpvec.push_back(make_pair(jt->second.first, jt->first));
sort(tmpvec.begin(), tmpvec.end());
reverse(tmpvec.begin(), tmpvec.end());
for (int i = 0; i < (int)(min((int)tmpvec.size(), it->second.second));
i++) {
tmp.second.push_back(tmpvec[i].second);
tmp.first.second += tmpvec[i].first;
}
}
if (res.first.second < tmp.first.second) res = tmp;
}
for (int i = 0; i < (int)(res.second.size()); i++)
for (int x = 0; x < (int)(3); x++) w1[x].erase(res.second[i]);
return res;
}
int main() {
cin >> n;
int total = 0;
for (int i = 0; i < (int)(n); i++) {
string s1, s2;
int a, b, c, d;
cin >> s1 >> s2 >> a >> b >> c >> d;
if (s2 == "weapon")
w[0][s1] = make_pair(a, d);
else if (s2 == "armor")
w[1][s1] = make_pair(b, d);
else
w[2][s1] = make_pair(c, d);
total += d;
}
cin >> k;
for (int i = 0; i < (int)(k); i++) {
string s1, s2, s3;
int x;
cin >> s1 >> s2 >> x >> s3;
if (s2 == "gladiator")
w1[0][s1] = make_pair(x, s3);
else if (s2 == "sentry")
w1[1][s1] = make_pair(x, s3);
else
w1[2][s1] = make_pair(x, s3);
}
bool change;
if (total == k)
change = 0;
else
change = 1;
pair<pair<string, int>, vector<string> > best[3];
for (int i = 0; i < (int)(3); i++) best[i] = calc(i, change);
for (int i = 0; i < (int)(3); i++) {
for (int x = 0; x < (int)(3); x++)
for (map<string, pair<int, string> >::iterator jt = w1[x].begin();
jt != w1[x].end(); jt++)
if (w[i][best[i].first.first].second > (int)best[i].second.size())
best[i].second.push_back(jt->first);
for (int j = 0; j < (int)(best[i].second.size()); j++)
for (int x = 0; x < (int)(3); x++) w1[x].erase(best[i].second[j]);
}
for (int i = 0; i < (int)(3); i++) {
cout << best[i].first.first << " " << best[i].second.size();
for (int j = 0; j < (int)(best[i].second.size()); j++)
cout << " " << best[i].second[j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, pair<pair<int, int>, vector<string> > > ai;
map<string, pair<int, string> > ar;
map<string, int> ti, tr;
vector<string> atki, defi, resi;
vector<string> atkr, defr, resr;
set<string> v;
int n, m, sz;
bool cmp(const string& a, const string& b) { return ar[a].first > ar[b].first; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string nam, cla;
int atk, def, res, siz;
cin >> nam >> cla >> atk >> def >> res >> siz;
if (cla == "weapon")
ai[nam].first = make_pair(atk, siz), atki.push_back(nam), ti[nam] = 1;
else if (cla == "armor")
ai[nam].first = make_pair(def, siz), defi.push_back(nam), ti[nam] = 2;
else if (cla == "orb")
ai[nam].first = make_pair(res, siz), resi.push_back(nam), ti[nam] = 3;
sz += siz;
}
cin >> m;
for (int i = 0; i < m; i++) {
string nam, cla;
int num;
string hom;
cin >> nam >> cla >> num >> hom;
if (cla == "gladiator")
ar[nam] = make_pair(num, hom), atkr.push_back(nam),
ai[hom].second.push_back(nam), tr[nam] = 1;
else if (cla == "sentry")
ar[nam] = make_pair(num, hom), defr.push_back(nam),
ai[hom].second.push_back(nam), tr[nam] = 2;
else if (cla == "physician")
ar[nam] = make_pair(num, hom), resr.push_back(nam),
ai[hom].second.push_back(nam), tr[nam] = 3;
}
sort(atkr.begin(), atkr.end(), cmp), sort(defr.begin(), defr.end(), cmp),
sort(resr.begin(), resr.end(), cmp);
int atks = -1, defs = -1, ress = -1;
string atkn, defn, resn;
if (sz == m) {
for (int i = 0; i < (int)atki.size(); i++) {
int a = ai[atki[i]].first.first;
for (int j = 0; j < (int)ai[atki[i]].second.size(); j++)
if (ti[atki[i]] == tr[ai[atki[i]].second[j]])
a += ar[ai[atki[i]].second[j]].first;
if (a > atks) atks = a, atkn = atki[i];
}
for (int i = 0; i < (int)defi.size(); i++) {
int a = ai[defi[i]].first.first;
for (int j = 0; j < (int)ai[defi[i]].second.size(); j++)
if (ti[defi[i]] == tr[ai[defi[i]].second[j]])
a += ar[ai[defi[i]].second[j]].first;
if (a > defs) defs = a, defn = defi[i];
}
for (int i = 0; i < (int)resi.size(); i++) {
int a = ai[resi[i]].first.first;
for (int j = 0; j < (int)ai[resi[i]].second.size(); j++)
if (ti[resi[i]] == tr[ai[resi[i]].second[j]])
a += ar[ai[resi[i]].second[j]].first;
if (a > ress) ress = a, resn = resi[i];
}
cout << atkn << " " << (int)ai[atkn].second.size();
for (int i = 0; i < (int)ai[atkn].second.size(); i++)
cout << " " << ai[atkn].second[i];
cout << endl;
cout << defn << " " << (int)ai[defn].second.size();
for (int i = 0; i < (int)ai[defn].second.size(); i++)
cout << " " << ai[defn].second[i];
cout << endl;
cout << resn << " " << (int)ai[resn].second.size();
for (int i = 0; i < (int)ai[resn].second.size(); i++)
cout << " " << ai[resn].second[i];
cout << endl;
return 0;
}
for (int i = 0; i < (int)atki.size(); i++) {
int a = ai[atki[i]].first.first;
for (int j = 0; j < min((int)atkr.size(), ai[atki[i]].first.second); j++)
a += ar[atkr[j]].first;
if (a > atks) atks = a, atkn = atki[i];
}
for (int i = 0; i < (int)defi.size(); i++) {
int a = ai[defi[i]].first.first;
for (int j = 0; j < min((int)defr.size(), ai[defi[i]].first.second); j++)
a += ar[defr[j]].first;
if (a > defs) defs = a, defn = defi[i];
}
for (int i = 0; i < (int)resi.size(); i++) {
int a = ai[resi[i]].first.first;
for (int j = 0; j < min((int)resr.size(), ai[resi[i]].first.second); j++)
a += ar[resr[j]].first;
if (a > ress) ress = a, resn = resi[i];
}
ai[atkn].second.clear();
for (int i = 0; i < min((int)atkr.size(), ai[atkn].first.second); i++)
ai[atkn].second.push_back(atkr[i]), v.insert(atkr[i]);
ai[defn].second.clear();
for (int i = 0; i < min((int)defr.size(), ai[defn].first.second); i++)
ai[defn].second.push_back(defr[i]), v.insert(defr[i]);
ai[resn].second.clear();
for (int i = 0; i < min((int)resr.size(), ai[resn].first.second); i++)
ai[resn].second.push_back(resr[i]), v.insert(resr[i]);
for (map<string, pair<int, string> >::iterator i = ar.begin(); i != ar.end();
i++)
if (v.find(i->first) == v.end()) {
v.insert(i->first);
if (ai[atkn].first.second > (int)ai[atkn].second.size()) {
ai[atkn].second.push_back(i->first);
continue;
}
if (ai[defn].first.second > (int)ai[defn].second.size()) {
ai[defn].second.push_back(i->first);
continue;
}
if (ai[resn].first.second > (int)ai[resn].second.size()) {
ai[resn].second.push_back(i->first);
continue;
}
}
cout << atkn << " " << (int)ai[atkn].second.size();
for (int i = 0; i < (int)ai[atkn].second.size(); i++)
cout << " " << ai[atkn].second[i];
cout << endl;
cout << defn << " " << (int)ai[defn].second.size();
for (int i = 0; i < (int)ai[defn].second.size(); i++)
cout << " " << ai[defn].second[i];
cout << endl;
cout << resn << " " << (int)ai[resn].second.size();
for (int i = 0; i < (int)ai[resn].second.size(); i++)
cout << " " << ai[resn].second[i];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
while (cin >> N) {
map<string, int> item_type;
map<string, int> item_val[3];
map<string, int> item_size;
map<string, int> item_fill;
map<string, int> item_initial_val;
map<string, vector<string> > item_initial_resident;
for (int i = 0; i < (int)(N); i++) {
string name, type;
int val[3], size;
cin >> name >> type >> val[0] >> val[1] >> val[2] >> size;
int type_i = type == "weapon" ? 0 : type == "armor" ? 1 : 2;
item_type[name] = type_i;
item_size[name] = size;
item_val[type_i][name] = val[type_i];
item_initial_val[name] = val[type_i];
}
int M;
cin >> M;
vector<pair<int, string> > resident[3];
for (int i = 0; i < (int)(M); i++) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
++item_fill[home];
int type_i = type == "gladiator" ? 0 : type == "sentry" ? 1 : 2;
resident[type_i].push_back(make_pair(bonus, name));
if (type_i == item_type[home]) item_initial_val[home] += bonus;
item_initial_resident[home].push_back(name);
}
bool filled = true;
for (__typeof((item_size).begin()) ite = (item_size).begin();
ite != (item_size).end(); ++ite) {
string name = ite->first;
if (item_fill[name] < item_size[name]) filled = false;
}
if (filled) {
for (int i = 0; i < (int)(3); i++) {
string best_name = "";
for (__typeof((item_val[i]).begin()) ite = (item_val[i]).begin();
ite != (item_val[i]).end(); ++ite) {
string name = ite->first;
if (best_name == "" ||
item_initial_val[best_name] < item_initial_val[name]) {
best_name = name;
}
}
cout << best_name << " " << item_initial_resident[best_name].size();
for (__typeof((item_initial_resident[best_name]).begin()) ite =
(item_initial_resident[best_name]).begin();
ite != (item_initial_resident[best_name]).end(); ++ite)
cout << " " << *ite;
cout << endl;
}
} else {
vector<bool> usd[3];
string sel_item[3];
vector<string> sel_res[3];
for (int i = 0; i < (int)(3); i++) {
sort(resident[i].rbegin(), resident[i].rend());
usd[i].resize(resident[i].size());
string best_name = "";
int best_val = -1;
for (__typeof((item_val[i]).begin()) ite = (item_val[i]).begin();
ite != (item_val[i]).end(); ++ite) {
string name = ite->first;
int val = item_val[i][name];
int k = min(item_size[name], (int)resident[i].size());
for (int j = 0; j < (int)(k); j++) val += resident[i][j].first;
if (val > best_val) {
best_name = name;
best_val = val;
}
}
sel_item[i] = best_name;
int k = min(item_size[best_name], (int)resident[i].size());
for (int j = 0; j < (int)(k); j++) {
sel_res[i].push_back(resident[i][j].second);
usd[i][j] = true;
}
}
for (int i = 0; i < (int)(3); i++)
for (int j = 0; j < (int)(resident[i].size()); j++)
if (usd[i][j] == false) {
for (int k = 0; k < (int)(3); k++)
if ((int)sel_res[k].size() < item_size[sel_item[k]]) {
sel_res[k].push_back(resident[i][j].second);
break;
}
}
for (int i = 0; i < (int)(3); i++) {
cout << sel_item[i] << " " << sel_res[i].size();
for (int j = 0; j < (int)(sel_res[i].size()); j++)
cout << " " << sel_res[i][j];
cout << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ss;
vector<pair<pair<int, int>, string> > w, a, o;
vector<pair<pair<int, string>, string> > g, se, p;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string s, t;
int v, x, y, z;
cin >> s >> t >> v >> x >> y >> z;
if (t == "weapon") w.push_back(make_pair(pair<int, int>(v, z), s));
if (t == "armor") a.push_back(make_pair(pair<int, int>(x, z), s));
if (t == "orb") o.push_back(make_pair(pair<int, int>(y, z), s));
ss += z;
}
cin >> k;
for (int j = 0; j < k; j++) {
string s, t, v;
int u;
cin >> s >> t >> u >> v;
if (t == "gladiator") g.push_back(make_pair(make_pair(u, v), s));
if (t == "sentry") se.push_back(make_pair(make_pair(u, v), s));
if (t == "physician") p.push_back(make_pair(make_pair(u, v), s));
}
if (ss == k) {
int wm, am, om;
vector<string> vw, va, vo, v;
for (int i = 0; i < w.size(); i++) {
v.clear();
for (int j = 0; j < g.size(); j++) {
if (g[j].first.second == w[i].second)
w[i].first.first += g[j].first.first, v.push_back(g[j].second);
}
for (int j = 0; j < se.size(); j++)
if (se[j].first.second == w[i].second) v.push_back(se[j].second);
for (int j = 0; j < p.size(); j++)
if (p[j].first.second == w[i].second) v.push_back(p[j].second);
if (!i || w[i].first.first > w[wm].first.first) wm = i, vw = v;
}
for (int i = 0; i < a.size(); i++) {
v.clear();
for (int j = 0; j < se.size(); j++) {
if (se[j].first.second == a[i].second)
a[i].first.first += se[j].first.first, v.push_back(se[j].second);
}
for (int j = 0; j < g.size(); j++)
if (g[j].first.second == a[i].second) v.push_back(g[j].second);
for (int j = 0; j < p.size(); j++)
if (p[j].first.second == a[i].second) v.push_back(p[j].second);
if (!i || a[i].first.first > a[am].first.first) am = i, va = v;
}
for (int i = 0; i < o.size(); i++) {
v.clear();
for (int j = 0; j < p.size(); j++) {
if (p[j].first.second == o[i].second)
o[i].first.first += p[j].first.first, v.push_back(p[j].second);
}
for (int j = 0; j < g.size(); j++)
if (g[j].first.second == o[i].second) v.push_back(g[j].second);
for (int j = 0; j < se.size(); j++)
if (se[j].first.second == o[i].second) v.push_back(se[j].second);
if (!i || o[i].first.first > o[om].first.first) om = i, vo = v;
}
cout << w[wm].second << " " << vw.size() << " ";
for (int i = 0; i < vw.size(); i++) cout << vw[i] << " ";
cout << endl << a[am].second << " " << va.size() << " ";
for (int i = 0; i < va.size(); i++) cout << va[i] << " ";
cout << endl << o[om].second << " " << vo.size() << " ";
for (int i = 0; i < vo.size(); i++) cout << vo[i] << " ";
} else {
int wm = 0, am = 0, om = 0, gs[11], ses[11], ps[11];
sort(g.begin(), g.end());
sort(se.begin(), se.end());
sort(p.begin(), p.end());
reverse(g.begin(), g.end());
reverse(se.begin(), se.end());
reverse(p.begin(), p.end());
gs[0] = ses[0] = ps[0] = 0;
for (int i = 1; i < 11; i++)
gs[i] = gs[i - 1] + (i <= g.size() ? g[i - 1].first.first : 0);
for (int i = 1; i < 11; i++)
ses[i] = ses[i - 1] + (i <= se.size() ? se[i - 1].first.first : 0);
for (int i = 1; i < 11; i++)
ps[i] = ps[i - 1] + (i <= p.size() ? p[i - 1].first.first : 0);
for (int i = 0; i < w.size(); i++) {
w[i].first.first += gs[w[i].first.second];
if (w[i].first.first > w[wm].first.first) wm = i;
}
for (int i = 0; i < a.size(); i++) {
a[i].first.first += ses[a[i].first.second];
if (a[i].first.first > a[am].first.first) am = i;
}
for (int i = 0; i < o.size(); i++) {
o[i].first.first += ps[o[i].first.second];
if (o[i].first.first > o[om].first.first) om = i;
}
int gn = w[wm].first.second < g.size() ? w[wm].first.second : g.size();
int sen = a[am].first.second < se.size() ? a[am].first.second : se.size();
int pn = o[om].first.second < p.size() ? o[om].first.second : p.size();
int wr = w[wm].first.second - gn, ar = a[am].first.second - sen,
orr = o[om].first.second - pn;
int gc = gn, senc = sen, pc = pn;
vector<string> vw, va, vo;
while (wr) {
if (gc < g.size()) vw.push_back(g[gc++].second), wr--;
if (!wr) break;
if (senc < se.size()) vw.push_back(se[senc++].second), wr--;
if (!wr) break;
if (pc < p.size()) vw.push_back(p[pc++].second), wr--;
if (gc == g.size() && senc == se.size() && pc == p.size()) break;
}
while (ar) {
if (gc < g.size()) va.push_back(g[gc++].second), ar--;
if (!ar) break;
if (senc < se.size()) va.push_back(se[senc++].second), ar--;
if (!ar) break;
if (pc < p.size()) va.push_back(p[pc++].second), ar--;
if (gc == g.size() && senc == se.size() && pc == p.size()) break;
}
while (orr) {
if (gc < g.size()) vo.push_back(g[gc++].second), orr--;
if (!orr) break;
if (senc < se.size()) vo.push_back(se[senc++].second), orr--;
if (!orr) break;
if (pc < p.size()) vo.push_back(p[pc++].second), orr--;
if (gc == g.size() && senc == se.size() && pc == p.size()) break;
}
cout << w[wm].second << " " << gn + vw.size() << " ";
for (int i = 0; i < gn; i++) cout << g[i].second << " ";
for (int i = 0; i < vw.size(); i++) cout << vw[i] << " ";
cout << endl << a[am].second << " " << sen + va.size() << " ";
for (int i = 0; i < sen; i++) cout << se[i].second << " ";
for (int i = 0; i < va.size(); i++) cout << va[i] << " ";
cout << endl << o[om].second << " " << pn + vo.size() << " ";
for (int i = 0; i < pn; i++) cout << p[i].second << " ";
for (int i = 0; i < vo.size(); i++) cout << vo[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool checkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool checkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
map<string, int> wid, rid;
string wname[110], rname[1100];
int inc[1100], val[110], wtype[1100], rtype[1100], sz[1100], loc[1100],
cnt[1100];
vector<int> item[3], res[3];
bool used[1100];
pair<int, int> best[3];
vector<int> ans[110];
inline int get_wtype(const string &s) {
if (s == "weapon") return 0;
if (s == "armor") return 1;
return 2;
}
inline int get_rtype(const string &s) {
if (s == "gladiator") return 0;
if (s == "sentry") return 1;
return 2;
}
inline bool cmp_val(const int &l, const int &r) { return val[l] > val[r]; }
inline bool cmp_inc(const int &l, const int &r) { return inc[l] > inc[r]; }
int main() {
int N, M;
cin >> N;
for (int i = 0; i < (N); ++i) {
string type;
int atk, def, res;
cin >> wname[i] >> type >> atk >> def >> res >> sz[i];
wid[wname[i]] = i;
int tmp;
item[tmp = wtype[i] = get_wtype(type)].push_back(i);
if (tmp == 0) {
val[i] = atk;
} else if (tmp == 1) {
val[i] = def;
} else {
val[i] = res;
}
}
cin >> M;
for (int i = 0; i < (M); ++i) {
string type, locname;
cin >> rname[i] >> type >> inc[i] >> locname;
loc[i] = wid[locname];
cnt[loc[i]]++;
res[rtype[i] = get_rtype(type)].push_back(i);
}
bool found = false;
for (int i = 0; i < (N); ++i) {
if (cnt[i] < sz[i]) {
found = true;
break;
}
}
if (found) {
for (int i = 0; i < (3); ++i) {
sort(res[i].begin(), res[i].end(), cmp_inc);
}
for (int i = 0; i < (N); ++i) {
ans[i].clear();
}
memset(used, false, sizeof(bool) * M);
for (int type = 0; type < (3); ++type) {
best[type] = make_pair((-1), (-1));
for (int i = 0; i < (((int)(item[type].size()))); ++i) {
int sum = val[item[type][i]];
for (int j = 0; j < ((int)(res[type].size())) && j < sz[item[type][i]];
++j) {
sum += inc[res[type][j]];
}
checkmax(best[type], make_pair((sum), (item[type][i])));
}
for (int j = 0;
j < ((int)(res[type].size())) && j < sz[best[type].second]; ++j) {
ans[best[type].second].push_back(res[type][j]);
used[res[type][j]] = true;
}
}
for (int i = 0; i < (M); ++i) {
if (!used[i]) {
for (int j = 0; j < (N); ++j) {
if (((int)(ans[j].size())) < sz[j]) {
ans[j].push_back(i);
break;
}
}
}
}
for (int i = 0; i < (3); ++i) {
cout << wname[best[i].second] << " "
<< ((int)(ans[best[i].second].size()));
for (int j = 0; j < (((int)(ans[best[i].second].size()))); ++j) {
cout << " " << rname[ans[best[i].second][j]];
}
cout << endl;
}
} else {
for (int i = 0; i < (3); ++i) {
for (int j = 0; j < (((int)(res[i].size()))); ++j) {
if (wtype[loc[res[i][j]]] == i) {
val[loc[res[i][j]]] += inc[res[i][j]];
}
}
}
for (int type = 0; type < (3); ++type) {
sort(item[type].begin(), item[type].end(), cmp_val);
cout << wname[item[type][0]] << " " << cnt[item[type][0]];
for (int i = 0; i < (3); ++i) {
for (int j = 0; j < (((int)(res[i].size()))); ++j) {
if (loc[res[i][j]] == item[type][0]) cout << " " << rname[res[i][j]];
}
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, m;
map<string, int> mp;
string name[N];
int state[N], atk[N], def[N], res[N], sz[N];
string name2[N], buffer;
int state2[N], home[N], bonus[N];
vector<int> sv1[3], sv2[3], acc[3];
int tot = 0;
bool vis[N];
vector<int> resid[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> name[i];
cin >> buffer;
if (buffer == "armor")
state[i] = 1;
else if (buffer == "orb")
state[i] = 2;
cin >> atk[i] >> def[i] >> res[i] >> sz[i];
tot += sz[i];
sv1[state[i]].push_back(i);
mp[name[i]] = i;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> name2[i];
cin >> buffer;
if (buffer == "sentry")
state2[i] = 1;
else if (buffer == "physician")
state2[i] = 2;
cin >> bonus[i] >> buffer;
home[i] = mp[buffer];
resid[home[i]].push_back(i);
sv2[state2[i]].push_back(i);
}
auto cmp = [](int x, int y) -> bool { return bonus[x] > bonus[y]; };
for (int i = 0; i < 3; i++) {
sort(sv2[i].begin(), sv2[i].end(), cmp);
if (sv2[i].size()) acc[i].push_back(bonus[sv2[i][0]]);
for (int j = 1; j < sv2[i].size(); j++)
acc[i].push_back(acc[i].back() + bonus[sv2[i][j]]);
}
if (tot == m) {
vector<int> ans(3);
vector<int> v(3);
for (int i = 0; i < sv1[0].size(); i++) {
for (int j = 0; j < sv1[1].size(); j++) {
for (int k = 0; k < sv1[2].size(); k++) {
int ii = sv1[0][i], jj = sv1[1][j], kk = sv1[2][k];
vector<int> init = {atk[ii], def[jj], res[kk]};
for (int f = 0; f < sz[ii]; f++)
if (state2[resid[ii][f]] == 0) init[0] += bonus[resid[ii][f]];
for (int f = 0; f < sz[jj]; f++)
if (state2[resid[jj][f]] == 1) init[1] += bonus[resid[jj][f]];
for (int f = 0; f < sz[kk]; f++)
if (state2[resid[kk][f]] == 2) init[2] += bonus[resid[kk][f]];
if (init > ans) {
ans = init;
v = {ii, jj, kk};
}
}
}
}
for (int j = 0; j < 3; j++) {
cout << name[v[j]] << ' ' << sz[v[j]];
for (int i = 0; i < sz[v[j]]; i++) cout << ' ' << name2[resid[v[j]][i]];
cout << '\n';
}
return 0;
}
vector<int> ans(3);
vector<int> v(3);
for (int i = 0; i < sv1[0].size(); i++) {
for (int j = 0; j < sv1[1].size(); j++) {
for (int k = 0; k < sv1[2].size(); k++) {
int ii = sv1[0][i], jj = sv1[1][j], kk = sv1[2][k];
vector<int> init = {atk[ii], def[jj], res[kk]};
if (acc[0].size())
init[0] += acc[0][min(int(acc[0].size()) - 1, sz[ii] - 1)];
if (acc[1].size())
init[1] += acc[1][min(int(acc[1].size()) - 1, sz[jj] - 1)];
if (acc[2].size())
init[2] += acc[2][min(int(acc[2].size()) - 1, sz[kk] - 1)];
if (init > ans) {
ans = init;
v = {ii, jj, kk};
}
}
}
}
vector<pair<string, vector<string> > > out(3);
out[0].first = name[v[0]];
out[1].first = name[v[1]];
out[2].first = name[v[2]];
int ii = v[0], jj = v[1], kk = v[2];
for (int j = 0; j < 3; j++)
for (int i = 0; i < min(sz[v[j]], int(sv2[j].size())); i++)
out[j].second.push_back(name2[sv2[j][i]]), vis[sv2[j][i]] = true;
for (int j = 0; j < 3; j++)
for (int i = 0; i < m; i++) {
if (vis[i] || out[j].second.size() == sz[v[j]]) continue;
out[j].second.push_back(name2[i]);
vis[i] = true;
}
for (int j = 0; j < 3; j++) {
cout << out[j].first << ' ' << out[j].second.size();
for (int i = 0; i < out[j].second.size(); i++)
cout << ' ' << out[j].second[i];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000")
using namespace std;
const double pi = 3.1415926535897932384626433832795;
char ch[1 << 20];
inline string gs() {
scanf("%s", ch);
return string(ch);
}
inline string gl() {
gets(ch);
return string(ch);
}
inline int gi() {
int x;
scanf("%d", &x);
return x;
}
int gcd(int a, int b) { return !a ? b : gcd(b % a, a); }
const int mod = 1000 * 1000 * 1000 + 9;
inline int MUL(int a, int b) { return 1LL * a * b % mod; }
inline int ADD(int a, int b) { return (a + b >= mod ? a + b - mod : a + b); }
map<string, pair<int, int> > A[3];
map<string, vector<string> > G;
map<string, int> D[3];
int main() {
int n = gi();
for (int i = (0), _b(n); i < _b; ++i) {
string s = gs();
string t = gs();
int a, b, c, z;
scanf("%d%d%d%d", &a, &b, &c, &z);
if (t == "weapon") {
A[0][s] = make_pair(a, z);
} else if (t == "armor") {
A[1][s] = make_pair(b, z);
} else {
A[2][s] = make_pair(c, z);
}
}
int m = gi();
for (int i = (0), _b(m); i < _b; ++i) {
string s, t;
s = gs();
t = gs();
int v = gi();
if (t == "gladiator") {
D[0][s] = v;
} else if (t == "sentry") {
D[1][s] = v;
} else {
D[2][s] = v;
}
string gh = gs();
G[gh].push_back(s);
}
int ok = 0;
for (int i = (0), _b(3); i < _b; ++i)
for (map<string, pair<int, int> >::iterator it = A[i].begin();
it != A[i].end(); ++it) {
if (G[it->first].size() != it->second.second) ok = 1;
}
if (ok) {
string used[3];
vector<string> in[3];
for (int t = (0), _b(3); t < _b; ++t) {
vector<pair<int, string> > V;
for (map<string, int>::iterator it = D[t].begin(); it != D[t].end();
++it) {
V.push_back(make_pair(it->second, it->first));
}
sort(V.rbegin(), V.rend());
string best = "";
int bestv = -1;
vector<string> put;
for (map<string, pair<int, int> >::iterator it = A[t].begin();
it != A[t].end(); ++it) {
int ad = 0;
for (int i = (0), _b(min(it->second.second, (int)V.size())); i < _b;
++i) {
ad += V[i].first;
}
ad += it->second.first;
if (ad > bestv) {
bestv = ad;
put.clear();
for (int i = (0), _b(min(it->second.second, (int)V.size())); i < _b;
++i) {
put.push_back(V[i].second);
}
best = it->first;
}
}
used[t] = best;
in[t] = put;
}
G.clear();
set<string> all;
for (int t = (0), _b(3); t < _b; ++t)
for (map<string, int>::iterator it = D[t].begin(); it != D[t].end(); ++it)
all.insert(it->first);
for (int t = (0), _b(3); t < _b; ++t) {
for (int i = (0), _b(in[t].size()); i < _b; ++i) {
G[used[t]].push_back(in[t][i]);
all.erase(in[t][i]);
}
}
for (int t = (0), _b(3); t < _b; ++t)
for (map<string, pair<int, int> >::iterator it = A[t].begin();
it != A[t].end(); ++it) {
while (all.size() && it->second.second > G[it->first].size()) {
G[it->first].push_back(*all.begin());
all.erase(all.begin());
}
}
}
for (int t = (0), _b(3); t < _b; ++t) {
string bests = "";
int bestv = -1;
for (map<string, pair<int, int> >::iterator it = A[t].begin();
it != A[t].end(); ++it) {
string s = it->first;
int v = it->second.first;
for (int i = (0), _b(G[s].size()); i < _b; ++i) {
if (D[t].count(G[s][i])) v += D[t][G[s][i]];
}
if (v > bestv) {
bestv = v;
bests = s;
}
}
printf("%s %d", bests.c_str(), G[bests].size());
for (int i = (0), _b(G[bests].size()); i < _b; ++i)
printf(" %s", G[bests][i].c_str());
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> th;
map<string, int> rs;
struct thing {
string name;
int cl;
int atk, def, res;
int size;
vector<int> resid;
int full;
void read(int id) {
full = 0;
cin >> name;
string s;
cin >> s;
if (s == "weapon")
cl = 1;
else if (s == "armor")
cl = 2;
else
cl = 3;
cin >> atk >> def >> res >> size;
th[name] = id;
}
};
thing a[200];
struct resident {
string name;
int typ;
string home;
int bonus;
int id;
void read(int _id) {
cin >> name;
string s;
cin >> s;
if (s == "gladiator")
typ = 1;
else if (s == "sentry")
typ = 2;
else
typ = 3;
cin >> bonus;
cin >> home;
int x = th[home];
rs[name] = _id;
a[x].resid.push_back(_id);
a[x].full++;
id = _id;
}
};
resident x[2200];
int n;
int m;
int empty = 1;
vector<int> ans[3];
int anss[4];
int xx[4];
int used[2210];
vector<resident> tt[4];
void update(int i, int j, int k) {
if (empty) {
int cur[4];
memset(cur, 0, sizeof(cur));
int px[3];
px[0] = i, px[1] = j, px[2] = k;
for (int t = 0; t < 3; t++) {
int tek = px[t];
if (a[tek].cl == 1) cur[1] += a[tek].atk;
if (a[tek].cl == 2) cur[2] += a[tek].def;
if (a[tek].cl == 3) cur[3] += a[tek].res;
for (int i = 0; i < a[tek].resid.size(); i++)
if (a[tek].cl == x[a[tek].resid[i]].typ)
cur[a[tek].cl] += x[a[tek].resid[i]].bonus;
}
int ok = 0;
for (int i = 1; i < 4; i++)
if (cur[i] > anss[i]) {
ok = 1;
break;
} else if (cur[i] < anss[i])
break;
if (ok) {
for (int i = 1; i < 4; i++) anss[i] = cur[i];
xx[1] = i, xx[2] = j, xx[3] = k;
for (int i = 0; i < 3; i++) {
ans[i].clear();
int tek = px[i];
for (int j = 0; j < a[tek].resid.size(); j++)
ans[i].push_back(a[tek].resid[j]);
}
}
} else {
int cur[4];
memset(cur, 0, sizeof(cur));
int px[3];
px[0] = i, px[1] = j, px[2] = k;
memset(used, 0, sizeof(used));
for (int i = 0; i < 3; i++) {
int tek = px[i];
if (a[tek].cl == 1) cur[1] += a[tek].atk;
if (a[tek].cl == 2) cur[2] += a[tek].def;
if (a[tek].cl == 3) cur[3] += a[tek].res;
for (int j = 0; j < min((int)a[tek].size, (int)tt[a[tek].cl].size()); j++)
cur[a[tek].cl] += tt[a[tek].cl][j].bonus;
}
int ok = 0;
for (int i = 1; i < 4; i++)
if (cur[i] > anss[i]) {
ok = 1;
break;
} else if (cur[i] < anss[i])
break;
if (ok) {
for (int i = 1; i < 4; i++) anss[i] = cur[i];
xx[1] = i, xx[2] = j, xx[3] = k;
for (int i = 0; i < 3; i++) {
int tek = px[i];
ans[i].clear();
for (int j = 0; j < min((int)a[tek].size, (int)tt[a[tek].cl].size());
j++) {
ans[i].push_back(tt[a[tek].cl][j].id);
used[ans[i].back()] = 1;
}
}
for (int i = 0; i < 3; i++) {
int tek = px[i];
for (int j = 0; j < m && ans[i].size() < a[tek].size; j++)
if (!used[j]) ans[i].push_back(j), used[j] = 1;
}
}
}
}
int cmp(resident a, resident b) { return a.bonus > b.bonus; }
int main() {
xx[1] = xx[2] = xx[3] = -1;
anss[1] = anss[2] = anss[3] = -1;
cin >> n;
for (int i = 0; i < n; i++) a[i].read(i);
cin >> m;
for (int i = 0; i < m; i++) x[i].read(i);
for (int i = 0; i < n; i++)
if (a[i].size != a[i].full) empty = 0;
for (int i = 0; i < m; i++) {
tt[x[i].typ].push_back(x[i]);
}
for (int i = 1; i <= 3; i++) sort(tt[i].begin(), tt[i].end(), cmp);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++) {
int us[4];
us[1] = us[2] = us[3] = 0;
us[a[i].cl] = 1;
us[a[j].cl] = 1;
us[a[k].cl] = 1;
if (us[1] + us[2] + us[3] == 3) {
us[a[i].cl] = i;
us[a[j].cl] = j;
us[a[k].cl] = k;
update(us[1], us[2], us[3]);
}
}
for (int i = 0; i < 3; i++) {
cout << a[xx[i + 1]].name << " " << ans[i].size();
for (int j = 0; j < ans[i].size(); j++) cout << " " << x[ans[i][j]].name;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
string type;
string name;
int atk, def, orb;
int sz;
set<string> residents;
};
struct resident {
string name;
string type;
int power;
string init;
bool used;
};
item s[111];
resident r[1111];
struct Compare {
char x;
Compare(const char x) : x(x) {}
bool operator()(const item &a, const item &b) const {
if (a.type == b.type) {
if (a.type[0] == 'w') return a.atk > b.atk;
if (a.type[0] == 'a') return a.def > b.def;
return a.orb > b.orb;
}
if (a.type[0] == x) return true;
if (b.type[0] == x) return false;
return a.name < b.name;
}
};
struct CompareR {
char x;
explicit CompareR(const char x) : x(x) {}
bool operator()(const resident &a, const resident &b) const {
if (a.type == b.type) {
return a.power > b.power;
}
if (a.type[0] == x) return true;
if (b.type[0] == x) return false;
return a.name < b.name;
}
};
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i].name >> s[i].type >> s[i].atk >> s[i].def >> s[i].orb >>
s[i].sz;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> r[i].name >> r[i].type >> r[i].power >> r[i].init;
if (r[i].type[0] == 'g')
r[i].type = "weapon";
else if (r[i].type[0] == 's')
r[i].type = "armor";
else if (r[i].type[0] == 'p')
r[i].type = "orb";
r[i].used = false;
}
int sizes = 0;
for (int i = 0; i < n; i++) {
sizes += s[i].sz;
}
if (sizes == m) {
for (int i = 0; i < m; i++) {
for (int u = 0; u < n; u++) {
if (r[i].init == s[u].name) {
if (s[u].type == r[i].type) {
if (s[u].type[0] == 'w') {
s[u].atk += r[i].power;
} else if (s[u].type[0] == 'a') {
s[u].def += r[i].power;
} else if (s[u].type[0] == 'o') {
s[u].orb += r[i].power;
}
}
s[u].residents.insert(r[i].name);
}
}
}
} else {
sort(r, r + m, CompareR('w'));
int can = -1;
for (int u = 0;; u++) {
if (r[u].type[0] != 'w') break;
++can;
}
for (int i = 0; i < n; i++) {
if (s[i].type[0] == 'w') {
for (int u = 0; u <= min(can, s[i].sz - 1); u++) {
s[i].atk += r[u].power;
s[i].residents.insert(r[u].name);
r[u].used = true;
}
}
}
sort(r, r + m, CompareR('a'));
can = -1;
for (int u = 0;; u++) {
if (r[u].type[0] != 'a') break;
++can;
}
for (int i = 0; i < n; i++) {
if (s[i].type[0] == 'a') {
for (int u = 0; u <= min(can, s[i].sz - 1); u++) {
s[i].def += r[u].power;
s[i].residents.insert(r[u].name);
r[u].used = true;
}
}
}
sort(r, r + m, CompareR('o'));
can = -1;
for (int u = 0;; u++) {
if (r[u].type[0] != 'o') break;
++can;
}
for (int i = 0; i < n; i++) {
if (s[i].type[0] == 'o') {
for (int u = 0; u <= min(can, s[i].sz - 1); u++) {
s[i].orb += r[u].power;
s[i].residents.insert(r[u].name);
r[u].used = true;
}
}
}
for (int i = 0; i < m; i++) {
if (r[i].used == false) {
for (int u = 0; u < n; u++) {
if (s[u].residents.size() < s[u].sz) {
s[u].residents.insert(r[i].name);
break;
}
}
}
}
}
sort(s, s + n, Compare('w'));
cout << s[0].name << ' ' << s[0].residents.size();
for (set<string>::iterator it = s[0].residents.begin();
it != s[0].residents.end(); ++it)
cout << ' ' << *it;
cout << endl;
sort(s, s + n, Compare('a'));
cout << s[0].name << ' ' << s[0].residents.size();
for (set<string>::iterator it = s[0].residents.begin();
it != s[0].residents.end(); ++it)
cout << ' ' << *it;
cout << endl;
sort(s, s + n, Compare('o'));
cout << s[0].name << ' ' << s[0].residents.size();
for (set<string>::iterator it = s[0].residents.begin();
it != s[0].residents.end(); ++it)
cout << ' ' << *it;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000,1000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
struct item {
string Name, Class;
long long atk, def, res, size;
} x[105];
struct resident {
string Name, Type;
long long bonus;
string Home;
friend bool operator<(resident a, resident b) { return a.bonus > b.bonus; }
} all[1005];
map<string, long long> where;
long long cnt[105];
long long n, m;
vector<resident> atk, def, res;
long long prefa[1005], prefb[1005], prefc[1005];
int main(void) {
cin >> n;
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
cin >> x[i].Name >> x[i].Class >> x[i].atk >> x[i].def >> x[i].res >>
x[i].size;
where[x[i].Name] = i;
}
cin >> m;
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
resident now;
cin >> now.Name >> now.Type >> now.bonus >> now.Home;
all[i] = now;
if (now.Type == "gladiator") atk.push_back(now);
if (now.Type == "sentry") def.push_back(now);
if (now.Type == "physician") res.push_back(now);
cnt[where[now.Home]]++;
}
sort((atk).begin(), (atk).end());
sort((def).begin(), (def).end());
sort((res).begin(), (res).end());
if (atk.size()) prefa[1] = atk[0].bonus;
if (def.size()) prefb[1] = def[0].bonus;
if (res.size()) prefc[1] = res[0].bonus;
for (long long(i) = 0; (i) < (long long)((long long)atk.size() - 1); (i)++)
prefa[i + 2] = prefa[i + 1] + atk[i + 1].bonus;
for (long long(i) = 0; (i) < (long long)((long long)def.size() - 1); (i)++)
prefb[i + 2] = prefb[i + 1] + def[i + 1].bonus;
for (long long(i) = 0; (i) < (long long)((long long)res.size() - 1); (i)++)
prefc[i + 2] = prefc[i + 1] + res[i + 1].bonus;
bool ok = 0;
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
if (cnt[i] != x[i].size) {
ok = 1;
break;
}
}
if (!ok) {
long long ax = 0, bx = 0, cx = 0;
vector<string> name;
for (long long(i) = 0; (i) < (long long)(atk.size()); (i)++)
x[where[atk[i].Home]].atk += atk[i].bonus;
for (long long(i) = 0; (i) < (long long)(def.size()); (i)++)
x[where[def[i].Home]].def += def[i].bonus;
for (long long(i) = 0; (i) < (long long)(res.size()); (i)++)
x[where[res[i].Home]].res += res[i].bonus;
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
if (x[i].Class == "weapon") ax = i;
if (x[i].Class == "armor") bx = i;
if (x[i].Class == "orb") cx = i;
}
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
if (x[i].Class == "weapon" && x[i].atk > x[ax].atk) ax = i;
if (x[i].Class == "armor" && x[i].def > x[bx].def) bx = i;
if (x[i].Class == "orb" && x[i].res > x[cx].res) cx = i;
}
name.clear();
cout << x[ax].Name << " ";
for (long long(i) = 0; (i) < (long long)(m); (i)++)
if (where[all[i].Home] == ax) name.push_back(all[i].Name);
cout << name.size();
if (name.size()) cout << " ";
for (long long(i) = 0; (i) < (long long)(name.size()); (i)++)
cout << name[i] << " ";
cout << endl;
name.clear();
cout << x[bx].Name << " ";
for (long long(i) = 0; (i) < (long long)(m); (i)++)
if (where[all[i].Home] == bx) name.push_back(all[i].Name);
cout << name.size();
if (name.size()) cout << " ";
for (long long(i) = 0; (i) < (long long)(name.size()); (i)++)
cout << name[i] << " ";
cout << endl;
name.clear();
cout << x[cx].Name << " ";
for (long long(i) = 0; (i) < (long long)(m); (i)++)
if (where[all[i].Home] == cx) name.push_back(all[i].Name);
cout << name.size();
if (name.size()) cout << " ";
for (long long(i) = 0; (i) < (long long)(name.size()); (i)++)
cout << name[i] << " ";
cout << endl;
exit(0);
}
long long ax = 0, bx = 0, cx = 0;
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
if (x[i].Class == "weapon") ax = i;
if (x[i].Class == "armor") bx = i;
if (x[i].Class == "orb") cx = i;
}
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
long long mx = min(x[i].size, (long long)atk.size());
long long my = min(x[i].size, (long long)def.size());
long long mz = min(x[i].size, (long long)res.size());
long long gx = min(x[ax].size, (long long)atk.size());
long long gy = min(x[bx].size, (long long)def.size());
long long gz = min(x[cx].size, (long long)res.size());
if (x[i].Class == "weapon" && x[i].atk + prefa[mx] > x[ax].atk + prefa[gx])
ax = i;
if (x[i].Class == "armor" && x[i].def + prefb[my] > x[bx].def + prefb[gy])
bx = i;
if (x[i].Class == "orb" && x[i].res + prefc[mz] > x[cx].res + prefc[gz])
cx = i;
}
vector<string> name;
vector<string> px, py, pz;
long long lx = 0, ly = 0, lz = 0;
name.clear();
for (long long(i) = 0;
(i) < (long long)(min(x[ax].size, (long long)atk.size())); (i)++)
name.push_back(atk[i].Name), lx++;
px = name;
name.clear();
for (long long(i) = 0;
(i) < (long long)(min(x[bx].size, (long long)def.size())); (i)++)
name.push_back(def[i].Name), ly++;
py = name;
name.clear();
for (long long(i) = 0;
(i) < (long long)(min(x[cx].size, (long long)res.size())); (i)++)
name.push_back(res[i].Name), lz++;
pz = name;
while (px.size() < x[ax].size && ly < def.size())
px.push_back(def[ly].Name), ly++;
while (px.size() < x[ax].size && lz < res.size())
px.push_back(res[lz].Name), lz++;
while (py.size() < x[bx].size && lx < atk.size())
py.push_back(atk[lx].Name), lx++;
while (py.size() < x[bx].size && lz < res.size())
py.push_back(res[lz].Name), lz++;
while (pz.size() < x[cx].size && ly < def.size())
pz.push_back(def[ly].Name), ly++;
while (pz.size() < x[cx].size && lx < atk.size())
pz.push_back(atk[lx].Name), lx++;
cout << x[ax].Name << " " << px.size();
if (px.size()) cout << " ";
for (long long(i) = 0; (i) < (long long)(px.size()); (i)++)
cout << px[i] << " ";
cout << endl;
cout << x[bx].Name << " " << py.size();
if (py.size()) cout << " ";
for (long long(i) = 0; (i) < (long long)(py.size()); (i)++)
cout << py[i] << " ";
cout << endl;
cout << x[cx].Name << " " << pz.size();
if (pz.size()) cout << " ";
for (long long(i) = 0; (i) < (long long)(pz.size()); (i)++)
cout << pz[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
int atk;
int def;
int res;
int cap;
string name;
public:
item(int a, int d, int r, int c, string n) {
atk = a;
def = d;
res = r;
cap = c;
name = n;
}
};
vector<item> weapon, shield, orb;
vector<pair<string, int> > gladiator, sentry, physician;
map<string, vector<string> > dict;
int cmp(const pair<string, int> &a, const pair<string, int> &b) {
return a.second > b.second;
}
int cmpweapon(const item &a, const item &b) { return a.atk > b.atk; }
int cmparmor(const item &a, const item &b) { return a.def > b.def; }
int cmporb(const item &a, const item &b) { return a.res > b.res; }
int main() {
int n;
cin >> n;
int totcap = 0;
for (int i = 0; i < n; i++) {
string name, itemclass;
int atk, def, res, cap;
cin >> name >> itemclass >> atk >> def >> res >> cap;
if (itemclass == "weapon") {
weapon.push_back(item(atk, def, res, cap, name));
} else if (itemclass == "armor") {
shield.push_back(item(atk, def, res, cap, name));
} else {
orb.push_back(item(atk, def, res, cap, name));
}
totcap += cap;
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
if (type == "gladiator") {
gladiator.push_back(make_pair(name, bonus));
if (k == totcap)
for (int j = 0; j < weapon.size(); j++)
if (weapon[j].name == home) weapon[j].atk += bonus;
} else if (type == "sentry") {
sentry.push_back(make_pair(name, bonus));
if (k == totcap)
for (int j = 0; j < shield.size(); j++)
if (shield[j].name == home) shield[j].def += bonus;
} else {
physician.push_back(make_pair(name, bonus));
if (k == totcap)
for (int j = 0; j < orb.size(); j++)
if (orb[j].name == home) orb[j].res += bonus;
}
dict[home].push_back(name);
}
if (totcap == k) {
sort(weapon.begin(), weapon.end(), cmpweapon);
sort(shield.begin(), shield.end(), cmparmor);
sort(orb.begin(), orb.end(), cmporb);
cout << weapon[0].name << " " << weapon[0].cap;
for (int i = 0; i < weapon[0].cap; i++)
cout << " " << dict[weapon[0].name][i];
cout << endl;
cout << shield[0].name << " " << shield[0].cap;
for (int i = 0; i < shield[0].cap; i++)
cout << " " << dict[shield[0].name][i];
cout << endl;
cout << orb[0].name << " " << orb[0].cap;
for (int i = 0; i < orb[0].cap; i++) cout << " " << dict[orb[0].name][i];
cout << endl;
return 0;
}
sort(gladiator.begin(), gladiator.end(), cmp);
sort(sentry.begin(), sentry.end(), cmp);
sort(physician.begin(), physician.end(), cmp);
vector<string> junk;
vector<string> w, s, p;
int best1 = 0, pos1 = 0;
for (int i = 0; i < weapon.size(); i++) {
int value = weapon[i].atk;
for (int j = 0; j < weapon[i].cap; j++) {
if (j >= gladiator.size()) break;
value += gladiator[j].second;
}
if (value > best1) {
pos1 = i;
best1 = value;
}
}
for (int i = 0; i < gladiator.size(); i++) {
if (i < weapon[pos1].cap) {
w.push_back(gladiator[i].first);
} else {
junk.push_back(gladiator[i].first);
}
}
int best2 = 0, pos2 = 0;
for (int i = 0; i < shield.size(); i++) {
int value = shield[i].def;
for (int j = 0; j < shield[i].cap; j++) {
if (j >= sentry.size()) break;
value += sentry[j].second;
}
if (value > best2) {
pos2 = i;
best2 = value;
}
}
for (int i = 0; i < sentry.size(); i++) {
if (i < shield[pos2].cap) {
s.push_back(sentry[i].first);
} else {
junk.push_back(sentry[i].first);
}
}
int best3 = 0, pos3 = 0;
for (int i = 0; i < orb.size(); i++) {
int value = orb[i].res;
for (int j = 0; j < orb[i].cap; j++) {
if (j >= physician.size()) break;
value += physician[j].second;
}
if (value > best3) {
pos3 = i;
best3 = value;
}
}
for (int i = 0; i < physician.size(); i++) {
if (i < orb[pos3].cap) {
p.push_back(physician[i].first);
} else {
junk.push_back(physician[i].first);
}
}
int gg = 0;
for (int i = w.size(); i < weapon[pos1].cap && gg < junk.size(); i++)
w.push_back(junk[gg++]);
for (int i = s.size(); i < shield[pos2].cap && gg < junk.size(); i++)
s.push_back(junk[gg++]);
for (int i = p.size(); i < orb[pos3].cap && gg < junk.size(); i++)
p.push_back(junk[gg++]);
cout << weapon[pos1].name << " " << w.size();
for (int i = 0; i < w.size(); i++) cout << " " << w[i];
cout << endl;
cout << shield[pos2].name << " " << s.size();
for (int i = 0; i < s.size(); i++) cout << " " << s[i];
cout << endl;
cout << orb[pos3].name << " " << p.size();
for (int i = 0; i < p.size(); i++) cout << " " << p[i];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char name[1100][1100], name2[1100][1100], type[1100][1100], type2[1100][1100],
home[1100][1100];
int a[1100], b[1100], c[1100], num[1100];
int n, m, k, empty[1100], size[1100], r[1100];
int g[1100][1100], use[1100];
bool cmp(int x, int y) {
if (strcmp(type2[x], type2[y]) != 0) return strcmp(type2[x], type2[y]) < 0;
return num[x] > num[y];
}
void gao(char w, char g, int pos1, int *a, int &id1) {
int max1 = 0, cnt1 = 0;
for (int ii = 0; ii < n; ii++) {
if (type[ii][0] == w) {
int now = a[ii], cnt = 0;
if (pos1 != -1) {
for (int i = pos1; i < k && i < pos1 + size[ii] && type2[r[i]][0] == g;
i++) {
now += num[r[i]];
cnt++;
}
}
if (now >= max1) {
max1 = now;
id1 = ii;
cnt1 = cnt;
}
}
}
}
void findmax(char ss, char ss2, int *a) {
int max = 0, id = 0;
for (int i = 0; i < n; i++) {
if (type[i][0] != ss) continue;
int now = a[i];
for (int j = 0; j < k; j++) {
if (strcmp(home[j], name[i]) == 0) {
if (type2[j][0] == ss2) now += num[j];
}
}
if (now >= max) {
max = now;
id = i;
}
}
printf("%s %d", name[id], empty[id]);
for (int j = 0; j < k; j++) {
if (strcmp(home[j], name[id]) == 0) printf(" %s", name2[j]);
}
printf("\n");
}
int main() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++)
scanf("%s%s%d%d%d%d", name[i], type[i], &a[i], &b[i], &c[i], &size[i]);
scanf("%d", &k);
memset(empty, 0, sizeof(empty));
for (int i = 0; i < k; i++) {
scanf("%s%s%d%s", name2[i], type2[i], &num[i], home[i]);
int id;
for (int j = 0; j < n; j++)
if (strcmp(name[j], home[i]) == 0) id = j;
empty[id]++;
}
bool can = false;
for (int i = 0; i < n; i++)
if (size[i] != empty[i]) can = true;
if (can == false) {
findmax('w', 'g', a);
findmax('a', 's', b);
findmax('o', 'p', c);
} else {
for (int i = 0; i < k; i++) r[i] = i;
sort(r, r + k, cmp);
int pos1 = -1, pos2 = -1, pos3 = -1;
for (int i = 0; i < k; i++) {
if (type2[r[i]][0] == 'g') {
if (i == 0 || type2[r[i - 1]][0] != 'g') pos1 = i;
}
if (type2[r[i]][0] == 's') {
if (i == 0 || type2[r[i - 1]][0] != 's') pos2 = i;
}
if (type2[r[i]][0] == 'p') {
if (i == 0 || type2[r[i - 1]][0] != 'p') pos3 = i;
}
}
int id1, id2, id3;
int max1 = 0, max2 = 0, max3 = 0;
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
gao('w', 'g', pos1, a, id1);
gao('a', 's', pos2, b, id2);
gao('o', 'p', pos3, c, id3);
memset(g, 0, sizeof(g));
memset(use, 0, sizeof(use));
for (int i = pos1; i < k && i < pos1 + size[id1] && type2[r[i]][0] == 'g';
i++) {
g[id1][r[i]] = 1;
use[r[i]] = 1;
cnt1++;
}
for (int i = pos2; i < k && i < pos2 + size[id2] && type2[r[i]][0] == 's';
i++) {
g[id2][r[i]] = 1;
use[r[i]] = 1;
cnt2++;
}
for (int i = pos3; i < k && i < pos3 + size[id3] && type2[r[i]][0] == 'p';
i++) {
g[id3][r[i]] = 1;
use[r[i]] = 1;
cnt3++;
}
if (cnt1 < size[id1]) {
for (int i = 0; i < k; i++)
if (!use[i]) {
use[i] = 1;
g[id1][i] = 1;
cnt1++;
if (cnt1 == size[id1]) break;
}
}
if (cnt2 < size[id2]) {
for (int i = 0; i < k; i++)
if (!use[i]) {
use[i] = 1;
g[id2][i] = 1;
cnt2++;
if (cnt2 == size[id2]) break;
}
}
if (cnt3 < size[id3]) {
for (int i = 0; i < k; i++)
if (!use[i]) {
use[i] = 1;
g[id3][i] = 1;
cnt3++;
if (cnt3 == size[id3]) break;
}
}
printf("%s %d", name[id1], cnt1);
for (int i = 0; i < k; i++)
if (g[id1][i]) printf(" %s", name2[i]);
printf("\n");
printf("%s %d", name[id2], cnt2);
for (int i = 0; i < k; i++)
if (g[id2][i]) printf(" %s", name2[i]);
printf("\n");
printf("%s %d", name[id3], cnt3);
for (int i = 0; i < k; i++)
if (g[id3][i]) printf(" %s", name2[i]);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = ((1 << 31) - 1);
const long long LLINF = (((1LL << 63) - 1LL));
const double eps = 1e-9;
const double PI = 3.14159265358979323846;
struct Item {
string name;
string class_;
int atk, def, res;
int size;
void read() { cin >> name >> class_ >> atk >> def >> res >> size; }
int get(int i) {
if (i == 0) return atk;
if (i == 1) return def;
if (i == 2) return res;
return -1;
}
};
struct Man {
string name, type, home;
int bonus;
void read() { cin >> name >> type >> bonus >> home; }
bool operator<(Man A) const { return bonus < A.bonus; }
};
pair<int, vector<string> > getBest(vector<Item>& items, vector<Man>& men,
int id) {
int best_score = 0;
vector<string> best_men;
int ii = 0;
for (int i = 0; i < items.size(); ++i) {
vector<string> cur_men;
int cur_score = items[i].get(id);
for (int j = 0; j < men.size() && j < items[i].size; ++j) {
cur_score += men[j].bonus;
cur_men.push_back(men[j].name);
}
if (best_score <= cur_score) {
best_score = cur_score;
best_men = cur_men;
ii = i;
}
}
return pair<int, vector<string> >(ii, best_men);
}
int packTo(Item& item, vector<string>& men, vector<Man>& gladiators,
vector<Man>& sentries, vector<Man>& physicians, int& i, int& j,
int& k) {
while (i < gladiators.size() && men.size() < item.size) {
men.push_back(gladiators[i].name);
++i;
}
while (j < sentries.size() && men.size() < item.size) {
men.push_back(sentries[j].name);
++j;
}
while (k < physicians.size() && men.size() < item.size) {
men.push_back(physicians[k].name);
++k;
}
return -1;
}
void printV(vector<string>& s) {
cout << " ";
cout << s.size() << " ";
for (int i = 0; i < s.size(); ++i) printf("%s ", s[i].c_str());
cout << "\n";
}
void printV(vector<Man>& s) {
cout << " ";
cout << s.size() << " ";
for (int i = 0; i < s.size(); ++i) printf("%s ", s[i].name.c_str());
cout << "\n";
}
int main() {
int n;
cin >> n;
vector<Item> weapons;
vector<Item> armors;
vector<Item> orb;
int v = 0;
map<string, pair<int, int> > dict_items;
for (int i = 0; i < n; ++i) {
Item A;
A.read();
if (A.class_[0] == 'w') {
weapons.push_back(A);
dict_items[A.name] = make_pair(0, weapons.size() - 1);
} else if (A.class_[0] == 'a') {
armors.push_back(A);
dict_items[A.name] = make_pair(1, armors.size() - 1);
} else if (A.class_[0] == 'o') {
orb.push_back(A);
dict_items[A.name] = make_pair(2, orb.size() - 1);
} else
assert(false);
v += A.size;
}
vector<Man> gladiators;
vector<Man> sentries;
vector<Man> physicians;
int m;
cin >> m;
vector<vector<Man> > weaponsMen(weapons.size());
vector<vector<Man> > armorsMen(armors.size());
vector<vector<Man> > orbsMen(orb.size());
for (int i = 0; i < m; ++i) {
Man B;
B.read();
int j = dict_items[B.home].second;
int t = dict_items[B.home].first;
if (t == 0)
weaponsMen[j].push_back(B);
else if (t == 1)
armorsMen[j].push_back(B);
else if (t == 2)
orbsMen[j].push_back(B);
if (B.type[0] == 'g')
gladiators.push_back(B);
else if (B.type[0] == 's')
sentries.push_back(B);
else if (B.type[0] == 'p')
physicians.push_back(B);
else
assert(false);
}
if (m == v) {
int best_weapon = -1, best_armor = -1, best_orb = -1;
int best_weapon_index, best_armor_index, best_orb_index;
for (int i = 0; i < weapons.size(); ++i) {
for (int j = 0; j < weaponsMen[i].size(); ++j) {
if (weaponsMen[i][j].type[0] == 'g')
weapons[i].atk += weaponsMen[i][j].bonus;
}
if (best_weapon <= weapons[i].atk) {
best_weapon = weapons[i].atk;
best_weapon_index = i;
}
}
for (int i = 0; i < armors.size(); ++i) {
for (int j = 0; j < armorsMen[i].size(); ++j) {
if (armorsMen[i][j].type[0] == 's')
armors[i].def += armorsMen[i][j].bonus;
}
if (best_armor <= armors[i].def) {
best_armor = armors[i].def;
best_armor_index = i;
}
}
for (int i = 0; i < orb.size(); ++i) {
for (int j = 0; j < orbsMen[i].size(); ++j) {
if (orbsMen[i][j].type[0] == 'p') orb[i].res += orbsMen[i][j].bonus;
}
if (best_orb <= orb[i].res) {
best_orb = orb[i].res;
best_orb_index = i;
}
}
cout << weapons[best_weapon_index].name << " ";
printV(weaponsMen[best_weapon_index]);
cout << armors[best_armor_index].name << " ";
printV(armorsMen[best_armor_index]);
cout << orb[best_orb_index].name << " ";
printV(orbsMen[best_orb_index]);
} else {
sort((gladiators).begin(), (gladiators).end());
reverse((gladiators).begin(), (gladiators).end());
sort((sentries).begin(), (sentries).end());
reverse((sentries).begin(), (sentries).end());
sort((physicians).begin(), (physicians).end());
reverse((physicians).begin(), (physicians).end());
pair<int, vector<string> > a = getBest(weapons, gladiators, 0);
pair<int, vector<string> > b = getBest(armors, sentries, 1);
pair<int, vector<string> > c = getBest(orb, physicians, 2);
int i = a.second.size();
int j = b.second.size();
int k = c.second.size();
packTo(weapons[a.first], a.second, gladiators, sentries, physicians, i, j,
k);
packTo(armors[b.first], b.second, gladiators, sentries, physicians, i, j,
k);
packTo(orb[c.first], c.second, gladiators, sentries, physicians, i, j, k);
cout << weapons[a.first].name;
printV(a.second);
cout << armors[b.first].name;
printV(b.second);
cout << orb[c.first].name;
printV(c.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int k;
bool debug = false;
class rdt {
public:
string name, type, home;
int bonus;
bool operator<(const rdt b) const { return bonus > b.bonus; }
};
class item {
public:
string name, cls;
int atk, def, res, size, ans = 0;
vector<rdt> rs, rsAns;
void pp() {
printf("%s %d ", &name[0], rs.size());
for (auto x : rs) cout << x.name << " ";
puts("");
}
};
map<string, item> wps;
map<string, rdt> rzds;
map<string, vector<rdt>> sortR;
map<string, int> cc, setdown;
item *A, *D, *R;
bool judgeSame(string cls, string type) {
return (cls == "weapon" && type == "gladiator") ||
(cls == "armor" && type == "sentry") ||
(cls == "orb" && type == "physician");
}
string changeType(string type) {
if (type == "gladiator") return "weapon";
if (type == "sentry") return "armor";
if (type == "physician") return "orb";
return "";
}
void gg() {
auto ii = rzds.begin();
for (auto &x : wps) {
item *i = &x.second;
while (i->size > i->rs.size()) {
while (ii != rzds.end() && setdown[ii->first]) ii++;
if (ii == rzds.end()) return;
i->rs.push_back(ii->second);
setdown[ii->first] = 1;
}
if (ii == rzds.end()) return;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
item im;
cin >> im.name >> im.cls >> im.atk >> im.def >> im.res >> im.size;
wps[im.name] = im;
}
cin >> k;
for (int i = 1; i <= k; i++) {
rdt r;
cin >> r.name >> r.type >> r.bonus >> r.home;
rzds[r.name] = r;
cc[r.home]++;
wps[r.home].rs.push_back(r);
if (judgeSame(wps[r.home].cls, r.type)) wps[r.home].ans += r.bonus;
sortR[changeType(r.type)].push_back(r);
}
bool fl = 0;
for (auto x : wps) {
if (x.second.size != cc[x.first]) fl = 1;
}
if (fl) {
for (auto &x : sortR) {
vector<rdt> &v = x.second;
sort(v.begin(), v.end());
}
for (auto &x : wps) {
item *i = &x.second;
i->rs.clear();
i->ans = 0;
for (int j = 0; j < i->size && j < sortR[i->cls].size(); j++) {
i->rs.push_back(sortR[i->cls][j]);
i->ans += sortR[i->cls][j].bonus;
}
if (i->cls == "weapon") {
i->ans += i->atk;
if (A == NULL || A->ans < i->ans) A = i;
} else if (i->cls == "armor") {
i->ans += i->def;
if (D == NULL || D->ans < i->ans) D = i;
} else {
i->ans += i->res;
if (R == NULL || R->ans < i->ans) R = i;
}
}
for (rdt r : A->rs) setdown[r.name] = 1;
for (rdt r : D->rs) setdown[r.name] = 1;
for (rdt r : R->rs) setdown[r.name] = 1;
gg();
} else {
for (auto &x : wps) {
item *i = &x.second;
if (i->cls == "weapon") {
i->ans += i->atk;
if (A == NULL || A->ans < i->ans) A = i;
} else if (i->cls == "armor") {
i->ans += i->def;
if (D == NULL || D->ans < i->ans) D = i;
} else {
i->ans += i->res;
if (R == NULL || R->ans < i->ans) R = i;
}
}
}
A->pp();
D->pp();
R->pp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct subj {
string name;
int sz;
int val;
};
int main() {
int n;
cin >> n;
vector<subj> atk, def, res;
for (int i = 0; i < n; ++i) {
string name, clss;
int i1, i2, i3, sz;
cin >> name >> clss >> i1 >> i2 >> i3 >> sz;
subj cur;
cur.name = name, cur.sz = sz;
if (clss == "weapon") {
cur.val = i1;
atk.push_back(cur);
} else if (clss == "armor") {
cur.val = i2;
def.push_back(cur);
} else if (clss == "orb") {
cur.val = i3;
res.push_back(cur);
}
}
map<string, int> insubj;
map<string, int> insubjv1, insubjv2, insubjv3;
map<string, vector<string> > insubjn;
int k;
cin >> k;
vector<pair<int, string> > ratk, rdef, rres;
for (int i = 0; i < k; ++i) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
insubj[home]++;
insubjn[home].push_back(name);
pair<int, string> cur(bonus, name);
if (type == "gladiator") {
ratk.push_back(cur);
insubjv1[home] += bonus;
} else if (type == "sentry") {
rdef.push_back(cur);
insubjv2[home] += bonus;
} else if (type == "physician") {
rres.push_back(cur);
insubjv3[home] += bonus;
}
}
bool allf = true;
for (size_t i = 0; i < atk.size(); ++i) {
if (atk[i].sz != insubj[atk[i].name]) allf = false;
}
for (size_t i = 0; i < def.size(); ++i) {
if (def[i].sz != insubj[def[i].name]) allf = false;
}
for (size_t i = 0; i < res.size(); ++i) {
if (res[i].sz != insubj[res[i].name]) allf = false;
}
if (allf) {
int mval = -1, mind = -1;
for (size_t i = 0; i < atk.size(); ++i) {
int cv = atk[i].val + insubjv1[atk[i].name];
if (cv > mval) {
mval = cv;
mind = i;
}
}
const vector<string>& v1 = insubjn[atk[mind].name];
cout << atk[mind].name << ' ' << v1.size();
for (size_t i = 0; i < v1.size(); ++i) cout << ' ' << v1[i];
cout << '\n';
mval = -1, mind = -1;
for (size_t i = 0; i < def.size(); ++i) {
int cv = def[i].val + insubjv2[def[i].name];
if (cv > mval) {
mval = cv;
mind = i;
}
}
const vector<string>& v2 = insubjn[def[mind].name];
cout << def[mind].name << ' ' << v2.size();
for (size_t i = 0; i < v2.size(); ++i) cout << ' ' << v2[i];
cout << '\n';
mval = -1, mind = -1;
for (size_t i = 0; i < res.size(); ++i) {
int cv = res[i].val + insubjv3[res[i].name];
if (cv > mval) {
mval = cv;
mind = i;
}
}
const vector<string>& v3 = insubjn[res[mind].name];
cout << res[mind].name << ' ' << v3.size();
for (size_t i = 0; i < v3.size(); ++i) cout << ' ' << v3[i];
cout << '\n';
return 0;
}
sort(ratk.begin(), ratk.end(), greater<pair<int, string> >());
sort(rdef.begin(), rdef.end(), greater<pair<int, string> >());
sort(rres.begin(), rres.end(), greater<pair<int, string> >());
int qatk = -1, qdef = -1, qres = -1;
int natk = -1, ndef = -1, nres = -1;
for (size_t i = 0; i < atk.size(); ++i) {
const subj& th = atk[i];
const vector<pair<int, string> >& vls = ratk;
int csum = th.val;
for (int j = 0; j < (int)vls.size() && j < th.sz; ++j) csum += vls[j].first;
if (csum > qatk) {
qatk = csum;
natk = i;
}
}
for (size_t i = 0; i < def.size(); ++i) {
const subj& th = def[i];
const vector<pair<int, string> >& vls = rdef;
int csum = th.val;
for (int j = 0; j < (int)vls.size() && j < th.sz; ++j) csum += vls[j].first;
if (csum > qdef) {
qdef = csum;
ndef = i;
}
}
for (size_t i = 0; i < res.size(); ++i) {
const subj& th = res[i];
const vector<pair<int, string> >& vls = rres;
int csum = th.val;
for (int j = 0; j < (int)vls.size() && j < th.sz; ++j) csum += vls[j].first;
if (csum > qres) {
qres = csum;
nres = i;
}
}
vector<string> aatk, adef, ares;
int i = 0;
while (i < atk[natk].sz && i < (int)ratk.size()) {
aatk.push_back(ratk[i].second);
++i;
}
ratk.erase(ratk.begin(), ratk.begin() + i);
i = 0;
while (i < def[ndef].sz && i < (int)rdef.size()) {
adef.push_back(rdef[i].second);
++i;
}
rdef.erase(rdef.begin(), rdef.begin() + i);
i = 0;
while (i < res[nres].sz && i < (int)rres.size()) {
ares.push_back(rres[i].second);
++i;
}
rres.erase(rres.begin(), rres.begin() + i);
while (!ratk.empty()) {
string cur = ratk.back().second;
if ((int)adef.size() != def[ndef].sz)
adef.push_back(cur);
else if ((int)ares.size() != res[nres].sz)
ares.push_back(cur);
ratk.pop_back();
}
while (!rdef.empty()) {
string cur = rdef.back().second;
if ((int)aatk.size() != atk[natk].sz)
aatk.push_back(cur);
else if ((int)ares.size() != res[nres].sz)
ares.push_back(cur);
rdef.pop_back();
}
while (!rres.empty()) {
string cur = rres.back().second;
if ((int)aatk.size() != atk[natk].sz)
aatk.push_back(cur);
else if ((int)adef.size() != def[ndef].sz)
adef.push_back(cur);
rres.pop_back();
}
cout << atk[natk].name << ' ' << aatk.size();
for (size_t i = 0; i < aatk.size(); ++i) cout << ' ' << aatk[i];
cout << '\n';
cout << def[ndef].name << ' ' << adef.size();
for (size_t i = 0; i < adef.size(); ++i) cout << ' ' << adef[i];
cout << '\n';
cout << res[nres].name << ' ' << ares.size();
for (size_t i = 0; i < ares.size(); ++i) cout << ' ' << ares[i];
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct thing {
string name;
string type;
int cap;
int val;
vector<pair<string, int> > residents;
thing() {}
thing(string n, string t, int s, int a, int d, int r) {
name = n;
type = t;
cap = s;
if (t == "weapon")
val = a;
else if (t == "armor")
val = d;
else
val = r;
}
};
map<string, thing> things;
thing choose(string type) {
int mx = -1;
for (map<string, thing>::iterator i = things.begin(); i != things.end(); ++i)
if (i->second.type == type) {
if (i->second.val > mx) mx = i->second.val;
}
for (map<string, thing>::iterator i = things.begin(); i != things.end(); ++i)
if (i->second.type == type) {
if (i->second.val == mx) return i->second;
}
}
void update(string type, vector<pair<int, string> >& x) {
for (map<string, thing>::iterator i = things.begin(); i != things.end(); ++i)
if (i->second.type == type) {
thing& t = i->second;
t.residents.clear();
for (int i = 0; i < t.cap && i < (int)x.size(); ++i) {
t.val += x[i].first;
t.residents.push_back(make_pair(x[i].second, x[i].first));
}
}
}
void print(thing t) {
cout << t.name << " " << t.residents.size();
for (int i = 0; i < (int)t.residents.size(); ++i)
cout << " " << t.residents[i].first;
cout << endl;
}
map<string, string> res_type;
void recalc() {
for (map<string, thing>::iterator i = things.begin(); i != things.end();
++i) {
thing& t = i->second;
for (int j = 0; j < (int)t.residents.size(); ++j)
if (res_type[t.residents[j].first] == t.type)
t.val += t.residents[j].second;
}
}
bool stuck() {
for (map<string, thing>::iterator i = things.begin(); i != things.end();
++i) {
if (i->second.cap != (int)i->second.residents.size()) return false;
}
return true;
}
vector<pair<int, string> > atk, def, res;
set<string> all;
int suma[1001];
int sumd[1001];
int sumr[1001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string name, klass;
int a, d, r, s;
cin >> name >> klass >> a >> d >> r >> s;
things[name] = thing(name, klass, s, a, d, r);
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
string name, home, klass;
int b;
cin >> name >> klass >> b >> home;
if (klass == "gladiator") {
atk.push_back(make_pair(b, name));
res_type[name] = "weapon";
} else if (klass == "sentry") {
def.push_back(make_pair(b, name));
res_type[name] = "armor";
} else {
res.push_back(make_pair(b, name));
res_type[name] = "orb";
}
things[home].residents.push_back(make_pair(name, b));
all.insert(name);
}
sort(atk.begin(), atk.end(), greater<pair<int, string> >());
sort(def.begin(), def.end(), greater<pair<int, string> >());
sort(res.begin(), res.end(), greater<pair<int, string> >());
if (stuck()) {
recalc();
thing a = choose("weapon");
thing d = choose("armor");
thing r = choose("orb");
print(a);
print(d);
print(r);
} else {
update("weapon", atk);
update("armor", def);
update("orb", res);
thing a = choose("weapon");
thing d = choose("armor");
thing r = choose("orb");
for (int i = 0; i < a.residents.size(); ++i)
all.erase(a.residents[i].first);
for (int i = 0; i < d.residents.size(); ++i)
all.erase(d.residents[i].first);
for (int i = 0; i < r.residents.size(); ++i)
all.erase(r.residents[i].first);
for (int i = a.residents.size(); i < a.cap && all.size(); ++i) {
string s = *all.begin();
a.residents.push_back(make_pair(s, 0));
all.erase(s);
}
for (int i = d.residents.size(); i < d.cap && all.size(); ++i) {
string s = *all.begin();
d.residents.push_back(make_pair(s, 0));
all.erase(s);
}
for (int i = r.residents.size(); i < r.cap && all.size(); ++i) {
string s = *all.begin();
r.residents.push_back(make_pair(s, 0));
all.erase(s);
}
print(a);
print(d);
print(r);
}
return 0;
}
|
#include <bits/stdc++.h>
int N, K;
std::map<std::string, int> nconv, kconv;
std::string nlst[110], klst[1110];
int ncnt, kcnt;
inline int nget(std::string& b) {
int rt = nconv[b];
if (rt == 0) {
ncnt++;
nconv[b] = rt = ncnt;
nlst[rt] = b;
}
return rt;
}
inline int kget(std::string& b) {
int rt = kconv[b];
if (rt == 0) {
kcnt++;
kconv[b] = rt = kcnt;
klst[rt] = b;
}
return rt;
}
int ntype[110], nval[3][110], nsize[110], tmp[110];
std::vector<int> nlive[110];
int ktype[1110], kadd[1110], bel[1110];
std::vector<std::pair<int, int> > lst[3];
std::vector<int> ans[3];
int used[1110];
int main() {
std::cin >> N;
int kcount = 0;
for (int i = 0; i < N; i++) {
std::string sn, stype;
std::cin >> sn >> stype;
int no = nget(sn);
std::cin >> nval[0][no] >> nval[1][no] >> nval[2][no] >> nsize[no];
if (stype[0] == 'w') ntype[no] = 0;
if (stype[0] == 'a') ntype[no] = 1;
if (stype[0] == 'o') ntype[no] = 2;
kcount += nsize[no];
}
std::cin >> K;
for (int i = 0; i < K; i++) {
std::string sk, stype, sbl;
std::cin >> sk >> stype;
int no = kget(sk), fno;
if (stype[0] == 'g') ktype[no] = 0;
if (stype[0] == 's') ktype[no] = 1;
if (stype[0] == 'p') ktype[no] = 2;
std::cin >> kadd[no] >> sbl;
fno = bel[no] = nget(sbl);
if (ktype[no] == ntype[fno]) tmp[fno] += kadd[no];
nlive[fno].push_back(no);
lst[ktype[no]].push_back(std::make_pair(kadd[no], no));
}
if (kcount == K) {
int mmax[3], mpos[3];
mmax[0] = mmax[1] = mmax[2] = -1;
for (int i = 1; i <= ncnt; i++) {
int nt = ntype[i];
if (tmp[i] + nval[nt][i] > mmax[nt]) {
mmax[nt] = tmp[i] + nval[nt][i];
mpos[nt] = i;
}
}
for (int i = 0; i < 3; i++) {
int mp = mpos[i];
std::cout << nlst[mp] << ' ' << nlive[mp].size();
for (int j = nlive[mp].size() - 1; j >= 0; j--)
std::cout << ' ' << klst[nlive[mp][j]];
std::cout << '\n';
}
} else {
for (int i = 0; i < 3; i++) std::sort(lst[i].begin(), lst[i].end());
int mmax[3], mpos[3], mpchd[3];
mmax[0] = mmax[1] = mmax[2] = -1;
for (int i = 1; i <= ncnt; i++) {
int nt = ntype[i], nv, nchd = nsize[i];
nv = nval[nt][i];
if (nchd > lst[nt].size()) nchd = lst[nt].size();
int lsize = lst[nt].size();
for (int j = 0; j < nchd; j++) nv += lst[nt][lsize - j - 1].first;
if (nv > mmax[nt]) {
mmax[nt] = nv;
mpos[nt] = i;
mpchd[nt] = nchd;
}
}
for (int i = 0; i < 3; i++) {
int lsize = lst[i].size();
for (int j = 0; j < mpchd[i]; j++) {
ans[i].push_back(lst[i][lsize - j - 1].second);
used[lst[i][lsize - j - 1].second] = true;
}
}
for (int i = 0; i < 3; i++) {
for (int j = 1; j <= kcnt; j++) {
if (ans[i].size() == nsize[mpos[i]]) break;
if (used[j]) continue;
used[j] = true;
ans[i].push_back(j);
}
}
for (int i = 0; i < 3; i++) {
int mp = mpos[i];
std::cout << nlst[mp] << ' ' << ans[i].size();
int lsize = lst[i].size();
for (int j = 0; j < ans[i].size(); j++)
std::cout << ' ' << klst[ans[i][j]];
std::cout << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
vector<int> p;
vector<vector<pair<int, int> > > gr;
vector<int> x;
int dsu_get(int v) { return (v == p[v]) ? v : (p[v] = dsu_get(p[v])); }
void dsu_unite(int a, int b) {
a = dsu_get(a);
b = dsu_get(b);
if (rand() & 1) swap(a, b);
if (a != b) p[a] = b;
}
vector<int> marked;
vector<char> used;
void dfs(int v) {
marked[v] = 1;
for (int i = 0; i < gr[v].size(); i++)
if (!marked[gr[v][i].first]) {
dfs(gr[v][i].first);
if (marked[gr[v][i].first] == 2) {
used[gr[v][i].second] = true;
marked[v] = 2;
}
}
if (x[v]) {
marked[v] = 2;
}
}
int main() {
srand(time(NULL));
int n, m, k;
cin >> n >> m >> k;
gr.resize(n);
x.resize(n, 0);
int xf = 0;
for (int i = 0; i < k; i++) {
int ff;
cin >> ff;
ff--;
x[ff] = 1;
xf = ff;
}
vector<pair<int, pair<int, int> > > g;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
g.push_back(make_pair(w, make_pair(v, u)));
}
int cost = 0;
vector<pair<int, pair<int, int> > > res;
sort(g.begin(), g.end());
p.resize(n, 0);
for (int i = 0; i < n; ++i) p[i] = i;
for (int i = 0; i < m; ++i) {
int a = g[i].second.first, b = g[i].second.second, l = g[i].first;
if (dsu_get(a) != dsu_get(b)) {
cost += l;
res.push_back(make_pair(g[i].first, g[i].second));
dsu_unite(a, b);
}
}
sort(res.begin(), res.end());
marked.resize(n, false);
used.resize(res.size(), false);
for (int i = 0; i < res.size(); i++) {
gr[res[i].second.first].push_back(make_pair(res[i].second.second, i));
gr[res[i].second.second].push_back(make_pair(res[i].second.first, i));
}
dfs(xf);
int ans = 0;
for (int i = res.size() - 1; i >= 0; i--)
if (used[i]) {
ans = res[i].first;
break;
}
for (int i = 0; i < k; i++) cout << ans << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k;
set<long long int> x;
vector<pair<long long int, long long int>> adj[1000001];
long long int par[1000001];
vector<pair<long long int, pair<long long int, long long int>>> l;
long long int find(long long int x) {
if (par[x] == 0) {
return x;
}
return par[x] = find(par[x]);
}
long long int ans;
long long int vis[10000001];
void dfs(long long int cur, long long int mx) {
if (x.find(cur) != x.end()) {
ans = max(ans, mx);
}
vis[cur] = 1;
long long int i, j;
for (i = 0; i < adj[cur].size(); ++i) {
if (!vis[adj[cur][i].first]) {
dfs(adj[cur][i].first, max(mx, adj[cur][i].second));
}
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
long long int i, j;
long long int u, v, w;
for (i = 1; i <= k; ++i) {
cin >> j;
x.insert(j);
}
for (i = 1; i <= m; ++i) {
cin >> u >> v >> w;
l.push_back(make_pair(w, make_pair(u, v)));
}
sort(l.begin(), l.end());
for (i = 0; i < l.size(); ++i) {
long long int a, b;
a = find(l[i].second.first);
b = find(l[i].second.second);
if (a != b) {
par[a] = b;
adj[l[i].second.first].push_back(
make_pair(l[i].second.second, l[i].first));
adj[l[i].second.second].push_back(
make_pair(l[i].second.first, l[i].first));
}
}
set<long long int>::iterator it = x.begin();
dfs(*it, 0);
for (i = 1; i <= k; ++i) cout << ans << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, k, byk[N];
int par[N];
pair<int, pair<int, int> > edge[N];
int now;
int find(int u) {
if (par[u] == u) return u;
return par[u] = find(par[u]);
}
void merge(int x, int y) {
byk[find(x)] += byk[find(y)];
byk[find(y)] = 0;
par[find(y)] = find(x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
par[i] = i;
}
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
byk[x]++;
}
for (int i = 1; i <= m; i++) {
int a, b, w;
cin >> a >> b >> w;
edge[i] = {w, {a, b}};
}
int ans = 0;
sort(edge + 1, edge + m + 1);
for (int i = 1; i <= m; i++) {
pair<int, pair<int, int> > isi = edge[i];
if (find(isi.second.first) == find(isi.second.second)) continue;
now = isi.first;
merge(isi.second.first, isi.second.second);
if (byk[find(isi.second.first)] == k) {
ans = now;
break;
}
}
for (int i = 1; i <= k; i++) {
cout << ans << " ";
}
cout << endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.