text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
namespace std {
template <>
struct hash<pair<int, int>> {
size_t operator()(const pair<int, int> &p) const {
return hash<int>()(p.first) ^ hash<int>()(p.second);
}
};
} // namespace std
constexpr int kMinusInf = numeric_limits<int>::min();
template <typename Func>
void ForAllRec(int k, Func f, vector<int> &choice) {
if (k == 0) {
f(choice);
} else {
for (int i = 0; i < (3); ++i) {
choice[k - 1] = i;
ForAllRec(k - 1, f, choice);
}
}
}
template <typename Func>
void ForAll(int k, Func f) {
vector<int> choice(k);
ForAllRec(k, f, choice);
}
void GetSum(const vector<vector<int>> &numbers, const vector<int> &choice,
int &a, int &b, int &c) {
a = b = c = 0;
int ar[3] = {0, 0, 0};
int ars[3] = {0, 0, 0};
for (int i = 0; i < (numbers.size()); ++i) {
for (int j = 0; j < (3); ++j) {
ars[j] += numbers[i][j];
}
ar[choice[i]] += numbers[i][choice[i]];
}
a = ars[0] - ar[0];
b = ars[1] - ar[1];
c = ars[2] - ar[2];
}
string Excl(int i) {
const static string s = "LMW";
string res = s;
res.erase(res.begin() + i);
return res;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
cin >> n;
vector<vector<int>> deltas1(n / 2, vector<int>(3, 0));
vector<vector<int>> deltas2(n - n / 2, vector<int>(3, 0));
for (int i = 0; i < (n); ++i) {
if (i < n / 2) {
cin >> deltas1[i][0] >> deltas1[i][1] >> deltas1[i][2];
} else {
cin >> deltas2[i - n / 2][0] >> deltas2[i - n / 2][1] >>
deltas2[i - n / 2][2];
}
}
unordered_map<pair<int, int>, int> m;
auto fill = [&m, &deltas1](const vector<int> &choice) {
int a, b, c;
GetSum(deltas1, choice, a, b, c);
auto p = make_pair(a - b, a - c);
if (m.find(p) != m.end()) {
m[p] = max(m[p], a);
} else {
m[p] = a;
}
};
int best = kMinusInf;
vector<int> best_choice2;
pair<int, int> best_p1;
int best_a1;
auto find2 = [&m, &best, &deltas2, &best_choice2, &best_p1,
&best_a1](const vector<int> &choice) {
int a, b, c;
GetSum(deltas2, choice, a, b, c);
auto p = make_pair(b - a, c - a);
auto it = m.find(p);
if (it != m.end()) {
if (it->second + a > best) {
best = it->second + a;
best_p1 = it->first;
best_a1 = it->second;
best_choice2 = choice;
}
}
};
vector<int> best_choice1;
auto find1 = [&m, &deltas1, &best_p1, &best_a1,
&best_choice1](const vector<int> &choice) {
int a, b, c;
GetSum(deltas1, choice, a, b, c);
auto p = make_pair(a - b, a - c);
if (best_p1 == p && best_a1 == a) {
best_choice1 = choice;
}
};
ForAll(n / 2, fill);
ForAll(n - n / 2, find2);
ForAll(n / 2, find1);
if (best == kMinusInf) {
cout << "Impossible\n";
} else {
for (int excl : best_choice1) {
cout << Excl(excl) << '\n';
}
for (int excl : best_choice2) {
cout << Excl(excl) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[30], m[30], w[30], n, ans, flag, ans1[30], a[30];
long long g[30], pos;
map<pair<int, int>, int> mp, mp1;
void dfs(int x, int X, int L, int M, int W, long long t) {
if (x > X) {
int p1 = L - M, p2 = L - W;
if (mp.find(pair<int, int>(p1, p2)) == mp.end())
mp[pair<int, int>(p1, p2)] = L, mp1[pair<int, int>(p1, p2)] = t;
else if (mp[pair<int, int>(p1, p2)] < L) {
mp[pair<int, int>(p1, p2)] = L;
mp1[pair<int, int>(p1, p2)] = t;
}
return;
}
dfs(x + 1, X, L + l[x], M + m[x], W, t * 3);
dfs(x + 1, X, L + l[x], M, W + w[x], t * 3 + 1);
dfs(x + 1, X, L, M + m[x], W + w[x], t * 3 + 2);
}
void dfs1(int x, int X, int L, int M, int W, long long t) {
if (x > X) {
int p1 = L - M, p2 = L - W;
if (mp.find(pair<int, int>(-p1, -p2)) != mp.end())
if (flag == 0 || L + mp[pair<int, int>(-p1, -p2)] > ans) {
flag = 1;
ans = L + mp[pair<int, int>(-p1, -p2)];
pos = mp1[pair<int, int>(-p1, -p2)] * g[n - n / 2] + t;
}
return;
}
dfs1(x + 1, X, L + l[x], M + m[x], W, t * 3);
dfs1(x + 1, X, L + l[x], M, W + w[x], t * 3 + 1);
dfs1(x + 1, X, L, M + m[x], W + w[x], t * 3 + 2);
}
int main() {
g[0] = 1;
for (int i = 1; i <= 14; i++) g[i] = g[i - 1] * 3;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &l[i], &m[i], &w[i]);
}
dfs(1, n / 2, 0, 0, 0, 0);
dfs1(n / 2 + 1, n, 0, 0, 0, 0);
if (flag == 0)
printf("Impossible\n");
else {
cerr << ans << endl;
for (int i = n; i >= 1; i--) ans1[i] = pos % 3, pos /= 3;
for (int i = 1; i <= n; i++) {
if (ans1[i] == 0) printf("LM\n");
if (ans1[i] == 1) printf("LW\n");
if (ans1[i] == 2) printf("MW\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, pair<pair<int, int>, pair<int, long long> > > part1;
map<pair<int, int>, bool> visitPart1;
int n;
int l[30], m[30], w[30];
long long s1 = -1, s2 = -1;
long long ma = -20000000000000;
void gen(int idx, int a, int b, int c, long long seq) {
if (idx == n / 2) {
int x = a - b, y = a - c;
pair<pair<int, int>, pair<int, long long> > &temp = part1[make_pair(x, y)];
bool &visit = visitPart1[make_pair(x, y)];
if (!visit) {
temp = make_pair(make_pair(a, b), make_pair(c, seq));
visit = true;
return;
}
pair<pair<int, int>, pair<int, long long> > t = temp;
if (t.first.first + t.first.second + t.second.first < a + b + c) {
temp = make_pair(make_pair(a, b), make_pair(c, seq));
}
return;
}
gen(idx + 1, a + l[idx], b + m[idx], c, seq * 10LL + 1LL);
gen(idx + 1, a + l[idx], b, c + w[idx], seq * 10LL + 2LL);
gen(idx + 1, a, b + m[idx], c + w[idx], seq * 10LL + 3LL);
}
void dfs(int idx, int a, int b, int c, long long seq) {
if (idx == n) {
int x = b - a, y = c - a;
if (!visitPart1[make_pair(x, y)]) {
return;
}
pair<pair<int, int>, pair<int, long long> > t = part1[make_pair(x, y)];
int ans = a + t.first.first + b + t.first.second + c + t.second.first;
if (ans > ma) {
s1 = t.second.second, s2 = seq;
ma = ans;
}
return;
}
dfs(idx + 1, a + l[idx], b + m[idx], c, seq * 10LL + 1LL);
dfs(idx + 1, a + l[idx], b, c + w[idx], seq * 10LL + 2LL);
dfs(idx + 1, a, b + m[idx], c + w[idx], seq * 10LL + 3LL);
}
void print(string second) {
for (int i = 0; i < second.size(); i++) {
if (second[i] == '1') {
printf("LM\n");
} else if (second[i] == '2') {
printf("LW\n");
} else
printf("MW\n");
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &l[i], &m[i], &w[i]);
}
gen(0, 0, 0, 0, 0);
dfs(n / 2, 0, 0, 0, 0);
if (s1 == -1 && s2 == -1) {
cout << "Impossible\n";
return 0;
}
string alt1 = "", alt2 = "";
while (s1) {
alt1 += (s1 % 10 + '0');
s1 /= 10;
}
while (s2) {
alt2 += (s2 % 10 + '0');
s2 /= 10;
}
reverse(alt1.begin(), alt1.end());
reverse(alt2.begin(), alt2.end());
print(alt1), print(alt2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> l(n), m(n), w(n);
map<pair<long long, long long>, pair<int, long long> > mp;
for (int i = 0; i < n; i++) scanf("%d %d %d", &l[i], &m[i], &w[i]);
for (int i = 0; i < pow(3, n / 2); i++) {
long long a = 0, b = 0, c = 0;
int t = i;
for (int j = 0; j < (n / 2); j++) {
if (t % 3 == 0) {
a += l[j];
b += m[j];
} else if (t % 3 == 1) {
a += l[j];
c += w[j];
} else {
b += m[j];
c += w[j];
}
t /= 3;
}
map<pair<long long, long long>, pair<int, long long> >::iterator iter =
mp.find(make_pair(b - a, c - b));
if (iter == mp.end())
mp.insert(make_pair(make_pair(b - a, c - b), make_pair(i, a)));
else if ((iter->second).second < a)
(iter->second) = make_pair(i, a);
}
int result_str1 = 0;
int result_str2 = 0;
long long result_mx = -2000000000;
for (int i = 0; i < pow(3, (n + 1) / 2); i++) {
long long a = 0, b = 0, c = 0;
int t = i;
for (int j = 0; j < ((n + 1) / 2); j++) {
if (t % 3 == 0) {
a += l[(n / 2) + j];
b += m[(n / 2) + j];
} else if (t % 3 == 1) {
a += l[(n / 2) + j];
c += w[(n / 2) + j];
} else {
b += m[(n / 2) + j];
c += w[(n / 2) + j];
}
t /= 3;
}
map<pair<long long, long long>, pair<int, long long> >::iterator iter =
mp.find(make_pair(a - b, b - c));
if (iter != mp.end()) {
long long result_mx_here = a + (iter->second).second;
if (result_mx_here > result_mx) {
result_str1 = (iter->second).first;
result_str2 = i;
result_mx = result_mx_here;
}
}
}
if (result_mx == -2000000000)
printf("Impossible");
else {
for (int i = 0; i < (n / 2); i++) {
if (result_str1 % 3 == 0)
printf("LM\n");
else if (result_str1 % 3 == 1)
printf("LW\n");
else
printf("MW\n");
result_str1 /= 3;
}
for (int i = 0; i < ((n + 1) / 2); i++) {
if (result_str2 % 3 == 0)
printf("LM\n");
else if (result_str2 % 3 == 1)
printf("LW\n");
else
printf("MW\n");
result_str2 /= 3;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a = 0, b = 0, c = 0;
map<pair<int, int>, long long> mxa, vst;
int izm[30][5];
void rec1(int p, long long d) {
if (p == k) {
if (!vst.count(make_pair(a - b, b - c)) ||
a > mxa[make_pair(a - b, b - c)]) {
mxa[make_pair(a - b, b - c)] = a;
vst[make_pair(a - b, b - c)] = d;
}
return;
}
a += izm[p][0], b += izm[p][1];
rec1(p + 1, d * 10 + 1);
b -= izm[p][1], c += izm[p][2];
rec1(p + 1, d * 10 + 2);
a -= izm[p][0], b += izm[p][1];
rec1(p + 1, d * 10 + 3);
b -= izm[p][1];
c -= izm[p][2];
}
bool gh = 0;
long long rez1, rez2, mx;
void rec2(int p, long long d) {
if (p == n) {
if (vst.count(make_pair(b - a, c - b))) {
if (!gh || mx < mxa[make_pair(b - a, c - b)] + a) {
mx = mxa[make_pair(b - a, c - b)] + a;
rez1 = vst[make_pair(b - a, c - b)];
rez2 = d;
}
gh = 1;
}
return;
}
a += izm[p][0], b += izm[p][1];
rec2(p + 1, d * 10 + 1);
b -= izm[p][1], c += izm[p][2];
rec2(p + 1, d * 10 + 2);
a -= izm[p][0], b += izm[p][1];
rec2(p + 1, d * 10 + 3);
b -= izm[p][1];
c -= izm[p][2];
}
string ser(int a) {
if (a == 1) return "LM";
if (a == 2) return "LW";
if (a == 3) return "MW";
}
int main() {
cin >> n;
k = n / 2;
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= 2; j++) cin >> izm[i][j];
rec1(0, 0);
a = 0, b = 0, c = 0;
rec2(k, 0);
if (!gh) return cout << "Impossible", 0;
stack<int> rt;
while (rez2) {
rt.push(rez2 % 10);
rez2 /= 10;
}
while (rez1) {
rt.push(rez1 % 10);
rez1 /= 10;
}
while (!rt.empty()) {
cout << ser(rt.top()) << endl;
rt.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct triple {
int a, b, c;
triple() : a(0), b(0), c(0) {}
triple(int a, int b, int c) : a(a), b(b), c(c) {}
};
namespace std {
template <>
class hash<pair<int, int> > {
public:
size_t operator()(const pair<int, int>& p) const {
return hash<int>()(p.first) ^ hash<int>()(p.second);
}
};
}; // namespace std
template <typename Comparer>
bool gen(const vector<triple>& v, Comparer comp, int pos,
vector<pair<char, char> >& ans, triple& val) {
if (pos == v.size()) return comp(ans, val);
ans[pos] = {'L', 'M'};
val.a += v[pos].a;
val.b += v[pos].b;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.b -= v[pos].b;
ans[pos] = {'L', 'W'};
val.a += v[pos].a;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.c -= v[pos].c;
ans[pos] = {'M', 'W'};
val.b += v[pos].b;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.b -= v[pos].b;
val.c -= v[pos].c;
return true;
}
template <typename Comparer>
void launch_gen(const vector<triple>& v, Comparer comp) {
vector<pair<char, char> > ans(v.size());
triple val;
gen(v, comp, 0, ans, val);
}
unordered_map<pair<int, int>, pair<int, vector<pair<char, char> > > > m;
int best = -1234567890;
vector<pair<char, char> > res;
bool map_putter(const vector<pair<char, char> >& ans, const triple& val) {
pair<int, int> p(val.a - val.b, val.b - val.c);
if (!m.count(p) || val.c > m[p].first) m[p] = make_pair(val.c, ans);
return true;
}
bool ans_seeker(const vector<pair<char, char> >& ans, const triple& val) {
pair<int, int> p(val.b - val.a, val.c - val.b);
if (m.count(p)) {
auto& ptr = m[p];
if (ptr.first + val.c > best) {
best = ptr.first + val.c;
res.clear();
res.insert(res.end(), ptr.second.begin(), ptr.second.end());
res.insert(res.end(), ans.begin(), ans.end());
}
}
return true;
}
int main() {
int n;
cin >> n;
vector<triple> v1, v2;
for (int i = 0; i < n; i++) {
triple t;
cin >> t.a >> t.b >> t.c;
((i < (n / 2)) ? v1 : v2).push_back(t);
}
launch_gen(v1, map_putter);
launch_gen(v2, ans_seeker);
if (res.empty())
cout << "Impossible" << endl;
else
for (auto it : res) cout << it.first << it.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct mypair {
T x, y;
public:
mypair() : x(0), y(0) {}
mypair(T x, T y) : x(x), y(y) {}
bool operator<(const mypair<T> &o) const {
return (x == o.x) ? (y < o.y) : (x < o.x);
}
bool operator>(const mypair<T> &o) const { return o < *this; }
bool operator!=(const mypair<T> &o) const {
return (*this < o) || (o < *this);
}
bool operator==(const mypair<T> &o) const { return !(*this != o); }
mypair<T> operator+(const mypair<T> &o) {
return mypair<T>(x + o.x, y + o.y);
}
mypair<T> operator*(const long long &n) const {
return mypair<T>(n * x, n * y);
}
mypair<T> operator/(const long long &n) const {
return mypair<T>(x / n, y / n);
}
mypair<T> operator-(const mypair<T> &o) const { return *this + (-1LL) * o; }
long long operator*(const mypair<T> &o) const {
return x * 1LL * o.x + y * 1LL * o.y;
}
long long cross(const mypair<T> &o) { return x * 1LL * o.y - y * 1LL * o.x; }
mypair<T> conj() { return mypair<T>(x, -y); }
mypair<T> operator/(const mypair<T> &o) const {
return (*this * o.conj()) / hypot(o.x, o.y);
}
double angle() {
double t = atan2(y, x);
if (t < 0) t += acos(-1);
return t;
}
friend ostream &operator<<(ostream &stream, const mypair<T> &p) {
stream << "(" << p.x << " ," << p.y << ")";
return stream;
}
friend istream &operator>>(istream &stream, mypair<T> &p) {
stream >> p.x >> p.y;
return stream;
}
friend void swap(mypair<T> &u, mypair<T> &v) {
using std::swap;
u.x ^= v.x ^= u.x ^= v.x;
u.y ^= v.y ^= u.y ^= v.y;
}
};
long long L[25], M[25], W[25];
unordered_map<
long long,
unordered_map<long long,
pair<long long, vector<pair<int, pair<int, int> > > > > >
F;
vector<pair<int, pair<int, int> > > RR, LL;
long long tot = LLONG_MIN;
void insert(long long a, long long b, long long c,
vector<pair<int, pair<int, int> > > &C) {
if (F.find(a) == F.end())
F[a] =
unordered_map<long long,
pair<long long, vector<pair<int, pair<int, int> > > > >();
if (F[a].find(b) == F[a].end()) F[a][b] = make_pair(c, C);
if (F[a][b].first < c) F[a][b] = make_pair(c, C);
}
void contains(long long a, long long b, long long c,
vector<pair<int, pair<int, int> > > &C) {
if (F.find(a) == F.end()) return;
if (F[a].find(b) == F[a].end()) return;
if (c + F[a][b].first >= tot) {
tot = c + F[a][b].first;
LL = F[a][b].second;
RR = C;
}
}
void generate(int i, int n, vector<pair<int, pair<int, int> > > &C,
long long *L, long long *M, long long *W, bool cond) {
if (i == n) {
long long a = 0, b = 0, c = 0;
for (int j = 0; j < (n); j++) {
auto &p = C[j];
a += p.first * L[j];
b += p.second.first * M[j];
c += p.second.second * W[j];
}
if (cond)
insert(a - b, b - c, a, C);
else
contains(b - a, c - b, a, C);
return;
}
C[i].first = 1;
C[i].second.first = 1;
C[i].second.second = 0;
generate(i + 1, n, C, L, M, W, cond);
C[i].first = 1;
C[i].second.first = 0;
C[i].second.second = 1;
generate(i + 1, n, C, L, M, W, cond);
C[i].first = 0;
C[i].second.first = 1;
C[i].second.second = 1;
generate(i + 1, n, C, L, M, W, cond);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); i++) scanf("%I64d %I64d %I64d", L + i, M + i, W + i);
if (n == 1) {
if (L[0] == M[0] && M[0] == 0)
cout << "LM" << endl;
else if (L[0] == W[0] && W[0] == 0)
cout << "LW" << endl;
else if (M[0] == W[0] && W[0] == 0)
cout << "MW" << endl;
else
cout << "Impossible" << endl;
return 0;
}
vector<pair<int, pair<int, int> > > C(n / 2);
generate(0, n / 2, C, L, M, W, 1);
C.resize(n - (n / 2));
generate(0, n - (n / 2), C, L + (n / 2), M + (n / 2), W + (n / 2), 0);
if (LL.empty())
puts("Impossible");
else {
for (auto p : LL) {
if (p.first) putchar('L');
if (p.second.first) putchar('M');
if (p.second.second) putchar('W');
puts("");
}
for (auto p : RR) {
if (p.first) putchar('L');
if (p.second.first) putchar('M');
if (p.second.second) putchar('W');
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int base = 3;
struct node {
long long y, z;
node(long long a, long long b) {
y = a;
z = b;
}
bool operator<(const node &head) const {
return head.y == y ? head.z < z : head.y < y;
}
};
map<node, int> mp;
struct info {
int choice;
long long x;
} f[2000001];
int m, n;
int has = 0;
struct self {
int x, y, z;
} s[33];
long long ans;
int choicex, choicey;
void predfs(int dep, long long x, long long y, long long z, int choice) {
if (dep == n + 1) {
y -= x;
z -= x;
node t = node(y, z);
if (mp.find(t) != mp.end()) {
int pos = mp[t];
if (f[pos].x < x) {
f[pos].x = x;
f[pos].choice = choice;
}
} else {
has++;
mp[t] = has;
f[has].x = x;
f[has].choice = choice;
}
return;
}
for (int k = 0; k <= 2; k++) {
if (k == 0) {
predfs(dep + 1, x + s[dep].x, y + s[dep].y, z, choice * 3 + k);
}
if (k == 1) {
predfs(dep + 1, x + s[dep].x, y, z + s[dep].z, choice * 3 + k);
}
if (k == 2) {
predfs(dep + 1, x, y + s[dep].y, z + s[dep].z, choice * 3 + k);
}
}
}
void lowdfs(int dep, long long x, long long y, long long z, int choice) {
if (dep == n) {
y -= x;
z -= x;
node t = node(-y, -z);
if (mp.find(t) != mp.end()) {
int pos = mp[t];
{
if (f[pos].x + x > ans) {
ans = f[pos].x + x;
choicex = f[pos].choice;
choicey = choice;
}
}
}
return;
}
for (int k = 0; k <= 2; k++) {
if (k == 0) {
lowdfs(dep - 1, x + s[dep].x, y + s[dep].y, z, choice * 3 + k);
}
if (k == 1) {
lowdfs(dep - 1, x + s[dep].x, y, z + s[dep].z, choice * 3 + k);
}
if (k == 2) {
lowdfs(dep - 1, x, y + s[dep].y, z + s[dep].z, choice * 3 + k);
}
}
}
void rep(int i, int u) {
if (i == 1) {
int t = u % 3;
if (t == 0) printf("LM\n");
if (t == 1) printf("LW\n");
if (t == 2) printf("MW\n");
return;
}
rep(i - 1, u / 3);
int t = u % 3;
if (t == 0) printf("LM\n");
if (t == 1) printf("LW\n");
if (t == 2) printf("MW\n");
}
void p(int i, int u) {
while (i <= m) {
int t = u % 3;
u /= 3;
i++;
if (t == 0) printf("LM\n");
if (t == 1) printf("LW\n");
if (t == 2) printf("MW\n");
}
}
void print(int l, int r) {
rep(n, l);
p(n + 1, r);
}
int main() {
ans = -1e14;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d%d%d", &s[i].x, &s[i].y, &s[i].z);
if (m % 2 == 0)
n = m / 2;
else
n = m / 2 + 1;
predfs(1, 0, 0, 0, 0);
lowdfs(m, 0, 0, 0, 0);
if (ans != -1e14)
print(choicex, choicey);
else
printf("Impossible\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
vector<tuple<int, int, int, int> > a;
int val[3][30];
long long bonus = 1e9;
unordered_map<long long, pair<int, int> > B;
void bt(int poz, int limit, int history, vector<int> vals, int target) {
if (poz == limit + 1) {
if (target == 1) {
a.push_back(make_tuple(vals[0], vals[1], vals[2], history));
} else {
int x = vals[0], y = vals[1], z = vals[2];
y = x - y;
z = x - z;
if (B.count(bonus * y + z) == 0) {
B[bonus * y + z] = make_pair(x, history);
} else {
int _x = B[bonus * y + z].first;
if (_x < x) {
B[bonus * y + z] = make_pair(x, history);
}
}
}
} else {
bt(poz + 1, limit, history * 3,
{vals[0] + 1 * val[0][poz], vals[1] + 1 * val[1][poz],
vals[2] + 0 * val[2][poz]},
target);
bt(poz + 1, limit, history * 3 + 1,
{vals[0] + 0 * val[0][poz], vals[1] + 1 * val[1][poz],
vals[2] + 1 * val[2][poz]},
target);
bt(poz + 1, limit, history * 3 + 2,
{vals[0] + 1 * val[0][poz], vals[1] + 0 * val[1][poz],
vals[2] + 1 * val[2][poz]},
target);
}
}
string D(int n, int nr) {
if (n == -1) {
return "";
}
string val[3] = {"LM\n", "MW\n", "LW\n"};
vector<string> rez;
for (int i = 0; i < nr; ++i) {
rez.push_back(val[n % 3]);
n /= 3;
}
reverse(rez.begin(), rez.end());
string r = "";
for (auto itr : rez) {
r += itr;
}
return r;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> val[0][i] >> val[1][i] >> val[2][i];
}
time_t t = clock();
int dr = min(13, n);
bt(1, dr, 0, {0, 0, 0}, 1);
if (dr < n) {
bt(dr + 1, n, 0, {0, 0, 0}, 2);
} else {
B[0] = {0, -1};
}
int mx = -inf;
int Ha = 0, Hb = 0;
for (auto itr : a) {
int x, y, z;
int history;
tie(x, y, z, history) = itr;
if (B.count(bonus * (y - x) + (z - x)) == 0) {
continue;
}
pair<int, int> rez = B[(bonus * (y - x) + (z - x))];
x += rez.first;
if (x > mx) {
mx = x;
Ha = history;
Hb = rez.second;
}
}
if (mx == -inf) {
cout << "Impossible\n";
} else {
cout << D(Ha, dr) << D(Hb, (n - dr)) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename Tuple>
void print_tuple(ostream&, const Tuple&) {}
template <typename Car, typename... Cdr, typename Tuple>
void print_tuple(ostream& os, const Tuple& t) {
print_tuple<Cdr...>(os, t);
os << (sizeof...(Cdr) ? "," : "") << get<sizeof...(Cdr)>(t);
}
template <typename... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
print_tuple<Args...>(os << '(', t);
return os << ')';
}
template <typename Ch, typename Tr, typename C>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os, const C& c) {
os << '[';
for (auto i = begin(c); i != end(c); ++i)
os << (i == begin(c) ? "" : " ") << *i;
return os << ']';
}
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
map<tuple<int, int, int>, tuple<int, int>> generate(
const vector<vector<int>>& a) {
int n = a.size(), m = 1;
for (int i = int(0); i < int(n); i++) m *= 3;
map<tuple<int, int, int>, tuple<int, int>> res;
for (int i = int(0); i < int(m); i++) {
int x = 0, y = 0, z = 0, t = i;
for (int j = int(0); j < int(n); j++) {
if (t % 3 == 0) x += a[j][0], y += a[j][1];
if (t % 3 == 1) x += a[j][0], z += a[j][2];
if (t % 3 == 2) y += a[j][1], z += a[j][2];
t /= 3;
}
int mn = min({x, y, z});
x -= mn, y -= mn, z -= mn;
auto p = res.emplace(make_tuple(x, y, z), make_tuple(mn, i));
if (!p.second && get<0>(p.first->second) < mn)
p.first->second = make_tuple(mn, i);
}
return res;
}
void solve(vector<vector<int>> a) {
int n = a.size();
if (n == 1) {
auto m = generate(a);
if (m.count(make_tuple(0, 0, 0))) {
int c = get<1>(m[make_tuple(0, 0, 0)]);
if (c == 0) cout << "LM" << endl;
if (c == 1) cout << "LW" << endl;
if (c == 2) cout << "MW" << endl;
} else
cout << "Impossible" << endl;
return;
}
auto m1 = generate(vector<vector<int>>(begin(a), begin(a) + n / 2));
auto m2 = generate(vector<vector<int>>(begin(a) + n / 2, end(a)));
int res = -INF;
vector<int> resc(2);
for (auto kv : m1) {
int x, y, z;
tie(x, y, z) = kv.first;
int mx = max({x, y, z});
x = mx - x, y = mx - y, z = mx - z;
auto it = m2.find(make_tuple(x, y, z));
if (it != end(m2)) {
int v1, v2, c1, c2;
tie(v1, c1) = kv.second;
tie(v2, c2) = it->second;
if (res < mx + v1 + v2) {
res = mx + v1 + v2;
resc[0] = c1, resc[1] = c2;
}
}
}
if (res == -INF)
cout << "Impossible" << endl;
else {
for (int i = int(0); i < int(n / 2); i++) {
if (resc[0] % 3 == 0) cout << "LM" << endl;
if (resc[0] % 3 == 1) cout << "LW" << endl;
if (resc[0] % 3 == 2) cout << "MW" << endl;
resc[0] /= 3;
}
for (int i = int(0); i < int(n - n / 2); i++) {
if (resc[1] % 3 == 0) cout << "LM" << endl;
if (resc[1] % 3 == 1) cout << "LW" << endl;
if (resc[1] % 3 == 2) cout << "MW" << endl;
resc[1] /= 3;
}
}
}
int main() {
for (int n; cin >> n && n;) {
vector<vector<int>> a(n, vector<int>(3));
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(3); j++) cin >> a[i][j];
solve(a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> res, k;
map<pair<int, int>, pair<int, int> > Mp;
int n, L[26], M[26], W[26], l, mx = -(1LL << 30);
long long ans = -1, bas = 1;
void fDFS(int now, int v, int a, int b, int c) {
if (now == 0) {
res = make_pair(b - a, c - a);
k = make_pair(v, a);
if (Mp.find(res) == Mp.end())
Mp[res] = k;
else if (Mp[res].second < a)
Mp[res] = k;
return;
}
fDFS(now - 1, v * 3 + 0, a, b + M[now], c + W[now]);
fDFS(now - 1, v * 3 + 1, a + L[now], b, c + W[now]);
fDFS(now - 1, v * 3 + 2, a + L[now], b + M[now], c);
return;
}
void sDFS(int now, int v, int a, int b, int c) {
if (now == l) {
res = make_pair(a - b, a - c);
if (Mp.find(res) == Mp.end()) return;
long long t = 1ll * (Mp[res].first) + 1ll * v * bas;
if (a + Mp[res].second > mx) ans = t, mx = a + Mp[res].second;
return;
}
sDFS(now - 1, v * 3 + 0, a, b + M[now], c + W[now]);
sDFS(now - 1, v * 3 + 1, a + L[now], b, c + W[now]);
sDFS(now - 1, v * 3 + 2, a + L[now], b + M[now], c);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d %d", &L[i], &M[i], &W[i]);
l = n / 2;
fDFS(l, 0, 0, 0, 0);
for (int i = 1; i <= l; i++) bas *= 3;
sDFS(n, 0, 0, 0, 0);
if (ans == -1) {
puts("Impossible");
return 0;
}
for (int i = 1, p; i <= n; i++) {
p = ans % 3;
if (p == 0) puts("MW");
if (p == 1) puts("LW");
if (p == 2) puts("LM");
ans /= 3;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int att[30][3];
int pot[30];
map<pair<int, int>, int> mapa;
map<pair<int, int>, int> res;
char s[3][3] = {"MW", "LW", "LM"};
int main(void) {
int n;
pair<int, int> code;
int max_grat = -0x3f3f3f3f;
pot[0] = 1;
for (int i = 1; i < 30 / 2; i++) {
pot[i] = 3 * pot[i - 1];
}
scanf(" %d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
scanf(" %d", &att[i][j]);
}
}
for (int mask = 0; mask < pot[n / 2]; mask++) {
int a = 0;
int b = 0;
int c = 0;
int aux = mask;
for (int j = 0; j < n / 2; j++) {
a += att[j][0];
b += att[j][1];
c += att[j][2];
if (aux % 3 == 0) {
a -= att[j][0];
} else if (aux % 3 == 1) {
b -= att[j][1];
} else {
c -= att[j][2];
}
aux /= 3;
}
pair<int, int> idx = make_pair(a - b, b - c);
if (mapa.find(idx) == mapa.end()) {
mapa[idx] = a;
res[idx] = mask;
}
int grat = mapa[idx];
if (grat < a) {
mapa[idx] = a;
res[idx] = mask;
}
}
for (int mask = 0; mask < pot[n - (n / 2)]; mask++) {
int a = 0;
int b = 0;
int c = 0;
int aux = mask;
for (int j = 0; j < n - (n / 2); j++) {
a += att[(n / 2) + j][0];
b += att[(n / 2) + j][1];
c += att[(n / 2) + j][2];
if (aux % 3 == 0) {
a -= att[(n / 2) + j][0];
} else if (aux % 3 == 1) {
b -= att[(n / 2) + j][1];
} else {
c -= att[(n / 2) + j][2];
}
aux /= 3;
}
pair<int, int> idx = make_pair(b - a, c - b);
if (mapa.find(idx) != mapa.end()) {
int grat = a + mapa[idx];
if (grat > max_grat) {
max_grat = grat;
code = make_pair(res[idx], mask);
}
}
}
if (max_grat == -0x3f3f3f3f) {
printf("Impossible\n");
} else {
int aux = code.first;
for (int i = 0; i < n / 2; i++) {
printf("%s\n", s[aux % 3]);
aux /= 3;
}
aux = code.second;
for (int i = 0; i < n - (n / 2); i++) {
printf("%s\n", s[aux % 3]);
aux /= 3;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct triple {
int a, b, c;
triple() : a(0), b(0), c(0) {}
triple(int a, int b, int c) : a(a), b(b), c(c) {}
};
template <typename Comparer>
bool gen(const vector<triple>& v, Comparer comp, int pos,
vector<pair<char, char> >& ans, triple& val) {
if (pos == v.size()) return comp(ans, val);
ans[pos] = {'L', 'M'};
val.a += v[pos].a;
val.b += v[pos].b;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.b -= v[pos].b;
ans[pos] = {'L', 'W'};
val.a += v[pos].a;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.c -= v[pos].c;
ans[pos] = {'M', 'W'};
val.b += v[pos].b;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.b -= v[pos].b;
val.c -= v[pos].c;
return true;
}
template <typename Comparer>
void launch_gen(const vector<triple>& v, Comparer comp) {
vector<pair<char, char> > ans(v.size());
triple val;
gen(v, comp, 0, ans, val);
}
map<pair<int, int>, pair<int, vector<pair<char, char> > > > m;
int best = -1234567890;
vector<pair<char, char> > res;
bool map_putter(const vector<pair<char, char> >& ans, const triple& val) {
pair<int, int> p(val.a - val.b, val.b - val.c);
if (!m.count(p) || val.c > m[p].first) m[p] = make_pair(val.c, ans);
return true;
}
bool ans_seeker(const vector<pair<char, char> >& ans, const triple& val) {
pair<int, int> p(val.b - val.a, val.c - val.b);
if (m.count(p))
if (m[p].first + val.c > best) {
best = m[p].first + val.c;
res.clear();
res.insert(res.end(), m[p].second.begin(), m[p].second.end());
res.insert(res.end(), ans.begin(), ans.end());
}
return true;
}
int main() {
int n;
cin >> n;
vector<triple> v1, v2;
for (int i = 0; i < n; i++) {
triple t;
cin >> t.a >> t.b >> t.c;
((i < (n / 2)) ? v1 : v2).push_back(t);
}
launch_gen(v1, map_putter);
launch_gen(v2, ans_seeker);
if (res.empty())
cout << "Impossible" << endl;
else
for (auto it : res) cout << it.first << it.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long y, z;
long long x;
int choice;
};
node g[2000001];
int cmp(node head, node a) {
if (head.y != a.y) return head.y < a.y;
if (head.z != a.z) return head.z < a.z;
return head.x > a.x;
}
struct info {
int choice;
long long x;
} f[2000001];
int m, n;
int has = 0;
struct self {
int x, y, z;
} s[33];
long long ans;
int choicex, choicey;
int ipow(int i, int k) {
if (k == 0) return 1;
return i * ipow(i, k - 1);
}
int bs(long long y, long long z) {
int l = 1, r = has, mid, ret = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (g[mid].y > y || (g[mid].y == y && g[mid].z >= z)) {
ret = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (g[ret].y == y && g[ret].z == z)
return ret;
else
return 0;
}
void rep(int i, int u) {
if (i == 1) {
int t = u % 3;
if (t == 0) printf("LM\n");
if (t == 1) printf("LW\n");
if (t == 2) printf("MW\n");
return;
}
rep(i - 1, u / 3);
int t = u % 3;
if (t == 0) printf("LM\n");
if (t == 1) printf("LW\n");
if (t == 2) printf("MW\n");
}
void p(int i, int u) {
while (i <= m) {
int t = u % 3;
u /= 3;
i++;
if (t == 0) printf("LM\n");
if (t == 1) printf("LW\n");
if (t == 2) printf("MW\n");
}
}
void print(int l, int r) {
rep(n, l);
p(n + 1, r);
}
int main() {
ans = -1e14;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d%d%d", &s[i].x, &s[i].y, &s[i].z);
if (m % 2 == 0)
n = m / 2;
else
n = m / 2 + 1;
for (int i = 0; i < ipow(3, n); i++) {
int v = i;
long long x = 0, y = 0, z = 0;
for (int j = n; j >= 1; j--) {
int k = v % 3, li = j;
long long a = x, b = y;
if (k == 0) {
x += s[li].x;
y += s[li].y;
}
if (k == 1) {
x += s[li].x;
z += s[li].z;
}
if (k == 2) {
y += s[li].y;
z += s[li].z;
}
v /= 3;
}
y -= x;
z -= x;
has++;
g[has].x = x;
g[has].y = y;
g[has].z = z;
g[has].choice = i;
}
sort(g + 1, g + has + 1, cmp);
for (int i = 0; i < ipow(3, m - n); i++) {
int v = i;
long long x = 0, y = 0, z = 0;
for (int j = n + 1; j <= m; j++) {
int k = v % 3, li = j;
if (k == 0) {
x += s[li].x;
y += s[li].y;
}
if (k == 1) {
x += s[li].x;
z += s[li].z;
}
if (k == 2) {
y += s[li].y;
z += s[li].z;
}
v /= 3;
}
y -= x;
z -= x;
int pos = bs(-y, -z);
if (pos != 0)
if (g[pos].x + x > ans) {
ans = g[pos].x + x;
choicex = g[pos].choice;
choicey = i;
}
}
if (ans != -1e14)
print(choicex, choicey);
else
printf("Impossible\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, pair<pair<int, int>, pair<int, long long> > > part1;
map<pair<int, int>, bool> visitPart1;
int n;
int l[25], m[25], w[25];
long long s1 = -1, s2 = -1;
long long ma = -20000000000000;
void gen(int idx, int a, int b, int c, long long seq) {
if (idx == n / 2) {
int x = a - b, y = a - c;
pair<pair<int, int>, pair<int, long long> > &temp = part1[make_pair(x, y)];
bool &visit = visitPart1[make_pair(x, y)];
if (!visit) {
temp = make_pair(make_pair(a, b), make_pair(c, seq));
visit = true;
return;
}
pair<pair<int, int>, pair<int, long long> > t = temp;
if (t.first.first + t.first.second + t.second.first < a + b + c) {
temp = make_pair(make_pair(a, b), make_pair(c, seq));
}
return;
}
gen(idx + 1, a + l[idx], b + m[idx], c, seq * 10LL + 1LL);
gen(idx + 1, a + l[idx], b, c + w[idx], seq * 10LL + 2LL);
gen(idx + 1, a, b + m[idx], c + w[idx], seq * 10LL + 3LL);
}
void dfs(int idx, int a, int b, int c, long long seq) {
if (idx == n) {
int x = b - a, y = c - a;
if (!visitPart1[make_pair(x, y)]) {
return;
}
pair<pair<int, int>, pair<int, long long> > t = part1[make_pair(x, y)];
int ans = a + t.first.first + b + t.first.second + c + t.second.first;
if (ans > ma) {
s1 = t.second.second, s2 = seq;
ma = ans;
}
return;
}
dfs(idx + 1, a + l[idx], b + m[idx], c, seq * 10LL + 1LL);
dfs(idx + 1, a + l[idx], b, c + w[idx], seq * 10LL + 2LL);
dfs(idx + 1, a, b + m[idx], c + w[idx], seq * 10LL + 3LL);
}
void print(string second) {
for (int i = 0; i < second.size(); i++) {
if (second[i] == '1') {
printf("LM\n");
} else if (second[i] == '2') {
printf("LW\n");
} else
printf("MW\n");
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &l[i], &m[i], &w[i]);
}
gen(0, 0, 0, 0, 0);
dfs(n / 2, 0, 0, 0, 0);
if (s1 == -1 && s2 == -1) {
cout << "Impossible\n";
return 0;
}
string alt1 = "", alt2 = "";
while (s1) {
alt1 += (s1 % 10 + '0');
s1 /= 10;
}
while (s2) {
alt2 += (s2 % 10 + '0');
s2 /= 10;
}
reverse(alt1.begin(), alt1.end());
reverse(alt2.begin(), alt2.end());
print(alt1), print(alt2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(15);
}
long long modpow(long long a, long long p, long long mod) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
p /= 2;
}
return ret % mod;
}
long long power(long long a, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a);
a = (a * a);
p /= 2;
}
return ret;
}
int vec[30];
int l[30], m[30], w[30];
map<pair<int, int>, int> mapit;
map<int, string> s;
int fin[2000000];
int ans = INT_MIN, m1, m2;
int main() {
FastIO();
s[0] = "LM";
s[1] = "MW";
s[2] = "WL";
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i] >> m[i] >> w[i];
long long tot1 = power(3, n / 2);
long long tot2 = power(3, n - n / 2);
for (int i = 0; i < tot1; i++) {
int t = i;
for (int j = 0; j < n / 2; j++) {
vec[j] = t % 3;
t /= 3;
}
reverse(vec, vec + n / 2);
int x = 0, y = 0, z = 0;
for (int j = 0; j < n / 2; j++) {
if (vec[j] == 0) {
x += l[j];
y += m[j];
} else if (vec[j] == 1) {
y += m[j];
z += w[j];
} else {
z += w[j];
x += l[j];
}
}
mapit[make_pair(y - x, z - x)] = i + 1;
fin[i] = x;
}
for (int i = 0; i < tot2; i++) {
int t = i;
for (int j = n / 2; j < n; j++) {
vec[j - n / 2] = (t % 3);
t /= 3;
}
reverse(vec, vec + n - n / 2);
int x = 0, y = 0, z = 0;
for (int j = n / 2; j < n; j++) {
int k = j - n / 2;
if (vec[k] == 0) {
x += l[j];
y += m[j];
} else if (vec[k] == 1) {
y += m[j];
z += w[j];
} else {
z += w[j];
x += l[j];
}
}
y -= x;
z -= x;
int mask = mapit[make_pair(-y, -z)] - 1;
if (mask == -1) continue;
if (fin[mask] + x > ans) {
ans = fin[mask] + x;
m1 = mask;
m2 = i;
}
}
if (ans == INT_MIN) {
cout << "Impossible\n";
return 0;
}
vector<int> vec;
for (int j = 0; j < n / 2; j++) {
vec.push_back(m1 % 3);
m1 /= 3;
}
reverse(vec.begin(), vec.end());
for (int j = 0; j < n / 2; j++) cout << s[vec[j]] << '\n';
for (int j = n / 2; j < n; j++) {
vec.push_back(m2 % 3);
m2 /= 3;
}
reverse(vec.begin(), vec.end());
for (int j = 0; j < n - n / 2; j++) cout << s[vec[j]] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int data[25][3];
map<pair<int, int>, pair<int, int> > upper;
map<pair<int, int>, pair<int, int> > lower;
int power(int n, int e) {
if (e == 0) return 1;
int temp = power(n, e / 2);
temp = temp * temp;
if (e % 2 == 1) temp *= n;
return temp;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &data[i][0], &data[i][1], &data[i][2]);
}
int half = n / 2;
int pow = power(3, half);
for (int i = 0; i < pow; i++) {
int tmp = i;
int a = 0, b = 0, c = 0, d = 0;
for (int j = 0; j < half; j++) {
int k = tmp % 3;
tmp /= 3;
switch (k) {
case 0:
a += data[j][0];
b += data[j][1];
d += data[j][0];
break;
case 1:
b += data[j][1];
c += data[j][2];
break;
case 2:
d += data[j][0];
c += data[j][2];
a += data[j][0];
}
}
auto it = upper.find(make_pair(a - b, a - c));
if (it == upper.end()) {
upper[make_pair(a - b, a - c)] = make_pair(i, d);
} else {
if (it->second.second < d) {
it->second = make_pair(i, d);
}
}
}
half = n - half;
pow = power(3, half);
for (int i = 0; i < pow; i++) {
int tmp = i;
int a = 0, b = 0, c = 0, d = 0;
for (int j = n - half; j < n; j++) {
int k = tmp % 3;
tmp /= 3;
switch (k) {
case 0:
a += data[j][0];
b += data[j][1];
d += data[j][0];
break;
case 1:
b += data[j][1];
c += data[j][2];
break;
case 2:
c += data[j][2];
a += data[j][0];
d += data[j][0];
}
}
auto it = lower.find(make_pair(b - a, c - a));
if (it == lower.end()) {
lower[make_pair(b - a, c - a)] = make_pair(i, d);
} else {
if (it->second.second < d) {
it->second = make_pair(i, d);
}
}
}
half = n - half;
bool good = false;
int u;
int l;
int sum = -2000000000;
for (auto &x : upper) {
auto it = lower.find(x.first);
if (it != lower.end()) {
if (sum > x.second.second + it->second.second) continue;
good = true;
u = x.second.first;
l = it->second.first;
sum = x.second.second + it->second.second;
}
}
if (good) {
for (int i = 0; i < n; i++) {
if (i < half) {
int tmp = u % 3;
u /= 3;
if (tmp == 0) {
printf("LM\n");
} else if (tmp == 1) {
printf("MW\n");
} else {
printf("LW\n");
}
} else {
int tmp = l % 3;
l /= 3;
if (tmp == 0) {
printf("LM\n");
} else if (tmp == 1) {
printf("MW\n");
} else {
printf("LW\n");
}
}
}
} else {
printf("Impossible");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 34;
int a[N][3];
struct util {
int arr[3];
util() {
for (int i = 0; i < 3; i++) arr[i] = 0;
}
};
char carr[] = {'L', 'M', 'W'};
void fun1(vector<util> &v, int ind, int lim, util cur) {
if (ind == lim) {
v.push_back(cur);
return;
}
for (int i = 0; i < 3; i++) {
for (int j = i + 1; j < 3; j++) {
util tcur = cur;
tcur.arr[i] += a[ind][i];
tcur.arr[j] += a[ind][j];
fun1(v, ind + 1, lim, tcur);
}
}
}
vector<string> vs;
int construct(int ind, int lim, util cur, util req) {
if (ind == lim) {
int flag = 1;
for (int i = 0; i < 3; i++)
if (cur.arr[i] != req.arr[i]) flag = 0;
return flag;
}
for (int i = 0; i < 3; i++) {
for (int j = i + 1; j < 3; j++) {
util tcur = cur;
tcur.arr[i] += a[ind][i];
tcur.arr[j] += a[ind][j];
int outcome = construct(ind + 1, lim, tcur, req);
if (outcome) {
string hs = "";
hs.push_back(carr[i]);
hs.push_back(carr[j]);
vs.push_back(hs);
return 1;
}
}
}
return 0;
}
int solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) scanf("%d", &a[i][j]);
vector<util> va, vb;
util temp;
fun1(va, 0, n / 2, temp);
fun1(vb, n / 2, n, temp);
map<pair<int, int>, int> ma;
for (int i = 0; i < (int)vb.size(); i++) {
auto it = vb[i];
int xx = it.arr[1] - it.arr[0], yy = it.arr[2] - it.arr[1];
pair<int, int> pp = {xx, yy};
if (ma.find(pp) == ma.end()) ma[pp] = i;
{
int ind = ma[pp];
if (vb[i].arr[0] > vb[ind].arr[0]) ma[pp] = i;
}
}
int mx = INT_MIN, ii = -1, jj = -1;
for (int i = 0; i < (int)va.size(); i++) {
int xh = va[i].arr[0] - va[i].arr[1], yh = va[i].arr[1] - va[i].arr[2];
pair<int, int> pp = {xh, yh};
if (ma.find(pp) != ma.end()) {
int ind = ma[pp], here = va[i].arr[0] + vb[ind].arr[0];
if (here > mx) mx = here, ii = i, jj = ind;
}
}
if (mx == INT_MIN) {
printf("Impossible");
return 0;
}
for (int i = 1; i < 3; i++) {
assert(va[ii].arr[i] + vb[jj].arr[i] ==
va[ii].arr[i - 1] + vb[jj].arr[i - 1]);
}
construct(0, n / 2, temp, va[ii]);
reverse(vs.begin(), vs.end());
for (auto it : vs) cout << it << '\n';
vs.clear();
construct(n / 2, n, temp, vb[jj]);
reverse(vs.begin(), vs.end());
for (auto it : vs) cout << it << '\n';
return 0;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> P;
map<pair<int, int>, int> mp;
struct node {
int a, b, c;
} T[30];
bool found = 0, got = 0;
char res[5];
int n, ans[30], ans1, ans2, ans3, ma = -2000000000, now[30];
int fast[30];
void make(int x, int y, int z, int d) {
if (d == n + 1) {
P.first = x - y, P.second = x - z;
if (mp.find(P) == mp.end())
mp[P] = x;
else
mp[P] = max(mp[P], x);
return;
}
make(x + T[d].a, y + T[d].b, z, d + 1);
make(x, y + T[d].b, z + T[d].c, d + 1);
make(x + T[d].a, y, z + T[d].c, d + 1);
}
void search(int d, int x, int y, int z) {
if (x + fast[d] <= ma) return;
if (d == n / 2 + 1) {
P.first = y - x, P.second = z - x;
if (mp.find(P) != mp.end()) {
if (mp[P] + x > ma) {
ma = mp[P] + x;
ans1 = y - x, ans2 = z - x, ans3 = mp[P];
for (int i = 1; i < d; i++) ans[i] = now[i];
found = 1;
}
}
return;
}
now[d] = 2;
search(d + 1, x + T[d].a, y, z + T[d].c);
now[d] = 3;
search(d + 1, x + T[d].a, y + T[d].b, z);
now[d] = 1;
search(d + 1, x, y + T[d].b, z + T[d].c);
}
void research(int d, int x, int y, int z) {
if (got) return;
if (d == n + 1) {
if (x - y == ans1 && x - z == ans2 && x == ans3) got = 1;
return;
}
ans[d] = 2;
research(d + 1, x + T[d].a, y, z + T[d].c);
if (got) return;
ans[d] = 3;
research(d + 1, x + T[d].a, y + T[d].b, z);
if (got) return;
ans[d] = 1;
research(d + 1, x, y + T[d].b, z + T[d].c);
}
int main() {
int i, k, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d%d", &T[i].a, &T[i].b, &T[i].c);
for (i = n; i >= 1; i--)
fast[i] = fast[i + 1], fast[i] += (T[i].a) > 0 ? T[i].a : 0;
make(0, 0, 0, n / 2 + 1);
P.first = 0, P.second = -1;
search(1, 0, 0, 0);
res[1] = 'L', res[2] = 'M', res[3] = 'W';
if (found) {
for (i = 1; i <= n / 2; i++) {
for (k = 1; k <= 3; k++)
if (ans[i] != k) printf("%c", res[k]);
puts("");
}
research(n / 2 + 1, 0, 0, 0);
for (i = n / 2 + 1; i <= n; i++) {
for (k = 1; k <= 3; k++)
if (ans[i] != k) printf("%c", res[k]);
puts("");
}
} else
puts("Impossible");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
int n, A[30], B[30], C[30], maxn, ans = -inf, printx, printy, num[2000010],
cntt, cnt;
struct node {
int zhuangtai, x;
} e[2000010];
struct node2 {
int x, y;
bool operator<(const node2 &a) const { return a.x == x ? a.y < y : a.x < x; }
};
map<node2, int> a;
void dfs1(int dep, int x, int y, int z, int sta) {
if (dep == maxn + 1) {
y -= x;
z -= x;
node2 temp;
temp.x = y;
temp.y = z;
if (a.find(temp) == a.end()) {
a[temp] = ++cnt;
e[cnt].zhuangtai = sta;
e[cnt].x = x;
} else {
if (e[a[temp]].x < x) {
e[a[temp]].x = x;
e[a[temp]].zhuangtai = sta;
}
}
return;
}
for (int i = 0; i < 3; i++) {
if (i == 0) dfs1(dep + 1, x + A[dep], y + B[dep], z, sta * 3);
if (i == 1) dfs1(dep + 1, x + A[dep], y, z + C[dep], sta * 3 + 1);
if (i == 2) dfs1(dep + 1, x, y + B[dep], z + C[dep], sta * 3 + 2);
}
}
void dfs2(int dep, int x, int y, int z, int sta) {
if (dep == maxn) {
y -= x;
z -= x;
y = -y;
z = -z;
node2 temp;
temp.x = y;
temp.y = z;
if (a.find(temp) != a.end()) {
if (e[a[temp]].x + x > ans) {
ans = e[a[temp]].x + x;
printx = e[a[temp]].zhuangtai;
printy = sta;
}
}
return;
}
for (int i = 0; i < 3; i++) {
if (i == 0) dfs2(dep - 1, x + A[dep], y + B[dep], z, sta * 3);
if (i == 1) dfs2(dep - 1, x + A[dep], y, z + C[dep], sta * 3 + 1);
if (i == 2) dfs2(dep - 1, x, y + B[dep], z + C[dep], sta * 3 + 2);
}
}
void print() {
for (int i = 1; i <= maxn; i++) {
num[++cntt] = printx % 3;
printx /= 3;
}
for (int i = cntt; i >= 1; i--) {
if (num[i] == 0) puts("LM");
if (num[i] == 1) puts("LW");
if (num[i] == 2) puts("MW");
}
cntt = 0;
for (int i = maxn + 1; i <= n; i++) {
num[++cntt] = printy % 3;
printy /= 3;
}
for (int i = 1; i <= cntt; i++) {
if (num[i] == 0) puts("LM");
if (num[i] == 1) puts("LW");
if (num[i] == 2) puts("MW");
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &A[i], &B[i], &C[i]);
if (n % 2 == 0)
maxn = n / 2;
else
maxn = n / 2 + 1;
dfs1(1, 0, 0, 0, 0);
dfs2(n, 0, 0, 0, 0);
if (ans != -inf)
print();
else
puts("Impossible");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30;
const int oo = 2000000000;
int n, Mid;
int a[maxn], b[maxn], c[maxn];
map<pair<int, int>, pair<int, long long> > Opt;
pair<int, long long> ans;
inline int read() {
int x = 0;
bool flag = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') flag = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return flag ? -x : x;
}
void DFS1(int Pos, int Status, int A, int B, int C) {
if (Pos == Mid + 1) {
pair<int, long long> &now = Opt[make_pair(A - B, B - C)];
if (now.second == 0 || now.first < A) now = make_pair(A, Status);
return;
}
DFS1(Pos + 1, Status << 2 | 1, A, B + b[Pos], C + c[Pos]);
DFS1(Pos + 1, Status << 2 | 2, A + a[Pos], B, C + c[Pos]);
DFS1(Pos + 1, Status << 2 | 3, A + a[Pos], B + b[Pos], C);
}
void DFS2(int Pos, int Status, int A, int B, int C) {
if (Pos == n + 1) {
pair<int, long long> now = Opt[make_pair(B - A, C - B)];
if (!now.second) return;
if (now.first + A > ans.first) {
ans.first = now.first + A;
ans.second = (now.second << ((n - Mid) << 1) | Status);
}
return;
}
DFS2(Pos + 1, Status << 2 | 1, A, B + b[Pos], C + c[Pos]);
DFS2(Pos + 1, Status << 2 | 2, A + a[Pos], B, C + c[Pos]);
DFS2(Pos + 1, Status << 2 | 3, A + a[Pos], B + b[Pos], C);
}
void Print(long long Status) {
if (!Status) return;
int dy = Status & 3;
Print((Status >> 2));
if (dy == 1)
printf("MW\n");
else if (dy == 2)
printf("LW\n");
else
printf("LM\n");
}
bool Cheater() {
if (n != 1) return false;
if (!a[1] && !b[1])
printf("LM\n");
else if (!a[1] && !c[1])
printf("LW\n");
else if (!b[1] && !c[1])
printf("MW\n");
else
printf("Impossible\n");
return true;
}
int main() {
n = read();
Mid = n >> 1;
for (int i = 1; i <= n; i++) a[i] = read(), b[i] = read(), c[i] = read();
if (Cheater()) return 0;
DFS1(1, 0, 0, 0, 0);
ans.first = -oo, ans.second = 0;
DFS2(Mid + 1, 0, 0, 0, 0);
if (ans.first == -oo)
printf("Impossible\n");
else
Print(ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 26, inf = 1e9;
int n, ind, tmp[3];
long long a[maxn][3];
map<pair<int, int>, pair<int, int> > Left;
char c[3] = {'L', 'M', 'W'};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1] >> a[i][2];
int n1 = n / 2, pw = 1;
for (int i = 0; i < n1; i++) pw *= 3;
for (int i = 0; i < pw; i++) {
for (int j = 0; j < 3; j++) tmp[j] = 0;
int mask = i;
for (int j = 0; j < n1; j++) {
tmp[(mask % 3 + 1) % 3] += a[j][(mask % 3 + 1) % 3];
tmp[(mask % 3 + 2) % 3] += a[j][(mask % 3 + 2) % 3];
mask /= 3;
}
pair<int, int> in = make_pair(tmp[1] - tmp[0], tmp[2] - tmp[1]);
if (Left.find(in) == Left.end())
Left[in] = make_pair(tmp[0], i);
else
Left[in] = max(Left[in], make_pair(tmp[0], i));
}
int n2 = n - n1;
pw = 1;
for (int i = 0; i < n2; i++) pw *= 3;
int ans = -inf;
int mask1 = -1, mask2 = -1;
for (int i = 0; i < pw; i++) {
for (int j = 0; j < 3; j++) tmp[j] = 0;
int mask = i;
for (int j = n1; j < n; j++) {
tmp[(mask % 3 + 1) % 3] += a[j][(mask % 3 + 1) % 3];
tmp[(mask % 3 + 2) % 3] += a[j][(mask % 3 + 2) % 3];
mask /= 3;
}
pair<int, int> in = make_pair(-tmp[1] + tmp[0], -tmp[2] + tmp[1]);
if (Left.find(in) != Left.end()) {
pair<int, int> tmpp = Left[in];
if (tmp[0] + tmpp.first > ans) {
ans = tmp[0] + tmpp.first;
mask1 = i;
mask2 = tmpp.second;
}
}
}
if (mask1 == -1)
cout << "Impossible" << endl;
else {
for (int i = 0; i < n1; i++) {
cout << c[(mask2 % 3 + 1) % 3] << c[(mask2 % 3 + 2) % 3] << endl;
mask2 /= 3;
}
for (int i = 0; i < n2; i++) {
cout << c[(mask1 % 3 + 1) % 3] << c[(mask1 % 3 + 2) % 3] << endl;
mask1 /= 3;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long inline ipow(long long a, long long b, long long m) {
long long val = 1;
a %= m;
while (b) {
if (b & 01) val = (val * a) % m;
b >>= 1;
a = (a * a) % m;
};
return val % m;
}
long long inline ipow(long long a, long long b) {
long long val = 1;
while (b) {
if (b & 01) val = (val * a);
b >>= 1;
a = (a * a);
};
return val;
}
int constructSegmentTree(int* arr, int* segArr, int start, int end, int pos) {
if (start == end) {
segArr[pos] = arr[start];
return segArr[pos];
}
int mid = start + (end - start) / 2;
segArr[pos] = constructSegmentTree(arr, segArr, start, mid, 2 * pos + 1) +
constructSegmentTree(arr, segArr, mid + 1, end, 2 * pos + 2);
return segArr[pos];
}
int* segmentTree(int* arr, int n) {
int first = (int)(ceil(log2(n)));
first = 2 * pow(2, first) - 1;
int* st = new int[first];
constructSegmentTree(arr, st, 0, n - 1, 0);
return st;
}
int getSumUtil(int* st, int qstart, int qend, int sstart, int send, int pos) {
if (qstart <= sstart && qend >= send) return st[pos];
if (qstart > send || qend < sstart) return 0;
int mid = sstart + (send - sstart) / 2;
return getSumUtil(st, qstart, qend, sstart, mid, 2 * pos + 1) +
getSumUtil(st, qstart, qend, mid + 1, send, 2 * pos + 2);
}
int getSum(int* st, int n, int qstart, int qend) {
return getSumUtil(st, qstart, qend, 0, n - 1, 0);
}
void updateValueUtil(int* st, int i, int sstart, int send, int diff, int pos) {
if (i < sstart || i > send) return;
st[pos] += diff;
int mid = sstart + (send - sstart) / 2;
if (sstart != send) {
updateValueUtil(st, i, sstart, mid, diff, 2 * pos + 1);
updateValueUtil(st, i, mid + 1, send, diff, 2 * pos + 2);
}
return;
}
void updateValue(int* arr, int* st, int n, int i, int new_val) {
int diff = new_val - arr[i];
arr[i] = new_val;
updateValueUtil(st, i, 0, n - 1, diff, 0);
}
int len(int n) {
int ans = 0;
while (n) {
ans += 1 & n;
n >>= 1;
}
return ans;
}
long long int expo(long long int a, long long int b) {
long long int result;
if (b == 0) return 1;
if (b == 2) return (a * a) % 1000000007;
if (b == 1) return a % 1000000007;
if (b % 2 == 1) {
return (a * expo(a, b - 1)) % 1000000007;
} else {
result = expo(a, b / 2) % 1000000007;
return (result * result) % 1000000007;
}
}
int N, maxAttitude;
long long int moves, bestmoves;
int val[3], bestVal[3], l[30], m[30], w[30];
string movesList[30];
map<pair<int, int>, int> m1;
map<pair<int, int>, long long int> m2;
void backtrack(int n) {
if (n == N / 2) {
int d1 = val[0] - val[1], d2 = val[1] - val[2];
pair<int, int> p(d1, d2);
if (m1.count(p) == 0 || m1[p] < val[0]) {
m1[p] = val[0];
m2[p] = moves;
}
return;
}
moves *= 10;
val[0] += l[n];
val[1] += m[n];
backtrack(n + 1);
moves++;
val[1] -= m[n];
val[2] += w[n];
backtrack(n + 1);
moves++;
val[0] -= l[n];
val[1] += m[n];
backtrack(n + 1);
val[1] -= m[n];
val[2] -= w[n];
moves /= 10;
}
void backtrack2(int n) {
if (n == N) {
int d1 = val[1] - val[0], d2 = val[2] - val[1];
pair<int, int> p(d1, d2);
if (m1.count(p) == 0) return;
if (val[0] + m1[p] > maxAttitude) {
maxAttitude = val[0] + m1[p];
bestmoves = moves;
memcpy(bestVal, val, sizeof val);
}
return;
}
moves *= 10;
val[0] += l[n];
val[1] += m[n];
backtrack2(n + 1);
moves++;
val[1] -= m[n];
val[2] += w[n];
backtrack2(n + 1);
moves++;
val[0] -= l[n];
val[1] += m[n];
backtrack2(n + 1);
val[1] -= m[n];
val[2] -= w[n];
moves /= 10;
}
void getMovesList() {
int bestD1 = bestVal[1] - bestVal[0], bestD2 = bestVal[2] - bestVal[1];
long long int moveFirst = m2[make_pair(bestD1, bestD2)];
for (int i = N / 2 - 1; i >= 0; --i) {
if (moveFirst % 10 == 0)
movesList[i] = "LM";
else if (moveFirst % 10 == 1)
movesList[i] = "LW";
else
movesList[i] = "MW";
moveFirst /= 10;
}
long long int moveSecond = bestmoves;
for (int i = N - 1; i >= N / 2; --i) {
if (moveSecond % 10 == 0)
movesList[i] = "LM";
else if (moveSecond % 10 == 1)
movesList[i] = "LW";
else
movesList[i] = "MW";
moveSecond /= 10;
}
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> l[i] >> m[i] >> w[i];
}
backtrack(0);
memset(val, 0, sizeof val);
moves = 0;
maxAttitude = INT_MIN;
backtrack2(N / 2);
if (maxAttitude == INT_MIN) {
cout << "Impossible" << endl;
} else {
getMovesList();
for (int i = 0; i < N; ++i) {
cout << movesList[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 30;
long long a[N][10];
long long limit;
char bh[10];
map<pair<long long, long long>, pair<long long, long long> > Q;
long long ans[N], n;
pair<long long, pair<long long, long long> > Max =
make_pair(-1LL << 60, make_pair(-1LL, -1LL));
void outs(long long mask, long long flag, long long x, long long y,
long long z) {
long long delta1 = x - y, delta2 = y - z;
if (flag == 0) {
if (!Q.count(make_pair(delta1, delta2)))
Q[make_pair(delta1, delta2)] = make_pair(x, mask);
else
Q[make_pair(delta1, delta2)] =
max(Q[make_pair(delta1, delta2)], make_pair(x, mask));
return;
} else {
if (Q.count(make_pair(-delta1, -delta2))) {
pair<long long, long long> mask1 = Q[make_pair(-delta1, -delta2)];
Max = max(Max, make_pair(x + mask1.first, make_pair(mask1.second, mask)));
}
}
return;
}
void dfs(long long deep, long long mask, long long x, long long y, long long z,
long long flag) {
if (deep > limit) {
outs(mask, flag, x, y, z);
return;
}
dfs(deep + 1, mask * 3 + 0, x, y + a[deep][1], z + a[deep][2], flag);
dfs(deep + 1, mask * 3 + 1, x + a[deep][0], y, z + a[deep][2], flag);
dfs(deep + 1, mask * 3 + 2, x + a[deep][0], y + a[deep][1], z, flag);
return;
}
int main() {
scanf("%I64d", &n);
for (long long i = 1; i <= n; i++)
for (long long j = 0; j <= 2; j++) scanf("%I64d", &a[i][j]);
bh[0] = 'L';
bh[1] = 'M', bh[2] = 'W';
long long k = n / 2;
limit = k;
dfs(1, 0, 0, 0, 0, 0);
limit = n;
dfs(k + 1, 0, 0, 0, 0, 1);
if (Max.first != -1LL << 60) {
long long now = n / 2;
long long mask1 = Max.second.first;
while (mask1) {
ans[now] = mask1 % 3;
mask1 /= 3;
now--;
}
long long mask = Max.second.second;
now = n;
while (mask) {
ans[now] = mask % 3;
mask /= 3;
now--;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= 2; j++)
if (ans[i] != j) printf("%c", bh[j]);
puts("");
}
} else {
puts("Impossible");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int mid;
int a[30];
int b[30];
int c[30];
int num[30];
int res = -(int)2e9;
int m1, m2;
pair<int, int> para;
map<pair<int, int>, pair<int, int> > have;
map<pair<int, int>, pair<int, int> >::iterator it;
void calcF(int x) {
int px = x;
memset(num, 0, sizeof(num));
int pos = 0;
while (x > 0) {
num[++pos] = x % 3;
x /= 3;
}
pos = mid;
int L, M, W;
L = M = W = 0;
for (int i = 1; i <= pos; i++) {
if (num[i] == 0) {
L += a[i];
M += b[i];
} else if (num[i] == 1) {
L += a[i];
W += c[i];
} else {
M += b[i];
W += c[i];
}
}
it = have.find(make_pair(L - M, M - W));
if (it == have.end()) {
have.insert(make_pair(make_pair(L - M, M - W), make_pair(px, L)));
} else {
para = it->second;
if (para.second < L) {
para = make_pair(px, L);
}
have[make_pair(L - M, M - W)] = para;
}
}
void calcS(int x) {
int px = x;
memset(num, 0, sizeof(num));
int pos = 0;
while (x > 0) {
num[++pos] = x % 3;
x /= 3;
}
pos = n - mid;
int L, M, W;
L = M = W = 0;
for (int i = 1; i <= pos; i++) {
if (num[i] == 0) {
L += a[i + mid];
M += b[i + mid];
} else if (num[i] == 1) {
L += a[i + mid];
W += c[i + mid];
} else {
M += b[i + mid];
W += c[i + mid];
}
}
it = have.find(make_pair(M - L, W - M));
if (it == have.end()) {
return;
}
para = it->second;
if (para.second + L > res) {
res = para.second + L;
m1 = para.first;
m2 = px;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
mid = (n + 1) / 2;
int maxN = 1;
for (int i = 1; i <= mid; i++) {
maxN *= 3;
}
int other = 1;
for (int i = 1; i <= n - mid; i++) {
other *= 3;
}
for (int i = 0; i <= maxN; i++) {
calcF(i);
}
for (int i = 0; i <= other; i++) {
calcS(i);
}
if (res == -(int)2e9) {
puts("Impossible");
return 0;
}
memset(num, 0, sizeof(num));
int pos = 0;
while (m1 > 0) {
num[++pos] = m1 % 3;
m1 /= 3;
}
pos = mid;
while (m2 > 0) {
num[++pos] = m2 % 3;
m2 /= 3;
}
for (int i = 1; i <= n; i++) {
if (num[i] == 0) {
puts("LM");
} else if (num[i] == 1) {
puts("LW");
} else
puts("MW");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
struct point {
long long v1, v2;
point(long long cv1 = 0, long long cv2 = 0) {
v1 = cv1;
v2 = cv2;
}
bool operator<(const point &rhs) const {
return v1 < rhs.v1 || (v1 == rhs.v1 && v2 < rhs.v2);
}
bool operator==(const point &rhs) const {
return v1 == rhs.v1 && v2 == rhs.v2;
}
};
map<point, point> M;
long long dp[30];
int A[30], B[30], C[30];
int dep, n;
point ans;
void dfs(int ro, long long v1, long long v2, long long v3, long long v4) {
if (ro == dep) {
point A;
A.v1 = v1;
A.v2 = v2;
if (M.count(A) == 0)
M[A] = point(v3, v4);
else {
point B = M[A];
if (B.v1 < v3) {
M[A] = point(v3, v4);
}
}
return;
}
dfs(ro + 1, v1 + B[ro] - A[ro], v2 - A[ro], v3, v4 * 3);
dfs(ro + 1, v1 + B[ro], v2 + C[ro], v3 + C[ro], v4 * 3 + 1);
dfs(ro + 1, v1 - A[ro], v2 + C[ro] - A[ro], v3 + C[ro], v4 * 3 + 2);
}
void dfs2(int ro, long long v1, long long v2, long long v3, long long v4) {
if (ro == n) {
point A;
A.v1 = -v1;
A.v2 = -v2;
if (M.count(A) != 0) {
point B = M[A];
long long d = B.v1 + v3;
if (d > ans.v1) {
ans.v1 = d;
ans.v2 = B.v2 * dp[n - dep] + v4;
}
}
if (v1 == 0 && v2 == 0 && dep == 0) {
if (v3 > ans.v1) {
ans.v1 = v3;
ans.v2 = v4;
}
}
return;
}
dfs2(ro + 1, v1 + B[ro] - A[ro], v2 - A[ro], v3, v4 * 3);
dfs2(ro + 1, v1 + B[ro], v2 + C[ro], v3 + C[ro], v4 * 3 + 1);
dfs2(ro + 1, v1 - A[ro], v2 + C[ro] - A[ro], v3 + C[ro], v4 * 3 + 2);
}
void print(int loc, long long v) {
if (loc == 0) return;
print(loc - 1, v / 3);
int d = v % 3;
if (d == 0)
puts("LM");
else if (d == 1)
puts("MW");
else
puts("LW");
}
int main() {
dp[0] = 1;
for (int i = 1; i <= 25; i++) dp[i] = dp[i - 1] * 3;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d%d", &A[i], &B[i], &C[i]);
dep = n / 2;
point a;
dfs(0, 0, 0, 0, 0);
ans.v1 = -INF;
dfs2(dep, 0, 0, 0, 0);
if (ans.v1 == -INF)
puts("Impossible");
else {
print(n, ans.v2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30;
int n;
int ans = -0x3f3f3f3f;
pair<long long, long long> res;
int L[maxn], M[maxn], W[maxn];
bool f;
map<pair<long long, long long>, pair<long long, long long> > ma;
void dfs1(int d, int sta, int l, int m, int w) {
if (d > n / 2) {
pair<long long, long long> t = make_pair(m - l, w - l);
if (!ma.count(t))
ma[t] = make_pair(l, sta);
else if (ma[t].first < l)
ma[t] = make_pair(l, sta);
return;
}
dfs1(d + 1, sta * 3, l + L[d], m + M[d], w);
dfs1(d + 1, sta * 3 + 1, l + L[d], m, w + W[d]);
dfs1(d + 1, sta * 3 + 2, l, m + M[d], w + W[d]);
}
void dfs2(int d, int sta, int l, int m, int w) {
if (d > n) {
pair<long long, long long> t = make_pair(l - m, l - w);
if (ma.count(t)) {
f = 1;
if (ma[t].first + l > ans) {
ans = ma[t].first + l;
res = make_pair(ma[t].second, sta);
}
}
return;
}
dfs2(d + 1, sta * 3, l + L[d], m + M[d], w);
dfs2(d + 1, sta * 3 + 1, l + L[d], m, w + W[d]);
dfs2(d + 1, sta * 3 + 2, l, m + M[d], w + W[d]);
}
void otp() {
int i;
stack<int> s;
for (i = 1; i <= n - n / 2; i++) s.push(res.second % 3), res.second /= 3;
for (i = 1; i <= n / 2; i++) s.push(res.first % 3), res.first /= 3;
for (; !s.empty(); s.pop())
puts(s.top() == 0 ? "LM" : s.top() == 1 ? "LW" : "MW");
}
int main() {
int i;
cin >> n;
for (i = 1; i <= n; i++) scanf("%d%d%d", &L[i], &M[i], &W[i]);
dfs1(1, 0, 0, 0, 0);
dfs2(n / 2 + 1, 0, 0, 0, 0);
if (!f)
puts("Impossible");
else
otp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost[26][3];
int poss[3][3] = {{0, 1, 1}, {1, 0, 1}, {1, 1, 0}};
set<pair<int, int> > s2;
vector<pair<pair<int, int>, int> > s1;
map<pair<int, int>, int> m2;
map<pair<int, int>, int> mx2;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> cost[i][j];
}
}
if (n == 1) {
bool ok = false;
int ans = 0;
int mx = -2000000000;
for (int i = 0; i < 3; i++) {
int l = poss[i][0] * cost[0][0];
int m = poss[i][1] * cost[0][1];
int w = poss[i][2] * cost[0][2];
if (l == m and m == w) {
ok = true;
if (l > mx) {
mx = l;
ans = i;
}
}
}
if (ok) {
if (poss[ans][0]) cout << "L";
if (poss[ans][1]) cout << "M";
if (poss[ans][2]) cout << "W";
cout << "\n";
} else {
cout << "Impossible"
<< "\n";
}
exit(0);
}
int sz1 = n / 2;
int sz2 = n / 2;
sz1 += n & 1;
int pos1 = 1;
for (int i = 0; i < sz1; i++) {
pos1 *= 3;
}
for (int i = 0; i < pos1; i++) {
int cur = i;
int l = 0, m = 0, w = 0;
for (int j = 0; j < sz1; j++) {
int aux = cur % 3;
l += poss[aux][0] * cost[j][0];
m += poss[aux][1] * cost[j][1];
w += poss[aux][2] * cost[j][2];
cur /= 3;
}
s1.push_back(make_pair(make_pair(m - l, m - w), i));
}
int pos2 = 1;
for (int i = 0; i < sz2; i++) {
pos2 *= 3;
}
for (int i = 0; i < pos2; i++) {
int cur = i;
int l = 0, m = 0, w = 0;
for (int j = sz1; j < n; j++) {
int aux = cur % 3;
l += poss[aux][0] * cost[j][0];
m += poss[aux][1] * cost[j][1];
w += poss[aux][2] * cost[j][2];
cur /= 3;
}
s2.insert(make_pair(m - l, m - w));
auto it = mx2.find(make_pair(m - l, m - w));
if (it != mx2.end()) {
if (it->second < l + w + m) {
m2[make_pair(m - l, m - w)] = i;
mx2[make_pair(m - l, m - w)] = l + w + m;
}
} else {
m2[make_pair(m - l, m - w)] = i;
mx2[make_pair(m - l, m - w)] = l + w + m;
}
}
int ans1 = 0;
int ans2 = 0;
int mx = -2000000000;
for (auto x : s1) {
pair<int, int> i = x.first;
if (s2.count(make_pair(-i.first, -i.second))) {
int n1 = x.second;
int n2 = m2[make_pair(-i.first, -i.second)];
int nn1 = n1;
int nn2 = n2;
int l = 0;
for (int j = 0; j < sz1; j++) {
int aux = n1 % 3;
if (poss[aux][0]) {
l += cost[j][0];
}
n1 /= 3;
}
for (int j = 0; j < sz2; j++) {
int aux = n2 % 3;
if (poss[aux][0]) {
l += cost[sz1 + j][0];
}
n2 /= 3;
}
if (l > mx) {
mx = l;
ans1 = nn1;
ans2 = nn2;
}
}
}
if (mx == -2000000000)
cout << "Impossible"
<< "\n";
else {
for (int j = 0; j < sz1; j++) {
int aux = ans1 % 3;
if (poss[aux][0]) cout << "L";
if (poss[aux][1]) cout << "M";
if (poss[aux][2]) cout << "W";
ans1 /= 3;
cout << "\n";
}
for (int j = 0; j < sz2; j++) {
int aux = ans2 % 3;
if (poss[aux][0]) cout << "L";
if (poss[aux][1]) cout << "M";
if (poss[aux][2]) cout << "W";
ans2 /= 3;
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
map<pair<long long, long long>, pair<long long, long long>> mp;
vector<tuple<long long, long long, long long>> v;
pair<long long, long long> ans(-LINF, 0);
void solve(int pos, int left, long long sum,
tuple<long long, long long, long long> cur, long long mask,
long long p, bool is_r) {
auto [l, m, w] = cur;
if (!left) {
if (is_r) {
pair<long long, long long> curdif(m - l, w - m);
if (!mp.count(curdif))
mp[curdif] = {sum, mask};
else
mp[curdif] = max(mp[curdif], make_pair(sum, mask));
} else {
pair<long long, long long> need(-(m - l), -(w - m));
if (mp.count(need))
ans = max(ans, make_pair(mp[need].first + sum, mp[need].second + mask));
}
return;
}
auto [vl, vm, vw] = v[pos];
tuple<long long, long long, long long> aux = {l, m + vm, w + vw};
solve(pos + 1, left - 1, sum + vm + vw, aux, mask, p * 3, is_r);
aux = {l + vl, m, w + vw};
solve(pos + 1, left - 1, sum + vl + vw, aux, mask + p, p * 3, is_r);
aux = {l + vl, m + vm, w};
solve(pos + 1, left - 1, sum + vl + vm, aux, mask + 2 * p, p * 3, is_r);
}
int main() {
if (!false) ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
v.resize(n);
for (auto& [l, m, w] : v) cin >> l >> m >> w;
vector<long long> p3(n + 1);
long long p = 1;
for (int i = 0; i <= n; i++) p3[i] = p, p *= 3;
int lsz = (n + 1) / 2, rsz = n - lsz;
tuple<long long, long long, long long> tnull(0, 0, 0);
solve(lsz, rsz, 0, tnull, 0, p3[lsz], true);
solve(0, lsz, 0, tnull, 0, 1, false);
if (ans.first == -LINF) {
cout << "Impossible" << '\n';
return 0;
}
long long mask = ans.second;
for (int i = 0; i < n; i++) {
if (mask % 3 == 0) cout << "MW" << '\n';
if (mask % 3 == 1) cout << "LW" << '\n';
if (mask % 3 == 2) cout << "LM" << '\n';
mask /= 3;
}
return 0;
}
|
#include <bits/stdc++.h>
const int MOD = int(1e9) + 7;
inline int add(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline void inc(int &a, int b) { a = add(a, b); }
inline int sub(int a, int b) { return (a - b < 0) ? (a - b + MOD) : (a - b); }
inline void dec(int &a, int b) { a = sub(a, b); }
inline int mul(int a, int b) { return (a * 1ll * b) % MOD; }
using namespace std;
const int N = 25;
int L[N], M[N], W[N];
map<pair<int, int>, pair<int, int> > A, B;
stack<int> S;
string str = "LMW";
void init(int from, int to, int a, int b, int c, int x,
map<pair<int, int>, pair<int, int> > &_map) {
if (from == to) {
pair<int, int> p = make_pair((b - a), (c - b)), q = make_pair((a), (x));
if (_map.count(p) == 0 || _map[p] < q) _map[p] = q;
return;
}
init(from + 1, to, a + L[from], b + M[from], c, x * 3 + 2, _map);
init(from + 1, to, a + L[from], b, c + W[from], x * 3 + 1, _map);
init(from + 1, to, a, b + M[from], c + W[from], x * 3, _map);
}
void print(int x, int n) {
for (int i = 0; i < n; i++) {
S.push(x % 3);
x /= 3;
}
while (!S.empty()) {
for (int i = 0; i < 3; i++)
if (S.top() != i) printf("%c", str[i]);
puts("");
S.pop();
}
}
bool solve(int testNumber) {
int n;
if (scanf("%d", &n) == EOF) return false;
for (int i = 0; i < n; i++) scanf("%d %d %d", &L[i], &M[i], &W[i]);
A.clear();
B.clear();
init(0, n / 2, 0, 0, 0, 0, A);
init(n / 2, n, 0, 0, 0, 0, B);
int ret = INT_MIN;
for (__typeof((A).begin()) it = (A).begin(); it != (A).end(); ++it) {
pair<int, int> p = make_pair((-it->first.first), (-it->first.second));
if (B.count(p) > 0) ret = max(ret, it->second.first + B[p].first);
}
if (ret == INT_MIN)
puts("Impossible");
else
for (__typeof((A).begin()) it = (A).begin(); it != (A).end(); ++it) {
pair<int, int> p = make_pair((-it->first.first), (-it->first.second));
if (B.count(p) > 0 && it->second.first + B[p].first == ret) {
print(A[it->first].second, n / 2);
print(B[p].second, n - n / 2);
break;
}
}
return true;
}
int main() {
for (int i = 1; solve(i); i++)
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MINF = -23333333333333333;
int N, M;
long long A[25], B[25], C[25];
map<pair<long long, long long>, pair<long long, int>> F;
long long H = MINF;
int G1, G2;
const char *X[3]{"LM", "MW", "LW"};
void dfs1(int m, int n, long long a, long long b, long long c, int s, int d) {
if (m == n) {
auto i = F.find(make_pair(a - b, b - c));
if (i == F.end())
F.insert(make_pair(make_pair(a - b, b - c), make_pair(a, s)));
else if (i->second.first < a) {
i->second = make_pair(a, s);
}
return;
}
dfs1(m + 1, n, a + A[m], b + B[m], c, s, d * 3);
dfs1(m + 1, n, a, b + B[m], c + C[m], s + d, d * 3);
dfs1(m + 1, n, a + A[m], b, c + C[m], s + (d << 1), d * 3);
}
void dfs2(int m, int n, long long a, long long b, long long c, int s, int d) {
if (m == n) {
auto i = F.find(make_pair(b - a, c - b));
if (i != F.end() && i->second.first + a > H) {
H = i->second.first + a;
G1 = i->second.second;
G2 = s;
}
return;
}
dfs2(m + 1, n, a + A[m], b + B[m], c, s, d * 3);
dfs2(m + 1, n, a, b + B[m], c + C[m], s + d, d * 3);
dfs2(m + 1, n, a + A[m], b, c + C[m], s + (d << 1), d * 3);
}
int main() {
ios::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < N; ++i) cin >> A[i] >> B[i] >> C[i];
M = N >> 1;
dfs1(0, M, 0, 0, 0, 0, 1);
dfs2(M, N, 0, 0, 0, 0, 1);
if (H > MINF) {
for (int i = 0; i < M; ++i, G1 /= 3) cout << X[G1 % 3] << endl;
for (int i = M; i < N; ++i, G2 /= 3) cout << X[G2 % 3] << endl;
} else
cout << "Impossible" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[27][3];
for (int i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
}
int n2 = n / 2;
map<pair<int, int>, pair<int, int> > left;
int pw = 1;
for (int i = 0; i < n2; i++) pw *= 3;
for (int i = 0; i < pw; i++) {
int sm[3] = {0};
int msk = i;
for (int j = 0; j < n2; j++) {
sm[(msk % 3 + 1) % 3] += a[j][(msk % 3 + 1) % 3];
sm[(msk % 3 + 2) % 3] += a[j][(msk % 3 + 2) % 3];
msk /= 3;
}
pair<int, int> in = make_pair(sm[1] - sm[0], sm[2] - sm[1]);
if (!left.count(in))
left[in] = make_pair(sm[0], i);
else
left[in] = max(left[in], make_pair(sm[0], i));
}
int n1 = n - n2;
pw = 1;
for (int i = 0; i < n1; i++) pw *= 3;
int best = -1000000000;
int msk1 = -1, msk2 = -1;
for (int i = 0; i < pw; i++) {
int sm[3] = {0};
int msk = i;
for (int j = n2; j < n; j++) {
sm[(msk % 3 + 1) % 3] += a[j][(msk % 3 + 1) % 3];
sm[(msk % 3 + 2) % 3] += a[j][(msk % 3 + 2) % 3];
msk /= 3;
}
pair<int, int> in = make_pair(-(sm[1] - sm[0]), -(sm[2] - sm[1]));
if (left.count(in)) {
pair<int, int> r = left[in];
if (sm[0] + r.first > best) {
best = sm[0] + r.first;
msk1 = i;
msk2 = r.second;
}
}
}
string S = "LMW";
if (msk1 == -1) {
cout << "Impossible" << endl;
} else {
for (int i = 0; i < n2; i++) {
cout << S[(msk2 % 3 + 1) % 3] << S[(msk2 % 3 + 2) % 3] << endl;
msk2 /= 3;
}
for (int i = 0; i < n1; i++) {
cout << S[(msk1 % 3 + 1) % 3] << S[(msk1 % 3 + 2) % 3] << endl;
msk1 /= 3;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int val[30][3];
int n;
string path;
map<pair<int, int>, pair<int, string> > m[2];
string mp[] = {"MW\n", "LW\n", "LM\n"};
map<pair<int, int>, pair<int, string> >::iterator iter, ater;
int ans = (int)-1e9;
string sp;
void dfs(int k, int h, int x, int p, int q, int r) {
if (h == 0) {
if (k == 0) {
iter = m[1].find(make_pair(-p + q, -q + r));
if (iter != m[1].end()) {
if (ans < p + iter->second.first) {
ans = p + iter->second.first;
ater = iter;
sp = path;
}
}
} else {
iter = m[k].find(make_pair(p - q, q - r));
if (iter != m[k].end()) {
if (iter->second.first < p) {
iter->second.first = p;
iter->second.second = path;
}
} else {
m[k][make_pair(p - q, q - r)] = make_pair(p, path);
}
}
return;
}
path += mp[0];
dfs(k, h - 1, x + 1, p, q + val[x][1], r + val[x][2]);
path.erase(path.size() - 3);
path += mp[1];
dfs(k, h - 1, x + 1, p + val[x][0], q, r + val[x][2]);
path.erase(path.size() - 3);
path += mp[2];
dfs(k, h - 1, x + 1, p + val[x][0], q + val[x][1], r);
path.erase(path.size() - 3);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
scanf("%d", &val[i][j]);
}
}
if (n == 1) {
for (int i = 0; i < 3; ++i) {
int j = (i + 1) % 3;
if (val[0][i] == val[0][j] && !val[0][i]) {
cout << mp[(i + 2) % 3];
return 0;
}
}
printf("Impossible\n");
return 0;
}
int h = n / 2;
dfs(1, h, n - h, 0, 0, 0);
dfs(0, n - h, 0, 0, 0, 0);
if (ans > (int)-1e9) {
cout << sp;
cout << (ater->second.second);
} else {
printf("Impossible\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string x[] = {"LM", "LW", "MW"};
int cost[30][3], up;
map<pair<int, int>, pair<int, int> > dp[30];
void dfs(int pos, int A, int B, int C, int path) {
if (pos == up + 1) {
pair<int, int> cur = make_pair(B - A, C - A);
pair<int, int> val = make_pair(A, path);
auto it = dp[up].find(cur);
if (it == dp[up].end() || (it->second) < val) {
dp[up][cur] = val;
}
return;
}
dfs(pos + 1, A + cost[pos][0], B + cost[pos][1], C, (path << 2) | 0);
dfs(pos + 1, A + cost[pos][0], B, C + cost[pos][2], (path << 2) | 1);
dfs(pos + 1, A, B + cost[pos][1], C + cost[pos][2], (path << 2) | 2);
}
int main() {
int n, L, M, W, p1, p2;
scanf("%d", &n);
for (int i = 0; i < (int)n; ++i) {
scanf("%d %d %d", &L, &M, &W);
cost[i][0] = L;
cost[i][1] = M;
cost[i][2] = W;
}
if (n == 1) {
if (L == 0 && M == 0) {
printf("LM\n");
} else if (L == 0 && W == 0) {
printf("LW\n");
} else if (W == 0 && M == 0) {
printf("MW\n");
} else
printf("Impossible\n");
return 0;
}
up = n / 2 - 1;
dfs(0, 0, 0, 0, 0);
up = n - 1;
dfs(n / 2, 0, 0, 0, 0);
int mx = INT_MIN;
for (auto it = dp[n / 2 - 1].begin(); it != dp[n / 2 - 1].end(); ++it) {
pair<int, int> cur = it->first;
cur.first = -cur.first;
cur.second = -cur.second;
auto ptr = dp[n - 1].find(cur);
if (ptr != dp[n - 1].end()) {
int vv = (ptr->second).first + (it->second).first;
if (vv > mx) {
mx = vv;
p1 = (it->second).second;
p2 = (ptr->second).second;
}
}
}
if (mx == INT_MIN)
printf("Impossible\n");
else {
vector<int> res(n);
for (int i = n / 2 - 1; i >= 0; --i) {
res[i] = (p1 & 3);
p1 >>= 2;
}
for (int i = n - 1; i >= n / 2; --i) {
res[i] = (p2 & 3);
p2 >>= 2;
}
for (int i = 0; i < n; ++i) {
printf("%s\n", x[res[i]].c_str());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> ma, Ma;
char str[3];
int n, i, a[100], b[100], c[100], Ans, A1, A2, ans[100];
void dfs(long long x, long long y, long long z, int d, int k) {
if (d > n / 2) {
long long tmp = (y - x) * 300007 + (z - x);
if ((ma.find(tmp) == ma.end()) || (x > ma[tmp])) {
ma[tmp] = x;
Ma[tmp] = k;
}
return;
}
dfs(x + a[d], y + b[d], z, d + 1, k * 3);
dfs(x, y + b[d], z + c[d], d + 1, k * 3 + 1);
dfs(x + a[d], y, z + c[d], d + 1, k * 3 + 2);
}
void Dfs(long long x, long long y, long long z, int d, int k) {
if (d > n) {
long long tmp = (x - y) * 300007 + (x - z);
if (ma.find(tmp) != ma.end()) {
if (ma[tmp] + x > Ans) {
Ans = ma[tmp] + x;
A1 = Ma[tmp];
A2 = k;
}
}
return;
}
Dfs(x + a[d], y + b[d], z, d + 1, k * 3);
Dfs(x, y + b[d], z + c[d], d + 1, k * 3 + 1);
Dfs(x + a[d], y, z + c[d], d + 1, k * 3 + 2);
}
int main() {
scanf("%d", &n);
Ans = -0x37373737;
int q = 0;
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
dfs(0, 0, 0, 1, 0);
Dfs(0, 0, 0, n / 2 + 1, 0);
if (Ans == -0x37373737)
printf("Impossible");
else {
for (i = n; i > n / 2; i--) {
ans[i] = A2 % 3;
A2 = A2 / 3;
}
for (i = n / 2; i >= 1; i--) {
ans[i] = A1 % 3;
A1 = A1 / 3;
}
for (i = 1; i <= n; i++)
if (ans[i] == 0)
printf("LM\n");
else if (ans[i] == 1)
printf("MW\n");
else if (ans[i] == 2)
printf("LW\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
int N;
int l[30], m[30], w[30];
void dfs(map<pair<int, int>, pair<int, long long>> &comb, int i, int n, int x,
int y, int z, long long s) {
if (i == n) {
pair<int, int> ofs = make_pair(x - y, x - z);
if ((comb.find(ofs) != comb.end()))
comb[ofs] = max(comb[ofs], make_pair(x, s));
else
comb[ofs] = make_pair(x, s);
return;
}
dfs(comb, i + 1, n, x, y + m[i], z + w[i], 3 * s);
dfs(comb, i + 1, n, x + l[i], y, z + w[i], 3 * s + 1);
dfs(comb, i + 1, n, x + l[i], y + m[i], z, 3 * s + 2);
}
int main(void) {
cin >> N;
for (int i = (int)(0); i < (int)(N); i++) cin >> l[i] >> m[i] >> w[i];
map<pair<int, int>, pair<int, long long>> comb1, comb2;
dfs(comb1, 0, N / 2, 0, 0, 0, 0);
dfs(comb2, N / 2, N, 0, 0, 0, 0);
string ans[25];
const string C[] = {"MW", "LW", "LM"};
int mx = -INF;
for (__typeof(comb1.begin()) it = comb1.begin(); it != comb1.end(); it++) {
pair<int, int> ofs = (*it).first;
int x1 = (*it).second.first;
long long s1 = (*it).second.second;
pair<int, int> rofs = make_pair(-ofs.first, -ofs.second);
if ((comb2.find(rofs) != comb2.end())) {
int x2 = comb2[rofs].first;
long long s2 = comb2[rofs].second;
if (x1 + x2 < mx) continue;
mx = x1 + x2;
for (int i = (int)(0); i < (int)(N / 2); i++) {
ans[i] = C[s1 % 3];
s1 /= 3;
}
reverse(ans, ans + (N / 2));
for (int i = (int)(N / 2); i < (int)(N); i++) {
ans[i] = C[s2 % 3];
s2 /= 3;
}
reverse(ans + (N / 2), ans + N);
}
}
if (mx > -INF) {
for (int i = (int)(0); i < (int)(N); i++) cout << ans[i] << '\n';
} else {
cout << "Impossible" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int P[15];
void Init() {
P[0] = 1;
for (int i = 1; i < 15; i++) P[i] = P[i - 1] * 3;
}
int n, V[26][4];
struct node {
long long v1, v2, v;
int now;
bool operator==(const node &_) const { return v1 == _.v1 && v2 == _.v2; }
bool operator<(const node &_) const {
if (v1 == _.v1) {
if (v2 == _.v2) return v > _.v;
return v2 < _.v2;
}
return v1 < _.v1;
}
} A1[1594325], A2[1594325], B[1594325];
int n1, n2;
void solve(int L, int R, int p) {
int len = R - L + 1;
int n3 = 0;
for (int i = 0; i < P[len]; i++) {
long long v1 = 0, v2 = 0, v3 = 0;
for (int j = 0; j < len; j++) {
int p1 = i / P[j] % 3;
if (p1 == 0) v1 += V[j + L][1], v2 += V[j + L][2];
if (p1 == 1) v1 += V[j + L][1], v3 += V[j + L][3];
if (p1 == 2) v2 += V[j + L][2], v3 += V[j + L][3];
}
B[++n3] = (node){v1 - v2, v1 - v3, v1, i};
}
sort(B + 1, B + 1 + n3);
for (int i = 1; i <= n3; i++) {
if (B[i] == B[i - 1]) continue;
if (!p)
A1[++n1] = B[i];
else
A2[++n2] = B[i];
}
}
int main() {
Init();
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 3; j++) scanf("%d", &V[i][j]);
if (n == 1) {
if (V[1][1] == 0 && V[1][2] == 0)
puts("LM");
else if (V[1][1] == 0 && V[1][3] == 0)
puts("LW");
else if (V[1][2] == 0 && V[1][3] == 0)
puts("MW");
else
puts("Impossible");
return 0;
}
solve(1, n / 2, 0);
solve(n / 2 + 1, n, 1);
long long mx = -1e18;
int a1 = 0, a2 = 0;
for (int i = 1; i <= n1; i++) {
node ned = (node){-A1[i].v1, -A1[i].v2, 0, 0};
int x = lower_bound(A2 + 1, A2 + 1 + n2, ned) - A2;
for (int j = max(1, x - 1); j <= min(x + 1, n2); j++) {
if (A2[j] == ned) {
long long v = A1[i].v + A2[j].v;
if (v > mx) mx = v, a1 = i, a2 = j;
}
}
}
if (a1 == 0)
puts("Impossible");
else {
int L = 1, R = n / 2;
for (int i = 0; i < R - L + 1; i++) {
int p = A1[a1].now / P[i] % 3;
if (p == 0) puts("LM");
if (p == 1) puts("LW");
if (p == 2) puts("MW");
}
L = n / 2 + 1, R = n;
for (int i = 0; i < R - L + 1; i++) {
int p = A2[a2].now / P[i] % 3;
if (p == 0) puts("LM");
if (p == 1) puts("LW");
if (p == 2) puts("MW");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[25][3];
int b[26];
map<pair<int, int>, pair<int, int> > mp;
int main() {
int n, ans = -1e9, c1, c2, i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d %d %d", &a[i][0], &a[i][1], &a[i][2]);
if (n == 1) {
if (a[0][0] == 0 && a[0][1] == 0) {
puts("LM");
} else if (a[0][0] == 0 && a[0][2] == 0) {
puts("LW");
} else if (a[0][1] == 0 && a[0][2] == 0) {
puts("MW");
} else {
puts("Impossible");
}
return 0;
}
b[0] = 1;
for (i = 1; i <= n; i++) b[i] = b[i - 1] * 3;
for (i = 0; i < b[(n + 1) / 2]; i++) {
int x = 0, y = 0, z = 0, p = i;
for (j = 0; j < (n + 1) / 2; j++) {
if (p % 3 == 0) {
y += a[j][1];
z += a[j][2];
} else if (p % 3 == 1) {
x += a[j][0];
z += a[j][2];
} else {
x += a[j][0];
y += a[j][1];
}
p /= 3;
}
if (!mp.count(make_pair(y - x, z - x)) ||
mp[make_pair(y - x, z - x)].first < x) {
mp[make_pair(y - x, z - x)] = make_pair(x, i);
}
}
for (i = 0; i < b[n / 2]; i++) {
int x = 0, y = 0, z = 0, p = i;
for (j = 0; j < n / 2; j++) {
if (p % 3 == 0) {
y += a[j + (n + 1) / 2][1];
z += a[j + (n + 1) / 2][2];
} else if (p % 3 == 1) {
x += a[j + (n + 1) / 2][0];
z += a[j + (n + 1) / 2][2];
} else {
x += a[j + (n + 1) / 2][0];
y += a[j + (n + 1) / 2][1];
}
p /= 3;
}
if (mp.count(make_pair(x - y, x - z)) &&
mp[make_pair(x - y, x - z)].first + x > ans) {
ans = mp[make_pair(x - y, x - z)].first + x;
c1 = mp[make_pair(x - y, x - z)].second;
c2 = i;
}
}
if (ans == -1e9) {
puts("Impossible");
} else {
for (i = 0; i < (n + 1) / 2; i++) {
if (c1 % 3 == 0) {
puts("MW");
} else if (c1 % 3 == 1) {
puts("LW");
} else {
puts("LM");
}
c1 /= 3;
}
for (i = 0; i < n / 2; i++) {
if (c2 % 3 == 0) {
puts("MW");
} else if (c2 % 3 == 1) {
puts("LW");
} else {
puts("LM");
}
c2 /= 3;
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 2147483647;
const int MOD = 1000000007;
const long long INF64 = 9223372036854775807;
using namespace std;
vector<pair<pair<int, int>, pair<int, string> > > s;
int l[25], m[25], w[25];
int res = -INF;
string ans = "Impossible\n";
bool comp(pair<pair<int, int>, pair<int, string> > a,
pair<pair<int, int>, pair<int, string> > b) {
return (a.first.first == b.first.first
? (a.first.second == b.first.second
? a.second.first > b.second.first
: a.first.second < b.first.second)
: a.first.first < b.first.first);
}
void check(int k, int a, int b, int c, int n, string cur) {
if (k == n) {
s.push_back(make_pair(make_pair(a - b, b - c), make_pair(a, cur)));
} else {
check(k + 1, a + l[k], b + m[k], c, n, cur + "LM");
check(k + 1, a, b + m[k], c + w[k], n, cur + "MW");
check(k + 1, a + l[k], b, c + w[k], n, cur + "LW");
}
}
void check2(int k, int a, int b, int c, int n, string cur) {
if (k == n) {
vector<pair<pair<int, int>, pair<int, string> > >::iterator it =
lower_bound((s).begin(), (s).end(),
make_pair(make_pair(b - a, c - b), make_pair(-INF, cur)));
if (it != s.end() && it->first.first == b - a &&
it->first.second == c - b && it->second.first + a > res) {
res = it->second.first + a;
ans = it->second.second + cur;
}
} else {
check2(k + 1, a + l[k], b + m[k], c, n, cur + "LM");
check2(k + 1, a, b + m[k], c + w[k], n, cur + "MW");
check2(k + 1, a + l[k], b, c + w[k], n, cur + "LW");
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d%d", l + i, m + i, w + i);
int k = n / 2;
check(0, 0, 0, 0, k, "");
sort((s).begin(), (s).end(), comp);
check2(k, 0, 0, 0, n, "");
if (ans == "Impossible\n") {
cout << ans;
return 0;
}
for (int i = 0; i < ans.size(); i += 2) cout << ans[i] << ans[i + 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 26;
const int inf = 0x3f3f3f3f;
int n;
int a[3][maxn];
char s[3][4] = {"MW", "LW", "LM"};
struct node {
int id, x, d1, d2;
node() {}
node(int id, int x, int d1, int d2) : id(id), x(x), d1(d1), d2(d2) {}
bool operator<(const node &rhs) const {
if (d1 != rhs.d1) return d1 < rhs.d1;
return d2 < rhs.d2;
}
} s1[2222222], s2[2222222];
node cal(int beg, int end, int st) {
int sum[3] = {0, 0, 0};
int ss = st;
for (int i = beg; i < end; i++) {
int x = st % 3;
st /= 3;
for (int j = 0; j < 3; j++) {
if (j == x) continue;
sum[j] += a[j][i];
}
}
return node(ss, sum[0], sum[1] - sum[0], sum[2] - sum[0]);
}
void print(int beg, int end, int st) {
for (int i = beg; i < end; i++) {
int x = st % 3;
puts(s[x]);
st /= 3;
}
}
int pow3[15];
int main() {
pow3[0] = 1;
for (int i = 1; i <= 13; i++) pow3[i] = pow3[i - 1] * 3;
while (cin >> n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) scanf("%d", &a[j][i]);
if (n == 1) {
bool flag = 0;
for (int i = 0; i < 3; i++) {
int cnt = 0;
for (int j = 0; j < 3; j++) {
if (j == i) continue;
if (a[j][0] == 0) cnt++;
}
if (cnt == 2) {
flag = 1;
puts(s[i]);
break;
}
}
if (!flag) puts("Impossible");
continue;
}
bool flag = 0;
int mx = -inf;
int m = n >> 1;
int c1 = pow3[m], c2 = pow3[n - m];
int st1, st2;
for (int i = 0; i < c1; i++) {
s1[i] = cal(0, m, i);
}
for (int i = 0; i < c2; i++) {
s2[i] = cal(m, n, i);
}
sort(s2, s2 + c2);
for (int i = 0; i < c1; i++) {
int beg = lower_bound(s2, s2 + c2, node(0, 0, -s1[i].d1, -s1[i].d2)) - s2;
int end = upper_bound(s2, s2 + c2, node(0, 0, -s1[i].d1, -s1[i].d2)) - s2;
for (int j = beg; j < end; j++) {
if (s1[i].d1 + s2[j].d1 != 0 || s1[i].d2 + s2[j].d2 != 0) break;
int all = s1[i].x + s2[j].x;
flag = 1;
if (all > mx) {
mx = all;
st1 = i;
st2 = s2[j].id;
}
}
}
if (!flag)
puts("Impossible");
else {
print(0, m, st1);
print(m, n, st2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, pair<int, int> > Hsh;
bool okz;
int result = -(1 << 29), a[666], b[666], c[666];
pair<int, int> coef_result;
void solve1(vector<int> grp) {
int N = grp.size();
int nr_pos = 1, i, j;
for (i = 1; i <= N; ++i) nr_pos *= 3;
for (i = 0; i < nr_pos; ++i) {
int value = i;
int v1 = 0, v2 = 0, v3 = 0;
for (j = 0; j < N; ++j, value /= 3) {
if (value % 3 == 0) v2 += b[grp[j]], v3 += c[grp[j]];
if (value % 3 == 1) v1 += a[grp[j]], v3 += c[grp[j]];
if (value % 3 == 2) v1 += a[grp[j]], v2 += b[grp[j]];
}
int cf1 = v1 - v2, cf2 = v1 - v3;
if (Hsh.find(make_pair(cf1, cf2)) == Hsh.end())
Hsh[make_pair(cf1, cf2)] = make_pair(v1, i);
else
Hsh[make_pair(cf1, cf2)] =
max(Hsh[make_pair(cf1, cf2)], make_pair(v1, i));
}
}
void solve2(vector<int> grp) {
int N = grp.size();
int nr_pos = 1, i, j;
for (i = 1; i <= N; ++i) nr_pos *= 3;
for (i = 0; i < nr_pos; ++i) {
int value = i;
int v1 = 0, v2 = 0, v3 = 0;
for (j = 0; j < N; ++j, value /= 3) {
if (value % 3 == 0) v2 += b[grp[j]], v3 += c[grp[j]];
if (value % 3 == 1) v1 += a[grp[j]], v3 += c[grp[j]];
if (value % 3 == 2) v1 += a[grp[j]], v2 += b[grp[j]];
}
int cf1 = -v1 + v2, cf2 = -v1 + v3;
if (Hsh.find(make_pair(cf1, cf2)) == Hsh.end()) continue;
pair<int, int> P = Hsh[make_pair(cf1, cf2)];
if (P.first + v1 > result) {
result = P.first + v1;
coef_result = make_pair(P.second, i);
okz = true;
}
}
}
void print_result(int value, int N) {
for (int i = 1; i <= N; ++i, value /= 3) {
if (value % 3 == 0) cout << "MW";
if (value % 3 == 1) cout << "LW";
if (value % 3 == 2) cout << "LM";
cout << '\n';
}
}
int main() {
int n, i;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i] >> b[i] >> c[i];
if (n == 1) {
if ((a[1] != 0 && b[1] != 0) || (a[1] != 0 && c[1] != 0) ||
(b[1] != 0 && c[1] != 0)) {
cout << "Impossible";
return 0;
} else {
int nr = 0;
if (a[1] == 0) cout << "L", ++nr;
if (b[1] == 0) cout << "M", ++nr;
if (c[1] == 0 && nr == 1) cout << "W";
return 0;
}
return 0;
}
vector<int> first_group, second_group;
for (i = 1; i <= n / 2; ++i) first_group.push_back(i);
for (i = n / 2 + 1; i <= n; ++i) second_group.push_back(i);
solve1(first_group);
solve2(second_group);
if (okz == false) {
cout << "Impossible";
;
return 0;
}
print_result(coef_result.first, n / 2);
print_result(coef_result.second, n - n / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, a[3][30], half;
long long ans, ans1, ans2;
struct node {
long long x, y, z;
bool operator<(const node& T) const {
if (x != T.x)
return x < T.x;
else if (y != T.y)
return y < T.y;
else
return z < T.z;
}
};
map<node, long long> b;
void pt(long long s, long long s1) {
long long val = 0;
long long temp = s;
long long temp1 = s1;
for (int w = 0; w < half; w++) {
if (s % 3 == 1 || s % 3 == 2) val += a[0][w];
s /= 3;
}
for (int w = half; w < n; w++) {
if (s1 % 3 == 1 || s1 % 3 == 2) val += a[0][w];
s1 /= 3;
}
if (val > ans) {
ans = val;
ans1 = temp;
ans2 = temp1;
}
}
void solve(int ind, long long s, long long r, long long w, long long mask) {
if (ind == -1) {
long long g = min(s, min(r, w));
s -= g;
r -= g;
w -= g;
b[{s, r, w}] = mask;
} else {
solve(ind - 1, s, r + a[1][ind], w + a[2][ind], mask * 3);
solve(ind - 1, s + a[0][ind], r, w + a[2][ind], mask * 3 + 1);
solve(ind - 1, s + a[0][ind], r + a[1][ind], w, mask * 3 + 2);
}
}
void solve1(int ind, long long s, long long r, long long w, long long mask) {
if (ind == half - 1) {
long long g = min(s, min(r, w));
node temp = {s, r, w};
s -= g;
r -= g;
w -= g;
if (s >= r && s >= w) {
if (b[{0, s - r, s - w}]) {
pt(b[{0, s - r, s - w}], mask);
}
}
if (r >= s && r >= w) {
if (b[{r - s, 0, r - w}]) {
pt(b[{r - s, 0, r - w}], mask);
}
}
if (w >= s && w >= r) {
if (b[{w - s, w - r, 0}]) {
pt(b[{w - s, w - r, 0}], mask);
}
}
} else {
solve1(ind - 1, s, r + a[1][ind], w + a[2][ind], mask * 3);
solve1(ind - 1, s + a[0][ind], r, w + a[2][ind], mask * 3 + 1);
solve1(ind - 1, s + a[0][ind], r + a[1][ind], w, mask * 3 + 2);
}
}
int main() {
scanf("%d", &n);
b.clear();
for (i = 0; i < n; i++) scanf("%d%d%d", &a[0][i], &a[1][i], &a[2][i]);
if (n == 1) {
if (a[0][0] == 0 && a[1][0] == 0)
printf("LM\n");
else if (a[0][0] == 0 && a[2][0] == 0)
printf("LW\n");
else if (a[1][0] == 0 && a[2][0] == 0)
printf("MW\n");
else
printf("Impossible\n");
return 0;
}
half = (n + 1) / 2;
ans = -1000000000;
solve(half - 1, 0, 0, 0, 0);
solve1(n - 1, 0, 0, 0, 0);
if (ans == -1000000000)
return 0 * printf("Impossible\n");
else {
for (i = 0; i < half; i++) {
if (ans1 % 3 == 0)
printf("MW\n");
else if (ans1 % 3 == 1)
printf("LW\n");
else
printf("LM\n");
ans1 /= 3;
}
for (i = half; i < n; i++) {
if (ans2 % 3 == 0)
printf("MW\n");
else if (ans2 % 3 == 1)
printf("LW\n");
else
printf("LM\n");
ans2 /= 3;
}
}
}
|
#include <bits/stdc++.h>
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
std::pair<int, int> operator+(std::pair<int, int> a, std::pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
std::pair<long long, long long> operator+(std::pair<long long, long long> a,
std::pair<long long, long long> b) {
return {a.first + b.first, a.second + b.second};
}
std::ostream& operator<<(std::ostream& out, std::pair<int, int> a) {
out << a.first << " " << a.second << "\n";
return out;
}
std::ostream& operator<<(std::ostream& out, std::pair<long long, long long> a) {
out << a.first << " " << a.second << "\n";
return out;
}
std::istream& operator>>(std::istream& in, std::pair<int, int>& a) {
in >> a.first >> a.second;
return in;
}
std::istream& operator>>(std::istream& in, std::pair<long long, long long>& a) {
in >> a.first >> a.second;
return in;
}
using namespace std;
long long power(int a, int b) {
long long int ans = 1;
for (int i = 0; i < b; ++i) {
ans *= a;
}
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int l[n], m[n], w[n];
for (int i = 0; i < n; ++i) {
cin >> l[i] >> m[i] >> w[i];
}
if (n == 1) {
if (l[0] == 0 && w[0] == 0) {
cout << "LW";
} else if (l[0] == 0 && m[0] == 0) {
cout << "LM";
} else if (m[0] == 0 && w[0] == 0) {
cout << "MW";
} else {
cout << "Impossible";
}
return 0;
}
int l1[n / 2], m1[n / 2], w1[n / 2];
int l2[n - n / 2], m2[n - n / 2], w2[n - n / 2];
for (int i = 0; i < n; ++i) {
if (i < n / 2) {
l1[i] = l[i];
m1[i] = m[i];
w1[i] = w[i];
} else {
l2[i - n / 2] = l[i];
m2[i - n / 2] = m[i];
w2[i - n / 2] = w[i];
}
}
map<std::pair<int, int>, std::pair<int, int> > conf1, conf2;
for (int i = 0; i < power(3, n / 2); ++i) {
int t = i;
int ly = 0, me = 0, wo = 0;
for (int k = 0; k < n / 2; ++k) {
if (t % 3 == 0) {
ly += l1[k];
me += m1[k];
} else if (t % 3 == 1) {
ly += l1[k];
wo += w1[k];
} else {
wo += w1[k];
me += m1[k];
}
t = t / 3;
}
me -= ly;
wo -= ly;
if (conf1.count(make_pair(me, wo)) == 0)
conf1[make_pair(me, wo)] = {ly, i};
else {
if (conf1[make_pair(me, wo)].first < ly) {
conf1[make_pair(me, wo)] = {ly, i};
}
}
}
for (int i = 0; i < power(3, n - n / 2); ++i) {
int t = i;
int ly = 0, me = 0, wo = 0;
for (int k = 0; k < n - n / 2; ++k) {
if (t % 3 == 0) {
ly += l2[k];
me += m2[k];
} else if (t % 3 == 1) {
ly += l2[k];
wo += w2[k];
} else {
wo += w2[k];
me += m2[k];
}
t /= 3;
}
me -= ly;
wo -= ly;
if (conf2.count(make_pair(me, wo)) == 0)
conf2[make_pair(me, wo)] = {ly, i};
else {
if (conf2[make_pair(me, wo)].first < ly) {
conf2[make_pair(me, wo)] = {ly, i};
}
}
}
int ans = (-2) * 1000000007;
int config1 = -1, config2 = -1;
for (auto& i : conf1) {
if (conf2.count(make_pair(-i.first.first, -i.first.second)) != 0) {
int x = conf1[i.first].first +
conf2[make_pair(-i.first.first, -i.first.second)].first;
if (x > ans) {
ans = x;
config1 = conf1[i.first].second;
config2 = conf2[make_pair(-i.first.first, -i.first.second)].second;
}
}
}
if (ans == (-2 * 1000000007))
cout << "Impossible";
else {
for (int i = 0; i < n / 2; ++i) {
if (config1 % 3 == 0) {
cout << "LM"
<< "\n";
} else if (config1 % 3 == 1) {
cout << "LW"
<< "\n";
} else
cout << "MW"
<< "\n";
config1 /= 3;
}
for (int i = 0; i < n - n / 2; ++i) {
if (config2 % 3 == 0) {
cout << "LM"
<< "\n";
} else if (config2 % 3 == 1) {
cout << "LW"
<< "\n";
} else
cout << "MW"
<< "\n";
config2 /= 3;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b, c;
} T[30];
struct nodt {
int a, b, c;
bool operator<(const nodt &p) const {
if (p.a != a) return a < p.a;
if (p.b != b) return b < p.b;
return c > p.c;
}
bool operator==(const nodt &p) const { return p.a == a && p.b == b; }
} mp[2000000];
bool found = 0, got = 0;
char res[5];
int n, ans[30], ans1, ans2, ans3, ma = -2000000000, now[30], CNT = 0, cnt = 0;
int fast[30];
int find(nodt res) {
int l = 1, r = cnt;
while (l <= r) {
int mid = l + r >> 1;
if (mp[mid] == res) return mid;
if (res < mp[mid])
r = mid - 1;
else
l = mid + 1;
}
return -1;
}
void make(int x, int y, int z, int d) {
if (d == n + 1) {
nodt P;
P.a = x - y, P.b = x - z;
P.c = x, mp[++CNT] = P;
return;
}
make(x + T[d].a, y + T[d].b, z, d + 1);
make(x, y + T[d].b, z + T[d].c, d + 1);
make(x + T[d].a, y, z + T[d].c, d + 1);
}
void search(int d, int x, int y, int z) {
if (x + fast[d] <= ma) return;
if (d == n / 2 + 1) {
nodt P;
P.a = y - x, P.b = z - x;
int pla = find(P);
if (pla != -1) {
if (mp[pla].c + x > ma) {
ma = mp[pla].c + x;
ans1 = y - x, ans2 = z - x, ans3 = mp[pla].c;
for (int i = 1; i < d; i++) ans[i] = now[i];
found = 1;
}
}
return;
}
now[d] = 2;
search(d + 1, x + T[d].a, y, z + T[d].c);
now[d] = 3;
search(d + 1, x + T[d].a, y + T[d].b, z);
now[d] = 1;
search(d + 1, x, y + T[d].b, z + T[d].c);
}
void research(int d, int x, int y, int z) {
if (got) return;
if (d == n + 1) {
if (x - y == ans1 && x - z == ans2 && x == ans3) got = 1;
return;
}
ans[d] = 2;
research(d + 1, x + T[d].a, y, z + T[d].c);
if (got) return;
ans[d] = 3;
research(d + 1, x + T[d].a, y + T[d].b, z);
if (got) return;
ans[d] = 1;
research(d + 1, x, y + T[d].b, z + T[d].c);
}
int main() {
int i, k, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d%d", &T[i].a, &T[i].b, &T[i].c);
for (i = n; i >= 1; i--)
fast[i] = fast[i + 1], fast[i] += (T[i].a) > 0 ? T[i].a : 0;
make(0, 0, 0, n / 2 + 1);
sort(mp + 1, mp + 1 + CNT);
mp[0].a = -2000000000, mp[0].b = -2000000000, mp[0].c = -2000000000;
for (i = 1; i <= CNT; i++)
if (!(mp[i] == mp[i - 1])) mp[++cnt] = mp[i];
search(1, 0, 0, 0);
res[1] = 'L', res[2] = 'M', res[3] = 'W';
if (found) {
for (i = 1; i <= n / 2; i++) {
for (k = 1; k <= 3; k++)
if (ans[i] != k) printf("%c", res[k]);
puts("");
}
research(n / 2 + 1, 0, 0, 0);
for (i = n / 2 + 1; i <= n; i++) {
for (k = 1; k <= 3; k++)
if (ans[i] != k) printf("%c", res[k]);
puts("");
}
} else
puts("Impossible");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> P;
map<pair<int, int>, int> mp;
struct node {
int a, b, c;
} T[30];
bool found = 0, got = 0;
char res[5];
int n, ans[30], ans1, ans2, ans3, ma = -2000000000, now[30];
int test[30];
void make(int x, int y, int z, int d) {
if (d == n + 1) {
P.first = x - y, P.second = x - z;
if (mp.find(P) == mp.end())
mp[P] = x;
else
mp[P] = max(mp[P], x);
return;
}
test[d] = 3;
make(x + T[d].a, y + T[d].b, z, d + 1);
test[d] = 1;
make(x, y + T[d].b, z + T[d].c, d + 1);
test[d] = 2;
make(x + T[d].a, y, z + T[d].c, d + 1);
}
void search(int d, int x, int y, int z) {
if (d == n / 2 + 1) {
P.first = y - x, P.second = z - x;
if (mp.find(P) != mp.end()) {
if (mp[P] + x > ma) {
ma = mp[P] + x;
ans1 = y - x, ans2 = z - x, ans3 = mp[P];
for (int i = 1; i < d; i++) ans[i] = now[i];
found = 1;
}
}
return;
}
now[d] = 2;
search(d + 1, x + T[d].a, y, z + T[d].c);
now[d] = 3;
search(d + 1, x + T[d].a, y + T[d].b, z);
now[d] = 1;
search(d + 1, x, y + T[d].b, z + T[d].c);
}
void research(int d, int x, int y, int z) {
if (got) return;
if (d == n + 1) {
if (x - y == ans1 && x - z == ans2 && x == ans3) got = 1;
return;
}
ans[d] = 2;
research(d + 1, x + T[d].a, y, z + T[d].c);
if (got) return;
ans[d] = 3;
research(d + 1, x + T[d].a, y + T[d].b, z);
if (got) return;
ans[d] = 1;
research(d + 1, x, y + T[d].b, z + T[d].c);
}
int main() {
int i, k, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d%d", &T[i].a, &T[i].b, &T[i].c);
make(0, 0, 0, n / 2 + 1);
P.first = 0, P.second = -1;
search(1, 0, 0, 0);
res[1] = 'L', res[2] = 'M', res[3] = 'W';
if (found) {
for (i = 1; i <= n / 2; i++) {
for (k = 1; k <= 3; k++)
if (ans[i] != k) printf("%c", res[k]);
puts("");
}
research(n / 2 + 1, 0, 0, 0);
for (i = n / 2 + 1; i <= n; i++) {
for (k = 1; k <= 3; k++)
if (ans[i] != k) printf("%c", res[k]);
puts("");
}
} else
puts("Impossible");
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:13371488228")
using namespace std;
long long n, n2;
map<tuple<long long, long long, long long>, long long> m, mm;
vector<tuple<long long, long long, long long> > d;
long long best = -1e15, ans_l, ans_r;
void gen_left(long long i, long long a, long long b, long long c,
long long mask) {
if (i == n2) {
m[make_tuple(a - b, a - c, b - c)] = mask;
mm[make_tuple(a - b, a - c, b - c)] = a;
return;
}
gen_left(i + 1, a, b + get<1>(d[i]), c + get<2>(d[i]), mask * 3 + 0);
gen_left(i + 1, a + get<0>(d[i]), b, c + get<2>(d[i]), mask * 3 + 1);
gen_left(i + 1, a + get<0>(d[i]), b + get<1>(d[i]), c, mask * 3 + 2);
}
void gen_right(long long i, long long a, long long b, long long c,
long long mask) {
if (i == n) {
if (m.count(make_tuple(-(a - b), -(a - c), -(b - c)))) {
long long cur = mm[make_tuple(-(a - b), -(a - c), -(b - c))];
if (cur + a > best) {
best = cur + a;
ans_l = m[make_tuple(-(a - b), -(a - c), -(b - c))];
ans_r = mask;
}
}
return;
}
gen_right(i + 1, a, b + get<1>(d[i]), c + get<2>(d[i]), mask * 3 + 0);
gen_right(i + 1, a + get<0>(d[i]), b, c + get<2>(d[i]), mask * 3 + 1);
gen_right(i + 1, a + get<0>(d[i]), b + get<1>(d[i]), c, mask * 3 + 2);
}
signed main() {
ios_base::sync_with_stdio(0);
cin >> n;
d.resize(n);
for (long long i = 0; i < n; ++i)
cin >> get<0>(d[i]) >> get<1>(d[i]) >> get<2>(d[i]);
n2 = n / 2;
gen_left(0, 0, 0, 0, 0);
gen_right(n2, 0, 0, 0, 0);
if (best == -1e15) {
cout << "Impossible\n";
return 0;
}
vector<long long> ans1, ans2;
for (long long i = 0; i < n2; ++i) {
ans1.push_back(ans_l % 3);
ans_l /= 3;
}
for (long long i = n2; i < n; ++i) {
ans2.push_back(ans_r % 3);
ans_r /= 3;
}
vector<string> g = {"MW\n", "LW\n", "LM\n"};
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
for (long long i = 0; i < n2; ++i) cout << g[ans1[i]];
for (long long i = n2; i < n; ++i) cout << g[ans2[i - n2]];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct triple {
int a, b, c;
triple() : a(0), b(0), c(0) {}
triple(int a, int b, int c) : a(a), b(b), c(c) {}
};
template <typename Comparer>
bool gen(const vector<triple>& v, Comparer comp, int pos, vector<string>& ans,
triple& val) {
if (pos == v.size()) return comp(ans, val);
ans[pos] = "LM";
val.a += v[pos].a;
val.b += v[pos].b;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.b -= v[pos].b;
ans[pos] = "LW";
val.a += v[pos].a;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.c -= v[pos].c;
ans[pos] = "MW";
val.b += v[pos].b;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.b -= v[pos].b;
val.c -= v[pos].c;
return true;
}
template <typename Comparer>
void launch_gen(const vector<triple>& v, Comparer comp) {
vector<string> ans(v.size());
triple val;
gen(v, comp, 0, ans, val);
}
map<pair<int, int>, pair<int, vector<string> > > m;
int best = -1234567890;
vector<string> res = {"Impossible"};
bool map_putter(const vector<string>& ans, const triple& val) {
pair<int, int> p(val.a - val.b, val.b - val.c);
if (!m.count(p) || val.c > m[p].first) m[p] = make_pair(val.c, ans);
return true;
}
bool ans_seeker(const vector<string>& ans, const triple& val) {
pair<int, int> p(val.b - val.a, val.c - val.b);
if (m.count(p))
if (m[p].first + val.c > best) {
best = m[p].first + val.c;
res.clear();
res.insert(res.end(), m[p].second.begin(), m[p].second.end());
res.insert(res.end(), ans.rbegin(), ans.rend());
}
return true;
}
int main() {
int n;
cin >> n;
vector<triple> v1, v2;
for (int i = 0; i < n; i++) {
triple t;
cin >> t.a >> t.b >> t.c;
((i < (n / 2)) ? v1 : v2).push_back(t);
}
reverse(v2.begin(), v2.end());
launch_gen(v1, map_putter);
launch_gen(v2, ans_seeker);
for (const string& it : res) cout << it << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[30], B[30], C[30];
map<pair<int, int>, int> curr, M;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &A[i], &B[i], &C[i]);
}
int n1 = n / 2;
int last = 1;
for (int i = 0; i < n1; i++) last *= 3;
for (int i = 0; i < last; i++) {
int k = i;
int a = 0, b = 0, c = 0;
for (int j = 0; j < n1; j++) {
int res = k % 3;
k /= 3;
if (res == 0) a += A[j], b += B[j];
if (res == 1) a += A[j], c += C[j];
if (res == 2) b += B[j], c += C[j];
}
if (curr.find({a - b, b - c}) == curr.end() || curr[{a - b, b - c}] < a) {
curr[{a - b, b - c}] = a;
M[{a - b, b - c}] = i;
}
}
int ans = -0x3f3f3f3f;
int best_a = -1, best_b = -1;
last = 1;
for (int i = n1; i < n; i++) last *= 3;
for (int i = 0; i < last; i++) {
int k = i;
int a = 0, b = 0, c = 0;
for (int j = n1; j < n; j++) {
int res = k % 3;
k /= 3;
if (res == 0) a += A[j], b += B[j];
if (res == 1) a += A[j], c += C[j];
if (res == 2) b += B[j], c += C[j];
}
if (curr.find({b - a, c - b}) != curr.end() &&
curr[{b - a, c - b}] + a > ans) {
ans = curr[{b - a, c - b}] + a;
best_a = M[{b - a, c - b}];
best_b = i;
}
}
if (best_a < 0)
printf("Impossible\n");
else {
for (int i = 0; i < n1; i++) {
int res = best_a % 3;
best_a /= 3;
if (res == 0) printf("LM\n");
if (res == 1) printf("LW\n");
if (res == 2) printf("MW\n");
}
for (int i = n1; i < n; i++) {
int res = best_b % 3;
best_b /= 3;
if (res == 0) printf("LM\n");
if (res == 1) printf("LW\n");
if (res == 2) printf("MW\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 1e9 + 10;
int n;
long long a[30][3];
map<pair<long long, long long>, long long> BestDif;
map<pair<long long, long long>, vector<int> > path;
vector<int> v, v1, v2;
long long ans = -OO;
bool flag;
void MIM(int i, vector<int> &v, long long s1, long long s2, long long s3) {
if (i == (flag ? n : n / 2)) {
if (flag) {
pair<long long, long long> p(s2 - s1, s3 - s2);
if (BestDif.find(p) != BestDif.end()) {
if (BestDif[p] + s1 > ans) ans = BestDif[p] + s1, v1 = path[p], v2 = v;
}
} else {
pair<long long, long long> p(s1 - s2, s2 - s3);
if (BestDif.find(p) == BestDif.end() || s1 > BestDif[p])
BestDif[p] = s1, path[p] = v;
}
return;
}
v.push_back(0);
MIM(i + 1, v, s1 + a[i][0], s2 + a[i][1], s3);
v.pop_back();
v.push_back(1);
MIM(i + 1, v, s1 + a[i][0], s2, s3 + a[i][2]);
v.pop_back();
v.push_back(2);
MIM(i + 1, v, s1, s2 + a[i][1], s3 + a[i][2]);
v.pop_back();
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) scanf("%I64d", &a[i][j]);
if (n == 1) {
if (!a[0][0] && !a[0][1])
printf("LM\n");
else if (!a[0][0] && !a[0][2])
printf("LW\n");
else if (!a[0][1] && !a[0][2])
printf("MW\n");
else
printf("Impossible\n");
return 0;
}
MIM(0, v, 0, 0, 0);
flag = true;
MIM(n / 2, v, 0, 0, 0);
if (ans == -OO)
printf("Impossible\n");
else {
for (auto x : v2) v1.push_back(x);
for (auto x : v1) {
if (x == 0)
printf("LM\n");
else if (x == 1)
printf("LW\n");
else
printf("MW\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Bitcnt(T a) {
int sum = 0;
while (a) {
if (a & 1) sum++;
a /= 2;
}
return sum;
}
template <class T>
T Max3(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T Lcm(T a, T b) {
T tmp = __gcd(a, b);
return (a / tmp) * b;
}
template <class T>
T Pow(T a, T b) {
T ans = 1;
T base = a;
while (b) {
if (b & 1) ans = (ans * base);
base = (base * base);
b /= 2;
}
return ans;
}
int Bigmod(int a, int b) {
int res = 1;
int pw = a % 1000000007LL;
while (b > 0) {
if (b & 1) res = (res * pw) % 1000000007LL;
pw = (pw * pw) % 1000000007LL;
b /= 2;
}
return res;
}
int a_x[] = {1, -1, 0, 0};
int a_y[] = {0, 0, 1, -1};
int X, Y;
void extend_euclid(int a, int b) {
if (b == 0) {
X = a;
Y = 0;
return;
}
extend_euclid(b, a % b);
int x, y;
x = Y;
y = X - (a / b) * Y;
X = x;
Y = y;
}
int inverse_modulo(int a, int b) {
extend_euclid(a, b);
return (X + 1000000007LL) % 1000000007LL;
}
int x[30];
int y[30];
int z[30];
int n;
int hf;
map<pair<int, int>, pair<int, int> > met;
int F, S, res;
int ans[1005];
void f(int pos, int a, int b, int c, int mask) {
if (pos >= hf) {
pair<int, int> p = make_pair(a - b, b - c);
if (!met.count(p) || met[p].first < a) {
met[p] = make_pair(a, mask);
}
return;
}
f(pos + 1, a + x[pos], b + y[pos], c, mask * 3);
f(pos + 1, a + x[pos], b, c + z[pos], mask * 3 + 1);
f(pos + 1, a, b + y[pos], c + z[pos], mask * 3 + 2);
}
void f2(int pos, int a, int b, int c, int mask) {
if (pos > n) {
pair<int, int> p = make_pair(b - a, c - b);
if (met.count(p)) {
if (met[p].first + a > res) {
res = met[p].first + a;
F = met[p].second;
S = mask;
}
}
return;
}
f2(pos + 1, a + x[pos], b + y[pos], c, mask * 3);
f2(pos + 1, a + x[pos], b, c + z[pos], mask * 3 + 1);
f2(pos + 1, a, b + y[pos], c + z[pos], mask * 3 + 2);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d %d", &x[i], &y[i], &z[i]);
hf = n / 2;
res = -1000000000;
F = -1;
f(1, 0, 0, 0, 0);
f2(hf, 0, 0, 0, 0);
if (F == -1)
puts("Impossible");
else {
for (int i = hf - 1; i >= 1; i--) {
ans[i] = F % 3;
F /= 3;
}
for (int i = n; i >= hf; i--) {
ans[i] = S % 3;
S /= 3;
}
for (int i = 1; i <= n; i++) {
if (ans[i] == 0)
puts("LM");
else if (ans[i] == 1)
puts("LW");
else
puts("MW");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> l, m, w;
void gen(int a, int b, vector<pair<pair<int, int>, pair<int, int>>> &xs) {
int len = b - a + 1;
if (len == 0) return;
int end = 3;
for (int i = 1; i < len; i++) end *= 3;
xs.reserve(end);
for (int i = 0; i < end; i++) {
int cur = i;
int L = 0;
int W = 0;
int M = 0;
for (int j = 0; j < len; j++) {
if (cur % 3 == 0) {
L += l[a + j];
M += m[a + j];
} else if (cur % 3 == 1) {
L += l[a + j];
W += w[a + j];
} else {
M += m[a + j];
W += w[a + j];
}
cur /= 3;
}
int a = W - L;
int b = M - W;
xs.push_back({{a, b}, {-L, i}});
}
}
void out(int ans, int ans2) {
int partA = min(13, (int)l.size());
int partB = l.size() - partA;
for (int i = 0; i < partA; i++) {
if (ans % 3 == 0) {
printf("LM\n");
} else if (ans % 3 == 1) {
printf("LW\n");
} else
printf("MW\n");
ans /= 3;
}
ans = ans2;
for (int i = 0; i < partB; i++) {
if (ans % 3 == 0) {
printf("LM\n");
} else if (ans % 3 == 1) {
printf("LW\n");
} else
printf("MW\n");
ans /= 3;
}
}
void solve() {
int n;
cin >> n;
l.resize(n);
m.resize(n);
w.resize(n);
for (int i = 0; i < n; i++) cin >> l[i] >> m[i] >> w[i];
int partA = min(13, n);
vector<pair<pair<int, int>, pair<int, int>>> res1, res2;
gen(0, partA - 1, res1);
gen(partA, n - 1, res2);
pair<int, int> result = {-1, -1};
int resultVal = -1e9;
bool possible = false;
if (res2.size()) {
sort(res2.begin(), res2.end());
for (auto cur : res1) {
auto num = cur.first;
pair<pair<int, int>, pair<int, int>> find = {{-num.first, -num.second},
{(int)-1e9, (int)-1e9}};
auto ret = lower_bound(res2.begin(), res2.end(), find);
if (ret->first == find.first) {
if (resultVal < (-cur.second.first + -ret->second.first)) {
result = {cur.second.second, ret->second.second};
resultVal = -cur.second.first + -ret->second.first;
possible = true;
}
}
}
} else {
for (auto cur : res1) {
auto num = cur.first;
auto ans = cur.second;
ans.first *= -1;
if (num.first == num.second && num.first == 0) {
if (resultVal < ans.first) {
resultVal = ans.first;
result = {ans.second, 0};
possible = true;
}
}
}
}
if (possible)
out(result.first, result.second);
else
cout << "Impossible";
}
void check() {
int n;
cin >> n;
l.resize(n);
m.resize(n);
w.resize(n);
for (int i = 0; i < n; i++) cin >> l[i] >> m[i] >> w[i];
vector<string> xs(n);
for (int i = 0; i < n; i++) cin >> xs[i];
int L = 0, M = 0, W = 0;
for (int i = 0; i < n; i++) {
if (xs[i][0] == 'L' || xs[i][1] == 'L') L += l[i];
if (xs[i][0] == 'M' || xs[i][1] == 'M') M += m[i];
if (xs[i][0] == 'W' || xs[i][1] == 'W') W += w[i];
}
cout << L << " " << M << " " << W << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int IN() {
int x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int fr, bh, n, cnt, l[26], m[26], w[26];
int Ans1 = -1 << 30, Ans2, Ans3;
struct Opr {
int bs, sc, td, seq;
bool operator<(const Opr& x) const {
return sc == x.sc ? (td == x.td ? bs < x.bs : td < x.td) : sc < x.sc;
}
} a[600000];
int find(int sc, int td) {
int l = 1, r = cnt;
while (l < r) {
int mid = l + r + 1 >> 1;
if (a[mid].sc < sc || (a[mid].sc == sc && a[mid].td <= td))
l = mid;
else
r = mid - 1;
}
if (a[l].sc == sc && a[l].td == td)
return l;
else
return 0;
}
void DFS1(int now, int L, int M, int W, int seq) {
if (!now) {
a[++cnt] = (Opr){L, M - L, W - L, seq};
return;
}
DFS1(now - 1, L + l[now], M + m[now], W, seq * 3);
DFS1(now - 1, L + l[now], M, W + w[now], seq * 3 + 1);
DFS1(now - 1, L, M + m[now], W + w[now], seq * 3 + 2);
}
void Solve(int Ans, int len) {
for (int i = 1; i <= len; i++) {
if (Ans % 3 == 0)
puts("LM");
else if (Ans % 3 == 1)
puts("LW");
else
puts("MW");
Ans /= 3;
}
}
void DFS2(int now, int L, int M, int W, int seq) {
if (now == fr) {
int Ans = find(L - M, L - W);
if (Ans && a[Ans].bs + L > Ans1) {
Ans1 = a[Ans].bs + L;
Ans2 = a[Ans].seq;
Ans3 = seq;
}
return;
}
DFS2(now - 1, L + l[now], M + m[now], W, seq * 3);
DFS2(now - 1, L + l[now], M, W + w[now], seq * 3 + 1);
DFS2(now - 1, L, M + m[now], W + w[now], seq * 3 + 2);
}
int main() {
n = IN();
for (int i = 1; i <= n; i++) l[i] = IN(), m[i] = IN(), w[i] = IN();
if (n == 1) {
if (l[1] == m[1]) return puts("LM"), 0;
if (l[1] == w[1]) return puts("LW"), 0;
if (m[1] == w[1]) return puts("MW"), 0;
return puts("Impossible"), 0;
}
fr = n / 2;
DFS1(fr, 0, 0, 0, 0);
sort(a + 1, a + cnt + 1);
DFS2(n, 0, 0, 0, 0);
if (Ans1 >= -3e8) {
Solve(Ans2, fr);
Solve(Ans3, n - fr);
} else
puts("Impossible");
}
|
#include <bits/stdc++.h>
using namespace std;
struct ab {
int l, m, r;
};
ab a[100005];
string s[3] = {"LM", "MW", "LW"};
int T[100005];
pair<pair<int, int>, int> ss;
map<pair<int, int>, pair<int, int> > D;
bool exitt = 0, ok = 0;
int ans = -109000000;
int P[100005];
int n;
void Sinh1(int k, int l, int r) {
if (k > r) {
int a1, a2, a3;
a1 = a2 = a3 = 0;
for (int i = l; i <= r; i++) {
a1 += a[i].l * (T[i] == 0 || T[i] == 2);
a2 += a[i].m * (T[i] == 1 || T[i] == 0);
a3 += a[i].r * (T[i] == 1 || T[i] == 2);
}
pair<int, int> vv = D[make_pair(a2 - a1, a2 - a3)];
if (vv.first == 5) {
if (vv.second < a2) {
D[make_pair(a2 - a1, a2 - a3)].second = a2;
}
} else
D[make_pair(a2 - a1, a2 - a3)] = make_pair(5, a2);
return;
}
for (int i = 0; i < 3; i++) {
T[k] = i;
Sinh1(k + 1, l, r);
}
}
void Sinh2(int k, int l, int r) {
if (k > r) {
int a1, a2, a3;
a1 = a2 = a3 = 0;
for (int i = l; i <= r; i++) {
a1 += a[i].l * (T[i] == 0 || T[i] == 2);
a2 += a[i].m * (T[i] == 1 || T[i] == 0);
a3 += a[i].r * (T[i] == 1 || T[i] == 2);
}
pair<int, int> vt = D[make_pair(a1 - a2, a3 - a2)];
if (vt.first != 5) return;
int vv = vt.second;
if (vv + a2 >= ans) {
ok = true;
for (int i = l; i <= r; i++) P[i] = T[i];
ss = make_pair(make_pair(a1 - a2, a3 - a2), vv);
ans = vv + a2;
}
return;
}
for (int i = 0; i < 3; i++) {
T[k] = i;
Sinh2(k + 1, l, r);
}
}
void Sinh3(int k, int l, int r) {
if (exitt) return;
if (k > r) {
int a1, a2, a3;
a1 = a2 = a3 = 0;
for (int i = l; i <= r; i++) {
a1 += a[i].l * (T[i] == 0 || T[i] == 2);
a2 += a[i].m * (T[i] == 1 || T[i] == 0);
a3 += a[i].r * (T[i] == 1 || T[i] == 2);
}
if (ss == make_pair(make_pair(a2 - a1, a2 - a3), a2)) {
exitt = 1;
for (int i = l; i <= r; i++) P[i] = T[i];
}
return;
}
for (int i = 0; i < 3; i++) {
T[k] = i;
Sinh3(k + 1, l, r);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].l >> a[i].m >> a[i].r;
Sinh1(1, 1, n / 2);
Sinh2(n / 2 + 1, n / 2 + 1, n);
Sinh3(1, 1, n / 2);
if (!ok)
cout << "Impossible";
else {
for (int i = 1; i <= n; i++) cout << s[P[i]] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long sq(long long a) { return a * a; }
long long pot(long long a, long long e) {
return e ? sq(pot(a, e >> 1)) * (e & 1 ? a : 1) : 1;
}
int N;
long long A[3][25];
char C[3] = {'L', 'M', 'W'};
int main() {
scanf("%d", &N);
for (int q = 0; q < N; q++)
scanf("%lld %lld %lld", &A[0][q], &A[1][q], &A[2][q]);
if (N == 1) {
vector<int> ans;
for (int i = 0; i < 3; i++)
if (A[i][0] == 0) ans.push_back(i);
if (ans.size() < 2)
printf("Impossible\n");
else
printf("%c%c\n", C[ans[0]], C[ans[1]]);
return 0;
}
map<pair<long long, long long>, long long> m, m2;
int n = N / 2;
for (int mask = 0; mask < pot(3, n); mask++) {
int tmpmask = mask;
int a[3] = {0, 0, 0};
for (int q = 0; q < n; q++) {
int trit = tmpmask % 3;
tmpmask /= 3;
for (int i = 0; i < 3; i++) {
if (trit == i) continue;
a[i] += A[i][q];
}
}
pair<long long, long long> tmp = {a[0] - a[1], a[1] - a[2]};
if (m.find(tmp) == m.end() || m[tmp] < a[0]) {
m[tmp] = a[0];
m2[tmp] = mask;
}
}
bool found = false;
long long MAX = 0, ans[2] = {-1, -1};
for (int mask = 0; mask < pot(3, N - n); mask++) {
int tmpmask = mask;
int a[3] = {0, 0, 0};
for (int q = n; q < N; q++) {
int trit = tmpmask % 3;
tmpmask /= 3;
for (int i = 0; i < 3; i++) {
if (trit == i) continue;
a[i] += A[i][q];
}
}
pair<long long, long long> tmp = {a[1] - a[0], a[2] - a[1]};
if (m.find(tmp) == m.end()) continue;
if (!found) {
found = true;
MAX = a[0] + m[tmp];
ans[0] = m2[tmp];
ans[1] = mask;
} else {
if (MAX < a[0] + m[tmp]) {
MAX = a[0] + m[tmp];
ans[0] = m2[tmp];
ans[1] = mask;
}
}
}
if (!found) {
printf("Impossible\n");
} else {
int mask = ans[0];
for (int q = 0; q < n; q++) {
int trit = mask % 3;
mask /= 3;
for (int i = 0; i < 3; i++) {
if (trit == i) continue;
printf("%c", C[i]);
}
printf("\n");
}
mask = ans[1];
for (int q = n; q < N; q++) {
int trit = mask % 3;
mask /= 3;
for (int i = 0; i < 3; i++) {
if (trit == i) continue;
printf("%c", C[i]);
}
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct triple {
int a, b, c;
triple() : a(0), b(0), c(0) {}
triple(int a, int b, int c) : a(a), b(b), c(c) {}
};
namespace std {
template <>
class hash<pair<int, int> > {
public:
inline size_t operator()(const pair<int, int>& p) const {
return hash<int>()(p.first) ^ hash<int>()(p.second);
}
};
}; // namespace std
template <typename Comparer>
bool gen(const vector<triple>& v, Comparer comp, int pos,
vector<pair<char, char> >& ans, triple& val) {
if (pos == v.size()) return comp(ans, val);
ans[pos] = {'L', 'M'};
val.a += v[pos].a;
val.b += v[pos].b;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.b -= v[pos].b;
ans[pos] = {'L', 'W'};
val.a += v[pos].a;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.a -= v[pos].a;
val.c -= v[pos].c;
ans[pos] = {'M', 'W'};
val.b += v[pos].b;
val.c += v[pos].c;
if (!gen(v, comp, pos + 1, ans, val)) return false;
val.b -= v[pos].b;
val.c -= v[pos].c;
return true;
}
template <typename Comparer>
void launch_gen(const vector<triple>& v, Comparer comp) {
vector<pair<char, char> > ans(v.size());
triple val;
gen(v, comp, 0, ans, val);
}
unordered_map<pair<int, int>, pair<int, vector<pair<char, char> > > > m;
int best = -1234567890;
vector<pair<char, char> > res;
inline bool map_putter(const vector<pair<char, char> >& ans,
const triple& val) {
pair<int, int> p(val.a - val.b, val.b - val.c);
if (!m.count(p) || val.c > m[p].first) m[p] = make_pair(val.c, ans);
return true;
}
inline bool ans_seeker(const vector<pair<char, char> >& ans,
const triple& val) {
pair<int, int> p(val.b - val.a, val.c - val.b);
if (m.count(p)) {
auto& ptr = m[p];
if (ptr.first + val.c > best) {
best = ptr.first + val.c;
res.clear();
res.insert(res.end(), ptr.second.begin(), ptr.second.end());
res.insert(res.end(), ans.begin(), ans.end());
}
}
return true;
}
int main() {
int n;
cin >> n;
vector<triple> v1, v2;
for (int i = 0; i < n; i++) {
triple t;
cin >> t.a >> t.b >> t.c;
((i < (n / 2)) ? v1 : v2).push_back(t);
}
launch_gen(v1, map_putter);
launch_gen(v2, ans_seeker);
if (res.empty())
cout << "Impossible" << endl;
else
for (auto it : res) cout << it.first << it.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[15];
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(a, 0, sizeof a);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x]++;
}
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
ans = ans + a[i] * a[j];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int genre[20], sum[20];
int main() {
int n, m, i, j;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> j;
genre[j]++;
}
int s = 0;
sum[1] = genre[1];
for (i = 2; i <= m; i++) {
sum[i] += (sum[i - 1] + genre[i]);
}
for (i = 1; i < m; i++) {
s = s + genre[i] * (sum[m] - sum[i]);
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 15;
int num[maxn];
int main() {
int n, m, i, j, count, book, temp;
while (scanf("%d%d", &n, &m) == 2) {
memset(num, 0, sizeof(num));
for (i = 0; i < n; ++i) {
scanf("%d", &book);
num[book]++;
}
count = 0;
for (i = 1; i < m; ++i) {
for (j = i + 1; j <= m; ++j) count += num[i] * num[j];
}
printf("%d\n", count);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
long long n, m, counts;
stack<int> stk;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<int> visited(m + 1, 0);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
visited[x]++;
}
for (int i = 1; i <= m; i++) {
counts += (long long)visited[i] * (long long)(n - visited[i]);
}
cout << counts / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[m + 1];
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[x]++;
}
int ans = 0;
for (int i = 1; i < m; i++) {
for (int j = i + 1; j <= m; j++) ans += a[i] * a[j];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y);
long long int gcd(long long int a, long long int b);
vector<long long int> ft = {0};
long long int modInv(long long int i) { return power(i, 1000000007 - 2); }
long long int ncr(long long int n, long long int r) {
return (n >= r ? (ft[n] * modInv(ft[r])) % 1000000007 * modInv(ft[n - r]) %
1000000007
: 0);
}
long long int power(long long int x, long long int y) {
long long int res = 1;
x %= 1000000007;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res % 1000000007;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
map<long long int, long long int> m1;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
m1[a[i]]++;
}
long long int ans = 0, cur = 0;
for (long long int i = 0; i < n; i++) {
ans += max(0ll, (n - m1[a[i]] - cur));
m1[a[i]]--;
cur++;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
vector<long long> a, b, ps;
void solve() {
long long n, m;
cin >> n >> m;
a.resize(n);
b.resize(m);
ps.resize(m + 1);
for (long long i = 0; i < n; i++) {
cin >> a[i];
b[a[i] - 1]++;
}
ps[0] = 0;
for (long long i = 0; i < m; i++) {
ps[i + 1] = ps[i] + b[i];
}
long long cnt = 0;
for (long long i = 0; i < m - 1; i++) {
cnt += (b[i] * (n - ps[i + 1]));
}
cout << cnt;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
int arr[m + 1];
for (i = 0; i <= m; i++) arr[i] = 0;
for (i = 0; i < n; i++) {
int x;
cin >> x;
arr[x]++;
}
int ans = 0;
for (i = 1; i < m; i++) {
n = n - arr[i];
ans = ans + (arr[i] * n);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long choose_two_books(long books) {
if (books % 2 == 0) {
return (books / 2) * (books - 1);
} else {
return books * ((books - 1) / 2);
}
}
int main(int argc, char** argv) {
long n, m, books_per_genre[11];
unsigned long ways;
int genre;
cin >> n >> m;
fill(books_per_genre, books_per_genre + 11, 0);
for (long i = 0; i < n; i++) {
cin >> genre;
books_per_genre[genre]++;
}
ways = choose_two_books(n);
for (int i = 1; i < 11; i++) {
if (books_per_genre[i] >= 2) {
ways -= choose_two_books(books_per_genre[i]);
}
}
cout << ways << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[20];
int main() {
cin >> n >> m;
for (int t, i = 1; i <= n; i++) {
cin >> t;
a[t]++;
}
int ans = 0;
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++) ans += a[i] * a[j];
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, a[1000010], y[10010];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
y[a[i]]++;
}
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
t = t + y[i] * y[j];
}
}
cout << t << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, dat;
cin >> n >> m;
int c[12];
memset(c, 0, sizeof(c));
pair<int, int> d[n];
for (int i = 0; i < (int)n; i++) {
cin >> dat;
d[i].first = dat;
d[i].second = -1;
}
for (int i = n - 1; i >= 0; i--) {
d[i].second = c[d[i].first];
c[d[i].first]++;
}
long long ans = 0;
for (int i = 0; i < (int)n; i++) {
ans += (n - (i + 1) - d[i].second);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> divi;
vector<long long int> fact;
void pre(long long int n) {
for (long long int i = 1ll; i <= n; i++) {
if (n % i == 0) {
divi.push_back(i);
}
}
}
long long int a[100001];
int main() {
long long int n, m;
cin >> n >> m;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
long long int x;
cin >> x;
a[x]++;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= m; j++) {
ans += a[i] * a[j];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0, x;
cin >> n >> m;
vector<vector<int> > a(m + 1);
for (int i = 1; i <= n; i++) {
cin >> x;
a[x].push_back(i);
}
ans = 0;
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++) ans += (a[i].size() * a[j].size());
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long a[n];
map<long long, long long> m1;
for (int i = 0; i < n; i++) {
cin >> a[i];
m1[a[i]]++;
}
long long i = 1, sum = n;
long long delet = 0, add = 0;
map<long long, long long>::iterator p = m1.begin();
while (i < m) {
delet += p->second;
add += (sum - delet) * p->second;
p++;
i++;
}
cout << add << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e19;
const int mod = 1000000000 + 7;
int main() {
int n, m;
cin >> n >> m;
int a[n];
vector<int> c(m + 1, 0);
for (int i = 0; i < n; i++) cin >> a[i], c[a[i]]++;
long long ans = 0;
for (int i = 0; i < n; i++) ans += n - c[a[i]];
cout << ans / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 11;
long long a[N];
int main(void) {
long long n, m, cur;
long long rep = 0LL;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> cur;
a[cur]++;
}
for (int i = 1; i <= m; i++) rep += a[i] * (a[i] - 1LL) / 2LL;
cout << n * (n - 1LL) / 2LL - rep;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long flag, cnt, j, i, k, ans, maxy, sum;
long long n, t, c, x, m;
int main() {
cin >> n >> m;
vector<long long> a(m + 1);
for (i = 1; i <= n; i++) {
cin >> x;
a[x]++;
}
sum = accumulate(a.begin(), a.end(), 0);
j = a[0];
for (i = 1; i <= m; i++) {
ans = ans + a[i] * (sum - a[i] - j);
j = j + a[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[2 * 100000];
int b[11];
int main() {
cin >> n >> m;
bool c = false;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i <= 10; i++) {
b[i] = 0;
}
for (int i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) {
c = true;
break;
}
}
if (c == false) {
cout << 0;
return 0;
}
for (int i = 0; i < n; i++) {
b[a[i]]++;
}
for (int i = 1; i <= m; i++) {
sum += b[i] * (n - b[i]);
}
cout << sum / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[11];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[x]++;
}
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
ans += a[i] * a[j];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n;
int m;
cin >> n >> m;
long int arr[m];
memset(arr, 0, sizeof arr);
long int temp;
for (long int i = 0; i < n; i++) {
cin >> temp;
arr[temp - 1]++;
}
unsigned long int ans = n * n;
for (int i = 0; i < m; i++) {
ans -= arr[i] * arr[i];
}
cout << ans / 2;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int a[25];
int main() {
int n, m, i, j;
long long int ans = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> j, a[j]++;
long long int sum = 0;
for (i = 1; i <= m; i++) sum += a[i];
for (i = 1; i <= m; i++) ans += a[i] * (sum - a[i]);
cout << ans / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int m, n;
std::cin >> n >> m;
int a[10] = {};
for (int i = 0; i < n; ++i) {
int d;
std::cin >> d;
++a[d - 1];
}
int sum = 0;
for (int i = 0; i < m; ++i) {
for (int j = i + 1; j < m; ++j) {
sum += a[i] * a[j];
}
}
std::cout << sum << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, count = 0;
cin >> n >> m;
int arr[n];
int count1[m + 1], count2[m + 1];
for (i = 1; i <= m; i++) {
count1[i] = 0;
count2[i] = 0;
}
for (i = 0; i < n; i++) {
cin >> arr[i];
count1[arr[i]]++;
}
for (i = 1; i <= m; i++) {
count2[i] = count1[i];
}
for (i = m - 1; i > 0; i--) {
count2[i] += count2[i + 1];
}
for (i = 1; i < m; i++) {
count += count1[i] * count2[i + 1];
}
cout << count << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k = 0, mas[100];
int a;
cin >> n;
cin >> m;
for (int i = 0; i < m; i++) mas[i] = 0;
for (int i = 0; i < n; i++) {
cin >> a;
mas[a - 1]++;
}
for (int i = 0; i < m; i++)
for (int j = i + 1; j < m; j++) k += mas[i] * mas[j];
cout << k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, ans = 0;
long long int a[11];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
a[--x]++;
}
for (long long int i = 0; i < m; i++)
for (long long int j = i + 1; j < m; j++) ans += a[i] * a[j];
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9;
template <class T>
istream& operator>>(istream& ss, vector<T>& v) {
for (int i = 0; i < v.size(); i++) ss >> v[i];
return ss;
}
template <class T>
ostream& operator<<(ostream& ss, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) ss << v[i] << ' ';
return ss;
}
void solve() {
int n, m;
cin >> n >> m;
unordered_map<int, int> mp;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
mp[x]++;
}
vector<int> a;
for (auto p : mp) a.push_back(p.second);
double ans = 0;
for (int i = 0; i < a.size(); ++i) {
ans += (n - a[i]) * 1.0 * a[i] / 2.0;
}
cout << int(ans);
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, ans = 0, c = 0;
cin >> n >> m;
long long books[n], upay[m];
for (long long i = 0; i < n; i++) {
cin >> books[i];
}
sort(books, books + n);
for (long long i = 1; i < m; i++) {
long long k = 0;
for (long long j = 0; j < n; j++) {
if (i == books[j]) {
c++;
k++;
}
}
ans += k * (n - c);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1100;
using namespace std;
long long ans;
int n, m;
long long cnt[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
cnt[val]++;
}
ans = 1ll * n * (n - 1) / 2;
for (int i = 1; i <= m; i++) {
long long val = cnt[i];
ans -= val * (val - 1) / 2;
}
cout << ans << endl;
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[15], sum;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
cnt[t]++;
sum++;
}
int ans = 0;
for (int i = 1; i <= m; i++) {
sum -= cnt[i];
ans += cnt[i] * sum;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, s = 0;
cin >> n >> m;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
for (int i = 0; i < n; i++) {
int ch;
ch = ar[i];
int z, l = 0, r = n;
while (l < r) {
z = (l + r) / 2;
if (ar[z] >= ch) {
r = z;
} else {
l = z + 1;
}
}
s += l;
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[20101010], ans = 0, b[12], r;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i] - 1]++;
}
for (int i = 0; i < m; i++) {
r = 0;
for (int j = i + 1; j < m; j++) {
r += b[j];
}
ans += b[i] * r;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
cin >> m;
vector<int> usb(m, 0);
for (int i = 0; i < n; i++) {
int r;
cin >> r;
usb[r - 1]++;
}
long long int s = 0;
for (vector<int>::iterator it = usb.begin(); it != usb.end(); it++) {
s += (*it) * (n - (*it));
}
cout << (s / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m, temp;
cin >> n >> m;
vector<long long int> vec(m, 0);
for (long long int i = 0; i < n; i++) {
cin >> temp;
vec[--temp]++;
}
long long int sum = 0;
for (long long int i = 0; i < m; i++) {
sum += (vec[i] * (n - vec[i]));
}
cout << sum / 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, sum = 0;
int a, b[11] = {0};
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a;
b[a]++;
}
for (i = 1; i < m; i++) {
sum += (n - b[i]) * b[i];
n = n - b[i];
}
cout << sum << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 200111;
int n, m, ans, a[N], pre[N][11];
void f() {
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j <= m; j++) {
pre[i][j] = pre[i + 1][j] + (a[i] != j);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
f();
for (int i = 0; i < n; i++) {
ans += pre[i][a[i]];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9, PI = acos(-1.);
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const int N = 2e5 + 5;
long long n, m, a[N], gnr[20];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long k;
cin >> k;
gnr[k]++;
}
long long ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
ans += gnr[i] * gnr[j];
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m, a, b[11] = {0}, i, j, x = 0;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a);
b[a]++;
}
for (i = 1; i < m; i++) {
for (j = i + 1; j <= m; j++) {
x = x + b[j] * b[i];
}
}
printf("%d", x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int x, int y) { return x > y; }
int n, m, a[1010], h;
long long sol;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &h);
a[h]++;
}
for (int i = 1; i <= m; i++) sol += (n - a[i]) * a[i];
printf("%I64d\n", sol / 2LL);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> v(m + 1);
for (int i = 0; i < n; i++) {
int tmep;
cin >> tmep;
v[tmep]++;
}
long long ans = 0;
for (int i = 1; i < m + 1; i++) {
for (int j = i + 1; j < m + 1; j++) {
ans += (long long)v[i] * v[j];
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int a[n];
int f[m];
memset(f, 0, sizeof(f));
long long sum = 0, ans = 0;
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
sum++;
f[a[i]]++;
}
for (int i = 0; i <= m - 1; i++) {
ans += f[i] * (sum - f[i]);
sum -= f[i];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int genre[11];
int main() {
int n;
scanf("%d", &(n));
;
int m;
scanf("%d", &(m));
;
for (int(i) = (0); (i) < (n); (i)++) {
int a;
scanf("%d", &(a));
;
genre[a]++;
}
int tot = n;
int ans = 0;
for (int(i) = (1); (i) < (11); (i)++) {
tot -= genre[i];
ans += genre[i] * tot;
}
cout << (ans) << "\n";
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, a[N], ct = 0;
bool Read() {
cin >> n;
if (cin.eof()) return 0;
cin >> m;
for (int i = 0; i < n; i++) cin >> a[i];
return 1;
}
void Process() {
long long ans = (long long)n * ((long long)n - 1) / 2;
int freq[11];
memset(freq, 0, sizeof freq);
for (int i = 0; i < n; i++) freq[a[i]]++;
for (int i = 1; i <= m; i++)
ans -= (long long)freq[i] * ((long long)freq[i] - 1) / 2;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
while (Read()) Process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int ans1;
unsigned long long int arr[11];
for (int i = 0; i < 11; i++) arr[i] = 0;
long long int n, m, x;
cin >> n >> m;
long long int k = n;
while (k--) {
cin >> x;
arr[x]++;
}
ans1 = (n * (n - 1)) / 2;
unsigned long long int sum = 0;
for (int i = 0; i < 11; i++) {
if (arr[i] > 1) {
ans1 -= (arr[i] * (arr[i] - 1)) / 2;
}
}
cout << ans1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, v[12], i, j, s = 0;
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> x;
v[x]++;
}
for (i = 1; i < m; i++) {
for (j = i + 1; j <= m; j++) s = s + v[i] * v[j];
}
cout << s;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.