text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const int inf = INT_MAX;
vector<string> l = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ld x, y, z;
cin >> x >> y >> z;
if (x < 1 and y < 1 and z < 1) {
ld ans = pow(x, pow(y, z));
int cur = 0;
if (pow(x, pow(z, y)) > ans) {
ans = pow(x, pow(z, y));
cur = 1;
}
if (pow(x, y * z) > ans) {
ans = pow(x, y * z);
cur = 2;
}
if (pow(y, pow(x, z)) > ans) {
ans = pow(y, pow(x, z));
cur = 4;
}
if (pow(y, pow(z, x)) > ans) {
ans = pow(y, pow(z, x));
cur = 5;
}
if (pow(y, x * z) > ans) {
ans = pow(y, x * z);
cur = 6;
}
if (pow(z, pow(x, y)) > ans) {
ans = pow(z, pow(x, y));
cur = 8;
}
if (pow(z, pow(y, x)) > ans) {
ans = pow(z, pow(y, x));
cur = 9;
}
if (pow(z, x * y) > ans) {
ans = pow(z, x * y);
cur = 10;
}
cout << l[cur] << "\n";
return 0;
}
ld ans = 0;
int cur = 0;
if (x < 1)
ans = -1e18;
else if (x == 1)
ans = -1000;
else
ans = z * log(y) + log(log(x));
if (x > 1 and y * log(z) + log(log(x)) > ans) {
ans = y * log(z) + log(log(x));
cur = 1;
}
if (x > 1 and log(y) + log(z) + log(log(x)) > ans) {
ans = log(y) + log(z) + log(log(x));
cur = 2;
}
if (y == 1 and ans < -1000) {
ans = -1000;
cur = 4;
}
if (y > 1 and z * log(x) + log(log(y)) > ans) {
ans = z * log(x) + log(log(y));
cur = 4;
}
if (y > 1 and x * log(z) + log(log(y)) > ans) {
ans = x * log(z) + log(log(y));
cur = 5;
}
if (y > 1 and log(x) + log(z) + log(log(y)) > ans) {
ans = log(x) + log(z) + log(log(y));
cur = 6;
}
if (z == 1 and ans < -1000) {
ans = -1000;
cur = 8;
}
if (z > 1 and y * log(x) + log(log(z)) > ans) {
ans = y * log(x) + log(log(z));
cur = 8;
}
if (z > 1 and x * log(y) + log(log(z)) > ans) {
ans = x * log(y) + log(log(z));
cur = 9;
}
if (z > 1 and log(x) + log(y) + log(log(z)) > ans) {
ans = log(x) + log(y) + log(log(z));
cur = 10;
}
cout << l[cur];
return 0;
}
|
#include <bits/stdc++.h>
const long double EPS = 1e-12;
using namespace std;
inline long long rit() {
long long f = 0, key = 1;
char c;
do {
c = getchar();
if (c == '-') key = -1;
} while (c < '0' || c > '9');
do {
f = f * 10 + c - '0';
c = getchar();
} while (c >= '0' && c <= '9');
return f * key;
}
string op[12];
void init() {
op[0] = "x^y^z";
op[1] = "x^z^y";
op[2] = "(x^y)^z";
op[3] = "(x^z)^y";
op[4] = "y^x^z";
op[5] = "y^z^x";
op[6] = "(y^x)^z";
op[7] = "(y^z)^x";
op[8] = "z^x^y";
op[9] = "z^y^x";
op[10] = "(z^x)^y";
op[11] = "(z^y)^x";
}
inline long double chk(long double a, long double b, long double c) {
return log(a) * pow(b, c);
}
inline long double c2(long double a, long double b, long double c) {
return log(a) * b * c;
}
int eq(const long double &x, const long double &y) {
return abs(x - y) < EPS || abs(x - y) < EPS * abs(x);
}
long double ans[12], a, b, c;
void read() {
double fa, fb, fc;
scanf("%lf%lf%lf", &fa, &fb, &fc);
a = fa, b = fb, c = fc;
}
void solve() {
int key, i;
long double val;
ans[0] = chk(a, b, c);
ans[1] = chk(a, c, b);
ans[2] = c2(a, b, c);
ans[3] = c2(a, c, b);
ans[4] = chk(b, a, c);
ans[5] = chk(b, c, a);
ans[6] = c2(b, a, c);
ans[7] = c2(b, c, a);
ans[8] = chk(c, a, b);
ans[9] = chk(c, b, a);
ans[10] = c2(c, a, b);
ans[11] = c2(c, b, a);
key = 0;
val = ans[0];
for (i = 1; i < 12; i++) {
if ((!eq(val, ans[i])) && ans[i] > val) {
val = ans[i];
key = i;
}
}
cout << op[key] << endl;
}
int main() {
int nn = 1;
init();
while (nn--) {
read();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, z;
scanf("%lf%lf%lf", &x, &y, &z);
double m = -1000000.0;
int ad = 2;
for (int i = 0; i < 12; i++) {
double cmp;
if (x >= 2 || y >= 2 || z >= 2) switch (i) {
case 0:
cmp = z * log(y) + log(log(x));
break;
case 1:
cmp = y * log(z) + log(log(x));
break;
case 2:
cmp = log(y * z) + log(log(x));
break;
case 3:
cmp = log(y * z) + log(log(x));
break;
case 4:
cmp = z * log(x) + log(log(y));
break;
case 5:
cmp = x * log(z) + log(log(y));
break;
case 6:
cmp = log(x * z) + log(log(y));
break;
case 7:
cmp = log(x * z) + log(log(y));
break;
case 8:
cmp = y * log(x) + log(log(z));
break;
case 9:
cmp = x * log(y) + log(log(z));
break;
case 10:
cmp = log(x * y) + log(log(z));
break;
case 11:
cmp = log(x * y) + log(log(z));
break;
}
else
switch (i) {
case 0:
cmp = pow(x, pow(y, z));
break;
case 1:
cmp = pow(x, pow(z, y));
break;
case 2:
cmp = pow(pow(x, y), z);
break;
case 3:
cmp = pow(pow(x, z), y);
break;
case 4:
cmp = pow(y, pow(x, z));
break;
case 5:
cmp = pow(y, pow(z, x));
break;
case 6:
cmp = pow(y, x * z);
break;
case 7:
cmp = pow(y, x * z);
break;
case 8:
cmp = pow(z, pow(x, y));
break;
case 9:
cmp = pow(z, pow(y, x));
break;
case 10:
case 11:
cmp = pow(z, x * y);
break;
}
if (cmp - m > 1e-12) {
ad = i;
m = cmp;
}
}
switch (ad) {
case 0:
cout << "x^y^z";
break;
case 1:
cout << "x^z^y";
break;
case 2:
cout << "(x^y)^z";
break;
case 3:
cout << "(x^z)^y";
break;
case 4:
cout << "y^x^z";
break;
case 5:
cout << "y^z^x";
break;
case 6:
cout << "(y^x)^z";
break;
case 7:
cout << "(y^z)^x";
break;
case 8:
cout << "z^x^y";
break;
case 9:
cout << "z^y^x";
break;
case 10:
cout << "(z^x)^y";
break;
case 11:
cout << "(z^y)^x";
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
double a, b, c;
char s[12][100] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
struct num {
int a, p;
double x;
bool operator>(num y) { return a > y.a || a == y.a && x > y.x + 1e-12; }
} x, y = {};
inline void orz(double a, double b, double c, int p) {
x.p = p;
if (fabs(a - 1) < 1e-12) {
x.a = 2;
x.x = 0;
} else if (a < 1) {
x.a = 1;
x.x = -log(-log(a)) - log(b) * c;
} else {
x.a = 3;
x.x = log(log(a)) + log(b) * c;
}
if (x > y) y = x;
}
inline void orz_(double a, double b, double c, int p) {
x.p = p;
if (fabs(a - 1) < 1e-12) {
x.a = 2;
x.x = 0;
} else if (a < 1) {
x.a = 1;
x.x = -log(-log(a)) - log(b * c);
} else {
x.a = 3;
x.x = log(log(a)) + log(b * c);
}
if (x > y) y = x;
}
int main() {
scanf("%lf%lf%lf", &a, &b, &c);
orz(a, b, c, 0);
orz(a, c, b, 1);
orz_(a, b, c, 2);
orz_(a, c, b, 3);
orz(b, a, c, 4);
orz(b, c, a, 5);
orz_(b, a, c, 6);
orz_(b, c, a, 7);
orz(c, a, b, 8);
orz(c, b, a, 9);
orz_(c, a, b, 10);
orz_(c, b, a, 11);
printf("%s\n", s[y.p]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
double x, y, z;
cin >> x >> y >> z;
vector<double> a(12, -10000000000);
auto f1 = [](double a, double b, double c) { return pow(a, pow(b, c)); };
auto f2 = [](double a, double b, double c) { return pow(pow(a, b), c); };
auto f3 = [](double a, double b, double c) {
return c * log(b) + log(log(a));
};
auto f4 = [](double a, double b, double c) {
return log(c) + log(b) + log(log(a));
};
if (x <= 1 && y <= 1 && z <= 1) {
a[0] = f1(x, y, z);
a[1] = f1(x, z, y);
a[2] = f2(x, y, z);
a[3] = f2(x, z, y);
a[4] = f1(y, x, z);
a[5] = f1(y, z, x);
a[6] = f2(y, x, z);
a[7] = f2(y, z, x);
a[8] = f1(z, x, y);
a[9] = f1(z, y, x);
a[10] = f2(z, x, y);
a[11] = f2(z, y, x);
} else {
if (x > 1) {
a[0] = f3(x, y, z);
a[1] = f3(x, z, y);
a[2] = f4(x, y, z);
a[3] = f4(x, z, y);
}
if (y > 1) {
a[4] = f3(y, x, z);
a[5] = f3(y, z, x);
a[6] = f4(y, x, z);
a[7] = f4(y, z, x);
}
if (z > 1) {
a[8] = f3(z, x, y);
a[9] = f3(z, y, x);
a[10] = f4(z, x, y);
a[11] = f4(z, y, x);
}
}
double tmp = a[0];
int ret = 0;
for (int i = (0); i < (12); ++i) {
if (tmp < a[i] - EPS) {
tmp = a[i];
ret = i;
}
}
string S[12] = {
"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x",
};
cout << S[ret] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y, z, a[15], b[13];
cin >> x >> y >> z;
a[1] = x, b[1] = pow(y, z);
a[2] = x, b[2] = pow(z, y);
a[3] = x, b[3] = y * z;
a[4] = x, b[4] = z * y;
a[5] = y, b[5] = pow(x, z);
a[6] = y, b[6] = pow(z, x);
a[7] = y, b[7] = x * z;
a[8] = y, b[8] = z * x;
a[9] = z, b[9] = pow(x, y);
a[10] = z, b[10] = pow(y, x);
a[11] = z, b[11] = x * y;
a[12] = z, b[12] = y * x;
int ind = 1;
for (int i = 1; i <= 12; i++) {
if (log(a[i]) * b[i] > log(a[ind]) * b[ind]) {
ind = i;
}
}
if (ind == 1) {
cout << "x^y^z\n";
}
if (ind == 2) {
cout << "x^z^y\n";
}
if (ind == 3) {
cout << "(x^y)^z\n";
}
if (ind == 4) {
cout << "(x^z)^y\n";
}
if (ind == 5) {
cout << "y^x^z\n";
}
if (ind == 6) {
cout << "y^z^x\n";
}
if (ind == 7) {
cout << "(y^x)^z\n";
}
if (ind == 8) {
cout << "(y^z)^x\n";
}
if (ind == 9) {
cout << "z^x^y\n";
}
if (ind == 10) {
cout << "z^y^x\n";
}
if (ind == 11) {
cout << "(z^x)^y\n";
}
if (ind == 12) {
cout << "(z^y)^x\n";
}
return 0;
}
|
#include <bits/stdc++.h>
double x, y, z, xy, yz, zx, x_y, y_z, z_x, y_x, z_y, x_z,
max = -98765987654321.0, mod = 987654321.0, a[14];
int ans;
char ar[50][50] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
scanf("%lf %lf %lf", &x, &y, &z);
if (log(x) > 0) {
a[1] = z * log(y) + log(log(x));
a[1] += 987654321.0;
} else if (log(x) < 0) {
a[1] = z * log(y) - log(-log(x));
a[1] -= 987654321.0;
} else
a[1] = 0;
a[1] = log(x) > 0 ? z * log(y) + log(log(x)) + mod
: log(x) < 0 ? z * log(y) - log(-log(x)) - mod
: 0;
a[2] = log(x) > 0 ? y * log(z) + log(log(x)) + mod
: log(x) < 0 ? y * log(z) - log(-log(x)) - mod
: 0;
a[3] = log(x) > 0 ? log(y * z) + log(log(x)) + mod
: log(x) < 0 ? -log(y * z) - log(-log(x)) - mod
: 0;
a[4] = a[3];
a[5] = log(y) > 0 ? z * log(x) + log(log(y)) + mod
: log(y) < 0 ? z * log(x) - log(-log(y)) - mod
: 0;
a[6] = log(y) > 0 ? x * log(z) + log(log(y)) + mod
: log(y) < 0 ? x * log(z) - log(-log(y)) - mod
: 0;
a[7] = log(y) > 0 ? log(x * z) + log(log(y)) + mod
: log(y) < 0 ? -log(x * z) - log(-log(y)) - mod
: 0;
a[8] = a[7];
a[9] = log(z) > 0 ? y * log(x) + log(log(z)) + mod
: log(z) < 0 ? y * log(x) - log(-log(z)) - mod
: 0;
a[10] = log(z) > 0 ? x * log(y) + log(log(z)) + mod
: log(z) < 0 ? x * log(y) - log(-log(z)) - mod
: 0;
a[11] = log(z) > 0 ? log(x * y) + log(log(z)) + mod
: log(z) < 0 ? -log(x * y) - log(-log(z)) - mod
: 0;
a[12] = a[11];
for (int i = 1; i <= 12; i++) {
if (a[i] > max) {
max = a[i];
ans = i;
}
}
printf("%s", ar[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-12;
bool gt(long double a, long double b) {
if (fabs(a - b) < EPS)
return false;
else
return a > b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long double x, y, z;
cin >> x >> y >> z;
vector<pair<string, long double>> val;
val.emplace_back("x^y^z", log(x) * pow(y, z));
val.emplace_back("x^z^y", log(x) * pow(z, y));
val.emplace_back("(x^y)^z", log(x) * y * z);
val.emplace_back("(x^z)^y", log(x) * z * y);
val.emplace_back("y^x^z", log(y) * pow(x, z));
val.emplace_back("y^z^x", log(y) * pow(z, x));
val.emplace_back("(y^x)^z", log(y) * x * z);
val.emplace_back("z^x^y", log(z) * pow(x, y));
val.emplace_back("z^y^x", log(z) * pow(y, x));
val.emplace_back("(z^x)^y", log(z) * x * y);
val.emplace_back("(z^y)^x", log(z) * y * x);
string rs = "";
long double mx = -numeric_limits<long double>::infinity();
for (auto it : val) {
if (gt(it.second, mx)) {
rs = it.first;
mx = it.second;
}
}
cout << rs << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long double x, y, z;
cin >> x >> y >> z;
const long double eps = (long double)1e-12;
auto check = [&](long double x, long double y) { return abs(x - y) < eps; };
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
vector<long double> a(11);
a[0] = logx * pow(y, z);
a[1] = logx * pow(z, y);
a[2] = logx * y * z;
a[3] = a[2];
a[4] = logy * pow(x, z);
a[5] = logy * pow(z, x);
a[6] = logy * x * z;
a[7] = a[6];
a[8] = logz * pow(x, y);
a[9] = logz * pow(y, x);
a[10] = logz * x * y;
long double tmp = -1;
int pos = -1;
for (int i = 0; i < 11; i++) {
if (!check(a[i], tmp) && a[i] > tmp) {
tmp = a[i];
pos = i;
}
}
if (pos == 0) {
cout << "x^y^z" << '\n';
} else if (pos == 1) {
cout << "x^z^y" << '\n';
} else if (pos == 2) {
cout << "(x^y)^z" << '\n';
} else if (pos == 4) {
cout << "y^x^z" << '\n';
} else if (pos == 5) {
cout << "y^z^x" << '\n';
} else if (pos == 6) {
cout << "(y^x)^z" << '\n';
} else if (pos == 8) {
cout << "z^x^y" << '\n';
} else if (pos == 9) {
cout << "z^y^x" << '\n';
} else {
cout << "(z^x)^y" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z, ans = -1;
string s;
int main() {
cin >> x >> y >> z;
if (log(x) * pow(y, z) > ans) ans = log(x) * pow(y, z), s = "x^y^z";
if (log(x) * pow(z, y) > ans) ans = log(x) * pow(z, y), s = "x^z^y";
if (log(x) * y * z > ans) ans = log(x) * y * z, s = "(x^y)^z";
if (log(y) * pow(x, z) > ans) ans = log(y) * pow(x, z), s = "y^x^z";
if (log(y) * pow(z, x) > ans) ans = log(y) * pow(z, x), s = "y^z^x";
if (log(y) * x * z > ans) ans = log(y) * x * z, s = "(y^x)^z";
if (log(z) * pow(x, y) > ans) ans = log(z) * pow(x, y), s = "z^x^y";
if (log(z) * pow(y, x) > ans) ans = log(z) * pow(y, x), s = "z^y^x";
if (log(z) * x * y > ans) ans = log(z) * y * x, s = "(z^x)^y";
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string as[15] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y)",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
bool EQ(long double a, long double b) {
if (fabs(a - b) < 1e-9) return 1;
return 0;
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
long double ans[15];
ans[1] = logx * pow(y, z);
ans[2] = logx * pow(z, y);
ans[3] = logx * y * z;
ans[4] = ans[3];
ans[5] = logy * pow(x, z);
ans[6] = logy * pow(z, x);
ans[7] = logy * x * z;
ans[8] = ans[7];
ans[9] = logz * pow(x, y);
ans[10] = logz * pow(y, x);
ans[11] = logz * x * y;
ans[12] = ans[11];
int inx = 1;
long double tmp = ans[1];
for (int i = 2; i <= 12; ++i) {
if (!EQ(tmp, ans[i]) && tmp < ans[i]) tmp = ans[i], inx = i;
}
cout << as[inx] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[13] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
double num[13];
const double INF = 1.0e36;
void solve(double x, double y, double z, int a, int b, int c) {
double MAX = -INF, MIN = INF;
int id;
if (a == 1 && b == 1 && c == 1) {
num[1] = z * log(y) + log(log(x));
num[2] = y * log(z) + log(log(x));
num[3] = log(z) + log(y) + log(log(x));
num[4] = log(y) + log(z) + log(log(x));
num[5] = z * log(x) + log(log(y));
num[6] = x * log(z) + log(log(y));
num[7] = log(z) + log(x) + log(log(y));
num[8] = log(x) + log(z) + log(log(y));
num[9] = y * log(x) + log(log(z));
num[10] = x * log(y) + log(log(z));
num[11] = log(x) + log(y) + log(log(z));
num[12] = log(y) + log(x) + log(log(z));
for (int i = 1; i <= 12; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
} else if (a == 0 && b == 1 && c == 1) {
num[5] = z * log(x) + log(log(y));
num[6] = x * log(z) + log(log(y));
num[7] = log(z) + log(x) + log(log(y));
num[8] = log(x) + log(z) + log(log(y));
num[9] = y * log(x) + log(log(z));
num[10] = x * log(y) + log(log(z));
num[11] = log(x) + log(y) + log(log(z));
num[12] = log(y) + log(x) + log(log(z));
for (int i = 5; i <= 12; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
} else if (a == 1 && b == 0 && c == 1) {
num[1] = z * log(y) + log(log(x));
num[2] = y * log(z) + log(log(x));
num[3] = log(z) + log(y) + log(log(x));
num[4] = log(y) + log(z) + log(log(x));
num[9] = y * log(x) + log(log(z));
num[10] = x * log(y) + log(log(z));
num[11] = log(x) + log(y) + log(log(z));
num[12] = log(y) + log(x) + log(log(z));
for (int i = 1; i <= 4; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
for (int i = 9; i <= 12; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
} else if (a == 1 && b == 1 && c == 0) {
num[1] = z * log(y) + log(log(x));
num[2] = y * log(z) + log(log(x));
num[3] = log(z) + log(y) + log(log(x));
num[4] = log(y) + log(z) + log(log(x));
num[5] = z * log(x) + log(log(y));
num[6] = x * log(z) + log(log(y));
num[7] = log(z) + log(x) + log(log(y));
num[8] = log(x) + log(z) + log(log(y));
for (int i = 1; i <= 8; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
} else if (a == 1 && b == 0 && c == 0) {
num[1] = z * log(y) + log(log(x));
num[2] = y * log(z) + log(log(x));
num[3] = log(z) + log(y) + log(log(x));
num[4] = log(y) + log(z) + log(log(x));
for (int i = 1; i <= 4; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
} else if (a == 0 && b == 1 && c == 0) {
num[5] = z * log(x) + log(log(y));
num[6] = x * log(z) + log(log(y));
num[7] = log(z) + log(x) + log(log(y));
num[8] = log(x) + log(z) + log(log(y));
for (int i = 5; i <= 8; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
} else if (a == 0 && b == 0 && c == 1) {
num[9] = y * log(x) + log(log(z));
num[10] = x * log(y) + log(log(z));
num[11] = log(x) + log(y) + log(log(z));
num[12] = log(y) + log(x) + log(log(z));
for (int i = 9; i <= 12; i++) {
if (MAX < num[i]) {
MAX = num[i];
id = i;
}
}
} else if (a == 0 && b == 0 && c == 0) {
num[1] = z * log(y) + log(-log(x));
num[2] = y * log(z) + log(-log(x));
num[3] = log(z) + log(y) + log(-log(x));
num[4] = log(y) + log(z) + log(-log(x));
num[5] = z * log(x) + log(-log(y));
num[6] = x * log(z) + log(-log(y));
num[7] = log(z) + log(x) + log(-log(y));
num[8] = log(x) + log(z) + log(-log(y));
num[9] = y * log(x) + log(-log(z));
num[10] = x * log(y) + log(-log(z));
num[11] = log(x) + log(y) + log(-log(z));
num[12] = log(y) + log(x) + log(-log(z));
for (int i = 1; i <= 12; i++) {
if (MIN > num[i]) {
MIN = num[i];
id = i;
}
}
}
cout << s[id] << endl;
}
int main() {
double x, y, z;
cin >> x >> y >> z;
int xf = 1, yf = 1, zf = 1;
if (x <= 1.0) xf = 0;
if (y <= 1.0) yf = 0;
if (z <= 1.0) zf = 0;
solve(x, y, z, xf, yf, zf);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2e3 + 5;
int TEST_NUM = 1;
using namespace std;
void calc(string *res, long double *d, long double x, long double y,
long double z) {
res[1] = "x^y^z";
d[1] = log(x) * pow(y, z);
res[2] = "x^z^y";
d[2] = log(x) * pow(z, y);
res[3] = "(x^y)^z";
d[3] = log(x) * y * z;
res[4] = "(x^z)^y";
d[4] = log(x) * y * z;
res[5] = "y^x^z";
d[5] = log(y) * pow(x, z);
res[6] = "y^z^x";
d[6] = log(y) * pow(z, x);
res[7] = "(y^x)^z";
d[7] = log(y) * x * z;
res[8] = "(y^z)^x";
d[8] = log(y) * x * z;
res[9] = "z^x^y";
d[9] = log(z) * pow(x, y);
res[10] = "z^y^x";
d[10] = log(z) * pow(y, x);
res[11] = "(z^x)^y";
d[11] = log(z) * x * y;
res[12] = "(z^y)^x";
d[12] = log(z) * x * y;
}
int main() {
long double x, y, z;
string res[15];
long double d[15];
cin >> x >> y >> z;
calc(res, d, x, y, z);
int mxi = -1;
for (int i = 1; i <= 12; i++) {
if (mxi == -1 || d[mxi] < d[i]) {
mxi = i;
}
}
cout << res[mxi] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char *a[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
const double minn = -1e18;
const double esp = 1e-6;
int main() {
double x, y, z;
while (scanf("%lf %lf %lf", &x, &y, &z) == 3) {
int flag = 0;
double p[12];
if (x > 1 || y > 1 || z > 1) {
p[0] = x > 1 ? z * log10(y) + log10(log10(x)) : minn;
p[1] = x > 1 ? y * log10(z) + log10(log10(x)) : minn;
p[2] = x > 1 ? log10(z) + log10(y * log10(x)) : minn;
p[3] = x > 1 ? log10(y) + log10(z * log10(x)) : minn;
p[4] = y > 1 ? z * log10(x) + log10(log10(y)) : minn;
p[5] = y > 1 ? x * log10(z) + log10(log10(y)) : minn;
p[6] = y > 1 ? log10(z) + log10(x * log10(y)) : minn;
p[7] = y > 1 ? log10(x) + log10(z * log10(y)) : minn;
p[8] = z > 1 ? y * log10(x) + log10(log10(z)) : minn;
p[9] = z > 1 ? x * log10(y) + log10(log10(z)) : minn;
p[10] = z > 1 ? log10(y) + log10(x * log10(z)) : minn;
p[11] = z > 1 ? log10(x) + log10(y * log10(z)) : minn;
} else {
p[0] = (double)pow(x, pow(y, z));
p[1] = (double)pow(x, pow(z, y));
p[2] = (double)pow(pow(x, y), z);
p[3] = (double)pow(pow(x, z), y);
p[4] = (double)pow(y, pow(x, z));
p[5] = (double)pow(y, pow(z, x));
p[6] = (double)pow(pow(y, x), z);
p[7] = (double)pow(pow(y, z), x);
p[8] = (double)pow(z, pow(x, y));
p[9] = (double)pow(z, pow(y, x));
p[10] = (double)pow(pow(z, x), y);
p[11] = (double)pow(pow(z, y), x);
}
double max_num = p[0];
for (int i = 0; i < 12; i++) {
if (p[i] - max_num > esp) {
max_num = p[i];
flag = i;
}
}
printf("%s\n", a[flag]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-9;
const long long int mod = 1e9 + 7;
const long long int inf = 1LL << 30;
const int MAXN = 1e5 + 5;
void cp() {
double x, y, z;
cin >> x >> y >> z;
vector<double> arr;
if (x > 1. || y > 1. || z > 1.) {
arr.push_back(z * log(y) + log(log(x)));
arr.push_back(y * log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
swap(x, y);
arr.push_back(z * log(y) + log(log(x)));
arr.push_back(y * log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
swap(x, z);
arr.push_back(z * log(y) + log(log(x)));
arr.push_back(y * log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
for (double &X : arr)
if (isnan(X)) X = -DBL_MAX;
} else {
arr.push_back(pow(x, pow(y, z)));
arr.push_back(pow(x, pow(z, y)));
arr.push_back(pow(x, y * z));
arr.push_back(pow(x, y * z));
swap(x, y);
arr.push_back(pow(x, pow(y, z)));
arr.push_back(pow(x, pow(z, y)));
arr.push_back(pow(x, y * z));
arr.push_back(pow(x, y * z));
swap(x, z);
arr.push_back(pow(x, pow(y, z)));
arr.push_back(pow(x, pow(z, y)));
arr.push_back(pow(x, y * z));
arr.push_back(pow(x, y * z));
}
string ans;
int idx = max_element(arr.begin(), arr.end()) - begin(arr);
if (idx == 0)
ans = "x^y^z";
else if (idx == 1)
ans = "x^z^y";
else if (idx == 2)
ans = "(x^y)^z";
else if (idx == 3)
ans = "(x^z)^y";
else if (idx == 4)
ans = "y^x^z";
else if (idx == 5)
ans = "y^z^x";
else if (idx == 6)
ans = "(y^x)^z";
else if (idx == 7)
ans = "(y^z)^x";
else if (idx == 8)
ans = "z^x^y";
else if (idx == 9)
ans = "z^y^x";
else if (idx == 10)
ans = "(z^x)^y";
else
ans = "(z^y)^x";
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void reader(int *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(long long *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(double *x) { scanf("%lf", x); }
void reader(long double *x) { scanf("%Lf", x); }
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T *x, S *y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T *x, S *y, U *z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T *x, S *y, U *z, V *w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(double x, char c) {
printf("%.15f", x);
putchar(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar(x[i]);
putchar(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
int i;
if (!n) {
putchar('\n');
return;
}
for (i = 0; i < n - 1; i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
char memarr[17000000];
void *mem = memarr;
long double X, Y, Z;
long double val[9];
const char *ans[9] = {
"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y",
};
int main() {
int i, j, k, ind;
double tmp;
reader(&tmp);
X = tmp;
reader(&tmp);
Y = tmp;
reader(&tmp);
Z = tmp;
val[0] = logl(X) * powl(Y, Z);
val[1] = logl(X) * powl(Z, Y);
val[2] = logl(X) * Y * Z;
val[3] = logl(Y) * powl(X, Z);
val[4] = logl(Y) * powl(Z, X);
val[5] = logl(Y) * X * Z;
val[6] = logl(Z) * powl(X, Y);
val[7] = logl(Z) * powl(Y, X);
val[8] = logl(Z) * X * Y;
ind = 0;
for (i = 1; i < 9; i++)
if (val[ind] < val[i]) ind = i;
writerLn(ans[ind]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double a[13];
int main() {
double xx, yy, zz;
cin >> xx >> yy >> zz;
long double x, y, z;
x = xx;
y = yy;
z = zz;
a[1] = log(x) * pow(y, z);
a[2] = log(x) * pow(z, y);
a[3] = log(x) * y * z;
a[4] = a[3];
a[5] = log(y) * pow(x, z);
a[6] = log(y) * pow(z, x);
a[7] = log(y) * x * z;
a[8] = a[7];
a[9] = log(z) * pow(x, y);
a[10] = log(z) * pow(y, x);
a[11] = log(z) * x * y;
a[12] = a[11];
int j;
long double mina;
mina = -2.0;
for (int i = 1; i <= 12; i++) {
if (a[i] > mina) {
j = i;
mina = a[i];
}
}
if (j == 1) {
cout << "x^y^z" << endl;
}
if (j == 2) {
cout << "x^z^y" << endl;
}
if (j == 3 || j == 4) {
cout << "(x^y)^z" << endl;
}
if (j == 5) {
cout << "y^x^z" << endl;
}
if (j == 6) {
cout << "y^z^x" << endl;
}
if (j == 7 || j == 8) {
cout << "(y^x)^z" << endl;
}
if (j == 9) {
cout << "z^x^y" << endl;
}
if (j == 10) {
cout << "z^y^x" << endl;
}
if (j == 11 || j == 12) {
cout << "(z^x)^y" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double x, y, z, ans = -1;
int num;
int main() {
std::ios_base::sync_with_stdio(false);
cin >> x >> y >> z;
if (ans < pow(y, z) * log(x)) ans = pow(y, z) * log(x), num = 1;
if (ans < pow(z, y) * log(x)) ans = pow(z, y) * log(x), num = 2;
if (ans < y * z * log(x)) ans = y * z * log(x), num = 3;
if (ans < pow(x, z) * log(y)) ans = pow(x, z) * log(y), num = 4;
if (ans < pow(z, x) * log(y)) ans = pow(z, x) * log(y), num = 5;
if (ans < x * z * log(y)) ans = x * z * log(y), num = 6;
if (ans < pow(x, y) * log(z)) ans = pow(x, y) * log(z), num = 7;
if (ans < pow(y, x) * log(z)) ans = pow(y, x) * log(z), num = 8;
if (ans < x * y * log(z)) ans = x * y * log(z), num = 9;
switch (num) {
case 1:
cout << "x^y^z";
break;
case 2:
cout << "x^z^y";
break;
case 3:
cout << "(x^y)^z";
break;
case 4:
cout << "y^x^z";
break;
case 5:
cout << "y^z^x";
break;
case 6:
cout << "(y^x)^z";
break;
case 7:
cout << "z^x^y";
break;
case 8:
cout << "z^y^x";
break;
case 9:
cout << "(z^x)^y";
break;
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double DELTA = 0.0000001;
const double MAX_DOUBLE = numeric_limits<double>::max();
const double MIN_DOUBLE = -numeric_limits<double>::max();
double f1(double x, double y, double z, double def) {
if (log(x) < -DELTA) return def;
if (log(x) < DELTA) return MIN_DOUBLE;
return z * log(y) + log(log(x));
}
double f2(double x, double y, double z, double def) {
if ((y * z) * log(x) < -DELTA) return def;
if ((y * z) * log(x) < DELTA) return MIN_DOUBLE;
return log((y * z) * log(x));
}
typedef double (*Func)(double x, double y, double z, double def);
void find_max(Func func, double arg1, double arg2, double arg3, string res_set,
double& mx, string& res) {
double curr = func(arg1, arg2, arg3, MIN_DOUBLE);
if (curr > mx + DELTA) {
res = res_set;
mx = curr;
}
}
void find_min(Func func, double arg1, double arg2, double arg3, string res_set,
double& mn, string& res) {
double curr = func(arg1, arg2, arg3, MAX_DOUBLE);
if (curr < mn - DELTA) {
res = res_set;
mn = curr;
}
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
double x, y, z;
cin >> x >> y >> z;
string res;
if (x > 1.0 + DELTA || y > 1.0 + DELTA || z > 1.0 + DELTA) {
double mx = MIN_DOUBLE;
find_max(f1, x, y, z, "x^y^z", mx, res);
find_max(f1, x, z, y, "x^z^y", mx, res);
find_max(f2, x, y, z, "(x^y)^z", mx, res);
find_max(f2, x, z, y, "(x^z)^y", mx, res);
find_max(f1, y, x, z, "y^x^z", mx, res);
find_max(f1, y, z, x, "y^z^x", mx, res);
find_max(f2, y, x, z, "(y^x)^z", mx, res);
find_max(f2, y, z, x, "(y^z)^x", mx, res);
find_max(f1, z, x, y, "z^x^y", mx, res);
find_max(f1, z, y, x, "z^y^x", mx, res);
find_max(f2, z, x, y, "(z^x)^y", mx, res);
find_max(f2, z, y, x, "(z^y)^x", mx, res);
} else {
double mn = MAX_DOUBLE;
find_min(f1, 1.0 / x, y, z, "x^y^z", mn, res);
find_min(f1, 1.0 / x, z, y, "x^z^y", mn, res);
find_min(f2, 1.0 / x, y, z, "(x^y)^z", mn, res);
find_min(f2, 1.0 / x, z, y, "(x^z)^y", mn, res);
find_min(f1, 1.0 / y, x, z, "y^x^z", mn, res);
find_min(f1, 1.0 / y, z, x, "y^z^x", mn, res);
find_min(f2, 1.0 / y, x, z, "(y^x)^z", mn, res);
find_min(f2, 1.0 / y, z, x, "(y^z)^x", mn, res);
find_min(f1, 1.0 / z, x, y, "z^x^y", mn, res);
find_min(f1, 1.0 / z, y, x, "z^y^x", mn, res);
find_min(f2, 1.0 / z, x, y, "(z^x)^y", mn, res);
find_min(f2, 1.0 / z, y, x, "(z^y)^x", mn, res);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[][100] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
double x, y, z;
long double a[20];
long double k;
int n;
while (~scanf("%lf%lf%lf", &x, &y, &z)) {
k = 0;
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
a[0] = logx * powl(y, z);
a[1] = logx * powl(z, y);
a[2] = logx * y * z;
a[3] = -1;
a[4] = logy * powl(x, z);
a[5] = logy * powl(z, x);
a[6] = logy * x * z;
a[7] = -1;
a[8] = logz * powl(x, y);
a[9] = logz * powl(y, x);
a[10] = logz * x * y;
a[11] = -1;
n = 0;
for (int i = 1; i < 12; i++) {
if (a[i] > a[n]) {
n = i;
}
}
printf("%s\n", s[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char out[12][12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
struct value {
double a, b;
public:
value() {}
value(double a, double b) : a(a), b(log(b)) {}
bool operator<(const value& v2) const {
const value& v1 = *this;
if (abs(v1.b) < 1e-9) return v2.b > 0 && abs(v2.b) > 1e-9;
double b1 = v1.b, b2 = v2.b;
if (b1 < 0) {
b1 *= -1, b2 *= -1;
if (b2 < 0) return 1;
double x = v1.a - v2.a, y = log(b2) - log(b1);
return x > y && abs(x - y);
}
if (b2 < 0) return 0;
double x = v1.a - v2.a, y = log(b2) - log(b1);
return x < y && abs(x - y);
}
};
pair<value, int> V[12];
int main() {
double x, y, z;
cin >> x >> y >> z;
V[0].first = value(z * log(y), x);
V[1].first = value(y * log(z), x);
V[2].first = value(log(y * z), x);
V[3].first = value(log(y * z), x);
V[4].first = value(z * log(x), y);
V[5].first = value(x * log(z), y);
V[6].first = value(log(x * z), y);
V[7].first = value(log(x * z), y);
V[8].first = value(y * log(x), z);
V[9].first = value(x * log(y), z);
V[10].first = value(log(x * y), z);
V[11].first = value(log(x * y), z);
for (int i = 0; i < (12); i++) V[i].second = i;
sort(V, V + 12);
int c = V[11].second;
for (int i = 0; i < (12); i++) {
if (!(V[i].first < V[11].first) && !(V[11].first < V[i].first)) {
cerr << V[i].second << " ----- " << endl;
c = min(c, V[i].second);
}
}
puts(out[c]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INFint = 2147483547;
const long long INF = 9223372036854775807ll;
const long long MOD = 1000000007ll;
const long double EPS = 1e-16;
long double pow1(long double x, long double y, long double z) {
return pow(y, z) * log(x);
}
long double pow2(long double x, long double y, long double z) {
return y * z * log(x);
}
int main() {
ios_base::sync_with_stdio(0);
long double x, y, z;
cin >> x >> y >> z;
vector<long double> v;
v.push_back(pow1(x, y, z));
v.push_back(pow1(x, z, y));
v.push_back(pow2(x, y, z));
v.push_back(pow2(x, z, y));
v.push_back(pow1(y, x, z));
v.push_back(pow1(y, z, x));
v.push_back(pow2(y, x, z));
v.push_back(pow2(y, z, x));
v.push_back(pow1(z, x, y));
v.push_back(pow1(z, y, x));
v.push_back(pow2(z, x, y));
v.push_back(pow2(z, y, x));
string get[12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double mx = -INF;
int ans = 0;
for (int i = 0; i < v.size(); i++) {
if (0) cerr << fixed << setprecision(6) << v[i] << endl;
if (v[i] - mx > EPS) {
mx = v[i];
ans = i;
}
}
cout << get[ans];
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y, z;
string str[] = {"", "x^y^z\n", "x^z^y\n", "(x^y)^z\n", "y^x^z\n",
"y^z^x\n", "(y^x)^z\n", "z^x^y\n", "z^y^x\n", "(z^x)^y\n"};
cin >> x >> y >> z;
long double a[13];
a[1] = log(x) * pow(y, z);
a[2] = log(x) * pow(z, y);
a[3] = y * z * log(x);
a[4] = log(y) * pow(x, z);
a[5] = log(y) * pow(z, x);
a[6] = x * z * log(y);
a[7] = log(z) * pow(x, y);
a[8] = log(z) * pow(y, x);
a[9] = x * y * log(z);
long double ans = a[1];
int m = 1;
for (int i = 2; i < 10; ++i) {
if (a[i] > ans) {
ans = a[i];
m = i;
}
}
cout << str[m];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int n, ans;
long double x, y, z, mxm, val[15];
char str[][10] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
cin >> x >> y >> z;
val[1] = pow(y, z) * log(x);
val[2] = pow(z, y) * log(x);
val[3] = val[4] = log(x) * y * z;
val[5] = pow(x, z) * log(y);
val[6] = pow(z, x) * log(y);
val[7] = val[8] = log(y) * x * z;
val[9] = pow(x, y) * log(z);
val[10] = pow(y, x) * log(z);
val[11] = val[12] = log(z) * x * y;
mxm = val[1];
ans = 1;
for (int i = 1; i <= 12; i++) {
if (val[i] > mxm) {
mxm = val[i];
ans = i;
}
}
cout << str[ans] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long double x, y, z;
int main(void) {
cin >> x >> y >> z;
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
char str[11][20] = {"x^y^z", "x^z^y", "(x^y)^z", "", "y^x^z", "y^z^x",
"(y^x)^z", " ", "z^x^y", "z^y^x", "(z^x)^y"};
long double num[11];
num[0] = logx * pow(y, z);
num[1] = logx * pow(z, y);
num[2] = logx * y * z;
num[3] = num[2];
num[4] = logy * pow(x, z);
num[5] = logy * pow(z, x);
num[6] = logy * x * z;
num[7] = num[6];
num[8] = logz * pow(x, y);
num[9] = logz * pow(y, x);
num[10] = logz * x * y;
int pos = -1;
long double maxx = -1;
for (int i = 0; i < 11; i++) {
if (abs(num[i] - maxx) > 1e-12 && maxx < num[i]) {
maxx = num[i];
pos = i;
}
}
cout << str[pos] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long double arr[13];
string s[13];
int main() {
long double x, y, z;
cin >> x >> y >> z;
s[0] = "x^y^z";
s[1] = "x^z^y";
s[2] = "(x^y)^z";
s[3] = "y^x^z";
s[4] = "y^z^x";
s[5] = "(y^x)^z";
s[6] = "z^x^y";
s[7] = "z^y^x";
s[8] = "(z^x)^y";
arr[0] = log(x) * pow(y, z);
arr[1] = log(x) * pow(z, y);
arr[2] = log(x) * y * z;
arr[3] = log(y) * pow(x, z);
arr[4] = log(y) * pow(z, x);
arr[5] = log(y) * x * z;
arr[6] = log(z) * pow(x, y);
arr[7] = log(z) * pow(y, x);
arr[8] = log(z) * x * y;
string ans;
long double an = -1.0;
cout.precision(20);
for (int i = 0; i < 9; i++) {
if (arr[i] > an) {
an = arr[i];
ans = s[i];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, z;
cin >> x >> y >> z;
double ninf = log(0);
double a, b, c, d, e, f, g, h, i;
double m;
string res;
if (log(x) < 0 && log(y) < 0 && log(z) < 0) {
a = z * log(y) + log(-log(x));
b = y * log(z) + log(-log(x));
c = log(y * z * -log(x));
d = z * log(x) + log(-log(y));
e = x * log(z) + log(-log(y));
f = log(x * z * -log(y));
g = y * log(x) + log(-log(z));
h = x * log(y) + log(-log(z));
i = log(x * y * -log(z));
m = a;
res = "x^y^z";
if (b < m) m = b, res = "x^z^y";
if (c < m) m = c, res = "(x^y)^z";
if (d < m) m = d, res = "y^x^z";
if (e < m) m = e, res = "y^z^x";
if (f < m) m = f, res = "(y^x)^z";
if (g < m) m = g, res = "z^x^y";
if (h < m) m = h, res = "z^y^x";
if (i < m) m = i, res = "(z^x)^y";
printf("%s\n", res.c_str());
} else {
if (log(x) >= 0) {
a = z * log(y) + log(log(x));
b = y * log(z) + log(log(x));
c = log(y * z * log(x));
}
if (log(y) >= 0) {
d = z * log(x) + log(log(y));
e = x * log(z) + log(log(y));
f = log(x * z * log(y));
}
if (log(z) >= 0) {
g = y * log(x) + log(log(z));
h = x * log(y) + log(log(z));
i = log(x * y * log(z));
}
bool flag = 0;
if (log(x) >= 0 && (a > m || !flag)) m = a, res = "x^y^z", flag = 1;
if (log(x) >= 0 && (b > m || !flag)) m = b, res = "x^z^y", flag = 1;
if (log(x) >= 0 && (c > m || !flag)) m = c, res = "(x^y)^z", flag = 1;
if (log(y) >= 0 && (d > m || !flag)) m = d, res = "y^x^z", flag = 1;
if (log(y) >= 0 && (e > m || !flag)) m = e, res = "y^z^x", flag = 1;
if (log(y) >= 0 && (f > m || !flag)) m = f, res = "(y^x)^z", flag = 1;
if (log(z) >= 0 && (g > m || !flag)) m = g, res = "z^x^y", flag = 1;
if (log(z) >= 0 && (h > m || !flag)) m = h, res = "z^y^x", flag = 1;
if (log(z) >= 0 && (i > m || !flag)) m = i, res = "(z^x)^y", flag = 1;
printf("%s\n", res.c_str());
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-9;
const long long int mod = 1e9 + 7;
const long long int inf = 1LL << 30;
const int MAXN = 1e5 + 5;
void cp() {
double x, y, z;
cin >> x >> y >> z;
vector<double> arr;
if (x > 1. || y > 1. || z > 1.) {
arr.push_back(z * log(y) + log(log(x)));
arr.push_back(y * log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
swap(x, y);
arr.push_back(z * log(y) + log(log(x)));
arr.push_back(y * log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
swap(x, z);
arr.push_back(z * log(y) + log(log(x)));
arr.push_back(y * log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
arr.push_back(log(y) + log(z) + log(log(x)));
for (double &X : arr)
if (isnan(X)) X = -DBL_MAX;
} else {
arr.push_back(pow(x, pow(y, z)));
arr.push_back(pow(x, pow(z, y)));
arr.push_back(pow(x, y * z));
arr.push_back(pow(x, y * z));
swap(x, y);
arr.push_back(pow(x, pow(y, z)));
arr.push_back(pow(x, pow(z, y)));
arr.push_back(pow(x, y * z));
arr.push_back(pow(x, y * z));
swap(x, z);
arr.push_back(pow(x, pow(y, z)));
arr.push_back(pow(x, pow(z, y)));
arr.push_back(pow(x, y * z));
arr.push_back(pow(x, y * z));
}
string ans;
int idx = max_element(arr.begin(), arr.end()) - begin(arr);
if (idx == 0)
ans = "x^y^z";
else if (idx == 1)
ans = "x^z^y";
else if (idx == 2)
ans = "(x^y)^z";
else if (idx == 3)
ans = "(x^z)^y";
else if (idx == 4)
ans = "y^x^z";
else if (idx == 5)
ans = "y^z^x";
else if (idx == 6)
ans = "(y^x)^z";
else if (idx == 7)
ans = "(y^z)^x";
else if (idx == 8)
ans = "z^x^y";
else if (idx == 9)
ans = "z^y^x";
else if (idx == 10)
ans = "(z^x)^y";
else
ans = "(z^y)^x";
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
|
#include <bits/stdc++.h>
double aa[12];
int sign[12];
int compare(const void *a, const void *b) {
int i = *(int *)a;
int j = *(int *)b;
if (sign[i] != sign[j]) return sign[j] - sign[i];
if (sign[i] == 0) return i - j;
return aa[i] == aa[j] ? i - j : aa[i] > aa[j] ? -sign[i] : sign[i];
}
void power(int i, double x, double y, double z) {
if (x == 1)
sign[i] = 0;
else if (x > 1) {
sign[i] = 1;
aa[i] = z * log(y) + log(log(x));
} else {
sign[i] = -1;
aa[i] = z * log(y) + log(-log(x));
}
}
void power_(int i, double x, double yz) {
if (x == 1)
sign[i] = 0;
else if (x > 1) {
sign[i] = 1;
aa[i] = log(yz) + log(log(x));
} else {
sign[i] = -1;
aa[i] = log(yz) + log(-log(x));
}
}
int main() {
static char ss[12][16] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
static int ii[12];
double x, y, z;
int i;
scanf("%lf%lf%lf", &x, &y, &z);
power(0, x, y, z);
power(1, x, z, y);
power_(2, x, y * z);
power_(3, x, y * z);
power(4, y, x, z);
power(5, y, z, x);
power_(6, y, x * z);
power_(7, y, x * z);
power(8, z, x, y);
power(9, z, y, x);
power_(10, z, x * y);
power_(11, z, x * y);
for (i = 0; i < 12; i++) ii[i] = i;
qsort(ii, 12, sizeof *ii, compare);
printf("%s\n", ss[ii[0]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int Scan() {
int res = 0, ch, flag = 0;
if ((ch = getchar()) == '-')
flag = 1;
else if (ch >= '0' && ch <= '9')
res = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') res = res * 10 + ch - '0';
return flag ? -res : res;
}
pair<double, int> cmp(double x, double y, double z, int id) {
if (z * log10(y) >= y * log10(z) &&
z * log10(y) >= (double)(log10(z) + log10(y)))
return make_pair(z * log10(y) + log10(log10(x)), 1 + id);
if (y * log10(z) >= z * log10(y) &&
y * log10(z) >= (double)(log10(z) + log10(y)))
return make_pair(y * log10(z) + log10(log10(x)), 2 + id);
if ((double)(log10(z) + log10(y)) >= z * log10(y) &&
(log10(z) + log10(y)) >= y * log10(z))
return make_pair((log10(z) + log10(y)) + log10(log10(x)), 3 + id);
}
int cmp2(pair<double, int> p1, pair<double, int> p2, pair<double, int> p3) {
if (p1.first >= p2.first && p1.first >= p3.first) return p1.second;
if (p2.first >= p1.first && p2.first >= p3.first) return p2.second;
if (p3.first >= p1.first && p3.first >= p2.first) return p3.second;
}
pair<double, int> cmp3(double x, double y, double z, int id) {
if (z * log10(y) <= y * log10(z) &&
z * log10(y) <= (double)(log10(z) + log10(y)))
return make_pair(z * log10(y) + log10(log10(x)), 1 + id);
if (y * log10(z) <= z * log10(y) &&
y * log10(z) <= (double)(log10(z) + log10(y)))
return make_pair(y * log10(z) + log10(log10(x)), 2 + id);
if ((double)(log10(z) + log10(y)) <= z * log10(y) &&
(log10(z) + log10(y)) <= y * log10(z))
return make_pair((log10(z) + log10(y)) + log10(log10(x)), 3 + id);
}
int cmp4(pair<double, int> p1, pair<double, int> p2, pair<double, int> p3) {
if (p1.first <= p2.first && p1.first <= p3.first) return p1.second;
if (p2.first <= p1.first && p2.first <= p3.first) return p2.second;
if (p3.first <= p1.first && p3.first <= p2.first) return p3.second;
}
void show1(char x, char y, char z) { printf("%c^%c^%c\n", x, y, z); }
void show2(char x, char y, char z) { printf("(%c^%c)^%c", x, y, z); }
int main() {
double x, y, z;
cin >> x >> y >> z;
if (x > 1 && y > 1 && z > 1) {
pair<double, int> p1 = cmp(x, y, z, 0);
pair<double, int> p2 = cmp(y, x, z, 4);
pair<double, int> p3 = cmp(z, x, y, 8);
int res = cmp2(p1, p2, p3);
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (x > 1 && y > 1) {
pair<double, int> p1 = cmp(x, y, z, 0);
pair<double, int> p2 = cmp(y, x, z, 4);
int res = p1.first > p2.first ? p1.second : p2.second;
if (fabs(p1.first - p2.first) < 1e-9) res = p1.second;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (y > 1 && z > 1) {
pair<double, int> p2 = cmp(y, x, z, 4);
pair<double, int> p3 = cmp(z, x, y, 8);
int res = p2.first >= p3.first ? p2.second : p3.second;
if (fabs(p2.first - p3.first) < 1e-9) res = p2.second;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (x > 1 && z > 1) {
pair<double, int> p1 = cmp(x, y, z, 0);
pair<double, int> p3 = cmp(z, x, y, 8);
int res = p1.first >= p3.first ? p1.second : p3.second;
if (fabs(p1.first - p3.first) < 1e-9) res = p1.second;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (x > 1) {
pair<double, int> p1 = cmp(x, y, z, 0);
int res = p1.second;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (y > 1) {
pair<double, int> p2 = cmp(y, x, z, 4);
int res = p2.second;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (z > 1) {
pair<double, int> p3 = cmp(z, x, y, 8);
int res = p3.second;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (x == 1) {
int res = 1;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (y == 1) {
int res = 5;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else if (z == 1) {
int res = 9;
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
} else {
pair<double, int> p1 = cmp3(1 / x, y, z, 0);
pair<double, int> p2 = cmp3(1 / y, x, z, 4);
pair<double, int> p3 = cmp3(1 / z, x, y, 8);
int res = cmp4(p1, p2, p3);
switch (res) {
case 1:
show1('x', 'y', 'z');
break;
case 2:
show1('x', 'z', 'y');
break;
case 3:
show2('x', 'y', 'z');
break;
case 4:
show2('x', 'z', 'y');
break;
case 5:
show1('y', 'x', 'z');
break;
case 6:
show1('y', 'z', 'x');
break;
case 7:
show2('y', 'x', 'z');
break;
case 8:
show2('y', 'z', 'x');
break;
case 9:
show1('z', 'x', 'y');
break;
case 10:
show1('z', 'y', 'x');
break;
case 11:
show2('z', 'x', 'y');
break;
case 12:
show2('z', 'y', 'x');
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char ans[15][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
double cal(double x, double y, double z, int k) {
switch (k) {
case 0:
return z * log(y) + log(log(x));
case 1:
return y * log(z) + log(log(x));
case 2:
case 3:
return log(y) + log(z) + log(log(x));
case 4:
return z * log(x) + log(log(y));
case 5:
return x * log(z) + log(log(y));
case 6:
case 7:
return log(x) + log(z) + log(log(y));
case 8:
return y * log(x) + log(log(z));
case 9:
return x * log(y) + log(log(z));
case 10:
case 11:
return log(x) + log(y) + log(log(z));
}
}
int main() {
double a[5];
scanf("%lf%lf%lf", &a[0], &a[1], &a[2]);
if (a[0] > 1.0 || a[1] > 1.0 || a[2] > 1.0) {
int m = -1;
double k = -1.0;
for (int i = (0); i <= (2); i++) {
if (a[i] < 1.0) continue;
for (int j = (0); j <= (3); j++) {
double tmp = cal(a[0], a[1], a[2], i * 4 + j);
if (m == -1 || tmp - k > 1e-10) {
m = i * 4 + j;
k = tmp;
}
}
}
printf("%s", ans[m]);
} else {
int m = -1;
double k = 1.0;
for (int i = (0); i <= (2); i++) {
double t = a[i];
a[i] = 1 / a[i];
for (int j = (0); j <= (3); j++) {
double tmp = cal(a[0], a[1], a[2], i * 4 + j);
if (m == -1 || k - tmp > 1e-10) {
m = i * 4 + j;
k = tmp;
}
}
a[i] = t;
}
printf("%s", ans[m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double ans[13];
int id[13];
bool flag[13];
char s[13][13] = {" ", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
bool cmp(int i, int j) { return ans[i] < ans[j]; }
bool cmp1(int i, int j) {
if (flag[i] != flag[j]) return flag[i] > flag[j];
return ans[i] > ans[j];
}
int main() {
double x, y, z, xx, yy, zz;
scanf("%lf%lf%lf", &x, &y, &z);
for (int i = 1; i <= 12; i++) {
id[i] = i;
flag[i] = true;
}
if (x < 1 && y < 1 && z < 1) {
xx = 1.0 / x;
yy = 1.0 / y;
zz = 1.0 / z;
ans[1] = z * log(y) + log(log(xx));
ans[2] = y * log(z) + log(log(xx));
ans[3] = log(y * z * log(xx));
ans[4] = log(y * z * log(xx));
ans[5] = z * log(x) + log(log(yy));
ans[6] = x * log(z) + log(log(yy));
ans[7] = log(x * z * log(yy));
ans[8] = log(x * z * log(yy));
ans[9] = y * log(x) + log(log(zz));
ans[10] = x * log(y) + log(log(zz));
ans[11] = log(x * y * log(zz));
ans[12] = log(x * y * log(zz));
sort(id + 1, id + 13, cmp);
printf("%s", s[id[1]]);
} else {
if (x >= 1) {
ans[1] = z * log(y) + log(log(x));
ans[2] = y * log(z) + log(log(x));
ans[3] = log(y * z * log(x));
ans[4] = log(y * z * log(x));
} else
flag[1] = flag[2] = flag[3] = flag[4] = false;
if (y >= 1) {
ans[5] = z * log(x) + log(log(y));
ans[6] = x * log(z) + log(log(y));
ans[7] = log(x * z * log(y));
ans[8] = log(x * z * log(y));
} else
flag[5] = flag[6] = flag[7] = flag[8] = false;
if (z >= 1) {
ans[9] = y * log(x) + log(log(z));
ans[10] = x * log(y) + log(log(z));
ans[11] = log(x * y * log(z));
ans[12] = log(x * y * log(z));
} else
flag[9] = flag[10] = flag[11] = flag[12] = false;
sort(id + 1, id + 13, cmp1);
printf("%s", s[id[1]]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, z;
cin >> x >> y >> z;
double a[12];
auto check = [&a]() -> bool {
for (int i = 0; i < 12; ++i)
if (std::isinf(a[i]) || std::isnan(a[i])) return true;
return false;
};
a[0] = pow(x, pow(y, z));
a[1] = pow(x, pow(z, y));
a[2] = pow(x, y * z);
a[3] = a[2];
a[4] = pow(y, pow(x, z));
a[5] = pow(y, pow(z, x));
a[6] = pow(y, x * z);
a[7] = a[2];
a[8] = pow(z, pow(x, y));
a[9] = pow(z, pow(y, x));
a[10] = pow(z, x * y);
a[11] = a[2];
if (check()) {
a[0] = pow(y, z) * log2(x);
a[1] = pow(z, y) * log2(x);
a[2] = y * z * log2(x);
a[3] = a[2];
a[4] = pow(x, z) * log2(y);
a[5] = pow(z, x) * log2(y);
a[6] = x * z * log2(y);
a[7] = a[6];
a[8] = pow(x, y) * log2(z);
a[9] = pow(y, x) * log2(z);
a[10] = x * y * log2(z);
a[11] = a[6];
if (check()) {
a[0] = z * log2(y) + log2(log2(x));
a[1] = y * log2(z) + log2(log2(x));
a[2] = log2(y) + log2(z) + log2(log2(x));
a[3] = a[2];
a[4] = z * log2(x) + log2(log2(y));
a[5] = x * log2(z) + log2(log2(y));
a[6] = log2(x) + log2(z) + log2(log2(y));
a[7] = a[6];
a[8] = y * log2(x) + log2(log2(z));
a[9] = x * log2(y) + log2(log2(z));
a[10] = log2(x) + log2(y) + log2(log2(z));
a[11] = a[10];
}
}
const char* s[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int i = 0;
for (int j = 1; j < 12; ++j)
if (a[j] > a[i]) i = j;
cout << s[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y, z, a[13] = {0}, maxa = -1;
cin >> x >> y >> z;
a[1] = pow(y, z) * log(x);
a[2] = pow(z, y) * log(x);
a[3] = z * y * log(x);
a[4] = y * z * log(x);
a[5] = pow(x, z) * log(y);
a[6] = pow(z, x) * log(y);
a[7] = z * x * log(y);
a[8] = x * z * log(y);
a[9] = pow(x, y) * log(z);
a[10] = pow(y, x) * log(z);
a[11] = y * x * log(z);
a[12] = x * y * log(z);
int maxi = 0;
for (int i = 1; i <= 12; i++) {
if (a[i] > maxa) {
maxi = i;
maxa = a[i];
}
}
string s[13] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
cout << s[maxi];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[15];
void print(int p) {
if (p == 1)
printf("x^y^z");
else if (p == 2)
printf("x^z^y");
else if (p == 3)
printf("(x^y)^z");
else if (p == 4)
printf("(x^z)^y");
else if (p == 5)
printf("y^x^z");
else if (p == 6)
printf("y^z^x");
else if (p == 7)
printf("(y^x)^z");
else if (p == 8)
printf("(y^z)^x");
else if (p == 9)
printf("z^x^y");
else if (p == 10)
printf("z^y^x");
else if (p == 11)
printf("(z^x)^y");
else
printf("(z^y)^x");
}
int main() {
double x, y, z;
scanf("%lf%lf%lf", &x, &y, &z);
if (log(x) < -1e-10 && log(y) < -1e-10 && log(z) < -1e-10) {
a[1] = z * log(y) + log(-log(x));
a[2] = y * log(z) + log(-log(x));
a[3] = log(y) + log(z) + log(-log(x));
a[4] = a[3];
a[5] = z * log(x) + log(-log(y));
a[6] = x * log(z) + log(-log(y));
a[7] = log(x) + log(z) + log(-log(y));
a[8] = a[7];
a[9] = y * log(x) + log(-log(z));
a[10] = x * log(y) + log(-log(z));
a[11] = log(x) + log(y) + log(-log(z));
a[12] = a[11];
double s = 1000000000.0;
for (int i = 1; i <= 12; i++) {
s = min(s, a[i]);
}
for (int i = 1; i <= 12; i++) {
if (fabs(s - a[i]) < 1e-10) {
print(i);
return 0;
}
}
} else {
if (log(x) < -1e-10) {
double s = max(log(x), log(y));
s = max(s, log(z));
if (fabs(s) < 1e-10) {
if (fabs(log(y)) < 1e-10) {
print(5);
} else {
print(9);
}
return 0;
}
for (int i = 1; i <= 12; i++) a[i] = -1000000000.0;
if (log(y) > 1e-10) {
a[5] = z * log(x) + log(log(y));
a[6] = x * log(z) + log(log(y));
a[7] = log(x) + log(z) + log(log(y));
a[8] = a[7];
}
if (log(z) > 1e-10) {
a[9] = y * log(x) + log(log(z));
a[10] = x * log(y) + log(log(z));
a[11] = log(x) + log(y) + log(log(z));
a[12] = a[11];
}
s = -1000000000.0;
for (int i = 1; i <= 12; i++) {
s = max(s, a[i]);
}
for (int i = 1; i <= 12; i++) {
if (fabs(s - a[i]) < 1e-10) {
print(i);
return 0;
}
}
} else {
double s = max(log(x), log(y));
s = max(s, log(z));
if (fabs(s) < 1e-10) {
if (fabs(log(x)) < 1e-10) {
print(1);
} else if (fabs(log(y)) < 1e-10) {
print(5);
} else
print(9);
return 0;
}
for (int i = 1; i <= 12; i++) a[i] = -1000000000.0;
a[1] = z * log(y) + log(log(x));
a[2] = y * log(z) + log(log(x));
a[3] = log(y) + log(z) + log(log(x));
a[4] = a[3];
if (log(y) > 1e-10) {
a[5] = z * log(x) + log(log(y));
a[6] = x * log(z) + log(log(y));
a[7] = log(x) + log(z) + log(log(y));
a[8] = a[7];
}
if (log(z) > 1e-10) {
a[9] = y * log(x) + log(log(z));
a[10] = x * log(y) + log(log(z));
a[11] = log(x) + log(y) + log(log(z));
a[12] = a[11];
}
s = -1000000000.0;
for (int i = 1; i <= 12; i++) {
s = max(s, a[i]);
}
for (int i = 1; i <= 12; i++) {
if (fabs(s - a[i]) < 1e-10) {
print(i);
return 0;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[13][15] = {{" "}, {"x^y^z"}, {"x^z^y"}, {"(x^y)^z"},
{"(x^z)^y"}, {"y^x^z"}, {"y^z^x"}, {"(y^x)^z"},
{"(y^z)^x"}, {"z^x^y"}, {"z^y^x"}, {"(z^x)^y"},
{"(z^y)^x"}};
long double a[15];
long double x, y, z;
cin >> x >> y >> z;
a[1] = pow(y, z) * log(x);
a[2] = pow(z, y) * log(x);
a[3] = z * log(pow(x, y));
a[4] = y * log(pow(x, z));
a[5] = pow(x, z) * log(y);
a[6] = pow(z, x) * log(y);
a[7] = z * log(pow(y, x));
a[8] = x * log(pow(y, z));
a[9] = pow(x, y) * log(z);
a[10] = pow(y, x) * log(z);
a[11] = y * log(pow(z, x));
a[12] = x * log(pow(z, y));
long double ma = -1000000;
int pos = 0;
for (int i = 1; i <= 12; i++) {
if (a[i] > ma + 1e-6) {
ma = a[i];
pos = i;
}
}
cout << s[pos] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long double eps = -1e12;
inline bool eq(const long double &x, const long double &y) {
return abs(x - y) < eps || abs(x - y) < eps * abs(x);
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
string expression[12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
vector<long double> ans(12, 0);
long double res = -1000;
long double logx = log(x);
long double logy = log(y);
long double logz = log(z);
ans[0] = pow(y, z) * logx;
ans[1] = pow(z, y) * logx;
ans[2] = logx * y * z;
ans[3] = ans[2];
ans[4] = pow(x, z) * logy;
ans[5] = pow(z, x) * logy;
ans[6] = logy * x * z;
ans[7] = ans[6];
ans[8] = pow(x, y) * logz;
ans[9] = pow(y, x) * logz;
ans[10] = logz * y * x;
ans[11] = ans[10];
int index = 0;
for (int i = 0; i < 12; ++i) {
if (ans[i] > res && !eq(ans[i], res)) {
res = ans[i];
index = i;
}
}
cout << expression[index] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
double arr[13];
double x, y, z, lx, ly, lz, llx, lly, llz;
cin >> x >> y >> z;
if (!(x < 1.05 && y < 1.05 && z < 1.05)) {
lx = log(x);
ly = log(y);
lz = log(z);
llx = -1000000000000000000;
lly = -1000000000000000000;
llz = -1000000000000000000;
if (lx > 0) llx = log(lx);
if (ly > 0) lly = log(ly);
if (lz > 0) llz = log(lz);
arr[1] = z * ly + llx;
arr[2] = y * lz + llx;
arr[3] = log(y * z * lx);
arr[4] = -10000000000000000;
arr[5] = z * lx + lly;
arr[6] = x * lz + lly;
arr[7] = log(x * z * ly);
arr[8] = -100000000000000000;
arr[9] = y * lx + llz;
arr[10] = x * ly + llz;
arr[11] = log(x * y * lz);
arr[12] = -10000000000000000;
} else {
arr[1] = pow(x, pow(y, z));
arr[2] = pow(x, pow(z, y));
arr[3] = pow(x, (y * z));
arr[4] = -10000000000000000;
arr[5] = pow(y, pow(x, z));
arr[6] = pow(y, pow(z, x));
arr[7] = pow(y, (x * z));
arr[8] = -100000000000000000;
arr[9] = pow(z, pow(x, y));
arr[10] = pow(z, pow(y, x));
arr[11] = pow(z, (y * x));
arr[12] = -10000000000000000;
}
long long ind = 1;
double ma = arr[1];
for (long long i = 2; i < 13; ++i) {
if (arr[i] > ma) {
ind = i;
ma = arr[i];
}
}
if (ind == 1)
cout << "x^y^z";
else if (ind == 2)
cout << "x^z^y";
else if (ind == 3)
cout << "(x^y)^z";
else if (ind == 5)
cout << "y^x^z";
else if (ind == 6)
cout << "y^z^x";
else if (ind == 7)
cout << "(y^x)^z";
else if (ind == 9)
cout << "z^x^y";
else if (ind == 10)
cout << "z^y^x";
else if (ind == 11)
cout << "(z^x)^y";
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
bool eq(long double x, long double y) { return abs(x - y) < 1E-20; }
int main() {
int ans;
long double x, y, z;
cin >> x >> y >> z;
long double a[12], lx = log(x), llx = log(lx), ly = log(y), lly = log(ly),
lz = log(z), llz = log(log(z));
a[1] = lx * pow(y, z);
a[2] = lx * pow(z, y);
a[3] = lx * y * z;
a[4] = a[2];
a[5] = ly * pow(x, z);
a[6] = ly * pow(z, x);
a[7] = ly * x * z;
a[8] = a[7];
a[9] = lz * pow(x, y);
a[10] = lz * pow(y, x);
a[11] = lz * x * y;
long double max = a[1], max1;
int tmp = 1;
for (int i = 2; i < 12; i++) {
if (!eq(a[i], max) && max < a[i]) {
max = a[i];
tmp = i;
}
}
switch (tmp) {
case 1:
printf("x^y^z");
break;
case 2:
printf("x^z^y");
break;
case 3:
printf("(x^y)^z");
break;
case 4:
printf("(x^y)^z");
break;
case 5:
printf("y^x^z");
break;
case 6:
printf("y^z^x");
break;
case 7:
printf("(y^x)^z");
break;
case 8:
printf("(y^x)^z");
break;
case 9:
printf("z^x^y");
break;
case 10:
printf("z^y^x");
break;
case 11:
printf("(z^x)^y");
break;
default:
printf("..");
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005, infi = 1000000, mod = 1000000007;
long double x, y, z, mx, lx, ly, lz, eps = 0.000000001;
string sol = "x^y^z";
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> x >> y >> z;
mx = pow(y, z) * log(x);
if (pow(z, y) * log(x) - mx > eps) mx = pow(z, y) * log(x), sol = "x^z^y";
if (z * log(pow(x, y)) - mx > eps) mx = z * log(pow(x, y)), sol = "(x^y)^z";
if (y * log(pow(x, z)) - mx > eps) mx = y * log(pow(x, z)), sol = "(x^z)^y";
if (pow(x, z) * log(y) - mx > eps) mx = pow(x, z) * log(y), sol = "y^x^z";
if (pow(z, x) * log(y) - mx > eps) mx = pow(z, x) * log(y), sol = "y^z^x";
if (z * log(pow(y, x)) - mx > eps) mx = z * log(pow(y, x)), sol = "(y^x)^z";
if (x * log(pow(y, z)) - mx > eps) mx = x * log(pow(y, z)), sol = "(y^z)^x";
if (pow(x, y) * log(z) - mx > eps) mx = pow(x, y) * log(z), sol = "z^x^y";
if (pow(y, x) * log(z) - mx > eps) mx = pow(y, x) * log(z), sol = "z^y^x";
if (y * log(pow(z, x)) - mx > eps) mx = y * log(pow(z, x)), sol = "(z^x)^y";
if (x * log(pow(z, y)) - mx > eps) mx = x * log(pow(z, y)), sol = "(z^y)^x";
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double myLogLog(long double x, long double y, long double z, bool type,
bool log_mode, bool* ignore, int num);
int main() {
long double x, y, z;
long double m = -1e10, _m;
int c;
bool log_mode = false, ignore[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
cin >> x >> y >> z;
((x > 1 || y > 1 || z > 1) ? log_mode = true : log_mode = false);
_m = myLogLog(z, y, x, 0, log_mode, ignore, 12 - 1);
if (m <= _m + 1e-6 && !ignore[12 - 1]) {
m = _m;
c = 12;
}
_m = myLogLog(z, x, y, 0, log_mode, ignore, 11 - 1);
if (m <= _m + 1e-6 && !ignore[11 - 1]) {
m = _m;
c = 11;
}
_m = myLogLog(z, y, x, 1, log_mode, ignore, 10 - 1);
if (m <= _m + 1e-6 && !ignore[10 - 1]) {
m = _m;
c = 10;
}
_m = myLogLog(z, x, y, 1, log_mode, ignore, 9 - 1);
if (m <= _m + 1e-6 && !ignore[9 - 1]) {
m = _m;
c = 9;
}
_m = myLogLog(y, z, x, 0, log_mode, ignore, 8 - 1);
if (m <= _m + 1e-6 && !ignore[8 - 1]) {
m = _m;
c = 8;
}
_m = myLogLog(y, x, z, 0, log_mode, ignore, 7 - 1);
if (m <= _m + 1e-6 && !ignore[7 - 1]) {
m = _m;
c = 7;
}
_m = myLogLog(y, z, x, 1, log_mode, ignore, 6 - 1);
if (m <= _m + 1e-6 && !ignore[6 - 1]) {
m = _m;
c = 6;
}
_m = myLogLog(y, x, z, 1, log_mode, ignore, 5 - 1);
if (m <= _m + 1e-6 && !ignore[5 - 1]) {
m = _m;
c = 5;
}
_m = myLogLog(x, z, y, 0, log_mode, ignore, 4 - 1);
if (m <= _m + 1e-6 && !ignore[4 - 1]) {
m = _m;
c = 4;
}
_m = myLogLog(x, y, z, 0, log_mode, ignore, 3 - 1);
if (m <= _m + 1e-6 && !ignore[3 - 1]) {
m = _m;
c = 3;
}
_m = myLogLog(x, z, y, 1, log_mode, ignore, 2 - 1);
if (m <= _m + 1e-6 && !ignore[2 - 1]) {
m = _m;
c = 2;
}
_m = myLogLog(x, y, z, 1, log_mode, ignore, 1 - 1);
if (m <= _m + 1e-6 && !ignore[1 - 1]) {
m = _m;
c = 1;
}
switch (c) {
case 12:
cout << "(z^y)^x";
break;
case 11:
cout << "(z^x)^y";
break;
case 10:
cout << "z^y^x";
break;
case 9:
cout << "z^x^y";
break;
case 8:
cout << "(y^z)^x";
break;
case 7:
cout << "(y^x)^z";
break;
case 6:
cout << "y^z^x";
break;
case 5:
cout << "y^x^z";
break;
case 4:
cout << "(x^z)^y";
break;
case 3:
cout << "(x^y)^z";
break;
case 2:
cout << "x^z^y";
break;
case 1:
cout << "x^y^z";
break;
}
cout << endl;
return 0;
}
long double myLogLog(long double x, long double y, long double z, bool type,
bool log_mode, bool* ignore, int num) {
if (!type) {
if (log_mode)
if (x <= 1) {
ignore[num] = true;
return 0;
} else
return log(z) + log(y) + log(log(x));
else
return pow(pow(x, y), z);
} else {
if (log_mode)
if (x <= 1) {
ignore[num] = true;
return 0;
} else
return z * log(y) + log(log(x));
else
return pow(x, pow(y, z));
}
}
|
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-12;
int main() {
double x, y, z;
cin >> x >> y >> z;
long double a[13];
string s[13];
a[1] = powl(y, z) * log(x);
a[2] = powl(z, y) * log(x);
a[3] = y * z * log(x);
a[4] = y * z * log(x);
a[5] = powl(x, z) * log(y);
a[6] = powl(z, x) * log(y);
a[7] = x * z * log(y);
a[8] = x * z * log(y);
a[9] = powl(x, y) * log(z);
a[10] = powl(y, x) * log(z);
a[11] = x * y * log(z);
a[12] = x * y * log(z);
s[1] = "x^y^z";
s[2] = "x^z^y";
s[3] = "(x^y)^z";
s[4] = "(x^z)^y";
s[5] = "y^x^z";
s[6] = "y^z^x";
s[7] = "(y^x)^z";
s[8] = "(y^z)^x";
s[9] = "z^x^y";
s[10] = "z^y^x";
s[11] = "(z^x)^y";
s[12] = "(z^y)^x";
long double mx = LONG_MIN;
for (long long i = (long long)(1); i <= (long long)(12); i++) {
cerr << "[DEBUG] "
<< "s[i]"
<< " = " << s[i] << endl;
cerr << "[DEBUG] "
<< "a[i]"
<< " = " << a[i] << endl;
mx = max(mx, a[i]);
}
for (long long i = (long long)(1); i <= (long long)(12); i++)
if (fabs(mx - a[i]) < EPS) {
cout << s[i];
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const char *strs[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^y)^z",
"y^x^z", "y^z^x", "(y^x)^z", "(y^x)^z",
"z^x^y", "z^y^x", "(z^x)^y", "(z^x)^y"};
long double mylog(long double x) { return log(x); }
int main() {
long double x, y, z;
vector<long double> r(12);
double inf = 1.0 / 0.0;
double nan = 0.0 / 0.0;
cin >> x >> y >> z;
r[0] = z * mylog(y) + mylog(mylog(x));
r[1] = y * mylog(z) + mylog(mylog(x));
r[2] = r[3] = mylog(y * z * mylog(x));
r[4] = z * mylog(x) + mylog(mylog(y));
r[5] = x * mylog(z) + mylog(mylog(y));
r[6] = r[7] = mylog(x * z * mylog(y));
r[8] = y * mylog(x) + mylog(mylog(z));
r[9] = x * mylog(y) + mylog(mylog(z));
r[10] = r[11] = mylog(y * x * mylog(z));
long double maxd = -inf;
int mini = 0;
for (int i = 0; i < 12; i++) {
if (r[i] == nan) continue;
if (r[i] > maxd) {
maxd = r[i];
mini = i;
}
}
if (maxd > -inf) {
cout << strs[mini];
exit(0);
}
for (int i = 0; i < 12; i++)
if (r[i] == -inf) {
cout << strs[i];
exit(0);
}
r[0] = pow(x, pow(y, z));
r[1] = pow(x, pow(z, y));
r[2] = r[3] = pow(x, y * z);
r[4] = pow(y, pow(x, z));
r[5] = pow(y, pow(z, x));
r[6] = r[7] = pow(y, z * x);
r[8] = pow(z, pow(x, y));
r[9] = pow(z, pow(y, x));
r[10] = r[11] = pow(z, y * x);
for (int i = 0; i < 12; i++) {
if (r[i] > maxd) {
maxd = r[i];
mini = i;
}
}
cout << strs[mini];
}
|
#include <bits/stdc++.h>
using namespace std;
string ans[12] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
bool solve() {
double first, second, z;
scanf("%lf %lf %lf", &first, &second, &z);
if (first < 5 && second < 5 && z < 5) {
long double a[12] = {
powl(second, z) * logl(first), powl(z, second) * logl(first),
second * z * logl(first), z * second * logl(first),
powl(first, z) * logl(second), powl(z, first) * logl(second),
first * z * logl(second), z * first * logl(second),
powl(first, second) * logl(z), powl(second, first) * logl(z),
first * second * logl(z), second * first * logl(z)};
long double Max = a[0];
int idx = 0;
for (int i = 1; i < 12; i++) {
if (a[i] > Max) {
Max = a[i];
idx = i;
}
}
printf("%s\n", ans[idx].c_str());
} else {
long double a[12] = {z * logl(second) + logl(logl(first)),
second * logl(z) + logl(logl(first)),
logl(second * z * logl(first)),
logl(z * second * logl(first)),
z * logl(first) + logl(logl(second)),
first * logl(z) + logl(logl(second)),
logl(first * z * logl(second)),
logl(z * first * logl(second)),
second * logl(first) + logl(logl(z)),
first * logl(second) + logl(logl(z)),
logl(first * second * logl(z)),
logl(second * first * logl(z))};
if (logl(first) < 1e-8) a[0] = a[1] = a[2] = a[3] = -1e9;
if (logl(second) < 1e-8) a[4] = a[5] = a[6] = a[7] = -1e9;
if (logl(z) < 1e-8) a[8] = a[9] = a[10] = a[11] = -1e9;
long double Max = a[0];
int idx = 0;
for (int i = 1; i < 12; i++) {
if (a[i] > Max) {
Max = a[i];
idx = i;
}
}
printf("%s\n", ans[idx].c_str());
}
return true;
}
int main() {
int t = 1;
00000;
while (t--) solve();
}
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
using namespace std;
long double resposta = -1 * INF;
int mp[3];
bool par = false;
long double calc(long double x, long double y, long double z, bool c) {
if (c) return z * y * log(x);
return pow(y, z) * log(x);
}
void calcula(int *v, map<int, long double> &p, bool c) {
do {
for (int i = 0; i < 3; i++) {
long double x = p.find(v[0])->second;
long double y = p.find(v[1])->second;
long double z = p.find(v[2])->second;
long double resp = calc(x, y, z, c);
if (resp > resposta + 1e-8) {
resposta = resp;
mp[0] = v[0], mp[1] = v[1], mp[2] = v[2];
par = c;
}
}
} while (next_permutation(v, v + 3));
}
int main() {
long double x, y, z;
cin >> x >> y >> z;
map<int, char> m;
m[0] = 'x', m[1] = 'y', m[2] = 'z';
map<int, long double> p;
p[0] = x, p[1] = y, p[2] = z;
int v[] = {0, 1, 2};
calcula(v, p, false);
calcula(v, p, true);
char a, b, c;
a = m.find(mp[0])->second;
b = m.find(mp[1])->second;
c = m.find(mp[2])->second;
if (par) {
printf("(%c^%c)^%c\n", a, b, c);
} else
printf("%c^%c^%c\n", a, b, c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int id[20] = {0, 1, 2};
int neg[20], n2[20];
double a[20], b[20], ans[20];
int cnt = 0;
string fuck[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
struct data {
int x, id;
double y;
bool operator<(const data &b) const {
if (x != b.x) return x < b.x;
if (x) {
return y < b.y || (y == b.y && id < b.id);
}
return y > b.y || (y == b.y && id < b.id);
}
} hehe[20];
void f() {
double temp = log(b[0]);
if (temp < 0) ++neg[cnt], temp *= -1;
ans[cnt++] = log(temp) + b[2] * log(b[1]);
if (cnt % 2 == 0) cnt += 2;
}
void g() {
double temp = b[2] * b[1] * log(b[0]);
if (temp < 0) ++neg[cnt], temp *= -1;
ans[cnt++] = log(temp);
if (cnt % 2 == 0) cnt += 2;
}
int main() {
for (int i = 0; i < 3; ++i) cin >> a[i];
do {
for (int i = 0; i < 3; ++i) b[i] = a[id[i]];
f();
} while (next_permutation(id, id + 3));
cnt = 2;
for (int i = 0; i < 3; ++i) id[i] = i;
do {
for (int i = 0; i < 3; ++i) b[i] = a[id[i]];
g();
} while (next_permutation(id, id + 3));
for (int i = 0; i < 12; ++i)
hehe[i].x = neg[i], hehe[i].y = ans[i], hehe[i].id = i;
sort(hehe, hehe + 12);
cout << fuck[hehe[0].id] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double gen(double x, double y, double z) { return log(log(x)) + z * log(y); }
double gen(double x, double y) { return log(log(x)) + log(y); }
vector<pair<double, string> > genall(double x, double y, double z) {
vector<pair<double, string> > r;
if (x > 1.) {
r.push_back(pair<double, string>(gen(x, y, z), "x^y^z"));
r.push_back(pair<double, string>(gen(x, z, y), "x^z^y"));
r.push_back(pair<double, string>(gen(x, y * z), "(x^y)^z"));
}
if (y > 1.) {
r.push_back(pair<double, string>(gen(y, x, z), "y^x^z"));
r.push_back(pair<double, string>(gen(y, z, x), "y^z^x"));
r.push_back(pair<double, string>(gen(y, x * z), "(y^x)^z"));
}
if (z > 1.) {
r.push_back(pair<double, string>(gen(z, x, y), "z^x^y"));
r.push_back(pair<double, string>(gen(z, y, x), "z^y^x"));
r.push_back(pair<double, string>(gen(z, x * y), "(z^x)^y"));
}
return r;
}
int main() {
double x, y, z;
cin >> x >> y >> z;
if (x <= 1. && y <= 1. && z <= 1.) {
vector<pair<double, string> > r;
if (x == 1.) {
cout << "x^y^z" << endl;
return 0;
}
if (y == 1.) {
cout << "y^x^z" << endl;
return 0;
}
if (z == 1.) {
cout << "z^x^y" << endl;
return 0;
}
auto v1 = genall(1. / x, y, z);
auto v2 = genall(x, 1. / y, z);
auto v3 = genall(x, y, 1. / z);
r.insert(r.end(), v1.begin(), v1.end());
r.insert(r.end(), v2.begin(), v2.end());
r.insert(r.end(), v3.begin(), v3.end());
auto it =
min_element(r.begin(), r.end(),
[](pair<double, string> lhs, pair<double, string> rhs) {
return lhs.first < rhs.first;
});
cout << it->second << endl;
} else {
auto v = genall(x, y, z);
auto it =
max_element(v.begin(), v.end(),
[](pair<double, string> lhs, pair<double, string> rhs) {
return lhs.first < rhs.first;
});
cout << it->second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
string ans[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double x, y, z;
void solve() {
cin >> x >> y >> z;
int index = 0;
if (max(x, max(y, z)) < 1.0 + EPS) {
long double maxi = powl(x, powl(y, z));
if (powl(x, powl(z, y)) > maxi + EPS) {
maxi = powl(x, powl(z, y));
index = 1;
}
if (powl(x, y * z) > maxi + EPS) {
maxi = powl(x, y * z);
index = 2;
}
if (powl(y, powl(x, z)) > maxi + EPS) {
maxi = powl(y, powl(x, z));
index = 4;
}
if (powl(y, powl(z, x)) > maxi + EPS) {
maxi = powl(y, powl(z, x));
index = 5;
}
if (powl(y, x * z) > maxi + EPS) {
maxi = powl(y, x * z);
index = 6;
}
if (powl(z, powl(x, y)) > maxi + EPS) {
maxi = powl(z, powl(x, y));
index = 8;
}
if (powl(z, powl(y, x)) > maxi + EPS) {
maxi = powl(z, powl(y, x));
index = 9;
}
if (powl(z, x * y) > maxi + EPS) {
index = 10;
}
} else {
long double maxi = (x > 1.0 - EPS) ? z * logl(y) + logl(logl(x)) : -1e18;
if (x > 1.0 - EPS && y * logl(z) + logl(logl(x)) > maxi + EPS) {
maxi = y * logl(z) + logl(logl(x));
index = 1;
}
if (x > 1.0 - EPS && logl(y * z) + logl(logl(x)) > maxi + EPS) {
maxi = logl(y * z) + logl(logl(x));
index = 2;
}
if (y > 1.0 - EPS && z * logl(x) + logl(logl(y)) > maxi + EPS) {
maxi = z * logl(x) + logl(logl(y));
index = 4;
}
if (y > 1.0 - EPS && x * logl(z) + logl(logl(y)) > maxi + EPS) {
maxi = x * logl(z) + logl(logl(y));
index = 5;
}
if (y > 1.0 - EPS && logl(x * z) + logl(logl(y)) > maxi + EPS) {
maxi = logl(x * z) + logl(logl(y));
index = 6;
}
if (z > 1.0 - EPS && y * logl(x) + logl(logl(z)) > maxi + EPS) {
maxi = y * logl(x) + logl(logl(z));
index = 8;
}
if (z > 1.0 - EPS && x * logl(y) + logl(logl(z)) > maxi + EPS) {
maxi = x * logl(y) + logl(logl(z));
index = 9;
}
if (z > 1.0 - EPS && logl(x * y) + logl(logl(z)) > maxi + EPS) {
index = 10;
}
}
cout << ans[index] << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char s[12][10] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double a[12];
long double x, y, z;
while (cin >> x >> y >> z) {
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = a[3] = y * z * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = a[7] = x * z * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = a[11] = x * y * log(z);
int pos = 0;
for (int i = 1; i < 12; i++)
if (a[i] > a[pos]) pos = i;
printf("%s\n", s[pos]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[10][10] = {{"x^y^z"}, {"x^z^y"}, {"(x^y)^z"}, {"y^x^z"}, {"y^z^x"},
{"(y^x)^z"}, {"z^x^y"}, {"z^y^x"}, {"(z^x)^y"}};
long double a, b, c, maxn;
int maxi;
inline long double power(long double a, long double b) { return log(a) * b; }
int main() {
cin >> a >> b >> c;
maxn = power(a, pow(b, c)), maxi = 0;
if (power(a, pow(c, b)) > maxn) maxn = power(a, pow(c, b)), maxi = 1;
if (power(a, b * c) > maxn) maxn = power(a, b * c), maxi = 2;
if (power(b, pow(a, c)) > maxn) maxn = power(b, pow(a, c)), maxi = 3;
if (power(b, pow(c, a)) > maxn) maxn = power(b, pow(c, a)), maxi = 4;
if (power(b, a * c) > maxn) maxn = power(b, a * c), maxi = 5;
if (power(c, pow(a, b)) > maxn) maxn = power(c, pow(a, b)), maxi = 6;
if (power(c, pow(b, a)) > maxn) maxn = power(c, pow(b, a)), maxi = 7;
if (power(c, a * b) > maxn) maxn = power(c, a * b), maxi = 8;
printf("%s", ch[maxi]);
}
|
#include <bits/stdc++.h>
using namespace std;
double x, y, z, ans;
int t;
void MAX1(double x, double y, double z, int w) {
if (pow(x, pow(y, z)) > ans + 1e-9) {
ans = pow(x, pow(y, z));
t = w;
}
}
void MAX3(double x, double y, double z, int w) {
if (pow(pow(x, y), z) > ans + 1e-9) {
ans = pow(pow(x, y), z);
t = w;
}
}
void MAX2(double a, double b, double c, int w) {
if (a > 0.95)
if (log(log(a)) + c * log(b) > ans + 1e-9) {
ans = log(log(a)) + c * log(b);
t = w;
}
}
void MAX4(double a, double b, double c, int w) {
if (a > 0.95)
if (log(c) + log(b * log(a)) > ans + 1e-9) {
ans = log(c) + log(b * log(a));
t = w;
}
}
int main() {
scanf("%lf %lf %lf", &x, &y, &z);
ans = -1000000000000.0;
if (x < 1.1 && y < 1.1 && z < 1.1) {
MAX1(x, y, z, 1);
MAX1(x, z, y, 2);
MAX3(x, y, z, 3);
MAX3(x, z, y, 4);
MAX1(y, x, z, 5);
MAX1(y, z, x, 6);
MAX3(y, x, z, 7);
MAX3(y, z, x, 8);
MAX1(z, x, y, 9);
MAX1(z, y, x, 10);
MAX3(z, x, y, 11);
MAX3(z, y, x, 12);
} else {
MAX2(x, y, z, 1);
MAX2(x, z, y, 2);
MAX4(x, y, z, 3);
MAX4(x, z, y, 4);
MAX2(y, x, z, 5);
MAX2(y, z, x, 6);
MAX4(y, x, z, 7);
MAX4(y, z, x, 8);
MAX2(z, x, y, 9);
MAX2(z, y, x, 10);
MAX4(z, x, y, 11);
MAX4(z, y, x, 12);
}
if (t == 1) printf("x^y^z\n");
if (t == 2) printf("x^z^y\n");
if (t == 3) printf("(x^y)^z\n");
if (t == 4) printf("(x^z)^y\n");
if (t == 5) printf("y^x^z\n");
if (t == 6) printf("y^z^x\n");
if (t == 7) printf("(y^x)^z\n");
if (t == 8) printf("(y^z)^x\n");
if (t == 9) printf("z^x^y\n");
if (t == 10) printf("z^y^x\n");
if (t == 11) printf("(z^x)^y\n");
if (t == 12) printf("(z^y)^x\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
return (first < second) ? (first = second, 1) : 0;
}
const double EPS = 1e-6;
map<char, double> values;
bool is_one(double first) { return first > 0.95 && first < 1.05; }
class Info {
public:
int type;
char a, b, c;
Info() {}
Info(char p, char q, char r, int t) { a = p, b = q, c = r, type = t; }
void print() {
if (type == 0) {
printf("%c^%c^%c", a, b, c);
} else {
printf("(%c^%c)^%c", a, b, c);
}
}
double value() {
double first = values[a];
double second = values[b];
double z = values[c];
double res = 0;
double lgx = log(first);
if (first > 1.05) {
res = 1e10;
if (type == 0) {
res += z * log(second) + log(lgx);
} else {
res += log(second * z) + log(lgx);
}
} else {
if (type == 0) {
res += -(z * log(second) + log(-lgx));
} else {
res += -(log(second * z) + log(-lgx));
}
}
return res;
}
bool operator<(Info &o) {
double first = values[a];
double x2 = values[o.a];
if (is_one(first) && is_one(x2)) {
return false;
} else if (is_one(first)) {
if (x2 > 1.05) {
return true;
} else {
return false;
}
} else if (is_one(x2)) {
if (first > 1.05) {
return false;
} else {
return true;
}
} else {
return value() < o.value() - EPS;
}
}
};
vector<Info> forms;
int main() {
double a;
cin >> a;
values['x'] = a;
cin >> a;
values['y'] = a;
cin >> a;
values['z'] = a;
forms.push_back(Info('x', 'y', 'z', 0));
forms.push_back(Info('x', 'z', 'y', 0));
forms.push_back(Info('x', 'y', 'z', 1));
forms.push_back(Info('y', 'x', 'z', 0));
forms.push_back(Info('y', 'z', 'x', 0));
forms.push_back(Info('y', 'x', 'z', 1));
forms.push_back(Info('z', 'x', 'y', 0));
forms.push_back(Info('z', 'y', 'x', 0));
forms.push_back(Info('z', 'x', 'y', 1));
int pick = 0;
for (int i = 1; i < ((int)(forms).size()); i++) {
if (forms[pick] < forms[i]) {
pick = i;
}
}
forms[pick].print();
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void imprimirVector(vector<long long> v) {
if (!v.empty()) {
int p = v.size();
cout << "[";
for (int i = 0; i < (int)(p - 1); i++) cout << v[i] << ",";
cout << v[p - 1] << "]" << endl;
} else
cout << "[]" << endl;
}
long long toNumber(string s) {
long long Number;
if (!(istringstream(s) >> Number)) Number = 0;
return Number;
}
string toString(long long number) {
ostringstream ostr;
ostr << number;
return ostr.str();
}
int main() {
long double x, y, z;
while (cin >> x >> y >> z) {
vector<string> a = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "z^(y^x)"};
vector<long double> ad = {
pow(y, z) * log(x), pow(z, y) * log(x), z * y * log(x), y * z * log(x),
pow(x, z) * log(y), pow(z, x) * log(y), x * z * log(y), z * x * log(y),
pow(x, y) * log(z), pow(y, x) * log(z), x * y * log(z), y * x * log(z)};
long double maxi = -9999999999999999.0, maxiInd = -1;
for (int i = 0; i < (int)(12); i++)
if (ad[i] > maxi) {
maxiInd = i;
maxi = ad[i];
}
cout << a[maxiInd] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const char s[12][15] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
long double t[12], r[12];
int main() {
double tx, ty, tz;
scanf("%lf%lf%lf", &tx, &ty, &tz);
long double x = tx, y = ty, z = tz;
t[0] = z * log(y);
t[1] = y * log(z);
t[2] = t[3] = log(y) + log(z);
t[4] = z * log(x);
t[5] = x * log(z);
t[6] = t[7] = log(x) + log(z);
t[8] = y * log(x);
t[9] = x * log(y);
t[10] = t[11] = log(x) + log(y);
r[0] = r[1] = r[2] = r[3] = log(x);
r[4] = r[5] = r[6] = r[7] = log(y);
r[8] = r[9] = r[10] = r[11] = log(z);
bool flag = 0;
for (int i = 0; i < 12; i++) flag |= (r[i] > 0);
int loc = 11;
if (!flag) {
for (int i = 0; i < 12; i++) r[i] = -r[i];
for (int i = 11; i >= 0; i--)
if (r[i] == 0 || t[i] + log(r[i]) < t[loc] + log(r[loc]) + eps) loc = i;
} else {
for (int i = 11; i >= 0; i--)
if (r[i] > 0) {
loc = i;
break;
}
for (int i = 11; i >= 0; i--)
if (r[i] > 0 && t[i] + log(r[i]) > t[loc] + log(r[loc]) - eps) loc = i;
}
printf("%s", s[loc]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = int(2e6) + 256;
const int INF = int(1e9);
const int mod = (int)(1e9) + 7;
const double pi = 3.1415926535897932384626433832795;
const double eps = (1e-16);
long long n, m, t, ans, a[MaxN];
long double x, y, z;
pair<long double, pair<int, string> > p[40];
bool cmp(pair<long double, pair<int, string> > a,
pair<long double, pair<int, string> > b) {
if (fabs(a.first - b.first) < eps) {
if (a.second.first < b.second.first) return 1;
return 0;
}
if (a.first > b.first) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> x >> y >> z;
p[1] = make_pair(log(x) * pow(y, z), make_pair(1, "x^y^z"));
p[2] = make_pair(log(x) * pow(z, y), make_pair(2, "x^z^y"));
p[3] = make_pair(log(x) * y * z, make_pair(3, "(x^y)^z"));
p[4] = make_pair(log(x) * z * y, make_pair(4, "(x^z)^y"));
p[5] = make_pair(log(y) * pow(x, z), make_pair(5, "y^x^z"));
p[6] = make_pair(log(y) * pow(z, x), make_pair(6, "y^z^x"));
p[7] = make_pair(log(y) * x * z, make_pair(7, "(y^x)^z"));
p[8] = make_pair(log(y) * z * x, make_pair(8, "(y^z)^x"));
p[9] = make_pair(log(z) * pow(x, y), make_pair(9, "z^x^y"));
p[10] = make_pair(log(z) * pow(y, x), make_pair(10, "z^y^x"));
p[11] = make_pair(log(z) * x * y, make_pair(11, "(z^x)^y"));
p[12] = make_pair(log(z) * y * x, make_pair(12, "(z^y)^x"));
sort(p + 1, p + 13, cmp);
cout << p[1].second.second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string out[] = {"x^y^z", "x^z^y", "(x^y)^z", "y^x^z", "y^z^x",
"(y^x)^z", "z^x^y", "z^y^x", "(z^x)^y"};
int main() {
long double a, b, c;
pair<long double, int> ans[12];
cin >> a >> b >> c;
ans[0] = make_pair(-log(a) * pow(b, c), 0);
ans[1] = make_pair(-log(a) * pow(c, b), 1);
ans[2] = make_pair(-log(a) * b * c, 2);
ans[3] = make_pair(-log(b) * pow(a, c), 3);
ans[4] = make_pair(-log(b) * pow(c, a), 4);
ans[5] = make_pair(-log(b) * a * c, 5);
ans[6] = make_pair(-log(c) * pow(a, b), 6);
ans[7] = make_pair(-log(c) * pow(b, a), 7);
ans[8] = make_pair(-log(c) * a * b, 8);
sort(ans, ans + 9);
cout << out[ans[0].second] << endl;
return 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<T> &v) {
for (typename vector<T>::size_type i = 0; i < v.size(); ++i)
out << v[i] << " ";
out << "\n";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, set<T> &s) {
for (auto e : s) out << e << " ";
out << "\n";
return out;
}
template <typename T, typename N>
std::ostream &operator<<(std::ostream &out, pair<T, N> &p) {
out << "(" << p.first << ", " << p.second << ") ";
return out;
}
template <typename T, typename N>
std::ostream &operator<<(std::ostream &out, vector<pair<T, N> > &v) {
for (size_t i = 0; i < v.size(); ++i) cout << v[i];
out << "\n";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<vector<T> > &v) {
for (size_t i = 0; i < v.size(); ++i) {
for (size_t j = 0; j < v[i].size(); ++j) {
out << v[i][j] << " ";
}
out << "\n";
}
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<set<T> > &v) {
for (size_t i = 0; i < v.size(); ++i) {
out << v[i];
}
out << "\n";
return out;
}
void solve() {
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (n == 4 || k < n + 1) {
cout << "-1\n";
return;
}
cout << a << " " << c << " ";
vector<int> middle_vertices;
for (int i = 1; i <= n; ++i) {
if (i != a && i != b && i != c && i != d) {
cout << i << " ";
}
}
cout << d << " " << b << "\n";
cout << c << " " << a << " ";
for (int i = 1; i <= n; ++i) {
if (i != a && i != b && i != c && i != d) {
cout << i << " ";
}
}
cout << b << " " << d << "\n";
return;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, k, a, b, c, d, p;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
cin >> a >> b >> c >> d;
p = (n * (n - 1)) / 2;
p -= 2;
if (n == 4) {
cout << -1;
return 0;
}
if (k < n + 1) {
cout << -1;
return 0;
}
if (k > p) {
cout << -1;
return 0;
}
cout << a << " " << c << " ";
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << b << " " << d << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int MOD = 1000000007;
signed main() {
cin.tie(0), cout.tie(0);
ios::sync_with_stdio(0);
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (k < n + 1 || n <= 4)
cout << -1 << '\n', exit(0);
else {
cout << a << ' ' << c << ' ';
for (int i = 1; i <= n; i++)
if (i != a && i != b && i != c && i != d) cout << i << ' ';
cout << d << ' ' << b << '\n';
cout << c << ' ' << a << ' ';
for (int i = 1; i <= n; i++)
if (i != a && i != b && i != c && i != d) cout << i << ' ';
cout << b << ' ' << d << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
int p[1010];
int select(int v, int n) {
for (int i = 1; i <= n; ++i) {
if (p[i] == v) return i;
}
return -1;
}
int main() {
int n, k;
int s1, e1, s2, e2;
while (~scanf("%d%d", &n, &k)) {
scanf("%d%d%d%d", &s1, &e1, &s2, &e2);
if (n < 5 || k < n + 1) {
puts("-1");
continue;
}
for (int i = 1; i <= n; ++i) {
p[i] = i;
}
if (e1 != 1) {
std::swap(p[1], p[s1]);
std::swap(p[n], p[e1]);
} else {
std::swap(p[n], p[e1]);
std::swap(p[1], p[s1]);
}
int pc = select(s2, n);
std::swap(p[2], p[pc]);
int pd = select(e2, n);
std::swap(p[n - 1], p[pd]);
for (int i = 1; i <= n; ++i) {
if (i > 1) printf(" ");
printf("%d", p[i]);
}
printf("\n");
printf("%d ", p[2]);
for (int i = 1; i <= n; ++i) {
if (i != 2 && i != n - 1) printf("%d ", p[i]);
}
printf("%d\n", p[n - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, c, d, v[1010];
void init() {
scanf("%d%d", &n, &k);
scanf("%d%d%d%d", &a, &b, &c, &d);
}
void solve() {
if (k < n + 1 || n <= 4) {
printf("-1\n");
return;
}
for (int i = 3, j = 1; i <= n - 2; i++, j++) {
if (j != a && j != b && j != c && j != d)
v[i] = j;
else
i--;
}
v[1] = a;
v[2] = c;
v[n - 1] = d;
v[n] = b;
for (int i = 1; i <= n; i++) printf("%d ", v[i]);
printf("\n");
printf("%d %d ", v[2], v[1]);
for (int i = 3; i <= n - 2; i++) printf("%d ", v[i]);
printf("%d %d\n", v[n], v[n - 1]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const long long MOD = 1E9 + 7;
const long long N = 1e3 + 15;
const int maxn = 5e5 + 15;
const int letter = 130;
const int INF = 1e17;
const double pi = acos(-1.0);
const double eps = 1e-10;
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, k, p[N];
int a, b, c, d;
int main() {
scanf("%d%d", &n, &k);
scanf("%d%d%d%d", &a, &b, &c, &d);
p[a] = p[b] = p[c] = p[d] = 1;
if (n < 5 || k < n + 1) {
puts("-1");
return 0;
}
if (n == 5) {
for (int i = 1; i <= n; i++) {
if (!p[i]) {
printf("%d %d %d %d %d\n", a, c, i, d, b);
printf("%d %d %d %d %d\n", c, a, i, b, d);
return 0;
}
}
}
printf("%d %d ", a, c);
for (int i = 1; i <= n; i++) {
if (!p[i]) printf("%d ", i);
}
printf("%d %d\n", d, b);
printf("%d %d ", c, a);
for (int i = 1; i <= n; i++) {
if (!p[i]) printf("%d ", i);
}
printf("%d %d\n", b, d);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
void print() {
set<int> s;
s.clear();
for (int i = 1; i <= n; i++) s.insert(i);
s.erase(a);
s.erase(b);
s.erase(c);
s.erase(d);
for (int i : s) {
cout << i << " ";
}
}
int main() {
int k;
cin >> n >> k;
cin >> a >> b >> c >> d;
if (n == 4) {
cout << -1;
return 0;
}
if (k <= n) {
cout << -1;
return 0;
}
cout << a << " " << c << " ";
print();
cout << d << " " << b << endl;
cout << c << " " << a << " ";
print();
cout << b << " " << d << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a, b, c, d;
int s[1010];
int main() {
cin >> n >> k;
cin >> a >> b >> c >> d;
s[a] = 1;
s[b] = 1;
s[c] = 1;
s[d] = 1;
if (n == 4)
cout << -1;
else {
if (k < n + 1)
cout << -1;
else {
cout << a << " " << c << " ";
for (int i = 1; i <= n; i++)
if (s[i] == 0) cout << i << " ";
cout << d << " " << b << "\n";
cout << c << " " << a << " ";
for (int i = 1; i <= n; i++)
if (s[i] == 0) cout << i << " ";
cout << b << " " << d << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a, b, c, d;
vector<int> w;
int main() {
scanf("%d%d", &n, &m);
scanf("%d%d%d%d", &a, &b, &c, &d);
if (n == 4 || m == n - 1 || m == n) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) {
if (i == a || i == b || i == c || i == d) continue;
w.push_back(i);
}
printf("%d %d ", a, c);
for (int x : w) printf("%d ", x);
printf("%d %d\n", d, b);
printf("%d %d ", c, a);
for (int x : w) printf("%d ", x);
printf("%d %d\n", b, d);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b, c, d, vis[1001];
cin >> n >> k;
cin >> a >> b >> c >> d;
memset(vis, 0, sizeof(vis));
if (n == 4 || k < n + 1) {
cout << "-1";
} else {
vector<int> g1, g2;
g1.push_back(a);
g1.push_back(c);
g2.push_back(c);
g2.push_back(a);
vis[a] = vis[c] = 1;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0 && i != b && i != d) {
g1.push_back(i);
g2.push_back(i);
vis[i] = 1;
}
}
g1.push_back(d);
g1.push_back(b);
g2.push_back(b);
g2.push_back(d);
for (int i = 0; i < n; i++) {
cout << g1[i] << " ";
}
cout << endl;
for (int i = 0; i < n; i++) {
cout << g2[i] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, a, b, c, d;
cin >> N >> K >> a >> b >> c >> d;
if (K < N + 1 || N == 4) {
cout << -1 << endl;
return 0;
}
set<int> Set;
for (int i = 0; i < N; ++i) {
Set.insert(i + 1);
}
Set.erase(a);
Set.erase(b);
Set.erase(c);
Set.erase(d);
cout << a << ' ' << c << ' ';
for (auto elem : Set) {
cout << elem << ' ';
}
cout << d << ' ' << b << endl;
cout << c << ' ' << a << ' ';
for (auto elem : Set) {
cout << elem << ' ';
}
cout << b << ' ' << d << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int p1[2000];
int p2[2000];
set<int> ss;
int main() {
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (n == 4 || k <= n) {
cout << -1;
return 0;
}
for (int i = 1; i <= n; i++) {
if (i == a || i == b || i == c || i == d) continue;
ss.insert(i);
}
p1[a] = c;
p1[c] = *ss.begin();
set<int>::iterator it;
set<int>::iterator it0;
set<int>::iterator it1;
it = ss.begin();
it0 = ss.begin();
it++;
for (; it != ss.end(); it++) {
p1[*it0] = *it;
it0++;
}
it1 = ss.end();
it1--;
p1[*it1] = d;
p1[d] = b;
p2[c] = a;
p2[a] = *ss.begin();
it = ss.begin();
it0 = ss.begin();
it++;
for (; it != ss.end(); it++) {
p2[*it0] = *it;
it0++;
}
it1 = ss.end();
it1--;
p2[*it1] = b;
p2[b] = d;
int x = a;
printf("%d ", x);
while (x != b) {
x = p1[x];
printf("%d ", x);
}
cout << endl;
x = c;
printf("%d ", x);
while (x != d) {
x = p2[x];
printf("%d ", x);
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, k;
scanf("%d%d", &n, &k);
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
if ((k < n + 1) || (n == 4)) {
printf("-1\n");
} else {
printf("%d %d ", a, c);
for (int i = 1; i <= n; i++) {
if ((i != a) && (i != b) && (i != c) && (i != d)) {
printf("%d ", i);
}
}
printf("%d %d\n", d, b);
printf("%d %d ", c, a);
for (int i = 1; i <= n; i++) {
if ((i != a) && (i != b) && (i != c) && (i != d)) {
printf("%d ", i);
}
}
printf("%d %d\n", b, d);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
if (k == n - 1) {
printf("-1");
return 0;
}
if (k == n) {
printf("-1");
return 0;
}
if (n == 4) {
printf("-1");
return 0;
}
int ans[n];
ans[0] = a;
ans[1] = c;
ans[n - 1] = b;
ans[n - 2] = d;
int j = 2;
for (int i = 1; i <= n; i++) {
if (i == a || i == b || i == c || i == d) continue;
ans[j] = i;
j++;
}
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
printf("%d ", ans[1]);
printf("%d ", ans[0]);
for (int i = 2; i < n - 2; i++) printf("%d ", ans[i]);
printf("%d ", ans[n - 1]);
printf("%d ", ans[n - 2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 222222;
int n, k;
int a, b, c, d;
int main(int argc, char const *argv[]) {
scanf("%d%d", &(n), &(k));
scanf("%d%d", &(a), &(b));
scanf("%d%d", &(c), &(d));
if (n == 4 || k < n + 1) {
puts("-1");
return 0;
}
vector<int> v;
for (int i = 1; i <= n; ++i) {
if (i != a && i != b && i != c && i != d) {
v.push_back(i);
}
}
printf("%d %d ", a, c);
for (int(i) = 0; i < (int)(((int)(v).size())); ++(i)) printf("%d ", v[i]);
printf("%d %d\n", d, b);
printf("%d %d ", c, a);
for (int(i) = 0; i < (int)(((int)(v).size())); ++(i)) printf("%d ", v[i]);
printf("%d %d\n", b, d);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, A, B, C, D, N;
int main() {
cin >> n >> m >> A >> B >> C >> D;
N = n - 4;
if (n > 4) {
if (m < 6 + N - 1) {
puts("-1");
exit(0);
} else {
cout << A << " " << C << " ";
for (int i = 1; i <= n; ++i) {
if (i != A && i != B && i != C && i != D) {
cout << i << " ";
}
}
cout << D << " " << B << "\n";
cout << C << " " << A << " ";
for (int i = 1; i <= n; ++i) {
if (i != A && i != B && i != C && i != D) {
cout << i << " ";
}
}
cout << B << " " << D << "\n";
}
} else {
puts("-1");
exit(0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b, c, d;
cin >> n >> k;
cin >> a >> b >> c >> d;
if (n == 4 || k < n + 1)
cout << -1 << endl;
else {
cout << a << " " << c << " ";
for (int i = (1); i < (n + 1); i++) {
if (i == a || i == b || i == c || i == d)
continue;
else
cout << i << " ";
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (int i = (1); i < (n + 1); i++) {
if (i == a || i == b || i == c || i == d)
continue;
else
cout << i << " ";
}
cout << b << " " << d << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
void solve() {
long long n, k;
cin >> n >> k;
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (n == 4) {
cout << -1;
return;
}
if (n > 4 && k < n + 1) {
cout << -1;
return;
}
cout << a << " " << c << " ";
for (long long i = 1; i < 1 + n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (long long i = 1; i < 1 + n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << b << " " << d;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b, c, d;
cin >> n >> k;
int vis[n + 1];
memset(vis, 0, sizeof(vis));
cin >> a >> b >> c >> d;
vis[a]++;
vis[b]++;
vis[c]++;
vis[d]++;
if (k <= n || n == 4)
cout << "-1\n";
else {
int temp = n - 4;
cout << a << " " << c << " ";
int x = 1;
while (temp) {
if (!vis[x]) {
cout << x << " ";
temp--;
}
x++;
}
cout << d << " " << b << "\n";
temp = n - 4;
cout << c << " " << a << " ";
x = 1;
while (temp) {
if (!vis[x]) {
cout << x << " ";
temp--;
}
x++;
}
cout << b << " " << d << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
int n, k;
vector<int> res;
int a, b, c, d;
bool used[MAXN];
int main() {
cin >> n >> k;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
if (k <= n || n == 4) {
cout << -1;
return 0;
}
res.resize(n);
res[n - 1] = b;
res[0] = a;
res[n - 2] = d;
res[1] = c;
used[a] = used[b] = used[c] = used[d] = true;
int ptr = 2;
for (int i = 0; i < (int)(n); ++i) {
if (!used[i]) res[ptr++] = i;
}
for (int i = 0; i < (int)(n); ++i) cout << res[i] + 1 << ' ';
cout << '\n';
swap(res[0], res[1]);
swap(res[n - 1], res[n - 2]);
for (int i = 0; i < (int)(n); ++i) cout << res[i] + 1 << ' ';
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (n == 4) {
cout << -1;
return 0;
}
if (n >= m) {
cout << -1;
return 0;
}
long long i;
cout << a << " " << c << " ";
for (i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << b << " " << d << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lim = 1e5 + 5;
long long mod = 1e9 + 7;
void solve() {
long long n, k;
cin >> n >> k;
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (n == 4 || k < n + 1) {
cout << -1 << endl;
return;
}
cout << a << " " << c << " ";
vector<long long> v;
for (long long i = 1; i < (long long)n + 1; i++) {
if (v.size() == 1) {
cout << d << " ";
v.push_back(d);
i--;
} else if (i != a && i != b && i != c && i != d) {
cout << i << " ";
v.push_back(i);
}
}
if (v.size() == 1) {
cout << d << " ";
v.push_back(d);
}
cout << b << " ";
v.push_back(b);
cout << "\n";
;
cout << c << " " << a << " " << v[0] << " ";
reverse(v.begin(), v.end());
for (long long i = 0; i < (long long)v.size() - 1; i++) {
cout << v[i] << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long test = 1;
while (test--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int a, b, c, d;
cin >> n >> k;
cin >> a >> b >> c >> d;
if (n == 4 || k < n + 1) {
cout << -1 << endl;
return 0;
}
vector<int> l{a, c}, r{b};
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) r.push_back(i);
}
r.push_back(d);
cout << a << " " << c << " ";
for (size_t i = 0; i < r.size(); i++) {
cout << r[(i + 1) % r.size()] << " ";
}
cout << endl;
cout << c << " " << a << " ";
for (size_t i = 0; i < r.size(); i++) {
cout << r[(r.size() - 2 - i + r.size()) % r.size()] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k <= n || n <= 4) {
cout << -1;
return 0;
}
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << a << " " << c << " ";
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << b << " " << d;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long N = 1e6 + 10;
long long dr[4] = {0, 0, 1, -1};
long long dc[4] = {1, -1, 0, 0};
long long ddr[8] = {0, 0, 1, -1, 1, -1, 1, -1};
long long ddc[8] = {1, -1, 0, 0, 1, -1, -1, 1};
long long ddr1[8] = {1, 1, -1, -1, 2, 2, -2, -2};
long long ddc1[8] = {2, -2, 2, -2, 1, -1, 1, -1};
int32_t main() {
fast();
long long n, k;
cin >> n >> k;
long long a, b, c, d;
cin >> a >> b >> c >> d;
vector<long long> v;
v.emplace_back(a);
v.emplace_back(c);
for (long long i = 1; i < n + 1; i++) {
if (i == a || i == b || i == c || i == d) continue;
v.emplace_back(i);
}
v.emplace_back(d);
v.emplace_back(b);
if (k > n && n > 4) {
for (auto i : v) cout << i << " ";
cout << "\n";
swap(v[0], v[1]);
swap(v[n - 1], v[n - 2]);
for (auto i : v) cout << i << " ";
cout << "\n";
} else
cout << "-1\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
const long long int MOD = 1e9 + 7;
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
struct custom {
bool operator()(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) const {
if (p1.first == p2.first) return p2.second < p1.second;
return p1.first < p2.first;
}
};
long long int get_pow(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const long long int N = 5e5 + 2, inf = 4e18;
void solve() {
long long int n, k;
cin >> n >> k;
if (k < n + 1 || n < 5) {
cout << -1;
exit(0);
}
long long int a, b, c, d;
cin >> a >> b >> c >> d;
vector<long long> v(n, -1);
v[0] = a;
v[1] = c;
v[n - 1] = d;
v[n - 2] = b;
int up = 2;
for (long long int i = (long long int)1; i < (long long int)(n + 1); i++) {
if (i == a || i == b || i == c || i == d) continue;
v[up] = i;
up++;
}
for (long long int i = (long long int)0; i < (long long int)(n - 2); i++)
cout << v[i] << ' ';
cout << d << ' ' << b << '\n';
cout << v[1] << ' ' << v[0] << ' ';
for (long long int i = (long long int)2; i < (long long int)(n); i++)
cout << v[i] << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
clock_t z = clock();
for (long long int tes = (long long int)0; tes < (long long int)(test);
tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (k < n + 1 || n < 5) {
cout << -1;
return 0;
}
vector<int> ans(n);
ans[0] = a;
ans[n - 1] = b;
ans[1] = c;
ans[n - 2] = d;
int j = 1;
unordered_set<int> S{a, b, c, d};
for (int i = 2; i < n - 2; ++i) {
while (S.find(j) != S.end()) ++j;
ans[i] = j;
++j;
}
for (int i = 0; i < n; ++i) cout << ans[i] << " ";
cout << endl;
swap(ans[0], ans[1]);
swap(ans[n - 2], ans[n - 1]);
for (int i = 0; i < n; ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[10000];
int main() {
int n, k, a, b, c, d;
cin >> n >> k;
cin >> a >> b >> c >> d;
if (k <= n || n == 4) {
cout << -1;
return 0;
}
for (int i = 0, num = 1; i < n - 4; i++, num++) {
while (num == a || num == b || num == c || num == d) num++;
ans[i] = num;
}
cout << a << " " << c << " ";
for (int i = 0; i < n - 4; i++) {
cout << ans[i] << " ";
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (int i = 0; i < n - 4; i++) {
cout << ans[i] << " ";
}
cout << b << " " << d;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned;
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vvd = vector<vd>;
using vs = vector<string>;
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename Tuple>
void print_tuple(ostream&, const Tuple&) {}
template <typename Car, typename... Cdr, typename Tuple>
void print_tuple(ostream& os, const Tuple& t) {
print_tuple<Cdr...>(os, t);
os << (sizeof...(Cdr) ? "," : "") << get<sizeof...(Cdr)>(t);
}
template <typename... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
print_tuple<Args...>(os << '(', t);
return os << ')';
}
template <typename Ch, typename Tr, typename C>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os, const C& c) {
os << '[';
for (auto i = begin(c); i != end(c); ++i)
os << (i == begin(c) ? "" : " ") << *i;
return os << ']';
}
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
int main() {
for (int n, m, a, b, c, d; cin >> n >> m >> a >> b >> c >> d && n | m;) {
if (n == 4) {
cout << -1 << endl;
} else {
if (m < n + 1) {
cout << -1 << endl;
continue;
}
vi vs;
for (int i = int(0); i < int(n); i++)
if (!set<int>{a, b, c, d}.count(i + 1)) vs.push_back(i + 1);
cout << a << ' ' << c << ' ';
for (int v : vs) cout << v << ' ';
cout << d << ' ' << b << endl;
cout << c << ' ' << a << ' ';
for (int v : vs) cout << v << ' ';
cout << b << ' ' << d << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (k > n && n > 4 && k >= 6) {
vector<int> path;
path.push_back(a);
path.push_back(c);
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) path.push_back(i);
}
path.push_back(d);
path.push_back(b);
if (path.size() > k) {
cout << -1;
exit(0);
}
for (int i = 0; i < n; i++) {
cout << path[i] << ' ';
}
cout << '\n';
path.clear();
path.push_back(c);
path.push_back(a);
for (int i = 1; i <= n; i++) {
if (i != c && i != d && i != a && i != b) path.push_back(i);
}
path.push_back(b);
path.push_back(d);
for (int i = 0; i < n; i++) {
cout << path[i] << ' ';
}
} else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (k < n + 1 || n == 4) {
cout << -1;
return 0;
}
int cur = 1;
vector<int> v;
while (cur == a || cur == b || cur == c || cur == d) cur++;
cout << a << ' ' << c << ' ' << cur << ' ' << d << ' ';
cur++;
for (; cur <= n; cur++) {
while (cur == a || cur == b || cur == c || cur == d) cur++;
if (cur > n) break;
cout << cur << ' ';
v.push_back(cur);
}
cout << b << '\n';
cur = 1;
while (cur == a || cur == b || cur == c || cur == d) cur++;
cout << c << ' ' << a << ' ' << cur << ' ' << b << ' ';
for (int i = v.size() - 1; i >= 0; i--) {
cout << v[i] << ' ';
}
cout << d << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &x) {
s << "[";
for (auto it : x) {
s << it << ", ";
}
s << "]";
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const set<T> &x) {
s << "{";
for (auto it : x) {
s << it << ", ";
}
s << "}";
return s;
}
template <typename U, typename V>
ostream &operator<<(ostream &s, const pair<U, V> &x) {
s << "(" << x.first << ", " << x.second << ")";
return s;
}
template <typename T>
bool chmax(T &x, const T &y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <typename T>
bool chmin(T &x, const T &y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
int n, k;
cin >> n >> k;
if (n == 4 || k < n + 1) {
cout << -1 << "\n";
return 0;
}
int a, b, c, d;
cin >> a >> b >> c >> d;
set<int> used = {a, b, c, d};
vector<int> line;
for (int i = 1; i <= n; i++) {
if (used.count(i) == 0) {
line.push_back(i);
}
}
cout << a << " " << c << " ";
for (auto x : line) cout << x << " ";
cout << d << " " << b << "\n";
cout << c << " " << a << " ";
for (auto x : line) cout << x << " ";
cout << b << " " << d << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
int used[MAXN];
int main() {
int n, k, a[4];
scanf("%d%d%d%d%d%d", &n, &k, &a[0], &a[1], &a[2], &a[3]);
if (n == 4 || k < n + 1) {
puts("-1");
return 0;
}
for (int i = 0; (i) < (4); ++i) a[i]--, used[a[i]] = 1;
printf("%d %d ", a[0] + 1, a[2] + 1);
for (int i = 0; (i) < (n); ++i)
if (!used[i]) printf("%d ", i + 1);
printf("%d %d ", a[3] + 1, a[1] + 1);
puts("");
printf("%d %d ", a[2] + 1, a[0] + 1);
for (int i = 0; (i) < (n); ++i)
if (!used[i]) printf("%d ", i + 1);
printf("%d %d ", a[1] + 1, a[3] + 1);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (k <= n || n == 4) {
cout << -1 << endl;
return 0;
}
vector<int> v;
v.push_back(a);
v.push_back(c);
for (int i = 1; i <= n; ++i) {
if (i == a || i == c || i == d || i == b) {
continue;
}
v.push_back(i);
}
v.push_back(d);
v.push_back(b);
for (int x : v) {
cout << x << " ";
}
cout << endl;
cout << v[1] << " " << v[0] << " " << v[2] << " ";
for (int i = 3; i < n - 2; ++i) {
cout << v[i] << " ";
}
cout << v[n - 1] << " " << v[n - 2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1e3 + 5;
bool used[maxn];
int n, k, a, b, c, d;
int main() {
scanf("%d %d", &n, &k);
scanf("%d %d %d %d", &a, &b, &c, &d);
if (n <= 4 or k < n + 1) {
puts("-1");
return 0;
}
used[a] = used[b] = used[c] = used[d] = true;
vector<int> path = {a, c};
for (int i = 1; i <= n; i++)
if (!used[i]) path.emplace_back(i);
path.insert(path.end(), {d, b});
for (int i = 0; i < n; i++) printf("%d%c", path[i], " \n"[i + 1 == n]);
printf("%d %d ", path[1], path[0]);
for (int i = 2; i < n - 2; i++) printf("%d ", path[i]);
printf("%d %d\n", path[n - 1], path[n - 2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<T> &v) {
for (typename vector<T>::size_type i = 0; i < v.size(); ++i)
out << v[i] << " ";
out << "\n";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, set<T> &s) {
for (auto e : s) out << e << " ";
out << "\n";
return out;
}
template <typename T, typename N>
std::ostream &operator<<(std::ostream &out, pair<T, N> &p) {
out << "(" << p.first << ", " << p.second << ") ";
return out;
}
template <typename T, typename N>
std::ostream &operator<<(std::ostream &out, vector<pair<T, N> > &v) {
for (size_t i = 0; i < v.size(); ++i) cout << v[i];
out << "\n";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<vector<T> > &v) {
for (size_t i = 0; i < v.size(); ++i) {
for (size_t j = 0; j < v[i].size(); ++j) {
out << v[i][j] << " ";
}
out << "\n";
}
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<set<T> > &v) {
for (size_t i = 0; i < v.size(); ++i) {
out << v[i];
}
out << "\n";
return out;
}
void solve() {
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
if (n == 4 || k < n + 1) {
cout << "-1\n";
return;
}
cout << a << " " << c << " ";
for (int i = 1; i <= n; ++i) {
if (i != a && i != b && i != c && i != d) {
cout << i << " ";
}
}
cout << d << " " << b << "\n";
cout << c << " " << a << " ";
for (int i = 1; i <= n; ++i) {
if (i != a && i != b && i != c && i != d) {
cout << i << " ";
}
}
cout << b << " " << d << "\n";
return;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b, c, d;
cin >> n >> k >> a >> b >> c >> d;
if (k < n + 1 || n == 4) {
cout << -1 << endl;
} else {
cout << a << " " << c << " ";
for (int v = 1; v <= n; v++) {
if (v != a && v != b && v != c && v != d) {
cout << v << " ";
}
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (int v = 1; v <= n; v++) {
if (v != a && v != b && v != c && v != d) {
cout << v << " ";
}
}
cout << b << " " << d << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long N = 1010;
long long v[N], n, k, a, b, c, d;
vector<long long> u;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> a >> b >> c >> d;
if (k < n + 1 || n <= 4) {
cout << -1;
return 0;
}
for (int i = 1; i <= n; i++)
if (i != a && i != b && i != c && i != d) u.push_back(i);
v[1] = a;
v[2] = c;
v[n - 1] = d;
v[n] = b;
for (int i = 3; i <= n - 2; i++) v[i] = u[i - 3];
for (int i = 1; i <= n; i++) cout << v[i] << " ";
cout << endl;
swap(v[1], v[2]);
swap(v[n - 1], v[n]);
for (int i = 1; i <= n; i++) cout << v[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
int a, b, c, d;
cin >> n >> k;
cin >> a >> b >> c >> d;
if (n == 4 || (n >= 5 && k <= n)) return cout << -1, 0;
vector<int> vec;
for (int i = 1; i <= n; i++)
if (i != a && i != b && i != c && i != d) vec.push_back(i);
cout << a << " " << d << " ";
for (auto x : vec) cout << x << " ";
cout << c << " " << b << '\n';
reverse(vec.begin(), vec.end());
cout << c << " " << b << " ";
for (auto x : vec) cout << x << " ";
cout << a << " " << d << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
int a, b, c, d;
cin >> a >> b >> c >> d;
vector<int> x;
for (int i = 1; i <= n; i++) {
if (i == a or i == b or i == c or i == d) continue;
x.push_back(i);
}
if (x.empty()) {
cout << -1 << '\n';
return (0);
}
set<pair<int, int> > edges;
auto add_edge = [&](int u, int v) {
edges.insert(pair<int, int>(min(u, v), max(u, v)));
};
vector<int> p1;
p1.push_back(a);
p1.push_back(c);
for (int xi : x) p1.push_back(xi);
p1.push_back(d);
p1.push_back(b);
vector<int> p2;
p2.push_back(c);
p2.push_back(a);
for (int xi : x) p2.push_back(xi);
p2.push_back(b);
p2.push_back(d);
for (int i = 1; i < int(p1.size()); i++) {
add_edge(p1[i - 1], p1[i]);
add_edge(p2[i - 1], p2[i]);
}
if (int(edges.size()) > k) {
cout << -1 << '\n';
return (0);
}
for (int i = 0; i < int(p1.size()); i++) {
cout << p1[i] << " \n"[i == int(p1.size()) - 1];
}
for (int i = 0; i < int(p2.size()); i++) {
cout << p2[i] << " \n"[i == int(p2.size()) - 1];
}
return (0);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160")
using namespace std;
const int INF = 1e9 + 10;
const long long LINF = (long long)2e18 + 10;
const long double PI = acos(-1);
const long double eps = 1e-8;
const long double EPS = 1e-12;
int n, k;
int a, b, c, d;
void solve() {
scanf("%d%d", &n, &k);
scanf("%d%d%d%d", &a, &b, &c, &d);
if (k == n - 1 || k == n || n == 4) {
printf("-1");
return;
}
printf("%d %d ", a, c);
for (int i = 1; i <= n; ++i)
if (i != a && i != b && i != c && i != d) printf("%d ", i);
printf("%d %d\n", d, b);
printf("%d %d ", c, a);
for (int i = 1; i <= n; ++i)
if (i != a && i != b && i != c && i != d) printf("%d ", i);
printf("%d %d\n", b, d);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T v) {
cerr << v << " ";
return *this;
}
} dbg;
int vis[10000];
int line[10000];
int main() {
int n, m;
int a, b, c, d;
cin >> n >> m;
cin >> a >> b >> c >> d;
if (m < n + 1 || n < 5) {
cout << -1 << "\n";
return 0;
}
line[1] = a;
line[n] = b;
line[2] = c;
line[n - 1] = d;
vis[a] = 1;
vis[b] = 1;
vis[c] = 1;
vis[d] = 1;
int idx = 3;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
line[idx++] = i;
vis[i] = 1;
}
for (int i = 1; i <= n; ++i) {
cout << line[i] << " ";
}
cout << "\n";
cout << c << " " << a;
for (int i = n - 2; i > 2; --i) cout << " " << line[i];
cout << " " << b << " " << d << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using D = double;
using uint = unsigned int;
vector<int> answer;
int n, k, a, b, c, d;
int main() {
scanf("%d%d", &n, &k);
scanf("%d%d%d%d", &a, &b, &c, &d);
if (k == n - 1 || k == n || n == 4) {
cout << -1 << endl;
return 0;
}
answer.push_back(a);
answer.push_back(d);
for (int i = 1; i <= n; i++)
if (i != a && i != b && i != c && i != d) answer.push_back(i);
answer.push_back(c);
answer.push_back(b);
for (int i = 0; i < n; i++) printf("%d ", answer[i]);
printf("\n");
for (int i = n - 2; i < n; i++) printf("%d ", answer[i]);
for (int i = n - 3; i > 1; i--) printf("%d ", answer[i]);
for (int i = 0; i < 2; i++) printf("%d ", answer[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, c, d;
int main() {
cin >> n >> m >> a >> b >> c >> d;
if (m < n + 1 || n == 4) {
cout << -1;
return 0;
}
cout << a << " " << c << " ";
for (int i = 1; i < n + 1; i++) {
if (i != a and i != b and i != c and i != d) {
cout << i << " ";
}
}
cout << d << " " << b << "\n";
cout << c << " " << a << " ";
for (int i = 1; i < n + 1; i++) {
if (i != a and i != b and i != c and i != d) {
cout << i << " ";
}
}
cout << b << " " << d;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.