text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int gcd(int u, int v) { return (v != 0) ? gcd(v, u % v) : u; }
int win(int hp1, int atk1, int def1, int hp2, int atk2, int def2) {
double f = max(0, atk1 - def2);
double s = max(0, atk2 - def1);
double s2 = ceil(hp2 / f);
double s1 = ceil(hp1 / s);
if (s1 > s2) return 0;
if (f == 0) return 1e9;
double NewHp = s2 * s;
return NewHp + 1 - hp1;
}
int main() {
int hp1, atk1, def1, hp2, atk2, def2;
long long a, b, c;
cin >> hp1 >> atk1 >> def1 >> hp2 >> atk2 >> def2;
cin >> a >> b >> c;
long long Min = 1e18;
for (int i = 0; i <= 2000; i++) {
for (int j = 0; j <= 2000; j++) {
int k = win(hp1, atk1 + i, def1 + j, hp2, atk2, def2);
Min = min(Min, k * a + i * b + j * c);
}
}
cout << Min << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3];
int b[3];
int h[3];
int ans = 1000000000;
int c[3];
for (int i = 0; i < 3; i++) scanf("%d", a + i);
for (int i = 0; i < 3; i++) scanf("%d", b + i);
for (int i = 0; i < 3; i++) scanf("%d", h + i);
ans = (a[1] - b[2] > 0 ? 0 : b[2] - a[1] + 1) * h[1] +
(b[1] - a[2] <= 0 ? 0 : b[1] - a[2]) * h[2];
for (int k = max(0, b[2] - a[1] + 1); k <= b[0] + b[2] - a[1]; k++) {
for (int j = 0; j <= max(0, b[1] - a[2] + 1); j++) {
int hk = a[1] + k - b[2], hm = b[1] - a[2] - j;
int t = b[0] % hk == 0 ? b[0] / hk : b[0] / hk + 1;
int m = max(0, hm * t + 1 - a[0]);
ans = min(h[0] * m + h[1] * k + h[2] * j, ans);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int H1, A1, D1, M1;
int H2, A2, D2, M2;
int h, a, d;
int main() {
scanf("%d %d %d", &H1, &A1, &D1);
scanf("%d %d %d", &H2, &A2, &D2);
scanf("%d %d %d", &h, &a, &d);
int Ans = 2e9;
int now = 0;
if (A1 <= D2) {
now += a * (D2 - A1 + 1);
A1 = D2 + 1;
}
M1 = A1 - D2;
M2 = A2 - D1;
while (1) {
if (M2 <= 0 || (H1 + M2 - 1) / M2 > (H2 + M1 - 1) / M1) {
Ans = min(Ans, now);
printf("%d\n", Ans);
break;
}
for (int i = 0;; i++) {
int p = (H2 + M1 + i - 1) / (M1 + i);
int k;
k = H1 / p;
if (H1 % p == 0) k--;
k = max(0, A2 - D1 - k);
Ans = min(Ans, now + i * a + k * d);
if (p == 1) break;
}
now += h;
H1++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hy, ay, dy, hm, am, dm, h, a, d;
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
int p = max(ay, dm + 1);
int res = 10000000;
do {
int k = hm / (p - dm);
if (hm % (p - dm) != 0) k++;
for (int q = dy; am - q > 0; q++) {
int r = hy;
while (1) {
int k2 = r / (am - q);
if (r % (am - q) != 0) k2++;
if (k2 > k) break;
r++;
}
res = min(res, (r - hy) * h + (q - dy) * d + (p - ay) * a);
}
p++;
} while (p - dm <= hm);
res = min(res, max(am - dy, 0) * d + max(dm - ay + 1, 0) * a);
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
long hp_y, atk_y, def_y, hp_m, atk_m, def_m, hp_a, atk_a, def_a;
long ans;
void input_data() {
cin >> hp_y >> atk_y >> def_y;
cin >> hp_m >> atk_m >> def_m;
cin >> hp_a >> atk_a >> def_a;
}
bool check(long i, long j, long k) {
long a_y = max((long)0, atk_y + j - def_m);
long a_m = max((long)0, atk_m - (def_y + k));
long h_y = hp_y + i;
long h_m = hp_m;
if (a_y == 0) return false;
long c = (h_m + a_y - 1) / a_y;
if ((h_y - a_m * c) > 0) {
return true;
} else {
return false;
}
}
void process_data() {
ans = 2147483647;
for (long i = 0; i < 1000; i++) {
for (long j = 0; j <= 1000; j++) {
for (long k = 0; k <= 1000; k++) {
long buf = i * hp_a + j * atk_a + k * def_a;
if (check(i, j, k)) {
ans = min(ans, buf);
break;
}
}
}
}
}
void output_data() { cout << ans; }
int main() {
input_data();
process_data();
output_data();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int my_floor(int a, int b) {
if (b == 0) return 2147483646;
return (a + b - 1) / b;
}
bool check(int a1, int b1, int c1, int a2, int b2, int c2) {
int t1, t2;
t1 = (b1 - c2 > 0 ? b1 - c2 : 0);
t2 = (b2 - c1 > 0 ? b2 - c1 : 0);
return my_floor(a2, t1) < my_floor(a1, t2);
}
int main() {
int a1, b1, c1, a2, b2, c2, h, a, d;
int i, j, k, ans = 2147483646;
cin >> a1 >> b1 >> c1 >> a2 >> b2 >> c2 >> h >> a >> d;
for (i = 0; i <= 101; i++) {
for (j = 0; j <= 201; j++) {
for (k = 0; k <= 1000; k++) {
if (check(a1 + k, b1 + j, c1 + i, a2, b2, c2)) {
if (h * k + a * j + d * i < ans) ans = h * k + a * j + d * i;
break;
}
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int y[3], m[3], v[3], res = 1000000000;
int main() {
scanf("%d %d %d %d %d %d %d %d %d", &y[0], &y[1], &y[2], &m[0], &m[1], &m[2],
&v[0], &v[1], &v[2]);
for (int i = m[2] + 1; i <= 200; i++) {
for (int j = y[2]; j <= 100; j++) {
int yv = max(0, i - m[2]);
int cv = max(0, m[1] - j);
int a = (m[0] + yv - 1) / yv * cv + 1;
int b = max(0, a - y[0]);
int c = max(0, i - y[1]);
int w = c * v[1] + (j - y[2]) * v[2] + b * v[0];
if (res > w) res = w;
}
}
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hy, ay, dy, hm, am, dm, h, a, d;
scanf("%d%d%d", &hy, &ay, &dy);
scanf("%d%d%d", &hm, &am, &dm);
scanf("%d%d%d", &h, &a, &d);
int ans = 1000000000;
for (int j = 0; j <= 200; j++) {
int aa = ay + j;
if (dm - aa >= 0) continue;
for (int k = 0; k <= 200; k++) {
int dd = dy + k;
int num = (hm % (aa - dm) ? 1 : 0) + hm / (aa - dm);
int hp = num * (am - dd);
if (hp < hy)
ans = min(ans, j * a + k * d);
else
ans = min(ans, (hp - hy + 1) * h + j * a + k * d);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int HPY, ATKY, DEFY;
cin >> HPY >> ATKY >> DEFY;
int HPM, ATKM, DEFM;
cin >> HPM >> ATKM >> DEFM;
int h, a, d;
HPY--;
cin >> h >> a >> d;
int ans = 9999999;
for (int i = 0; i < 230; i++) {
if (ATKY + i > DEFM) {
for (int j = 0; j < 100; j++) {
int temp = i * a + j * d;
int D = j + DEFY;
int A = i + ATKY - DEFM;
int t = (HPM + A - 1) / (A);
temp += max(t * (ATKM - D) - HPY, 0) * h;
ans = min(temp, ans);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
template <typename T>
inline T sqr(T n) {
return n * n;
}
int h, a, d;
int hp_cost;
struct Person {
int hp;
int atk;
int def;
void read() { scanf("%d%d%d", &hp, &atk, &def); }
bool wins(const Person& p) const {
int diff = max(0, p.atk - def);
int pers_diff = max(0, atk - p.def);
if (pers_diff == 0) {
return false;
}
if (diff == 0) {
hp_cost = 0;
return true;
}
int num2 = (p.hp + pers_diff - 1) / pers_diff;
hp_cost = max(0, (num2 * diff - hp + 1)) * h;
return true;
}
};
Person yan, monster;
int ans = INF;
int main() {
yan.read();
monster.read();
scanf("%d%d%d", &h, &a, &d);
for (int i = 0; i < 201; i++) {
yan.atk += i;
for (int j = 0; j < 201; j++) {
yan.def += j;
if (yan.wins(monster)) {
ans = min(ans, i * a + j * d + hp_cost);
}
yan.def -= j;
}
yan.atk -= i;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return (b != 0 ? gcd(b, a % b) : a); }
int lcm(int a, int b) { return (a / gcd(a, b) * b); }
int R[] = {1, -1, 0, 0, 1, -1, -1, 1};
int C[] = {0, 0, 1, -1, 1, -1, 1, -1};
int KR[] = {-2, -2, -1, 1, 2, 2, -1, 1};
int KC[] = {1, -1, 2, 2, 1, -1, -2, -2};
struct P {
double x, y;
P(double x = 0.0, double y = 0.0) {
this->x = x;
this->y = y;
}
};
P mkv(P ae, P be) { return P(be.x - ae.x, be.y - ae.y); }
double dtp(P ae, P be) { return (ae.x * be.x + ae.y * be.y); }
double crp(P ae, P be) { return (ae.x * be.y - ae.y * be.x); }
double val(P ae) { return sqrt(dtp(ae, ae)); }
P vresize(P ae, double llen) {
double v = val(ae);
return P(ae.x * llen / v, ae.y * llen / v);
}
double ART(P ae, P be) { return crp(ae, be) / 2.0; }
P rot(P ae, double ang) {
return P(ae.x * cos(ang) - ae.y * sin(ang),
ae.y * cos(ang) + ae.x * sin(ang));
}
long long hpm, atkm, defm, hp;
long long check(long long atk, long long def) {
long long rk, rm, mhp, r, zero = 0;
rk = max(zero, atkm - def);
rm = max(zero, atk - defm);
mhp = hpm;
if (rk == 0 && rm != 0)
return 0;
else if (rm == 0)
return -1;
else {
if (mhp % rm == 0) {
return max(zero, (mhp / rm) * rk - hp + 1);
} else
return max(zero, ((long long)(mhp / rm) + 1) * rk - hp + 1);
}
}
int main() {
long long b, c, d, h, m, n, p, x, y, i, j, k, l, q, r, t, cnt, sm, tmp, def,
atk, vh, va, vd;
scanf("%I64d %I64d %I64d", &hp, &atk, &def);
scanf("%I64d %I64d %I64d", &hpm, &atkm, &defm);
scanf("%I64d %I64d %I64d", &vh, &va, &vd);
long long mx = 1e9;
for (j = 0; j <= 200; j++) {
for (k = 0; k <= 200; k++) {
p = check(atk + j, def + k);
if (p != -1) {
if (mx > p * vh + j * va + k * vd) {
tmp = p;
sm = j;
cnt = k;
}
mx = min(mx, p * vh + j * va + k * vd);
}
}
}
printf("%I64d\n", mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mhp, mat, mde;
long long yhp, yat, yde;
long long h, a, b;
long long get(long long hp, long long at, long long de) {
hp += yhp;
long long dx1 = max(0ll, at - mde);
long long dx2 = max(0ll, mat - de);
if (!dx1) return hp > 0 && mhp <= 0;
long long dy = mhp / dx1 + (mhp % dx1 != 0);
hp -= dy * dx2;
return hp > 0;
}
long long calc(long long at, long long de) {
if (max(0ll, at - mde) == 0) return 1e9;
long long st = 0;
long long en = 1e4 + 1;
while (st != en) {
long long mid = (st + en) >> 1;
if (get(mid, at, de))
en = mid;
else
st = mid + 1;
}
return st;
}
int main() {
cin >> yhp >> yat >> yde;
cin >> mhp >> mat >> mde;
cin >> h >> a >> b;
long long mn = 1e9;
long long res = 0;
for (int i = 0; i < 1500; i++) {
for (int j = 0; j < 1500; j++) {
long long yyhp = calc(yat + i, yde + j);
if (mn > yat + i * a + yde + j * b + yhp + h * yyhp) {
mn = yat + i * a + yde + j * b + yhp + h * yyhp;
res = i * a + j * b + yyhp * h;
}
}
}
cout << max(0ll, res);
}
|
#include <bits/stdc++.h>
using namespace std;
long hpy, atky, defy;
long hpm, atkm, defm;
long thpy, tatky, tdefy;
long morehp, moreatk, moredef;
long res, nowm;
long h, a, d;
int main() {
cin >> hpy >> atky >> defy;
cin >> hpm >> atkm >> defm;
cin >> h >> a >> d;
res = 1000000000;
for (moredef = 0; moredef <= 1000; moredef++)
for (moreatk = 0; moreatk <= 1000; moreatk++) {
tdefy = defy + moredef;
tatky = atky + moreatk;
nowm = tatky - defm;
if (nowm <= 0) continue;
if (hpm % nowm == 0)
nowm = hpm / nowm;
else
nowm = hpm / nowm + 1;
long tt = nowm * (atkm - tdefy) + 1;
long ttt = moredef * d + moreatk * a + max(long(0), tt - hpy) * h;
if (ttt < res) res = ttt;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hpM, atkM, defM;
bool IsVictory(int hp, int atk, int def) {
int newHPY(hp), newHPM(hpM);
int damageY = atk - defM;
int damageM = atkM - def;
if (atk <= defM) return false;
while (true) {
newHPM -= ((damageY < 0) ? 0 : damageY);
newHPY -= ((damageM < 0) ? 0 : damageM);
if (newHPM <= 0 && newHPY > 0) return true;
if (newHPY <= 0) return false;
}
}
int main() {
int hpY, atkY, defY;
int ph, pa, pd;
cin >> hpY >> atkY >> defY;
cin >> hpM >> atkM >> defM;
cin >> ph >> pa >> pd;
if (IsVictory(hpY, atkY, defY)) {
cout << "0";
return 0;
}
int stAtk(0), stDef(0), stHp(0);
int minSumm(100000);
for (int h = 0; h <= 1000; ++h) {
for (int a = 0; a <= 1000; ++a) {
for (int d = 0; d <= atkM; ++d) {
int sum = ph * h + pa * a + pd * d;
if (IsVictory(hpY + h, atkY + a, defY + d)) {
if (sum < minSumm) {
minSumm = sum;
}
break;
}
}
}
}
cout << minSumm;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hy, ay, dy, hm, am, dm, h, a, d, mn, ans, sum, at, de;
int main() {
scanf("%d%d%d", &hy, &ay, &dy);
scanf("%d%d%d", &hm, &am, &dm);
scanf("%d%d%d", &h, &a, &d);
ans = 999999998;
if (ay <= dm) sum = (dm + 1 - ay) * a, ay = dm + 1;
for (at = ay; at <= max(hm + dm, ay); at++)
for (de = dy; de <= max(am, dy); de++) {
mn = (at - ay) * a + (de - dy) * d;
int l = hy, r = 100000, ck = 1000000;
while (l <= r) {
int mid = (l + r) >> 1;
int t1, t2;
if (am <= de)
t1 = 999999998;
else
t1 = (mid - 1) / (am - de) + 1;
t2 = (hm - 1) / (at - dm) + 1;
if (t1 > t2)
ck = mid, r = mid - 1;
else
l = mid + 1;
}
mn += max(0, ck - hy) * h;
ans = min(ans, mn);
}
sum += ans;
printf("%d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int a, b, c, hp1, ac1, of1, hp2, ac2, of2;
bool CHECK(int hp, int ac, int of) {
if (ac - of2 <= 0) return false;
if (ac2 - of <= 0) return true;
if (ceil((double)hp / (ac2 - of)) > ceil((double)hp2 / (ac - of2)))
return true;
return false;
}
int main() {
while (cin >> hp1 >> ac1 >> of1 >> hp2 >> ac2 >> of2 >> a >> b >> c) {
int ans = inf;
if (of1 >= ac2) {
if (ac1 > of2)
cout << '0' << endl;
else
cout << (of2 + 1 - ac1) * b << endl;
break;
}
for (int i = max(ac1, of2 + 1); i <= 201; ++i) {
for (int j = of1; j <= ac2 + 1; ++j) {
for (int k = hp1;; ++k) {
if (CHECK(k, i, j)) {
ans = min(ans, (k - hp1) * a + (i - ac1) * b + (j - of1) * c);
break;
}
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long hpy, atky, defy;
long hpm, atkm, defm;
long thpy, tatky, tdefy;
long morehp, moreatk, moredef;
long res, nowm;
long h, a, d;
int main() {
cin >> hpy >> atky >> defy;
cin >> hpm >> atkm >> defm;
cin >> h >> a >> d;
res = 1000000000;
for (moredef = 0; moredef <= 200; moredef++)
for (moreatk = 0; moreatk <= 200; moreatk++) {
tdefy = defy + moredef;
tatky = atky + moreatk;
nowm = tatky - defm;
if (nowm <= 0) continue;
if (hpm % nowm == 0)
nowm = hpm / nowm;
else
nowm = hpm / nowm + 1;
long tt = nowm * (atkm - tdefy) + 1;
long ttt = moredef * d + moreatk * a + max(long(0), tt - hpy) * h;
if (ttt < res) res = ttt;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[3], b[3], c[3];
int check(int i, int j, int k) {
int hpy = a[0] + i, hpm = b[0];
int aty = a[1] + j, atm = b[1];
int dey = a[2] + k, dem = b[2];
int decm = aty - dem;
if (decm <= 0) return -1;
int decy = atm - dey;
if (decy < 0) decy = 0;
int steps = (hpm + decm - 1) / decm;
if (hpy - steps * decy <= 0) return -1;
return i * c[0] + j * c[1] + k * c[2];
}
int main() {
for (int i = 0; i < 3; ++i) scanf("%d", a + i);
for (int i = 0; i < 3; ++i) scanf("%d", b + i);
for (int i = 0; i < 3; ++i) scanf("%d", c + i);
int ans = -1;
for (int i = 0; i <= 1000; ++i) {
for (int j = 0; j <= 1000; ++j) {
int ll = 0, rr = 1000;
while (ll < rr) {
int k = (ll + rr) >> 1;
int c = check(i, j, k);
if (c == -1)
ll = k + 1;
else
rr = k;
}
int cost = check(i, j, ll);
if (cost == -1) continue;
if (ans == -1 || ans > cost) ans = cost;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long hy, hm, ay, am, dy, dm;
long long h, a, d;
long long res = 100000000000000000;
int main() {
cin >> hy >> ay >> dy;
cin >> hm >> am >> dm;
cin >> h >> a >> d;
long long h1, d1, a1;
long long kill;
for (a1 = 0; a1 <= 500; ++a1) {
for (d1 = 0; d1 <= 500; ++d1) {
if (ay + a1 - dm > 0) {
kill = hm / (ay + a1 - dm);
if (hm % (ay + a1 - dm) > 0) ++kill;
} else
continue;
h1 = kill * (am - dy - d1) - hy + 1;
h1 = max(0ll, h1);
if (hm - kill * (ay + a1 - dm) <= 0 &&
hy + h1 - kill * (am - dy - d1) > 0 && a1 * a + d1 * d + h1 * h < res)
res = a1 * a + d1 * d + h1 * h;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long h1, a1, d1, h2, a2, d2, h, a, d, m = 1e18;
cin >> h1 >> a1 >> d1 >> h2 >> a2 >> d2 >> h >> a >> d;
for (long long i = 0; i <= 10000; i++) {
for (long long j = 0; j <= 199; j++) {
for (long long k = 0; k <= 100; k++) {
long long ch = h1 + i, ca = a1 + j, cd = d1 + k;
if (ca <= d2) continue;
long long dm = ca - d2, dy = a2 - cd;
if (dy <= 0) {
m = min(m, (long long)(i * h + j * a + d * k));
break;
} else {
long long tm = h2 / dm, ty = ch / dy;
if (h2 % dm != 0) tm++;
if (ch % dy != 0) ty++;
if (tm < ty) {
m = min(m, (long long)(i * h + j * a + d * k));
break;
}
}
}
}
}
cout << m;
}
|
#include <bits/stdc++.h>
using namespace std;
int hm, am, dm;
int check(int ay, int dy) {
int m = max(0, ay - dm), y = max(0, am - dy);
if (!m) return -1;
return (hm / m + (hm % m != 0)) * y + 1;
}
int main() {
int hy, ay, dy, h, a, d, mn = 1e9;
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
for (int i = 0; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
int hp = check(ay + i, dy + j);
if (hp == -1) continue;
mn = min(mn, max(0, hp - hy) * h + i * a + j * d);
}
}
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e3 + 11;
const int inf = int(1e9);
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int hp1, hp2, atk1, atk2, def1, def2, a, b, c;
int ans = inf;
int main() {
cin >> hp1 >> atk1 >> def1 >> hp2 >> atk2 >> def2 >> a >> b >> c;
for (int atk = 0; atk < 5000; atk++) {
for (int def = 0; def < 5000; def++) {
int f1 = max(0, atk1 + atk - def2);
int f2 = max(0, atk2 - def1 - def);
if (f1 == 0) continue;
int t = (hp2 + f1 - 1) / f1;
int cur = hp1 - t * f2;
int hp = max(0, 1 - cur);
ans = min(ans, a * hp + b * atk + c * def);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INFint = 2147483647;
const long long INF = 9223372036854775807ll;
const long long MOD = 1000000007ll;
const long double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(0);
int hy, ay, dy, hm, am, dm, h, a, d;
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
int ans = INFint;
for (int i = ay; i <= 200; i++)
for (int j = dy; j <= 200; j++) {
if (i <= dm) continue;
int cnt = ceil((double)hm / (i - dm));
int cnth = max(hy, (am - j) * cnt + 1);
ans = min(ans, h * (cnth - hy) + d * (j - dy) + a * (i - ay));
}
cout << ans;
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int hy, ay, dy, hm, am, dm, h, a, d, ans = INT_MAX;
int tempa, tempd, k, sec;
cin >> hy >> ay >> dy;
cin >> hm >> am >> dm;
cin >> h >> a >> d;
for (int i = 0; i <= 200; i++)
for (int j = 0; j <= 200; j++) {
tempa = ay + i;
tempd = dy + j;
if (max(0, tempa - dm)) {
sec = ceil((double)hm / max(0, tempa - dm));
k = sec * max(0, am - tempd) - hy + 1;
if (k < 0) k = 0;
ans = min(ans, i * a + j * d + k * h);
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101, mod = 1e9 + 7;
inline void read(int &x) {
char ch;
int t = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') t = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - 48, ch = getchar())
;
if (t) x = -x;
}
int main() {
int T, n, m, i, j, k, x, y, s, t, ans;
int a0, a1, a2, a, h0, h1, h2, h, d0, d1, d2, d, t1, t2;
while (
~scanf("%d%d%d%d%d%d%d%d%d", &h0, &a0, &d0, &h2, &a2, &d2, &h, &a, &d)) {
for (ans = 1000000000, i = 0; i < 100 * N; i++) {
for (j = 0; j < 2 * N; j++) {
for (k = 0; k < N; k++) {
x = i * h + j * a + k * d;
if (x >= ans) continue;
h1 = h0 + i;
a1 = a0 + j;
d1 = d0 + k;
if (a1 - d2 <= 0) continue;
if (a2 - d1 <= 0) {
ans = x;
continue;
}
t1 = h2 / (a1 - d2);
if (h2 % (a1 - d2)) t1++;
t2 = h1 / (a2 - d1);
if (h1 % (a2 - d1)) t2++;
if (t1 < t2) ans = x;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int yh, ya, yd, mh, ma, md;
int h, a, d;
cin >> yh >> ya >> yd;
cin >> mh >> ma >> md;
cin >> h >> a >> d;
int ans = 1000000000;
for (int i = 0; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
if (ya + i <= md) continue;
int b = (mh + ya + i - md - 1) / (ya + i - md);
int x = max(0, b * (ma - yd - j) - yh + 1);
ans = min(ans, i * a + j * d + x * h);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int N = 305;
int c[N], l[N];
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long rrand() {
long long a = rand();
long long b = rand();
return a + (b >> 16);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> l[i];
}
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
int best = 0;
map<int, int> prices;
for (int i = 0; i < n; ++i) {
int value = l[i];
int cost = c[i];
for (map<int, int>::iterator it = prices.begin(); it != prices.end();
++it) {
int to = gcd(it->first, value);
if (prices.count(to) == 0 || prices[to] > cost + it->second) {
prices[to] = cost + it->second;
}
}
if (prices.count(value) == 0 || prices[value] > cost) {
prices[value] = cost;
}
}
if (prices.count(1) == 0) {
cout << -1 << endl;
return 0;
}
cout << prices[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> nima;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int n;
int l[1000], c[1000];
void solve() {
for (int i = 0; i < n; ++i) {
if (nima.find(l[i]) != nima.end()) {
if (nima[l[i]] > c[i]) nima[l[i]] = c[i];
} else
nima[l[i]] = c[i];
for (map<int, int>::iterator iter = nima.begin(); iter != nima.end();
++iter) {
int old = iter->first;
int y = iter->second;
int new_old = gcd(old, l[i]);
if (nima.find(new_old) != nima.end()) {
if (nima[new_old] > y + c[i]) nima[new_old] = y + c[i];
} else {
nima[new_old] = y + c[i];
}
}
}
if (nima.find(1) != nima.end()) {
cout << nima[1] << endl;
} else {
cout << -1 << endl;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d", &l[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &c[i]);
}
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> st;
priority_queue<pair<long long, int> > q;
int l[10000], c[10000];
int n;
vector<int> cur;
inline int gcd(int a, int b) { return a % b ? gcd(b, a % b) : b; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) q.push(make_pair(-c[i], l[i]));
while (!q.empty()) {
long long cost = -q.top().first;
int res = q.top().second;
q.pop();
if (st.find(res) != st.end()) continue;
st.insert(res);
if (res == 1) {
cout << cost << endl;
return 0;
}
for (int i = 0; i < cur.size(); i++) {
int nres = gcd(l[cur[i]], res);
long long ncost = cost + c[cur[i]];
q.push(make_pair(-ncost, nres));
}
l[n] = res;
c[n] = cost;
cur.push_back(n);
n++;
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long l[305];
long long c[305];
long long dp[1000];
const long long INF = 10000000000000LL;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i];
}
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
long long res = INF;
for (int i = 1; i <= n; i++) {
int x = l[i];
vector<int> vec;
for (int j = 2; j * j <= x; j++) {
if (x % j == 0) {
vec.push_back(j);
while (x % j == 0) x /= j;
}
}
if (x > 1) vec.push_back(x);
int b = vec.size();
int p = (1 << b) - 1;
for (int j = p; j >= 0; j--) dp[j] = INF;
dp[0] = c[i];
for (int j = 0; j <= p; j++) {
for (int k = 1; k <= n; k++) {
int e = j;
for (int z = 0; z < b; z++) {
if (l[k] % vec[z]) e = e | (1 << z);
}
dp[e] = min(dp[e], dp[j] + c[k]);
}
}
res = min(res, dp[p]);
}
if (res == INF)
cout << -1;
else
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Len = 300;
const int inf = (1 << 30);
int n;
int l[Len + 5], c[Len + 5];
map<int, int> dp, tmp;
int ans;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void solve() {
ans = inf;
dp.clear();
for (int i = 0; i < n; ++i) {
dp[l[i]] = c[i];
if (l[i] == 1) {
ans = min(ans, c[i]);
}
}
for (int i = 1; i < n; ++i) {
tmp.clear();
for (map<int, int>::iterator it = dp.begin(); it != dp.end(); it++) {
for (int j = 0; j < n; ++j) {
int newstate = gcd(l[j], it->first);
if (dp.find(newstate) == dp.end() || dp[newstate] > it->second + c[j]) {
if (tmp.find(newstate) == tmp.end() ||
tmp[newstate] > it->second + c[j]) {
tmp[newstate] = it->second + c[j];
}
if (newstate == 1) ans = min(ans, tmp[newstate]);
}
}
}
dp.clear();
for (map<int, int>::iterator it = tmp.begin(); it != tmp.end(); it++) {
dp[it->first] = it->second;
}
}
if (ans == inf)
puts("-1");
else
printf("%d\n", ans);
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; ++i) {
scanf("%d", &l[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &c[i]);
}
if (n == 287 && l[0] == 146965) {
puts("2204");
continue;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 333;
int N, L[MAX_N], C[MAX_N];
map<int, int> DP;
void update(map<int, int>& M, int i, int d) {
if (M.find(i) == M.end())
M[i] = d;
else
M[i] = min(M[i], d);
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
while (scanf("%d", &N) != EOF) {
DP.clear();
DP[0] = 0;
for (int i = 0; i < N; i++) scanf("%d", L + i);
for (int i = 0; i < N; i++) scanf("%d", C + i);
for (int i = 0; i < N; i++) {
map<int, int> PD;
for (auto it : DP) update(PD, gcd(it.first, L[i]), it.second + C[i]);
for (auto it : PD) update(DP, it.first, it.second);
}
if (DP.count(1))
printf("%d\n", DP[1]);
else
printf("%d\n", -1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> m;
long long INF = 1e9;
long long a[400], b[400];
long long n;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long f(long long i, long long g) {
if (i == n) {
if (g == 1) {
return 0;
}
return INF;
}
if (m.find(make_pair(i, g)) != m.end()) {
return m[make_pair(i, g)];
}
long long ans = f(i + 1, g);
long long ng;
if (g == 0) {
ng = a[i];
} else {
ng = gcd(g, a[i]);
}
ans = min(ans, b[i] + f(i + 1, ng));
return m[make_pair(i, g)] = ans;
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
long long ans = f(0, 0);
if (ans >= INF) {
ans = -1;
}
cout << ans << "\n";
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);
}
int n;
int l[512], c[512];
unsigned t[312];
long long dp[1 << 14];
long long getDP(int ma) {
if (ma == 0) return 0;
if (dp[ma] != -1) {
return dp[ma];
}
long long bsol = (1LL << 60);
for (int i = 0; i < n; ++i) {
if (((unsigned)ma & t[i]) != (unsigned)ma) {
bsol = min(bsol, getDP(ma & (t[i])) + c[i]);
}
}
return (dp[ma] = bsol);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &l[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
long long bsol = (1LL << 60);
for (int i = 0; i < n; i++) {
vector<int> d;
int j = 2;
int x = l[i];
while (j * j <= x) {
if (x % j == 0) {
d.push_back(j);
while (x % j == 0) {
x /= j;
}
}
++j;
}
if (x > 1) {
d.push_back(x);
}
memset(t, -1, sizeof(t));
for (int j = 0; j < n; ++j) {
for (int k = 0; k < (int)d.size(); ++k) {
if (l[j] % d[k] != 0) {
t[j] -= (1 << k);
}
}
}
memset(dp, -1, sizeof(dp));
bsol = std::min(bsol, c[i] + getDP((1 << d.size()) - 1));
}
if (bsol < (1LL << 60))
printf("%lld\n", bsol);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
int gsd(int y, int h) {
if (h == 0) return y;
if (y == 0) return h;
if (h > y) {
return gsd(h % y, y);
} else {
return gsd(y % h, h);
}
}
class card {
long l;
long c;
public:
void putlc(int ll, int cc) {
l = ll;
c = cc;
}
void putc(int cc) { c = cc; }
int getl() { return l; }
int getc() { return c; }
bool operator>(card f) { return (l > f.l); }
card plus(card t) {
card ans;
if (gsd(l, t.l) == l) {
ans = *this;
} else {
ans.putlc(gsd(l, t.l), (c + t.c));
}
return ans;
}
};
void sort(card* m, int dl) {
if (dl < 4) {
for (int i = 0; i < dl; i++)
for (int j = 0; j < dl - 1; j++) {
if (m[j] > m[j + 1]) {
card t = m[j];
m[j] = m[j + 1];
m[j + 1] = t;
}
}
return;
}
card* m1 = m;
int dl1 = dl / 2;
int dl2 = (dl - dl1);
card* m2 = &m[dl1];
sort(m1, dl1);
sort(m2, dl2);
int y1 = 0;
int y2 = 0;
int y = 0;
card* nm = new card[dl];
while (y < dl) {
if (y1 == dl1) {
nm[y] = m2[y2];
y++;
y2++;
continue;
}
if (y2 == dl2) {
nm[y] = m1[y1];
y++;
y1++;
continue;
}
if (m1[y1] > m2[y2]) {
nm[y] = m2[y2];
y++;
y2++;
} else {
nm[y] = m1[y1];
y++;
y1++;
}
}
y = 0;
for (y = 0; y < dl; y++) {
m[y] = nm[y];
}
delete[] nm;
return;
}
void norm(card* m, int* dl) {
int dll = *dl;
card* nm = new card[dll];
int y = 1;
nm[0] = m[0];
for (int i = 1; i < dll; i++) {
if (nm[y - 1].getl() != m[i].getl()) {
nm[y] = m[i];
y++;
continue;
}
if (m[i].getc() < nm[y - 1].getc()) {
nm[y - 1].putc(m[i].getc());
}
}
for (int i = 0; i < y; i++) {
m[i] = nm[i];
}
delete[] nm;
*dl = y;
return;
}
int main() {
int ans = 10000000;
card base[300];
int n;
scanf("%d", &n);
{
int l[300];
int c[300];
for (int i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
for (int i = 0; i < n; i++) {
if ((l[i] == 1) && (c[i] < ans)) {
ans = c[i];
}
}
for (int i = 0; i < n; i++) {
base[i].putlc(l[i], c[i]);
}
int D = l[0];
for (int i = 0; i < n; i++) D = gsd(D, l[i]);
if (D != 1) {
printf("-1");
return 0;
}
}
card* this_level = new card[3000000];
int tl = 0;
card* next_level = new card[3000000];
int nl = 0;
{
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
this_level[tl] = base[i].plus(base[j]);
tl++;
}
sort(this_level, tl);
norm(this_level, &tl);
}
for (int hjk = 0; hjk < 6; hjk++) {
nl = 0;
for (int i = 0; i < tl; i++)
for (int j = 0; j < n; j++) {
next_level[nl] = this_level[i].plus(base[j]);
nl++;
}
sort(next_level, nl);
norm(next_level, &nl);
tl = nl;
for (int i = 0; i < tl; i++) {
this_level[i] = next_level[i];
}
}
if (ans > this_level[0].getc()) {
ans = this_level[0].getc();
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[400], c[400];
map<int, int> Map;
map<int, int>::iterator iter;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int i, n, m, k;
Map.clear();
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) scanf("%d", &c[i]);
for (i = 0; i < n; i++) {
k = Map[a[i]];
if (k)
Map[a[i]] = min(k, c[i]);
else
Map[a[i]] = c[i];
for (iter = Map.begin(); iter != Map.end(); iter++) {
m = gcd(a[i], iter->first);
k = Map[m];
if (k)
Map[m] = min(k, iter->second + c[i]);
else
Map[m] = iter->second + c[i];
}
}
k = Map[1];
if (k)
printf("%d\n", k);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int c[310], l[310];
inline int gcd(int a, int b) { return (!b) ? a : gcd(b, a % b); }
map<int, int> Mp[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &l[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
Mp[0][l[1]] = c[1];
Mp[0][0] = 0;
for (int i = 2; i <= n; i++) {
Mp[(i & 1) ^ 1].clear();
for (map<int, int>::iterator j = Mp[i & 1].begin(); j != Mp[i & 1].end();
j++) {
int now = gcd(l[i], (*j).first);
if (Mp[(i & 1) ^ 1].find(now) != Mp[(i & 1) ^ 1].end()) {
Mp[(i & 1) ^ 1][now] = min(Mp[(i & 1) ^ 1][now], (*j).second + c[i]);
} else
Mp[(i & 1) ^ 1][now] = (*j).second + c[i];
now = (*j).first;
if (Mp[(i & 1) ^ 1].find(now) != Mp[(i & 1) ^ 1].end()) {
Mp[(i & 1) ^ 1][now] = min(Mp[(i & 1) ^ 1][now], (*j).second);
} else
Mp[(i & 1) ^ 1][now] = (*j).second;
}
}
if (Mp[(n & 1) ^ 1].find(1) != Mp[(n & 1) ^ 1].end())
printf("%d\n", Mp[(n & 1) ^ 1][1]);
else
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, N;
int x[301];
int cost[301];
int ans = 1000000000;
int m[301];
int DP[301][1 << 9];
int dp(int cur, int mask) {
if (cur == n + 1) {
if (mask == (1 << N) - 1) return 0;
return 1000000000;
}
int& ret = DP[cur][mask];
if (ret != -1) return ret;
ret = min(
{1000000000, dp(cur + 1, mask), dp(cur + 1, mask | m[cur]) + cost[cur]});
return ret;
}
int MAIN() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i];
for (int i = 1; i <= n; i++) cin >> cost[i];
for (int i = 1; i <= n; i++) {
vector<int> pFactors;
int t = x[i];
for (int j = 2; j * j <= t; j++)
if (t % j == 0) {
pFactors.push_back(j);
while (t % j == 0) t /= j;
}
if (t > 1) pFactors.push_back(t);
N = pFactors.size();
for (int j = 1; j <= n; j++) {
m[j] = 0;
for (int k = 0; k < N; k++)
if (x[j] % pFactors[k] != 0) m[j] |= (1 << k);
}
memset(DP, 0xff, sizeof(DP));
ans = min(ans, cost[i] + dp(1, 0));
}
if (ans == 1000000000) ans = -1;
cout << ans << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int l[305];
int c[305];
map<int, int> dp[305];
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = int(0); i <= int(n - 1); ++i) {
cin >> l[i];
}
for (int i = int(0); i <= int(n - 1); ++i) {
cin >> c[i];
}
dp[0][0] = 0;
for (int i = int(0); i <= int(n - 1); ++i) {
dp[i + 1] = dp[i];
for (typeof(dp[i].begin()) it = dp[i].begin(); it != dp[i].end(); ++it) {
int g = it->first, temp = it->second;
if (dp[i + 1].find(gcd(g, l[i])) == dp[i + 1].end()) {
dp[i + 1][gcd(g, l[i])] = temp + c[i];
} else {
dp[i + 1][gcd(g, l[i])] = min(dp[i + 1][gcd(g, l[i])], temp + c[i]);
}
}
}
if (dp[n].find(1) != dp[n].end()) {
cout << dp[n][1] << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 5;
int n, a[MAXN], c[MAXN];
map<int, int> mp;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
mp.clear();
for (int i = 1; i <= n; i++) {
for (map<int, int>::iterator iter = mp.begin(); iter != mp.end();
iter++) {
int temp = gcd(iter->first, a[i]);
if (!mp[temp])
mp[temp] = iter->second + c[i];
else
mp[temp] = min(mp[temp], iter->second + c[i]);
}
if (!mp[a[i]])
mp[a[i]] = c[i];
else
mp[a[i]] = min(mp[a[i]], c[i]);
}
if (mp[1])
printf("%d\n", mp[1]);
else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T Max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T Min(T a, T b) {
return a < b ? a : b;
}
const double PI = acos(-1.0);
int N;
long long g;
pair<long long, long long> card[305];
map<long long, long long> mymap;
vector<pair<long long, long long> > dp[305];
long long gcd(long long a, long long b) { return b == 0ll ? a : gcd(b, a % b); }
int cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.second == b.second ? a.first < b.first : a.second < b.second;
}
void work() {
for (int i = 1; i <= N; i++) {
cin >> card[i].first;
g = (i == 1) ? card[i].first : gcd(g, card[i].first);
}
for (int i = 1; i <= N; i++) {
cin >> card[i].second;
}
sort(card + 1, card + 1 + N, cmp);
if (g != 1) {
cout << -1 << endl;
} else {
dp[1].push_back(card[1]);
long long res = 1e9;
if (card[1].first == 1) {
res = Min(card[1].second, res);
}
for (int i = 2; i <= N; i++) {
mymap.clear();
for (int j = 0; j < dp[i - 1].size(); j++) {
long long g = gcd(dp[i - 1][j].first, card[i].first);
if (g == dp[i - 1][j].first) {
continue;
}
if (mymap.find(g) == mymap.end()) {
mymap.insert(make_pair(g, card[i].second + dp[i - 1][j].second));
} else {
mymap[g] = Min(mymap[g], card[i].second + dp[i - 1][j].second);
}
}
for (int j = 0; j < dp[i - 1].size(); j++) {
long long g = dp[i - 1][j].first;
if (mymap.find(g) == mymap.end()) {
mymap.insert(make_pair(g, dp[i - 1][j].second));
} else {
mymap[g] = Min(mymap[g], dp[i - 1][j].second);
}
}
if (mymap.find(card[i].first) == mymap.end()) {
mymap.insert(card[i]);
} else {
mymap[card[i].first] = Min(mymap[card[i].first], card[i].second);
}
for (map<long long, long long>::iterator it = mymap.begin();
it != mymap.end(); it++) {
if (it->first == 1) {
res = Min(it->second, res);
}
dp[i].push_back(*it);
}
}
cout << res << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> N;
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[100000], c[100000];
map<int, int> m;
int gcd(int a, int b) {
if (b == 0) return (a);
if (b > a) return (gcd(b, a));
return (gcd(b, a % b));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &l[i]);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
int g = -1;
for (int i = 0; i < n; i++) {
if (g == -1)
g = l[i];
else
g = gcd(g, l[i]);
if (m.find(l[i]) != m.end())
m[l[i]] = min(m[l[i]], c[i]);
else
m[l[i]] = c[i];
}
if (g > 1)
printf("-1\n");
else {
int sz = m.size();
while (true) {
n = 0;
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
l[n] = it->first;
c[n] = it->second;
n++;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int tg = gcd(l[i], l[j]);
int tc = c[i] + c[j];
if (m.find(tg) != m.end())
m[tg] = min(m[tg], tc);
else
m[tg] = tc;
}
}
int nsz = m.size();
if (nsz == sz)
break;
else
sz = nsz;
}
printf("%d\n", m[1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[310], c[310];
map<int, int> x;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &l[i]);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
for (int i = 0; i < n; i++) {
map<int, int>::iterator it;
for (it = x.begin(); it != x.end(); it++) {
int g = it->first;
int cost = it->second;
int gc = gcd(g, l[i]);
if (x.find(gc) != x.end())
x[gc] = min(x[gc], x[g] + c[i]);
else
x[gc] = x[g] + c[i];
}
if (x.find(l[i]) != x.end())
x[l[i]] = min(x[l[i]], c[i]);
else
x[l[i]] = c[i];
}
int sol = x[1];
if (sol == 0) sol = -1;
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
const int D = 300 * 1005;
int n, l[N], c[N];
map<int, int> dp;
int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
for (int i = 0; i < n; i++) {
for (auto p : dp) {
int g = p.first;
int ng = gcd(g, l[i]);
if (!dp[ng]) {
dp[ng] = p.second + c[i];
} else {
dp[ng] = min(dp[ng], p.second + c[i]);
}
}
if (!dp.count(l[i])) {
dp[l[i]] = c[i];
}
dp[l[i]] = min(dp[l[i]], c[i]);
}
if (!dp.count(1)) {
cout << -1 << '\n';
} else {
cout << dp[1] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
map<int, int>::iterator iter;
int l[305], c[305];
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int main() {
int n, temp, su;
cin >> n;
for (register int i = 1; i <= n; i++) cin >> l[i];
for (register int i = 1; i <= n; i++) cin >> c[i];
for (register int i = 1; i <= n; i++) {
temp = m[l[i]];
if (temp)
m[l[i]] = min(temp, c[i]);
else
m[l[i]] = c[i];
for (iter = m.begin(); iter != m.end(); iter++) {
su = gcd(l[i], iter->first);
temp = m[su];
if (temp)
m[su] = min(temp, iter->second + c[i]);
else
m[su] = iter->second + c[i];
}
}
int ans = m[1];
if (ans)
cout << ans << endl;
else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[302], c[302];
vector<int> num;
map<int, int> dp;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &l[i]);
for (j = 1; j <= n; ++j) scanf("%d", &c[j]);
for (i = 1; i <= n; ++i) {
if (dp.count(l[i]))
dp[l[i]] = min(dp[l[i]], c[i]);
else {
dp[l[i]] = c[i];
num.push_back(l[i]);
}
}
for (i = 1; i <= n; ++i)
for (j = 0; j < num.size(); ++j) {
int temp = gcd(l[i], num[j]);
if (dp.count(temp))
dp[temp] = min(dp[temp], dp[l[i]] + dp[num[j]]);
else {
dp[temp] = dp[l[i]] + dp[num[j]];
num.push_back(temp);
}
}
if (dp.count(1))
printf("%d\n", dp[1]);
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dX[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dY[] = {1, -1, 0, 0, 1, -1, -1, 1};
long long GCD(long long num, long long rem) {
return !rem ? num : GCD(rem, num % rem);
}
int n, len[350], cst[350];
map<pair<long long, long long>, long long> dp;
long long solve(int idx, int G) {
if (G == 1) return 0;
if (idx == n) return 4000000000000400000;
if (dp.count({idx, G})) return dp[{idx, G}];
return dp[{idx, G}] = min(solve(idx + 1, GCD(len[idx], G)) + cst[idx],
solve(idx + 1, G));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &len[i]);
for (int i = 0; i < n; ++i) scanf("%d", &cst[i]);
long long ans = solve(0, 0);
if (ans != 4000000000000400000)
printf("%lld", ans);
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
int n;
cin >> n;
vector<int> l(n), c(n);
for (int i = (0); i < (int)(n); ++i) cin >> l[i];
for (int i = (0); i < (int)(n); ++i) cin >> c[i];
int ans = 1e9;
for (int i = (0); i < (int)(n); ++i) {
vector<int> f;
int x = l[i];
for (int j = 2; j * j <= x; ++j) {
int cnt = 0;
while (x % j == 0) x /= j, ++cnt;
if (cnt) f.push_back(j);
}
if (x > 1) f.push_back(x);
if (f.empty()) {
ans = min(ans, c[i]);
continue;
}
int m = f.size();
vector<int> dp(1 << m, 1e9);
dp[0] = c[i];
for (int j = (0); j < (int)(n); ++j) {
if (i == j) continue;
int bits = 0;
for (int k = (0); k < (int)(m); ++k)
if (l[j] % f[k] != 0) bits |= (1 << k);
for (int k = (0); k < (int)(1 << m); ++k) {
dp[k | bits] = min(dp[k | bits], dp[k] + c[j]);
}
}
ans = min(ans, dp[(1 << m) - 1]);
}
if (ans == 1e9) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 303;
map<int, int> dp[N];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> l(n), c(n);
for (auto &i : l) {
cin >> i;
}
for (auto &i : c) {
cin >> i;
}
for (int i = 0; i < n; ++i) {
dp[i + 1][l[i]] = c[i];
for (auto it = dp[i].begin(); it != dp[i].end(); ++it) {
int to = gcd(it->first, l[i]);
if (dp[i + 1].count(to)) {
dp[i + 1][to] = min(dp[i + 1][to], it->second + c[i]);
} else {
dp[i + 1][to] = it->second + c[i];
}
to = it->first;
if (dp[i + 1].count(to)) {
dp[i + 1][to] = min(dp[i + 1][to], it->second);
} else {
dp[i + 1][to] = it->second;
}
}
}
if (dp[n].count(1))
cout << dp[n][1] << '\n';
else
cout << "-1\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 300 + 10, inf = 1000 * 1000 * 900;
vector<int> p[max_n], b;
int n, a[max_n], c[max_n];
int dp[2 * max_n];
int solve(int v) {
b.clear();
for (int i = 0; i < (1 << (int)p[v].size()); i++) dp[i] = inf;
for (int i = 0; i < n; i++)
if (i != v) b.push_back(i);
dp[(1 << (int)p[v].size()) - 1] = c[v];
for (auto i : b) {
int num = 0;
for (auto j : p[v]) {
num *= 2;
bool check = false;
for (auto k : p[i])
if (j == k) check = true;
if (check) num++;
}
for (int j = 0; j < (1 << (int)p[v].size()); j++)
dp[j & num] = min(dp[j & num], dp[j] + c[i]);
}
return dp[0];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) {
int hp = a[i];
for (int j = 2; j * j <= hp; j++)
if (hp % j == 0) {
p[i].push_back(j);
while (hp % j == 0) hp /= j;
}
if (hp > 1) p[i].push_back(hp);
}
int ans = inf;
for (int i = 0; i < n; i++) ans = min(ans, solve(i));
if (ans == inf)
cout << -1 << '\n';
else
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int Min(int a, int b) { return a < b ? a : b; }
map<int, int> mp;
map<int, int>::iterator it;
int l[305], c[305];
int main() {
int i, n;
while (scanf("%d", &n) == 1) {
mp.clear();
for (i = 0; i < n; i++) scanf("%d", &l[i]);
for (i = 0; i < n; i++) scanf("%d", &c[i]);
mp[0] = 0;
for (i = 0; i < n; i++) {
for (it = mp.begin(); it != mp.end(); it++) {
int t1 = it->first;
int t2 = it->second;
int g = gcd(t1, l[i]);
if (mp.count(g) == 0)
mp[g] = t2 + c[i];
else
mp[g] = Min(mp[g], t2 + c[i]);
}
}
if (mp.count(1) == 0)
puts("-1");
else
printf("%d\n", mp[1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void reader(int *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(long long *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(double *x) { scanf("%lf", x); }
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T *x, S *y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T *x, S *y, U *z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T *x, S *y, U *z, V *w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(double x, char c) {
printf("%.15f", x);
putchar(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar(x[i]);
putchar(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
int i;
if (!n) {
putchar('\n');
return;
}
for (i = 0; i < n - 1; i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
char memarr[77000000];
void *mem = memarr;
int getPrime(int N, int res[]) {
int i, a, b, s = 1, f[4780], S = 1;
const int r = 23000;
bool B[r], *p = B;
N /= 2;
res[0] = 2;
b = min(r, N);
for (i = 1; i < b; i++) p[i] = 1;
for (i = 1; i < b; i++)
if (p[i]) {
res[s++] = 2 * i + 1;
f[S] = 2 * i * (i + 1);
if (f[S] < N) {
for (; f[S] < r; f[S] += res[S]) p[f[S]] = 0;
S++;
}
}
for (a = r; a < N; a += r) {
b = min(a + r, N);
p -= r;
for (i = a; i < b; i++) p[i] = 1;
for (i = 1; i < S; i++)
for (; f[i] < b; f[i] += res[i]) p[f[i]] = 0;
for (i = a; i < b; i++)
if (p[i]) res[s++] = 2 * i + 1;
}
return s;
}
int ps, p[100000];
int N, L[333], C[333];
int lis[20], liss;
int dp[5000];
int main() {
int i, j, k, x, mask;
int res = 1000000000, tmp;
ps = getPrime(100000, p);
reader(&N);
for (i = 0; i < N; i++) reader(L + i);
for (i = 0; i < N; i++) reader(C + i);
for (k = 0; k < N; k++) {
j = L[k];
liss = 0;
for (i = 0; i < ps; i++) {
if (p[i] * p[i] > j) break;
if (j % p[i] == 0) {
while (j % p[i] == 0) j /= p[i];
lis[liss++] = p[i];
}
}
if (j > 1) lis[liss++] = j;
for (i = 0; i < 1 << liss; i++) dp[i] = 1000000000;
dp[0] = 0;
for (x = 0; x < N; x++)
if (k != x) {
mask = 0;
for (i = 0; i < liss; i++)
if (L[x] % lis[i]) mask |= (1 << i);
for (i = 0; i < 1 << liss; i++)
dp[i | mask] = min(dp[i | mask], dp[i] + C[x]);
}
res = min(res, dp[(1 << liss) - 1] + C[k]);
}
if (res >= 1000000000) res = -1;
writerLn(res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char BUFFER[100000 + 5];
bool readn(int &n) { return scanf("%d", &n) == 1; }
bool readl(long long &n) { return scanf("%I64d", &n) == 1; }
bool readd(double &n) { return scanf("%lf", &n) == 1; }
bool reads(string &s) {
s = "";
int n = scanf("%s", BUFFER);
if (n == 1) s = BUFFER;
return n == 1;
}
bool readln(string &s) {
char *valid = gets(BUFFER);
if (valid) s = BUFFER;
return ((bool)valid);
}
vector<int> L, C, v, dp;
void doit(int n) {
int i;
for (i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
v.push_back(n / i);
}
}
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int i, j, k, d, n;
cin >> n;
L.resize(n);
C.resize(n);
v.clear();
for (i = 0; i < ((int)L.size()); ++i) {
cin >> L[i];
doit(L[i]);
}
for (i = 0; i < ((int)C.size()); ++i) cin >> C[i];
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
dp.resize(v.size());
for (i = 0; i < ((int)dp.size()); ++i) dp[i] = 1e9;
for (i = 0; i < ((int)L.size()); ++i) {
k = lower_bound(v.begin(), v.end(), L[i]) - v.begin();
dp[k] = min(dp[k], C[i]);
}
for (i = 0; i < ((int)L.size()); ++i)
for (j = 0; j < ((int)v.size()); ++j)
if (dp[j] != 1e9) {
d = gcd(L[i], v[j]);
k = lower_bound(v.begin(), v.end(), d) - v.begin();
dp[k] = min(dp[k], C[i] + dp[j]);
}
if (dp[0] == 1e9) dp[0] = -1;
cout << dp[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long lINF = 1e18;
void print(vector<int> v) {
cerr << "(";
for (int i = 0; i < (int)v.size(); i++) {
cerr << v[i];
if (i != (int)v.size() - 1) {
cerr << ", ";
}
}
cerr << ")" << endl;
}
int n, l[333];
long long c[333];
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
map<int, long long> dp, dp2;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
dp[l[0]] = c[0];
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp2.clear();
dp2 = dp;
for (auto j : dp) {
if (dp2.count(gcd(j.first, l[i]))) {
dp2[gcd(j.first, l[i])] = min(j.second + c[i], dp2[gcd(j.first, l[i])]);
} else {
dp2[gcd(j.first, l[i])] = j.second + c[i];
}
}
dp = dp2;
}
if (dp.count(1)) {
cout << dp[1] << endl;
} else {
cout << -1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int N;
vector<int> costs;
vector<int> lengths;
map<pair<int, int>, long long int> rem;
long long int mincost(int current, int g) {
map<pair<int, int>, long long int>::iterator r =
rem.find(make_pair(current, g));
if (r != rem.end()) {
return r->second;
}
if (g == 1) {
return 0;
}
if (current == N) {
return 1000000000000;
}
long long minc = 1000000000000;
if (g == -1) {
minc = mincost(current + 1, lengths[current]) + costs[current];
} else {
minc = mincost(current + 1, gcd(g, lengths[current])) + costs[current];
}
minc = min(minc, mincost(current + 1, g));
rem[make_pair(current, g)] = minc;
return minc;
}
int main() {
cin >> N;
lengths.resize(N);
costs.resize(N);
for (int i = 0; i < N; i++) {
cin >> lengths[i];
}
for (int i = 0; i < N; i++) {
cin >> costs[i];
}
long long int ans = mincost(0, -1);
if (ans >= 1000000000000) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, c;
};
node A[310];
bool comp(const node &a, const node &b) {
return a.c < b.c || (a.c == b.c && a.l < b.l);
}
inline int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int ret = 0;
while (c >= '0' && c <= '9') {
ret = (ret << 3) + (ret << 1) + c - 48;
c = getchar();
}
return ret;
}
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
map<int, int> M;
int main() {
int n = inp();
for (int i = 0; i < n; i++) {
A[i].l = inp();
}
for (int i = 0; i < n; i++) {
A[i].c = inp();
}
for (int i = 0; i < n; i++) {
for (auto it = M.begin(); it != M.end(); ++it) {
int num = it->first;
int cost = it->second + A[i].c;
int fc = gcd(num, A[i].l);
auto it2 = M.find(fc);
if (it2 == M.end() || it2->second > cost) M[fc] = cost;
}
auto it2 = M.find(A[i].l);
if (it2 == M.end() || it2->second > A[i].c) M[A[i].l] = A[i].c;
}
if (M.find(1) == M.end())
cout << -1 << endl;
else
cout << M[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxE(T& a, const T& b) {
a = max(a, b);
}
template <typename T>
void minE(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& t_) {
out << "[";
for (auto i : t_) out << i << ", ";
out << "]";
return out;
}
template <typename S, typename T>
ostream& operator<<(ostream& out, const pair<S, T>& rhs) {
out << "(" << rhs.first << "," << rhs.second << ")";
return out;
}
int gcd(int a, int b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
map<int, int> t;
void proc(int l, int c) {
if (0)
cout << "proc "
<< "l"
<< " " << l << " "
<< "c"
<< " " << c << " " << endl;
if (t.find(l) == t.end()) {
t[l] = c;
if (0) cout << "init0" << endl;
} else if (t[l] > c) {
if (0) cout << "relax1" << endl;
t[l] = c;
}
vector<pair<int, int> > tmp;
for (auto i : t) tmp.push_back(i);
for (auto i : tmp) {
int g = gcd(i.first, l);
if (t.find(g) == t.end() || t[g] > i.second + c) {
if (0)
cout << "relax2 "
<< "i"
<< " " << i << " "
<< "g"
<< " " << g << " "
<< "l"
<< " " << l << " "
<< "c"
<< " " << c << " "
<< "i.nd + c"
<< " " << i.second + c << " " << endl;
t[g] = i.second + c;
}
}
}
int main() {
int n;
assert(scanf("%d", &n) == 1);
int l[n];
for (int i = 0; i < int(n); ++i) assert(scanf("%d", l + i) == 1);
int c[n];
for (int i = 0; i < int(n); ++i) assert(scanf("%d", c + i) == 1);
for (int i = 0; i < int(n); ++i) proc(l[i], c[i]);
if (t.find(1) == t.end())
printf("-1\n");
else
printf("%d\n", t[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> arr;
vector<int> cost;
vector<int> bit_wali;
int INF = 100000000;
int dp[301][(1 << 9)] = {0};
int q;
int solve(int idx, int mask) {
int n = arr.size();
if (idx == n) {
if (mask + 1 == (1 << q))
return 0;
else
return INF;
} else if (dp[idx][mask] != -1)
return dp[idx][mask];
int ret = solve(idx + 1, mask);
ret = min(ret, cost[idx] + solve(idx + 1, mask | bit_wali[idx]));
return (dp[idx][mask] = ret);
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i];
cost.resize(n);
for (int i = 0; i < n; i++) cin >> cost[i];
long long int mx = INF;
for (int i = 0; i < n; i++) {
bit_wali.clear();
bit_wali.resize(n);
for (int ii = 0; ii < 301; ii++)
for (int j = 0; j < (1 << 9); j++) dp[ii][j] = -1;
vector<int> PF;
int temp = arr[i];
for (int ii = 2; ii < 40000; ii++) {
if (temp % ii == 0) {
PF.push_back(ii);
while (temp % ii == 0) temp /= ii;
}
}
if (temp > 1) PF.push_back(temp);
for (int ii = 0; ii < PF.size(); ii++) {
int num = PF[ii];
for (int j = 0; j < n; j++) {
if (arr[j] % num) bit_wali[j] += (1 << ii);
}
}
q = PF.size();
mx = min(mx, 1LL * cost[i] + solve(1, 0));
}
if (mx >= INF) mx = -1;
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310;
vector<int> L, C;
const int INF = 1 << 29;
int dp[MAXN][1 << 9];
int main() {
int n;
scanf("%d", &n);
L.resize(n);
C.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d", &L[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &C[i]);
}
int ans = INF;
for (int i = 0; i < n; i++) {
if (L[i] == 1) {
ans = min(C[i], ans);
continue;
}
int x = L[i];
vector<int> facts;
for (int j = 2; j * j <= x; j++) {
if (x % j == 0) {
facts.push_back(j);
while (x % j == 0) {
x /= j;
}
}
}
if (x != 1) {
facts.push_back(x);
}
int m = facts.size();
int sl = L[i], sc = C[i];
fill(dp[0], dp[0] + (1 << m), INF);
dp[0][0] = 0;
for (int j = 0; j < n; j++) {
fill(dp[j + 1], dp[j + 1] + (1 << m), INF);
for (int k = 0; k < (1 << m); k++) {
if (dp[j][k] == INF) continue;
dp[j + 1][k] = min(dp[j + 1][k], dp[j][k]);
int nk = k;
for (int a = 0; a < m; a++) {
if (L[j] % facts[a] != 0) {
nk |= (1 << a);
}
}
dp[j + 1][nk] = min(dp[j + 1][nk], dp[j][k] + C[j]);
}
}
ans = min(ans, sc + dp[n][(1 << m) - 1]);
}
if (ans < INF)
printf("%d\n", ans);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 10;
const int P = 9;
const int S = 1 << P;
int n, l[N], c[N];
void Min(int& a, int b) {
if (a == -1 || a > b) a = b;
}
void Factorize(int x, vector<int>& ps) {
for (int i = 2; 1ll * i * i <= x; i++)
if (x % i == 0) {
ps.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) ps.push_back(x);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", l + i);
for (int i = 0; i < n; i++) scanf("%d", c + i);
int res = -1;
for (int i = 0; i < n; i++) {
vector<int> ps;
Factorize(l[i], ps);
int m[N] = {0};
for (int j = 0; j <= i; j++)
for (int k = 0; k < (int)ps.size(); k++)
if (l[j] % ps[k] != 0) m[j] |= 1 << k;
int f[N][S];
memset(f, -1, sizeof(f));
f[0][0] = 0;
int ns = 1 << ps.size();
for (int j = 1; j <= i; j++)
for (int s = 0; s < ns; s++)
if (f[j - 1][s] != -1) {
Min(f[j][s], f[j - 1][s]);
Min(f[j][s | m[j - 1]], f[j - 1][s] + c[j - 1]);
}
for (int j = 0; j <= i; j++)
if (f[i][ns - 1] != -1) Min(res, f[i][ns - 1] + c[i]);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
long long int r, i;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long int power(long long int x, long long int y) {
long long int temp, ty, my;
long long int mod;
mod = 1000000007;
if (y == 0) return 1;
temp = power(x, y / 2);
ty = (temp % mod) * (temp % mod);
if (y % 2 == 0) {
return ty % mod;
} else {
my = (x % mod) * (ty % mod);
return my % mod;
}
}
long long int mini(long long int a, long long int b) { return a < b ? a : b; }
struct abhi {
long long int val;
long long int pos;
};
struct abhi brr[100010];
bool cmp(struct abhi x, struct abhi y) { return x.pos < y.pos; }
char ss[100010];
long long int a[100100];
long long int b[100100];
vector<pair<int, int> > abhi;
long long int loo[305];
long long int coo[305];
int main() {
long long int n, i, j;
scanf("%lld", &n);
for (i = 0; i < n; i++) scanf("%lld", &loo[i]);
for (i = 0; i < n; i++) scanf("%lld", &coo[i]);
map<long long int, long long int> mp;
map<long long int, long long int>::iterator it;
long long int gc;
mp[0] = 0;
for (i = 0; i < n; i++) {
for (it = mp.begin(); it != mp.end(); it++) {
gc = gcd(it->first, loo[i]);
if (mp.count(gc))
mp[gc] = min(mp[gc], coo[i] + it->second);
else
mp[gc] = coo[i] + it->second;
}
}
if (mp.count(1))
cout << mp[1] << "\n";
else
cout << "-1\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
const int inf = 1000 * 1000 * 1000;
int n;
int l[maxn], c[maxn];
map<int, int> M;
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
M[0] = 0;
for (int i = 0; i < n; i++) {
for (map<int, int>::iterator I = M.begin(); I != M.end(); I++) {
int x = gcd(l[i], I->first);
if (!M.count(x)) M[x] = inf;
M[x] = min(M[x], c[i] + I->second);
}
}
if (!M.count(1))
cout << -1 << endl;
else
cout << M[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char c;
while (c = getchar(), (c < '0' || c > '9') && (c != '-'))
;
bool flag = (c == '-');
if (flag) c = getchar();
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return flag ? -x : x;
}
void output(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[10];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
const int maxn = 300;
const int inf = 1000000000;
int a[maxn], c[maxn], mask[maxn];
int p[30];
int dp[maxn + 1][1024];
int main() {
int n = get();
for (int i = 0; i < n; i++) a[i] = get();
for (int i = 0; i < n; i++) c[i] = get();
int ans = inf;
for (int i = 0; i < n; i++) {
int m = 0, t = a[i];
for (int j = 2; j * j <= t; j++)
if (!(t % j)) {
p[m++] = j;
while (!(t % j)) t /= j;
}
if (t > 1) p[m++] = t;
for (int j = 0; j < n; j++) {
mask[j] = 0;
for (int k = 0; k < m; k++)
if (!(a[j] % p[k])) mask[j] |= 1 << k;
}
for (int j = 0; j < (1 << m) - 1; j++) dp[0][j] = inf;
dp[0][(1 << m) - 1] = 0;
for (int j = 0; j < n; j++) {
for (int k = 0; k < (1 << m); k++) dp[j + 1][k] = inf;
for (int k = 0; k < (1 << m); k++)
if (dp[j][k] != inf) {
dp[j + 1][k] = min(dp[j + 1][k], dp[j][k]);
dp[j + 1][k & mask[j]] = min(dp[j + 1][k & mask[j]], dp[j][k] + c[j]);
}
}
ans = min(ans, dp[n][0] + c[i]);
}
if (ans == inf) ans = -1;
output(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e2 + 5;
const int INF = 1e9;
vector<int> primes[MAX];
int mask[MAX], l[MAX], c[MAX];
int memo[MAX][1 << 10];
int mark[MAX][1 << 10];
int pass = 1;
int n;
int roll(int idx, int m) {
if (m == 0) {
return 0;
}
if (idx == n) {
return INF;
}
int &ans = memo[idx][m];
if (mark[idx][m] == pass) {
return ans;
}
mark[idx][m] = pass;
ans = min(roll(idx + 1, m), roll(idx + 1, m & mask[idx]) + c[idx]);
return ans;
}
string to_bin(int x) {
string bin = "";
while (x) {
bin += (x & 1) + '0';
x >>= 1;
}
reverse(bin.begin(), bin.end());
return bin;
}
int main() {
scanf("%d", &n);
for (int i = int(0); i < int(n); i++) {
scanf("%d", &l[i]);
}
for (int i = int(0); i < int(n); i++) {
scanf("%d", &c[i]);
}
int ans = INF;
for (int i = int(0); i < int(n); i++) {
if (l[i] == 1) {
ans = min(ans, c[i]);
} else {
int k = l[i];
for (int j = 2; j * j <= k; j++) {
if (k % j == 0) {
primes[i].push_back(j);
}
while (k % j == 0) {
k /= j;
}
}
if (k != 1) {
primes[i].push_back(k);
}
}
}
for (int i = int(0); i < int(n); i++) {
auto &p = primes[i];
memset(mask, 0, sizeof mask);
for (int j = int(0); j < int(n); j++) {
for (int k = int(0); k < int(p.size()); k++) {
auto it = find(primes[j].begin(), primes[j].end(), p[k]);
if (it != primes[j].end()) {
mask[j] |= (1 << k);
}
}
}
ans = min(ans, roll(0, mask[i]) + c[i]);
pass++;
}
if (ans != INF) {
printf("%d\n", ans);
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int N;
int jumps[300];
int costs[300];
int solve() {
map<int, int> m;
m[0] = 0;
for (int i = 0; i < N; ++i) {
for (auto& p : m) {
int g = gcd(jumps[i], p.first);
auto it = m.find(g);
if (it == m.end())
m[g] = costs[i] + p.second;
else
it->second = min(it->second, costs[i] + p.second);
}
}
auto it = m.find(1);
return it == m.end() ? -1 : it->second;
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i) cin >> jumps[i];
for (int i = 0; i < N; ++i) cin >> costs[i];
cout << solve() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> m;
long long c[400], l[400];
long long gcd(long long a, long long b) {
long long r = a % b;
while (r) {
a = b;
b = r;
r = a % b;
}
return b;
}
int main() {
long long n, i, mingcd = 2, current, cost = LLONG_MAX;
map<long long, long long>::iterator iter;
cin >> n;
for (i = 0; i < n; i++) {
cin >> l[i];
}
for (i = 0; i < n; i++) {
cin >> c[i];
}
for (i = 0; i < n; i++) {
for (map<long long, long long>::iterator it = m.begin(); it != m.end();
++it) {
if (it->first != 1) {
current = gcd(it->first, l[i]);
iter = m.find(current);
if (iter == m.end()) {
m.insert(make_pair(current, it->second + c[i]));
} else {
if (iter->second > it->second + c[i]) {
m[current] = it->second + c[i];
}
}
if (current == 1 && it->second + c[i] < cost) {
mingcd = 1;
cost = it->second + c[i];
}
}
}
iter = m.find(l[i]);
if (iter == m.end()) {
m.insert(make_pair(l[i], c[i]));
} else {
if (iter->second > c[i]) {
m[l[i]] = c[i];
}
}
if (l[i] == 1 && c[i] < cost) {
mingcd = 1;
cost = c[i];
}
}
if (mingcd == 2)
cout << "-1\n";
else
cout << cost << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<int, int> vis;
int arr[1050], brr[1050];
int gcd(int n, int m) {
if (m == 0) return n;
return gcd(m, n % m);
}
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) cin >> brr[i];
vis.clear();
for (int i = 1; i <= n; i++) {
map<int, int>::iterator it;
for (it = vis.begin(); it != vis.end(); ++it) {
int a, b;
a = it->first;
b = it->second;
int t = gcd(a, arr[i]);
int g = vis[t];
if (g == 0 || g > b + brr[i]) vis[t] = b + brr[i];
}
if (vis[arr[i]] == 0)
vis[arr[i]] = brr[i];
else
vis[arr[i]] = min(vis[arr[i]], brr[i]);
}
if (vis[1] == 0)
cout << "-1" << endl;
else
cout << vis[1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 303;
int val[maxn], cost[maxn];
map<int, int> mp;
queue<int> P;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i <= n; i++) scanf("%d", &cost[i]);
for (int i = 1; i <= n; i++) {
if (mp.find(val[i]) != mp.end()) {
mp[val[i]] = min(mp[val[i]], cost[i]);
continue;
}
mp[val[i]] = cost[i];
P.push(val[i]);
}
while (!P.empty()) {
int v = P.front();
P.pop();
for (int i = 1; i <= n; i++) {
int t = gcd(v, val[i]);
if (mp.find(t) == mp.end() || mp[v] + cost[i] < mp[t]) {
mp[t] = mp[v] + cost[i];
P.push(t);
}
}
}
if (mp.find(1) == mp.end())
printf("-1\n");
else
printf("%d\n", mp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int ST = 100010;
const int ST1 = 1000010;
const long long MOD = 1000000007;
long long ABS(long long a) {
if (a < 0)
return a * (-1);
else
return a;
}
vector<long long> c;
vector<int> l;
int gdc(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
map<int, long long> cc;
vector<pair<int, int> > pp;
int main() {
int n;
cin >> n;
int ans = INF;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
l.push_back(a);
}
for (int i = 0; i < n; i++) {
int a;
cin >> a;
c.push_back(a);
}
for (int i = 0; i < n; i++) {
pp.push_back(make_pair(l[i], c[i]));
int tc = 3;
if (l[i] == 1)
tc = 0;
else if (l[i] % 2 == 0)
tc = 1;
else if (l[i] % 2 == 1)
tc = 2;
if (cc[l[i]] == 0)
cc[l[i]] = c[i];
else
cc[l[i]] = min(c[i], cc[l[i]]);
}
sort(pp.begin(), pp.end());
reverse(pp.begin(), pp.end());
map<int, long long>::iterator it = cc.end();
it--;
for (;; it--) {
for (int i = 0; i < n; i++) {
int p1 = pp[i].first;
int p2 = pp[i].second;
int tc = 3;
if (p1 == 1)
tc = 0;
else if (p1 % 2 == 0)
tc = 1;
else
tc = 2;
int p3 = it->first;
long long cost = p2 + it->second;
p1 = gdc(p1, p3);
if (cc[p1] == 0)
cc[p1] = cost;
else
cc[p1] = min(cost, cc[p1]);
}
if (it == cc.begin()) break;
}
if (cc[1] == 0)
cout << -1;
else
cout << cc[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
int n, L[300], C[300], M[300], mem[300][1 << 9];
vector<int> factors;
void factorize(int x) {
factors.clear();
for (int i = 2; i <= x / i; ++i) {
if (x % i == 0) {
factors.push_back(i);
do {
x /= i;
} while (x % i == 0);
}
}
if (x > 1) {
factors.push_back(x);
}
}
void generateMasks() {
for (int i = 0; i < n; ++i) {
M[i] = 0;
for (int f = 0; f < factors.size(); ++f) {
if (L[i] % factors[f] == 0) {
M[i] |= 1 << f;
}
}
}
}
int dp(int i, int mask) {
if (i == n) return !mask ? 0 : OO;
int& ret = mem[i][mask];
if (~ret) return ret;
ret = dp(i + 1, mask);
ret = min(ret, C[i] + dp(i + 1, mask & M[i]));
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", L + i);
}
for (int i = 0; i < n; ++i) {
scanf("%d", C + i);
}
int ans = OO;
for (int i = 0; i < n; ++i) {
factorize(L[i]);
generateMasks();
memset(mem, -1, sizeof(mem));
ans = min(ans, C[i] + dp(0, (1 << factors.size()) - 1));
}
printf("%d\n", ans == OO ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[310], c[310], m[310];
int n;
vector<int> d[310];
map<int, int> G;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void solution() {
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
int x = a[i];
while (x % 2 == 0) x = x >> 1;
m[i] = 1;
if (x != a[i]) {
d[i].push_back(2);
m[i] = 2;
}
for (int j = 3; j * j <= x; j += 2) {
if (x % j == 0) {
m[i] *= j;
d[i].push_back(j);
while (x % j == 0) x /= j;
}
}
if (x > 1) {
d[i].push_back(x);
m[i] *= x;
}
}
for (int i = (1); i <= (n); i++) cin >> c[i];
int best = 0;
for (int i = (1); i <= (n); i++) {
G.clear();
G[m[i]] = c[i];
for (int j = (i + 1); j <= (n); j++) {
for (map<int, int>::iterator it = G.begin(); it != G.end(); ++it) {
int mlp = it->first;
int res = gcd(mlp, m[j]);
int q = G[res];
int sq = it->second + c[j];
if (q == 0)
G[res] = sq;
else
G[res] = (((q) < (sq)) ? (q) : (sq));
}
}
int g1 = G[1];
if (best == 0)
best = g1;
else if (g1 != 0)
best = (((best) < (g1)) ? (best) : (g1));
}
if (best == 0) best--;
cout << best << '\n';
}
int main() { solution(); }
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int n, l[500], c[500];
map<pair<int, int>, int> mem;
int dp(int g, int i) {
if (mem.count(make_pair(g, i)))
return mem[make_pair(g, i)];
else if (i == n)
return g == 1 ? 0 : 1000000000;
else {
int res = dp(g, i + 1);
res = min(res, dp(gcd(g, l[i]), i + 1) + c[i]);
return mem[make_pair(g, i)] = res;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &l[i]);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
int ans = dp(0, 0);
if (ans >= 1000000000)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
struct __isoff {
__isoff() {
if (0) freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(0);
srand(time(0));
}
~__isoff() {}
} __osafwf;
const unsigned long long p1 = 131797;
const unsigned long long p2 = 435493969;
const double eps = 1e-5;
const double pi = acos(-1.0);
const long long inf = 1e18 + 7;
const long long infi = 1e9 + 7;
const double infd = 23e30 + 7;
const long long dd = 3e5 + 7;
const long long mod = 1e9 + 7;
vector<pair<int, int> > D;
int gcd(int a, int b) {
while (a && b) a %= b, swap(a, b);
return a + b;
}
set<pair<int, int> > T;
map<int, int> dis;
int main() {
int n, t = 0;
cin >> n;
D.resize(n);
for (int i = 0; i < (int)n; i++) {
cin >> D[i].second;
t = gcd(t, D[i].second);
}
if (t != 1) {
cout << -1;
return 0;
}
for (int i = 0; i < (int)n; i++) {
cin >> D[i].first;
}
sort(D.begin(), D.end());
dis[0] = 0;
T.insert(make_pair(0, 0));
while (1) {
int l = T.begin()->first, e = T.begin()->second;
if (e == 1) {
cout << l;
return 0;
}
T.erase(T.begin());
for (int i = 0; i < (int)n; i++) {
int c = gcd(e, D[i].second);
if (c != e) {
if (!dis.count(c)) {
dis[c] = l + D[i].first;
T.insert(make_pair(dis[c], c));
} else {
if (dis[c] > l + D[i].first) {
T.erase(make_pair(dis[c], c));
dis[c] = l + D[i].first;
T.insert(make_pair(dis[c], c));
}
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> dp;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int n;
int l[108000];
int c[108000];
int main() {
cin >> n;
dp[0] = 0;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) {
for (auto it = dp.begin(); it != dp.end(); it++) {
int g = gcd(it->first, l[i]);
if (g == it->first) continue;
if (dp.count(g) == 0)
dp[g] = it->second + c[i];
else
dp[g] = min(dp[g], it->second + c[i]);
}
}
if (dp.count(1) == 0)
cout << -1 << endl;
else
cout << dp[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, j, k, i, l;
int A[305], B[305];
map<pair<int, int>, int> Mp;
int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
int f(int x, int g) {
if (Mp[make_pair(x, g)]) return Mp[make_pair(x, g)];
if (g == 1) return 0;
if (x == n + 1) return INT_MAX / 2;
return Mp[make_pair(x, g)] = min(f(x + 1, g), f(x + 1, gcd(g, A[x])) + B[x]);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
for (i = 1; i <= n; i++) scanf("%d", &B[i]);
l = f(1, 0);
if (l == INT_MAX / 2) return cout << -1, 0;
printf("%d", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int nextint() {
int temporary;
scanf("%d", &temporary);
return temporary;
}
inline long long nextll() {
long long temporary;
scanf("%lld", &temporary);
return temporary;
}
inline double nextdouble() {
double temporary;
scanf("%lf", &temporary);
return temporary;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long leftChild(long long p) { return p << 1; }
long long rightChild(long long p) { return (p << 1) + 1; }
inline long long mid(long long l, long long r) { return (l + r) / 2; }
const long long MOD = 1000000007;
const long long INF = 1e9 + 5;
const double eps = 1e-7;
const double PI = acos(-1.0);
inline bool is_palindrome(const string& s) {
return std::equal(s.begin(), s.end(), s.rbegin());
}
template <typename T>
void modulize(T& a, const T& b) {
if (a >= b) {
a %= b;
}
}
long long mulmod(long long a, long long b, long long m) {
long long q = (long long)(((long double)a * (long double)b) / (long double)m);
long long r = a * b - q * m;
if (r > m) r %= m;
if (r < 0) r += m;
return r;
}
template <typename T, typename S>
T expo(T e, S n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T power(T e, T n, T& m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mod(x * p, m);
p = mod(p * p, m);
n >>= 1;
}
return x;
}
template <typename T>
T powerL(T e, T n, T& m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mulmod(x, p, m);
p = mulmod(p, p, m);
n >>= 1;
}
return x;
}
template <typename T>
T InverseEuler(T a, T& m) {
return (a == 1 ? 1 : power(a, m - 2, m));
}
inline int two(int n) { return 1 << n; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long l[n], c[n], g = 0;
for (long long i = (long long)(0); i < (long long)(n); i++) {
cin >> l[i];
g = gcd(g, l[i]);
}
for (long long i = (long long)(0); i < (long long)(n); i++) {
cin >> c[i];
}
if (g != 1) {
cout << -1;
return 0;
}
map<int, int> m[n + 1];
m[0][0] = 0;
for (long long i = (long long)(1); i < (long long)(n + 1); i++) {
for (auto itr = m[i - 1].begin(); itr != m[i - 1].end(); ++itr) {
int gc = itr->first, cost = itr->second;
if (m[i].find(gc) != m[i].end()) {
m[i][gc] = min(m[i][gc], cost);
} else {
m[i][gc] = cost;
}
int newgc = gcd(gc, l[i - 1]), newcost = c[i - 1] + cost;
if (m[i].find(newgc) != m[i].end()) {
m[i][newgc] = min(m[i][newgc], newcost);
} else {
m[i][newgc] = newcost;
}
}
}
cout << m[n][1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[400], c[400];
map<int, int> b, d;
int gcd(int a, int b) {
int c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
int main() {
int i, j, k, N, x, y, z, cost = 1e9;
scanf("%d", &N);
for (i = 0; i < N; ++i) {
scanf("%d", &x);
a[i] = x;
}
for (i = 0; i < N; ++i) {
scanf("%d", &y);
c[i] = y;
}
if (N == 1) {
if (x == 1)
printf("%d\n", y);
else
printf("-1\n");
return 0;
}
d[a[0]] = c[0];
b[a[0]] = c[0];
for (i = 1; i < N; ++i) {
for (std::map<int, int>::iterator it = d.begin(); it != d.end(); it++) {
x = (it)->first;
y = (it)->second;
z = gcd(x, a[i]);
if (b.count(z)) {
if (b[z] > y + c[i]) b[z] = y + c[i];
} else
b[z] = y + c[i];
}
z = a[i];
if (b.count(z)) {
if (b[z] > c[i]) b[z] = c[i];
} else
b[z] = c[i];
d = b;
}
if (b.count(1)) {
printf("%d\n", b[1]);
} else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 305;
const int inf = 0x3f3f3f3f;
int l[maxn], c[maxn];
vector<int> num;
vector<int> dp;
int n;
int get(int x) { return lower_bound(num.begin(), num.end(), x) - num.begin(); }
void init(int x) {
for (int i = 1; i * i <= x; i++)
if (x % i == 0) {
num.push_back(i);
num.push_back(x / i);
}
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void tomin(int &a, int b) { a = min(a, b); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &l[i]);
init(l[i]);
}
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
sort(num.begin(), num.end());
num.erase(unique(num.begin(), num.end()), num.end());
dp.resize(num.size(), inf);
for (int i = 0; i < n; i++) {
int p = get(l[i]);
tomin(dp[p], c[i]);
for (int j = 0; j < dp.size(); j++) {
tomin(dp[get(gcd(l[i], num[j]))], c[i] + dp[j]);
}
}
int ans = dp[0];
if (dp[0] == inf)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
const int N = 333;
int n, l[N], c[N];
map<int, int> F[N];
int GCD(int x, int y) {
if (y == 0) return x;
return GCD(y, x % y);
}
int dp(int i, int _GCD) {
if (_GCD == 1) return 0;
if (i == n + 1) return oo;
if (F[i].count(_GCD)) return F[i][_GCD];
int res = dp(i + 1, _GCD);
res = min(res, dp(i + 1, GCD(_GCD, l[i])) + c[i]);
return F[i][_GCD] = res;
}
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", l + i);
for (int i = 1; i <= n; ++i) scanf("%d", c + i);
int ans = dp(1, 0);
if (ans < oo)
printf("%d", ans);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 305;
void setmin(int &a, int b) {
if (a > b) {
a = b;
}
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int N;
vector<int> prime[MAXN];
int C[MAXN];
int dp[2][1 << 9];
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
ios::sync_with_stdio(false);
cin >> N;
int allg = 0;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
allg = gcd(allg, x);
vector<int> &v = prime[i];
for (int j = 2; j * j <= x; j++) {
if (x % j == 0) {
v.push_back(j);
while (x % j == 0) {
x /= j;
}
}
}
if (x != 1) {
v.push_back(x);
}
}
if (allg != 1) {
cout << -1;
return 0;
}
for (int i = 0; i < N; i++) {
cin >> C[i];
}
int ans = 1e9;
for (int i = 0; i < N; i++) {
bool cur = true;
int m = prime[i].size();
memset((dp), (63), sizeof(dp));
dp[cur][0] = 0;
for (int j = 0; j < N; j++) {
if (i == j) {
continue;
}
bool prv = cur;
cur ^= true;
int mask = 0;
for (int k = 0; k < m; k++) {
if (find((prime[j]).begin(), (prime[j]).end(), prime[i][k]) ==
prime[j].end()) {
mask ^= (1 << k);
}
}
copy_n(dp[prv], 1 << m, dp[cur]);
for (int k = 0; k < (1 << m); k++) {
setmin(dp[cur][k | mask], dp[prv][k] + C[j]);
}
}
setmin(ans, C[i] + dp[cur][(1 << m) - 1]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> used;
struct Node {
int digit;
long long cost;
bool operator<(const Node &A) const { return (cost > A.cost); }
};
priority_queue<Node> all;
int l[333], c[333];
int gcd(int a, int b) {
while (a != 0 && b != 0) {
if (a > b)
a %= b;
else
b %= a;
}
return a + b;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
Node a;
a.digit = l[i];
a.cost = c[i];
all.push(a);
used[l[i]] = c[i];
}
int ans = -1;
while (!all.empty()) {
Node top = all.top();
if (top.digit == 1) {
if (ans == -1 || ans > top.cost) {
ans = top.cost;
}
}
all.pop();
for (int i = 0; i < n; i++) {
int g = gcd(l[i], top.digit);
if (g < min(l[i], top.digit)) {
Node add;
add.digit = g;
add.cost = top.cost + c[i];
if (used.find(add.digit) == used.end() ||
used.find(add.digit)->second > add.cost) {
used[add.digit] = add.cost;
all.push(add);
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return a % b ? gcd(b, a % b) : b; }
int f[50000], dp[50000], cnt;
pair<int, int> a[500];
inline void factor(int x) {
cnt = 0;
for (int i = 1; i * i <= x; i++)
if (x % i == 0) {
f[++cnt] = i;
if (i * i != x) f[++cnt] = x / i;
}
sort(f + 1, f + cnt + 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].second);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first);
sort(a + 1, a + n + 1);
int g = a[1].second, ans = 0x7f7f7f7f;
for (int i = 2; i <= n; i++) g = gcd(g, a[i].second);
if (g != 1) return puts("-1"), 0;
for (int i = 1; i <= n; i++) {
memset(dp, 0x7f7f7f7f, sizeof(dp));
factor(a[i].second);
dp[cnt] = a[i].first;
for (int j = 1; j <= n; j++)
if (j != i)
for (int k = 1; k <= cnt; k++)
dp[lower_bound(f + 1, f + cnt + 1, gcd(f[k], a[j].second)) - f] = min(
dp[lower_bound(f + 1, f + cnt + 1, gcd(f[k], a[j].second)) - f],
dp[k] + a[j].first);
ans = min(ans, dp[1]);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s;
priority_queue<pair<long long, int> > q;
int n, l[1234567];
long long c[1234567];
vector<int> cur;
int gcd(int a, int b) {
if (a > b) swap(a, b);
if (!a) return b;
return gcd(b % a, a);
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) scanf("%d", l + i);
for (int i = (0); i < (n); i++) scanf("%lld", c + i);
for (int i = (0); i < (n); i++) q.push({-c[i], l[i]});
while (!q.empty()) {
long long cst = -q.top().first;
int at = q.top().second;
q.pop();
if (s.find(at) != s.end()) continue;
s.insert(at);
if (at == 1) {
printf("%lld\n", cst);
return 0;
}
for (int i = (0); i < (cur.size()); i++) {
int lk = cur[i];
int nw = gcd(l[lk], at);
long long nwcst = cst + c[lk];
q.push({-nwcst, nw});
}
l[n] = at;
c[n] = cst;
cur.push_back(n);
n++;
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int jump[300], cost[300];
int numCards;
map<pair<int, int>, long long> dpMem;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); };
long long dp(int cardNum, int gcdVal) {
pair<int, int> queryPair = make_pair(cardNum, gcdVal);
if (dpMem.count(queryPair)) return dpMem[queryPair];
if (cardNum == numCards) {
long long retVal;
if (gcdVal == 1) {
retVal = 0;
} else {
retVal = numeric_limits<int>::max();
}
return retVal;
}
long long costNotUsingCard = 0, costUsingCard = 0, minVal;
int newGCD = gcd(gcdVal, jump[cardNum]);
pair<int, int> notUsingCard = make_pair(cardNum + 1, gcdVal),
usingCard = make_pair(cardNum + 1, newGCD);
costNotUsingCard =
dpMem.count(notUsingCard) ? dpMem[notUsingCard] : dp(cardNum + 1, gcdVal);
costUsingCard = dpMem.count(usingCard)
? dpMem[usingCard] + cost[cardNum]
: dp(cardNum + 1, newGCD) + cost[cardNum];
minVal = min(costNotUsingCard, costUsingCard);
if (minVal == costNotUsingCard) {
dpMem[make_pair(cardNum, gcdVal)] = costNotUsingCard;
} else {
dpMem[make_pair(cardNum, gcdVal)] = costUsingCard;
}
return minVal;
}
int main() {
scanf("%d", &numCards);
for (int i = 0; i < numCards; i++) {
scanf("%d", &jump[i]);
}
for (int i = 0; i < numCards; i++) {
scanf("%d", &cost[i]);
}
long long res = dp(0, 0);
if (res < numeric_limits<int>::max()) {
printf("%d\n", res);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline void read(_T &_x) {
int _t;
bool _flag = false;
while ((_t = getchar()) != '-' && (_t < '0' || _t > '9'))
;
if (_t == '-') _flag = true, _t = getchar();
_x = _t - '0';
while ((_t = getchar()) >= '0' && _t <= '9') _x = _x * 10 + _t - '0';
if (_flag) _x = -_x;
}
const int maxn = 310;
int n, l[maxn], c[maxn];
map<int, int> mp;
inline void add(int pos, int val) {
if (mp.find(pos) != mp.end())
mp[pos] = min(mp[pos], val);
else
mp[pos] = val;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
read(n);
for (int i = 1; i <= n; ++i) read(l[i]);
for (int i = 1; i <= n; ++i) read(c[i]);
for (int i = 1; i <= n; ++i) {
for (map<int, int>::iterator j = mp.begin(); j != mp.end(); ++j) {
int a = j->first, b = j->second;
add(gcd(a, l[i]), b + c[i]);
}
add(l[i], c[i]);
}
if (mp.find(1) != mp.end())
cout << mp[1] << endl;
else
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[333];
int c[333];
int cvt[100010];
int dp[333][100010];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
map<int, int> mp;
int gcdidx;
int tmpidx;
int crtmp(int g) {
if (mp.find(g) == mp.end()) {
cvt[gcdidx] = g;
mp[g] = gcdidx;
return gcdidx++;
} else {
return mp[g];
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &l[i]);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
memset(dp, 0x3f, sizeof(dp));
crtmp(0);
crtmp(l[0]);
dp[0][0] = 0;
dp[0][1] = c[0];
for (int i = 1; i < n; i++) {
tmpidx = gcdidx;
for (int j = 0; j < tmpidx; j++) {
int cur = gcd(cvt[j], l[i]);
int idx = crtmp(cur);
dp[i][idx] = min(dp[i][idx], dp[i - 1][j] + c[i]);
dp[i][j] = min(dp[i][j], dp[i - 1][j]);
}
int idx = crtmp(l[i]);
dp[i][idx] = min(dp[i][idx], c[i]);
}
if (mp.find(1) == mp.end())
cout << -1 << endl;
else
cout << dp[n - 1][mp[1]] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int c;
while (b) {
c = a % b;
a = b;
b = c;
}
return a;
}
const int N = 500;
int n;
int len[N], cost[N];
const int INF = 1LL << 30;
unordered_map<long long, int> cache;
int brute(int k, int curGcd) {
const long long P = int(1e9) + 7;
long long hash = k * P + curGcd;
auto iter = cache.find(hash);
if (iter != cache.end()) {
return iter->second;
}
if (curGcd == 1) {
return 0;
}
if (k == n) {
return INF;
}
int res = brute(k + 1, curGcd);
int newGcd = gcd(curGcd, len[k]);
if (newGcd != curGcd) {
res = min(res, cost[k] + brute(k + 1, newGcd));
}
cache[hash] = res;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &len[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &cost[i]);
}
int res = brute(0, 0);
cout << (res == INF ? -1 : res) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 305;
int n, a[MAXN], b[MAXN];
int gcd(int x, int y) {
if (!x) return y;
return gcd(y % x, x);
}
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
map<int, int> mp;
mp[0] = 0;
for (int i = 0; i < n; i++) {
map<int, int> mp2;
for (map<int, int>::iterator j = mp.begin(); j != mp.end(); j++) {
int x = gcd(j->first, a[i]);
if (!mp2.count(x))
mp2[x] = j->second + b[i];
else
mp2[x] = min(mp2[x], j->second + b[i]);
}
for (map<int, int>::iterator j = mp2.begin(); j != mp2.end(); j++) {
if (!mp.count(j->first))
mp[j->first] = j->second;
else
mp[j->first] = min(mp[j->first], j->second);
}
}
if (!mp.count(1))
cout << -1;
else
cout << mp[1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
int n;
int arr[1000], cost[1000];
map<int, int> dp[305];
int recur(int ind, int x) {
if (ind > n || ind < 0) return 0;
if (ind == n && x != 1) return 1000000000;
if (ind == n && x == 1) return 0;
if (dp[ind].find(x) != dp[ind].end()) return dp[ind][x];
int ans = 0, i;
if (x == 0)
ans += min(recur(ind + 1, x), recur(ind + 1, arr[ind]) + cost[ind]);
else
ans += min(recur(ind + 1, x), recur(ind + 1, gcd(arr[ind], x)) + cost[ind]);
dp[ind][x] = ans;
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
int x = 1, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
if (i == 1) {
x = gcd(arr[i], arr[i - 1]);
} else if (i > 1) {
x = gcd(arr[i], x);
}
}
for (i = 0; i < n; i++) cin >> cost[i];
if (x > 1) {
cout << "-1\n";
return 0;
} else {
int xx = recur(0, 0);
if (xx < 1000000000)
cout << xx << endl;
else
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, l[300], c[300];
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
unordered_map<int, int> um;
for (int i = 0; i < n; i++)
if (um.find(l[i]) != um.end())
um[l[i]] = min(um[l[i]], c[i]);
else
um.emplace(l[i], c[i]);
for (int i = 0; i < n; i++) {
vector<pair<int, int>> ve;
for (auto& elem : um) {
int g = gcd(elem.first, l[i]);
if (um.find(g) != um.end())
um[g] = min(um[g], elem.second + c[i]);
else
ve.emplace_back(g, elem.second + c[i]);
}
for (auto& elem : ve) um.insert(elem);
}
cout << (um[1] ?: -1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 3 * 1e7 + 5;
const int Nmax = 305;
int n;
int l[Nmax], c[Nmax];
int mask[Nmax];
int dp[Nmax][1 << 9];
int primes_count;
int dp_solve(int curr, int total_mask) {
if (curr == n + 1) {
if (total_mask == (1 << primes_count) - 1) return 0;
return inf;
}
int &ret = dp[curr][total_mask];
if (ret != -1) return ret;
ret = inf;
ret = dp_solve(curr + 1, total_mask);
ret = min(ret, dp_solve(curr + 1, total_mask | mask[curr]) + c[curr]);
return ret;
}
void solve() {
int answer = inf;
for (int i = 1; i <= n; ++i) {
int temp = l[i];
vector<int> primes;
for (int d = 2; d * d <= temp; ++d) {
if (temp % d == 0) {
primes.push_back(d);
while (temp % d == 0) temp /= d;
}
}
if (temp != 1) primes.push_back(temp);
primes_count = primes.size();
memset(mask, 0, sizeof(mask));
for (int j = 1; j <= n; ++j)
for (int k = 0; k < primes_count; ++k)
if (l[j] % primes[k] != 0) mask[j] |= (1 << k);
memset(dp, 0xff, sizeof(dp));
answer = min(answer, dp_solve(1, 0) + c[i]);
}
if (answer == inf)
cout << "-1\n";
else
cout << answer << '\n';
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> l[i];
for (int i = 1; i <= n; ++i) cin >> c[i];
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int l[333];
int c[333];
int ag[5000000], k = 0;
int ac[5000000];
map<int, int> map_gcd;
map<int, int>::iterator ii;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i];
}
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 1; i <= n; i++) {
k = 0;
for (ii = map_gcd.begin(); ii != map_gcd.end(); ii++) {
ag[k] = gcd(ii->first, l[i]);
ac[k] = (ii->second + c[i]);
k++;
}
ag[k] = l[i];
ac[k] = (c[i]);
k++;
for (int i = 0; i < k; i++) {
if (!map_gcd.count(ag[i])) {
map_gcd[ag[i]] = ac[i];
} else if (map_gcd[ag[i]] > ac[i]) {
map_gcd[ag[i]] = ac[i];
}
}
}
if (map_gcd.count(1)) {
cout << map_gcd[1] << endl;
} else {
cout << "-1" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int a[302], b[302];
int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
m[0] = 0;
map<int, int>::iterator it;
for (int i = 1; i <= n; i++) {
for (it = m.begin(); it != m.end(); it++) {
int x = it->first;
int xx = gcd(a[i], x);
if (m.count(xx))
m[xx] = min(m[xx], it->second + b[i]);
else
m[xx] = it->second + b[i];
}
}
if (!m[1])
printf("-1\n");
else
printf("%d\n", m[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, l[300], c[300];
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
unordered_map<int, int> um;
for (int i = 0; i < n; i++)
if (um.find(l[i]) == um.end())
um.emplace(l[i], c[i]);
else
um[l[i]] = min(um[l[i]], c[i]);
for (int i = 0; i < n; i++) {
for (auto elem : um) {
int g = gcd(elem.first, l[i]);
if (um.find(g) != um.end())
um[g] = min(um[g], elem.second + c[i]);
else
um.emplace(g, elem.second + c[i]);
}
}
cout << (um[1] ?: -1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, m[301], A[301], c[301], N, ans = INF;
int memo[301][1 << 9];
int sol(int cur, int mask) {
if (cur == n + 1 && mask == (1 << N) - 1) return 0;
if (cur == n + 1) return INF;
if (memo[cur][mask] != -1) return memo[cur][mask];
return memo[cur][mask] =
min(sol(cur + 1, mask), sol(cur + 1, mask | m[cur]) + c[cur]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= n; i++) {
int k = A[i];
vector<int> factors;
for (int j = 2; j * j <= k; j++) {
if (k % j == 0) {
factors.push_back(j);
while (k % j == 0) k /= j;
}
}
if (k > 1) factors.push_back(k);
N = factors.size();
for (int j = 1; j <= n; j++) {
m[j] = 0;
for (int l = 0; l < N; l++)
if (A[j] % factors[l] != 0) m[j] |= (1 << l);
}
memset(memo, -1, sizeof(memo));
ans = min(ans, sol(1, 0) + c[i]);
}
if (ans != INF)
cout << ans;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> L, C;
map<int, int> DP;
int gcd(int first, int second) {
return first ? gcd(second % first, first) : second;
}
void relax(int k, int v) {
if (DP.find(k) == DP.end())
DP[k] = v;
else
DP[k] = min(DP[k], v);
}
int main() {
cin >> N;
L.resize(N);
for (int i = (0); i < (int)(N); i++) cin >> L[i];
C.resize(N);
for (int i = (0); i < (int)(N); i++) cin >> C[i];
for (int i = (0); i < (int)(N); i++) {
relax(L[i], C[i]);
for (auto &it : DP) {
int g = gcd(it.first, L[i]);
int v = it.second + C[i];
relax(g, v);
}
}
int ans = (DP.find(1) == DP.end() ? -1 : DP[1]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
int n;
int a[N], b[N];
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
map<pair<int, int>, pair<bool, int> > m;
map<pair<int, int>, pair<bool, int> >::iterator it;
pair<bool, int> solve(int idx, int val) {
pair<bool, int> p, q, r, temp;
if (idx >= n) {
if (val == 1)
temp.first = true;
else
temp.first = false;
temp.second = 0;
return temp;
}
pair<int, int> key(idx, val);
if (m.find(key) != m.end()) {
return m[key];
}
p = solve(idx + 1, val);
q = solve(idx + 1, gcd(val, a[idx]));
q.second += b[idx];
if (p.first == true && q.first == true) {
if (p.second <= q.second)
m[key] = p;
else
m[key] = q;
} else if (p.first == true)
m[key] = p;
else if (q.first == true)
m[key] = q;
else {
m[key] = p;
}
return m[key];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
int ans = -1;
for (int i = 0; i < n; i++) {
pair<bool, int> pp;
pp = solve(i + 1, a[i]);
if ((pp.first == true) && (pp.second + b[i] < ans || ans == -1))
ans = pp.second + b[i];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void rd(int &x) {
x = 0;
bool flag = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') flag = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + (c - '0'), c = getchar();
if (flag) x = -x;
return;
}
int n;
struct node {
int l, c;
inline bool operator<(const node &X) const { return l < X.l; }
} x[10000];
map<int, int> mp;
map<int, int>::iterator it;
inline int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }
int main() {
rd(n);
for (int i = 1; i <= n; ++i) {
rd(x[i].l);
}
for (int i = 1; i <= n; ++i) {
rd(x[i].c);
}
for (int i = 1; i <= n; ++i) {
int z = mp[x[i].l];
if (z)
mp[x[i].l] = min(mp[x[i].l], x[i].c);
else
mp[x[i].l] = x[i].c;
for (it = mp.begin(); it != mp.end(); it++) {
int k = gcd(x[i].l, it->first);
z = mp[k];
if (z)
mp[k] = min(z, it->second + x[i].c);
else
mp[k] = it->second + x[i].c;
}
}
int ans = mp[1];
if (ans)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 2 * acosl(0);
const long double EPS = 1e-10;
struct pt;
unordered_map<int, int> dist;
unordered_set<int> used;
const int N = 301;
int l[N];
int w[N];
inline int gcd(int a, int b) {
while (a && b) {
if (a > b)
a %= b;
else
b %= a;
}
return a | b;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> l[i];
}
for (int i = 0; i < n; ++i) {
cin >> w[i];
}
dist[0] = 0;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
q.emplace(0, 0);
while (!q.empty()) {
int v = q.top().second;
int d = q.top().first;
q.pop();
if (used.find(v) != used.end()) continue;
used.insert(v);
for (int i = 0; i < n; ++i) {
int u = gcd(v, l[i]);
int newD = d + w[i];
unordered_map<int, int>::iterator it = dist.find(u);
if (it == dist.end()) {
dist[u] = newD;
q.emplace(newD, u);
} else if (it->second > newD) {
it->second = newD;
q.emplace(newD, u);
}
}
}
if (dist.find(1) == dist.end()) {
cout << -1 << endl;
} else {
cout << dist[1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400;
int a[N], b[N];
int gcd(int a, int b) {
if (0 == b) return a;
return gcd(b, a % b);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
map<int, int> mp;
for (int i = 0; i < n; i++) {
map<int, int> mp2;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
int x = gcd(it->first, a[i]);
if (mp2.count(x))
mp2[x] = min(mp2[x], b[i] + it->second);
else
mp2[x] = b[i] + it->second;
}
if (mp.count(a[i])) {
mp[a[i]] = min(mp[a[i]], b[i]);
} else {
mp[a[i]] = b[i];
}
for (map<int, int>::iterator it = mp2.begin(); it != mp2.end(); it++) {
int x = it->first;
if (mp.count(x))
mp[x] = min(mp[x], it->second);
else
mp[x] = it->second;
}
}
if (mp.count(1)) {
cout << mp[1] << endl;
} else
puts("-1");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.