text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
bool isEq(int start1, int len1, int start2, int len2) {
if (len1 & 1) {
for (int i = 0; i < len1; i++) {
if (s1[start1 + i] != s2[start2 + i]) return false;
}
return true;
}
int mid1 = len1 / 2, mid2 = len2 / 2;
bool result = ((isEq(start1, mid1, start2, mid2) &&
isEq(start1 + mid1, mid1, start2 + mid2, mid2)) ||
(isEq(start1, mid1, start2 + mid2, mid2) &&
isEq(start1 + mid1, mid1, start2, mid2)));
return result;
}
int main() {
cin >> s1 >> s2;
if (isEq(0, s1.length(), 0, s2.length()))
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool check_same(string s1, string s2) {
int ch[30];
memset(ch, 0, sizeof(ch));
for (int i = 0; i < s1.size(); i++) ch[s1[i] - 'a']++;
for (int i = 0; i < s2.size(); i++) ch[s2[i] - 'a']--;
for (int i = 0; i < 25; i++)
if (ch[i] != 0) return false;
return true;
}
bool f(string a, string b) {
string a1, a2, b1, b2;
if (a.size() == 0 or b.size() == 0) return false;
if (a.size() != b.size()) return false;
bool res = (a == b);
if ((a.size() % 2 != 0 or b.size() % 2 != 0) and !res) return false;
if (res) return true;
if (!check_same(a, b)) return false;
a1.insert(a1.begin(), a.begin(), a.begin() + a.size() / 2);
a2.insert(a2.begin(), a.begin() + a.size() / 2, a.end());
b1.insert(b1.begin(), b.begin(), b.begin() + b.size() / 2);
b2.insert(b2.begin(), b.begin() + b.size() / 2, b.end());
if (f(a1, b2) and f(a2, b1))
return true;
else if (f(a1, b1) and f(a2, b2))
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string a, b;
cin >> a >> b;
if (f(a, b))
printf("YES");
else
printf("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
string ans[2] = {"NO", "YES"};
long long int mod[2] = {1000000007, 1000000009}, inv[2][200100],
hasha[2][200100], hashb[2][200100];
string lex_min(string a) {
if ((a.size()) & 1) return a;
string b, c;
b = lex_min(a.substr(0, a.size() / 2));
c = lex_min(a.substr(a.size() / 2, a.size() / 2));
if (b < c)
return b + c;
else
return c + b;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
string a, b;
cin >> a >> b;
cout << ans[lex_min(a) == lex_min(b)] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
bool f(string a, string b) {
if (a == b) return true;
int len1 = a.size(), len2 = b.size();
if (len1 & 1 || len2 & 1) return false;
string ta1 = a.substr(0, len1 / 2), ta2 = a.substr(len1 / 2, len1 / 2);
string tb1 = b.substr(0, len2 / 2), tb2 = b.substr(len2 / 2, len2 / 2);
if ((f(ta1, tb2) && f(ta2, tb1)) || (f(ta1, tb1) && f(ta2, tb2))) return true;
return false;
}
int main() {
cin >> s1;
cin >> s2;
if (f(s1, s2))
puts("YES");
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[200001], b[200001];
bool chk(char* a, char* b, int n) {
if (strncmp(a, b, n) == 0)
return 1;
else if (n % 2)
return 0;
else if (chk(a + n / 2, b, n / 2) && chk(a, b + n / 2, n / 2))
return 1;
else if (chk(a, b, n / 2) && chk(a + n / 2, b + n / 2, n / 2))
return 1;
else
return 0;
}
int main() {
cin >> a >> b;
bool temp = chk(a, b, strlen(a));
if (temp)
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
const long long OO = 1e18;
map<pair<string, string>, bool> dp;
map<pair<string, string>, bool> visited;
bool calc(string s, string str, long long siz) {
if (s == str) return true;
if (siz & 1) return false;
if (visited[{s, str}]) return dp[{s, str}];
visited[{s, str}] = true;
string hi = s.substr(0, siz / 2), hi2 = s.substr(siz / 2, siz / 2),
hello = str.substr(0, siz / 2), hello2 = str.substr(siz / 2, siz / 2);
if ((hi == hello && hi2 == hello2) || (hi == hello2 && hi2 == hello))
return dp[{s, str}] = dp[{str, s}] = true;
if ((calc(hi, hello, siz / 2) && calc(hi2, hello2, siz / 2)) ||
(calc(hi, hello2, siz / 2) && calc(hi2, hello, siz / 2)))
return dp[{s, str}] = dp[{str, s}] = true;
return dp[{s, str}] = dp[{str, s}] = false;
}
void Suhaib_Sawalha() {
string s, str;
cin >> s >> str;
if (s == str || calc(s, str, s.size()))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void Suhaib_Sawalha1() {
long long t;
cin >> t;
while (t--) {
Suhaib_Sawalha();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Suhaib_Sawalha();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string solve(string k) {
if (k.length() % 2) return k;
string m = solve(k.substr(0, k.length() / 2));
string n = solve(k.substr(k.length() / 2, k.length()));
if (m < n) return n + m;
return m + n;
}
int main() {
string a, b;
cin >> a >> b;
cout << (solve(a) == solve(b) ? "YES" : "NO") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BM(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T mdINV(T a, T M) {
return BM(a, M - 2, M);
}
template <class T>
inline T PW(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
string NTS(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <class T>
T stringtonumber(const string &Text) {
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
template <class T>
bool ISLEFT(T a, T b, T c) {
if (((a.first.first - b.first.first) * (b.second.second - c.second.second) -
(b.first.first - c.first.first) * (a.second.second - b.second.second)) <
0.0)
return 1;
else
return 0;
}
string s, s1;
string change(string first) {
int l = first.size();
if (l % 2 == 1) return first;
int h = l / 2 - 1;
string s3 = change(first.substr(0, h + 1));
string s4 = change(first.substr(h + 1, h + 1));
if (s3 < s4)
return s3 + s4;
else
return s4 + s3;
}
int main() {
cin >> s >> s1;
string f = change(s);
string f1 = change(s1);
if (f == f1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool Equality(string a, string b) {
if (a == b) return 1;
if (a.size() % 2 || b.size() % 2) return 0;
string a1, a2, b1, b2;
a1 = a.substr(0, a.size() / 2);
a2 = a.substr(a.size() / 2, a.size() / 2);
b1 = b.substr(0, b.size() / 2);
b2 = b.substr(b.size() / 2, b.size() / 2);
return ((Equality(a1, b2) && Equality(a2, b1)) ||
(Equality(a1, b1) && Equality(a2, b2)));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string a, b;
cin >> a >> b;
cout << (Equality(a, b) ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
static bool equal(const char* a, const char* b, size_t n) noexcept {
if ((n & 1) != 0) return memcmp(a, b, n) == 0;
n >>= 1;
return equal(a, b, n) && equal(a + n, b + n, n) ||
equal(a, b + n, n) && equal(a + n, b, n);
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::string a, b;
std::cin >> a >> b;
std::cout << (equal(a.data(), b.data(), a.length()) ? "YES" : "NO") << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string prefix(string s) {
if (s.size() % 2) return s;
string s1 = prefix(s.substr(0, s.size() / 2));
string s2 = prefix(s.substr(s.size() / 2));
if (s1 < s2)
return s1 + s2;
else
return s2 + s1;
}
int main() {
string a, b;
ios_base::sync_with_stdio(false);
cin >> a >> b;
a = prefix(a);
b = prefix(b);
if (a == b)
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
bool containsEqual(string &a, string &b) {
int arr[26];
memset(arr, 0, sizeof(arr));
int a_len = a.length(), b_len = b.length();
int i;
for (i = 0; i < a_len; i++) arr[a[i] - 'a']++;
for (i = 0; i < b_len; i++) arr[b[i] - 'a']--;
for (i = 0; i < 26; i++)
if (arr[i] != 0) return false;
return true;
}
bool isEquivalent(string a, string b) {
if (a == b) return true;
int length = a.length();
if (length & 1 || !containsEqual(a, b)) return false;
string firsta = a.substr(0, length / 2), seca = a.substr(length / 2);
string firstb = b.substr(0, length / 2), secb = b.substr(length / 2);
return (isEquivalent(firsta, firstb) && isEquivalent(seca, secb)) ||
(isEquivalent(firsta, secb) && isEquivalent(seca, firstb));
}
int main() {
cin >> a >> b;
if (isEquivalent(a, b))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MO[] = {1000000007, 1000000009, 1000000007};
long long PR[] = {137, 173, 17};
long long PO[2][200005];
long long HA[2][200005][2];
string a, b;
struct Node {
int a1, b1;
int a2, b2;
Node(int _a1, int _a2, int _b1, int _b2) {
a1 = _a1;
b1 = _b1;
a2 = _a2;
b2 = _b2;
}
bool operator==(const Node &x) const {
if (this->a1 == x.a1 && this->a2 == x.a2 && this->b1 == x.b1 &&
this->b2 == x.b2)
return true;
return false;
}
bool operator<(const Node &x) const {
if (this->a1 == x.a1) {
if (this->a2 == x.a2) {
if (this->b1 == x.b1) {
return this->b2 < x.b2;
}
return this->b1 < x.b1;
}
return this->a2 < x.a2;
}
return this->a1 < x.a1;
}
};
void init(string S, int k) {
PO[0][0] = PO[1][0] = PO[2][0] = 1;
for (int h = 0; h < 2; ++h) {
for (int i = 0; i < S.size(); ++i) {
if (i) PO[h][i] = (PO[h][i - 1] * PR[h]) % MO[h];
if (i)
HA[h][i][k] = ((HA[h][i - 1][k] * PR[h]) + S[i]) % MO[h];
else
HA[h][i][k] = S[i];
}
}
}
long long getHash(int hId, int l, int r, int k) {
long long ret = HA[hId][r][k];
if (l == 0) return ret;
ret = (ret - (HA[hId][l - 1][k] * PO[hId][(r - l + 1)])) % MO[hId];
ret = (ret + MO[hId]) % MO[hId];
return ret;
}
bool same(int l, int r, int l2, int r2) {
for (int i = 0; i < 2; i++) {
if (getHash(i, l, r, 0) != getHash(i, l2, r2, 1)) return false;
}
return true;
}
map<Node, bool> dp;
bool solve(Node actual) {
if (actual.a1 > actual.a2 || actual.b1 > actual.b2) return false;
if (dp.find(actual) != dp.end()) return dp[actual];
if ((actual.a2 - actual.a1 + 1) & 1) {
return dp[actual] = same(actual.a1, actual.a2, actual.b1, actual.b2);
}
if (same(actual.a1, actual.a2, actual.b1, actual.b2)) {
return dp[actual] = true;
}
if ((actual.a2 - actual.a1 + 1) == 2) {
bool cur = (a[actual.a1] == b[actual.b2] && a[actual.a2] == b[actual.b1]);
return cur;
}
int midpoint_a = (actual.a2 + actual.a1) / 2;
int midpoint_b = (actual.b2 + actual.b1) / 2;
bool ans = (solve(Node(actual.a1, midpoint_a, midpoint_b + 1, actual.b2)) &&
solve(Node(midpoint_a + 1, actual.a2, actual.b1, midpoint_b)));
if (!ans)
ans = (solve(Node(actual.a1, midpoint_a, actual.b1, midpoint_b)) &&
solve(Node(midpoint_a + 1, actual.a2, midpoint_b + 1, actual.b2)));
return dp[actual] = ans;
}
int main() {
cin >> a;
init(a, 0);
cin >> b;
init(b, 1);
if (solve(Node(0, a.size() - 1, 0, b.size() - 1)))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long nax = 2e5 + 5;
const long long inf = 1e18;
using pii = pair<long long, long long>;
bool check(string s1, string s2) {
if (s1 == s2) {
return true;
}
if (s1.length() == 1) return false;
if (s1.length() % 2 || s2.length() % 2) return false;
if (check(s1.substr(0, s1.length() / 2),
s2.substr(s2.length() / 2, s2.length() / 2))) {
if (check(s1.substr(s1.length() / 2, s1.length() / 2),
s2.substr(0, s2.length() / 2))) {
return true;
}
}
if (check(s1.substr(0, s1.length() / 2), s2.substr(0, s2.length() / 2))) {
if (check(s1.substr(s1.length() / 2, s1.length() / 2),
s2.substr(s2.length() / 2, s2.length() / 2))) {
return true;
}
}
return false;
}
void solve() {
string s1, s2;
cin >> s1 >> s2;
if (check(s1, s2))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1, t1 = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str(string a) {
if (a.size() % 2 == 1) return a;
string s3, s4;
s3 = str(a.substr(0, a.size() / 2));
s4 = str(a.substr(a.size() / 2, a.size()));
return min(s3, s4) + max(s3, s4);
}
int main() {
ios_base::sync_with_stdio(0);
string a, b;
cin >> a >> b;
a = str(a);
b = str(b);
if (a == b)
cout << "YES";
else
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 2e5 + 400;
struct BIT {
int a[maxv];
long long sum(int p) {
long long ans = 0;
while (p > 0) {
ans += a[p];
p -= p & -p;
}
return ans;
}
void add(int p, int x) {
while (p < maxv) {
a[p] += x;
p += p & -p;
}
}
long long range(int a, int b) { return sum(b) - sum(a - 1); }
} A[26], B[26];
string a, b;
bool dfs(int l1, int r1, int l2, int r2) {
if (r1 - l1 <= 1) return a[l1 - 1] == b[l2 - 1];
for (int i = 0; i < 26; i++) {
if (A[i].range(l1, r1 - 1) != B[i].range(l2, r2 - 1)) {
return 0;
}
}
if ((r2 - l2) % 2 != 0) {
for (int i = l1; i < r1; i++) {
int j = i + l2 - l1;
if (a[i - 1] != b[j - 1]) {
return 0;
}
}
return 1;
}
if (dfs(l1, (l1 + r1) / 2, l2, (l2 + r2) / 2) &&
dfs((l1 + r1) / 2, r1, (l2 + r2) / 2, r2))
return 1;
if (dfs(l1, (l1 + r1) / 2, (l2 + r2) / 2, r2) &&
dfs((l1 + r1) / 2, r1, l2, (r2 + l2) / 2))
return 1;
return 0;
}
int main() {
;
cin >> a >> b;
int sz = a.size();
for (int i = 0; i < sz; i++) {
A[a[i] - 'a'].add(i + 1, 1);
B[b[i] - 'a'].add(i + 1, 1);
}
if (dfs(1, sz + 1, 1, sz + 1)) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
bool call(int x1, int x2, int l) {
int a[26];
memset(a, 0, sizeof(a));
for (int i = 0; i < l; i++) {
a[s1[x1 + i] - 'a']++;
a[s2[x2 + i] - 'a']--;
}
for (int i = 0; i < 26; i++)
if (a[i] != 0) return false;
return true;
}
bool equiv(int x1, int x2, int l) {
bool e = true;
for (int i = 0; i < l; i++) {
if (s1[x1 + i] != s2[x2 + i]) {
e = false;
break;
}
}
if (e) return true;
if (l % 2 == 1) return false;
l = l / 2;
if (call(x1, x2, l))
if (equiv(x1, x2, l) && equiv(x1 + l, x2 + l, l)) return true;
if (call(x1 + l, x2, l))
if (equiv(x1 + l, x2, l) && equiv(x1, x2 + l, l)) return true;
return false;
}
int main() {
cin >> s1 >> s2;
if (call(0, 0, s1.size()) && equiv(0, 0, s1.size()))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
string smaller(string a) {
int len = a.length();
if (len % 2 == 1) return a;
len = len / 2;
string a1, a2;
a1 = smaller(a.substr(0, len));
a2 = smaller(a.substr(len, len));
if (a1 < a2)
return a1 + a2;
else
return a2 + a1;
}
int main() {
cin >> a;
cin >> b;
if (smaller(a) == smaller(b))
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 2e5 + 300;
string a, b;
string get(string a) {
if (a.size() % 2 == 1) return a;
string x = get(a.substr(0, a.size() / 2));
string y = get(a.substr(a.size() / 2, a.size() / 2));
return x > y ? y + x : x + y;
}
int main() {
cin >> a >> b;
string x = get(a);
string y = get(b);
if (x == y) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cf313df(const char *a, const char *b, int ln) {
for (int i = 0; i < ln; i++) {
if (a[i] != b[i]) goto ff;
}
return 1;
ff:
if (ln % 2) return 0;
ln /= 2;
int f = (cf313df(a, b, ln) && cf313df(a + ln, b + ln, ln));
int ff;
if (!f) ff = (cf313df(a, b + ln, ln) && cf313df(a + ln, b, ln));
return f | ff;
}
int main() {
char a[200001], b[200001];
scanf("%s%s", a, b);
int ln = strlen(a);
if (cf313df(a, b, ln))
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cf313df(const char *a, const char *b, int ln) {
int smalla = 0;
for (int i = 0; i < ln; i++) {
if (a[i] != b[i]) {
if (a[i] > b[i]) swap(a, b);
goto ff;
}
}
return 1;
ff:
if (ln & 1) return 0;
ln >>= 1;
int f = (cf313df(a, b, ln) && cf313df(a + ln, b + ln, ln));
int ff;
if (!f) ff = (cf313df(a, b + ln, ln) && cf313df(a + ln, b, ln));
return f | ff;
}
int main() {
char a[200001], b[200001];
scanf("%s%s", a, b);
int ln = strlen(a);
if (cf313df(a, b, ln))
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 200010;
char a[maxx], b[maxx];
bool cmp(int p1, int p2, int len) {
for (int i = 0; i < len; i++)
if (a[i + p1] != b[i + p2]) return 0;
return 1;
}
bool judge(int p1, int p2, int len) {
bool flag = cmp(p1, p2, len);
if (flag == 1) return 1;
if (len & 1) return 0;
len /= 2;
if (((judge(p1, p2, len)) && (judge(p1 + len, p2 + len, len))) ||
(judge(p1, p2 + len, len) && judge(p1 + len, p2, len)))
return 1;
return 0;
}
int main() {
scanf("%s%s", a, b);
if (judge(0, 0, strlen(a)))
printf("YES\n");
else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
bool solve(string a, string b) {
if (a.size() % 2 == 1)
return a == b;
else {
int n = a.size();
string a1 = a.substr(0, n / 2);
string a2 = a.substr(n / 2, n / 2);
string b1 = b.substr(0, n / 2);
string b2 = b.substr(n / 2, n / 2);
return ((solve(a1, b2) and solve(a2, b1)) or
(solve(a1, b1) and solve(a2, b2)));
}
}
int main() {
char a[200005], b[200005];
scanf("%s", a);
scanf("%s", b);
int x = solve(a, b);
if (x == 1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
string sma(string str) {
if (str.size() % 2 == 1) return str;
string s1 = sma(str.substr(0, str.length() / 2));
string s2 = sma(str.substr(str.length() / 2, str.length() / 2));
if (s2 > s1) swap(s1, s2);
return (s1 + s2);
}
int main() {
cin >> a >> b;
if (sma(a) == sma(b))
cout << "YES";
else
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
char a[200010], b[200010];
bool equivalen(int p, int q, int r, int s) {
int flag = 1;
for (int i = p, j = r; i < q; ++i, ++j) {
if (a[i] != b[j]) {
flag = 0;
break;
}
}
if (flag) return 1;
int n = q - p, m = n >> 1;
if (n & 1) return 0;
return (equivalen(p, p + m, r, r + m) && equivalen(p + m, q, r + m, s)) ||
(equivalen(p, p + m, r + m, s) && equivalen(p + m, q, r, r + m));
}
int main() {
scanf("%s%s", a, b);
if (equivalen(0, strlen(a), 0, strlen(b)))
puts("YES");
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str1[1000009];
char str2[1000009];
int n;
bool areEqual(int in1, int fin1, int in2, int fin2) {
int j = in2;
for (int i = in1; i <= fin1; i++, j++)
if (str1[i] != str2[j]) return false;
return true;
}
bool check(int i1, int j1, int i2, int j2) {
if (i1 == j1 && i2 == j2) {
if (str1[i1] == str2[i2])
return true;
else
return false;
}
if ((j1 - i1) % 2 == 0 || (j2 - i2) % 2 == 0) {
return areEqual(i1, j1, i2, j2);
}
int mid1 = i1 + (j1 - i1) / 2;
int mid2 = i2 + (j2 - i2) / 2;
if ((areEqual(i1, mid1, i2, mid2) && areEqual(mid1 + 1, j1, mid2 + 1, j2)) ||
((areEqual(i1, mid1, mid2 + 1, j2) && areEqual(mid1 + 1, j1, i2, mid2))))
return true;
else
(check(i1, mid1, i2, mid2) && check(mid1 + 1, j1, mid2 + 1, j2)) ||
(check(i1, mid1, mid2 + 1, j2) && check(mid1 + 1, j1, i2, mid2));
}
int main() {
scanf("%s", str1);
scanf("%s", str2);
n = strlen(str1);
if (check(0, n - 1, 0, n - 1))
printf("YES\n");
else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int cf313df(const char *a, const char *b, int ln) {
for (int i = 0; i < ln; i++) {
if (a[i] != b[i]) goto ff;
}
return 1;
ff:
if (ln & 1) return 0;
ln >>= 1;
int f = (cf313df(a, b, ln) && cf313df(a + ln, b + ln, ln));
int ff;
if (!f) ff = (cf313df(a, b + ln, ln) && cf313df(a + ln, b, ln));
return f | ff;
}
int main() {
char a[200001], b[200001];
scanf("%s%s", a, b);
int ln = strlen(a);
if (cf313df(a, b, ln))
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
const int INF = 199999999;
char a[maxn], b[maxn];
bool solve(int l1, int r1, int l2, int r2) {
if (r1 - l1 != r2 - l2) return 0;
int len1 = r1 - l1 + 1;
int len2 = len1;
if (len1 % 2 == 1) {
int j, k;
for (j = 0; j < len1; ++j)
if (a[l1 + j] != b[l2 + j]) return 0;
return 1;
} else
return (solve(l1, l1 + len1 / 2 - 1, l2, l2 + len2 / 2 - 1) &&
solve(l1 + len1 / 2, r1, l2 + len2 / 2, r2)) ||
(solve(l1 + len1 / 2, r1, l2, l2 + len2 / 2 - 1) &&
solve(l1, l1 + len1 / 2 - 1, l2 + len2 / 2, r2));
return 0;
}
int main() {
cin >> a >> b;
if (solve(0, strlen(a) - 1, 0, strlen(b) - 1))
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string splitit(string a) {
if (a.size() % 2 == 1) return a;
string a1 = splitit(a.substr(0, (a.size()) / 2));
string a2 = splitit(a.substr((a.size()) / 2, (a.size()) / 2));
if (a1 < a2)
return a1 + a2;
else
return a2 + a1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a >> b;
a = splitit(a);
b = splitit(b);
if (a == b)
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool dfs(char* a, char* b, int l) {
if (strncmp(a, b, l) == 0) return true;
if (l % 2 != 0) return false;
int n = l / 2;
if (dfs(a, b + n, n) && dfs(a + n, b, n)) return true;
if (dfs(a, b, n) && dfs(a + n, b + n, n)) return true;
return false;
}
int main() {
char a[200005], b[200005];
while (cin >> a >> b) {
int len = strlen(a);
if (dfs(a, b, len))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <class T>
auto operator<<(ostream &out, T &&x) -> decltype(x.begin(), out) {
out << "{";
bool f = 1;
for (auto &a : x) {
if (!f) out << ", ";
out << a;
f = 0;
}
return out << "}";
}
template <class T>
void __f(const char *a, T &&t) {
cerr << a << ": " << t << endl;
}
template <class A, class... B>
void __f(const char *n, A &&a, B &&...b) {
const char *c = strchr(n + 1, ',');
cerr.write(n, c - n) << ": " << a << " |";
__f(c + 1, b...);
}
using ll = long long;
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
};
} fast_ios_;
string s, t;
int n;
string solve(string str) {
int l = (int)(str).size();
if (l & 1) return str;
int h = l / 2;
string a = solve(str.substr(0, h));
string b = solve(str.substr(h, h));
return ((a < b) ? a + b : b + a);
}
signed main() {
cin >> s >> t;
string a = solve(s);
string b = solve(t);
cout << (a == b ? "YES" : "NO") << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long MO[] = {1000000007, 1000000009, 1000000007};
long long PR[] = {137, 173, 17};
long long PO[2][200005];
long long HA[2][200005][2];
string a, b;
struct Node {
int a1, b1;
int a2, b2;
Node(int _a1, int _a2, int _b1, int _b2) {
a1 = _a1;
b1 = _b1;
a2 = _a2;
b2 = _b2;
}
bool operator==(const Node &x) const {
if (this->a1 == x.a1 && this->a2 == x.a2 && this->b1 == x.b1 &&
this->b2 == x.b2)
return true;
return false;
}
bool operator<(const Node &x) const {
if (this->a1 == x.a1) {
if (this->a2 == x.a2) {
if (this->b1 == x.b1) {
return this->b2 < x.b2;
}
return this->b1 < x.b1;
}
return this->a2 < x.a2;
}
return this->a1 < x.a1;
}
};
void init(string S, int k) {
PO[0][0] = PO[1][0] = PO[2][0] = 1;
for (int h = 0; h < 2; ++h) {
for (int i = 0; i < S.size(); ++i) {
if (i) PO[h][i] = (PO[h][i - 1] * PR[h]) % MO[h];
if (i)
HA[h][i][k] = ((HA[h][i - 1][k] * PR[h]) + S[i]) % MO[h];
else
HA[h][i][k] = S[i];
}
}
}
long long getHash(int hId, int l, int r, int k) {
long long ret = HA[hId][r][k];
if (l == 0) return ret;
ret = (ret - (HA[hId][l - 1][k] * PO[hId][(r - l + 1)])) % MO[hId];
ret = (ret + MO[hId]) % MO[hId];
return ret;
}
bool same(int l, int r, int l2, int r2) {
for (int i = 0; i < 2; i++) {
if (getHash(i, l, r, 0) != getHash(i, l2, r2, 1)) return false;
}
return true;
}
map<Node, bool> dp;
bool solve(Node actual) {
if (dp.find(actual) != dp.end()) return dp[actual];
if ((actual.a2 - actual.a1 + 1) & 1) {
return dp[actual] = same(actual.a1, actual.a2, actual.b1, actual.b2);
}
if (same(actual.a1, actual.a2, actual.b1, actual.b2)) {
return dp[actual] = true;
}
if ((actual.a2 - actual.a1 + 1) == 2) {
return (a[actual.a1] == b[actual.b2] && a[actual.a2] == b[actual.b1]);
}
int midpoint_a = (actual.a2 + actual.a1) / 2;
int midpoint_b = (actual.b2 + actual.b1) / 2;
bool ans = (solve(Node(actual.a1, midpoint_a, midpoint_b + 1, actual.b2)) &&
solve(Node(midpoint_a + 1, actual.a2, actual.b1, midpoint_b)));
if (!ans)
ans = (solve(Node(actual.a1, midpoint_a, actual.b1, midpoint_b)) &&
solve(Node(midpoint_a + 1, actual.a2, midpoint_b + 1, actual.b2)));
return dp[actual] = ans;
}
int main() {
cin >> a;
init(a, 0);
cin >> b;
init(b, 1);
if (solve(Node(0, a.size() - 1, 0, b.size() - 1)))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string smallestEq(string s) {
int stringLength = s.length();
if (stringLength % 2 == 1) return s;
string s1, s2;
s1 = smallestEq(s.substr(0, stringLength / 2));
s2 = smallestEq(s.substr(stringLength / 2, stringLength / 2));
if (s1 < s2) return s1 + s2;
return s2 + s1;
}
int main() {
string s1, s2;
cin >> s1 >> s2;
s1 = smallestEq(s1);
s2 = smallestEq(s2);
if (s1 == s2) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cf313df(const char *a, const char *b, int ln) {
for (int i = 0; i < ln; i++) {
if (a[i] != b[i]) break;
if (i == ln - 1) {
return 1;
}
}
if (ln % 2) return 0;
ln /= 2;
int f = (cf313df(a, b, ln) && cf313df(a + ln, b + ln, ln));
int ff;
if (!f) ff = (cf313df(a, b + ln, ln) && cf313df(a + ln, b, ln));
return f | ff;
}
int main() {
char a[200001], b[200001];
scanf("%s%s", a, b);
int ln = strlen(a);
if (cf313df(a, b, ln))
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[200007], b[200007];
int f(int la, int ra, int lb, int rb) {
int len = ra - la + 1;
if (len % 2 == 1) {
for (int i = 0; i < len; i++)
if (a[la + i] != b[lb + i]) return 0;
return 1;
} else {
int ma = (la + ra) / 2, mb = (lb + rb) / 2;
if (f(la, ma, lb, mb) && f(ma + 1, ra, mb + 1, rb)) return 1;
if (f(la, ma, mb + 1, rb) && f(ma + 1, ra, lb, mb)) return 1;
return 0;
}
}
int main() {
scanf("%s%s", a, b);
if (f(0, strlen(a) - 1, 0, strlen(b) - 1))
printf("YES\n");
else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
string word, word2;
bool check(string a, string b) {
if (a == b) return 1;
int len = a.size();
if (len & 1 || len == 0) return 0;
len >>= 1;
string temp, temp1, tmp, tmp1;
temp.assign(a, 0, len), temp1.assign(a, len, len), tmp.assign(b, 0, len),
tmp1.assign(b, len, len);
if (check(temp, tmp1) && check(temp1, tmp) ||
check(temp, tmp) && check(temp1, tmp1))
return 1;
return 0;
}
int main() {
cin >> word >> word2;
if (check(word, word2))
puts("YES");
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string divAndConq(string sip) {
if (sip.size() % 2 == 1) return sip;
string s1 = divAndConq(string(sip.begin(), sip.begin() + sip.size() / 2));
string s2 = divAndConq(string(sip.begin() + sip.size() / 2, sip.end()));
if (s1 < s2)
return s1 + s2;
else
return s2 + s1;
}
int main() {
string a, b;
cin >> a;
cin >> b;
if (divAndConq(a) == divAndConq(b))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
long long int m, n, res, k, ans = 0, nbcycle = 0;
string s1 = "", s2 = "zero", ch = "", s;
set<long long int> st;
multiset<long long int> mst;
vector<pair<long long int, long long int> > vv, vv2, vm;
vector<pair<long long int, pair<long long int, long long int> > > vvv;
vector<pair<long long int, long long int> > vvs;
vector<long long int> v[200005];
string solve(string s) {
if (s.size() % 2 == 1) return s;
string s1 = solve(s.substr(0, s.size() / 2));
string s2 = solve(s.substr(s.size() / 2, s.size()));
if (s1 <= s2)
return s1 + s2;
else
return s2 + s1;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int i = 0, x, y, j = 0, z, q, nb0 = 0, nbp = 0, nbn = 0, nbmax = 0,
nbinf = 0, mm = 5e8, idx = 0, ok = 0, l = 0, r = 0, negatif = 0,
positif = 0, l1, r1, t, d;
multiset<long long int>::iterator it;
char c;
cin >> s1 >> s2;
n = s1.size();
s1 = solve(s1);
s2 = solve(s2);
if (s1 == s2)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
string lexicographicMinimum(string s) {
int n = s.length();
if (n % 2 != 0) return s;
string s1 = lexicographicMinimum(s.substr(0, n / 2));
string s2 = lexicographicMinimum(s.substr(n / 2, n));
if (s1 < s2)
return s1 + s2;
else
return s2 + s1;
}
int main() {
cin.sync_with_stdio(false);
cin >> s1 >> s2;
cout << (lexicographicMinimum(s1) == lexicographicMinimum(s2) ? "YES" : "NO")
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool solve(string a, string b) {
if (a.length() & 1)
return a == b;
else {
string a_f = a.substr(0, a.length() / 2);
string a_l = a.substr(a.length() / 2, a.length() / 2);
string b_f = b.substr(0, b.length() / 2);
string b_l = b.substr(b.length() / 2, b.length() / 2);
return solve(a_f, b_l) && solve(a_l, b_f) ||
solve(a_f, b_f) && solve(a_l, b_l);
}
}
int main() {
ios::sync_with_stdio(false);
string s1, s2;
cin >> s1 >> s2;
if (solve(s1, s2))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
inline const int getint() {
int r = 0, k = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') k = -1;
for (; c >= '0' && c <= '9'; c = getchar()) r = r * 10 + c - '0';
return k * r;
}
const int maxn = 2e5 + 10;
const int maxm = 5e4 * 4 + 10;
const int inf = 1e9;
int a[10];
char s1[maxn], s2[maxn];
int n, m;
bool check(int len, int la, int lb) {
if (len & 1) {
int i;
for (i = 0; i <= len - 1; i++)
if (s1[la + i] != s2[lb + i]) {
return false;
}
return true;
} else {
int flag = 1;
int i;
for (i = 0; i <= len - 1; i++)
if (s1[la + i] != s2[lb + i]) {
flag = 0;
break;
}
if (flag) return true;
if ((check(len / 2, la, lb) &&
check(len / 2, la + len / 2, lb + len / 2)) ||
(check(len / 2, la, lb + len / 2) &&
check(len / 2, la + len / 2, lb))) {
return true;
} else
return false;
}
}
int main() {
while (scanf("%s%s", s1, s2) != EOF) {
int len1 = strlen(s1);
if (check(len1, 0, 0)) {
puts("YES");
} else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int L = 200000;
const unsigned int MAGIC1 = 10007;
const unsigned int MAGIC2 = 127;
char s[L + 5], t[L + 5];
unsigned int sh1[L + 5], th1[L + 5], base1[L + 5];
unsigned int sh2[L + 5], th2[L + 5], base2[L + 5];
int n;
inline void init_hash(unsigned int h[], char s[], unsigned int base[]) {
h[0] = 0;
for (int i = 1; i <= n; i++) h[i] = h[i - 1] * base[1] + s[i - 1];
}
inline unsigned int gethash(unsigned int h[], int l, int r,
unsigned int base[]) {
r++;
return h[r] - h[l] * base[r - l];
}
inline bool ok(int L1, int R1, int L2, int R2) {
return gethash(sh1, L1, R1, base1) == gethash(th1, L2, R2, base1) &&
gethash(sh2, L1, R1, base2) == gethash(th2, L2, R2, base2);
}
bool check(int L1, int R1, int L2, int R2) {
int len = R1 - L1 + 1;
if (ok(L1, R1, L2, R2)) return 1;
if (len & 1) return 0;
int hlen = len >> 1;
return (check(L1, R1 - hlen, L2 + hlen, R2) &&
check(L1 + hlen, R1, L2, R2 - hlen)) ||
(check(L1, R1 - hlen, L2, R2 - hlen) &&
check(L1 + hlen, R1, L2 + hlen, R2));
}
inline void prepare() {
base1[0] = base2[0] = 1;
for (int i = 1; i <= n; i++) {
base1[i] = base1[i - 1] * MAGIC1;
base2[i] = base2[i - 1] * MAGIC2;
}
init_hash(sh1, s, base1);
init_hash(sh2, s, base2);
init_hash(th1, t, base1);
init_hash(th2, t, base2);
}
int main() {
scanf("%s", s);
scanf("%s", t);
n = strlen(s);
prepare();
if (check(0, n - 1, 0, n - 1))
puts("YES");
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[200005], b[200005];
int chk(char* a1, char* b1, int l) {
bool flag = 0;
for (int i = 0; i < l; i++) {
if (a1[i] != b1[i]) {
flag = 1;
break;
}
}
if (flag == 0) return 1;
if (l % 2 == 1) return 0;
return (chk(a1, b1, l / 2) && chk(a1 + l / 2, b1 + l / 2, l / 2)) ||
(chk(a1, b1 + l / 2, l / 2) && chk(a1 + l / 2, b1, l / 2));
}
int main() {
while (scanf("%s%s", a, b) != EOF) {
if (chk(a, b, strlen(b)))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[201000], b[201000];
int hash1[201000], hash2[201000], seed = 131, base[201000];
bool solve(int be1, int en1, int be2, int en2) {
if ((en1 - be1 + 1) & 1 || (en2 - be2 + 1) & 1) return 0;
int a1, a2, b1, b2;
int mid1 = (be1 + en1) / 2;
int mid2 = (be2 + en2) / 2;
a1 = hash1[mid1];
if (be1 > 0) a1 -= hash1[be1 - 1] * base[mid1 - be1 + 1];
a2 = hash1[en1] - hash1[mid1] * base[en1 - mid1];
b1 = hash2[mid2];
if (be2 > 0) b1 -= hash2[be2 - 1] * base[mid2 - be2 + 1];
b2 = hash2[en2] - hash2[mid2] * base[en2 - mid2];
if ((a1 == b1 && a2 == b2) || (a1 == b2 && a2 == b1))
return 1;
else {
if ((a1 == b1 || solve(be1, mid1, be2, mid2)) &&
(a2 == b2 || solve(mid1 + 1, en1, mid2 + 1, en2)))
return 1;
else if (((a1 == b2) || solve(be1, mid1, mid2 + 1, en2)) &&
((a2 == b1) || solve(mid1 + 1, en1, be2, mid2)))
return 1;
return 0;
}
}
int main() {
base[1] = seed;
for (int i = 2; i <= 200000; i++) base[i] = base[i - 1] * seed;
while (scanf("%s%s", a, b) != EOF) {
hash1[0] = (a[0] - 'a' + 1);
int len1 = strlen(a), len2 = strlen(b);
hash2[0] = (b[0] - 'a' + 1);
for (int i = 1; i < len1; i++)
hash1[i] = hash1[i - 1] * seed + (a[i] - 'a' + 1);
for (int i = 1; i < len2; i++)
hash2[i] = hash2[i - 1] * seed + (b[i] - 'a' + 1);
if (hash1[len1 - 1] == hash2[len2 - 1]) {
puts("YES");
;
continue;
}
if (solve(0, len1 - 1, 0, len2 - 1))
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 1e6 + 5;
const int MOD = 1e9 + 7;
const int CM = 998244353;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
template <typename T>
T MAX(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T MIN(T a, T b) {
return a > b ? b : a;
}
template <typename T>
T GCD(T a, T b) {
return b == 0 ? a : GCD(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
return a / GCD(a, b) * b;
}
template <typename T>
T ABS(T a) {
return a > 0 ? a : -a;
}
template <typename T>
T ADD(T a, T b, T MOD) {
return (a + b) % MOD;
}
template <typename T>
T DEL(T a, T b, T MOD) {
return ((a - b) % MOD + MOD) % MOD;
}
template <typename T>
T getmod(T a, T mod) {
return (a % mod + mod) % mod;
}
template <typename T>
void debug(T a, char x) {
return;
}
int rand(int a, int b) { return rand() % (b - a + 1) + a; }
string a, b;
bool divi(string a, string b) {
if (a == b) return 1;
int n = a.length();
if (n & 1) return 0;
string a1 = a.substr(0, n / 2), a2 = a.substr(n / 2, n / 2);
string b1 = b.substr(0, n / 2), b2 = b.substr(n / 2, n / 2);
if (divi(a1, b2) && divi(a2, b1)) return 1;
if (divi(a1, b1) && divi(a2, b2)) return 1;
return 0;
}
void solve(int kase) {
cin >> a >> b;
if (divi(a, b))
printf("YES\n");
else
printf("NO\n");
}
const bool DUO = 0;
void TIME() {
clock_t start, finish;
double totaltime;
start = clock();
if (DUO) {
int Kase = 0;
cin >> Kase;
for (int kase = 1; kase <= Kase; kase++) solve(kase);
} else
solve(1);
finish = clock();
totaltime = (double)(finish - start) / CLOCKS_PER_SEC;
printf("\nTime:%lfms\n", totaltime * 1000);
}
int main() {
if (DUO) {
int Kase = 0;
cin >> Kase;
for (int kase = 1; kase <= Kase; kase++) solve(kase);
} else
solve(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string least(string ax) {
if (ax.size() <= 1) return ax;
int mid = ax.size() / 2;
if (mid % 2 == 1) {
string l = ax.substr(0, mid), r = ax.substr(mid, ax.size() - 1);
if (l < r) return (l + r);
return (r + l);
}
string l = least(ax.substr(0, mid)), r = least(ax.substr(mid, ax.size() - 1));
if (l < r) return (l + r);
return (r + l);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string a, b;
cin >> a >> b;
string c = least(a), d = least(b);
cout << (c == d ? "YES" : "NO") << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
bool echiv(int x, int xx, int y, int yy) {
if ((xx - x + 1) % 2 == 1) {
for (int i = x, j = y; i <= xx && j <= yy; ++i, ++j) {
if (a[i] != b[j]) {
return 0;
}
}
return 1;
}
int midx = (x + xx) >> 1;
int midy = (y + yy) >> 1;
return ((echiv(x, midx, y, midy) && echiv(midx + 1, xx, midy + 1, yy)) ||
(echiv(x, midx, midy + 1, yy) && echiv(midx + 1, xx, y, midy)));
}
int main() {
cin >> a >> b;
bool ans = echiv(0, (int)a.size() - 1, 0, (int)b.size() - 1);
if (ans == 1)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string ans[2] = {"NO", "YES"};
string lex_min(string a) {
if ((a.size()) & 1) return a;
string b, c;
b = lex_min(a.substr(0, a.size() / 2));
c = lex_min(a.substr(a.size() / 2, a.size() / 2));
if (b < c)
return b + c;
else
return c + b;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
string a, b;
cin >> a >> b;
cout << ans[lex_min(a) == lex_min(b)] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[201000], b[201000];
int hash1[201000], hash2[201000], seed = 131, base[201000];
bool solve(int be1, int en1, int be2, int en2) {
if ((en1 - be1 + 1) & 1 || (en2 - be2 + 1) & 1) return 0;
int a1, a2, b1, b2;
int mid1 = (be1 + en1) / 2;
int mid2 = (be2 + en2) / 2;
a1 = hash1[mid1];
if (be1 > 0) a1 -= hash1[be1 - 1] * base[mid1 - be1 + 1];
a2 = hash1[en1] - hash1[mid1] * base[en1 - mid1];
b1 = hash2[mid2];
if (be2 > 0) b1 -= hash2[be2 - 1] * base[mid2 - be2 + 1];
b2 = hash2[en2] - hash2[mid2] * base[en2 - mid2];
if ((a1 == b1 || solve(be1, mid1, be2, mid2)) &&
(a2 == b2 || solve(mid1 + 1, en1, mid2 + 1, en2)))
return 1;
else if (((a1 == b2) || solve(be1, mid1, mid2 + 1, en2)) &&
((a2 == b1) || solve(mid1 + 1, en1, be2, mid2)))
return 1;
return 0;
}
int main() {
base[1] = seed;
for (int i = 2; i <= 200000; i++) base[i] = base[i - 1] * seed;
while (scanf("%s%s", a, b) != EOF) {
hash1[0] = (a[0] - 'a' + 1);
int len1 = strlen(a), len2 = strlen(b);
hash2[0] = (b[0] - 'a' + 1);
for (int i = 1; i < len1; i++)
hash1[i] = hash1[i - 1] * seed + (a[i] - 'a' + 1);
for (int i = 1; i < len2; i++)
hash2[i] = hash2[i - 1] * seed + (b[i] - 'a' + 1);
if (hash1[len1 - 1] == hash2[len2 - 1]) {
puts("YES");
;
continue;
}
if (solve(0, len1 - 1, 0, len2 - 1))
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 25;
void io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& s) {
return os << '(' << s.first << ',' << s.second << ')';
}
const int MOD = 1000000007;
const double EPS = 1e-8;
string a, b;
bool check(int sa, int sb, int size) {
if (size % 2 != 0) {
for (int i = 0; i < size; i++) {
if (a[sa + i] != b[sb + i]) return 0;
}
return 1;
}
return (check(sa, sb, size / 2) &&
check(sa + size / 2, sb + size / 2, size / 2)) ||
(check(sa + size / 2, sb, size / 2) &&
check(sa, sb + size / 2, size / 2));
}
int main() {
io();
cin >> a >> b;
int length = a.size();
if (check(0, 0, length)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5;
string findsmallest(string s) {
if (s.length() & 1) return s;
string s1 = findsmallest(s.substr(0, s.length() / 2)),
s2 = findsmallest(s.substr(s.length() / 2, s.length()));
if (s1 < s2) return s1 + s2;
return s2 + s1;
}
int main() {
string s[2];
cin >> s[0] >> s[1];
s[0] = findsmallest(s[0]);
s[1] = findsmallest(s[1]);
if (s[0] == s[1])
printf("YES\n");
else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
string go(string s) {
if (s.size() % 2) return s;
string half1 = go(s.substr(0, s.size() / 2));
string half2 = go(s.substr(s.size() / 2));
if (half1 < half2)
return half1 + half2;
else
return half2 + half1;
}
int main() {
string s1, s2;
cin >> s1 >> s2;
if (go(s1) == go(s2))
cout << "YES" << endl;
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int dfs(int s1, int t1, int s2) {
int len = t1 - s1 + 1;
if (len & 1) {
for (int i = 0; i < len; i++) {
if (a[i + s1] != b[i + s2]) return 0;
}
return 1;
}
len /= 2;
if (dfs(s1, s1 + len - 1, s2) && dfs(s1 + len, t1, s2 + len)) return 1;
if (dfs(s1 + len, t1, s2) && dfs(s1, s1 + len - 1, s2 + len))
return 1;
else
return 0;
}
int main() {
int n, m, k, l;
while (cin >> a >> b) {
l = a.length();
if (dfs(0, l - 1, 0))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
const int INF = (1 << 29);
const double EPS = 0.0000000001;
const double Pi = acos(-1.0);
char a[maxn], b[maxn];
bool jud(char *a, char *b, int L) {
bool flag = 1;
for (int(i) = (0); (i) <= (L - 1); (i)++) {
if (a[i] != b[i]) {
flag = 0;
break;
}
}
if (flag) return 1;
if (L % 2) return 0;
L /= 2;
return (jud(a, b, L) && jud(a + L, b + L, L)) ||
(jud(a, b + L, L) && jud(a + L, b, L));
}
int main() {
while (~scanf("%s%s", a, b)) {
puts(jud(a, b, strlen(a)) ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
namespace chtholly {
char buf[1 << 22], *p1 = buf, *p2 = buf;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) putchar('-'), x = -x;
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int yuzu = 2e5;
typedef char norie[yuzu | 10];
norie a, b;
bool same(int la, int ra, int lb, int rb) {
for (int i = la, j = lb; i <= ra; ++i, ++j)
if (a[i] ^ b[j]) return 0;
return 1;
}
bool equiv(int la, int ra, int lb, int rb) {
if (la > ra || lb > rb) return 0;
if (same(la, ra, lb, rb)) return 1;
if (ra - la & 1 && rb - lb & 1) {
int ma = la + ra >> 1, mb = lb + rb >> 1;
return equiv(la, ma, lb, mb) && equiv(ma + 1, ra, mb + 1, rb) ||
equiv(la, ma, mb + 1, rb) && equiv(ma + 1, ra, lb, mb);
}
return 0;
}
int main() {
scanf("%s%s", a + 1, b + 1);
int n = strlen(a + 1);
puts(equiv(1, n, 1, n) ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
char str1[200010], str2[200010];
int sum1[200010][27], sum2[200010][27];
bool dfs(int l1, int r1, int l2, int r2) {
int len = r1 - l1 + 1;
if (len & 1) {
for (int i = 0; i < len; i++)
if (str1[l1 + i] != str2[l2 + i]) return 0;
return 1;
}
int mid1 = (l1 + r1) >> 1, mid2 = (l2 + r2) >> 1;
bool f1 = 1, f2 = 1, f3 = 1, f4 = 1;
for (int j = 0; j < 26; j++) {
if (!f1 && !f2 && !f3 && !f4) break;
if (f1 &&
sum1[mid1 + 1][j] - sum1[l1][j] != sum2[mid2 + 1][j] - sum2[l2][j]) {
f1 = 0;
}
if (f2 && sum1[r1 + 1][j] - sum1[mid1 + 1][j] !=
sum2[r2 + 1][j] - sum2[mid2 + 1][j]) {
f2 = 0;
}
if (f3 && sum1[mid1 + 1][j] - sum1[l1][j] !=
sum2[r2 + 1][j] - sum2[mid2 + 1][j]) {
f3 = 0;
}
if (f4 && sum1[r1 + 1][j] - sum1[mid1 + 1][j] !=
sum2[mid2 + 1][j] - sum2[l2][j]) {
f4 = 0;
}
}
bool flag1 = 0, flag2 = 0;
if (f1 && f2)
flag1 = dfs(l1, mid1, l2, mid2) && dfs(mid1 + 1, r1, mid2 + 1, r2);
if (flag1) return 1;
if (f3 && f4)
flag2 = dfs(l1, mid1, mid2 + 1, r2) && dfs(mid1 + 1, r1, l2, mid2);
if (flag2) return 1;
return 0;
}
int main(int argc, char* argv[]) {
scanf("%s%s", &str1, &str2);
memset(sum1, 0, sizeof(sum1));
memset(sum2, 0, sizeof(sum2));
int n = strlen(str1);
if (n & 1) {
if (strcmp(str1, str2) == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
if (str1[i - 1] - 'a' == j)
sum1[i][j] = sum1[i - 1][j] + 1;
else
sum1[i][j] = sum1[i - 1][j];
if (str2[i - 1] - 'a' == j)
sum2[i][j] = sum2[i - 1][j] + 1;
else
sum2[i][j] = sum2[i - 1][j];
}
}
bool flag = dfs(0, n - 1, 0, n - 1);
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbg(const char *xn, T x) {
cerr << xn << ": " << x << "\n";
}
template <class T, class... TA>
void dbg(const char *xn, T x, TA... t) {
while (*xn != ',') cerr << *xn++;
cerr << ": " << x << ",";
dbg(xn + 1, t...);
}
template <class T>
inline bool upd_max(T &x, T y) {
return y > x ? x = y, true : false;
}
template <class T>
inline bool upd_min(T &x, T y) {
return y < x ? x = y, true : false;
}
template <class T>
inline void add(T &x, T y) {
x += y;
}
using namespace std;
string sa, sb;
string represent(string s) {
int nNow = ((int)(s).size());
if (nNow & 1) return s;
string s1 = represent(s.substr(0, nNow / 2));
string s2 = represent(s.substr(nNow / 2, nNow));
if (s1 < s2) return s1 + s2;
return s2 + s1;
}
void solve() {
cin >> sa >> sb;
string reprA = represent(sa);
string reprB = represent(sb);
if (reprA == reprB)
cout << "YES";
else
cout << "NO";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout << fixed << setprecision(10);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b) {
return a * (b / gcd(a, b));
}
long long int modpower(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int p = modpower(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a;
b >>= 1;
}
return ans;
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
string s_sorting(string a) {
long long int n = a.length();
if (n % 2) return a;
string b = a.substr(0, n / 2);
string c = a.substr(n / 2, n / 2);
b = s_sorting(b);
c = s_sorting(c);
if (b < c)
return b + c;
else
return c + b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s1, s2;
cin >> s1 >> s2;
s1 = s_sorting(s1);
s2 = s_sorting(s2);
long long int ans = (s1 == s2);
if (ans)
cout << "YES";
else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int solve(int st1, int en1, int st2, int en2) {
int f = 0;
for (int i = st1, j = st2; i < en1 && j < en2; i++, j++) {
if (a[i] != b[j]) {
f = 1;
break;
}
}
if (!f) return 1;
if ((en1 - st1) & 1 || (en2 - st2) & 1) return 0;
int mid1 = (st1 + en1) / 2, mid2 = (st2 + en2) / 2;
int ans = solve(st1, mid1, st2, mid2);
if (ans) ans = solve(mid1, en1, mid2, en2);
if (ans) return 1;
ans = solve(st1, mid1, mid2, en2);
if (ans) ans = solve(mid1, en1, st2, mid2);
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b;
cout << (solve(0, a.size(), 0, b.size()) ? "YES" : "NO") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(vector<vector<size_t>>& h1, vector<vector<size_t>>& h2, int deg,
int one, int two) {
if (h1[deg][one] == h2[deg][two]) {
return true;
}
if (deg > 0) {
return (comp(h1, h2, deg - 1, 2 * one, 2 * two) &&
comp(h1, h2, deg - 1, 2 * one + 1, 2 * two + 1)) ||
(comp(h1, h2, deg - 1, 2 * one, 2 * two + 1) &&
comp(h1, h2, deg - 1, 2 * one + 1, 2 * two));
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(7);
srand(35);
std::hash<std::string> hash_fn;
std::string str1, str2;
std::cin >> str1 >> str2;
int n = str1.size();
int q = 1;
int po = 1;
while (n % (2 * q) == 0) {
q *= 2;
++po;
}
int m = n / q;
vector<vector<size_t>> h1(po);
vector<vector<size_t>> h2(po);
for (size_t i = 0; i < q; ++i) {
h1[0].push_back(hash_fn(str1.substr(i * m, m)));
h2[0].push_back(hash_fn(str2.substr(i * m, m)));
}
for (size_t de = 1; de < po; ++de) {
for (size_t i = 0; 2 * i < h1[de - 1].size(); ++i) {
h1[de].push_back((h1[de - 1][2 * i] + h1[de - 1][2 * i + 1] * 23) %
1000000007);
h2[de].push_back((h2[de - 1][2 * i] + h2[de - 1][2 * i + 1] * 23) %
1000000007);
}
}
if (comp(h1, h2, po - 1, 0, 0)) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char sa[200010], sb[200010];
bool divd(int l1, int r1, int l2, int r2) {
int i, j;
for (i = l1, j = l2; i <= r1 && j <= r2; i++, j++) {
if (sa[i] != sb[j]) return false;
}
return true;
}
bool check(int l1, int r1, int l2, int r2) {
if (l1 == r1 && !divd(l1, r1, l2, r2)) {
return false;
}
if (divd(l1, r1, l2, r2)) {
return true;
}
int len = r1 - l1 + 1;
if (len & 1) return false;
int m1 = (l1 + r1) >> 1, m2 = (l2 + r2) >> 1;
return check(l1, m1, l2, m2) && check(m1 + 1, r1, m2 + 1, r2) ||
(check(l1, m1, m2 + 1, r2) && check(m1 + 1, r1, l2, m2));
}
int main() {
int i, j;
while (~scanf("%s%s", sa + 1, sb + 1)) {
int l = strlen(sa + 1);
printf("%s\n", check(1, l, 1, l) ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXLEN = 2e5 + 10;
string s, t;
int l;
bool ck(int l1, int l2, int len) {
return s.substr(l1, len) == t.substr(l2, len);
}
bool cck(int l1, int l2, int len) {
if (len % 2) return s.substr(l1, len) == t.substr(l2, len);
return (cck(l1, l2 + len / 2, len / 2) && cck(l1 + len / 2, l2, len / 2)) ||
(cck(l1, l2, len / 2) && cck(l1 + len / 2, l2 + len / 2, len / 2));
}
int main() {
cin >> s >> t;
l = s.size();
bool c = cck(0, 0, l);
if (c) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
char str1[200010], str2[200010];
int sum1[200010][27], sum2[200010][27];
bool dfs(int l1, int r1, int l2, int r2) {
int len = r1 - l1 + 1;
if (len & 1) {
for (int i = 0; i < len; i++)
if (str1[l1 + i] != str2[l2 + i]) return 0;
return 1;
}
int mid1 = (l1 + r1) >> 1, mid2 = (l2 + r2) >> 1;
bool f1 = 1, f2 = 1, f3 = 1, f4 = 1;
bool flag1 = 0, flag2 = 0;
if (f1 && f2)
flag1 = dfs(l1, mid1, l2, mid2) && dfs(mid1 + 1, r1, mid2 + 1, r2);
if (flag1) return 1;
if (f3 && f4)
flag2 = dfs(l1, mid1, mid2 + 1, r2) && dfs(mid1 + 1, r1, l2, mid2);
if (flag2) return 1;
return 0;
}
int main(int argc, char* argv[]) {
scanf("%s%s", &str1, &str2);
int n = strlen(str1);
if (n & 1) {
if (strcmp(str1, str2) == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
if (str1[i - 1] - 'a' == j)
sum1[i][j] = sum1[i - 1][j] + 1;
else
sum1[i][j] = sum1[i - 1][j];
if (str2[i - 1] - 'a' == j)
sum2[i][j] = sum2[i - 1][j] + 1;
else
sum2[i][j] = sum2[i - 1][j];
}
}
bool flag = dfs(0, n - 1, 0, n - 1);
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5;
const int MOD = 1e9 + 7;
const long long INF = 1061109567;
const long double EPS = 1e-9;
const long double PI = acos(-1);
bool solve(string a, string b) {
if (a == b) return true;
int len = a.length();
if (len % 2 != 0) return false;
string a1 = a.substr(0, len / 2);
string a2 = a.substr(len / 2, len / 2);
string b1 = b.substr(0, len / 2);
string b2 = b.substr(len / 2, len / 2);
if ((solve(a1, b2) && solve(a2, b1)) || (solve(a1, b1) && solve(a2, b2)))
return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a >> b;
cout << (solve(a, b) ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
string solve(string s) {
int n;
if ((n = s.length()) % 2 == 1) return s;
n /= 2;
string s1 = solve(s.substr(0, n)), s2 = solve(s.substr(n, n));
return (s1 > s2 ? s2 + s1 : s1 + s2);
}
int main() {
cin >> s >> t;
cout << ((solve(s) == solve(t)) ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool same(string& s1, int64_t l1, int64_t r1, string& s2, int64_t l2,
int64_t r2) {
for (int64_t i = 0; i <= r1 - l1; i++) {
if (s1[l1 + i] != s2[l2 + i]) {
return false;
}
}
return true;
}
bool eq(string& s1, int64_t l1, int64_t r1, string& s2, int64_t l2,
int64_t r2) {
if (l1 == r1) {
if (s1[l1] == s2[l2]) {
return true;
}
return false;
}
if (same(s1, l1, r1, s2, l2, r2)) {
return true;
}
if ((r1 - l1 + 1) % 2 == 1) {
return false;
}
int64_t m1 = (l1 + r1) / 2;
int64_t m2 = (l2 + r2) / 2;
bool ok1 = eq(s1, l1, m1, s2, l2, m2);
bool ok2;
if (ok1) {
ok2 = eq(s1, m1 + 1, r1, s2, m2 + 1, r2);
if (!ok2) {
return false;
} else {
return true;
}
} else {
ok1 = eq(s1, l1, m1, s2, m2 + 1, r2);
if (ok1) {
ok2 = eq(s1, m1 + 1, r1, s2, l2, m2);
if (ok2) {
return true;
} else {
return false;
}
} else {
return false;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s1;
string s2;
cin >> s1 >> s2;
int64_t n = s1.size();
bool okay = eq(s1, 0, n - 1, s2, 0, n - 1);
if (okay) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
const long long MOD = 1000000000 + 7;
const long long MAXN = 100000 + 100;
const long long MAGIC = 123123123;
const double PI = 4 * atan(1.);
const double EPS = 1E-7;
struct cmp_for_set {
bool operator()(const int& a, const int& b) { return a > b; }
};
void time_elapsed() {
cout << "\nTIME ELAPSED: " << (double)clock() / CLOCKS_PER_SEC << " sec\n";
}
template <typename T>
T gcd(T a, T b) {
return ((!b) ? a : gcd(b, a % b));
}
template <typename T>
T gcd(T a, T b, T& x, T& y) {
if (!a) {
x = 0, y = 1;
return b;
}
T x1, y1;
T d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
template <typename T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <typename T, typename M>
T neg_mod(T a, M mod) {
return ((a % mod) + mod) % mod;
}
long long binpow(long long x, long long p) {
long long res = 1;
while (p) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
long long binpow_mod(long long x, long long p, long long m) {
long long res = 1;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
struct state {
long long mask;
long long sum[3];
state() {
mask = 0;
sum[0] = sum[1] = sum[2] = 0;
}
};
bool operator<(const state& a, const state& b) {
return (
a.sum[0] < b.sum[0] || (a.sum[0] == b.sum[0] && a.sum[1] < b.sum[1]) ||
(a.sum[0] == b.sum[0] && a.sum[1] == b.sum[1] && a.sum[2] < b.sum[2]));
}
char let[] = {'L', 'M', 'W'};
int main() {
int n;
cin >> n;
vector<vector<long long>> vec1(n / 2, vector<long long>(3)),
vec2(n - n / 2, vector<long long>(3));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
if (i < n / 2) {
scanf("%I64d", &vec1[i][j]);
} else {
scanf("%I64d", &vec2[i - n / 2][j]);
}
}
}
map<pair<long long, long long>, state> mem;
vector<long long> pow3(20);
pow3[0] = 1;
for (int i = 1; i < 20; ++i) {
pow3[i] = pow3[i - 1] * 3LL;
}
vector<long long> cmask(20);
for (int mask = 0; mask < pow3[vec1.size()]; ++mask) {
long long mm = mask;
for (int j = 0; j < vec1.size(); ++j) {
cmask[j] = mm % 3;
mm /= 3;
}
state cur_state;
for (int j = 0; j < vec1.size(); ++j) {
for (int k = 0; k < 3; ++k) {
cur_state.sum[k] += vec1[j][k];
}
cur_state.sum[cmask[j]] -= vec1[j][cmask[j]];
}
cur_state.mask = mask;
pair<long long, long long> cur_delta =
make_pair(cur_state.sum[1] - cur_state.sum[0],
cur_state.sum[2] - cur_state.sum[0]);
if (!mem.count(cur_delta)) {
mem[cur_delta] = cur_state;
} else if (mem[cur_delta] < cur_state) {
mem[cur_delta] = cur_state;
}
}
pair<long long, long long> best;
long long best_sum = -9999999999999999;
for (int mask = 0; mask < pow3[vec2.size()]; ++mask) {
long long mm = mask;
for (int j = 0; j < vec2.size(); ++j) {
cmask[j] = mm % 3;
mm /= 3;
}
state cur_state;
for (int j = 0; j < vec2.size(); ++j) {
for (int k = 0; k < 3; ++k) {
cur_state.sum[k] += vec2[j][k];
}
cur_state.sum[cmask[j]] -= vec2[j][cmask[j]];
}
cur_state.mask = mask;
pair<long long, long long> cur_delta =
make_pair(cur_state.sum[1] - cur_state.sum[0],
cur_state.sum[2] - cur_state.sum[0]);
pair<long long, long long> need = cur_delta;
need.first *= -1;
need.second *= -1;
if (mem.count(need)) {
state ss = mem[need];
if (cur_state.sum[0] + ss.sum[0] > best_sum) {
best_sum = cur_state.sum[0] + ss.sum[0];
best = make_pair(ss.mask, cur_state.mask);
}
}
}
if (best_sum == -9999999999999999) {
puts("Impossible");
} else {
for (int j = 0; j < vec1.size(); ++j) {
long long mm = best.first;
for (int j = 0; j < vec1.size(); ++j) {
cmask[j] = mm % 3;
mm /= 3;
}
for (int k = 0; k < 3; ++k) {
if (cmask[j] != k) {
printf("%c", let[k]);
}
}
printf("\n");
}
for (int j = 0; j < vec2.size(); ++j) {
long long mm = best.second;
for (int j = 0; j < vec2.size(); ++j) {
cmask[j] = mm % 3;
mm /= 3;
}
for (int k = 0; k < 3; ++k) {
if (cmask[j] != k) {
printf("%c", let[k]);
}
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, mod = 1e9 + 9, pw = 31;
const double eps = 1e-11;
map<pair<int, int>, int> m;
pair<int, int> ans = make_pair(-INF, -INF), check;
int n, d[30][5];
vector<int> res;
void out() {
for (auto i : res) {
if (i == 1) cout << "MW";
if (i == 2) cout << "LW";
if (i == 3) cout << "LM";
cout << "\n";
}
}
void rec1(int n, int v = 0, int a = 0, int b = 0, int c = 0) {
if (v == n) {
if (!m.count(make_pair(a - b, b - c)) || m[make_pair(a - b, b - c)] < c) {
m[make_pair(a - b, b - c)] = c;
}
return;
}
rec1(n, v + 1, a, b + d[v + 1][2], c + d[v + 1][3]);
rec1(n, v + 1, a + d[v + 1][1], b, c + d[v + 1][3]);
rec1(n, v + 1, a + d[v + 1][1], b + d[v + 1][2], c);
}
void rec2(int n, int v = 0, int a = 0, int b = 0, int c = 0) {
if (v == n) {
if (m.count(make_pair(b - a, c - b)) &&
m[make_pair(b - a, c - b)] + c > ans.first + ans.second) {
check = make_pair(b - a, c - b);
ans = make_pair(m[check], c);
}
return;
}
rec2(n, v + 1, a, b + d[v + 1][2], c + d[v + 1][3]);
rec2(n, v + 1, a + d[v + 1][1], b, c + d[v + 1][3]);
rec2(n, v + 1, a + d[v + 1][1], b + d[v + 1][2], c);
}
bool ok = 0;
void find1(int n, int v = 0, int a = 0, int b = 0, int c = 0) {
if (ok) return;
if (v == n) {
if (make_pair(a - b, b - c) == check && c == ans.first) {
out();
ok = 1;
}
return;
}
res.push_back(1);
find1(n, v + 1, a, b + d[v + 1][2], c + d[v + 1][3]);
res.pop_back();
res.push_back(2);
find1(n, v + 1, a + d[v + 1][1], b, c + d[v + 1][3]);
res.pop_back();
res.push_back(3);
find1(n, v + 1, a + d[v + 1][1], b + d[v + 1][2], c);
res.pop_back();
}
void find2(int n, int v = 0, int a = 0, int b = 0, int c = 0) {
if (v == n) {
if (make_pair(b - a, c - b) == check && c == ans.second) {
out();
exit(0);
}
return;
}
res.push_back(1);
find2(n, v + 1, a, b + d[v + 1][2], c + d[v + 1][3]);
res.pop_back();
res.push_back(2);
find2(n, v + 1, a + d[v + 1][1], b, c + d[v + 1][3]);
res.pop_back();
res.push_back(3);
find2(n, v + 1, a + d[v + 1][1], b + d[v + 1][2], c);
res.pop_back();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 3; j++) cin >> d[i][j];
}
rec1(n / 2);
rec2(n, n / 2);
if (ans == make_pair(-INF, -INF)) {
cout << "Impossible";
return 0;
}
find1(n / 2);
res.resize(0);
find2(n, n / 2);
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 <>
template <typename T1, typename T2>
struct hash<pair<T1, T2> > {
inline size_t operator()(const pair<T1, T2>& p) const {
return hash<T1>()(p.first) ^ hash<T2>()(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 first[25], second[25], z[25];
map<pair<int, int>, pair<int, int> > MAP;
string r[3] = {"LM", "LW", "MW"};
int n, lim, cc;
int u = 0, v = 0, c = 0, maxi = -25 * 1e7 - 10;
vector<string> ret, out;
void make(int ind, int t, int go) {
if (ind == lim && !go) {
if (!MAP.count(make_pair(v - u, c - u)))
MAP[make_pair(v - u, c - u)] = make_pair(u, t);
if (MAP[make_pair(v - u, c - u)].first < u)
MAP[make_pair(v - u, c - u)] = make_pair(u, t);
return;
}
if (ind == lim && go) {
if (MAP.count(make_pair(u - v, u - c))) {
int t = MAP[make_pair(u - v, u - c)].second, i,
tr = MAP[make_pair(u - v, u - c)].first;
if (u + tr > maxi) {
vector<string> temp;
maxi = u + tr;
for (i = 0; i < cc; ++i) {
temp.push_back(r[t % 3]);
t /= 3;
}
reverse(temp.begin(), temp.end());
out.clear();
for (i = 0; i < ret.size(); ++i) out.push_back(ret[i]);
for (i = 0; i < temp.size(); ++i) out.push_back(temp[i]);
}
}
return;
}
int i;
for (i = 0; i < 3; ++i) {
u += first[ind], v += second[ind], c += z[ind];
if (i == 0) c -= z[ind];
if (i == 1) v -= second[ind];
if (i == 2) u -= first[ind];
if (go) ret.push_back(r[i]);
make(ind + 1, t * 3 + i, go);
u -= first[ind], v -= second[ind], c -= z[ind];
if (i == 0)
c += z[ind];
else if (i == 1)
v += second[ind];
else
u += first[ind];
if (go) ret.pop_back();
}
}
int main() {
int i, j;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> first[i] >> second[i] >> z[i];
}
int s = n - (n / 2);
lim = n;
make(s, 0, 0);
cc = n - s;
ret.clear();
lim = s;
s = 0;
make(s, 0, 1);
if (out.size() > 0)
for (i = 0; i < out.size(); ++i) cout << out[i] << endl;
else
cout << "Impossible\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e9 + 100;
const long long inf_ll = 2e18;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 2e5 + 100;
const int LOG = 25;
const int mod = 998244353;
const int MX = 1e6 + 100;
const long long MOD = 1000000000949747713ll;
int a[MAXN], b[MAXN], c[MAXN];
vector<tuple<int, int, int, int> > get_all(int l, int r) {
int n = r - l + 1;
int max_mask = 1;
for (int i = 1; i <= n; ++i) {
max_mask = max_mask * 3;
}
vector<tuple<int, int, int, int> > res;
for (int mask = 0; mask < max_mask; ++mask) {
int x = mask;
int A = 0, B = 0, C = 0;
for (int i = r; i >= l; --i) {
int id = x % 3;
x = x / 3;
if (id == 0) {
A += a[i];
B += b[i];
} else if (id == 1) {
A += a[i];
C += c[i];
} else {
B += b[i];
C += c[i];
}
}
if (debug)
cout << "mask " << mask << " " << A << " " << B << " " << C << endl;
res.emplace_back(mask, A, B, C);
}
return res;
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
if (debug) cout << "get " << a[i] << " " << b[i] << " " << c[i] << endl;
}
string temp[3];
temp[0] = "LM";
temp[1] = "LW";
temp[2] = "MW";
if (n == 1) {
if (!a[1] && !b[1]) {
cout << temp[0];
return;
}
if (!a[1] && !c[1]) {
cout << temp[1];
return;
}
if (!b[1] && !c[1]) {
cout << temp[2];
return;
}
cout << "Impossible";
return;
}
int mid = n / 2;
auto res1 = get_all(1, mid);
auto res2 = get_all(mid + 1, n);
map<pair<int, int>, pair<int, int> > mp;
for (auto &x : res2) {
int mask, a, b, c;
tie(mask, a, b, c) = x;
if (mp.count({b - a, c - a})) {
mp[{b - a, c - a}] = max(mp[{b - a, c - a}], {a, mask});
} else {
mp[{b - a, c - a}] = {a, mask};
}
}
int ans = -inf_int;
int mask1 = -1;
int mask2;
for (auto &x : res1) {
int mask, a, b, c;
tie(mask, a, b, c) = x;
if (mp.count({a - b, a - c})) {
auto cur = mp[{a - b, a - c}];
if (cur.first + a > ans) {
ans = cur.first + a;
mask1 = mask;
mask2 = cur.second;
}
}
}
if (ans == -inf_int) {
cout << "Impossible";
return;
}
vector<string> res;
for (int i = n; i >= mid + 1; --i) {
res.push_back(temp[mask2 % 3]);
mask2 = mask2 / 3;
}
for (int i = mid; i >= 1; --i) {
res.push_back(temp[mask1 % 3]);
mask1 = mask1 / 3;
}
reverse(res.begin(), res.end());
for (auto x : res) {
cout << x << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
int t = 1;
while (t--) solve();
if (debug)
cerr << endl << "time : " << (1.0 * clock() / CLOCKS_PER_SEC) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int L[26], M[26], W[26];
vector<pair<pair<int, int>, pair<int, int> > > firstPart, secondPart;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> L[i] >> M[i] >> W[i];
}
if (N == 1) {
if (L[1] == 0 && M[1] == 0) {
cout << "LM" << endl;
} else if (L[1] == 0 && W[1] == 0) {
cout << "LW" << endl;
} else if (M[1] == 0 && W[1] == 0) {
cout << "MW" << endl;
} else {
cout << "Impossible" << endl;
}
return 0;
}
int half = N / 2;
int sz = half;
int pow3 = 1;
for (int i = 1; i <= sz; i++) {
pow3 *= 3;
}
for (int i = 0; i < pow3; i++) {
int aux = i;
int l1 = 0;
int m1 = 0;
int w1 = 0;
for (int j = 1; j <= sz; j++) {
if (aux % 3 == 0) {
l1 += L[j];
m1 += M[j];
} else if (aux % 3 == 1) {
l1 += L[j];
w1 += W[j];
} else {
m1 += M[j];
w1 += W[j];
}
aux /= 3;
}
firstPart.push_back(
make_pair(make_pair(l1 - m1, w1 - m1), make_pair(l1, i)));
}
sz = N - half;
pow3 = 1;
for (int i = 1; i <= sz; i++) {
pow3 *= 3;
}
for (int i = 0; i < pow3; i++) {
int aux = i;
int l1 = 0;
int m1 = 0;
int w1 = 0;
for (int j = half + 1; j <= N; j++) {
if (aux % 3 == 0) {
l1 += L[j];
m1 += M[j];
} else if (aux % 3 == 1) {
l1 += L[j];
w1 += W[j];
} else {
m1 += M[j];
w1 += W[j];
}
aux /= 3;
}
secondPart.push_back(
make_pair(make_pair(m1 - l1, m1 - w1), make_pair(l1, i)));
}
sort(secondPart.begin(), secondPart.end());
int maxSum = -1000000000;
int f1 = -1;
int f2 = -1;
for (int i = 0; i < firstPart.size(); i++) {
int x = firstPart[i].first.first;
int y = firstPart[i].first.second;
int ls = 0, ld = secondPart.size() - 1;
int curr = -1;
while (ls <= ld) {
int mid = (ls + ld) / 2;
if (secondPart[mid].first.first == x &&
secondPart[mid].first.second == y) {
curr = mid;
ls = mid + 1;
} else if (secondPart[mid].first.first < x) {
ls = mid + 1;
} else if (secondPart[mid].first.first > x) {
ld = mid - 1;
} else {
if (secondPart[mid].first.second < y) {
ls = mid + 1;
} else {
ld = mid - 1;
}
}
}
if (curr > -1 &&
firstPart[i].second.first + secondPart[curr].second.first > maxSum) {
maxSum = firstPart[i].second.first + secondPart[curr].second.first;
f1 = firstPart[i].second.second;
f2 = secondPart[curr].second.second;
}
}
if (f1 == -1 || f2 == -1) {
cout << "Impossible" << endl;
return 0;
}
sz = half;
int aux = f1;
for (int j = 1; j <= sz; j++) {
if (aux % 3 == 0) {
cout << "LM" << endl;
} else if (aux % 3 == 1) {
cout << "LW" << endl;
} else {
cout << "MW" << endl;
}
aux /= 3;
}
aux = f2;
for (int j = half + 1; j <= N; j++) {
if (aux % 3 == 0) {
cout << "LM" << endl;
} else if (aux % 3 == 1) {
cout << "LW" << endl;
} else {
cout << "MW" << endl;
}
aux /= 3;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[30][4], f[100], naive[5];
int now[30], cnt, l, maxans, sol[30];
bool flag = false;
struct pp {
int x, y;
bool operator<(const pp another) const {
if (x ^ another.x) return x < another.x;
return y < another.y;
}
} tmp, haha, __;
map<pp, int> s;
struct rec {
int x[4];
} p[2000009];
void dfs(int cur) {
if (cur >= l + 1) {
cnt++;
naive[1] = 0, naive[2] = 0, naive[3] = 0;
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= 3; j++) {
if (now[i] != j) p[cnt].x[j] += a[i][j];
}
}
tmp.x = -(p[cnt].x[2] - p[cnt].x[1]);
tmp.y = -(p[cnt].x[3] - p[cnt].x[2]);
s[tmp] = max(s[tmp] - 0x3f3f3f3f, p[cnt].x[1]) + 0x3f3f3f3f;
return;
}
now[cur] = 1;
dfs(cur + 1);
now[cur] = 2;
dfs(cur + 1);
now[cur] = 3;
dfs(cur + 1);
}
void dfs2(int cur) {
if (cur >= l + 1) {
cnt++;
naive[1] = 0, naive[2] = 0, naive[3] = 0;
for (int i = 1; i <= l; i++) {
sol[i] = now[i];
for (int j = 1; j <= 3; j++) {
if (now[i] != j) naive[j] += a[i][j];
}
}
haha.x = -(naive[2] - naive[1]);
haha.y = -(naive[3] - naive[2]);
if (haha.x == tmp.x && haha.y == tmp.y &&
naive[1] + 0x3f3f3f3f == s[haha]) {
for (int i = 1; i <= n; i++) {
if (sol[i] == 1)
printf("MW\n");
else if (sol[i] == 2)
printf("LW\n");
else
printf("LM\n");
}
exit(0);
}
return;
}
now[cur] = 1;
dfs2(cur + 1);
now[cur] = 2;
dfs2(cur + 1);
now[cur] = 3;
dfs2(cur + 1);
}
void dfs3(int cur) {
if (cur >= n + 1) {
cnt++;
naive[1] = 0, naive[2] = 0, naive[3] = 0;
for (int i = l + 1; i <= n; i++) {
for (int j = 1; j <= 3; j++) {
if (now[i] != j) naive[j] += a[i][j];
}
}
__.x = naive[2] - naive[1];
__.y = naive[3] - naive[2];
if (s[__] != 0) {
if (naive[1] + s[__] - 0x3f3f3f3f > maxans) {
tmp.x = __.x;
tmp.y = __.y;
maxans = naive[1] + s[__] - 0x3f3f3f3f;
for (int i = l + 1; i <= n; i++) {
sol[i] = now[i];
}
}
}
return;
}
now[cur] = 1;
dfs3(cur + 1);
if (flag) return;
now[cur] = 2;
dfs3(cur + 1);
if (flag) return;
now[cur] = 3;
dfs3(cur + 1);
if (flag) return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 3; j++) {
scanf("%d", &a[i][j]);
}
}
maxans = -0x3f3f3f3f;
l = n / 2;
dfs(1);
dfs3(l + 1);
if (maxans == -0x3f3f3f3f) {
printf("Impossible\n");
return 0;
}
dfs2(1);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<vector<int> > a(N, vector<int>(3));
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
if (N == 1) {
if (a[0][0] == 0 && 0 == a[0][1]) {
cout << "LM" << endl;
} else if (a[0][1] == 0 && 0 == a[0][2]) {
cout << "MW" << endl;
} else if (a[0][0] == 0 && 0 == a[0][2]) {
cout << "LW" << endl;
} else {
cout << "Impossible" << endl;
}
return 0;
}
int k1 = N / 2;
int k2 = N - k1;
map<pair<int, int>, pair<int, int> > dp;
for (int p = 0; p < pow(3, k1); p++) {
int t = p;
vector<int> curr(3, 0);
for (int i = 0; i < k1; i++) {
int index = t % 3;
for (int j = 0; j < 3; j++) {
if (index == j) {
continue;
}
curr[j] += a[i][j];
}
t /= 3;
}
auto key = make_pair(curr[0] - curr[1], curr[1] - curr[2]);
if (dp.find(key) == dp.end() || dp[key].first < curr[0]) {
dp[key] = make_pair(curr[0], p);
}
}
set<pair<int, pair<int, int> > > ans;
for (int p = 0; p < pow(3, k2); p++) {
int t = p;
vector<int> curr(3, 0);
for (int i = k1; i < k1 + k2; i++) {
int index = t % 3;
for (int j = 0; j < 3; j++) {
if (index == j) {
continue;
}
curr[j] += a[i][j];
}
t /= 3;
}
auto key = make_pair(curr[1] - curr[0], curr[2] - curr[1]);
if (dp.find(key) != dp.end()) {
ans.insert(
make_pair(dp[key].first + curr[0], make_pair(dp[key].second, p)));
}
}
if (ans.empty()) {
cout << "Impossible" << endl;
} else {
auto au = *ans.rbegin();
int p1 = au.second.first;
int p2 = au.second.second;
for (int i = 0; i < k1; i++) {
if (p1 % 3 == 0) {
cout << "MW" << endl;
} else if (p1 % 3 == 1) {
cout << "LW" << endl;
} else {
cout << "LM" << endl;
}
p1 /= 3;
}
for (int i = 0; i < k2; i++) {
if (p2 % 3 == 0) {
cout << "MW" << endl;
} else if (p2 % 3 == 1) {
cout << "LW" << endl;
} else {
cout << "LM" << endl;
}
p2 /= 3;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
pair<int, pair<int, int>> t[30];
map<pair<int, int>, pair<int, string>> M;
int best;
string beststr;
int s[3], mx, mn;
void process(int cur, int end, int ind, string str);
void go(pair<int, pair<int, int>> p, int cur, const int &end, const int &ind,
string str);
void process(int cur, int end, int ind, string str) {
mx = max(s[0], max(s[1], s[2]));
mn = min(s[0], min(s[1], s[2]));
if (cur == end) {
if (!ind) {
pair<int, int> pom = make_pair(s[1] - s[0], s[2] - s[1]);
if (M.find(pom) == M.end() || M[pom].first < mx + mn)
M[pom] = make_pair(mn, str);
} else {
pair<int, int> pom = make_pair(s[0] - s[1], s[1] - s[2]);
pair<int, string> found;
if (M.find(pom) != M.end()) {
found = M.find(pom)->second;
if (found.first + mx > best) {
best = found.first + mx;
beststr = found.second + str;
}
}
}
} else
go(make_pair(s[0], make_pair(s[1], s[2])), cur + 1, end, ind, str);
}
void go(pair<int, pair<int, int>> p, int cur, const int &end, const int &ind,
string str) {
if (cur > end) return;
s[0] = p.first + t[cur].first;
s[1] = p.second.first + t[cur].second.first;
s[2] = p.second.second;
process(cur, end, ind, str + '0');
s[0] = p.first + t[cur].first;
s[1] = p.second.first;
s[2] = p.second.second + t[cur].second.second;
process(cur, end, ind, str + '1');
s[0] = p.first;
s[1] = p.second.first + t[cur].second.first;
s[2] = p.second.second + t[cur].second.second;
process(cur, end, ind, str + '2');
}
int main() {
best = -1e9;
int n;
scanf("%d", &n);
for (int i = 0; i < (n); ++i)
scanf("%d%d%d", &t[i].first, &t[i].second.first, &t[i].second.second);
if (n == 1) {
if (t[0].first == t[0].second.first)
printf("LM\n");
else if (t[0].first == t[0].second.second)
printf("LW\n");
else if (t[0].second.first == t[0].second.second)
printf("MW\n");
else
printf("Impossible\n");
return 0;
}
go(make_pair(0, make_pair(0, 0)), 0, n / 2 - 1, 0, "");
go(make_pair(0, make_pair(0, 0)), n / 2, n - 1, 1, "");
if (best == -1e9)
printf("Impossible\n");
else {
for (int i = 0; i < (n); ++i)
if (beststr[i] == '0')
printf("LM\n");
else if (beststr[i] == '1')
printf("LW\n");
else
printf("MW\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const int NMax = 30;
const int MOD = 666013;
const int X = 7;
const int Y = 13;
int N;
struct str {
int x, y, z;
int dif1, dif2;
char *heroes;
str() {
x = y = z = dif1 = dif2 = 0;
heroes = NULL;
}
str(const int &x, const int &y, const int &z, const int &dif1,
const int &dif2) {
this->x = x;
this->y = y;
this->z = z;
this->dif1 = dif1;
this->dif2 = dif2;
heroes = NULL;
}
};
vector<str> H[MOD];
int a[NMax][4];
int st[NMax];
const char *ansnames = "aLMW";
bool existaSol = false;
int ans[4];
char ansHeroes[200];
int GetHash(int x, int y) { return abs(1LL * x * X + 1LL * y * Y) % MOD; }
void Insert(int dif1, int dif2, int x, int y, int z, char *nowheroes) {
int cod = GetHash(dif1, dif2);
for (vector<str>::iterator it = H[cod].begin(); it != H[cod].end(); ++it) {
if (it->dif1 == dif1 && it->dif2 == dif2) {
if (x > it->x) {
it->x = x;
it->y = y;
it->z = z;
delete it->heroes;
int lg = strlen(nowheroes + 1);
it->heroes = new char[lg + 3];
strcpy(it->heroes + 1, nowheroes + 1);
}
return;
}
}
str aux(x, y, z, dif1, dif2);
int lg = strlen(nowheroes + 1);
aux.heroes = new char[lg + 3];
strcpy(aux.heroes + 1, nowheroes + 1);
H[cod].push_back(aux);
}
void back(const int &k, const int &N, const int &offset) {
if (k == N + 1) {
char nowheroes[200];
int index = 0;
int v[4];
v[0] = v[1] = v[2] = v[3] = 0;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= 3; ++j) {
if (j == st[i]) {
continue;
} else {
nowheroes[++index] = ansnames[j];
v[j] += a[i][j];
}
}
nowheroes[++index] = '\n';
}
nowheroes[index + 1] = 0;
int dif1 = v[2] - v[1];
int dif2 = v[3] - v[1];
Insert(dif1, dif2, v[1], v[2], v[3], nowheroes);
return;
}
for (int i = 1; i <= 3; ++i) {
st[k] = i;
back(k + 1, N, offset);
}
}
void Search(int dif1, int dif2, int x, int y, int z, char *nowheroes) {
int cod = GetHash(dif1, dif2);
for (vector<str>::iterator it = H[cod].begin(); it != H[cod].end(); ++it) {
if (it->dif1 == dif1 && it->dif2 == dif2) {
existaSol = true;
if (it->x + x > ans[1]) {
ans[1] = it->x + x;
ans[2] = it->y + y;
ans[3] = it->z + z;
strcpy(ansHeroes + 1, it->heroes + 1);
strcat(ansHeroes + 1, nowheroes + 1);
}
return;
}
}
}
void back2(const int &k, const int &N, const int &offset) {
if (k == N + 1) {
char nowheroes[200];
int index = 0;
int v[4];
v[0] = v[1] = v[2] = v[3] = 0;
for (int i = 1 + offset; i <= N + offset; ++i) {
for (int j = 1; j <= 3; ++j) {
if (j == st[i - offset]) {
continue;
} else {
nowheroes[++index] = ansnames[j];
v[j] += a[i][j];
}
}
nowheroes[++index] = '\n';
}
nowheroes[index + 1] = 0;
int dif1 = v[2] - v[1];
int dif2 = v[3] - v[1];
dif1 = -dif1;
dif2 = -dif2;
Search(dif1, dif2, v[1], v[2], v[3], nowheroes);
return;
}
for (int i = 1; i <= 3; ++i) {
st[k] = i;
back2(k + 1, N, offset);
}
}
int main() {
ans[0] = ans[1] = ans[2] = ans[3] = -INF;
cin >> N;
for (int i = 1; i <= N; ++i) {
cin >> a[i][1] >> a[i][2] >> a[i][3];
}
if (N == 1) {
int nrz = 0;
for (int i = 1; i <= 3; ++i)
if (a[1][i] == 0) {
++nrz;
}
if (nrz >= 2) {
int index = 0;
nrz = 0;
for (int i = 1; i <= 3; ++i) {
if (a[1][i] == 0) {
++nrz;
if (nrz <= 2) {
ansHeroes[++index] = ansnames[i];
}
}
}
ansHeroes[++index] = '\n';
cout << ansHeroes + 1;
} else
cout << "Impossible\n";
return 0;
}
back(1, N / 2, 0);
back2(1, N - (N / 2), N / 2);
if (existaSol) {
cout << (ansHeroes + 1);
} else {
cout << "Impossible\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, mid;
int a[30], b[30], c[30];
map<pair<int, long long>, pair<int, long long> > h;
pair<int, long long> ans;
void dfs1(int step, long long sta, int A, int B, int C) {
if (step == mid + 1) {
pair<int, long long> tmp;
tmp = h[pair<int, long long>(A - B, B - C)];
if (tmp.second == 0)
h[pair<int, long long>(A - B, B - C)] = {A, sta};
else
h[pair<int, long long>(A - B, B - C)] =
max(tmp, pair<int, long long>(A, sta));
return;
}
dfs1(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs1(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs1(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
void dfs2(int step, long long sta, int A, int B, int C) {
if (step == n + 1) {
pair<int, long long> tmp = h[pair<int, long long>(B - A, C - B)];
if (tmp.second == 0) return;
ans = max(ans, pair<int, long long>(A + tmp.first,
tmp.second << (n - mid << 1) | sta));
return;
}
dfs2(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs2(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs2(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
int main() {
ans.first = -INF;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
mid = (n + 1) / 2;
dfs1(1, 0, 0, 0, 0);
dfs2(mid + 1, 0, 0, 0, 0);
if (ans.first == -INF) return puts("Impossible");
vector<int> res;
for (int i = 1; i <= n; i++) {
res.push_back(ans.second & 3);
ans.second >>= 2;
}
for (int i = res.size() - 1; i >= 0; i--) {
if (res[i] == 3)
puts("LM");
else if (res[i] == 2)
puts("LW");
else
puts("MW");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mid, n;
int a[30], b[30], c[30];
map<pair<int, int>, pair<int, long long> > H;
pair<int, long long> ans;
void dfs1(int step, long long sta, int A, int B, int C) {
if (step == mid + 1) {
pair<int, long long> temp;
temp = H[pair<int, int>(A - B, B - C)];
if (temp.second == 0)
H[pair<int, int>(A - B, B - C)] = pair<int, long long>(A, sta);
else
H[pair<int, int>(A - B, B - C)] = max(temp, pair<int, long long>(A, sta));
return;
}
dfs1(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs1(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs1(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
void dfs2(int step, long long sta, int A, int B, int C) {
if (step == n + 1) {
pair<int, long long> temp = H[pair<int, int>(B - A, C - B)];
if (temp.second == 0) return;
ans = max(ans, pair<int, long long>(A + temp.first,
temp.second << (n - mid << 1) | sta));
return;
}
dfs2(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs2(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs2(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
int main() {
ans.first = -99999999;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
mid = (n + 1) / 2;
dfs1(1, 0, 0, 0, 0);
dfs2(mid + 1, 0, 0, 0, 0);
if (ans.first == -99999999) return puts("Impossible");
vector<int> Ans;
for (int i = 1; i <= n; i++) {
Ans.push_back(ans.second & 3);
ans.second >>= 2;
}
for (int i = Ans.size() - 1; i >= 0; i--) {
if (Ans[i] == 3)
cout << "LM" << endl;
else if (Ans[i] == 2)
cout << "LW" << endl;
else
cout << "MW" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 26;
const long long MAX = 5 * 1e6;
const long long INF = 1e15;
long long l[N], m[N], w[N], n, nc, sz, szc;
long long a[MAX][3], b[MAX][3];
long long loc1 = -1, loc2;
map<pair<long long, long long>, long long> ma;
void solve() {
for (int i = 0; i < n; i++) cin >> l[i] >> m[i] >> w[i];
memset(a, 0, sizeof(a));
sz = 1;
for (int i = 0; i < n; i++) {
long long p = 0, q = sz, r = 2 * sz, s = 3 * sz;
for (int j = q; j < s; j++)
for (int k = 0; k < 3; k++) a[j][k] = a[j - sz][k];
for (int j = p; j < q; j++) a[j][0] += l[i], a[j][1] += m[i];
for (int j = q; j < r; j++) a[j][2] += w[i], a[j][1] += m[i];
for (int j = r; j < s; j++) a[j][0] += l[i], a[j][2] += w[i];
sz = sz * 3;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
long long nf = n / 2, ns = n - n / 2;
nc = n - n / 2;
n = n / 2;
solve();
for (int i = 0; i < sz; i++) {
if (ma.find(make_pair(a[i][0] - a[i][1], a[i][0] - a[i][2])) != ma.end()) {
ma[make_pair(a[i][0] - a[i][1], a[i][0] - a[i][2])] =
max(a[i][0], ma[make_pair(a[i][0] - a[i][1], a[i][0] - a[i][2])]);
} else
ma[make_pair(a[i][0] - a[i][1], a[i][0] - a[i][2])] = a[i][0];
}
n = nc;
long long szi = sz;
memcpy(b, a, sizeof(a));
solve();
long long ans = INF;
ans *= -1;
long long ac[2][3];
for (int i = 0; i < sz; i++) {
long long p = a[i][0], q = a[i][1], r = a[i][2];
q = p - q;
q *= -1;
r = p - r;
r *= -1;
if (ma.find(make_pair(q, r)) != ma.end()) {
if (p + ma[make_pair(q, r)] > ans) {
ans = p + ma[make_pair(q, r)];
ac[0][0] = ma[make_pair(q, r)];
ac[0][1] = q;
ac[0][2] = r;
ac[1][0] = p;
ac[1][1] = -1 * q;
ac[1][2] = -1 * r;
loc2 = i;
}
}
}
for (int i = 1; i < 3; i++) {
ac[0][i] = ac[0][0] - ac[0][i];
ac[1][i] = ac[1][0] - ac[1][i];
}
for (int i = 0; i < szi; i++) {
long long flag = 1;
for (int j = 0; j < 3; j++)
if (b[i][j] != ac[0][j]) flag = 0;
if (flag) {
loc1 = i;
break;
}
}
long long l1, l2;
l1 = loc1, l2 = loc2;
vector<long long> v;
while (nf--) {
v.push_back(loc1 % 3);
loc1 /= 3;
}
while (ns--) {
v.push_back(loc2 % 3);
loc2 /= 3;
}
if (ans == -1 * INF)
cout << "Impossible";
else {
for (long long i : v) {
if (i == 0) cout << "LM";
if (i == 1) cout << "MW";
if (i == 2) cout << "LW";
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
string str;
long long s[32][4];
map<pair<long long, long long>, long long> valueL;
map<pair<long long, long long>, string> strL;
long long bestSum = -0x3F3F3F3F3F3F3F3FLL;
string ans;
void gen(int i, int n, int opType) {
if (i == n) {
if (opType == 0) {
pair<long long, long long> key = make_pair(v[1] - v[0], v[2] - v[0]);
long long val = v[0] + v[1] + v[2];
if (valueL.count(key) && valueL[key] >= val) {
return;
}
valueL[key] = val;
strL[key] = str;
return;
} else {
pair<long long, long long> key = make_pair(v[0] - v[1], v[0] - v[2]);
long long val = v[0] + v[1] + v[2];
if (!valueL.count(key)) return;
long long currSum = valueL[key] + val;
if (currSum > bestSum) {
bestSum = currSum;
ans = strL[key] + str;
}
return;
}
return;
}
v[0] += s[i][0];
v[1] += s[i][1];
v[2] += s[i][2];
for (int k = 0; k < 3; ++k) {
v[k] -= s[i][k];
if (k == 0)
str += "MW\n";
else if (k == 1)
str += "LW\n";
else if (k == 2)
str += "LM\n";
gen(i + 1, n, opType);
v[k] += s[i][k];
str.pop_back();
str.pop_back();
str.pop_back();
}
v[0] -= s[i][0];
v[1] -= s[i][1];
v[2] -= s[i][2];
return;
}
int main() {
int n;
cin >> n;
int nl = n / 2;
int nr = n - nl;
for (int i = 0; i < n; ++i) {
scanf("%lld %lld %lld", &s[i][0], &s[i][1], &s[i][2]);
}
v = vector<long long>(3, 0LL);
gen(0, nl, 0);
gen(nl, n, 1);
if (ans.size() == 0) ans = "Impossible\n";
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
if (!false) ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
long long ls = 0, ms = 0, ws = 0;
vector<tuple<long long, long long, long long>> v(n);
for (auto& [l, m, w] : v) {
cin >> l >> m >> w;
ls += l;
ms += m;
ws += w;
}
vector<long long> p3(n + 1);
long long p = 1;
for (int i = 0; i <= n; i++) p3[i] = p, p *= 3;
pair<long long, long long> ans(-LINF, 0);
int lsz = (n + 1) / 2, rsz = n - lsz;
map<pair<long long, long long>, pair<long long, long long>> mp;
if (rsz == 0)
mp[{0, 0}] = {0, 0};
else {
tuple<long long, long long, long long> tsum(0, 0, 0);
long long sum = 0;
for (int i = lsz; i < n; i++) {
auto [l, m, w] = v[i];
auto& [tl, tm, tw] = tsum;
tl += l, tm += m, tw += w;
sum += l + m + w;
}
for (long long mask = 0; mask < p3[rsz]; mask++) {
tuple<long long, long long, long long> tcur = tsum;
long long sumcur = sum, maskcur = mask;
auto& [tcl, tcm, tcw] = tcur;
for (int i = 0; i < rsz; i++) {
auto [l, m, w] = v[i + lsz];
if (maskcur % 3 == 0) {
tcl -= l;
sumcur -= l;
}
if (maskcur % 3 == 1) {
tcm -= m;
sumcur -= m;
}
if (maskcur % 3 == 2) {
tcw -= w;
sumcur -= w;
}
maskcur /= 3;
}
pair<long long, long long> curdif = {tcm - tcl, tcw - tcm};
if (!mp.count(curdif))
mp[curdif] = {sumcur, mask};
else
mp[curdif] = max(mp[curdif], make_pair(sumcur, mask));
}
}
tuple<long long, long long, long long> tsum(0, 0, 0);
long long sum = 0;
for (int i = 0; i < lsz; i++) {
auto [l, m, w] = v[i];
auto& [tl, tm, tw] = tsum;
tl += l, tm += m, tw += w;
sum += l + m + w;
}
for (long long mask = 0; mask < p3[lsz]; mask++) {
tuple<long long, long long, long long> tcur = tsum;
long long sumcur = sum, maskcur = mask;
auto& [tcl, tcm, tcw] = tcur;
for (int i = 0; i < lsz; i++) {
auto [l, m, w] = v[i];
if (maskcur % 3 == 0) {
tcl -= l;
sumcur -= l;
}
if (maskcur % 3 == 1) {
tcm -= m;
sumcur -= m;
}
if (maskcur % 3 == 2) {
tcw -= w;
sumcur -= w;
}
maskcur /= 3;
}
pair<long long, long long> needdif = {tcl - tcm, tcm - tcw};
if (mp.count(needdif)) {
auto [nsum, nmask] = mp[needdif];
pair<long long, long long> win(nsum + sumcur, mask + p3[lsz] * nmask);
ans = max(ans, win);
}
}
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>
using namespace std;
int n, l[30], m[30], w[30], mmax, cnt;
long long fbit3, pw[30];
struct Node {
int diffx, diffy, sum;
long long bit3;
Node(int diffx = 0, int diffy = 0, int sum = 0, long long bit3 = 0)
: diffx(diffx), diffy(diffy), sum(sum), bit3(bit3) {}
bool operator<(const Node& A) const {
if (diffx == A.diffx) {
if (diffy == A.diffy) return sum > A.sum;
return diffy < A.diffy;
}
return diffx < A.diffx;
}
} p[int(6e5 + 5)];
void findHalf(int st, int x, int y, int z, long long bit3) {
if (st == n / 2) {
p[cnt++] = Node(x - y, x - z, x + y + z, bit3);
return;
}
findHalf(st + 1, x + l[st], y + m[st], z, bit3);
findHalf(st + 1, x, y + m[st], z + w[st], bit3 + pw[st]);
findHalf(st + 1, x + l[st], y, z + w[st], bit3 + 2 * pw[st]);
}
void findHalfRemain(int st, int x, int y, int z, long long bit3) {
if (st == n) {
int pos = lower_bound(p, p + cnt, Node(y - x, z - x, INT_MAX, bit3)) - p;
if (pos < cnt) {
if (p[pos].diffx == y - x && p[pos].diffy == z - x) {
if (mmax < p[pos].sum + x + y + z) {
mmax = max(mmax, p[pos].sum + x + y + z);
fbit3 = bit3 + p[pos].bit3;
}
}
}
return;
}
findHalfRemain(st + 1, x + l[st], y + m[st], z, bit3);
findHalfRemain(st + 1, x, y + m[st], z + w[st], bit3 + pw[st]);
findHalfRemain(st + 1, x + l[st], y, z + w[st], bit3 + 2 * pw[st]);
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
pw[0] = 1;
for (int i = 0; i < int(n); i++) {
if (i) pw[i] = pw[i - 1] * 3;
scanf("%d%d%d", &l[i], &m[i], &w[i]);
}
findHalf(0, 0, 0, 0, 0);
sort(p, p + cnt);
mmax = fbit3 = INT_MIN;
findHalfRemain(n / 2, 0, 0, 0, 0);
if (fbit3 < 0)
printf("Impossible\n");
else {
for (int i = 0; i < int(n); i++) {
int tmp = fbit3 % 3;
if (!tmp)
printf("LM\n");
else if (tmp == 1)
printf("MW\n");
else
printf("LW\n");
fbit3 /= 3;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const long long L = 1e9;
map<long long, pair<long long, long long> > mp;
int a[MAXN], b[MAXN], c[MAXN];
int n, nn;
long long ans, ans1, ans2;
void dfs1(int cur, long long t, long long x, long long y, long long z) {
if (cur == nn + 1) {
long long tmp = (y - x) * L + (z - y);
if (mp.count(tmp))
mp[tmp] = max(make_pair(x, t), mp[tmp]);
else
mp[tmp] = make_pair(x, t);
return;
}
dfs1(cur + 1, t * 3 + 0, x + a[cur], y + b[cur], z);
dfs1(cur + 1, t * 3 + 1, x + a[cur], y, z + c[cur]);
dfs1(cur + 1, t * 3 + 2, x, y + b[cur], z + c[cur]);
}
void dfs2(int cur, long long t, long long x, long long y, long long z) {
if (cur == n + 1) {
long long tmp = (x - y) * L + (y - z);
if (mp.count(tmp)) {
pair<long long, long long> A = mp[tmp];
if (A.first + x > ans) {
ans = A.first + x;
ans1 = A.second;
ans2 = t;
}
}
return;
}
dfs2(cur + 1, t * 3 + 0, x + a[cur], y + b[cur], z);
dfs2(cur + 1, t * 3 + 1, x + a[cur], y, z + c[cur]);
dfs2(cur + 1, t * 3 + 2, x, y + b[cur], z + c[cur]);
}
void print(long long x, int n) {
if (n > 1) print(x / 3, n - 1);
long long tmp = x % 3;
if (tmp == 0) printf("LM\n");
if (tmp == 1) printf("LW\n");
if (tmp == 2) printf("MW\n");
}
void solve() {
ans = -L;
mp.clear();
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
if (n == 1) {
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;
}
nn = n / 2;
dfs1(1, 0, 0, 0, 0);
dfs2(nn + 1, 0, 0, 0, 0);
if (ans == -L) {
printf("Impossible\n");
return;
}
print(ans1, nn);
print(ans2, n - nn);
}
int main() {
while (~scanf("%d", &n)) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bitct(long long r) { return r == 0 ? 0 : (bitct(r >> 1) + (r & 1)); }
long long gcd(long long x, long long y) { return x ? gcd(y % x, x) : y; }
template <typename T>
ostream& operator<<(ostream& o, vector<T> v) {
o << "{";
int i = 0, s = v.size();
for (; i + 1 < s; i++) o << v[i] << ", ";
if (s) o << v[i];
o << "}";
return o;
}
template <typename K, typename V>
ostream& operator<<(ostream& o, unordered_map<K, V> m) {
o << "{";
for (auto i : m) o << i.first << " -> " << i.second << ", ";
o << "}";
return o;
}
template <typename K, typename V>
ostream& operator<<(ostream& o, map<K, V> m) {
o << "{";
for (auto i : m) o << i.first << " -> " << i.second << ", ";
o << "}";
return o;
}
template <typename K, typename V>
ostream& operator<<(ostream& o, set<K> m) {
o << "{";
for (auto i : m) o << i << ", ";
o << "}";
return o;
}
template <typename K, typename V>
ostream& operator<<(ostream& o, unordered_set<K> m) {
o << "{";
for (auto i : m) o << i << ", ";
o << "}";
return o;
}
long long choose(long long n, long long q) {
if (n == 0 || q == 0) return 1;
if (q == 1)
return n;
else
return (choose(n, q - 1) * (n - q + 1) / q);
}
int main() {
ios_base::sync_with_stdio(false);
long long N;
cin >> N;
vector<vector<int>> in;
for (int i = 0; i < N; i++) {
int a, b, c;
cin >> a >> b >> c;
vector<int> inv;
inv.push_back(a);
inv.push_back(b);
inv.push_back(c);
in.push_back(inv);
}
vector<tuple<int, int, int, int>> top, bottom;
if (1 == N) top.push_back(make_tuple(0, 0, 0, 0));
long long l = 1;
for (int x = N / 2; x-- > 0;) l *= 3;
for (int t = 0; t < l; t++) {
vector<int> lmw(3, 0);
long long mt = t;
for (int i = 0; i < N / 2; i++) {
if (0 == mt % 3) lmw[0] += in[i][0], lmw[1] += in[i][1];
if (1 == mt % 3) lmw[0] += in[i][0], lmw[2] += in[i][2];
if (2 == mt % 3) lmw[2] += in[i][2], lmw[1] += in[i][1];
mt /= 3;
}
top.push_back(make_tuple(lmw[0] - lmw[2], lmw[0] - lmw[1], lmw[0], t));
}
l = 1;
for (int x = (N - N / 2); x-- > 0;) l *= 3;
for (int t = 0; t < l; t++) {
vector<int> lmw(3, 0);
long long mt = t;
for (int i = N / 2; i < N; i++) {
if (0 == mt % 3) lmw[0] += in[i][0], lmw[1] += in[i][1];
if (1 == mt % 3) lmw[0] += in[i][0], lmw[2] += in[i][2];
if (2 == mt % 3) lmw[2] += in[i][2], lmw[1] += in[i][1];
mt /= 3;
}
bottom.push_back(make_tuple(lmw[0] - lmw[2], lmw[0] - lmw[1], lmw[0], t));
}
sort(bottom.begin(), bottom.end());
long long tid = 0, bid = 0, best = -1000000000;
for (int a = 0; a < top.size(); a++) {
auto ok = upper_bound(
bottom.begin(), bottom.end(),
make_tuple(-get<0>(top[a]), -get<1>(top[a]), 2000000000, 0));
if (bottom.begin() == ok) continue;
ok--;
if (get<0>(*ok) != -get<0>(top[a]) || get<1>(*ok) != -get<1>(top[a]))
continue;
long long cand = get<2>(*ok) + get<2>(top[a]);
if (cand > best) {
best = cand;
tid = get<3>(top[a]);
bid = get<3>(*ok);
}
}
if (best == -1000000000) {
cout << "Impossible" << endl;
} else {
for (int i = 0; i < N / 2; i++) {
if (0 == tid % 3) cout << "LM" << endl;
if (1 == tid % 3) cout << "LW" << endl;
if (2 == tid % 3) cout << "MW" << endl;
tid /= 3;
}
for (int i = N / 2; i < N; i++) {
if (0 == bid % 3) cout << "LM" << endl;
if (1 == bid % 3) cout << "LW" << endl;
if (2 == bid % 3) cout << "MW" << endl;
bid /= 3;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long MAX_N = 30, INF = 1e9;
long n;
long arr[MAX_N][5];
vector<pair<pair<long, long>, long> > vec1, vec2;
string ans;
map<pair<pair<long, long>, long>, string> mm1, mm2;
void build1(long mx, long cnt, long a, long b, long c, string id = "") {
if (cnt == mx) {
vec1.push_back(make_pair(make_pair(a - b, b - c), a));
mm1[make_pair(make_pair(a - b, b - c), a)] = id;
return;
}
build1(mx, cnt + 1, a + arr[cnt][0], b + arr[cnt][1], c, id + '2');
build1(mx, cnt + 1, a + arr[cnt][0], b, c + arr[cnt][2], id + '1');
build1(mx, cnt + 1, a, b + arr[cnt][1], c + arr[cnt][2], id + '0');
}
void build2(long mx, long cnt, long a, long b, long c, string id = "") {
if (cnt == mx) {
vec2.push_back(make_pair(make_pair(a - b, b - c), a));
mm2[make_pair(make_pair(a - b, b - c), a)] = id;
return;
}
build2(mx, cnt + 1, a + arr[cnt][0], b + arr[cnt][1], c, id + '2');
build2(mx, cnt + 1, a + arr[cnt][0], b, c + arr[cnt][2], id + '1');
build2(mx, cnt + 1, a, b + arr[cnt][1], c + arr[cnt][2], id + '0');
}
int32_t main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
cin >> n;
for (long i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
long tm = floor(float(n) / 2);
build1(tm, 0, 0, 0, 0);
build2(n, tm, 0, 0, 0);
sort(vec2.begin(), vec2.end());
long k, mx = -INF;
pair<pair<pair<long, long>, long>, pair<pair<long, long>, long> > pans;
for (pair<pair<long, long>, long> x : vec1) {
k = upper_bound(
vec2.begin(), vec2.end(),
make_pair(make_pair(-x.first.first, -x.first.second + 1), -INF)) -
vec2.begin();
k--;
if (k >= 0 and vec2[k].first.first == -x.first.first and
vec2[k].first.second == -x.first.second) {
if (x.second + vec2[k].second > mx) {
mx = x.second + vec2[k].second;
pans = make_pair(x, vec2[k]);
}
}
}
ans = mm1[pans.first] + mm2[pans.second];
if (mx == -INF) {
cout << "Impossible"
<< "\n";
return 0;
}
for (char c : ans) {
if (c == '0')
cout << "MW"
<< "\n";
if (c == '1')
cout << "LW"
<< "\n";
if (c == '2')
cout << "LM"
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, divi;
const int MAXN = 30;
const int INF = int(1e9);
int L[MAXN], M[MAXN], W[MAXN];
string choices[] = {"LM", "LW", "MW"};
map<pair<int, int>, int> fst;
map<pair<int, int>, int> path_fst;
void dfs(int i, int ab, int ac, int a, int path) {
if (i == divi) {
if (fst.count(pair<int, int>(ab, ac))) return;
fst[pair<int, int>(ab, ac)] = a;
path_fst[pair<int, int>(ab, ac)] = path;
return;
}
dfs(i + 1, ab + L[i] - M[i], ac + L[i], a + L[i], path * 3 + 0);
dfs(i + 1, ab + L[i], ac + L[i] - W[i], a + L[i], path * 3 + 1);
dfs(i + 1, ab - M[i], ac - W[i], a, path * 3 + 2);
}
int hi;
int fstr, sstr;
void dfs2(int i, int ab, int ac, int a, int path) {
if (i == n) {
pair<int, int> seek = {ab, ac};
if (fst.count(seek)) {
int val = a + fst[seek];
if (val > hi) {
hi = val;
fstr = path_fst[seek];
sstr = path;
}
}
return;
}
dfs2(i + 1, ab - L[i] + M[i], ac - L[i], a + L[i], path * 3 + 0);
dfs2(i + 1, ab - L[i], ac - L[i] + W[i], a + L[i], path * 3 + 1);
dfs2(i + 1, ab + M[i], ac + W[i], a, path * 3 + 2);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> L[i] >> M[i] >> W[i];
divi = (n) / 2;
dfs(0, 0, 0, 0, 0);
hi = -INF;
dfs2(divi, 0, 0, 0, 0);
if (hi == -INF)
cout << "Impossible" << endl;
else {
vector<int> ans;
for (int i = 0; i < divi; i++) {
ans.push_back(fstr % 3);
fstr /= 3;
}
for (int i = divi - 1; i >= 0; i--) cout << choices[ans[i]] << endl;
ans.clear();
for (int i = divi; i < n; i++) {
ans.push_back(sstr % 3);
sstr /= 3;
}
for (int i = (int)ans.size() - 1; i >= 0; i--)
cout << choices[ans[i]] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int l[25], m[25], w[25];
map<pair<int, int>, pair<int, long long>> met;
int parsa;
long long parmask1, parmask2;
int res[25];
void meet1(int a, int b, int c, long long mask, int ind, int raja) {
if (ind == raja) {
pair<int, int> p = make_pair(b - a, c - b);
if (!(met.count(p)) || met[p].first < a) {
met[p] = make_pair(a, mask);
}
return;
}
meet1(a + l[ind], b + m[ind], c, 3 * mask, ind + 1, raja);
meet1(a + l[ind], b, c + w[ind], 3 * mask + 1, ind + 1, raja);
meet1(a, b + m[ind], c + w[ind], 3 * mask + 2, ind + 1, raja);
}
void meet2(int a, int b, int c, long long mask, int ind) {
if (ind == n) {
pair<int, int> p = make_pair(a - b, b - c);
if (met.count(p)) {
if (met[p].first + a > parsa) {
parsa = met[p].first + a;
parmask1 = met[p].second;
parmask2 = mask;
}
}
return;
}
meet2(a + l[ind], b + m[ind], c, 3 * mask, ind + 1);
meet2(a + l[ind], b, c + w[ind], 3 * mask + 1, ind + 1);
meet2(a, b + m[ind], c + w[ind], 3 * mask + 2, ind + 1);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i] >> m[i] >> w[i];
}
int raja1 = n / 2;
meet1(0, 0, 0, 0, 0, raja1);
int raja2 = n - raja1;
parsa = -100000000;
parmask1 = -1;
meet2(0, 0, 0, 0, raja1);
if (parmask1 == -1) {
cout << "Impossible\n";
return 0;
}
for (int i = 0; i < raja2; i++) {
res[i] = parmask2 % 3;
parmask2 /= 3;
}
for (int i = raja2; i < n; i++) {
res[i] = parmask1 % 3;
parmask1 /= 3;
}
for (int i = n - 1; i >= 0; i--) {
if (res[i] == 0) cout << "LM\n";
if (res[i] == 1) cout << "LW\n";
if (res[i] == 2) cout << "MW\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int A[25][3];
using Key = pair<int, int>;
using Value = tuple<int, int, int>;
using Item = pair<Key, Value>;
Key GetKey(const Value& value) {
return make_pair(get<1>(value) - get<0>(value),
get<2>(value) - get<0>(value));
}
void Gen(int idx, int to, Value value, vector<Item>& items) {
if (idx == to) {
items.push_back(make_pair(GetKey(value), value));
return;
}
get<0>(value) += A[idx][0];
get<1>(value) += A[idx][1];
Gen(idx + 1, to, value, items);
get<0>(value) -= A[idx][0];
get<1>(value) -= A[idx][1];
get<0>(value) += A[idx][0];
get<2>(value) += A[idx][2];
Gen(idx + 1, to, value, items);
get<0>(value) -= A[idx][0];
get<2>(value) -= A[idx][2];
get<1>(value) += A[idx][1];
get<2>(value) += A[idx][2];
Gen(idx + 1, to, value, items);
get<1>(value) -= A[idx][1];
get<2>(value) -= A[idx][2];
}
bool Gen2(int idx, int to, Value value, const Value& need,
vector<const char*>& way) {
if (idx == to) {
if (value == need) {
for (const char* line : way) {
cout << line << '\n';
}
return true;
}
return false;
}
get<0>(value) += A[idx][0];
get<1>(value) += A[idx][1];
way.push_back("LM");
if (Gen2(idx + 1, to, value, need, way)) {
return true;
}
way.pop_back();
get<0>(value) -= A[idx][0];
get<1>(value) -= A[idx][1];
get<0>(value) += A[idx][0];
get<2>(value) += A[idx][2];
way.push_back("LW");
if (Gen2(idx + 1, to, value, need, way)) {
return true;
}
way.pop_back();
get<0>(value) -= A[idx][0];
get<2>(value) -= A[idx][2];
get<1>(value) += A[idx][1];
get<2>(value) += A[idx][2];
way.push_back("MW");
if (Gen2(idx + 1, to, value, need, way)) {
return true;
}
way.pop_back();
get<1>(value) -= A[idx][1];
get<2>(value) -= A[idx][2];
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> A[i][j];
}
}
vector<Item> left, right;
Gen(0, N / 2, Value(0, 0, 0), left);
Gen(N / 2, N, Value(0, 0, 0), right);
sort(left.begin(), left.end(), [](const Item& lhs, const Item& rhs) {
if (lhs.first != rhs.first) {
return lhs.first < rhs.first;
}
return get<0>(lhs.second) > get<0>(rhs.second);
});
int result = numeric_limits<int>::min();
Value bleft, bright;
for (const auto& p : right) {
Key key(-p.first.first, -p.first.second);
const Value& value = p.second;
auto cmp = [](const Item& lhs, const Item& rhs) {
return lhs.first < rhs.first;
};
auto it = lower_bound(left.begin(), left.end(), Item(key, value), cmp);
if (it != left.end() && it->first == key) {
int cand = get<0>(value) + get<0>(it->second);
if (result < cand) {
result = cand;
bleft = it->second;
bright = value;
}
}
}
if (numeric_limits<int>::min() == result) {
cout << "Impossible" << '\n';
return 0;
}
vector<const char*> way;
way.clear();
Gen2(0, N / 2, Value(0, 0, 0), bleft, way);
way.clear();
Gen2(N / 2, N, Value(0, 0, 0), bright, way);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
const int maxhfsize = 1600000;
struct Result {
int d[2];
int mask;
};
inline bool operator<(const Result& a, const Result& b) {
return a.d[0] == b.d[0] ? a.d[1] < b.d[1] : a.d[0] < b.d[0];
}
inline bool operator==(const Result& a, const Result& b) {
return a.d[0] == b.d[0] && a.d[1] == b.d[1];
}
int deltas[maxn][3];
int firstSize, secondSize;
Result firstHalf[maxhfsize], secondHalf[maxhfsize];
void makeHalf(Result* out, int& sz, int begin, int end) {
int k = end - begin;
int maxMask = 1;
for (int i = 0; i < k; ++i) maxMask *= 3;
sz = 0;
for (int mask = 0; mask < maxMask; ++mask) {
Result& here = out[sz++];
here.mask = mask;
int t = mask;
for (int i = begin; i < end; ++i) {
int bit = t % 3;
t /= 3;
if (bit != 0) {
here.d[0] -= deltas[i][0];
here.d[1] -= deltas[i][0];
}
if (bit != 1) here.d[0] += deltas[i][1];
if (bit != 2) here.d[1] += deltas[i][2];
}
}
sort(out, out + sz);
sz = unique(out, out + sz) - out;
}
int n;
int score(int begin, int end, int mask) {
int ret = 0;
for (int i = begin; i < end; ++i) {
int bit = mask % 3;
mask /= 3;
if (bit) ret += deltas[i][0];
}
return ret;
}
void out(int begin, int end, int mask) {
int sum[3] = {0, 0, 0};
for (int i = begin; i < end; ++i) {
int bit = mask % 3;
mask /= 3;
for (int j = 0; j < 3; ++j)
if (j != bit) {
sum[j] += deltas[i][j];
cout << "LMW"[j];
}
cout << '\n';
}
42;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j) cin >> deltas[i][j];
int pivot = n / 2;
makeHalf(firstHalf, firstSize, 0, pivot);
makeHalf(secondHalf, secondSize, pivot, n);
int notMuch = -100000000;
int ansF = -1, ansS = -1, ans = notMuch;
for (int i = 0; i < secondSize; ++i) {
Result a = secondHalf[i];
Result need;
need.d[0] = -a.d[0];
need.d[1] = -a.d[1];
int fst = -1;
if (pivot != 0 || need.d[0] || need.d[1]) {
auto it = lower_bound(firstHalf, firstHalf + firstSize, need);
if (it == firstHalf + firstSize || !(*it == need)) continue;
fst = it->mask;
}
int here = score(0, pivot, fst) + score(pivot, n, a.mask);
if (here > ans) {
ans = here;
ansF = fst;
ansS = a.mask;
}
}
if (ans == notMuch)
cout << "Impossible\n";
else {
out(0, pivot, ansF);
out(pivot, n, ansS);
}
42;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, pair<long long, long long> > mp;
map<pair<long long, long long>, long long> vis;
long long x[30], y[30], z[30], n, mid, ans, sum;
void dfs1(long long tp, long long a, long long b, long long c, long long len) {
long long i = tp;
if (tp == mid + 1) {
if (mp[make_pair(a, b)].first < c || vis[make_pair(a, b)] == 0)
mp[make_pair(a, b)] = make_pair(c, len), vis[make_pair(a, b)] = 1;
return;
}
dfs1(tp + 1, a + x[i] - y[i], b + y[i], c + x[i], len * 4 + 1);
dfs1(tp + 1, a + x[i], b - z[i], c + x[i], len * 4 + 2);
dfs1(tp + 1, a - y[i], b + y[i] - z[i], c, len * 4 + 3);
}
void dfs2(long long tp, long long a, long long b, long long c, long long len) {
long long i = tp;
if (tp == n + 1) {
if (mp.count(make_pair(-a, -b)))
if (mp[make_pair(-a, -b)].first + c > sum) {
sum = mp[make_pair(-a, -b)].first + c;
ans = (mp[make_pair(-a, -b)].second << (n - mid) * 2) + len;
}
return;
}
dfs2(tp + 1, a + x[i] - y[i], b + y[i], c + x[i], len * 4 + 1);
dfs2(tp + 1, a + x[i], b - z[i], c + x[i], len * 4 + 2);
dfs2(tp + 1, a - y[i], b + y[i] - z[i], c, len * 4 + 3);
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> x[i] >> y[i] >> z[i];
mid = n / 2;
dfs1(1, 0, 0, 0, 0);
sum = -1e9;
dfs2(mid + 1, 0, 0, 0, 0);
if (sum == -1e9) puts("Impossible"), exit(0);
for (long long i = 1; i <= n; i++) {
long long g = (1ll << (n - i) * 2);
if (ans / g == 1)
puts("LM");
else if (ans / g == 2)
puts("LW");
else
puts("MW");
ans %= g;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int mid, n;
int a[30], b[30], c[30];
map<pair<int, int>, pair<int, long long> > H;
pair<int, long long> ans;
void dfs1(int step, long long sta, int A, int B, int C) {
if (step == mid + 1) {
pair<int, long long> temp;
temp = H[pair<int, int>(A - B, B - C)];
if (temp.second == 0)
H[pair<int, int>(A - B, B - C)] = pair<int, long long>(A, sta);
else
H[pair<int, int>(A - B, B - C)] = max(temp, pair<int, long long>(A, sta));
return;
}
dfs1(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs1(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs1(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
void dfs2(int step, long long sta, int A, int B, int C) {
if (step == n + 1) {
pair<int, long long> temp = H[pair<int, int>(B - A, C - B)];
if (temp.second == 0) return;
ans = max(ans, pair<int, long long>(A + temp.first,
temp.second << (n - mid << 1) | sta));
return;
}
dfs2(step + 1, sta << 2 | 1, A, B + b[step], C + c[step]);
dfs2(step + 1, sta << 2 | 2, A + a[step], B, C + c[step]);
dfs2(step + 1, sta << 2 | 3, A + a[step], B + b[step], C);
}
int main() {
ans.first = -99999999;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
mid = (n + 1) / 2;
dfs1(1, 0, 0, 0, 0);
dfs2(mid + 1, 0, 0, 0, 0);
if (ans.first == -99999999) return puts("Impossible");
vector<int> Ans;
for (int i = 1; i <= n; i++) {
Ans.push_back(ans.second & 3);
ans.second >>= 2;
}
for (int i = Ans.size() - 1; i >= 0; i--) {
if (Ans[i] == 3)
cout << "LM" << endl;
else if (Ans[i] == 2)
cout << "LW" << endl;
else
cout << "MW" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[25][3];
int bestsum, bc0, bc1;
map<pair<int, int>, pair<int, int> > dp;
void find(int half, int code, int s0, int s1, int s2, int pos, int limit) {
if (pos == limit) {
int p1 = s1 - s0;
int p2 = s2 - s0;
pair<int, int> pp;
if (!half) {
pp = make_pair(p1, p2);
pair<int, int> old =
dp.find(pp) != dp.end() ? dp[pp] : make_pair(s0 - 1, 0);
pair<int, int> cur = make_pair(s0, code);
if (cur > old) dp[pp] = cur;
} else {
pp = make_pair(-p1, -p2);
if (dp.find(pp) != dp.end()) {
pair<int, int> old = dp[pp];
int sum = s0 + old.first;
if (sum > bestsum) {
bestsum = sum;
bc0 = old.second;
bc1 = code;
}
}
}
return;
}
find(half, code * 3 + 0, s0 + 000000000, s1 + a[pos][1], s2 + a[pos][2],
pos + 1, limit);
find(half, code * 3 + 1, s0 + a[pos][0], s1 + 000000000, s2 + a[pos][2],
pos + 1, limit);
find(half, code * 3 + 2, s0 + a[pos][0], s1 + a[pos][1], s2 + 000000000,
pos + 1, limit);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) cin >> a[i][j];
int mid = n / 2;
find(0, 0, 0, 0, 0, 0, mid);
bestsum = -1000000000;
find(1, 0, 0, 0, 0, mid, n);
if (bestsum == -1000000000)
cout << "Impossible";
else {
vector<int> result(n);
for (int i = n - 1; i >= mid; i--, bc1 /= 3) result[i] = bc1 % 3;
for (int i = mid - 1; i >= 0; i--, bc0 /= 3) result[i] = bc0 % 3;
for (int i = 0; i < n; i++)
cout << (result[i] == 0 ? "MW" : result[i] == 1 ? "LW" : "LM") << endl;
}
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";
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");
}
}
pair<int, string> find(int x, int y) {
int l = 0, r = s.size() - 1;
while (l < r - 1) {
int m = (l + r) / 2;
if (s[m].first.first < x)
l = m;
else
r = m;
}
if (s[l].first.first != x && s[r].first.first != x)
return make_pair(-INF, "");
int l1 = (s[l].first.first == x ? l : r);
l = 0, r = s.size() - 1;
while (l < r - 1) {
int m = (l + r) / 2;
if (s[m].first.first <= x)
l = m;
else
r = m;
}
int r1 = (s[r].first.first == x ? r : l);
l = l1, r = r1;
while (l < r - 1) {
int m = (l + r) / 2;
if (s[m].first.second <= y)
l = m;
else
r = m;
}
if (s[l].first.second != y && s[r].first.second != y)
return make_pair(-INF, "");
return (s[r].first.second == y
? make_pair(s[r].second.first, s[r].second.second)
: make_pair(s[l].second.first, s[l].second.second));
}
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());
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;
struct node {
int a, b, c;
node() = default;
node(int x, int y, int z) : a(x), b(y), c(z) {}
} s[1000];
struct mask {
int d1, d2;
mask() = default;
mask(int a, int b) : d1(a), d2(b) {}
bool operator<(const mask &t) const {
if (d1 != t.d1) return d1 < t.d1;
return d2 < t.d2;
}
};
struct keep {
int v1, v2, v3;
keep(int v1 = 0, int v2 = 0, int v3 = 0) {}
vector<int> vct;
} statu;
map<mask, keep> mp;
void DFS_1(int x, int y) {
if (x >= y + 1) {
int t1 = statu.v2 - statu.v1, t2 = statu.v3 - statu.v2;
if (mp.find(mask(t1, t2)) == mp.end())
mp[mask(t1, t2)] = statu;
else {
keep &p = mp[mask(t1, t2)];
if (p.v1 < statu.v1) mp[mask(t1, t2)] = statu;
}
return;
}
statu.v1 += s[x].a;
statu.v2 += s[x].b;
statu.vct.push_back(12);
DFS_1(x + 1, y);
statu.v1 -= s[x].a;
statu.v2 -= s[x].b;
statu.vct.pop_back();
statu.v2 += s[x].b;
statu.v3 += s[x].c;
statu.vct.push_back(23);
DFS_1(x + 1, y);
statu.v2 -= s[x].b;
statu.v3 -= s[x].c;
statu.vct.pop_back();
statu.v1 += s[x].a;
statu.v3 += s[x].c;
statu.vct.push_back(13);
DFS_1(x + 1, y);
statu.v1 -= s[x].a;
statu.v3 -= s[x].c;
statu.vct.pop_back();
}
int v_ans;
vector<int> ans;
void DFS_2(int x, int y) {
if (x == y + 1) {
int t1 = statu.v2 - statu.v1, t2 = statu.v3 - statu.v2;
if (mp.find(mask(-t1, -t2)) == mp.end()) return;
keep &p = mp[mask(-t1, -t2)];
int sv1 = statu.v1 + p.v1;
int sv2 = statu.v2 + p.v2;
int sv3 = statu.v3 + p.v3;
if (sv1 > v_ans) {
v_ans = sv1;
ans.clear();
ans = p.vct;
for (int j = 0; j < statu.vct.size(); j++) ans.push_back(statu.vct[j]);
}
return;
}
statu.v1 += s[x].a;
statu.v2 += s[x].b;
statu.vct.push_back(12);
DFS_2(x + 1, y);
statu.v1 -= s[x].a;
statu.v2 -= s[x].b;
statu.vct.pop_back();
statu.v2 += s[x].b;
statu.v3 += s[x].c;
statu.vct.push_back(23);
DFS_2(x + 1, y);
statu.v2 -= s[x].b;
statu.v3 -= s[x].c;
statu.vct.pop_back();
statu.v1 += s[x].a;
statu.v3 += s[x].c;
statu.vct.push_back(13);
DFS_2(x + 1, y);
statu.v1 -= s[x].a;
statu.v3 -= s[x].c;
statu.vct.pop_back();
}
inline void print(int x) {
if (x == 1)
putchar('L');
else if (x == 2)
putchar('M');
else
putchar('W');
}
int main() {
int n, i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d%d", &s[i].a, &s[i].b, &s[i].c);
if (n == 1) {
if (s[1].a == 0 && s[1].b == 0)
printf("LM\n");
else if (s[1].b == 0 && s[1].c == 0)
printf("MW\n");
else if (s[1].a == 0 && s[1].c == 0)
printf("LW\n");
else
printf("Impossible\n");
return 0;
}
v_ans = -(1 << 30);
statu.v1 = statu.v2 = statu.v3 = 0;
statu.vct.clear();
DFS_1(1, n / 2);
statu.v1 = statu.v2 = statu.v3 = 0;
statu.vct.clear();
DFS_2(n / 2 + 1, n);
if (v_ans == -(1 << 30)) {
printf("Impossible\n");
return 0;
}
for (i = 0; i < n; i++) {
print(ans[i] / 10);
print(ans[i] % 10);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[25], b[25], c[25];
class state {
public:
long long com, a, b, c;
long long vals;
state(long long x, long long y, long long z, long long v) {
vals = v;
com = min(x, min(y, z));
a = x - com;
b = y - com;
c = z - com;
}
bool operator<(const state& o) const {
if (a != o.a) return a < o.a;
if (b != o.b) return b < o.b;
if (c != o.c) return c < o.c;
return com > o.com;
}
bool operator==(const state& o) const {
return a == o.a && b == o.b && c == o.c;
}
long long mm() { return a == b && a == c; }
bool operator>(const state& o) const { return com > o.com; }
};
void gen(int i, int to, long long m, long long x, long long y, long long z,
vector<state>& v) {
if (i == to) {
v.push_back(state(x, y, z, m));
return;
}
gen(i + 1, to, m * 3, x + a[i], y + b[i], z, v);
gen(i + 1, to, m * 3 + 1, x + a[i], y, z + c[i], v);
gen(i + 1, to, m * 3 + 2, x, y + b[i], z + c[i], v);
}
long long oo = 1ll << 50;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i] >> b[i] >> c[i];
if (n == 1) {
if (!a[0] && a[0] == b[0])
cout << "LM" << endl;
else if (!a[0] && a[0] == c[0])
cout << "LW" << endl;
else if (!b[0] && b[0] == c[0])
cout << "MW" << endl;
else
cout << "Impossible";
return 0;
}
vector<state> v, g;
gen(0, n / 2, 0, 0, 0, 0, v);
gen(n / 2, n, 0, 0, 0, 0, g);
long long p = 1;
for (int i = 0; i < n - n / 2; ++i) p = p * 3;
sort(g.begin(), g.end());
state best(-oo, -oo, -oo, 0);
for (int i = 0; i < v.size(); ++i) {
long long MAX = max(v[i].a, max(v[i].b, v[i].c));
state need(MAX - v[i].a, MAX - v[i].b, MAX - v[i].c, v[i].vals);
need.com = oo;
int idx = lower_bound(g.begin(), g.end(), need) - g.begin();
need.com -= oo - v[i].com;
if (idx != g.size() && g[idx] == need) {
if (best.com < MAX + g[idx].com + need.com) {
long long d = MAX + g[idx].com + need.com;
best = state(d, d, d, need.vals * p + g[idx].vals);
}
}
}
if (best.com <= -oo)
puts("Impossible");
else {
vector<string> res;
long long r = best.vals;
for (int i = 0; i < n; ++i) {
if (r % 3 == 0)
res.push_back("LM");
else if (r % 3 == 1)
res.push_back("LW");
else
res.push_back("MW");
r /= 3;
}
for (int i = n - 1; i + 1; --i) cout << res[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, a[3][30], half;
int ans, ans1, ans2;
struct node {
int 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, int> b;
void pt(int s, int s1) {
int val = 0;
int temp = s;
int 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, int s, int r, int w, int mask) {
if (ind == -1) {
int 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, int s, int r, int w, int mask) {
if (ind == half - 1) {
int 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>
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;
map<int, int> fin;
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;
int f = fin[mask];
if (f + x > ans) {
ans = f + 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;
long long a[33][4];
int n;
long long bar;
map<pair<pair<long long, long long>, long long>, long long> m;
map<pair<pair<long long, long long>, long long>, long long> m2;
void go1(int step, long long sa, long long sb, long long sc, long long msk) {
if (bar == step) {
m[make_pair(make_pair(sa - sb, sa - sc), sb - sc)] = msk;
m2[make_pair(make_pair(sa - sb, sa - sc), sb - sc)] = sa;
return;
}
go1(step + 1, sa, sb + a[step][1], sc + a[step][2], msk * 3);
go1(step + 1, sa + a[step][0], sb, sc + a[step][2], msk * 3 + 1);
go1(step + 1, sa + a[step][0], sb + a[step][1], sc, msk * 3 + 2);
}
long long ans1 = 0, ans2 = 0, val = -1e15;
void go2(int step, long long sa, long long sb, long long sc, long long msk) {
if (n + 1 == step) {
if (bar == 1) {
if (sa == sb && sb == sc) {
if (sa > val) {
ans2 = msk;
val = sa;
}
}
}
if (m.count(make_pair(make_pair(sb - sa, sc - sa), sc - sb))) {
int its = m2[make_pair(make_pair(sb - sa, sc - sa), sc - sb)];
if (its + sa > val) {
val = its + sa;
ans1 = m[make_pair(make_pair(sb - sa, sc - sa), sc - sb)];
ans2 = msk;
}
}
return;
}
go2(step + 1, sa, sb + a[step][1], sc + a[step][2], msk * 3);
go2(step + 1, sa + a[step][0], sb, sc + a[step][2], msk * 3 + 1);
go2(step + 1, sa + a[step][0], sb + a[step][1], sc, msk * 3 + 2);
}
string getstre(int a) {
if (a == 0)
return "MW\n";
else if (a == 1)
return "LW\n";
else
return "LM\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
bar = (n + 1) / 2;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> a[i][j];
}
}
go1(1, 0, 0, 0, 0);
go2(bar, 0, 0, 0, 0);
if (val == -1e15) {
cout << "Impossible\n";
return 0;
}
vector<int> a1, a2, a3;
for (int i = 1; i < bar; ++i) {
a1.push_back(ans1 % 3);
ans1 /= 3;
}
for (int i = bar; i <= n; ++i) {
a2.push_back(ans2 % 3);
ans2 /= 3;
}
reverse((a1).begin(), (a1).end());
reverse((a2).begin(), (a2).end());
for (int i = 0; i < a1.size(); ++i) {
cout << getstre(a1[i]);
}
for (int i = 0; i < a2.size(); ++i) {
cout << getstre(a2[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pct {
int x, y, z;
};
vector<pct> v1, v2;
vector<pair<pct, int> > vf1, vf2;
pct a;
void backx1(int x, int num) {
if (v1.size() == x) {
vf1.push_back(make_pair(a, num));
} else {
a.y += v1[x].y;
a.z += v1[x].z;
backx1(x + 1, num * 3);
a.y -= v1[x].y;
a.z -= v1[x].z;
a.z += v1[x].z;
a.x += v1[x].x;
backx1(x + 1, num * 3 + 1);
a.x -= v1[x].x;
a.z -= v1[x].z;
a.x += v1[x].x;
a.y += v1[x].y;
backx1(x + 1, num * 3 + 2);
a.x -= v1[x].x;
a.y -= v1[x].y;
}
}
void backx2(int x, int num) {
if (v2.size() == x) {
vf2.push_back(make_pair(a, num));
} else {
a.y += v2[x].y;
a.z += v2[x].z;
backx2(x + 1, num * 3);
a.y -= v2[x].y;
a.z -= v2[x].z;
a.z += v2[x].z;
a.x += v2[x].x;
backx2(x + 1, num * 3 + 1);
a.x -= v2[x].x;
a.z -= v2[x].z;
a.x += v2[x].x;
a.y += v2[x].y;
backx2(x + 1, num * 3 + 2);
a.x -= v2[x].x;
a.y -= v2[x].y;
}
}
inline pair<int, pair<int, int> > get(pct a) {
return make_pair(a.x, make_pair(a.y, a.z));
}
namespace std {
template <>
struct hash<pair<int, pair<int, int> > > {
public:
size_t operator()(pair<int, pair<int, int> > x) const throw() {
size_t h = x.first + x.second.first * 7 + x.second.second * 11;
return h;
}
};
} // namespace std
string sr[] = {"MW", "LW", "LM"};
unordered_map<pair<int, pair<int, int> >, int> h1, h2;
int main() {
int T;
int N;
cin >> N;
for (int i = 1; i <= N; ++i) {
if (v1.size() <= 11) {
pct a;
cin >> a.x >> a.y >> a.z;
v1.push_back(a);
} else {
pct a;
cin >> a.x >> a.y >> a.z;
v2.push_back(a);
}
}
reverse(v1.begin(), v1.end());
if (v2.size() > 0) reverse(v2.begin(), v2.end());
a.x = a.y = a.z = 0;
backx1(0, 0);
a.x = a.y = a.z = 0;
backx2(0, 0);
for (auto &x1 : vf1) {
auto x = x1.first;
int a = min(x.x, min(x.y, x.z));
x.x -= a;
x.y -= a;
x.z -= a;
if (h2.find(get(x)) == h2.end()) {
h2[get(x)] = a;
h1[get(x)] = x1.second + 1;
}
if (h2[get(x)] < a) {
h2[get(x)] = max(h2[get(x)], a);
h1[get(x)] = x1.second + 1;
}
}
int ret1 = -1, ret2 = -1;
int ret3 = -101010;
for (auto &x1 : vf2) {
auto x = x1.first;
int a = max(x.x, max(x.y, x.z));
x.x -= a;
x.y -= a;
x.z -= a;
x.x *= -1;
x.y *= -1;
x.z *= -1;
int xz = h1[get(x)];
if (xz != 0) {
int yz = h2[get(x)];
if (ret1 == -1 || (yz + a > ret3)) {
ret1 = xz - 1;
ret2 = x1.second;
ret3 = a + yz;
}
}
}
if (ret1 == -1) {
cout << "Impossible";
return 0;
}
for (int i = 0; i < v1.size(); ++i) {
cout << sr[ret1 % 3] << "\n";
ret1 /= 3;
}
for (int i = 0; i < v2.size(); ++i) {
cout << sr[ret2 % 3] << "\n";
ret2 /= 3;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 16E5;
struct node {
char choose[20];
int s1, s2, s3;
friend bool operator<(node n1, node n2) {
if (n1.s2 != n2.s2)
return n1.s2 < n2.s2;
else if (n1.s3 != n2.s3)
return n1.s3 < n2.s3;
else
return n1.s1 > n2.s1;
}
friend bool operator==(node n1, node n2) {
if (n1.s2 == n2.s2 && n1.s3 == n2.s3)
return true;
else
return false;
}
friend bool operator<=(node n1, node n2) {
if (n1.s2 != n2.s2)
return n1.s2 < n2.s2;
else
return n1.s3 < n2.s3;
}
} s[MAXN], t[MAXN];
int n, cnt, sum1, sum2, sum3, flag, m;
int a[30], b[30], c[30];
char ch[20];
void make(node s[], int t, int k) {
if (k == t) {
int p;
if (flag == 1)
p = 0;
else
p = m;
for (int i = p; i < t; i++) s[cnt].choose[i - p] = ch[i];
s[cnt].choose[t - p] = 0;
s[cnt].s1 = sum1;
s[cnt].s2 = flag * (sum2 - sum1);
s[cnt].s3 = flag * (sum3 - sum1);
cnt++;
return;
}
sum1 -= a[k];
ch[k] = 'L';
make(s, t, k + 1);
sum1 += a[k];
sum2 -= b[k];
ch[k] = 'M';
make(s, t, k + 1);
sum2 += b[k];
sum3 -= c[k];
ch[k] = 'W';
make(s, t, k + 1);
sum3 += c[k];
}
int main() {
int cnt1, cnt2, t1, t2, ans;
char ret[30];
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d%d", a + i, b + i, c + i);
m = n - n / 2;
sum1 = sum2 = sum3 = 0;
for (int i = 0; i < m; i++) {
sum1 += a[i];
sum2 += b[i];
sum3 += c[i];
}
cnt = 0;
flag = 1;
make(s, m, 0);
sort(s, s + cnt);
cnt1 = cnt;
sum1 = sum2 = sum3 = 0;
for (int i = m; i < n; i++) {
sum1 += a[i];
sum2 += b[i];
sum3 += c[i];
}
cnt = 0;
flag = -1;
make(t, n, m);
sort(t, t + cnt);
cnt2 = cnt;
t1 = t2 = 0;
flag = 0;
ans = 0x80000000;
while (t1 < cnt1 && t2 < cnt2) {
if (s[t1] <= t[t2])
t1++;
else if (s[t1] == t[t2]) {
flag = 1;
if (s[t1].s1 + t[t2].s1 > ans) {
ans = s[t1].s1 + t[t2].s1;
strcpy(ret, s[t1].choose);
strcat(ret, t[t2].choose);
}
t1++;
t2++;
} else
t2++;
}
if (!flag)
printf("Impossible\n");
else {
for (int i = 0; i < n; i++) {
switch (ret[i]) {
case 'L':
puts("MW");
break;
case 'M':
puts("LW");
break;
case 'W':
puts("LM");
break;
}
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.