text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int rev(int x) {
int y = 0;
while (x) {
y = y * 10 + x % 10;
x /= 10;
}
return y;
}
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
pair<int, int> fx(int x) {
int g = gcd(x, rev(x));
return make_pair(x / g, rev(x) / g);
}
pair<int, int> fy(int x) {
int g = gcd(x, rev(x));
return make_pair(rev(x) / g, x / g);
}
map<pair<int, int>, int> mx;
map<pair<int, int>, int> my;
int main() {
int maxx, maxy, w;
scanf("%d %d %d", &maxx, &maxy, &w);
mx.clear();
my.clear();
int ansx, ansy;
ansx = ansy = -1;
for (int y = 1; y <= maxy; y++) my[fy(y)]++;
int total = 0;
int y = maxy;
for (int x = 1; x <= maxx; x++) {
total += my[fx(x)];
mx[fx(x)]++;
while (y > 1 && total >= w) {
int add = mx[fy(y)];
if (total - add < w) break;
my[fy(y)]--;
total -= add;
y--;
}
if (total >= w) {
if (ansx == -1) {
ansx = x;
ansy = y;
} else if (x * y < ansx * ansy) {
ansx = x;
ansy = y;
}
}
}
if (ansx == -1)
printf("-1\n");
else
printf("%d %d\n", ansx, ansy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double mul = 1e9;
long long n, m, w, ans, ansx, ansy;
map<long long, long long> a, b;
long long Rev(long long x) {
long long res = 0;
while (x) {
res = res * 10 + x % 10;
x /= 10;
}
return res;
}
signed main() {
cin >> n >> m >> w;
ans = n * m + 1;
{
long long i = 0, j = m, now = 0;
for (long long o = 1; o <= m; ++o) {
long long tmp = round(mul * Rev(o) / o);
if (b.find(tmp) != b.end())
++b[tmp];
else
b[tmp] = 1;
}
while (i <= n && j >= 1) {
if (now < w) {
++i;
long long tmp = round(mul * i / Rev(i));
if (a.find(tmp) != a.end())
++a[tmp];
else
a[tmp] = 1;
if (b.find(tmp) != b.end()) now += b[tmp];
} else {
if (ans > i * j) {
ans = i * j;
ansx = i;
ansy = j;
}
long long tmp = round(mul * Rev(j) / j);
if (a.find(tmp) != a.end()) now -= a[tmp];
--b[tmp];
--j;
}
}
}
if (ans == n * m + 1) {
puts("-1");
} else {
cout << ansx << " " << ansy << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int totalCases, testNum;
int rev[100001];
pair<int, int> aByRevA[100001];
map<int, int> pf[100001];
set<pair<int, int> > validwRank[100001];
map<pair<int, int>, vector<int> > mymap;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int reverse(int n) {
int ret = 0;
while (n > 0) {
ret = ret * 10 + (n % 10);
n /= 10;
}
return ret;
}
void preprocess() {
for (int i = 1; i <= 100000; i++) rev[i] = reverse(i);
aByRevA[1] = make_pair(1, 1);
mymap[make_pair(1, 1)].push_back(1);
for (int a = 2; a <= 100000; a++) {
int reva = rev[a];
int g = gcd(a, reva);
pair<int, int> arg = make_pair(a / g, reva / g);
aByRevA[a] = arg;
mymap[arg].push_back(a);
}
}
int mx, my, w;
bool input() {
scanf("%d", &mx);
scanf("%d", &my);
scanf("%d", &w);
return true;
}
void solve() {
long long bestx, besty;
bestx = mx + 1;
besty = my + 1;
long long found = 0;
long long x, y;
pair<int, int> argx, argy;
y = my;
for (x = 1; x <= mx; x++) {
argx = aByRevA[x];
argy = make_pair(argx.second, argx.first);
int now = upper_bound(mymap[argy].begin(), mymap[argy].end(), y) -
mymap[argy].begin();
found += now;
while (found >= w) {
if (x * y < bestx * besty) {
bestx = x;
besty = y;
}
argy = aByRevA[y];
argx = make_pair(argy.second, argy.first);
now = upper_bound(mymap[argx].begin(), mymap[argx].end(), x) -
mymap[argx].begin();
found -= now;
y--;
}
}
if (bestx > mx) {
cout << -1 << endl;
return;
}
cout << bestx << " " << besty << endl;
}
int main() {
preprocess();
totalCases = 1;
for (testNum = 1; testNum <= totalCases; testNum++) {
if (!input()) break;
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int maxx, maxy, w, ansx = -1, ansy = -1, sum[100100], cnt[100100], rev[100100];
map<int, int> divs;
int _rev(int x) {
int res = 0;
while (x) {
res = 10 * res + x % 10;
x /= 10;
}
return res;
}
void factor(int x, int c) {
for (int i = 2; i * i <= x; i++)
while (!(x % i)) {
divs[i] += c;
x /= i;
}
if (x > 1) divs[x] += c;
}
int get_sum(int y) {
int res = 0;
for (; y >= 0; y = (y & (y + 1)) - 1) res += sum[y];
return res;
}
void change(int y) {
for (; y <= maxy; y |= y + 1) sum[y]++;
}
int main() {
int start = time(0);
cin >> maxx >> maxy >> w;
for (int i = 1; i <= max(maxx, maxy); i++) rev[i] = _rev(i);
for (int x = 1; x <= maxx; x++) {
divs.clear();
int revx = rev[x];
factor(x, 1);
factor(revx, -1);
int p1 = 1, p2 = 1;
for (map<int, int>::iterator it = divs.begin(); it != divs.end(); it++) {
for (int i = 0; i < (*it).second; i++) p1 *= (*it).first;
for (int i = 0; i > (*it).second; i--) p2 *= (*it).first;
}
for (int y = p2; y <= maxy; y += p2) {
int revy = rev[y];
if (x * y == revx * revy) change(y);
}
int l = 0, r = maxy + 1, m;
while (r - l > 1) {
m = (l + r) >> 1;
if (get_sum(m) < w)
l = m;
else
r = m;
}
if (r <= maxy) {
if (ansx == -1 || 1LL * ansx * ansy > 1LL * x * r) {
ansx = x;
ansy = r;
}
}
}
if (ansx == -1)
cout << -1;
else
cout << ansx << " " << ansy;
cerr << (time(0) - start);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxa, maxb, w;
inline int rev(int x) {
int nowans = 0;
for (; x;) nowans = nowans * 10 + x % 10, x /= 10;
return nowans;
}
int re[200010];
inline int gcd(int a, int b) { return (!b) ? a : gcd(b, a % b); }
int dex[200010], tot = 1;
struct node {
int ed, before;
} g[500010];
inline void add(int x, int y) {
g[++tot].ed = y;
g[tot].before = dex[x];
dex[x] = tot;
}
int H;
map<pair<int, int>, int> mp;
int father[200010];
int sum[200010];
int newx, newy;
int main() {
scanf("%d%d%d", &maxa, &maxb, &w);
int N = max(maxa, maxb);
for (int i = 1; i <= N; i++) re[i] = rev(i);
for (int i = 1; i <= N; i++) {
int x = i, y = re[i], k = gcd(x, y);
x /= k, y /= k;
if (mp.find(make_pair(x, y)) == mp.end()) mp[make_pair(x, y)] = ++H;
k = mp[make_pair(x, y)];
add(k, i);
if (mp.find(make_pair(y, x)) == mp.end()) mp[make_pair(y, x)] = ++H;
k = mp[make_pair(y, x)];
father[i] = k;
}
long long ans = LLONG_MAX;
int B = maxb + 1;
int tmp = 0;
for (int A = 1; A <= maxa; A++) {
for (int j = dex[father[A]]; j; j = g[j].before) {
int v = g[j].ed;
if (v <= maxb && v <= B) {
sum[v]++, tmp++;
}
}
for (; tmp - sum[B] >= w; tmp -= sum[B], B--)
;
if (tmp >= w) {
if (ans >= 1ll * A * B) {
ans = 1ll * A * B;
newx = A, newy = B;
}
}
}
if (ans == LLONG_MAX)
printf("-1\n");
else
printf("%d %d\n", newx, newy);
}
|
#include <bits/stdc++.h>
const double EPS = 1e-9;
const int INT_INF = 1 << 31 - 1;
const long long I64_INF = 1ll << 63 - 1ll;
const double PI = acos(-1.0);
using namespace std;
int maxx, maxy, w;
int rev[100500];
int Rev(int a) {
int res = 0;
while (a) res = res * 10 + a % 10, a /= 10;
return res;
}
map<pair<int, int>, int> m1;
map<pair<int, int>, int> m2;
int gcd(int a, int b) { return (b) ? gcd(b, a % b) : a; }
void inc(map<pair<int, int>, int>& m, int a, int b) {
int g = gcd(a, b);
a /= g;
b /= g;
m[make_pair(a, b)]++;
}
void dec(map<pair<int, int>, int>& m, int a, int b) {
int g = gcd(a, b);
a /= g;
b /= g;
m[make_pair(a, b)]--;
}
int get(map<pair<int, int>, int>& m, int a, int b) {
int g = gcd(a, b);
a /= g;
b /= g;
return m[make_pair(a, b)];
}
int X = -1, Y = -1;
void upd(int x, int y, int W) {
if (W < w || 1LL * x * y >= 1LL * X * Y && X != -1) return;
X = x;
Y = y;
}
int main() {
cin >> maxx >> maxy >> w;
for (int i = 1; i <= (int)1e5; i++) rev[i] = Rev(i);
int x;
int y = 0;
int W = 0;
for (x = 1; x <= maxx; x++) inc(m1, x, rev[x]);
x--;
while (x > 0) {
while (W < w && y < maxy) {
y++;
inc(m2, rev[y], y);
W += get(m1, rev[y], y);
}
upd(x, y, W);
dec(m1, x, rev[x]);
W -= get(m2, x, rev[x]);
x--;
}
if (X == -1)
puts("-1");
else
printf("%d %d\n", X, Y);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct dat {
long long x, y;
bool operator<(dat const &T) const { return x * T.y < y * T.x; }
bool operator==(dat const &T) const { return x * T.y == y * T.x; }
} T;
int rev(int x) {
int R = 0, t;
while (x > 0) {
t = x % 10;
R = R * 10 + t;
x /= 10;
}
return R;
}
dat a[100005];
map<dat, int> X, Y;
int mx, my;
int ret = -1, rex, rey, par, n, t, pt;
int main() {
scanf("%d%d%d", &mx, &my, &n);
Y.clear();
for (int i = 1; i <= my; i++) {
a[i].x = i;
a[i].y = rev(i);
Y[a[i]] = Y[a[i]] + 1;
}
X.clear();
par = 0;
pt = my;
for (int i = 1; i <= mx; i++) {
T.x = rev(i);
T.y = i;
par += Y[T];
X[T] = X[T] + 1;
if (par < n) continue;
while (pt >= 1) {
T.x = a[pt].x;
T.y = a[pt].y;
t = X[T];
if (par - t >= n) {
par -= t;
Y[a[pt]] = Y[a[pt]] - 1;
pt--;
} else
break;
}
if (i * pt < ret || ret == -1) {
ret = i * pt;
rex = i;
rey = pt;
}
}
if (ret == -1)
printf("-1\n");
else
printf("%d %d\n", rex, rey);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> record[100005], f[100005], g[100005];
map<long long, int> D;
long long k, ans;
double tmp;
int a[25], s, i, rev, tp, j, p, sum, cnt, tot, A, B, C, r, x, y;
inline int get(int k) {
for (s = 0, cnt = 0; k; s = s * 10 + k % 10, k /= 10)
;
return s;
}
int main() {
for (i = 1; i <= 100000; i++) {
rev = get(i);
tmp = rev * 1. / i;
k = (long long)(tmp * 1000000000ll);
if (!(p = D[k])) p = D[k] = ++tot;
record[p].push_back(i);
tmp = i * 1. / rev;
k = (long long)(tmp * 1000000000ll);
if (!(p = D[k])) continue;
for (j = 0; j < record[p].size(); j++) {
tp = record[p][j];
g[tp].push_back(i);
if (i != tp) g[i].push_back(tp);
f[i].push_back(tp);
if (i != tp) f[tp].push_back(i);
}
}
scanf("%d%d%d", &A, &B, &C);
r = B;
sum = 0;
ans = -1;
for (i = 1; i <= A; i++) {
for (j = 0; j < g[i].size(); j++)
if (g[i][j] <= r)
sum++;
else
break;
while (sum >= C && r) {
if (i * 1ll * r < ans || ans == -1) ans = i * 1ll * r, x = i, y = r;
for (j = 0; j < f[r].size(); j++)
if (f[r][j] <= i)
sum--;
else
break;
r--;
}
}
if (ans == -1)
puts("-1");
else
printf("%d %d", x, y);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ii, i, j, k, e, d, n, m, w, r1, r2, a[200200], o[200200], b[200200],
c[200200], p[7];
map<pair<int, int>, int> mm;
pair<int, int> cur;
long long res, r, rz, cw;
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
res = 200000;
res *= res;
rz = res;
for (i = 1; i <= 100000; i++) {
ii = i;
for (j = 0; j < 6; j++) {
p[j] = ii % 10;
ii /= 10;
}
for (j = 0; j < 6; j++) ii = ii * 10 + p[j];
while (ii % 10 == 0) ii /= 10;
d = gcd(i, ii);
cur = make_pair(i / d, ii / d);
a[i] = mm[cur];
if (a[i] == 0) mm[cur] = a[i] = ++e;
cur = make_pair(ii / d, i / d);
o[i] = mm[cur];
if (o[i] == 0) mm[cur] = o[i] = ++e;
}
scanf("%d%d%d", &n, &m, &w);
r = m;
for (j = 1; j <= m; j++) b[a[j]]++;
for (i = 1; i <= n; i++) {
c[o[i]]++;
cw += b[o[i]];
for (; r > 1; r--) {
if (cw - c[a[r]] < w) break;
cw -= c[a[r]];
b[a[r]]--;
}
if (cw >= w && r * i < res) {
res = r * i;
r1 = i;
r2 = r;
}
}
if (res < rz)
printf("%d %d\n", r1, r2);
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int t;
if (b < a) a ^= b ^= a ^= b;
while (a) {
t = b % a;
b = a;
a = t;
}
return b;
}
int reverse(int k) {
while (k && k % 10 == 0) {
k /= 10;
}
int t = 0;
while (k) {
t = t * 10 + k % 10;
k /= 10;
}
return t;
}
map<pair<int, int>, int> mx, my;
int W, X, Y;
pair<int, int> p, q;
int ansx, ansy;
long long ans = 1000000000000000000LL;
int main() {
scanf("%d%d%d", &X, &Y, &W);
for (int i = 1; i <= X; ++i) {
int j = reverse(i);
int g = gcd(i, j);
p.first = i / g;
p.second = j / g;
mx[p]++;
}
int cur = 0;
int x = X;
for (int y = 1; y <= Y; ++y) {
int j = reverse(y);
int g = gcd(y, j);
p.first = j / g;
p.second = y / g;
cur += mx[p];
my[p]++;
if (y == 10) {
}
while (x > 0 && cur >= W) {
if ((long long)((long long)x * (long long)y) < ans) {
ans = (long long)((long long)x * (long long)y);
ansx = x;
ansy = y;
}
int j = reverse(x);
int g = gcd(x, j);
p.first = x / g;
p.second = j / g;
cur -= my[p];
mx[p]--;
--x;
}
}
if (ans == 1000000000000000000LL) {
puts("-1");
} else {
printf("%d %d\n", ansx, ansy);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100008];
int p[7];
multimap<double, int>::iterator it[100008];
void get(int m) {
int q = 0;
int k = m;
while (m) {
int cc = m % 10;
m /= 10;
if (cc == 0 && q == 0)
continue;
else
p[++q] = cc;
}
for (int i = 1; i <= q; i++) {
a[k] = a[k] * 10 + p[i];
}
}
int main() {
int aa, bb, w, flag = 0;
scanf("%d%d%d", &aa, &bb, &w);
if (aa > bb) {
flag = 1;
swap(aa, bb);
}
fill(a, a + bb + 2, 0);
for (int i = 1; i <= bb; i++) get(i);
multimap<double, int> mm;
multimap<double, int> mm2;
for (int i = 1; i <= bb; i++) {
it[i] = mm.insert(make_pair((double)(i) / a[i], i));
}
int sum = 0;
int x, y;
int x1, y1;
long long ans = (long long)aa * bb + 1;
for (int i = 1; i <= aa; i++) {
double k = (double)(a[i]) / i;
int cnt = mm.count(k);
sum += cnt;
mm2.insert(make_pair(k, i));
if (sum >= w) {
x = i;
y = bb;
ans = x * y;
x1 = x;
y1 = y;
while (1) {
if (sum >= w) {
if (y > 1) {
double kk = (double)(y) / a[y];
int cnt = mm2.count(kk);
sum -= cnt;
mm.erase(it[y]);
y--;
if (sum >= w) {
if (x * y < ans) {
x1 = x;
y1 = y;
ans = x1 * y1;
}
}
} else
break;
} else {
if (x < aa) {
x++;
double kk = double(a[x]) / (x);
int cnt = mm.count(kk);
sum += cnt;
mm2.insert(make_pair(kk, x));
if (sum >= w) {
if (x * y < ans) {
x1 = x;
y1 = y;
ans = x * y;
}
}
} else
break;
}
}
break;
}
}
if (ans == ((long long)aa * bb + 1))
cout << "-1" << endl;
else if (flag) {
cout << y1 << " " << x1 << endl;
} else
cout << x1 << " " << y1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
void doubleIntSort(double d[], int m[], int s) {
int i, j, r;
double k1, k2, t;
if (s <= 1) return;
k1 = (d[0] + d[s - 1]) / 2.0;
k2 = k1 + 1e-10;
k1 -= 1e-10;
i = -1;
j = s;
for (;;) {
while (d[++i] < k1)
;
while (d[--j] > k2)
;
if (i >= j) break;
t = d[i];
d[i] = d[j];
d[j] = t;
r = m[i];
m[i] = m[j];
m[j] = r;
}
doubleIntSort(d, m, i);
doubleIntSort(d + j + 1, m + j + 1, s - j - 1);
}
typedef struct struct_vector_int {
int size, mem;
int *d;
} intVector;
intVector intVectorNull() {
intVector v;
v.size = v.mem = 0;
return v;
}
void intVectorMemoryExpand(intVector *v) {
int i, *t, m;
m = v->mem * 2;
if (m < 5) m = 5;
t = (int *)malloc(m * sizeof(int));
for (i = 0; i < v->size; i++) t[i] = v->d[i];
if (v->mem) free(v->d);
v->d = t;
v->mem = m;
}
void intVectorPushBack(intVector *v, int add) {
if (v->mem == v->size) intVectorMemoryExpand(v);
v->d[(v->size)++] = add;
}
int rev(int n) {
int i, res = 0;
char buf[100];
sprintf(buf, "%d", n);
for (i = 0;; i++)
if (buf[i] < ' ') break;
while (i--) res = res * 10 + buf[i] - '0';
return res;
}
int REV[100001];
double rat[100001];
int ind[100001];
intVector edge[100001];
int main() {
int i, j, k, l, m, n;
int useX[100001];
int x, y;
int st, ed, add = 0;
long long resX, resY, nowX, nowY, now;
for (i = 0; i < 100001; i++) REV[i] = rev(i);
for (i = 1; i < 100001; i++) rat[i] = REV[i] / (double)i, ind[i] = i;
doubleIntSort(rat + 1, ind + 1, 100001 - 1);
for (i = 0; i < 100001; i++) edge[i] = intVectorNull();
ed = 100001 - 1;
for (st = 1; st < 100001; st++) {
while (ed >= 1 && rat[st] * rat[ed] > 1 + 1e-10) ed--;
if (ed == 0) break;
for (i = ed; i >= 1; i--) {
if (rat[st] * rat[i] < 1 - 1e-10) break;
intVectorPushBack(edge + ind[st], ind[i]);
add++;
}
}
while (scanf("%d%d%d", &x, &y, &n) == 3) {
resX = 100000000;
resY = 100000000;
for (i = 0; i < x + 1; i++) useX[i] = 0;
nowX = x;
now = 0;
for (nowY = 1; nowY < y + 1; nowY++) {
for (i = 0; i < edge[nowY].size; i++)
if (1 <= edge[nowY].d[i] && edge[nowY].d[i] <= nowX)
now++, useX[edge[nowY].d[i]]++;
while (now >= n) {
if (resX * resY > nowX * nowY) resX = nowX, resY = nowY;
now -= useX[nowX];
nowX--;
}
}
if (resX > x)
puts("-1");
else
printf("%d %d\n", (int)resX, (int)resY);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 100;
map<double, long long> mp1, mp2;
long long rev(long long x) {
long long ans = 0;
while (x) {
ans = ans * 10 + x % 10;
x /= 10;
}
return ans;
}
int main() {
long long w, maxy, maxx, cnt = 0;
scanf("%lld%lld%lld", &maxx, &maxy, &w);
for (long long i = 1; i <= maxx; i++) mp1[1.0 * i / rev(i)]++;
for (long long i = 1; i <= maxy; i++) cnt += mp1[1.0 * rev(i) / i];
if (cnt < w) {
cout << -1 << endl;
return 0;
}
long long tx = maxx, ty = 1, ax = maxx, ay = maxy;
cnt = mp1[1.0];
mp2[1.0]++;
while (tx >= 1 && ty <= maxy) {
if (cnt >= w) {
if (tx * ty < ax * ay) ax = tx, ay = ty;
double tmp = 1.0 * tx / rev(tx);
cnt -= mp2[tmp];
mp1[tmp]--;
tx--;
} else {
ty++;
double tmp = 1.0 * rev(ty) / ty;
cnt += mp1[tmp];
mp2[tmp]++;
}
}
printf("%lld %lld\n", ax, ay);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long maxx, maxy, w, sum;
map<long double, long long> mp, Mp;
inline long long rev(long long x) {
long long sum = 0;
while (x) {
sum = sum * 10 + x % 10;
x /= 10;
}
return sum;
}
int main() {
cin >> maxx >> maxy >> w;
for (long long i = 1; i <= maxx; i++) mp[i * 1.0 / rev(i)]++;
for (long long i = 1; i <= maxy; i++) sum += mp[rev(i) * 1.0 / i];
if (sum < w) {
printf("-1\n");
return 0;
}
long long ansx = maxx, ansy = maxy, X = maxx, Y = 1;
sum = mp[1];
Mp[1]++;
while (X >= 1 && Y <= maxy) {
if (sum >= w) {
if (X * Y < ansx * ansy) {
ansx = X;
ansy = Y;
}
long double x = X * 1.0 / rev(X);
sum -= Mp[x];
mp[x]--;
X--;
} else {
Y++;
long double x = rev(Y) * 1.0 / Y;
sum += mp[x];
Mp[x]++;
}
}
printf("%lld %lld\n", ansx, ansy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
pair<int, int> temp[100005];
int gcd(int a, int b) {
int c;
if (a < b) swap(a, b);
while (b > 0) {
c = b;
b = a % b;
a = c;
}
return a;
}
map<pair<long long, long long>, int> M1, M2;
int main() {
int x, y;
long long w;
scanf("%d %d %lld", &x, &y, &w);
pair<long long, long long> m = make_pair(-1, -1);
long long l = 1e15;
for (int i = 1; i < 100005; ++i) {
int p = 0, q = i;
while (q > 0) {
p = p * 10 + q % 10;
q /= 10;
}
q = gcd(i, p);
temp[i] = make_pair(i / q, p / q);
}
for (int i = 1; i < y + 1; ++i) {
M1[temp[i]]++;
}
long long h = y;
long long ans = 0;
for (int i = 1; i < x + 1; ++i) {
pair<int, int> c = make_pair(temp[i].second, temp[i].first);
ans += M1[c];
M2[c]++;
while (ans >= w && h > 0) {
if ((h * i) < l) {
l = h * i;
m = make_pair(i, h);
}
M1[temp[h]]--;
ans -= M2[temp[h]];
h--;
}
if (h == 0) break;
}
if (l == 1e15)
printf("-1\n");
else
printf("%lld %lld\n", m.first, m.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ma, mb, target_x;
vector<int> ca[100001];
vector<int> cb[100001];
int rev(int x) {
int res = 0;
while (x) {
res = res * 10 + x % 10;
x /= 10;
}
return res;
}
bool is_palin(int x) { return (x == rev(x)); }
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
void gen1(int x) {
int rx = rev(x);
int g = gcd(x, rx);
int ix = x;
x /= g;
rx /= g;
int ry, y;
for (y = rx; y <= mb; y += rx) {
ry = rev(y);
if ((long long)x * y == (long long)rx * ry) {
ca[ix].push_back(y);
cb[y].push_back(ix);
}
}
}
void gen_all_pairs() {
int i;
for (i = 11; i <= ma; i++)
if (i % 10 != 0 && !is_palin(i)) gen1(i);
}
int cura, curb;
int pa, pb;
long long npal, npair, n_x;
void inc_b() {
curb++;
if (is_palin(curb)) pb++;
}
void inc_a() {
cura++;
if (is_palin(cura)) pa++;
npal = pa * pb;
int i;
for (i = 0; i < ca[cura].size(); i++)
if (ca[cura][i] <= curb) npair++;
n_x = npal + npair;
}
void dec_b() {
if (is_palin(curb)) pb--;
npal = pa * pb;
int i;
for (i = 0; i < cb[curb].size(); i++)
if (cb[curb][i] <= cura) npair--;
n_x = npal + npair;
curb--;
}
int main() {
scanf("%d %d %d", &ma, &mb, &target_x);
gen_all_pairs();
cura = curb = 0;
pa = pb = 0;
npal = npair = n_x = 0;
int ra, rb;
while (curb < mb) inc_b();
long long res = 1000000000000LL;
while (cura < ma) {
inc_a();
while (n_x >= target_x && curb >= 1) {
if ((long long)cura * curb < res) {
res = (long long)cura * curb;
ra = cura;
rb = curb;
}
dec_b();
}
if (curb == 0) break;
}
if (res == 1000000000000LL)
printf("-1\n");
else
printf("%d %d\n", ra, rb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 100 + 100;
map<double, set<long long> > mp;
long long n, maxx, maxy, x, y, w, rev[maxn], d[maxn], cnt, ansx, ansy,
l = (1ll << 50);
void check(long long x, long long y) {
if (x * y < l) {
l = x * y;
ansx = x;
ansy = y;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> maxx >> maxy >> w;
for (int i = 1; i < maxn; i++) {
int x = i, y = 0;
while (x) {
y *= 10;
y += x % 10;
x /= 10;
}
double z = double(i) / double(y);
rev[i] = y;
mp[z].insert(i);
d[i] = mp[z].size();
}
y = maxy;
for (x = 1; x <= maxx; x++) {
double z = double(rev[x]) / double(x);
if (mp[z].size()) {
set<long long>::iterator it = mp[z].upper_bound(y);
if (it == mp[z].end())
cnt += mp[z].size();
else {
int c = *mp[z].upper_bound(y);
cnt += d[c] - 1;
}
}
if (cnt < w) continue;
while (cnt >= w) {
check(x, y);
double z = double(rev[y]) / double(y);
if (mp[z].size()) {
set<long long>::iterator it = mp[z].upper_bound(x);
if (it == mp[z].end())
cnt -= mp[z].size();
else {
int c = *mp[z].upper_bound(x);
cnt -= (d[c] - 1);
}
}
y--;
}
}
if (!ansx && !ansy) {
cout << -1 << endl;
return 0;
}
cout << ansx << " " << ansy << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 203600;
char s[2000];
int rev(int first) {
int n;
sprintf(s, "%d%n", first, &n);
reverse(s, s + n);
sscanf(s, "%d", &first);
return first;
}
int gcd(int first, int second) {
return first ? gcd(second % first, first) : second;
}
map<int, int> MP;
pair<int, int> frac[N];
pair<int, int> recp[N];
map<pair<int, int>, int> cntx;
map<pair<int, int>, int> cnty;
int main() {
for (int i = (1); i <= (int)(100000); i++) {
int j = rev(i);
int g = gcd(i, j);
frac[i] = pair<int, int>(i / g, j / g);
recp[i] = pair<int, int>(j / g, i / g);
}
int mx, my, w;
scanf("%d%d%d", &mx, &my, &w);
int cx, cy = 1;
int ax, ay;
long long tot = 1LL << 40;
for (int first = (1); first <= (int)(mx); first++) cntx[recp[first]]++;
long long cur = 0;
for (cx = mx; cx; cx--) {
while (cy <= my && cur < w) {
cur += cntx[frac[cy]];
cnty[frac[cy]]++;
cy++;
}
if (cur >= w && (long long)cx * (cy - 1) < tot) {
tot = (long long)cx * (cy - 1);
ax = cx;
ay = cy - 1;
}
cur -= cnty[recp[cx]];
cntx[recp[cx]]--;
}
if (tot == (1LL << 40))
puts("-1");
else
printf("%d %d\n", ax, ay);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sign(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dxKn[] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dyKn[] = {1, 2, 2, 1, -1, -2, -2, -1};
const int N = int(1e5) + 9;
const int M = int(3e3) + 9;
const int LOGN = 22;
const int SQN = 350;
const int MOD = int(1e9) + 7;
const int INF = 1e9 + 100;
const long long INF64 = 2e18;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
int n, m, k;
map<pair<int, int>, int> cnt;
map<pair<int, int>, int> cur;
int rev[N];
int getrev(int x) {
int res = 0;
while (x) {
res = res * 10 + (x % 10);
x /= 10;
}
return res;
}
pair<int, int> norm(pair<int, int> a) {
int g = gcd(a.first, a.second);
a.first /= g, a.second /= g;
return a;
}
void solve() {
for (int i = 0; i < (int)(N); ++i) rev[i] = getrev(i);
cin >> n >> m >> k;
long long x = INF, y = INF;
for (int i = 1; i < (int)(n + 1); ++i) cnt[norm(make_pair(i, rev[i]))]++;
long long res = 0;
int i = n;
for (int j = 1; j < (int)(m + 1); ++j) {
res += cnt[norm(make_pair(rev[j], j))];
++cur[norm(make_pair(rev[j], j))];
while (i > 1 && res - cur[norm(make_pair(i, rev[i]))] >= k)
res -= cur[norm(make_pair(i, rev[i]))], --cnt[norm(make_pair(i, rev[i]))],
--i;
if (res >= k && x * y > i * 1LL * j) x = i, y = j;
}
if (x == INF)
cout << -1;
else
cout << x << ' ' << y;
}
int main() {
srand(time(NULL));
cout << setprecision(10) << fixed;
cerr << setprecision(10) << fixed;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> hash1, hash2;
int gcd(int x, int y) {
if (x == 0) return y;
return gcd(y % x, x);
}
int rev(int x) {
int sum = 0;
while (x) {
sum *= 10;
sum += x % 10;
x /= 10;
}
return sum;
}
int main() {
int x, y, w;
cin >> x >> y >> w;
for (int i = 1; i <= x; ++i) {
int re = rev(i);
int t = gcd(i, re);
++hash1[make_pair(i / t, re / t)];
}
int j = 0;
long long bestx = x, besty = y, e = 0;
long long sum = 0;
for (; x;) {
while (j < y && sum < w) {
int l = rev(++j), jj;
jj = gcd(j, l);
pair<int, int> tmp = make_pair(l / jj, j / jj);
sum += hash1[tmp];
++hash2[tmp];
}
if (sum >= w) {
if (besty * bestx >= (long long)j * x) {
bestx = x;
besty = j;
e = 1;
}
}
int re = rev(x);
int st = gcd(re, x);
pair<int, int> tmp = make_pair(x / st, re / st);
sum -= hash2[tmp];
--hash1[tmp];
--x;
}
if (e)
cout << bestx << ' ' << besty << endl;
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 * 1000;
const long long INF = (1LL << 30) * (1LL << 30);
map<double, long long> M1;
map<double, long long> M2;
long long Mx, My;
long long W;
long long rev(long long x) {
long long ret = 0;
while (x) {
ret *= 10;
ret += x % 10;
x /= 10;
}
return ret;
}
int main() {
cin >> Mx >> My >> W;
for (long long i = 1; i <= Mx; i++) M1[(double)i / (double)rev(i)]++;
long long Ansa = -1;
long long Ansb = -1;
long long X = Mx;
long long Y = 0;
long long NOW = 0;
while (X >= 1 && Y <= My) {
if (NOW < W) {
Y++;
double TEMP = (double)rev(Y) / (double)Y;
M2[TEMP]++;
NOW += M1[TEMP];
} else {
if (Ansa == -1 || Ansa * Ansb > X * Y) Ansa = X, Ansb = Y;
double TEMP = (double)X / (double)rev(X);
NOW -= M2[TEMP];
M1[TEMP]--;
X--;
}
}
if (Ansa == -1)
cout << -1 << endl;
else
cout << Ansa << " " << Ansb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(const T& t) {
return t * t;
}
template <class T>
T abs(const T& t) {
return ((t > 0) ? (t) : (-t));
}
void initialize() {
freopen("_.in", "r", stdin);
freopen("_.out", "w", stdout);
}
struct Point {
int x;
int y;
Point(int x_, int y_) : x(x_), y(y_) {}
};
map<pair<int, int>, vector<int> > fractions;
int rev(int a) {
int res = 0;
while (a > 0) {
res = res * 10 + (a % 10);
a /= 10;
}
return res;
}
int nod(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
return nod(b, a % b);
}
pair<int, int> fraction(int num) {
int a = num;
int b = rev(a);
int d = nod(a, b);
a /= d;
b /= d;
return pair<int, int>(a, b);
}
int main() {
int maxX, maxY, w;
cin >> maxX >> maxY >> w;
for (int i = 1; i <= max(maxX, maxY); ++i) {
fractions[fraction(i)].push_back(i);
}
map<pair<int, int>, vector<int> >::iterator it = fractions.begin(),
jt = fractions.end();
for (; it != jt; ++it) {
sort(it->second.begin(), it->second.end());
}
const long long INF = (long long)maxX * (long long)maxY + 1;
long long bestProduct = INF;
int rx = -1, ry = -1;
int res = 0;
int y = maxY;
for (int x = 1; x <= maxX; ++x) {
pair<int, int> f = fraction(x);
swap(f.first, f.second);
const vector<int>& v = fractions[f];
res += upper_bound(v.begin(), v.end(), y) - v.begin();
do {
pair<int, int> fy = fraction(y);
swap(fy.first, fy.second);
const vector<int>& vy = fractions[fy];
res -= upper_bound(vy.begin(), vy.end(), x) - vy.begin();
y -= 1;
} while (res >= w && y > 0);
y += 1;
pair<int, int> fy = fraction(y);
swap(fy.first, fy.second);
const vector<int>& vy = fractions[fy];
res += upper_bound(vy.begin(), vy.end(), x) - vy.begin();
if (res >= w) {
long long product = (long long)x * (long long)y;
if (product < bestProduct) {
bestProduct = product;
rx = x;
ry = y;
}
}
}
if (bestProduct < INF) {
cout << rx << " " << ry << endl;
} else {
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxx, maxy, w, l, r, ll, rr;
map<double, int> a, b;
long long min(long long l, long long r) {
if (l < r)
return l;
else
return r;
}
int rev(int k) {
int sum = 0;
while (k > 0) {
int t = k % 10;
k = k / 10;
sum = sum * 10 + t;
}
return sum;
}
int main() {
scanf("%d%d%d", &maxx, &maxy, &w);
for (int i = 1; i <= maxx; i++) {
double sum = (double)i / rev(i);
a[sum] = a[sum] + 1;
}
l = maxx;
r = 0;
int s = 0;
long long ans = 1e15;
while ((l >= 1) && (r <= maxy)) {
if ((s < w) && (r < maxy)) {
r = r + 1;
double sum = (double)rev(r) / r;
s = s + a[sum];
b[sum] = b[sum] + 1;
} else if (s >= w) {
if (ans > (long long)l * r) {
ans = (long long)l * r;
ll = l;
rr = r;
}
double sum = (double)l / rev(l);
s = s - b[sum];
a[sum] = a[sum] - 1;
l = l - 1;
} else
break;
}
if (ans == 1e15)
printf("-1\n");
else
printf("%d %d\n", ll, rr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
template <typename T>
T sqr(T a) {
return a * a;
}
const int INF = (int)1e9;
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
int gcd(int a, int b) { return (a == 0) ? b : gcd(b % a, a); }
struct rat {
int a, b;
rat(int ca, int cb) : a(ca), b(cb) {
int g = gcd(a, b);
a /= g;
b /= g;
}
};
bool operator<(const rat& a, const rat& b) {
return a.a * 1ll * b.b < b.a * 1ll * a.b;
}
int rev[100500];
inline int getRev(int a) {
if (rev[a] == -1) {
int b = a;
int res = 0;
do {
res = 10 * res + (b % 10);
b /= 10;
} while (b > 0);
rev[a] = res;
}
return rev[a];
}
int maxX, maxY, w;
map<rat, int> mx, my;
int main() {
pair<int, int> ans(-1, -1);
memset(rev, -1, sizeof(rev));
cin >> maxX >> maxY >> w;
for (int y = 1; y <= maxY; ++y) my[rat(y, getRev(y))]++;
int y = maxY;
int cur = 0;
for (int x = 1; x <= maxX; ++x) {
rat rx(x, getRev(x));
mx[rx]++;
swap(rx.a, rx.b);
cur += my[rx];
while (y > 0 && cur >= w) {
if (ans.first == -1 || ans.first * 1ll * ans.second > x * 1ll * y) {
ans = pair<int, int>(x, y);
}
rat ry(y, getRev(y));
my[ry]--;
swap(ry.a, ry.b);
cur -= mx[ry];
y--;
}
}
if (ans.first == -1) {
puts("-1");
return 0;
}
cout << ans.first << " " << ans.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long anss = 1e15, ansx, ansy;
map<double, long long> mp1, mp2;
double x[500005], y[500005];
long long work(long long x) {
long long ans = 0;
while (x) {
ans = ans * 10 + x % 10;
x /= 10;
}
return ans;
}
signed main() {
long long xx, yy, w, ans = 0;
scanf("%lld%lld%lld", &xx, &yy, &w);
for (long long i = 1; i <= xx; i++) {
x[i] = i;
x[i] /= work(i);
mp1[x[i]]++;
}
for (long long i = 1; i <= yy; i++) {
y[i] = work(i);
y[i] /= i;
}
long long xxx = xx, yyy = 1;
ans += mp1[y[1]];
mp2[y[1]]++;
while (xxx >= 1 && yyy <= yy) {
if (ans >= w) {
if (anss > xxx * yyy) {
ansx = xxx;
ansy = yyy;
anss = xxx * yyy;
}
ans -= mp2[x[xxx]];
mp1[x[xxx]]--;
xxx--;
} else {
yyy++;
ans += mp1[y[yyy]];
mp2[y[yyy]]++;
}
}
if (anss == 1e15)
printf("-1\n");
else
printf("%lld %lld\n", ansx, ansy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int rev[200005];
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
map<pair<int, int>, int> mpx;
map<pair<int, int>, int> mpy;
void init() {
for (int i = 1; i <= 200000; i++) {
int ans = i;
int a = 0;
while (ans) {
a = ans % 10 + a * 10;
ans /= 10;
}
rev[i] = a;
}
}
int main() {
init();
int x, y, w;
cin >> x >> y >> w;
for (int i = 1; i <= y; i++) {
pair<int, int> pi(i / gcd(i, rev[i]), rev[i] / gcd(i, rev[i]));
mpy[pi]++;
}
int ans = 0;
int posx, posy = y;
for (posx = 1; posx <= x; posx++) {
pair<int, int> pi(rev[posx] / gcd(rev[posx], posx),
posx / gcd(rev[posx], posx));
mpx[pi]++;
ans += mpy[pi];
if (ans >= w) {
break;
}
}
int nmin = inf;
int fx = -1;
int fy = -1;
if (ans >= w) {
nmin = posx * y;
fx = posx;
fy = y;
}
int res = ans;
while (true && posx <= x && posy >= 1 && res >= w) {
pair<int, int> pi(posy / gcd(posy, rev[posy]),
rev[posy] / gcd(posy, rev[posy]));
mpy[pi]--;
res -= mpx[pi];
while (res < w && posx + 1 <= x) {
posx++;
pair<int, int> pi(rev[posx] / gcd(rev[posx], posx),
posx / gcd(rev[posx], posx));
mpx[pi]++;
res += mpy[pi];
}
posy--;
if (res >= w && posx * posy < nmin) {
nmin = posx * posy;
fx = posx;
fy = posy;
}
}
if (~fx && ~fy) {
cout << fx << ' ' << fy << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mx, my;
int rev(int n) {
int res = 0;
while (n) {
int p = n % 10;
res = res * 10 + p;
n /= 10;
}
return res;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int maxx, maxy, w;
cin >> maxx >> maxy >> w;
for (int i = (1); i < (maxx + 1); ++i) {
int rx = rev(i);
int g = gcd(i, rx);
mx[make_pair(i / g, rx / g)]++;
}
int oury = 0;
long long ress = 0;
long long best = 1000000000000000000ll;
int ans1 = -1, ans2 = -1;
for (int x = maxx; x > 0; --x) {
bool f = false;
while (oury <= maxy) {
if (ress >= w) {
f = true;
break;
}
oury++;
int ry = rev(oury);
int g = gcd(oury, ry);
my[make_pair(ry / g, oury / g)]++;
ress += mx[make_pair(ry / g, oury / g)];
}
int rx = rev(x);
int g = gcd(x, rx);
ress -= my[make_pair(x / g, rx / g)];
mx[make_pair(x / g, rx / g)]--;
if (f) {
if (oury * 1ll * x < best) {
best = oury * 1ll * x;
ans1 = x;
ans2 = oury;
}
}
}
if (ans1 == -1)
printf("-1\n");
else
printf("%d %d\n", ans1, ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct rat {
int x, y;
rat() {}
rat(int tx, int ty) {
x = tx;
y = ty;
}
rat flip() { return rat(y, x); }
bool operator<(const rat& o) const {
return (long long)x * o.y < (long long)o.x * y;
}
bool operator==(const rat& o) const {
return (long long)x * o.y == (long long)o.x * y;
}
};
int getrev(int a) {
int t = 0;
while (a) {
t = (t * 10) + (a % 10);
a /= 10;
}
return t;
}
int rev[100010];
multiset<rat> a, b;
int c = 0, ta = 0, tb = 0;
void inca() {
ta++;
rat t(ta, rev[ta]);
a.insert(t);
c += b.count(t.flip());
}
void incb() {
tb++;
rat t(tb, rev[tb]);
b.insert(t);
c += a.count(t.flip());
}
void decb() {
rat t(tb, rev[tb]);
if (b.find(t) == b.end()) {
printf("ERR\n");
fflush(stdout);
exit(1);
}
b.erase(b.find(t));
c -= a.count(t.flip());
tb--;
}
int main() {
for (int i = 1; i <= 100000; i++) rev[i] = getrev(i);
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) incb();
long long best = 99999999999999LL;
int ba = 0, bb = 0;
for (int i = 1; i <= n; i++) {
inca();
while (tb != 0 && c >= k) decb();
if (tb < m) incb();
if (c >= k) {
long long t = ta;
t *= tb;
if (t < best) {
best = t;
ba = ta;
bb = tb;
}
}
}
if (best != 99999999999999LL)
printf("%d %d\n", ba, bb);
else
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
double aux(long long x) {
long long ans = 0;
while (x) ans = ans * 10 + x % 10, x /= 10;
return (double)ans;
}
map<double, long long> mp1, mp2;
double f[200005];
long long n, m, w;
signed main() {
scanf("%I64d%I64d%I64d", &n, &m, &w);
for (long long i = 1; i <= n; i++) f[i] = i / aux(i), mp1[f[i]]++;
long long tot = 0;
for (long long i = 1; i <= m; i++) tot += mp1[aux(i) / i];
if (tot < w) return puts("-1"), 0;
long long xx = n, yy = 1;
long long ansx, ansy, plk = 1e18;
long long sum = mp1[1.0];
mp2[1.0]++;
while (xx >= 1 && yy <= m) {
if (sum >= w) {
if (xx * yy < plk) plk = xx * yy, ansx = xx, ansy = yy;
double pl = 1.0 * xx / aux(xx);
mp1[pl]--;
sum -= mp2[pl];
xx--;
} else {
yy++;
double pl = aux(yy) / yy;
sum += mp1[pl];
mp2[pl]++;
}
}
cout << ansx << " " << ansy;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int MX, MY, W;
class rational {
public:
int x, y;
rational() {}
rational(int x1, int y1) {
x = x1;
y = y1;
}
bool operator<(const rational r) const {
return 1ll * x * r.y < 1ll * y * r.x;
}
};
const int LEN = 100010;
map<rational, int> m1, m2;
rational r[LEN], rr[LEN];
int rev(int x) {
int n = 0;
while (x != 0) {
n = n * 10 + x % 10;
x /= 10;
}
return n;
}
int main() {
cin >> MX >> MY >> W;
for (int i = 0; i < LEN; i++) {
r[i].x = i;
r[i].y = rev(i);
rr[i].x = r[i].y;
rr[i].y = r[i].x;
}
for (int i = 1; i <= MX; i++) m1[r[i]]++;
m2[rational(1, 1)] = 1;
int minx = LEN + 1, miny = 1;
int curw = m1[rational(1, 1)], cur = 1;
if (curw >= W) {
minx = MX;
miny = 1;
}
int maxw = 0;
for (int i = MX; i >= 1; i--) {
while (cur < MY && curw < W) {
cur++;
m2[rr[cur]]++;
curw += m1[rr[cur]];
}
if (maxw < curw) maxw = curw;
if (cur == MY && curw < W) break;
if (curw >= W && ((i * cur < minx * miny) || (minx > LEN))) {
minx = i;
miny = cur;
}
curw -= m2[r[i]];
m1[r[i]]--;
}
if (minx > LEN)
cout << "-1\n";
else
cout << minx << " " << miny << "\n";
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
int m1[100001];
vector<int> m2[100001];
map<int, int> mp[100001];
int main() {
int n = 1;
int maxx, maxy, w;
cin >> maxx >> maxy >> w;
for (int i = 1; i <= maxx; i++) {
int x = i, y = 0;
while (x) {
y = y * 10 + (x % 10);
x /= 10;
}
x = i;
int g = x, b = y;
while (b) {
int x2 = b;
b = g % b;
g = x2;
}
x /= g;
y /= g;
g = mp[x][y];
if (!g) {
mp[x][y] = n++;
g = n - 1;
}
m1[i] = g;
}
n = 0;
for (int i = 1; i <= maxy; i++) {
int x = i, y = 0;
while (x) {
y = y * 10 + (x % 10);
x /= 10;
}
x = i;
int g = x, b = y;
while (b) {
int x2 = b;
b = g % b;
g = x2;
}
x /= g;
y /= g;
g = mp[y][x];
if (g) {
m2[g].push_back(i);
n = max(n, (int)m2[g].size());
}
}
long long MH = (long long)(maxx + 1ll) * (long long)(maxy + 1ll);
long long l = 0, h = MH;
while (l <= h) {
long long m = (l + h) / 2ll;
int t = 0;
int cnt = 0;
priority_queue<int> q;
for (int x = 1; x <= maxx && !t; x++) {
long long h2 = m / x;
while (!q.empty() && q.top() > h2) q.pop();
int y = m1[x];
for (int i = 0; i < m2[y].size() && m2[y][i] <= h2; i++) {
q.push(m2[y][i]);
}
if (q.size() >= w) t = 1;
}
if (t)
h = m - 1;
else
l = m + 1;
}
if (l < MH) {
priority_queue<int> q;
int t = 0;
int x1, y1;
for (int x = 1; x <= maxx && !t; x++) {
while (!q.empty() && (long long)x * (long long)q.top() > l) q.pop();
int y = m1[x];
for (int i = 0;
i < m2[y].size() && (long long)x * (long long)m2[y][i] <= l; i++)
q.push(m2[y][i]);
if (q.size() >= w) {
t = 1;
x1 = x;
y1 = q.top();
}
}
cout << x1 << " " << y1 << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void check_max(T& a, T b) {
if (a < b) a = b;
}
template <class T>
void check_min(T& a, T b) {
if (a > b) a = b;
}
int r(int a) {
int res = 0;
for (int p = 0, mi = 1; mi <= a; mi *= 10, p++)
res = res * 10 + (a / mi % 10);
return res;
}
const int MAXN = 100000 + 1;
const int MAXMI = 16;
struct TYPE {
int num;
int mi[MAXMI][2];
};
bool operator<(TYPE a, TYPE b) {
for (int _t = MAXMI, i = 0; i < _t; i++)
for (int _t = 2, w = 0; w < _t; w++)
if (a.mi[i][w] != b.mi[i][w]) return a.mi[i][w] < b.mi[i][w];
return false;
}
TYPE rec[MAXN];
void add(map<int, int>& tmp, int v, int coef) {
for (int i = 2; i * i <= v; i++) {
if (v % i == 0) {
while (v % i == 0) {
tmp[i] += coef;
v /= i;
}
}
}
if (v != 1) tmp[v] += coef;
}
vector<int> R[MAXN];
void init() {
for (int _t = MAXN, i = 1; i < _t; i++) {
map<int, int> tmp;
add(tmp, i, 1);
add(tmp, r(i), -1);
memset(rec[i].mi, 0, sizeof(rec[i].mi));
int c = 0;
for (map<int, int>::iterator it = tmp.begin(); it != tmp.end(); it++)
if (it->second != 0) {
rec[i].mi[c][0] = it->first;
rec[i].mi[c][1] = it->second;
c++;
}
rec[i].num = i;
}
sort(rec + 1, rec + MAXN);
for (int _t = MAXN, i = 0; i < _t; i++) R[i].clear();
for (int _t = MAXN, p = 1; p < _t; p++) {
TYPE rev = rec[p];
for (int _t = MAXMI, x = 0; x < _t; x++) rev.mi[x][1] = -rev.mi[x][1];
int i = 0, d = 1;
while (d < MAXN) d *= 2;
for (; d > 0; d /= 2)
if (i + d < MAXN && rec[i + d] < rev) i += d;
i++;
if (i < MAXN && !(rev < rec[i])) {
int j = i;
while (j < MAXN && !(rec[i] < rec[j])) j++;
for (int _t = j, k = i; k < _t; k++) R[rec[p].num].push_back(rec[k].num);
}
}
}
const int IAL = 1 << 18;
int ia[IAL + 1];
int g(int v) { return v & (-v); }
void add(int v) {
while (v < IAL) {
ia[v]++;
v += g(v);
}
}
int sum(int v) {
int res = 0;
while (v) {
res += ia[v];
v -= g(v);
}
return res;
}
void solve() {
int maxx, maxy, w;
cin >> maxx >> maxy >> w;
memset(ia, 0, sizeof(ia));
bool ok = false;
long long ansx = 1E8, ansy = 1E8;
int all_sum = 0;
for (int x = 1; x <= maxx; x++) {
for (int _t = R[x].size(), p = 0; p < _t; p++)
if (R[x][p] <= maxy) {
add(R[x][p]);
all_sum++;
}
if (all_sum >= w) {
int d = 1;
while (d < maxy) d *= 2;
int y = 0;
for (; d > 0; d /= 2)
if (y + d <= maxy && sum(y + d) < w) y += d;
y++;
if ((long long)x * (long long)y < ansx * ansy) {
ansx = x;
ansy = y;
ok = true;
}
}
}
if (ok)
cout << ansx << " " << ansy << endl;
else
cout << -1 << endl;
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tree[200010], rever[100010];
int maxa, maxb, w;
map<long double, vector<int> > st;
int sum(int x) {
int ans = 0;
while (x > 0) {
ans += tree[x];
x -= x & -x;
}
return ans;
}
void add(int x, int a) {
while (x <= maxb) {
tree[x] += a;
x += x & -x;
}
}
int rev(int a) {
char str[10] = {0};
sprintf(str, "%d", a);
reverse(str, strlen(str) + str);
sscanf(str, "%d", &a);
return a;
}
int main() {
int lst = 100000, mx, my;
long long ans = 1000000000000ll;
scanf("%d%d%d", &maxa, &maxb, &w);
for (int i = 1; i <= maxb; ++i)
st[(long double)rev(i) / (long double)i].push_back(i);
for (int i = 1; i <= ((maxa) < (maxb) ? (maxb) : (maxa)); ++i)
rever[i] = rev(i);
for (int a = 1; a <= maxa; ++a) {
int reva = rever[a];
if (a % 9 != reva % 9) continue;
if (st.find((long double)a / (long double)reva) == st.end()) continue;
vector<int>& vec = st[(long double)a / (long double)reva];
for (int i = 0; i < vec.size() && vec[i] < lst; ++i)
if (vec[i] * a == rever[vec[i]] * reva) add(vec[i], 1);
if (sum(maxb) < w) continue;
int l = 0, r = maxb;
while (l < r) {
int ans = (l + r) >> 1;
if (sum(ans) >= w)
r = ans;
else
l = ans + 1;
}
lst = l;
if (ans > l * (long long)a) ans = l * (long long)a, mx = a, my = l;
}
if (ans < 1000000000000ll)
printf("%d %d", mx, my);
else
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp0, mp1;
int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int rev(int x) {
int ret = 0;
while (x) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
pair<int, int> SpeMakePair(int x, int y) {
int g = gcd(x, y);
return make_pair(x / g, y / g);
}
int main() {
int maxx, maxy, w, x, y, ansx, ansy, noww;
cin >> maxx >> maxy >> w;
for (int i = 1; i <= maxx; i++) mp0[SpeMakePair(i, rev(i))]++;
x = maxx;
y = 0;
noww = 0;
ansx = 0;
while (x > 0) {
if (noww < w) {
if (y < maxy)
y++, noww += mp0[SpeMakePair(rev(y), y)], mp1[SpeMakePair(rev(y), y)]++;
else
break;
} else {
if (ansx == 0 || x * y < ansx * ansy) ansx = x, ansy = y;
noww -= mp1[SpeMakePair(x, rev(x))];
mp0[SpeMakePair(x, rev(x))]--;
x--;
}
}
if (ansx == 0)
cout << -1 << endl;
else
cout << ansx << " " << ansy << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx, mn, w, x, cc, y, ansx, ansy;
map<double, int> m1;
map<double, int> m2;
double q;
int dz(int x) {
int ans = 0;
while (x) ans = ans * 10 + (x % 10), x /= 10;
return ans;
}
int main() {
cin >> mx >> mn >> w;
for (int i = 1; i <= mx; i++) q = i * 1.0 / dz(i), m1[q]++;
x = mx;
while (y <= mn && x >= 1) {
if (cc < w && y < mn)
y++, q = (dz(y) * 1.0) / y, cc += m1[q], m2[q]++;
else if (cc >= w) {
if (ansx * ansy > x * y || !ansx) ansx = x, ansy = y;
q = (x * 1.0) / dz(x), cc -= m2[q], m1[q]--, x--;
} else
y = mn + 1;
}
if (ansx == 0)
cout << -1;
else
cout << ansx << " " << ansy;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
const double pi = 3.1415926535897932384626433832795;
template <class T>
inline T Sqr(const T &x) {
return x * x;
}
template <class T>
inline T Abs(const T &x) {
return x >= 0 ? x : -x;
}
template <class T>
T gcd(T x, T y) {
return y == 0 ? x : gcd(y, x % y);
}
pair<int, int> calc(int x) {
int t = x, rev = 0;
while (t) {
int d = t % 10;
t /= 10;
rev = rev * 10 + d;
}
int g = gcd(x, rev);
return make_pair(x / g, rev / g);
}
pair<int, int> rev(pair<int, int> t) { return make_pair(t.second, t.first); }
map<pair<int, int>, int> m;
vector<int> nums[200000];
int q;
int getid(pair<int, int> x) {
if (m.find(x) == m.end()) {
m[x] = q++;
}
return m[x];
}
void solve() {
for (int i = 1; i <= 100000; i++) nums[getid(calc(i))].push_back(i);
int mx, my, w;
scanf("%d%d%d", &mx, &my, &w);
multiset<int> ms;
long long rescnt = 1ll << 60;
int resx = -1, resy = 1000000, cury = my + 1;
for (int i = 1; i <= mx; i++) {
int idx = getid(rev(calc(i)));
for (int j = 0; j < (nums[idx]).size(); j++)
if (nums[idx][j] < cury) ms.insert(nums[idx][j]);
if (ms.size() >= w) {
while (ms.size() > w) ms.erase(--ms.end());
int cury = *(--ms.end());
if (i * (long long)cury < rescnt) {
rescnt = i * (long long)cury;
resx = i;
resy = cury;
}
}
}
if (resx == -1)
cout << -1;
else
printf("%d %d", resx, resy);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int same[100100];
int tree[100100];
int m;
void add(int v) {
while (v <= m) {
tree[v]++;
v += (v & (v ^ (v - 1)));
}
}
int query(int v) {
int ret = 0;
while (v > 0) {
ret += tree[v];
v -= (v & (v ^ (v - 1)));
}
return ret;
}
int rev(int v) {
int ret = 0;
while (v) {
ret = ret * 10 + v % 10;
v /= 10;
}
return ret;
}
int gcd(int a, int b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int beg, end, mid, n, i, j, k, x, w, top = 0;
pair<long long, int> ret = make_pair(100000000000LL, -1);
scanf("%d %d %d", &n, &m, &w);
end = m;
for (i = 1; i <= m; i++)
if (i == rev(i)) same[top++] = i;
for (i = 1; i <= n; i++) {
x = rev(i);
k = x / gcd(x, i);
if (x == i)
for (j = 0; j < top; j++) add(same[j]);
else
for (j = k; j <= m; j += k)
if (1LL * i * j == 1LL * x * rev(j)) add(j);
beg = 0;
while (beg < end) {
mid = (beg + end) / 2;
if (query(mid) < w)
beg = mid + 1;
else
end = mid;
}
if (query(beg) >= w) ret = min(ret, make_pair(1LL * i * beg, i));
}
if (ret.second == -1)
printf("-1\n");
else
printf("%d %d\n", ret.second, ret.first / ret.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct NUM {
int x, y;
void init(int i) {
x = i;
int t = 0;
while (i) {
t = t * 10 + (i % 10);
i /= 10;
}
y = t;
}
bool operator<(const NUM &t) const { return 1LL * y * t.x <= 1LL * t.y * x; }
} num[100005];
int rev(int x) {
int res = 0;
while (x) {
res = res * 10 + (x % 10);
x /= 10;
}
return res;
}
int mx, my, w;
int a[100005];
void add(int x) {
while (x <= my) {
++a[x];
x += x & (-x);
}
}
int getSum(int x) {
int res = 0;
while (x >= 1) {
res += a[x];
x -= x & (-x);
}
return res;
}
int main() {
scanf("%d%d%d", &mx, &my, &w);
for (int i = 1; i <= my; ++i) num[i].init(i);
sort(num + 1, num + 1 + my);
int x = -1, y = -1;
long long mi;
for (int i = 1; i <= mx; ++i) {
int t = rev(i);
int l = 1, r = my;
while (l < r) {
int m = (l + r) >> 1;
if (1LL * num[m].y * t < 1LL * i * num[m].x)
l = m + 1;
else
r = m;
}
while (l <= my && 1LL * num[l].y * t == 1LL * i * num[l].x) {
add(num[l].x);
++l;
}
l = 1, r = my;
while (l < r) {
int m = (l + r) >> 1;
if (getSum(m) < w)
l = m + 1;
else
r = m;
}
if (getSum(l) >= w) {
if (x == -1)
x = i, y = l, mi = 1LL * x * y;
else if (mi > 1LL * i * l)
x = i, y = l, mi = 1LL * x * y;
}
}
if (x != -1) {
printf("%d %d\n", x, y);
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxint = 0x7fffffff;
map<pair<int, int>, vector<int> > have;
vector<int>::iterator it;
int maxx, maxy, w;
int tree[100000 * 8];
int reverse(int x) {
int y = 0;
while (x > 0) {
y = y * 10 + x % 10;
x /= 10;
}
return y;
}
int gcd(int x, int y) {
if (x < y) swap(x, y);
if (x % y == 0)
return y;
else
return gcd(y, x % y);
}
void insert(int root, int l, int r, int x) {
tree[root]++;
if (l == r) return;
int mid = (l + r) / 2;
if (x <= mid)
insert(root * 2, l, mid, x);
else
insert(root * 2 + 1, mid + 1, r, x);
}
int find(int root, int l, int r, int cnt) {
if (cnt > tree[root]) return 0;
if (l == r) return l;
int mid = (l + r) / 2;
if (cnt <= tree[root * 2])
return find(root * 2, l, mid, cnt);
else
return find(root * 2 + 1, mid + 1, r, cnt - tree[root * 2]);
}
int main() {
int i, y2, y3, g, x2, x3, ans, y, ax, ay;
scanf("%d%d%d", &maxx, &maxy, &w);
for (i = 1; i <= maxy; i++) {
y2 = i;
y3 = reverse(i);
g = gcd(y2, y3);
y2 /= g;
y3 /= g;
have[make_pair(y3, y2)].push_back(i);
}
ans = maxint;
for (i = 1; i <= maxx; i++) {
x2 = i;
x3 = reverse(i);
g = gcd(x2, x3);
x2 /= g;
x3 /= g;
for (it = have[make_pair(x2, x3)].begin();
it != have[make_pair(x2, x3)].end(); it++)
insert(1, 1, maxy, *it);
y = find(1, 1, maxy, w);
if (y != 0)
if (i * y < ans) {
ans = i * y;
ax = i;
ay = y;
}
}
if (ans == maxint)
printf("-1\n");
else
printf("%d %d\n", ax, ay);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxa, maxb, w;
int a, b, sum, ans1, ans2;
int q[11], cnt;
long long ans;
map<pair<int, int>, int> A, B;
int gcd(int a, int b) {
for (; b; b ^= a ^= b ^= a %= b)
;
return a;
}
int rev(int x) {
int sum = 0;
for (; x; x /= 10) sum = sum * 10 + x % 10;
return sum;
}
pair<int, int> get(int x, int y) {
int g = gcd(x, y);
return make_pair(x / g, y / g);
}
int main() {
scanf("%d%d%d", &maxa, &maxb, &w);
ans = 1ll * maxa * maxb + 1;
for (b = 1; b <= maxb; b++) B[get(rev(b), b)]++;
b--;
sum = 0;
for (a = 1; a <= maxa; a++) {
pair<int, int> PYC = get(a, rev(a));
sum += B[PYC];
A[PYC]++;
while (sum >= w && b > 0) {
pair<int, int> DYC = get(rev(b), b);
if (sum - A[DYC] >= w) {
sum -= A[DYC];
B[DYC]--;
b--;
} else
break;
}
if (sum >= w)
if (1ll * a * b < ans) ans = 1ll * a * b, ans1 = a, ans2 = b;
}
if (ans == 1ll * maxa * maxb + 1)
printf("-1\n");
else
printf("%d %d\n", ans1, ans2);
}
|
#include <bits/stdc++.h>
using namespace std;
int maxx, maxy, w, x, y, c, ansx, ansy;
map<double, int> p, q;
double t;
int rev(int x) {
int ans = 0;
while (x > 0) {
ans = ans * 10 + (x % 10);
x /= 10;
}
return ans;
}
int main() {
cin >> maxx >> maxy >> w;
for (int i = 1; i <= maxx; i++) {
t = i * 1.0 / rev(i);
p[t]++;
}
x = maxx;
while (y <= maxy && x >= 1) {
if (c >= w) {
if (ansx * ansy > x * y || !ansx) {
ansx = x;
ansy = y;
}
t = (x * 1.0) / rev(x);
c -= q[t];
p[t]--;
x--;
continue;
}
if (y >= maxy) {
y = maxy + 1;
continue;
}
if (c < w && y < maxy) {
y++;
t = (rev(y) * 1.0) / y;
c += p[t];
q[t]++;
}
}
if (!ansx)
cout << -1 << endl;
else
cout << ansx << " " << ansy << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int MX, MY, W;
map<pair<int, int>, int> m1, m2;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
int rev(int x) {
int res = 0;
while (x) {
res = res * 10 + (x % 10);
x /= 10;
}
return res;
}
void gs(int x) {
int a = x, b = rev(x);
int g = gcd(a, b);
a /= g;
b /= g;
m1[make_pair(a, b)]++;
}
bool okay(int y, int &total) {
int a = rev(y), b = y;
int g = gcd(a, b);
a /= g;
b /= g;
m2[make_pair(a, b)]++;
total += m1[make_pair(a, b)];
return total >= W;
}
int gety(int a, int b, int &total) {
if (total >= W) return b;
for (int i = b + 1; i <= MY; i++) {
if (okay(i, total)) return i;
}
return -1;
}
void sub(int x, int &total) {
int a = x, b = rev(x);
int g = gcd(a, b);
a /= g;
b /= g;
m1[make_pair(a, b)]--;
total -= m2[make_pair(a, b)];
}
int main() {
while (scanf("%d%d%d", &MX, &MY, &W) == 3) {
m1.clear();
m2.clear();
for (int i = 1; i <= MX; i++) gs(i);
int total = 0;
int X = MX;
int Y = gety(MX, 0, total);
if (Y == -1) {
puts("-1");
continue;
}
int AX = X, AY = Y;
long long ans = (long long)X * Y;
while (X > 1) {
sub(X, total);
X--;
Y = gety(X, Y, total);
if (Y == -1) break;
long long tmp = (long long)X * Y;
if (ans > tmp) {
ans = tmp;
AX = X;
AY = Y;
}
}
printf("%d %d\n", AX, AY);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return a == 0 ? b : gcd(b % a, a); }
int rev(int x) {
int res = 0;
for (; x; res = res * 10 + x % 10, x /= 10)
;
return res;
}
int ma, mb, w;
map<pair<int, int>, int> id;
int getID(const pair<int, int>& f) {
if (id.find(f) == id.end()) {
int sz = id.size();
id[f] = sz;
}
return id[f];
}
int a[100010];
int b[100010];
int aa[110010];
int bb[110010];
bool findans(long long cum, int& x, int& y) {
memset(aa, 0, sizeof(aa));
memset(bb, 0, sizeof(bb));
x = min(cum, (long long)ma);
y = cum / x;
long long acc = 0;
for (int i = 1; i <= x; i++) aa[a[i]]++;
for (int j = 1; j <= y; j++) {
bb[b[j]]++;
acc += aa[b[j]];
}
if (acc >= w) return true;
while (1) {
if (x == 1) break;
aa[a[x]]--;
acc -= bb[a[x]];
x--;
long long tary = cum / x;
if (tary > mb) break;
while (y < tary) {
y++;
bb[b[y]]++;
acc += aa[b[y]];
}
if (acc >= w) return true;
}
return false;
}
int main() {
id.clear();
scanf("%d%d%d", &ma, &mb, &w);
for (int i = 1; i <= ma; i++) {
int k = i;
int rk = rev(k);
int d = gcd(k, rk);
k /= d, rk /= d;
a[i] = getID(make_pair(k, rk));
}
for (int i = 1; i <= mb; i++) {
int k = i;
int rk = rev(k);
int d = gcd(k, rk);
k /= d, rk /= d;
b[i] = getID(make_pair(rk, k));
}
long long l = 1, r = (long long)ma * mb;
long long ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
int x, y;
if (findans(mid, x, y)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
if (ans == -1)
printf("-1\n");
else {
int x, y;
findans(ans, x, y);
printf("%d %d\n", x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx, mn, w, ans1, ans2, x, y, c;
map<double, int> m1, m2;
double qwq;
inline int f(int x) {
int s = 0;
while (x) {
s = s * 10 + x % 10;
x /= 10;
}
return s;
}
signed main() {
scanf("%d%d%d", &mx, &mn, &w);
x = mx;
for (int i = 1; i <= mx; ++i) {
qwq = 1.0 * i / f(i);
++m1[qwq];
}
while (x > 0 && y <= mn) {
if (c < w && y < mn) {
qwq = 1.0 * f(++y) / y;
c += m1[qwq];
++m2[qwq];
} else if (c >= w) {
if (ans1 * ans2 > x * y || !ans1) ans1 = x, ans2 = y;
qwq = 1.0 * x / f(x);
c -= m2[qwq];
--m1[qwq];
--x;
} else
y = mn + 1;
}
if (ans1)
printf("%d %d", ans1, ans2);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
struct frac {
int num, den;
frac(int a, int b) {
num = a / gcd(a, b);
den = b / gcd(a, b);
}
bool operator<(const frac& b) const {
if (num != b.num)
return num < b.num;
else
return den < b.den;
}
};
map<frac, vector<int> > M;
int reverseVal(int x) {
char s[10];
int x2;
sprintf(s, "%d", x);
reverse(s, s + strlen(s));
sscanf(s, "%d", &x2);
return x2;
}
frac get(int x) { return frac(x, reverseVal(x)); }
frac invget(int x) { return frac(reverseVal(x), x); }
int mx, my;
long long int w;
int getminx(int y, int w) {
int did = 0;
for (int x = 1; x <= 10000; x++) {
frac f = get(x);
vector<int>::iterator it = upper_bound(M[f].begin(), M[f].end(), y);
if (it != M[f].begin()) {
did += int(--it - M[f].begin() + 1);
}
if (did >= w) return x;
}
return -1;
}
long long int bit[100001];
void add(int x) {
while (x <= my) {
bit[x]++;
x += (x & -x);
}
}
long long int query(int x) {
long long int answ = 0;
while (x > 0) {
answ += (long long int)bit[x];
x -= (x & -x);
}
return answ;
}
int main(void) {
cin >> mx >> my >> w;
for (int i = 1; i <= my; i++) M[invget(i)].push_back(i);
int tot = 0;
for (map<frac, vector<int> >::iterator it = M.begin(); it != M.end(); it++)
sort(it->second.begin(), it->second.end());
memset(bit, 0, sizeof bit);
long long int best = -1;
int bx, by;
for (int i = 1; i <= mx; i++) {
frac t = get(i);
int s = M[t].size();
for (int j = 0; j < s; j++) add(M[t][j]);
long long int tot = query(my);
if (tot >= w) {
int lo = 1, hi = my;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (query(mid) >= w)
hi = mid;
else
lo = mid + 1;
}
if (query(lo) >= w) {
if (best == -1 || lo * i <= best) best = lo * i, bx = i, by = lo;
} else if (best == -1 || hi * i <= best)
best = hi * i, bx = i, by = hi;
}
}
if (best == -1)
cout << -1 << endl;
else
cout << bx << " " << by << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx, mn, w, ans1, ans2, x, y, c;
map<double, int> m1, m2;
double qwq;
inline int f(int x) {
int s = 0;
while (x) {
s = s * 10 + x % 10;
x /= 10;
}
return s;
}
signed main() {
scanf("%d%d%d", &mx, &mn, &w);
x = mx;
for (int i = 1; i <= mx; ++i) {
qwq = 1.0 * i / f(i);
++m1[qwq];
}
while (x > 0 && y <= mn) {
if (c < w && y < mn) {
qwq = 1.0 * f(++y) / y;
c += m1[qwq];
++m2[qwq];
} else if (c >= w) {
if (ans1 * ans2 > x * y || !ans1) ans1 = x, ans2 = y;
qwq = 1.0 * x / f(x);
c -= m2[qwq];
--m1[qwq];
--x;
} else
y = mn + 1;
}
if (ans1)
printf("%d %d", ans1, ans2);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[23];
double r[100003];
struct cmp {
bool operator()(const double& x, const double& y) const {
return x - y < -1e-10;
}
};
map<double, int, cmp> mpx, mpy;
int main() {
int X, Y, w;
bool swp = 0;
scanf("%d%d%d", &X, &Y, &w);
if (X > Y) swap(X, Y), swp = 1;
for (int i = 1; i <= Y; i++) {
sprintf(s, "%d", i);
int len = strlen(s);
reverse(s, s + len);
int j;
sscanf(s, "%d", &j);
r[i] = double(i) / j;
}
for (int k = 1; k <= Y; k++) mpy[r[k]]++;
mpx[r[1]]++;
long long ANS = 100000000000000000ll;
int ANSx, ANSy, res = mpy[1 / r[1]];
for (int i = 1, j = Y; i <= X && j >= 1;) {
if (res >= w) {
if ((long long)i * j < ANS) {
ANS = (long long)i * j;
ANSx = i;
ANSy = j;
}
res -= mpx[1 / r[j]];
mpy[r[j]]--;
j--;
} else {
i++;
res += mpy[1 / r[i]];
mpx[r[i]]++;
}
}
if (swp) swap(ANSx, ANSy);
if (ANS == 100000000000000000ll)
printf("-1\n");
else
printf("%d %d\n", ANSx, ANSy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100 * 1000 + 10;
map<pair<int, int>, pair<int, int> > mp;
int GCD(int a, int b);
int rev[Maxn];
int gcd[Maxn];
int w, m, n;
long long mn = 1ll << 60;
pair<int, int> ret;
void Rev(int);
map<pair<int, int>, pair<int, int> >::iterator it;
int main() {
cin >> n >> m >> w;
for (int i = 1; i <= max(m, n) + 1; i++) {
Rev(i);
gcd[i] = GCD(i, rev[i]);
}
for (int i = 1; i <= n; i++)
mp[pair<int, int>(i / gcd[i], rev[i] / gcd[i])].first++;
int p = 0, sum = 0;
for (int i = n; i > 0; i--) {
while (sum < w && p <= m) {
p++;
it = mp.find(pair<int, int>(rev[p] / gcd[p], p / gcd[p]));
if (it != mp.end()) {
sum += (*it).second.first;
(*it).second.second++;
}
}
if (p < m + 1 && mn > (long long)i * p)
mn = (long long)i * p, ret = pair<int, int>(i, p);
it = mp.find(pair<int, int>(i / gcd[i], rev[i] / gcd[i]));
if (it != mp.end()) {
sum -= (*it).second.second;
(*it).second.first--;
if ((*it).second.first == 0) mp.erase(it);
}
}
if (mn == 1ll << 60)
cout << -1 << endl;
else
cout << ret.first << " " << ret.second << endl;
return 0;
}
void Rev(int i) {
int t = i;
while (t) {
rev[i] *= 10;
rev[i] += t % 10;
t /= 10;
}
}
int GCD(int a, int b) {
if (b > a) swap(b, a);
return b ? GCD(b, a % b) : a;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 10;
const long long MOD = 1e6 + 3;
inline int in() {
int x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * flag;
}
map<double, int> Mapx, Mapy;
long long mx, my, w;
long long rev(long long x) {
long long ret = 0;
while (x) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
void upd(int flag, long long x) {
if (flag == 0)
Mapx[(double)rev(x) / (double)x]++;
else
Mapy[(double)rev(x) / (double)x]++;
}
void del(int flag, long long x) {
if (flag == 0)
Mapx[(double)rev(x) / (double)x]--;
else
Mapy[(double)rev(x) / (double)x]--;
}
int main() {
mx = in(), my = in(), w = in();
int x = 0, y = my;
long long bx = -1, by = -1;
long long ans = 0, best = 1e10;
for (int i = 1; i <= my; i++) upd(1, i);
while (x <= mx && y >= 1) {
if (ans >= w && x * y < best) bx = x, by = y, best = x * y;
if (ans < w) {
x++;
upd(0, x);
ans += Mapy[(double)x / (double)rev(x)];
} else if (ans >= w) {
ans -= Mapx[(double)y / (double)rev(y)];
del(1, y);
y--;
}
}
if (bx == -1)
printf("-1\n");
else
cout << bx << " " << by << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = (1 << 19);
long long v[MaxN], p[MaxN], s[MaxN];
void construct(int x, int l, int r) {
s[x] = r - l + 1;
if (l == r) return;
int mid = (l + r) >> 1;
construct(x * 2, l, mid);
construct(x * 2 + 1, mid + 1, r);
}
int L, R;
inline void add(int x, int V) {
v[x] += V * s[x];
p[x] += V;
}
inline void prop(int x) {
add(x * 2, p[x]);
add(x * 2 + 1, p[x]);
p[x] = 0;
}
void update(int x, int l, int r) {
if (l > R || r < L) return;
if (l >= L && r <= R) {
add(x, 1);
return;
}
prop(x);
int mid = (l + r) >> 1;
update(x * 2, l, mid);
update(x * 2 + 1, mid + 1, r);
s[x] = s[x * 2] + s[x * 2 + 1];
v[x] = v[x * 2] + v[x * 2 + 1];
}
int get(int x, int l, int r) {
if (l > R || r < L) return 0;
if (l == r) return v[x];
prop(x);
int mid = (l + r) >> 1;
int ret = get(x * 2, l, mid) + get(x * 2 + 1, mid + 1, r);
s[x] = s[x * 2] + s[x * 2 + 1];
v[x] = v[x * 2] + v[x * 2 + 1];
return ret;
}
void rem(int x, int l, int r) {
if (l > R || r < L) return;
--s[x];
if (l == r) {
v[x] = 0;
return;
}
prop(x);
int mid = (l + r) >> 1;
rem(x * 2, l, mid);
rem(x * 2 + 1, mid + 1, r);
s[x] = s[x * 2] + s[x * 2 + 1];
v[x] = v[x * 2] + v[x * 2 + 1];
}
int rev(int x) {
int ret = 0;
while (x > 0) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
int n, m, w;
long long A[MaxN], B[MaxN];
int q[MaxN], pos[MaxN];
int cmp(int x, int y) {
if (A[x] * B[y] != A[y] * B[x]) return A[x] * B[y] < A[y] * B[x];
return x < y;
}
int lower(int a, int b) {
int lo, hi;
lo = 0;
hi = m;
while (lo < hi) {
int mi = (lo + hi) >> 1;
if (A[q[mi]] * b < a * B[q[mi]])
lo = mi + 1;
else
hi = mi;
}
return lo;
}
int upper(int a, int b) {
int lo, hi;
lo = 0;
hi = m;
while (lo < hi) {
int mi = (lo + hi) >> 1;
if (A[q[mi]] * b <= a * B[q[mi]])
lo = mi + 1;
else
hi = mi;
}
return lo - 1;
}
int main(void) {
scanf("%d%d%d", &n, &m, &w);
for (int i = 1; i <= m; ++i) {
A[i] = rev(i);
B[i] = i;
q[i - 1] = i;
}
sort(q, q + m, cmp);
for (int i = 0; i < m; ++i) pos[q[i]] = i;
construct(1, 0, m - 1);
long long sol = ((long long)1 << (long long)62);
int sa, sb;
sa = sb = -1;
int last = m;
for (int i = 1; i <= n; ++i) {
L = lower(i, rev(i));
R = upper(i, rev(i));
if (R < L) continue;
update(1, 0, m - 1);
while (v[1] >= w) {
L = pos[last];
R = L;
int x = get(1, 0, m - 1);
if (v[1] - x >= w) {
rem(1, 0, m - 1);
--last;
} else
break;
}
if (v[1] >= w)
if (sol > (long long)i * (long long)last) {
sol = (long long)i * (long long)last, sa = i;
sb = last;
}
}
if (sa != -1)
printf("%d %d\n", sa, sb);
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mx, my, w;
map<double, int> a, b;
int rev(long long x) {
long long ret = 0;
while (x) {
ret *= 10;
ret += x % 10;
x /= 10;
}
return ret;
}
long long get(long long x, long long y) {
a.clear();
for (long long i = 1; i <= y; ++i) {
double tmp = 1.0 * rev(i) / i;
a[tmp]++;
}
long long ret = 0;
for (long long i = 1; i <= x; ++i) {
double tmp = 1.0 * i / rev(i);
ret += a[tmp];
}
return ret;
}
int main() {
cin >> mx >> my >> w;
if (get(mx, my) < w) {
puts("-1");
return 0;
}
int nx = mx, ny = 1, ax = mx, ay = my;
long long now = get(nx, ny);
a.clear();
for (long long i = 1; i <= nx; ++i) {
a[1.0 * i / rev(i)]++;
}
b.clear();
for (long long i = 1; i <= ny; ++i) {
b[1.0 * rev(i) / i]++;
}
while (nx >= 1 && ny <= my) {
if (now < w) {
ny++;
double tmp = 1.0 * rev(ny) / ny;
now += a[tmp];
b[tmp]++;
} else {
if (1ll * nx * ny < 1ll * ax * ay) {
ax = nx;
ay = ny;
}
double tmp = 1.0 * nx / rev(nx);
nx--;
now -= b[tmp];
a[tmp]--;
}
}
cout << ax << " " << ay << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
int rev(int x) {
int ret = 0;
while (x) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
map<pair<int, int>, int> m1, m2;
int ansx, ansy;
void check(int x, int y) {
if (ansx == -1 || ((long long)ansx) * ansy > ((long long)x) * y)
ansx = x, ansy = y;
}
int main() {
int xmax, ymax, w;
ansx = ansy = -1;
scanf("%d%d%d", &xmax, &ymax, &w);
int now = 0, x = 0, y = ymax;
for (int i = 1, j, d; i <= ymax; i++) {
j = rev(i);
d = gcd(i, j);
m2[make_pair(i / d, j / d)]++;
}
for (x = 1; x <= xmax; x++) {
int i = x, j = rev(x), d = gcd(i, j);
m1[make_pair(i / d, j / d)]++;
now += m2[make_pair(j / d, i / d)];
while (now >= w) {
check(x, y);
i = y, j = rev(y), d = gcd(i, j);
m2[make_pair(i / d, j / d)]--;
now -= m1[make_pair(j / d, i / d)];
y--;
}
}
if (ansx == -1)
puts("-1");
else
printf("%d %d\n", ansx, ansy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> A, B;
int MA, MB, W;
int r1, r2;
int rev(int u) {
int v = 0;
for (; u; u /= 10) v = v * 10 + u % 10;
return v;
}
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
scanf("%d%d%d", &MA, &MB, &W);
for (int i = 1; i <= MA; i++) {
int u = i, v = rev(i);
A[make_pair(u / gcd(u, v), v / gcd(u, v))]++;
}
r1 = r2 = -1;
long long now = 0;
for (int i = MA, j = 0; i; i--) {
while (j < MB && now < W) {
++j;
int u = rev(j), v = j;
pair<int, int> tmp = make_pair(u / gcd(u, v), v / gcd(u, v));
now += A[tmp];
B[tmp]++;
}
if (now >= W) {
if (r1 == -1 || (long long)r1 * r2 > (long long)i * j) r1 = i, r2 = j;
}
int u = i, v = rev(i);
pair<int, int> tmp = make_pair(u / gcd(u, v), v / gcd(u, v));
now -= B[tmp];
A[tmp]--;
}
if (r1 == -1)
printf("-1\n");
else
printf("%d %d\n", r1, r2);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cerr << *i << ' ';
cout << endl;
}
long long rev(long long x) {
long long res = 0;
for (; x; x /= 10) res = res * 10 + (x % 10);
return res;
}
long long gcd(long long a, long long b) { return b != 0 ? gcd(b, a % b) : a; }
pair<long long, long long> gen(long long x, int s) {
long long r = rev(x);
long long g = gcd(x, r);
x /= g;
r /= g;
if (s == 0)
return make_pair(x, r);
else
return make_pair(r, x);
}
int main() {
long long maxX, maxY, W;
while (cin >> maxX >> maxY >> W) {
map<pair<long long, long long>, int> countX, countY;
for (int x = 1; x <= maxX; x++) {
++countX[gen(x, 0)];
}
long long best = maxX * maxY + 10;
vector<int> res(2, -1);
int curW = 0;
long long y = 0;
for (int x = maxX; x >= 1 && y <= maxY;) {
if (curW >= W) {
if (best > x * y) {
best = x * y;
res[0] = x;
res[1] = y;
}
}
if (curW < W) {
y++;
++countY[gen(y, 1)];
curW += countX[gen(y, 1)];
} else {
--countX[gen(x, 0)];
curW -= countY[gen(x, 0)];
x--;
}
}
if (res[0] == -1)
cout << res[0] << endl;
else
cout << res[0] << ' ' << res[1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 2e5 + 5;
inline int read() {
int sum = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum * f;
}
int mx, my, w, x, y, ansx, ansy;
int rev(int x) {
int ans = 0;
while (x) {
ans = ans * 10 + x % 10;
x /= 10;
}
return ans;
}
map<double, int> m1, m2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> mx >> my >> w;
for (int x = 1; x <= mx; x++) {
double tmp = x * 1.0 / rev(x);
m1[tmp]++;
}
x = mx;
int cnt = 0;
while (y <= my && x >= 1) {
if (cnt < w) {
y++;
double tmp = rev(y) * 1.0 / y;
cnt += m1[tmp];
m2[tmp]++;
} else {
if (!ansx || x * y < ansx * ansy) {
ansx = x;
ansy = y;
}
double tmp = x * 1.0 / rev(x);
cnt -= m2[tmp];
m1[tmp]--;
x--;
}
}
if (!ansx)
cout << -1 << '\n';
else
cout << ansx << ' ' << ansy << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int w;
int rev[100001];
int getrev(int x) {
vector<int> v;
while (x) {
v.push_back(x % 10);
x /= 10;
}
int ans = 0;
for (int i = 0; i < (((int)(v).size())); i++) ans = ans * 10 + v[i];
return ans;
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
vector<pair<pair<int, int>, int> > v;
int s[105000];
int findsum(int l, int r) {
long long sum = 0;
int x = r;
while (x > 0) {
sum += s[x];
x &= x - 1;
}
x = l - 1;
while (x > 0) {
sum -= s[x];
x &= x - 1;
}
return sum;
}
void modify(int x, int val) {
while (x < m + 5) {
s[x] += val;
x |= x - 1;
x++;
}
}
int zlo;
void add(int x) {
int sx = x;
int y = rev[x];
int d = gcd(x, y);
y /= d;
x /= d;
int p = lower_bound((v).begin(), (v).end(), make_pair(make_pair(y, x), -1)) -
v.begin();
pair<int, int> o = make_pair(y, x);
while (p < ((int)(v).size()) && v[p].first == o) {
modify(v[p].second, 1);
p++;
zlo++;
}
}
int main() {
cin >> n >> m >> w;
int nn = max(n, m);
for (int i = 0; i < (nn + 1); i++) rev[i] = getrev(i);
for (int i = 1; i <= nn; i++) {
int d = gcd(i, rev[i]);
v.push_back(make_pair(make_pair(i / d, rev[i] / d), i));
}
sort((v).begin(), (v).end());
long long ax, ay;
int f = 0;
ax = 1000000;
ay = 1000000;
for (int i = 1; i <= n; i++) {
add(i);
int l = 1, r = m;
if (findsum(1, m) < w) continue;
int savec = 0;
while (l <= r) {
int c = (l + r) / 2;
if (findsum(1, c) < w)
l = c + 1;
else {
r = c - 1;
savec = c;
f = 1;
}
}
if ((long long)savec * (long long)i < ax * ay) {
ax = i;
ay = savec;
}
}
if (!f) {
cout << -1 << endl;
return 0;
}
cout << ax << ' ' << ay << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx, my, w, x, y, tot, bestx = 100001, besty = 100001;
map<pair<int, int>, int> xc, yc;
pair<int, int> xfr[100001], yfr[100001];
int rev(int a) {
int b = 0;
for (; a; a /= 10) b = b * 10 + a % 10;
return b;
}
int gcd(int a, int b) {
while (b) {
int t = b;
b = a % b;
a = t;
}
return a;
}
pair<int, int> frac(int a, int b) {
int g = gcd(a, b);
return make_pair(a / g, b / g);
}
int main() {
scanf("%d%d%d", &mx, &my, &w);
for (x = 1; x <= mx; x++) xfr[x] = frac(x, rev(x));
for (y = 1; y <= my; y++) yfr[y] = frac(rev(y), y);
for (x = 1; x <= mx; x++) xc[xfr[x]]++;
for (x = mx, y = 1; x; x--) {
for (; tot + xc[yfr[y]] < w && y <= my; y++) {
yc[yfr[y]]++;
tot += xc[yfr[y]];
}
if (tot + xc[yfr[y]] >= w && (long long)x * y < (long long)bestx * besty)
bestx = x, besty = y;
xc[xfr[x]]--;
tot -= yc[xfr[x]];
}
if (bestx != 100001)
printf("%d %d\n", bestx, besty);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long maxx, maxy, W, cnt, ansx, ansy;
map<double, long long> map1, map2;
inline int rev(int x) {
int ans = 0;
for (; x; x /= 10) (ans *= 10) += x % 10;
return ans;
}
int main() {
scanf("%lld%lld%lld", &maxx, &maxy, &W);
for (int i = (1); i <= (maxx); ++i) ++map1[1. * i / rev(i)];
for (int i = (1); i <= (maxy); ++i) cnt += map1[1. * rev(i) / i];
if (cnt < W) return puts("-1"), 0;
long long tx = maxx, ty = 1LL;
long long ansx = maxx, ansy = maxy;
cnt = map1[1.], ++map2[1.];
while (tx && ty ^ maxy) {
if (cnt >= W) {
if (tx * ty < ansx * ansy) ansx = tx, ansy = ty;
double quo = 1. * tx / rev(tx);
--tx;
cnt -= map2[quo], --map1[quo];
} else {
++ty;
double quo = 1. * rev(ty) / ty;
cnt += map1[quo], ++map2[quo];
}
}
printf("%lld %lld\n", ansx, ansy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> D;
int rev(int x) {
if (D[x] != -1) return D[x];
int p = 1;
while (1) {
if (p >= x) {
if (p > x) p /= 10;
break;
}
p *= 10;
}
int res = 0;
while (x) {
res += (x % 10) * p;
p /= 10;
x /= 10;
}
D[x] = res;
return res;
}
int gcd(int a, int b) {
while (b != 0) {
int t = a % b;
a = b;
b = t;
}
return a;
}
int main() {
istream &in = cin;
D.resize(100001, -1);
int mx, my, w, cnt = 0;
in >> mx >> my >> w;
map<pair<int, int>, int> MX, MY;
long long x, y;
for (x = 1; x <= mx; x++) {
int rx = rev(x);
int g = gcd(x, rx);
if (x / g == 1 && rx / g == 1) {
int tt = 0;
}
MX[make_pair(x / g, rx / g)]++;
}
int cw = 0;
long long ax, ay;
for (y = 1; y <= my; y++) {
int ry = rev(y);
int g = gcd(y, ry);
pair<int, int> p = make_pair(ry / g, y / g);
cw += MX[p];
MY[p]++;
if (cw >= w) break;
}
if (cw < w) {
cout << -1;
return 0;
}
x = mx;
ax = x;
ay = y;
for (; x >= 1;) {
int rx = rev(x);
int g = gcd(x, rx);
pair<int, int> px = make_pair(x / g, rx / g);
int decr = MY[px];
MX[px]--;
x--;
cw -= decr;
if (cw >= w && x * y < ax * ay) {
ax = x;
ay = y;
}
if (cw < w) {
bool ok = false;
for (;;) {
if (y == my) break;
y++;
int ry = rev(y);
int g = gcd(y, ry);
pair<int, int> py = make_pair(ry / g, y / g);
int inc = MX[py];
MY[py]++;
cw += inc;
if (cw >= w) {
if (x * y < ax * ay) {
ax = x;
ay = y;
}
ok = true;
break;
}
}
if (!ok) {
break;
}
}
}
cout << ax << " " << ay;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxx, maxy, w;
map<pair<int, int>, int> cntx, cnty;
int mcd(int a, int b) {
int tmp;
while (b != 0) {
tmp = b;
b = a % b;
a = tmp;
}
return a;
}
int rev(int n) {
int ret = 0;
while (n > 0) {
ret = 10 * ret + (n % 10);
n /= 10;
}
return ret;
}
pair<int, int> mpair(int x, int rx) {
int d = mcd(x, rx);
return pair<int, int>(rx / d, x / d);
}
int main() {
cin >> maxx >> maxy >> w;
long long bestx = maxx, besty = maxy;
cntx.clear();
cnty.clear();
for (int x = 1; x <= maxx; x++) cntx[mpair(x, rev(x))]++;
long long y = 1, x = maxx;
int cur_count = cntx[mpair(rev(1), 1)];
cnty[mpair(rev(1), 1)]++;
while (y < maxy && cur_count < w) {
y++;
cur_count += cntx[mpair(rev(y), y)];
cnty[mpair(y, rev(y))]++;
}
if (y == maxy && cur_count < w) {
cout << -1 << endl;
return 0;
}
while (x >= 1 && y <= maxy) {
while (x >= 1 && cur_count - cnty[mpair(rev(x), x)] >= w) {
cntx[mpair(x, rev(x))]--;
cur_count -= cnty[mpair(rev(x), x)];
x--;
}
if (x * y < bestx * besty) {
bestx = x;
besty = y;
}
y++;
if (y <= maxy) {
cur_count += cntx[mpair(rev(y), y)];
cnty[mpair(y, rev(y))]++;
}
}
cout << bestx << " " << besty << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 5;
map<pair<int, int>, int> remx, remy;
int d[MAXN];
int rev[MAXN];
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
int get_rev(int x) {
int res = 0, a;
while (x) {
a = x % 10;
res = res * 10 + a;
x /= 10;
}
return res;
}
void init(int ma) {
remx.clear(), remy.clear();
for (int i = 1; i <= ma; i++) rev[i] = get_rev(i);
for (int i = 1; i <= ma; i++) {
d[i] = gcd(i, rev[i]);
remy[make_pair(i / d[i], rev[i] / d[i])]++;
}
}
void solve(int max_x, int max_y, int W) {
bool flag = false;
if (max_x > max_y) {
swap(max_x, max_y);
flag = true;
}
init(max_y);
int x = 1, y = max_y;
int now = remy[make_pair(1, 1)];
remx[make_pair(1, 1)]++;
int ans_x = -1, ans_y = -1;
while (x <= y) {
while (x < y && x < max_x && now < W) {
x++;
remx[make_pair(rev[x] / d[x], x / d[x])]++;
now += remy[make_pair(rev[x] / d[x], x / d[x])];
}
if (now < W) break;
if (ans_x == -1 || (long long)x * y < (long long)ans_x * ans_y) {
ans_x = x, ans_y = y;
}
remy[make_pair(y / d[y], rev[y] / d[y])]--;
now -= remx[make_pair(y / d[y], rev[y] / d[y])];
y--;
}
if (flag) swap(ans_x, ans_y);
if (ans_x == -1)
puts("-1");
else
printf("%d %d\n", ans_x, ans_y);
return;
}
int main() {
int max_x, max_y, W;
while (~scanf("%d %d %d", &max_x, &max_y, &W)) {
solve(max_x, max_y, W);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
pair<int, int> flip(pair<int, int> p) { return make_pair(p.second, p.first); }
int rev(int x) {
int r = 0;
for (; x; x /= 10) {
r = r * 10 + x % 10;
}
return r;
}
pair<int, int> get(int x) {
int rx = rev(x);
int d = gcd(x, rx);
pair<int, int> p(x / d, rx / d);
return p;
}
int main() {
int maxx, maxy, w;
cin >> maxx >> maxy >> w;
map<pair<int, int>, vector<int> > m;
for (int i = 1; i <= 100000; ++i) {
m[get(i)].push_back(i);
}
int y = maxy;
int s = 0;
int ansX = -1, ansY = -1;
long long mn = 1LL << 60;
for (int x = 1; x <= maxx; ++x) {
pair<int, int> py = flip(get(x));
s += upper_bound((m[py]).begin(), (m[py]).end(), y) - m[py].begin();
while (y >= 1) {
pair<int, int> px = flip(get(y));
int d = upper_bound((m[px]).begin(), (m[px]).end(), x) - m[px].begin();
if (s - d >= w) {
s -= d;
--y;
} else {
break;
}
}
if (s >= w && (long long)x * y < mn) {
mn = (long long)x * y;
ansX = x;
ansY = y;
}
}
if (mn == 1LL << 60)
puts("-1");
else
printf("%d %d\n", ansX, ansY);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
vector<int> p[maxn + 10];
map<int, int> l[maxn + 10], r[maxn + 10];
int pre[maxn + 10];
map<map<int, int>, int> s1, s2;
void prepare() {
memset(pre, 0, sizeof(pre));
for (int i = 2; i <= maxn; ++i)
if (!pre[i]) {
pre[i] = i;
for (int j = i + i; j <= maxn; j += i) pre[j] = i;
}
for (int i = 2; i <= maxn; ++i) {
if (pre[i]) p[i] = p[i / pre[i]];
p[i].push_back(pre[i]);
}
map<int, int> tmp;
for (int i = 1; i <= maxn; ++i) {
int j = 0, k = i;
while (k) {
j = j * 10 + k % 10;
k /= 10;
}
tmp.clear();
for (int k = 0; k != p[i].size(); ++k) ++tmp[p[i][k]];
for (int k = 0; k != p[j].size(); ++k) --tmp[p[j][k]];
for (map<int, int>::iterator iter = tmp.begin(); iter != tmp.end(); ++iter)
if (iter->second != 0) l[i][iter->first] = iter->second;
tmp.clear();
for (int k = 0; k != p[i].size(); ++k) --tmp[p[i][k]];
for (int k = 0; k != p[j].size(); ++k) ++tmp[p[j][k]];
for (map<int, int>::iterator iter = tmp.begin(); iter != tmp.end(); ++iter)
if (iter->second != 0) r[i][iter->first] = iter->second;
}
}
int main() {
prepare();
int maxx, maxy, w;
cin >> maxx >> maxy >> w;
for (int i = 1; i <= maxx; ++i) ++s1[l[i]];
long long retx = 0, rety = 0;
long long cnt = 0;
for (long long i = maxx, j = 0; i > 0; --i) {
while (j < maxy && cnt < w) {
++j;
cnt += s1[r[j]];
++s2[r[j]];
}
if (cnt < w) break;
if (i * j < retx * rety || retx * rety < w) {
retx = i;
rety = j;
}
cnt -= s2[l[i]];
--s1[l[i]];
}
if (retx * rety < w)
cout << -1;
else
cout << retx << " " << rety;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int rev(int x) {
int res = 0;
while (x > 0) res *= 10, res += x % 10, x /= 10;
return res;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
pair<int, int> pt(int a, int b) {
int g = gcd(a, b);
return make_pair(a / g, b / g);
}
int main() {
long long res = 1000000000000LL, rx, ry;
int maxx, maxy, w, cur = 0;
cin >> maxx >> maxy >> w;
map<pair<int, int>, int> mx, my;
for (int _n((maxx)), i(1); i <= _n; i++) mx[pt(i, rev(i))]++;
for (int _n((maxy)), i(1); i <= _n; i++) my[pt(rev(i), i)]++;
for (map<pair<int, int>, int>::iterator it = mx.begin(); it != mx.end(); it++)
cur += it->second * my[it->first];
int cx = maxx, cy = maxy;
if (cur < w) {
cout << -1 << endl;
return 0;
}
rx = cx;
ry = cy;
res = (long long)(cx)*cy;
while (cx >= 1) {
pair<int, int> cd = pt(cx, rev(cx));
if (cur - my[cd] >= w) {
mx[cd]--;
cur -= my[cd];
cx--;
} else
break;
}
while (cx <= maxx && cy >= 1) {
if (res > (long long)(cx)*cy) {
res = (long long)(cx)*cy;
rx = cx;
ry = cy;
}
if (cy == 1 || cx == maxx) break;
pair<int, int> a = pt(cx + 1, rev(cx + 1));
pair<int, int> b = pt(rev(cy), cy);
if (cur - mx[b] >= w) {
my[b]--;
cur -= mx[b];
cy--;
} else {
mx[a]++;
cur += my[a];
cx++;
}
}
cout << rx << " " << ry << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100 * 1000 + 10;
map<long double, pair<int, int> > mp;
int rev[Maxn];
int w, m, n;
long long mn = 1ll << 60;
pair<int, int> ret;
void Rev();
map<long double, pair<int, int> >::iterator it;
int main() {
cin >> n >> m >> w;
Rev();
for (int i = 1; i <= n; i++) mp[(long double)i / rev[i]].first++;
int p = 0, sum = 0;
for (int i = n; i > 0; i--) {
while (sum < w && p <= m) {
p++;
it = mp.find((long double)rev[p] / p);
if (it != mp.end()) {
sum += (*it).second.first;
(*it).second.second++;
}
}
if (p < m + 1 && mn > (long long)i * p)
mn = (long long)i * p, ret = pair<int, int>(i, p);
it = mp.find((long double)i / rev[i]);
if (it != mp.end()) {
sum -= (*it).second.second;
(*it).second.first--;
if (!(*it).second.first) mp.erase(it);
}
}
if (mn == 1ll << 60)
cout << -1 << endl;
else
cout << ret.first << " " << ret.second << endl;
return 0;
}
void Rev() {
for (int i = 1; i <= max(n, m); i++) {
int t = i;
while (t) {
rev[i] *= 10;
rev[i] += t % 10;
t /= 10;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
pair<int, int> divide(int a, int b) {
assert(a >= 1 && b >= 1);
int d = gcd(a, b);
return make_pair(a / d, b / d);
}
template <typename T>
class fenv_tree {
vector<T> tr;
int f(int x) { return x - (x & (x - 1)); }
public:
fenv_tree(int n) { tr = vector<T>(n + 1); }
void add(int x, const T &v) {
x++;
for (; x < tr.size(); x += f(x)) tr[x] += v;
}
T get(int x) {
x++;
T val;
for (; x > 0; x -= f(x)) val += tr[x];
return val;
}
};
const int MAXN = 1e5;
int rev[MAXN + 1];
int main() {
for (int i = 0; i <= MAXN; i++) {
int x = i, y = 0;
for (; x; x /= 10) y = y * 10 + x % 10;
rev[i] = y;
}
assert(rev[12345] == 54321);
assert(rev[1200] == 21);
int mx, my, w;
while (scanf("%d%d%d", &mx, &my, &w) >= 1) {
map<pair<int, int>, vector<int> > cnts;
for (int b = 1; b <= my; b++) {
pair<int, int> cur = divide(rev[b], b);
cnts[cur].push_back(b);
}
long long ans = 1e18;
int ax = -1, ay = -1;
fenv_tree<long long> tr(my + 1);
for (int a = 1; a <= mx; a++) {
pair<int, int> cur = divide(a, rev[a]);
for (int i = 0; i < cnts[cur].size(); i++) tr.add(cnts[cur][i], 1);
if (tr.get(my) >= w) {
int L = 0, R = my;
while (L + 1 < R) {
int M = (L + R) / 2;
if (tr.get(M) >= w)
R = M;
else
L = M;
}
if ((long long)a * R < ans) {
ans = (long long)a * R;
ax = a;
ay = R;
}
}
}
if (ax < 0)
printf("-1\n");
else
printf("%d %d\n", ax, ay);
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
int ele[100];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int rev(int x) {
int l = 0;
while (x) {
ele[++l] = x % 10;
x /= 10;
}
for (int i = 1; i <= l; i++) {
x = x * 10 + ele[i];
}
return x;
}
struct Solve {
map<int, int> fac[MAXN];
int now;
void init(int x) {
for (int i = 1; i <= x; i++) fac[i].clear();
now = 0;
}
void add() {
now++;
int a = now, b = rev(now);
int c = gcd(a, b);
b /= c;
a /= c;
fac[b][a]++;
}
void del() {
int a = now, b = rev(now);
int c = gcd(a, b);
a /= c;
b /= c;
fac[b][a]--;
now--;
}
int calc(int x) {
int a = x, b = rev(x);
int c = gcd(a, b);
a /= c;
b /= c;
return fac[a][b];
}
} solve[2];
int ansx, ansy;
long long ans = (1ll << 60);
int main() {
int mx, my, k;
scanf("%d %d %d", &mx, &my, &k);
solve[0].init(mx);
solve[1].init(my);
long long now = 0;
for (int i = 1; i <= my; i++) {
solve[1].add();
}
for (int i = 1; i <= mx; i++) {
now += solve[1].calc(i);
solve[0].add();
while (1) {
if (solve[1].now == 0) break;
int tmp = solve[0].calc(solve[1].now);
if (now - tmp >= k) {
solve[1].del();
now -= tmp;
} else {
break;
}
}
if (now >= k && (long long)solve[0].now * solve[1].now < ans) {
ans = (long long)solve[0].now * solve[1].now;
ansx = solve[0].now;
ansy = solve[1].now;
}
}
if (ans == (1ll << 60)) {
printf("-1\n");
} else {
printf("%d %d\n", ansx, ansy);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
template <class T>
bool INRANGE(T x, T a, T b) {
return a <= x && x <= b;
}
const int MAX_N = 100005;
int bit[MAX_N + 1];
void bit_add(int xi, int v) {
for (int x = xi; x <= MAX_N; x += x & -x) {
bit[x] += v;
}
}
long long bit_sum(int xi) {
long long ret = 0;
for (int x = xi; x >= 1; x -= x & -x) {
ret += bit[x];
}
return ret;
}
int rev(int x) {
int ret = 0;
bool start = false;
while (x) {
if (start) ret *= 10;
if (x % 10) start = true;
ret += x % 10;
x /= 10;
}
return ret;
}
long long gcd(long long x, long long y) {
long long t;
while (y != 0) {
t = x % y;
x = y;
y = t;
}
return x;
}
int main() {
int X, Y, W;
scanf("%d%d%d", &X, &Y, &W);
map<pair<int, int>, vector<int> > mp;
for (int a = 1; a <= 100000; a++) {
int bunshi = a;
int bunbo = rev(a);
int gc = (int)gcd(bunshi, bunbo);
bunshi /= gc;
bunbo /= gc;
mp[make_pair(bunshi, bunbo)].push_back(a);
}
const long long LBIG = 98765432198765LL;
long long ab = LBIG;
int besta = 0;
int bestb = 0;
memset(bit, 0, sizeof(bit));
for (int a = 1; a <= X; a++) {
int bunshi = rev(a);
int bunbo = a;
int gc = (int)gcd(bunshi, bunbo);
bunshi /= gc;
bunbo /= gc;
for (int i = 0; i < ((int)mp[make_pair(bunshi, bunbo)].size()); i++) {
bit_add(mp[make_pair(bunshi, bunbo)][i], 1);
}
{
int lo = 0;
int hi = Y;
while (lo < hi) {
int mid = lo + (hi - lo) / 2LL;
if (bit_sum(mid) >= W) {
hi = mid;
} else {
lo = mid + 1;
}
}
if (bit_sum(lo) >= W) {
if (ab > (long long)a * lo) {
ab = (long long)a * lo;
besta = a;
bestb = lo;
}
}
}
}
if (ab == LBIG) {
printf("-1\n");
} else {
printf("%d %d\n", besta, bestb);
}
return 0;
}
|
#include <bits/stdc++.h>
bool DEBUG = false;
using namespace std;
int rev(int arg) {
int res = 0;
while (arg > 0) {
res = res * 10 + (arg % 10);
arg /= 10;
}
return res;
}
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
int maxx, maxy, w, ax, ay, x, y, n, t;
pair<int, int> mas[200000], r[200000];
map<pair<int, int>, int> mp, dup;
int main() {
cin >> maxx >> maxy >> w;
ax = ay = -1;
n = ((maxx) > (maxy) ? (maxx) : (maxy));
for (int i = (1); i <= (n); ++i) {
mas[i] = make_pair(i, rev(i));
t = gcd(mas[i].first, mas[i].second);
mas[i].first /= t;
mas[i].second /= t;
r[i] = make_pair(mas[i].second, mas[i].first);
}
for (int i = (1); i <= (maxx); ++i)
if (mp.find(mas[i]) == mp.end())
mp[mas[i]] = 1;
else
mp[mas[i]]++;
if (DEBUG) {
for (map<pair<int, int>, int>::iterator it = mp.begin(); it != mp.end();
it++) {
pair<pair<int, int>, int> p = *it;
cout << "(" << p.first.first << ";" << p.first.second << ") " << p.second
<< ": ";
for (int i = (1); i <= (maxx); ++i)
if (mas[i] == p.first) cout << i << " ";
cout << endl;
}
}
int res = 0;
int cur = 0;
x = maxx;
y = 0;
while (x > 0) {
if (res < w) {
y++;
while (y <= maxy) {
res += mp[r[y]];
dup[r[y]]++;
if (DEBUG) {
cout << "res"
<< ": " << (res) << endl;
};
if (res >= w) break;
y++;
}
}
if (DEBUG) {
cout << "After shift" << endl;
};
if (DEBUG) {
cout << "x"
<< ": " << (x) << endl;
};
if (DEBUG) {
cout << "y"
<< ": " << (y) << endl;
};
if (DEBUG) {
cout << "res"
<< ": " << (res) << endl;
};
if (y > maxy) break;
if (ax == -1 || x * y < ax * ay) {
ax = x;
ay = y;
}
if (DEBUG) {
cout << "ax"
<< ": " << (ax) << endl;
};
if (DEBUG) {
cout << "ay"
<< ": " << (ay) << endl;
};
res -= dup[mas[x]];
if (DEBUG) {
cout << "dup[mas[x]]"
<< ": " << (dup[mas[x]]) << endl;
};
mp[mas[x]]--;
x--;
}
if (ax == -1)
puts("-1");
else
cout << ax << " " << ay << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Inf = (long long)1e16;
const int N = 101000;
int x, y, w, a[N], b[N];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int calc(int x) {
int ret = 0;
while (x) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
void init() {
for (int i = 1; i < N; i++) {
a[i] = i;
b[i] = calc(i);
int g = gcd(a[i], b[i]);
a[i] /= g;
b[i] /= g;
}
}
int main() {
init();
cin >> x >> y >> w;
map<pair<int, int>, int> m1, m2;
int p, total = 0;
for (p = 1; p <= x; p++) {
m1[make_pair(b[p], a[p])]++;
}
p = x;
int ax = -1, ay = -1;
long long pro = Inf;
for (int i = 1; i <= y; i++) {
m2[make_pair(a[i], b[i])]++;
total += m1[make_pair(a[i], b[i])];
while (p > 1 && total - m2[make_pair(b[p], a[p])] >= w) {
total -= m2[make_pair(b[p], a[p])];
m1[make_pair(b[p], a[p])]--;
p--;
}
if (total >= w && pro > (long long)p * i) {
ax = p;
ay = i;
pro = (long long)p * i;
}
}
if (pro == Inf) {
puts("-1");
} else {
printf("%d %d\n", ax, ay);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx, mn, w, x, y, ansx, ansy, co = 0;
int rev(int k) {
int p = 0;
while (k > 0) {
p = p * 10 + (k % 10);
k /= 10;
}
return p;
}
int main() {
map<double, int> m1;
map<double, int> m2;
double q;
cin >> mx;
cin >> mn;
cin >> w;
for (x = 1; x <= mx; x++) {
q = (double)(x * 1.0 / rev(x));
m1[q]++;
}
x = mx;
y = 0;
co = 0;
while (y <= mn && x >= 1) {
if (co < w) {
y++;
q = (double)((rev(y) * 1.0) / y);
co += m1[q];
m2[q]++;
} else {
if (ansx * ansy > x * y || ansx == 0) {
ansx = x;
ansy = y;
}
q = (double)((x * 1.0) / rev(x));
co -= m2[q];
m1[q]--;
x--;
}
}
if (ansx == 0)
cout << -1;
else
cout << ansx << " " << ansy;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx, my, w, cnt, px, py, rx, ry, dp[100010];
double t;
map<double, int> ma, mb;
long long res = 10000000000000;
int rev(int a) {
if (dp[a] != 0) return dp[a];
int ret = 0;
while (a) {
ret *= 10;
ret += a % 10;
a /= 10;
}
return dp[a] = ret;
}
int main() {
cin >> mx >> my >> w;
for (int i = 1; i <= my; i++) mb[(rev(i) * 1.0 / i)]++;
for (int i = 1; i <= mx; i++) cnt += mb[i * 1.0 / rev(i)];
if (cnt < w) {
cout << -1 << endl;
return 0;
}
cnt = mb[1.0];
py = my;
ma[1.0]++;
px = 1;
while (py >= 1 && px <= mx) {
if (cnt >= w) {
if (res > (long long)px * py) {
res = (long long)px * py;
rx = px;
ry = py;
}
t = rev(py) * 1.0 / py;
cnt -= ma[t];
mb[t]--;
py--;
} else {
px++;
t = px * 1.0 / rev(px);
cnt += mb[t];
ma[t]++;
}
}
cout << rx << " " << ry << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 2e15;
int rev(int a) {
vector<int> temp;
while (a) {
temp.push_back(a % 10);
a /= 10;
}
int sz = (int)temp.size();
for (int i = (int)temp.size() - 1; i >= 0; i--) {
if (temp[i] == '0')
sz = i;
else
break;
}
temp.resize(sz);
reverse(temp.begin(), temp.end());
int last = 1;
int out = 0;
for (int i = 0; i < ((int)temp.size()); i++) {
out += temp[i] * last;
last *= 10;
}
return out;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
map<pair<int, int>, vector<int> > cnt;
void pre(int to) {
for (int i = 1; i <= to; i++) {
int f = rev(i);
int s = i;
int gc = gcd(f, s);
f /= gc;
s /= gc;
cnt[make_pair(f, s)].push_back(i);
}
}
long long int fen[1000000];
void inc(int id, int n) {
for (; id <= n; id += ((id + 1) & -(id + 1))) {
fen[id]++;
}
}
long long int geti(int id) {
long long int out = 0;
for (; id >= 0; id -= ((id + 1) & -(id + 1))) {
out += fen[id];
}
return out;
}
void upd(long long int &r1, int &outx, int &outy, int w, int w2) {
long long int r2 = (long long int)w * 1LL * (long long int)w2;
if (r2 < r1) {
r1 = r2;
outx = w;
outy = w2;
}
}
int main() {
int mx, my, w;
cin >> mx >> my >> w;
pre(my);
memset(fen, 0, sizeof fen);
int outx = -1, outy = -1;
long long int r1 = INF;
for (int i = 1; i <= mx; i++) {
int f = i;
int s = rev(f);
int gc = gcd(f, s);
f /= gc;
s /= gc;
map<pair<int, int>, vector<int> >::iterator it = cnt.find(make_pair(f, s));
if (it == cnt.end()) continue;
int last = 1;
long long int val;
for (int j = 0; j < ((int)it->second.size()); j++) {
int to = it->second[j];
val = geti(to - 1);
if (val >= w && last <= to - 1) {
int l = last, r = to - 1;
while (l != r) {
int mid = (l + r) / 2;
val = geti(mid);
if (val < w)
l = mid + 1;
else
r = mid;
}
upd(r1, outx, outy, i, l);
}
last = to;
inc(to, my);
val = geti(to);
if (val >= w) {
upd(r1, outx, outy, i, to);
}
}
val = geti(my);
if (val >= w) {
int l = last, r = my;
while (l != r) {
int mid = (l + r) / 2;
val = geti(mid);
if (val < w)
l = mid + 1;
else
r = mid;
}
upd(r1, outx, outy, i, l);
}
}
if (outx == -1) {
cout << -1;
} else {
cout << outx << " " << outy;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 7;
const int M = 300;
const int mod = 999983;
const int inf = 1e9 + 7;
const double pi = acos(-1);
const int maxn = N * 2;
const double PI = acos(-1);
int rev(int x) {
int nw = 0;
while (x) {
nw = nw * 10 + (x % 10);
x /= 10;
}
return nw;
}
int gcd(int u, int v) { return (u == 0) ? v : gcd(v % u, u); }
map<pair<int, int>, int> st;
map<pair<int, int>, int> pre;
int n, m, w;
pair<int, int> get(int u) {
int v = rev(u);
int d = gcd(u, v);
u /= d;
v /= d;
return make_pair(u, v);
}
void solve() {
cin >> n >> m >> w;
for (int i = 1; i <= m; i++) {
st[get(i)]++;
}
long long ans = (long long)inf * inf;
long long cur = 0;
int l = -1, r = -1;
for (int i = 1; i <= n; i++) {
int u = i, v = rev(i);
int d = gcd(u, v);
u /= d;
v /= d;
pre[make_pair(v, u)]++;
cur += st[make_pair(v, u)];
while (m > 0 && cur - pre[get(m)] >= w) {
cur -= pre[get(m)];
st[get(m)]--;
m--;
}
if (cur >= w && (long long)i * m < ans) {
l = i;
r = m;
ans = min(ans, (long long)l * r);
}
}
if (l == -1)
puts("-1");
else
cout << l << " " << r;
}
int main() {
int T = 1;
for (int i = (1); i < (T + 1); i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<double, int> mp1, mp2;
int rev(int k) {
int p = 0;
while (k > 0) {
p = p * 10 + (k % 10);
k /= 10;
}
return p;
}
int main() {
double q;
int MaxX, MaxY, w, ansx = 0, ansy = 0, x, y, cnt;
cin >> MaxX >> MaxY >> w;
for (x = 1; x <= MaxX; x++) {
q = (double)(x * 1.0 / rev(x));
mp1[q]++;
}
x = MaxX;
y = 0;
cnt = 0;
while (y <= MaxY && x >= 1) {
if (cnt < w) {
y++;
q = (double)((1.0 * rev(y)) / y);
cnt += mp1[q];
mp2[q]++;
} else {
if (ansx * ansy > x * y || ansx == 0) {
ansx = x;
ansy = y;
}
q = (double)((x * 1.0) / rev(x));
cnt -= mp2[q];
mp1[q]--;
x--;
}
}
if (ansx == 0)
cout << -1;
else
cout << ansx << ' ' << ansy;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
int rev(int x) {
int ret = 0;
while (x != 0) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
int gcd(int x, int y) { return x == 0 ? y : gcd(y % x, x); }
pair<int, int> f[MAXN];
map<pair<int, int>, int> cnt, cntr;
void init() {
for (int i = 1; i < MAXN; ++i) {
int y = rev(i);
int g = gcd(i, y);
f[i] = make_pair(i / g, y / g);
}
}
inline pair<int, int> rev(const pair<int, int> &p) {
return make_pair(p.second, p.first);
}
int main() {
int mx, my, mw;
init();
scanf("%d%d%d", &mx, &my, &mw);
int x = mx + 1, y = my + 1;
cnt.clear();
cntr.clear();
for (int i = 1; i <= my; ++i) {
cnt[f[i]]++;
}
long long w = 0;
for (int i = 1, j = my; i <= mx; ++i) {
cntr[f[i]]++;
w += cnt[rev(f[i])];
if (w < mw) {
continue;
}
while (j > 0 && w - cntr[rev(f[j])] >= mw) {
w -= cntr[rev(f[j])];
cnt[f[j]]--;
j--;
}
if ((long long)i * j < (long long)x * y) {
x = i;
y = j;
}
}
if (x != mx + 1) {
printf("%d %d\n", x, y);
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> A, B;
int maxx, maxy;
long long w, ansx = 100001, ansy = 100001;
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int rev(int x) {
int tmp = 0;
while (x) {
tmp = tmp * 10 + x % 10;
x /= 10;
}
return tmp;
}
int main() {
scanf("%d%d%d", &maxx, &maxy, &w);
for (int j = 1; j <= maxy; j++) {
int g = gcd(rev(j), j), revj = rev(j);
B[make_pair(revj / g, j / g)]++;
}
long long cnt = 0;
int j = maxy, i;
for (i = 1; i <= maxx; i++) {
int g = gcd(rev(i), i), revi = rev(i);
pair<int, int> tmp;
tmp = make_pair(i / g, revi / g);
A[tmp]++;
cnt += B[tmp];
while (1) {
int g = gcd(rev(j), j), revj = rev(j);
pair<int, int> tmp;
tmp = make_pair(revj / g, j / g);
if (cnt - A[tmp] < w) break;
cnt -= A[tmp];
B[tmp]--;
j--;
}
if (cnt >= w)
if ((long long)i * j < ansx * ansy ||
(long long)i * j == ansx * ansy && i < ansx)
ansx = i, ansy = j;
}
if (ansx <= maxx)
printf("%I64d %I64d\n", ansx, ansy);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1000003;
const int maxn = 100005;
struct Node {
long long a, b;
bool operator<(const Node node) const { return a * node.b < b * node.a; }
Node() {}
Node(long long a, long long b) : a(a), b(b) {}
} a[maxn];
map<Node, int> M;
map<Node, vector<int> > MV;
int A, B, W;
long long C[maxn];
inline int lowbit(int x) { return x & (-x); }
void cha(int pos, int sz, long long val) {
while (pos <= sz) {
C[pos] += val;
pos += lowbit(pos);
}
}
long long he(int pos) {
long long r = 0;
while (pos > 0) {
r += C[pos];
pos -= lowbit(pos);
}
return r;
}
int rev(int x) {
int r = 0;
while (x) {
r = r * 10 + (x % 10);
x /= 10;
}
return r;
}
int R[maxn];
vector<int> vc[maxn];
void pre() {
int i;
for (i = 1; i < maxn; ++i) R[i] = rev(i);
for (i = 1; i < maxn; ++i) a[i] = Node(i, R[i]);
MV.clear();
for (i = 1; i < maxn; ++i) {
MV[Node(R[i], i)].push_back(i);
}
for (i = 1; i < maxn; ++i) {
Node now = Node(i, R[i]);
if (MV.find(now) != MV.end()) vc[i] = MV[Node(i, R[i])];
}
}
pair<long long, long long> best, now;
void update(pair<long long, long long> a, pair<long long, long long> &best) {
if (best.first < 0)
best = a;
else if (a.first * a.second < best.first * best.second)
best = a;
}
void gao() {
memset(C, 0, sizeof C);
int i, j;
best = make_pair(-1, -1);
for (i = 1; i <= A; ++i) {
for (j = 0; j < vc[i].size(); ++j) {
cha(vc[i][j], B, 1);
}
int l, r, mid;
l = 1;
r = B;
mid = (l + r) >> 1;
while (l < r) {
mid = (l + r) >> 1;
long long ct = he(mid);
if (ct < W)
l = mid + 1;
else
r = mid - 1;
}
mid = min(B, mid + 2);
while (he(mid) >= W) --mid;
++mid;
if (mid <= B) {
update(make_pair(i, mid), best);
}
}
if (best.first < 0)
puts("-1");
else
cout << best.first << ' ' << best.second << endl;
}
int main() {
pre();
while (cin >> A >> B >> W) {
gao();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, K, an1, an2;
map<double, int> Map1, Map2;
long long mi, sum;
inline int get(int x) {
int s = 0;
for (; x; x /= 10) s = s * 10 + x % 10;
return s;
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (i = 1; i <= n; i++) Map1[1. * get(i) / i]++;
mi = (long long)1e15;
j = n;
for (i = 1; i <= m; i++) {
sum += Map1[1. * i / get(i)];
Map2[1. * i / get(i)]++;
for (; j > 1;) {
int A = Map2[1. * get(j) / j];
if (sum - A >= K) {
sum -= A;
Map1[1. * get(j) / j]--;
j--;
} else
break;
}
if (sum >= K && 1ll * i * j < mi) mi = 1ll * i * j, an1 = j, an2 = i;
}
if (mi == 1e15)
printf("-1\n");
else
printf("%d %d\n", an1, an2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> dp[10005];
int a[105], b[105];
int main() {
int n;
scanf("%d", &n);
int cap = 0, mx = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
cap += a[i];
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
mx += b[i];
}
for (int i = 1; i <= mx; i++) dp[i] = make_pair(-1, -1);
for (int i = 0; i < n; i++) {
for (int j = mx; j >= 0; j--) {
if (dp[j].first == -1) continue;
int nxt = j + b[i];
if (dp[nxt].first == -1)
dp[nxt] = make_pair(dp[j].first + 1, dp[j].second + a[i]);
else if (dp[nxt].first > dp[j].first + 1)
dp[nxt] = make_pair(dp[j].first + 1, dp[j].second + a[i]);
else if (dp[nxt].first == dp[j].first + 1)
dp[nxt].second = max(dp[nxt].second, dp[j].second + a[i]);
}
}
pair<int, int> mn = make_pair((int)1e9, 0);
for (int i = cap; i <= mx; i++) {
if (dp[i].first == -1) continue;
if (dp[i].first < mn.first)
mn = dp[i];
else if (dp[i].first == mn.first)
mn.second = max(mn.second, dp[i].second);
}
printf("%d %d\n", mn.first, cap - mn.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100, V = 100;
struct bottle {
int a, b;
bool operator<(const bottle &bt) const { return b > bt.b; }
} bot[N + 1];
int dp[N + 1][N * V + 1];
int main() {
int n, shui = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &bot[i].a);
shui += bot[i].a;
}
for (int j = 1; j <= n; ++j) scanf("%d", &bot[j].b);
sort(bot + 1, bot + n + 1);
int ping = 0;
for (int i = 1, w = shui; w > 0; ++i) {
w -= bot[i].b;
++ping;
}
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = ping; j; --j)
for (int k = shui; k >= bot[i].a; --k)
if (~dp[j - 1][k - bot[i].a])
dp[j][k] = max(dp[j][k], dp[j - 1][k - bot[i].a] + bot[i].b);
int mx = 0;
for (int i = shui; ~i; --i)
if (dp[ping][i] >= shui) {
mx = i;
break;
}
printf("%d %d\n", ping, shui - mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
const int N = 105;
int a[N], b[N], n, sum;
int dp[2][N * N][N];
int main() {
scanf("%d", &n);
sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
sum += a[i];
}
for (int i = 1; i <= n; i++) scanf("%d", b + i);
for (int j = 0; j <= sum; j++)
for (int k = 0; k <= n; k++) dp[0][j][k] = -INF;
dp[0][0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= sum; j++)
for (int k = 0; k <= n; k++) {
dp[i & 1][j][k] = dp[i & 1 ^ 1][j][k];
if (k)
dp[i & 1][j][k] = max(dp[i & 1][j][k],
dp[i & 1 ^ 1][max(j - b[i], 0)][k - 1] + a[i]);
}
for (int k = 0; k <= n; k++) {
if (dp[n & 1][sum][k] >= 0) {
printf("%d %d\n", k, sum - dp[n & 1][sum][k]);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
inline int Max(const int x, const int y) { return x > y ? x : y; }
int a[100 + 5], b[100 + 5], n, m, f[10000 + 42], g[10000 + 42], ans;
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (register int i = 1; i <= n; ++i) scanf("%d", &b[i]);
for (register int i = 1; i <= n; ++i) m += a[i];
for (register int i = m + 100; i >= 1; --i) f[i] = n;
for (register int i = 1; i <= n; ++i)
for (register int j = m + 100; j >= b[i]; --j)
if (f[j - b[i]] + 1 < f[j]) {
f[j] = f[j - b[i]] + 1;
g[j] = g[j - b[i]] + a[i];
} else if (f[j - b[i]] + 1 == f[j])
g[j] = Max(g[j], g[j - b[i]] + a[i]);
f[0] = n;
for (register int i = m + 100; i >= m; --i)
if (f[ans] > f[i])
ans = i;
else if (f[ans] == f[i] && g[ans] < g[i])
ans = i;
printf("%d %d", f[ans], m - g[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int x, int y) { return x > y; }
int n, lft, num, tot, ans;
int a[101], b[101], d[101], dp[101][10001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], lft += a[i];
for (int i = 1; i <= n; i++) cin >> b[i], d[i] = b[i];
sort(d + 1, d + 1 + n, cmp);
memset(dp, 128, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
tot += d[i];
if (tot >= lft) {
num = i;
break;
}
}
for (int i = 1; i <= n; i++)
for (int j = tot; j >= b[i]; j--)
for (int k = 1; k <= num; k++)
dp[k][j] = max(dp[k][j], dp[k - 1][j - b[i]] + a[i]);
for (int i = lft; i <= tot; i++) ans = max(ans, dp[num][i]);
cout << num << " " << lft - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 105;
using namespace std;
int a[N], b[N], c[N], f[N][N * N];
int main() {
int n, i, j, k, m, t, v = 0, s = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
s += a[i];
}
for (i = 0; i < n; i++) {
scanf("%d", &b[i]);
c[i] = b[i];
v += b[i];
}
sort(c, c + n);
m = 0;
t = 0;
for (i = n - 1; i >= 0; i--) {
t += c[i];
m++;
if (t >= s) break;
}
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (i = 0; i < n; i++)
for (j = m - 1; j >= 0; j--)
for (k = v; k >= 0; k--)
if (f[j][k] != -1)
f[j + 1][k + b[i]] = max(f[j + 1][k + b[i]], f[j][k] + a[i]);
int maxm = -1;
for (i = s; i <= v; i++) maxm = max(maxm, f[m][i]);
printf("%d %d\n", m, s - maxm);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
const double eps = 1e-8;
const int inf = 0x3f3f3f3f;
const long long lnf = 0x3f3f3f3f3f3f3f3f;
const long long mod = 998244353;
struct node {
int a, b;
} p[105];
int dp[105][10050];
bool cmp(node A, node B) { return A.b > B.b; }
int main() {
int n;
int sum = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].a);
sum += p[i].a;
}
for (int i = 1; i <= n; i++) scanf("%d", &p[i].b);
int cnt = 0;
sort(p + 1, p + 1 + n, cmp);
int temp = sum;
for (int i = 1; i <= n; i++) {
if (temp > 0) {
temp -= p[i].b;
cnt++;
} else
break;
}
memset(dp, -inf, sizeof(dp));
dp[0][0] = 0;
printf("%d ", cnt);
for (int i = 1; i <= n; i++) {
for (int j = sum; j >= p[i].a; j--) {
for (int k = i; k >= 1; k--) {
if (dp[k - 1][j - p[i].a] != -inf)
dp[k][j] = max(dp[k][j], dp[k - 1][j - p[i].a] + p[i].b);
}
}
}
for (int i = sum; i >= 1; i--) {
if (dp[cnt][i] >= sum) {
printf("%d\n", sum - i);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int n, sum1, sum2;
int dp[maxn][maxn * maxn];
struct node {
int a, b;
bool operator<(const node& i) const { return i.b < b; }
} p[maxn];
void Inite() {
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
}
void Solve() {
int tem = 0, q = 1;
for (int i = 1; i <= n; i++) {
tem += p[i].b;
q = i;
if (tem >= sum1) break;
}
for (int i = 1; i <= n; i++)
for (int j = q; j >= 1; j--)
for (int k = sum2; k >= p[i].b; k--)
if (~dp[j - 1][k - p[i].b])
dp[j][k] = max(dp[j][k], dp[j - 1][k - p[i].b] + p[i].a);
int ans = 0;
for (int i = sum1; i <= sum2; i++) ans = max(ans, dp[q][i]);
cout << q << " " << sum1 - ans << endl;
}
int main() {
cin >> n;
Inite();
sum1 = sum2 = 0;
for (int i = 1; i <= n; i++) {
cin >> p[i].a;
sum1 += p[i].a;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].b;
sum2 += p[i].b;
}
sort(p + 1, p + n + 1);
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105], dp[105][10005], b[105];
int np, t, n, i, j, k, sy, v;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sy += a[i];
}
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
v += b[i];
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = n; j >= 1; j--) {
for (k = v; k >= b[i]; k--)
if (dp[j - 1][k - b[i]] != -1)
dp[j][k] = max(dp[j][k], dp[j - 1][k - b[i]] + a[i]);
}
}
t = -1;
for (i = 1; i <= n; i++) {
for (j = sy; j <= v; j++) t = max(t, dp[i][j]);
if (t != -1) {
printf("%d %d", i, sy - t);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[105][105 * 105];
int n, k, sum;
struct node {
int a, b;
bool operator<(const node &a) const { return b > a.b; }
} p[105];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].a;
sum += p[i].a;
}
for (int i = 1; i <= n; i++) cin >> p[i].b;
sort(p + 1, p + 1 + n);
int tot = 0;
for (int i = 1; i <= n; i++) {
tot += p[i].b;
if (tot >= sum) {
k = i;
break;
}
}
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum - p[i].a; j >= 0; j--) {
for (int pre = i - 1; pre >= 0; pre--)
if (dp[pre][j] != -1) {
dp[pre + 1][j + p[i].a] =
max(dp[pre + 1][j + p[i].a], dp[pre][j] + p[i].b);
}
}
}
int t;
for (int i = sum; i; i--) {
if (dp[k][i] >= sum) {
t = i;
break;
}
}
printf("%d %d\n", k, sum - t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[100], dp[101][10001];
int main() {
int n;
scanf("%d", &n);
int ts = 0;
for (int i = 0; i < (int)(n); ++i) scanf("%d", s + i), ts += s[i];
for (int i = 0; i < (int)(n + 1); ++i)
for (int j = 0; j < (int)(10001); ++j) dp[i][j] = -1e9;
dp[0][0] = 0;
for (int i = 0; i < (int)(n); ++i) {
int sz;
scanf("%d", &sz);
for (int j = i; j >= 0; --j)
for (int k = sz; k < (int)(10001); ++k)
dp[j + 1][k] = max(dp[j + 1][k], dp[j][k - sz] + s[i]);
}
for (int i = 1; i < (int)(n + 1); ++i) {
int an = -1;
for (int j = ts; j < (int)(10001); ++j) an = max(an, dp[i][j]);
if (an >= 0) {
printf("%d %d\n", i, ts - an);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Bottle {
int water, all;
inline bool operator<(const Bottle &x) const { return all > x.all; }
};
int n, ans, sum, now, dp[10005][105], ans_time = -2147483647;
Bottle bottle[105];
inline int read() {
int ans = 0, f = 1;
char in = getchar();
while (!(in >= '0' && in <= '9')) {
if (in == '-') {
f = !f;
}
in = getchar();
}
while (in >= '0' && in <= '9') {
ans = (ans << 1) + (ans << 3) + (in ^ '0');
in = getchar();
}
return ans * f;
}
int main() {
n = read();
for (register int i = 1; i <= n; i++) {
bottle[i].water = read();
sum += bottle[i].water;
}
for (register int i = 1; i <= n; i++) {
bottle[i].all = read();
}
sort(bottle + 1, bottle + n + 1);
while (now < sum) {
ans++;
now += bottle[ans].all;
}
printf("%d ", ans);
memset(dp, 128, sizeof(dp));
dp[0][0] = 0;
for (register int i = 1; i <= n; i++) {
for (register int j = now; j >= bottle[i].all; j--) {
for (register int k = 1; k <= ans; k++) {
dp[j][k] = (dp[j][k] > dp[j - bottle[i].all][k - 1] + bottle[i].water
? dp[j][k]
: dp[j - bottle[i].all][k - 1] + bottle[i].water);
}
}
}
for (register int i = sum; i <= now; i++) {
ans_time = (ans_time > dp[i][ans] ? ans_time : dp[i][ans]);
}
printf("%d\n", sum - ans_time);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
inline int getint() {
int w = 0, q = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 1, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? -w : w;
}
int a[110];
int b[110];
int n;
int dp[11000][2];
int main() {
n = getint();
int sum = 0;
for (int i = 0; i < n; i++) {
a[i] = getint();
sum += a[i];
}
for (int i = 0; i < n; i++) {
b[i] = getint();
}
for (int i = 0; i <= sum; i++) {
dp[i][0] = 0X3F7F7F7F;
dp[i][1] = 0;
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = sum; j > 0; j--) {
int t = max(j - b[i], 0);
if (dp[j][0] > dp[t][0] + 1) {
dp[j][0] = dp[t][0] + 1;
dp[j][1] = dp[t][1] + a[i];
} else if (dp[j][0] == dp[t][0] + 1 && dp[j][1] < dp[t][1] + a[i]) {
dp[j][1] = dp[t][1] + a[i];
}
}
}
printf("%d %d\n", dp[sum][0], sum - dp[sum][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
int n;
while (~scanf("%d", &n)) {
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
vector<int> b(n);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
int S = accumulate(a.begin(), a.end(), 0);
vector<vector<int> > dp(n + 1, vector<int>(S + 1, INF));
const int Base = (int)1e5;
dp[0][0] = 0;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
for (int(j) = 0; (j) < (int)(S + 1); ++(j)) {
int x = dp[i][j];
if (x == INF) continue;
amin(dp[i + 1][j], x + a[i]);
amin(dp[i + 1][min(S, j + b[i])], x + Base);
}
}
int ans = dp[n][S];
printf("%d %d\n", ans / Base, ans % Base);
}
return 0;
}
|
#include <bits/stdc++.h>
char BB[1 << 15], *SS = BB, *TT = BB;
inline int Read() {
register int x = 0;
register char ch =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
while (ch < '0' || ch > '9')
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
while (ch <= '9' && ch >= '0') {
x = x * 10 + (ch ^ 48);
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
}
return x;
}
inline int Min(const int x, const int y) { return x < y ? x : y; }
inline int ABS(const int x) { return x < 0 ? ~x + 1 : 0x3f3f3f3f3f; }
int a[100 + 5], b[100 + 5], n, m, f[10000 + 42], g[10000 + 42], ans;
int main() {
n = Read();
for (register int i = 1; i <= n; ++i) m += (a[i] = Read());
for (register int i = 1; i <= n; ++i) b[i] = Min(Read(), m);
for (register int i = m + 100; i >= 1; --i) f[i] = n;
for (register int i = 1; i <= n; ++i)
for (register int j = m + 100; j >= b[i]; --j)
if (f[j - b[i]] + 1 < f[j]) {
if (j <= m) {
f[j] = f[j - b[i]] + 1;
g[j] = g[j - b[i]] + b[i] - a[i];
} else {
f[j] = f[j - b[i]] + 1;
g[j] = g[j - b[i]] + b[i] - a[i] + m - j;
}
} else if (f[j - b[i]] + 1 == f[j]) {
if (j <= m)
g[j] = Min(g[j], g[j - b[i]] + b[i] - a[i]);
else
g[j] = Min(g[j], g[j - b[i]] + b[i] - a[i] + m - j);
}
f[0] = n;
for (register int i = m + 100; i >= m; --i)
if (f[ans] > f[i])
ans = i;
else if (f[ans] == f[i] && g[ans] > g[i])
ans = i;
printf("%d %d", f[ans], g[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Sweet {
template <typename T>
inline void read(T &x) {
char ch;
int f = 1;
while (ch = getchar(), ch > '9' || ch < '0') (ch == '-') && (f = -1);
x = (ch ^ 48);
while (ch = getchar(), ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48);
x *= f;
}
template <typename T>
inline void write(T x) {
static int stk[100], top = 0;
if (x == 0) return (void)putchar('0');
if (x < 0) x = -x, putchar('-');
while (x) stk[++top] = x % 10, x /= 10;
while (top) putchar(stk[top--] + '0');
}
const int N = 4e2 + 10;
struct E {
int a, b;
friend bool operator<(const E &a, const E &b) {
return a.b == b.b ? a.a > b.a : a.b > b.b;
}
} e[N];
inline void max(int &x, const int &y) { (x < y) && (x = y); }
int n, q, sigmaA, sigmaB, pre[N], f[N * N][N];
inline void main() {
read(n);
for (int i = 1; i <= n; ++i) read(e[i].a), sigmaA += e[i].a;
for (int i = 1; i <= n; ++i) read(e[i].b), sigmaB += e[i].b;
sort(e + 1, e + n + 1);
for (int i = 1; i <= n; ++i) pre[i] = pre[i - 1] + e[i].b;
memset(f, 0xcf, sizeof(f));
f[0][0] = 0;
int x = lower_bound(pre + 1, pre + n + 1, sigmaA) - pre;
write(x), putchar(' ');
for (int i = 1; i <= n; ++i) {
for (int j = sigmaB; j >= e[i].b; --j) {
for (int k = 1; k <= x; ++k) {
max(f[j][k], f[j - e[i].b][k - 1] + e[i].a);
}
}
}
int ans = 0;
for (int i = sigmaA; i <= sigmaB; ++i) max(ans, f[i][x]);
write(sigmaA - ans);
}
} // namespace Sweet
int main() {
Sweet::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct bottles {
int las;
int vol;
} inp[1000];
int dp[105][20000];
bool cmp(bottles x, bottles y) { return x.vol > y.vol; }
int main() {
int n, sum = 0, cnt = 0, num = -1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &inp[i].las);
for (int i = 1; i <= n; i++) scanf("%d", &inp[i].vol);
for (int i = 1; i <= n; i++) sum += inp[i].las;
sort(inp + 1, inp + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
cnt += inp[i].vol;
if (cnt >= sum && num == -1) num = i;
}
printf("%d ", num);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = cnt; j >= inp[i].vol; j--) {
for (int k = 1; k <= num; k++) {
if (dp[k - 1][j - inp[i].vol] != -1) {
dp[k][j] = max(dp[k - 1][j - inp[i].vol] + inp[i].las, dp[k][j]);
}
}
}
}
int oup = -1;
for (int i = sum; i <= cnt; i++) {
oup = max(oup, dp[num][i]);
}
printf("%d", sum - oup);
return 0;
}
|
#include <bits/stdc++.h>
#pragma gcc optimize("O3")
#pragma gcc optimize("unroll-loops")
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 110;
const int INF = 1e9;
int n, tot;
pii ar[N];
int dp[N][N * N];
int ndp[N][N * N];
int findk() {
int ret = 0;
int tot = 0;
for (int i = 1; i <= n; i++) tot += ar[i].second;
for (int i = 1; i <= n; i++) {
tot -= ar[i].first;
if (tot <= 0) return i;
}
return n;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ar[i].second;
tot += ar[i].second;
}
for (int i = 1; i <= n; i++) {
cin >> ar[i].first;
}
sort(ar + 1, ar + n + 1, greater<pii>());
int mk = findk();
for (int i = 0; i <= mk; i++) {
for (int j = 0; j <= tot; j++) {
dp[i][j] = INF;
}
}
dp[0][0] = tot;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= mk; j++) {
for (int k = 0; k <= tot; k++) {
ndp[j][k] = dp[j][k];
}
}
for (int j = 0; j < mk; j++) {
for (int k = 0; k <= tot; k++) {
int nj = j + 1;
int nk = min(tot, k + ar[i].first);
dp[nj][nk] = min(dp[nj][nk], ndp[j][k] - ar[i].second);
}
}
}
cout << mk << " " << dp[mk][tot] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 10010;
int n;
int a[N], b[N], c[N];
int f[M][N];
int main() {
cin >> n;
int sa = 0, sb = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sa += a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
c[i] = b[i];
sb += b[i];
}
sort(c + 1, c + n + 1, greater<int>());
int s = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
s += c[i];
cnt++;
if (s >= sa) break;
}
memset(f, -0x3f, sizeof f);
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sb; j >= b[i]; j--) {
for (int k = 1; k <= cnt; k++)
f[j][k] = max(f[j][k], f[j - b[i]][k - 1] + a[i]);
}
}
int res = 0;
for (int i = sa; i <= sb; i++) res = max(res, f[i][cnt]);
res = sa - res;
cout << cnt << " " << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%I64d", &x);
return x;
}
struct Info {
int a, b;
} inp[205];
int tot;
int n;
pair<int, int> dp[105][10005];
pair<int, int> go(int now, int rem) {
if (rem <= 0) return make_pair(0, 0);
if (now > n) return make_pair(100000, 100000);
if (dp[now][rem] != make_pair(-1, -1)) return dp[now][rem];
pair<int, int> a;
a = go(now + 1, rem - inp[now].b);
pair<int, int> p, q;
p.first = 1 + a.first;
if (rem - inp[now].b >= 0)
p.second = (inp[now].b - inp[now].a) + a.second;
else
p.second = (rem - inp[now].a) + a.second;
q = go(now + 1, rem);
if (q.first < p.first)
p = q;
else if (q.first == p.first) {
if (q.second < p.second) p = q;
}
return dp[now][rem] = p;
}
int main() {
n = in();
for (int i = 1; i <= n; i++) {
inp[i].a = in();
tot += inp[i].a;
}
for (int i = 1; i <= n; i++) {
inp[i].b = in();
}
memset(dp, -1, sizeof dp);
pair<int, int> ans = go(1, tot);
printf("%d %d\n", ans.first, ans.second);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int MX = N * N;
const int INF = ~0x3f3f3f3f;
int a[N], b[N];
int dp[N][MX];
int main() {
int n;
while (scanf("%d", &n) == 1) {
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
sum += a[i];
}
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
}
memset(dp, INF, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
int aa = a[i], bb = b[i];
for (int j = i; j >= 0; j--) {
for (int k = 0; k < MX; k++) {
if (dp[j][k] != INF) {
dp[j + 1][k + bb] = max(dp[j + 1][k + bb], dp[j][k] + aa);
}
}
}
}
for (int i = 1; i <= n; i++) {
int mx = INF;
for (int j = sum; j < MX; j++) {
mx = max(mx, dp[i][j]);
}
if (mx != INF) {
printf("%d %d\n", i, sum - mx);
break;
}
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.