text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int l[305], c[305], best[2000], primes[100];
int n, res;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
res = (1 << 30);
for (int start = 0; start < n; ++start) {
int nprimes = 0;
int tmp = l[start];
for (int i = 2; i * i <= tmp; ++i) {
if (tmp % i == 0) {
while (tmp % i == 0) tmp /= i;
primes[nprimes++] = i;
}
}
if (tmp > 1) primes[nprimes++] = tmp;
memset(best, -1, sizeof(best));
best[0] = c[start];
for (int i = start + 1; i < n; i++) {
int cur = 0;
for (int j = 0; j < nprimes; ++j)
if (l[i] % primes[j] != 0) cur |= 1 << j;
int cc = c[i];
for (int old = 0; old < (1 << nprimes); ++old) {
if (best[old] != -1) {
if (best[old | cur] == -1 || best[old | cur] > best[old] + cc)
best[old | cur] = best[old] + cc;
}
}
}
if (best[(1 << nprimes) - 1] != -1)
res = min(res, best[(1 << nprimes) - 1]);
}
if (res == (1 << 30)) res = -1;
cout << res << endl;
;
return 0;
}
|
#include <bits/stdc++.h>
long long int ciel(double a) {
long long int ret = a;
if (a - ret > 0.0000000001) ret++;
return ret;
}
long long int gcd(long long int a, long long int b) {
if (a < b) return gcd(b, a);
if (a % b == 0) return b;
return gcd(b, a % b);
}
double fgcd(double a, double b) {
if (fabs(a) < fabs(b)) return fgcd(b, a);
if (fabs(b) < 0.0001) return a;
return fgcd(b, fmod(a, b));
}
bool db_db_cmp(double a, double b) {
return (a + 0.0000000001 > b && a - 0.0000000001 < b);
}
long long int fact[100005];
void generate_factorials() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= 100005 - 1; i++)
fact[i] = ((fact[i - 1] * i) % 1000000007);
}
long long int pow(long long int n, long long int p) {
if (p == 0) return 1;
if (n <= 1) return n;
long long int res = 1;
while (p) {
if (p & 1) res = res * n;
n = n * n;
p /= 2;
}
return res;
}
long long int mod_pow(long long int n, long long int p) {
if (p == 0) return 1;
if (n <= 1) return n;
long long int res = 1;
while (p) {
if (p & 1) res = ((res * n) % 1000000007);
n = ((n * n) % 1000000007);
p /= 2;
}
return res;
}
long long int get_inverse(long long int n) {
return mod_pow(n, 1000000007 - 2);
}
long long int get_nCr(long long int n, long long int r) {
return ((fact[n] * get_inverse(((fact[r] * fact[n - r]) % 1000000007))) %
1000000007);
}
using namespace std;
int sieve[100005];
vector<int> primes;
void calc_sieve() {
for (int i = 0; i < 100005; i++) sieve[i] = 0;
sieve[0] = sieve[1] = -1;
for (int i = 2; i < 100005; i++) {
if (sieve[i] == 0) {
primes.push_back(i);
for (int j = i; j < 100005; j = j + i) {
sieve[j]++;
}
}
}
}
vector<int> nums, cost;
int dp[1 << 11];
void preprocess() { calc_sieve(); }
void init() {}
vector<int> cur_primes;
void solve(int test_case) {
init();
int n;
cin >> n;
int g = -1;
int ans = -1;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
nums.push_back(a);
if (g == -1)
g = a;
else
g = gcd(g, a);
}
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
cost.push_back(a);
}
if (g > 1) {
cout << "-1\n";
return;
}
for (int i = 0; i <= (int)nums.size() - 1; i++) {
cur_primes.clear();
if (nums[i] == 1) {
if (ans == -1 || ans > cost[i]) ans = cost[i];
continue;
}
int temp = nums[i];
for (int j = 0; j < primes.size() && primes[j] * primes[j] <= temp; j++) {
if (temp % primes[j] == 0) {
cur_primes.push_back(primes[j]);
while (temp % primes[j] == 0) temp /= primes[j];
}
}
if (temp > 1) cur_primes.push_back(temp);
for (int j = 0; j <= (1 << cur_primes.size()) - 1; j++) {
dp[j] = -1;
}
for (int j = i + 1; j <= (int)nums.size() - 1; j++) {
int cur = 0;
for (int k = 0; k <= (int)cur_primes.size() - 1; k++) {
if (nums[j] % cur_primes[k] == 0) cur |= (1 << k);
}
if (dp[cur] == -1 || dp[cur] > cost[j]) dp[cur] = cost[j];
}
for (int j = (1 << cur_primes.size()) - 1; j >= 1; j--) {
for (int k = j + 1; k <= (1 << cur_primes.size()) - 1; k++) {
int temp = j & k;
if (dp[j] != -1 && dp[k] != -1 &&
(dp[temp] == -1 || dp[temp] > dp[j] + dp[k]))
dp[temp] = dp[j] + dp[k];
}
}
if (dp[0] != -1 && (ans == -1 || ans > dp[0] + cost[i]))
ans = dp[0] + cost[i];
}
cout << ans << endl;
}
int main() {
preprocess();
int t = 1;
for (int i = 1; i <= t; i++) {
solve(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000000;
int l[1000], c[1000];
int f[1000000];
int a[20];
int o[20];
int main() {
int n, i, j, k, ans, m, t, p;
o[0] = 1;
for (i = 1; i < 20; i++) o[i] = o[i - 1] * 2;
cin >> n;
for (i = 0; i < n; i++) cin >> l[i];
for (i = 0; i < n; i++) cin >> c[i];
ans = MAX;
for (i = 0; i < n; i++) {
t = 0;
p = l[i];
for (j = 2; j < sqrt(double(l[i])) + 10; j++)
if (p % j == 0) {
a[t++] = j;
while (p % j == 0) p /= j;
}
if (p != 1) a[t++] = j;
m = o[t] - 1;
for (j = 0; j < m; j++) f[j] = MAX;
f[m] = c[i];
for (j = 0; j < n; j++) {
p = 0;
for (k = 0; k < t; k++)
if (l[j] % a[k] == 0) p += o[k];
for (k = m; k >= 0; k--)
if (f[k] + c[j] < f[k & p]) {
f[k & p] = f[k] + c[j];
}
}
if (f[0] < ans) ans = f[0];
}
if (ans == MAX)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans;
vector<pair<int, int>> arr;
vector<int> len, cost;
unordered_map<int, int> dp;
unordered_map<int, int>::iterator it;
vector<pair<int, int>> tmp;
int const INF = 1e9;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
int main() {
while (scanf("%d", &n) == 1) {
ans = INF;
len.clear();
cost.clear();
tmp.clear();
arr.clear();
dp.clear();
unsigned int start = clock();
for (int i = 0; i < n; ++i) {
int l;
scanf("%d", &l);
len.push_back(l);
}
for (int i = 0; i < n; ++i) {
int l;
scanf("%d", &l);
cost.push_back(l);
}
for (int i = 0; i < n; ++i) {
arr.push_back(make_pair(cost[i], len[i]));
}
sort(arr.begin(), arr.end());
int cur = arr[0].second;
int curCost = arr[0].first;
for (int i = 1; i < n; ++i) {
if (cur == 0) {
ans = curCost;
break;
}
cur = gcd(min(cur, arr[i].second), max(cur, arr[i].second));
if (cur == 0) {
ans = curCost;
}
}
for (int i = 0; i < n; ++i) {
swap(arr[i].first, arr[i].second);
tmp.push_back(make_pair(arr[i].first, arr[i].second));
for (it = dp.begin(); it != dp.end(); ++it) {
pair<int, int> p = (*it);
tmp.push_back(
make_pair(gcd(p.first, arr[i].first), arr[i].second + p.second));
}
while (tmp.size()) {
pair<int, int> p = tmp.back();
tmp.pop_back();
if (dp.find(p.first) == dp.end() || dp[p.first] > p.second) {
if (p.second < ans) dp[p.first] = p.second;
}
}
}
if (dp.find(1) != dp.end()) ans = min(ans, dp[1]);
if (ans == INF)
printf("-1");
else
printf("%d", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
map<int, int> ma;
int l[305], c[305];
int dp[maxn], g[maxn];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n, cnt = 0;
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]);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= cnt; ++j) {
int t = gcd(g[j], l[i]);
if (!ma.count(t)) {
g[++cnt] = t;
ma[t] = cnt;
dp[cnt] = dp[j] + c[i];
} else {
dp[ma[t]] = min(dp[ma[t]], dp[j] + c[i]);
}
}
if (!ma.count(l[i])) {
g[++cnt] = l[i];
ma[l[i]] = cnt;
dp[cnt] = c[i];
} else {
dp[ma[l[i]]] = min(dp[ma[l[i]]], c[i]);
}
}
if (ma[1] == 0)
puts("-1");
else
printf("%d\n", dp[ma[1]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, a;
vector<long long int> val, card;
long long int m[305];
long long int dp[305][(1 << 9)];
long long int sizeo;
long long int rec(long long int wai, long long int mask) {
if (__builtin_popcount(mask) == sizeo) return 0;
if (wai == -1) return INT_MAX;
if (dp[wai][mask] != -1) return dp[wai][mask];
long long int gonnaret = INT_MAX;
gonnaret = min(
{gonnaret, rec(wai - 1, mask | m[wai]) + val[wai], rec(wai - 1, mask)});
return dp[wai][mask] = gonnaret;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long int j = 0; j < 2; j++) {
for (long long int i = 0; i < n; i++) {
cin >> a;
if (!j)
card.push_back(a);
else
val.push_back(a);
}
}
long long int ans = INT_MAX;
for (long long int i = 0; i < n; i++) {
vector<long long int> pfactors;
long long int t = card[i];
for (long long int j = 2; j * j <= t; j++) {
if (!(t % j)) {
pfactors.push_back(j);
while (!(t % j)) t /= j;
}
}
if (t > 1) pfactors.push_back(t);
sizeo = pfactors.size();
for (long long int j = 0; j < n; j++) {
m[j] = 0;
for (long long int ka = 0; ka < sizeo; ka++) {
if ((card[j] % pfactors[ka])) m[j] |= (1 << ka);
}
}
memset(dp, -1, sizeof dp);
ans = min(ans, rec(n - 1, 0) + val[i]);
}
if (ans != INT_MAX)
cout << ans << '\n';
else
cout << -1 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long l[300], c[300];
vector<int> pr[300];
set<int> com;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
map<pair<int, int>, int> dp;
void relax(pair<int, int> a, int c) {
if (dp.find(a) == dp.end())
dp[a] = c;
else
dp[a] = min(dp[a], c);
}
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];
for (auto v = dp.begin(); v != dp.end(); ++v) {
if (v->first.first < i) {
int t = v->first.second;
int s = v->second;
relax(make_pair(i, gcd(l[i], t)), s + c[i]);
} else
break;
}
relax(make_pair(i, l[i]), c[i]);
}
int ans = 1000000000;
for (auto v = dp.begin(); v != dp.end(); ++v) {
if (v->first.second == 1) {
ans = min(ans, v->second);
}
}
if (ans == 1000000000) ans = -1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 305;
const int INF = 0x7f7f7f7f;
int N;
int cards[MAXN];
int costs[MAXN];
int minc[MAXN][1024];
vector<int> factor(int arg) {
vector<int> res;
for (long long p = 2; p * p <= arg; p++)
if (arg % p)
continue;
else {
res.push_back(p);
while (arg % p == 0) arg /= p;
}
if (arg > 1) res.push_back(arg);
sort(res.begin(), res.end());
return res;
}
int pick(int i) {
vector<int> facs = factor(cards[i]);
memset(minc, 0x7f, sizeof(minc));
int M = (1 << facs.size());
minc[0][M - 1] = 0;
for (int j = 0; j < N; j++) {
int mask = 0;
for (int k = 0; k < facs.size(); k++)
if (cards[j] % facs[k] == 0) mask |= 1 << k;
for (int m = 0; m < M; m++)
if (minc[j][m] == INF)
continue;
else {
minc[j + 1][m] = min(minc[j + 1][m], minc[j][m]);
minc[j + 1][m & mask] =
min(minc[j + 1][m & mask], minc[j][m] + costs[j]);
}
}
if (minc[N][0] == INF) return INF;
return minc[N][0] + costs[i];
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> cards[i];
for (int i = 0; i < N; i++) cin >> costs[i];
int mc = INF;
for (int i = 0; i < N; i++) mc = min(mc, pick(i));
cout << (mc == INF ? -1 : mc) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int jump[305], cost[305];
int gcd(const int& a, const int& b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void put(map<int, int>& m, const int& k, const int& v) {
if (m.count(k) == 0)
m[k] = v;
else
m[k] = min(m[k], v);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> jump[i];
}
for (int i = 0; i < n; ++i) {
cin >> cost[i];
}
map<int, int> prev, cur;
map<int, int>::iterator it;
for (int i = 0; i < n; ++i) {
put(cur, jump[i], cost[i]);
for (it = prev.begin(); it != prev.end(); ++it) {
put(cur, it->first, it->second);
int v = gcd(it->first, jump[i]);
put(cur, v, it->second + cost[i]);
}
prev = cur;
}
if (cur.count(1) != 0)
cout << cur[1] << endl;
else
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<long long, long long> > d[301];
vector<long long> l, c;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
cin >> n;
l.assign(n, 0);
c.assign(n, 0);
for (int i = 0; i < n; i++) {
cin >> l[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
d[0].push_back({l[0], c[0]});
for (int i = 1; i < n; i++) {
d[i].push_back({l[i], c[i]});
for (int j = 0; j < d[i - 1].size(); j++) {
d[i].push_back({gcd(d[i - 1][j].first, l[i]), d[i - 1][j].second + c[i]});
}
for (int j = 0; j < d[i - 1].size(); j++) {
d[i].push_back(d[i - 1][j]);
}
d[i - 1].clear();
sort(d[i].begin(), d[i].end());
for (int j = 1; j < d[i].size(); j++) {
if (d[i][j - 1].first == d[i][j].first) {
d[i][j - 1].second = min(d[i][j].second, d[i][j - 1].second);
d[i][j].second = d[i][j - 1].second;
}
}
d[i].erase(unique(d[i].begin(), d[i].end()), d[i].end());
}
long long answer = 1000LL * 1000LL * 1000LL * 1000LL;
for (int i = 0; i < n; i++) {
for (int j = 0; j < d[i].size(); j++) {
if (d[i][j].first == 1) {
answer = min(answer, d[i][j].second);
}
}
}
if (answer == 1000LL * 1000LL * 1000LL * 1000LL) {
cout << -1;
} else {
cout << answer;
}
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) {
if (first == 0) return second;
return gcd(second % first, first);
}
int main() {
cin >> n;
for (int i = (0); i < (int)(n); i++) {
int t;
cin >> t;
l.push_back(t);
}
for (int i = (0); i < (int)(n); i++) {
int t;
cin >> t;
c.push_back(t);
}
for (int i = (0); i < (int)(n); i++) {
if (dp.find(l[i]) == dp.end())
dp[l[i]] = c[i];
else
dp[l[i]] = min(dp[l[i]], c[i]);
for (auto &it : dp) {
int g = gcd(it.first, l[i]);
if (dp.find(g) == dp.end())
dp[g] = it.second + c[i];
else
dp[g] = min(dp[g], it.second + c[i]);
}
}
int ans = (dp.find(1) == dp.end() ? -1 : dp[1]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, x;
int a[1000001], b[100001];
vector<int> p;
map<int, int> mp;
int d[1000001], d2[100001];
int gcd(int A, int B) {
if (A == 0) return B;
if (B == 0) return A;
return gcd(B, A % B);
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
x = a[i];
for (j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
if (mp[j] == 0) {
mp[j] = 1;
p.push_back(j);
}
if (mp[a[i] / j] == 0) {
mp[a[i] / j] = 1;
p.push_back(a[i] / j);
}
}
}
};
for (i = 1; i <= n; i++) cin >> b[i];
sort(p.begin(), p.end());
for (i = 0; i < p.size(); i++) mp[p[i]] = i, d[i] = d2[i] = 1000000000;
for (i = 1; i <= n; i++) {
d[mp[a[i]]] = min(d[mp[a[i]]], b[i]);
for (j = 0; j < p.size(); j++) {
x = gcd(p[j], a[i]);
x = mp[x];
d2[x] = min(d2[x], d[j] + b[i]);
}
for (j = 0; j < p.size(); j++) d[j] = min(d[j], d2[j]), d2[j] = 1000000000;
}
if (d[0] == 1000000000) d[0] = -1;
cout << d[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
int main() {
long long n;
cin >> n;
vector<pair<long long, long long> > cards(n);
for (long long i = 0; i < n; ++i) cin >> cards[i].second;
for (long long i = 0; i < n; ++i) cin >> cards[i].first;
priority_queue<pair<long long, long long> > q;
map<long long, long long> cost;
for (long long i = 0; i < n; ++i) {
pair<long long, long long> aux = cards[i];
aux.first = aux.first * -1;
q.push(aux);
if (cost.find(cards[i].second) == cost.end())
cost[cards[i].second] = cards[i].first;
else
cost[cards[i].second] = min(cost[cards[i].second], cards[i].first);
}
bool done = false;
while (not q.empty() and not done) {
pair<long long, long long> now = q.top();
q.pop();
if (now.second == 1) {
cout << -now.first << endl;
done = true;
}
if (-now.first == cost[now.second]) {
for (long long i = 0; i < n; ++i) {
pair<long long, long long> aux;
aux.second = gcd(cards[i].second, now.second);
aux.first = now.first - cards[i].first;
if (cost.find(aux.second) == cost.end() or
cost[aux.second] > -aux.first) {
cost[aux.second] = -aux.first;
q.push(aux);
}
}
}
}
if (not done) cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int l = 0;
int a[10005], f[40005], pr[10005], p[30], d[10005], v[10005], b[10005],
dp[10005];
void pre() {
int i, j;
long long now = 1;
for (i = 2; i <= 40000; i++)
if (!f[i]) {
pr[++l] = i;
for (j = i + i; j <= 40000; j += i) f[j] = 1;
}
for (i = 1; i <= 22; i++) p[i] = 1 << (i - 1);
}
int find(int x, int ll, int rr) {
int i, j, now, op = 0;
for (i = 1; i <= l; i++) {
if (x % pr[i] == 0) {
b[++op] = pr[i];
while (x % pr[i] == 0) x /= pr[i];
}
}
if (x > 1) b[++op] = x;
for (i = ll; i <= rr; i++) {
now = 0;
for (j = 1; j <= op; j++)
if (a[i] % b[j] == 0) now |= p[j];
d[i] = now;
}
return op;
}
int main() {
int n, i, j, k, l = 0, inf, ans = INT_MAX;
pre();
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) scanf("%d", &v[i]);
for (i = 1; i <= n; i++) {
l = find(a[i], i, n);
memset(dp, 0x3f, sizeof(dp));
inf = dp[0];
dp[p[l + 1] - 1] = v[i];
for (j = i; j <= n; j++) {
for (k = p[l + 1] - 1; k >= 1; k--) {
dp[k & d[j]] = min(dp[k & d[j]], dp[k] + v[j]);
}
}
ans = min(ans, dp[0]);
}
if (ans == inf) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> dp;
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int main() {
int n;
int l[305];
int c[305];
while (~scanf("%d", &n)) {
map<int, int>::iterator it;
for (int i = 1; i <= n; i++) {
scanf("%d", &l[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
dp.clear();
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (it = dp.begin(); it != dp.end(); it++) {
int t = gcd(l[i], it->first);
if (dp.count(t)) {
dp[t] = min(dp[t], it->second + c[i]);
} else {
dp[t] = it->second + c[i];
}
}
}
if (!dp.count(1)) {
printf("-1\n");
} else {
printf("%d\n", dp[1]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 410;
const int INF = 1 << 30;
int L[MAXN], C[MAXN];
unordered_map<int, int> dp[MAXN];
int gcd(int a, int b) {
int t;
while (b) {
t = a % b;
a = b;
b = t;
}
return a;
}
vector<pair<int, int> > fact(int x) {
vector<pair<int, int> > facts;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
int cc = 0;
while (x % i == 0) {
x /= i;
cc++;
}
facts.push_back(make_pair(i, cc));
}
}
if (x != 1) {
facts.push_back(make_pair(x, 1));
}
return facts;
}
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++) {
dp[i][L[i]] = C[i];
}
for (int i = 0; i < n; i++) {
for (auto it = dp[i].begin(); it != dp[i].end(); ++it) {
if (i + 1 < n) {
int t = gcd(it->first, L[i + 1]);
if (dp[i + 1].count(t) == 0) {
dp[i + 1][t] = INF;
}
dp[i + 1][t] = min(dp[i + 1][t], it->second + C[i + 1]);
}
if (dp[i + 1].count(it->first) == 0) {
dp[i + 1][it->first] = INF;
}
dp[i + 1][it->first] = min(dp[i + 1][it->first], it->second);
}
}
if (dp[n].count(1) == 0) {
printf("-1\n");
} else {
printf("%d\n", dp[n][1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310, inf = 1e9;
int n;
int x[MAXN], y[MAXN];
map<int, int> mapa;
int gcd(int a, int b) {
if (!a) return b;
return gcd(b % a, a);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
for (int i = 0; i < n; i++) scanf("%d", &y[i]);
for (int i = 0; i < n; i++) {
map<int, int>::iterator it;
for (it = mapa.begin(); it != mapa.end(); it++) {
int novi = gcd(it->first, x[i]);
int v = it->second + y[i];
if (mapa[novi] == 0)
mapa[novi] = v;
else
mapa[novi] = min(mapa[novi], v);
}
if (mapa[x[i]] == 0)
mapa[x[i]] = y[i];
else
mapa[x[i]] = min(mapa[x[i]], y[i]);
}
if (mapa[1] == 0)
printf("%d\n", -1);
else
printf("%d\n", mapa[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans;
long long curans;
int l[301];
int c[301];
int corder[301];
int curp, parts;
std::vector<int> p;
std::vector<int> praz;
int mini;
int minF[5000];
bool del[301][11];
int part[20];
const long long mod = 1000000007;
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b) return gcd(b, a % b);
return gcd(a, b % a);
}
void go() {
if (curp == praz.size()) {
std::vector<int> partnum(parts + 1, 0);
int deg2 = 1;
for (int j = 0; j < curp; j++) {
partnum[part[j]] += deg2;
deg2 *= 2;
}
long long curcur = 0;
for (int j = 1; j <= parts; j++) {
curcur += minF[partnum[j]];
}
if (curcur + curans < ans) {
ans = curcur + curans;
}
return;
}
curp++;
for (int i = 1; i <= parts; i++) {
part[curp - 1] = i;
go();
}
parts++;
part[curp - 1] = parts;
go();
parts--;
curp--;
}
int main() {
for (int i = 2; i <= 100000; i++) {
bool f = false;
for (int j = 0; j < p.size(); j++)
if (i % p[j] == 0) {
f = true;
break;
}
if (f) continue;
p.push_back(i);
}
ans = 999999999;
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
vector<pair<int, int>> sr;
for (int i = 0; i < n; i++) sr.push_back(make_pair(c[i], i));
sort(sr.begin(), sr.end());
for (int i = 0; i < n; i++) corder[i] = sr[i].second;
int cur = l[0];
for (int i = 1; i < n; i++) {
cur = gcd(cur, l[i]);
}
if (cur > 1) {
cout << -1;
return 0;
}
for (mini = 0; mini < n; mini++) {
int st = l[mini];
curans = c[mini];
praz.clear();
for (int j = 0; j < p.size(); j++) {
if (st % p[j] == 0) {
praz.push_back(p[j]);
do {
st = st / p[j];
} while (st % p[j] == 0);
}
}
if (st > 1) praz.push_back(st);
int deg2 = 1;
for (int j = 0; j < praz.size(); j++) {
int pp = praz[j];
for (int k = 0; k < n; k++) {
del[k][j] = (l[k] % pp == 0);
}
deg2 *= 2;
}
for (int k = 1; k < deg2; k++) {
int kk = k;
std::vector<int> x;
for (int j = 0; j < praz.size(); j++) {
if (kk % 2 == 1) x.push_back(j);
kk /= 2;
}
int num = x.size();
int minff = 99999999;
for (int i = mini + 1; i < n; i++) {
bool f = true;
for (int j = 0; j < num; j++) {
if (del[i][x[j]]) {
f = false;
break;
}
}
if (f) minff = min(minff, c[i]);
}
minF[k] = minff;
}
curp = 0;
parts = 0;
go();
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int L[305], C[305];
map<int, int> dp;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
while (cin >> n) {
dp.clear();
int i, j;
for (i = 0; i < n; i++) {
cin >> L[i];
}
for (i = 0; i < n; i++) {
cin >> C[i];
}
dp[0] = 0;
for (i = 0; i < n; i++) {
map<int, int>::iterator it = dp.begin();
for (; it != dp.end(); it++) {
int tem = gcd(it->first, L[i]);
if (dp.count(tem))
dp[tem] = min(dp[tem], it->second + C[i]);
else
dp[tem] = it->second + C[i];
}
}
if (dp.count(1))
cout << dp[1] << endl;
else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long INF64 = 1LL * INF * INF;
const long long mod = INF + 7;
int l[310], c[310];
int n;
map<int, int> dp;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> l[i];
for (int i = 0; i < n; ++i) cin >> c[i];
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (auto it : dp) {
int m_gcd = gcd(it.first, l[i]);
if (!dp.count(m_gcd)) dp[m_gcd] = INF;
dp[m_gcd] = min(dp[m_gcd], it.second + c[i]);
}
}
if (!dp.count(1))
cout << -1 << endl;
else
cout << dp[1] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static pair<int, int> pr[200000];
static int res, us[200000], t, n, a, t1;
int gcd(int a, int b) {
++t;
while (b) {
a %= b;
swap(a, b);
}
return a;
}
void gen(int g, int s) {
if (s >= res) return;
if (g == 1) {
res = s;
return;
}
if (t > 1.6e8 || t1 > 0.5e4) return;
++t;
++t1;
for (int i = n - 1; i >= 0; --i) {
a = gcd(pr[i].first, g);
if (a < g) gen(a, s + pr[i].second);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> pr[i].first;
for (int i = 0; i < n; ++i) cin >> pr[i].second;
srand(3437);
random_shuffle(pr, pr + n);
res = (long long)1000000007;
for (int i = 0; i < n; ++i) {
t1 = 0;
gen(pr[i].first, pr[i].second);
}
if (res == (long long)1000000007)
cout << "-1\n";
else
cout << res << endl;
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 main() {
int n;
cin >> n;
int a[305];
long long b[305];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
map<int, long long int> std;
for (int i = 0; i < n; i++) {
if (std.count(a[i])) {
std[a[i]] = min(std[a[i]], b[i]);
} else
std.insert(pair<int, long long int>(a[i], b[i]));
}
for (int i = 1; i < n; i++) {
map<int, long long int>::iterator it;
for (it = std.begin(); it != std.end(); it++) {
int ans = gcd(it->first, a[i]);
if (std.count(ans)) {
std[ans] = min((long long)it->second + b[i], std[ans]);
} else {
std.insert(pair<int, long long int>(ans, (long long)b[i] + it->second));
}
}
}
if (std.count(1))
cout << std[1] << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans = 1000000007;
vector<int> fact[307];
int c[307];
int l[307];
int dp[1 << 10];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> l[i];
int curr = l[i];
for (int j = 2; j * j <= l[i]; ++j) {
if (curr % j == 0) {
while (curr % j == 0) curr /= j;
fact[i].push_back(j);
}
}
if (curr > 1) fact[i].push_back(curr);
}
for (int i = 1; i <= n; ++i) {
cin >> c[i];
}
for (int i = 1; i <= n; ++i) {
memset(dp, 0x3f3f3f3f, sizeof dp);
int d = fact[i].size();
dp[(1 << d) - 1] = c[i];
for (int j = i + 1; j <= n; ++j) {
for (int m = 0; m < (1 << d); ++m) {
int curr = m;
for (int k = 0; k < d; ++k) {
if (l[j] % fact[i][k]) curr &= ~(1 << k);
}
dp[curr] = min(dp[curr], dp[m] + c[j]);
}
}
ans = min(ans, dp[0]);
}
if (ans == 1000000007)
cout << -1;
else
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l[310], c[310];
struct data {
int num, cost;
data(int num_, int cost_) : num(num_), cost(cost_) {}
data() {}
inline bool operator<(const data &x) const { return num < x.num; }
};
set<data> f[310];
int gcd(int x, int y) {
int t;
while (x % y) t = x % y, x = y, y = t;
return y;
}
void update(int x, int num, int cost) {
set<data>::iterator t = f[x].lower_bound(data(num, cost));
if (t->num == num) {
cost = min(cost, t->cost);
f[x].erase(t);
}
f[x].insert(data(num, cost));
}
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]);
f[0].insert(data(1, 1 << 30));
for (int i = 1; i <= n; ++i) {
update(i, l[i], c[i]);
for (set<data>::iterator j = f[i - 1].begin(); j != f[i - 1].end(); ++j)
update(i, j->num, j->cost), update(i, gcd(j->num, l[i]), j->cost + c[i]);
f[i - 1].clear();
}
set<data>::iterator t = f[n].lower_bound(data(1, 0));
if (t->cost < 1 << 30)
printf("%d\n", t->cost);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long a, long long b, long long mod) {
a %= mod;
if (a < 0) a += mod;
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return ans;
}
long long pwr(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
b /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
while (b) {
long long temp = a;
a = b;
b = temp % b;
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long modularInverse(long long a, long long m) {
assert(false);
return pwr(a, m - 2, m);
}
const int mod = 1000000007;
int l[1001];
int c[1001];
map<int, int> DP[301];
int dp(int n, int g) {
if (n == 0) {
if (g == 1)
return 0;
else
return 1e9;
}
if (DP[n].find(g) != DP[n].end()) return DP[n][g];
int o1 = c[n] + dp(n - 1, gcd(g, l[n]));
int o2 = dp(n - 1, g);
return DP[n][g] = min(o1, o2);
}
int main() {
std::ios::sync_with_stdio(false);
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 ans = dp(n, 0);
if (ans >= 1e9) ans = -1;
cout << ans;
}
|
#include <bits/stdc++.h>
size_t gcd(size_t a, size_t b) {
while (a && b) {
size_t rem = a % b;
a = b;
b = rem;
}
return a + b;
}
long solve(std::vector<size_t> const &len, std::vector<size_t> const &cst) {
std::vector<std::map<size_t, size_t> > dt(len.size());
for (size_t i = 0; i != len.size(); ++i) dt[i][len[i]] = cst[i];
for (size_t i = 0; i != len.size() - 1; ++i) {
typename std::map<size_t, size_t>::iterator const end = dt[i].end();
for (typename std::map<size_t, size_t>::iterator it = dt[i].begin();
it != end; ++it) {
typename std::map<size_t, size_t>::iterator jt =
dt[i + 1].find(it->first);
if (jt == dt[i + 1].end() || jt->second > it->second)
dt[i + 1][it->first] = it->second;
size_t const div = gcd(len[i + 1], it->first);
size_t const cost = it->second + cst[i + 1];
jt = dt[i + 1].find(div);
if (jt == dt[i + 1].end() || jt->second > cost) dt[i + 1][div] = cost;
}
}
typename std::map<size_t, size_t>::iterator const it = dt.back().find(1);
return it == dt.back().end() ? -1 : it->second;
}
int main() {
size_t n;
std::cin >> n;
std::vector<size_t> len(n, 0);
std::vector<size_t> cst(n, 0);
for (size_t i = 0; i != n; ++i) std::cin >> len[i];
for (size_t i = 0; i != n; ++i) std::cin >> cst[i];
std::cout << solve(len, cst) << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
long long Rand(long long L, long long R) { return L + rd() % (R - L + 1); }
long long MUL(long long A, long long B, long long MOD) {
long long r = 0;
while (B) {
r = (r + (A * (B % 2) % MOD)) % MOD;
A = (A + A) % MOD;
B /= 2;
}
return r;
}
long long POW(long long A, long long B, long long MOD) {
long long RES = 1;
A %= MOD;
assert(B >= 0);
for (; B; B >>= 1) {
if (B & 1) RES = MUL(RES, A, MOD);
A = MUL(A, A, MOD);
}
return RES;
}
long long GCD(long long A, long long B) { return B == 0 ? A : GCD(B, A % B); }
int dx[] = {0, -1, 0, 1, 0};
int dy[] = {0, 0, 1, 0, -1};
map<int, int> f;
const int MAXN = 305;
int N;
int l[MAXN], c[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
N = ({
int x = 0, n = 0, c = getchar();
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
(n) ? -x : x;
});
for (int i = 1; i <= N; ++i)
l[i] = ({
int x = 0, n = 0, c = getchar();
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
(n) ? -x : x;
});
for (int i = 1; i <= N; ++i)
c[i] = ({
int x = 0, n = 0, c = getchar();
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
(n) ? -x : x;
});
f[0] = 0;
for (int i = 1; i <= N; ++i) {
for (auto u : f) {
int v = GCD(l[i], u.first);
if (f[v] > f[u.first] + c[i] || f[v] == 0) f[v] = f[u.first] + c[i];
}
}
if (f[1] == 0)
cout << -1;
else
cout << f[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int l[305];
int c[305];
map<int, int> mp;
void ini() {
int i;
mp.clear();
for (i = 1; i <= n; i++) {
scanf("%d", &l[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
}
int gcd(int a, int b) {
if (b == 0)
return a;
else {
return gcd(b, a % b);
}
}
void solve() {
int i;
int te;
int cost;
map<int, int>::iterator it;
mp[0] = 0;
for (i = 1; i <= n; i++) {
for (it = mp.begin(); it != mp.end(); it++) {
te = gcd(l[i], it->first);
cost = c[i] + it->second;
if (mp[te] == 0) {
mp[te] = cost;
} else {
mp[te] = min(mp[te], cost);
}
}
}
}
void out() {
if (mp[1] == 0) {
printf("-1\n");
} else {
printf("%d\n", mp[1]);
}
}
int main() {
while (scanf("%d", &n) != EOF) {
ini();
solve();
out();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double eps = 1e-9;
int gcd(int a, int b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> jump(n), cost(n);
for (int& x : jump) cin >> x;
for (int& x : cost) cin >> x;
unordered_map<int, int> dist;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
for (int i = 0; i < n; ++i) {
dist[jump[i]] = cost[i];
pq.push(pair<int, int>(cost[i], jump[i]));
}
int ans = -1;
while (!pq.empty() && ans == -1) {
pair<int, int> u = pq.top();
pq.pop();
int ucost = u.first;
int ujump = u.second;
if (ujump == 1) {
ans = ucost;
} else {
for (int i = 0; i < n; ++i) {
int newjump = gcd(ujump, jump[i]);
int newcost = ucost + cost[i];
auto it = dist.find(newjump);
if (it == dist.end() || newcost < it->second) {
dist[newjump] = newcost;
pq.push(pair<int, int>(newcost, newjump));
}
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int N = 305;
using namespace std;
map<int, int> mp;
int l[N], c[N];
vector<pair<int, int> > f[N];
int gcd(int a, int b) {
int q = a % b;
while (q != 0) {
a = b;
b = q;
q = a % b;
}
return b;
}
int main() {
int n;
scanf("%d", &n);
int i, j, k, t;
for (i = 0; i < n; i++) scanf("%d", &l[i]);
for (i = 0; i < n; i++) scanf("%d", &c[i]);
f[0].push_back(make_pair(l[0], c[0]));
int ans = 100000000;
if (l[0] == 1) ans = c[0];
map<int, int>::iterator it;
for (i = 1; i < n; i++) {
mp.clear();
mp[l[i]] = c[i];
for (j = 0; j < i; j++)
for (k = 0; k < f[j].size(); k++) {
t = gcd(l[i], f[j][k].first);
if (mp.find(t) == mp.end() || mp[t] > c[i] + f[j][k].second)
mp[t] = c[i] + f[j][k].second;
}
for (it = mp.begin(); it != mp.end(); it++) {
f[i].push_back(make_pair(it->first, it->second));
if (it->first == 1) ans = min(ans, it->second);
}
}
if (ans == 100000000)
printf("-1");
else
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MX = 300 + 7;
const int mod = 1e9 + 7;
const int test[12] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long quimod(long long a, long long k, long long p) {
long long res = 1;
while (k) {
if (k & 1) res = (res * a) % p;
a = (a * a) % p;
k >>= 1;
}
return res;
}
long long multi(long long a, long long k, long long p) {
long long res = 0;
while (k) {
if (k & 1) res = (res + a) % p;
a = (a + a) % p;
k >>= 1;
}
return res;
}
int l[MX], c[MX];
map<int, int> dp;
int main() {
int n;
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]);
map<int, int>::iterator it;
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
for (it = dp.begin(); it != dp.end(); ++it) {
int cost = c[i] + it->second;
int g = gcd(l[i], it->first);
if (dp[g] && cost >= dp[g]) continue;
dp[g] = cost;
}
}
int res = dp[1];
if (!res)
printf("-1\n");
else
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1111], b[1111];
const int inf = 1e9;
map<int, int> mp, mp1;
int nsd(int x, int y) {
while (x > 0 && y > 0)
if (x > y)
x %= y;
else
y %= x;
return x + y;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
mp[a[1]] = b[1];
for (int i = 2; i <= n; i++) {
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
int heh = it->first;
int kok = it->second;
if (!mp1[heh] || mp1[heh] > kok) mp1[heh] = kok;
int kek = nsd(a[i], heh);
if (!mp1[kek] || mp1[kek] > kok + b[i]) mp1[kek] = kok + b[i];
}
mp = mp1;
mp1.clear();
if (!mp[a[i]] || mp[a[i]] > b[i]) mp[a[i]] = b[i];
}
if (mp[1] == 0)
cout << -1;
else
cout << mp[1];
}
|
#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 mask[MAXN];
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);
for (int j = 0; j < n; j++) {
mask[j] = 0;
for (int k = 0; k < m; k++) {
if (L[j] % facts[k] != 0) {
mask[j] |= 1 << k;
}
}
}
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 | mask[j];
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 = 303, M = 1 << 10, INF = 1e9 + 7;
int n;
int a[N];
int cost[N];
int mem[N][M];
int color[N][M];
int col = 0;
int mask[N];
int dp(int i, int msk) {
if (i == n) {
return msk == 0 ? 0 : INF;
}
int &ret = mem[i][msk];
if (color[i][msk] == col) return ret;
color[i][msk] = col;
ret = INF;
ret = dp(i + 1, msk);
ret = min(ret, dp(i + 1, msk & mask[i]) + cost[i]);
if (ret >= INF) ret = INF;
return ret;
}
int work(int x, int dx) {
vector<int> primes;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
primes.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) primes.push_back(x);
memset(mask, 0, sizeof mask);
for (int i = 0; i < n; i++) {
for (int j = 0; j < primes.size(); j++)
if (a[i] % primes[j] == 0) mask[i] |= (1 << j);
}
col++;
return dp(0, (1 << (int)primes.size()) - 1) + cost[dx];
}
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", &cost[i]);
}
int ans = INF;
for (int i = 0; i < n; i++) {
ans = min(ans, work(a[i], i));
}
printf("%d\n", ans == INF ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 0x3c3c3c3c;
const long long infl = 0x3c3c3c3c3c3c3c3c;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int N;
int l[303], c[303];
map<pair<int, int>, int> mp;
int go(int pos, int g) {
if (pos == N) return g == 1 ? 0 : inf;
auto cache = mp.find({pos, g});
if (cache != mp.end()) return (*cache).second;
int ret = inf;
ret = min(ret, c[pos] + go(pos + 1, g == -1 ? l[pos] : gcd(g, l[pos])));
ret = min(ret, go(pos + 1, g));
return mp[{pos, g}] = ret;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> N;
for (int i = 0; i < N; i++) cin >> l[i];
for (int i = 0; i < N; i++) cin >> c[i];
int ret = go(0, -1);
if (ret == inf)
cout << -1;
else
cout << ret;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
long long isp[100001], ar[333], cc[333];
vector<int> factor[333], prime;
long long dp[302][1 << 11], n, tt[333][333], p;
long long go(int c, int bp) {
if (c >= n) {
return bp == 0 ? 0 : 1ll << 60;
}
long long &ret = dp[c][bp];
if (ret != -1) return ret;
ret = 0;
ret = go(c + 1, bp);
ret = min(ret, cc[c] + go(c + 1, bp & tt[p][c]));
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b, c, d = -1, e, f = -1, g, h = 0, x, y, z = 0;
for (int i = 2; i <= 100000; i++) {
if (isp[i] == 0) {
for (int j = i * 2; j <= 100000; j += i) isp[j] = 1;
prime.push_back(i);
}
}
cin >> a;
for (int i = (0); i < (a); ++i) {
cin >> ar[i];
b = ar[i];
for (int j = (0); j < (prime.size()); ++j) {
if (b % prime[j] == 0) factor[i].push_back(prime[j]);
while (b % prime[j] == 0) b /= prime[j];
}
if (b > 1) factor[i].push_back(b);
}
for (int i = (0); i < (a); ++i) cin >> cc[i];
for (int i = (0); i < (a); ++i) {
for (int j = (i); j < (a); ++j) {
b = 0;
for (int k = (0); k < (factor[i].size()); ++k) {
for (int l = (0); l < (factor[j].size()); ++l) {
if (factor[i][k] == factor[j][l]) b |= 1ll << k;
}
}
tt[i][j] = b;
}
}
n = a;
f = 1000000007ll * 10000000ll;
for (int i = 0; i < a; i++) {
memset(dp, -1, sizeof dp);
p = i;
f = min(f, go(i, (1ll << factor[i].size()) - 1) + cc[i]);
}
if (f > 1000000000000000ll)
cout << -1 << endl;
else
cout << f << endl;
}
|
#include <bits/stdc++.h>
int v[300], c[300], t[10000000], u[10000000], lista[666019], next[10000000];
inline int gcd(int a, int b) {
int r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
int n, i, k, j, ans, y, x, p;
fscanf(stdin, "%d", &n);
for (i = 0; i < n; i++) {
fscanf(stdin, "%d", &v[i]);
}
for (i = 0; i < n; i++) {
fscanf(stdin, "%d", &c[i]);
}
t[1] = 0;
u[1] = 0;
k = 1;
for (i = 0; i < n; i++) {
y = k;
for (j = 1; j <= k; j++) {
x = gcd(v[i], t[j]);
p = lista[x % 666019];
while ((p) && (t[p] != x)) {
p = next[p];
}
if (p) {
if (u[p] > u[j] + c[i]) {
u[p] = u[j] + c[i];
}
} else {
y++;
u[y] = u[j] + c[i];
t[y] = x;
next[y] = lista[x % 666019];
lista[x % 666019] = y;
}
}
k = y;
}
ans = 1000000000;
for (i = 1; i <= k; i++) {
if ((t[i] == 1) && (ans > u[i])) {
ans = u[i];
}
}
if (ans == 1000000000) {
ans = -1;
}
fprintf(stdout, "%d\n", ans);
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
long int sum;
struct node *left, *right;
struct node* next;
};
struct node* newNode(int data) {
struct node* Node = new (struct node);
Node->data = data;
Node->left = Node->right = Node->next = NULL;
return (Node);
}
long long dist[310];
long long cost[310];
int n;
map<long long, long long> m;
long long gcd_(long long a, long long b) {
if (a < b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
if (a % b == 0) {
return b;
} else {
return gcd_(b, a % b);
}
}
long long findgcd() {
long long gcd = dist[0];
for (int i = 0; i < n; i++) {
gcd = gcd_(max(dist[i], gcd), min(dist[i], gcd));
printf("%I64d\n", gcd);
;
}
return gcd;
}
void solveTestCase() {
scanf("%d", &n);
;
for (int i = 0; i < n; i++) {
scanf("%I64d", &dist[i]);
;
}
for (int i = 0; i < n; i++) {
scanf("%I64d", &cost[i]);
;
}
m[0] = 0;
for (int i = 0; i < n; i++) {
map<long long, long long>::iterator it;
for (it = m.begin(); it != m.end(); it++) {
long long gcd_temp;
if (it->first == 0) {
gcd_temp = dist[i];
} else {
gcd_temp = gcd_(max(dist[i], it->first), min(dist[i], it->first));
}
if (m.find(gcd_temp) != m.end()) {
m[gcd_temp] = min(m[gcd_temp], cost[i] + it->second);
} else {
m[gcd_temp] = cost[i] + it->second;
}
}
}
long long ans;
ans = m.find(1) != m.end() ? m[1] : -1;
printf("%I64d\n", ans);
;
}
int main() {
solveTestCase();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int n, int m) {
if (m > n) swap(n, m);
int tmp;
while (m) {
tmp = n;
n = m;
m = tmp % m;
}
return n;
}
map<int, int> my[2];
int a[500], b[500];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
my[0].clear();
my[1].clear();
int cur = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
}
for (int i = 0; i < n; i++) {
cur ^= 1;
my[cur].clear();
map<int, int>::iterator it;
my[cur][a[i]] = b[i];
for (it = my[cur ^ 1].begin(); it != my[cur ^ 1].end(); it++) {
int num = it->first;
int cost = it->second;
int tem = gcd(num, a[i]);
if (my[cur].count(tem) == 0)
my[cur][tem] = cost + b[i];
else
my[cur][tem] = min(cost + b[i], my[cur][tem]);
tem = num;
if (my[cur].count(tem) == 0)
my[cur][tem] = cost;
else
my[cur][tem] = min(cost, my[cur][tem]);
}
}
if (my[cur].count(1) == 0)
puts("-1");
else
printf("%d\n", my[cur][1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)3e7 + 5;
int jumpp[305], cst[305];
vector<pair<int, int> > vec, vec2;
vector<int> divi;
int dp[305][1025];
int solve() {
if (((int)(vec2.size())) == 0) return inf;
for (int i = 0; i < 305; i++)
for (int j = 0; j < 1025; j++) dp[i][j] = inf;
for (int i = 0; i < ((int)(vec2.size())); i++)
dp[i][vec2[i].second] = vec2[i].first;
for (int i = 0; i < ((int)(vec2.size())); i++)
for (int j = 0; j < 1025; j++) {
dp[i + 1][j & vec2[i + 1].second] =
min(dp[i + 1][j & vec2[i + 1].second], vec2[i + 1].first + dp[i][j]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
int ans = inf;
for (int i = 0; i < ((int)(vec2.size())); i++) ans = min(ans, dp[i][0]);
return ans;
}
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> jumpp[i];
for (int i = 0; i < n; i++) cin >> cst[i];
int ans = inf;
vec.clear();
for (int i = 0; i < n; i++) {
if (jumpp[i] == 1)
ans = min(ans, cst[i]);
else {
vec.push_back(make_pair(cst[i], jumpp[i]));
}
}
sort(vec.begin(), vec.end());
for (int i = 0; i < ((int)(vec.size())); i++) {
divi.clear();
int jmp = vec[i].second;
if (jmp % 2 == 0) {
divi.push_back(2);
while (jmp % 2 == 0) jmp /= 2;
}
for (int j = 3; j * j <= jmp; j += 2) {
if (jmp % j == 0) {
divi.push_back(j);
while (jmp % j == 0) jmp /= j;
}
}
if (jmp > 1) divi.push_back(jmp);
vec2.clear();
for (int j = 0; j < i; j++) {
int mask = 0;
for (int k = 0; k < ((int)(divi.size())); k++) {
if (vec[j].second % divi[k] == 0) mask |= (1 << k);
}
vec2.push_back(make_pair(vec[j].first, mask));
}
ans = min(ans, vec[i].first + solve());
}
if (ans >= inf)
cout << "-1\n";
else
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 350, maxns = 6000000, big = 0x3f3f3f3f;
int n, l[maxn], c[maxn], ans;
int num[maxns], ns;
int f[maxns];
void get(int x) {
int i, lim = sqrt(x);
num[ns++] = x;
for (i = 2; i <= lim; i++)
if (!(x % i)) num[ns++] = i, num[ns++] = x / i;
}
inline int gcd(int u, int v) { return !v ? u : gcd(v, u % v); }
int main() {
int i, j, t;
num[ns++] = 1;
memset(f, big, sizeof(f));
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &l[i]), get(l[i]);
sort(num, num + ns);
ns = unique(num, num + ns) - num;
for (i = 0; i < n; i++) {
scanf("%d", &c[i]);
t = lower_bound(num, num + ns, l[i]) - num;
f[t] = min(f[t], c[i]);
for (j = 0; j < ns; j++)
if (f[j] != big) {
if (num[j] == 143 && i == 4) int ttt = 1;
t = lower_bound(num, num + ns, gcd(num[j], l[i])) - num;
f[t] = min(f[t], f[j] + c[i]);
}
}
ans = (f[0] == big ? -1 : f[0]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Card {
int len;
int cost;
};
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n;
cin >> n;
vector<Card> cards(n);
for (Card &x : cards) cin >> x.len;
for (Card &x : cards) cin >> x.cost;
map<int, int> dp;
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (auto x : dp) {
int g = gcd(x.first, cards[i].len);
if (dp.find(g) != dp.end()) {
dp[g] = min(dp[g], x.second + cards[i].cost);
} else
dp[g] = x.second + cards[i].cost;
}
}
auto aux = dp.find(1);
if (aux == dp.end())
cout << -1 << endl;
else
cout << (*aux).second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int power[10] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
int n, l[310], c[310], ans, tmp, num, line[12];
int dp[550];
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]);
ans = 655333000;
for (int i = 1; i <= n; i++) {
num = 0;
tmp = l[i];
for (int j = 2; j * j <= l[i]; j++)
if (tmp % j == 0) {
line[++num] = j;
while (tmp % j == 0) tmp /= j;
}
if (tmp > 1) line[++num] = tmp;
dp[0] = c[i];
for (int j = 1; j < power[num]; j++) dp[j] = 655333000;
for (int j = 0; j < power[num] - 1; j++) {
for (int k = 1; k <= n; k++) {
int ki = 0;
for (int w = 1; w <= num; w++)
if (l[k] % line[w]) ki |= power[w - 1];
dp[j | ki] =
((dp[j | ki]) < (dp[j] + c[k]) ? (dp[j | ki]) : (dp[j] + c[k]));
}
}
ans = ((ans) < (dp[power[num] - 1]) ? (ans) : (dp[power[num] - 1]));
}
if (ans == 655333000)
printf("-1");
else
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 305;
int n;
int val[MAXN], cost[MAXN];
map<int, int> dp[MAXN];
int gcd(int a, int b) {
if (a > b) swap(a, b);
while (b ^= a ^= b ^= a %= b)
;
return a;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 1; i <= n; i++) cin >> cost[i];
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (map<int, int>::iterator it = dp[i].begin(); it != dp[i].end(); it++) {
int num = it->first;
int score = it->second;
if (dp[i + 1].find(num) == dp[i + 1].end()) {
dp[i + 1][num] = score;
} else
dp[i + 1][num] = min(dp[i + 1][num], score);
int nex = gcd(num, val[i + 1]);
if (dp[i + 1].find(nex) == dp[i + 1].end()) {
dp[i + 1][nex] = score + cost[i + 1];
} else
dp[i + 1][nex] = min(dp[i + 1][nex], score + cost[i + 1]);
}
}
if (dp[n].find(1) == dp[n].end())
cout << -1 << endl;
else
cout << dp[n][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310;
map<int, int> Map;
int l[MAXN], c[MAXN], n;
int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
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]);
for (int i = 1; i <= n; ++i) {
if (Map[l[i]])
Map[l[i]] = min(Map[l[i]], c[i]);
else
Map[l[i]] = c[i];
for (map<int, int>::iterator it = Map.begin(); it != Map.end(); it++) {
int x = gcd(l[i], it->first);
if (Map[x])
Map[x] = min(Map[x], c[i] + it->second);
else
Map[x] = c[i] + it->second;
}
}
if (Map[1])
printf("%d", Map[1]);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 333;
int a[maxn], c[maxn];
vector<int> p[maxn];
int dp[maxn][2 * maxn];
int used[maxn][2 * maxn];
int pr[maxn][maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int x = a[i], j = 2;
while (j * j <= x) {
if (x % j == 0) {
p[i].push_back(j);
while (x % j == 0) x /= j;
}
j++;
}
if (x > 1) p[i].push_back(x);
}
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
for (int l = 0; l < (int)p[i].size(); l++) {
for (int t = 0; t < (int)p[j].size(); t++) {
if (p[i][l] == p[j][t]) {
pr[i][j] |= (1 << l);
break;
}
}
}
}
}
int ans = 2000000000;
for (int i = 1; i <= n; i++) {
used[i][pr[i][i]] = i;
dp[i][pr[i][i]] = c[i];
int m = (int)p[i].size();
for (int j = i; j < n; j++) {
for (int mask = 0; mask < (1 << m); mask++) {
if (used[j][mask] != i) continue;
if (used[j + 1][mask] != i) {
used[j + 1][mask] = i;
dp[j + 1][mask] = dp[j][mask];
} else
dp[j + 1][mask] = min(dp[j + 1][mask], dp[j][mask]);
if (used[j + 1][(mask & pr[i][j + 1])] != i) {
used[j + 1][(mask & pr[i][j + 1])] = i;
dp[j + 1][(mask & pr[i][j + 1])] = dp[j][mask] + c[j + 1];
} else
dp[j + 1][(mask & pr[i][j + 1])] =
min(dp[j + 1][(mask & pr[i][j + 1])], dp[j][mask] + c[j + 1]);
}
}
if (used[n][0] == i) ans = min(ans, dp[n][0]);
}
if (ans == 2000000000) ans = -1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
vector<int> g;
map<int, int> mp;
void add(int v) {
if (!mp[v]) {
mp[v] = g.size() + 1;
g.push_back(v);
}
}
void go(int v) {
for (int i = 1; i * i <= v; ++i) {
if (v % i == 0) {
add(i);
add(v / i);
}
}
}
int get(int v) {
int val = mp[v] - 1;
return val;
}
int a[1005];
int c[1005];
int c1[1000005];
int c2[1000005];
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;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
go(a[i]);
}
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
int M = g.size();
for (int i = 0; i < n + 5; ++i)
for (int j = 0; j < M + 5; ++j) c1[j] = c2[j] = INF;
for (int i = 0; i < n; ++i) {
int cur = get(a[i]);
c2[cur] = min(c1[cur], c[i]);
for (int j = 0; j < M; ++j) {
int cur = gcd(g[j], a[i]);
cur = get(cur);
c2[cur] = min(c2[cur], c1[j] + c[i]);
}
for (int j = 0; j < M; ++j) {
c1[j] = min(c1[j], c2[j]);
c2[j] = INF;
}
}
if (c1[0] == INF) c1[0] = -1;
cout << c1[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void amax(T &a, T b) {
if (a < b) a = b;
}
long long gcd(long long x, long long y) {
while (y) {
x %= y;
swap(x, y);
}
return x;
}
int N, L[333], C[333];
map<int, int> mp;
int main() {
scanf("%d", &N);
for (int i = 0, i_len = (N); i < i_len; ++i) scanf("%d", L + i);
for (int i = 0, i_len = (N); i < i_len; ++i) scanf("%d", C + i);
for (int i = 0, i_len = (N); i < i_len; ++i) {
vector<pair<int, int> > v;
v.push_back(make_pair(L[i], C[i]));
for (__typeof((mp).begin()) e = (mp).begin(), e_end = (mp).end();
e != e_end; ++e) {
v.push_back(make_pair(gcd(L[i], e->first), C[i] + e->second));
}
for (__typeof((v).begin()) e = (v).begin(), e_end = (v).end(); e != e_end;
++e) {
if (mp.count(e->first))
amin(mp[e->first], e->second);
else
mp[e->first] = e->second;
}
}
if (mp.count(1))
printf("%d\n", mp[1]);
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.);
int gcd(int a, int b) {
while (a && b)
if (a > b)
a %= b;
else
b %= a;
return a + b;
}
const int N = 333;
int a[N];
int cost[N];
vector<int> getPrimes(int x) {
vector<int> result;
for (int i = 2; i * i <= x; ++i) {
if (!(x % i)) {
result.push_back(i);
while (!(x % i)) {
x /= i;
}
}
}
if (x > 1) {
if (result.size() == 0 || result.back() != x) result.push_back(x);
}
return result;
}
int getMask(int x, vector<int>& primes) {
int res = 0;
for (int i = 0; i < primes.size(); ++i) {
if (!(x % primes[i])) res += (1 << i);
}
return res;
}
int getValue(int x, vector<int>& primes) {
int res = 1;
for (int i = 0; i < primes.size(); ++i) {
if (x & (1 << i)) res *= primes[i];
}
return res;
}
const int M = 11;
int f[N][1 << M];
int value[1 << M];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> cost[i];
int ans = 1e9;
for (int i = 0; i < n; ++i) {
int x = a[i];
vector<int> b = getPrimes(x);
int m = b.size();
int lim = 1 << m;
for (int msk = 0; msk < lim; ++msk) value[msk] = getValue(msk, b);
memset(f, 63, sizeof(f));
f[i][lim - 1] = cost[i];
for (int j = i; j < n; ++j)
for (int msk = 0; msk < lim; ++msk) {
int nmsk = getMask(gcd(a[j + 1], value[msk]), b);
f[j + 1][nmsk] = min(f[j + 1][nmsk], f[j][msk] + cost[j + 1]);
f[j + 1][msk] = min(f[j + 1][msk], f[j][msk]);
}
ans = min(ans, f[n][0]);
}
if (ans < 1e9) {
cout << ans << endl;
} else {
cout << "-1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 350;
const int INF = (int)1e9;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
int n;
int a[MAXN];
int c[MAXN];
int pn;
int p[MAXN];
int ans;
int dp[MAXN][1 << 15];
int main() {
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]);
ans += c[i];
}
if (n == 1) {
if (a[1] == 1) {
printf("%d\n", c[1]);
} else
puts("-1");
return 0;
}
int g = a[1];
for (int i = 2; i <= n; i++) g = gcd(g, a[i]);
if (g != 1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
int cur = a[i];
if (cur == 1) {
ans = min(ans, c[i]);
continue;
}
pn = 0;
for (int j = 2; j * j <= cur; j++) {
if (cur % j == 0) {
pn++;
p[pn] = j;
while (cur % j == 0) cur /= j;
}
}
if (cur > 1) {
pn++;
p[pn] = cur;
}
for (int j = i; j <= n; j++) {
for (int k = 0; k < (1 << pn); k++) dp[j][k] = INF;
}
dp[i][(1 << pn) - 1] = c[i];
for (int j = i; j <= n; j++) {
if (dp[j][0] < ans) ans = dp[j][0];
int mask = 0;
for (int k = 1; k <= pn; k++)
if ((a[j] % p[k]) == 0) mask |= (1 << (k - 1));
for (int k = 0; k < (1 << pn); k++) {
if (dp[j][k] == INF) continue;
if (j + 1 <= n) {
if (dp[j][k] < dp[j + 1][k]) dp[j + 1][k] = dp[j][k];
int gomask = k & mask;
if (dp[j][k] + c[j] < dp[j + 1][gomask])
dp[j + 1][gomask] = dp[j][k] + c[j];
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300;
const int INF = 1e8;
int n, N;
int cost[maxn + 5];
int l[maxn + 5];
int m[maxn + 5];
int dp[(1 << 21) + 5];
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", &cost[i]);
int ans = INF;
for (int i = 1; i <= n; ++i) {
vector<int> v;
int x = l[i];
for (int j = 2; j * j <= l[i]; ++j) {
if (x % j == 0) {
v.push_back(j);
while (x % j == 0) x /= j;
}
}
if (x != 1) v.push_back(x);
N = v.size();
for (int j = 1; j <= n; ++j) {
m[j] = 0;
for (int k = 0; k <= N - 1; ++k) {
if (l[j] % v[k] != 0) {
m[j] |= (1 << k);
}
}
}
int MAX = (1 << N) - 1;
for (int j = 1; j <= MAX; ++j) dp[j] = INF;
dp[0] = 0;
for (int j = 0; j <= MAX; ++j) {
for (int k = 1; k <= n; ++k) {
dp[j | m[k]] = min(dp[j | m[k]], dp[j] + cost[k]);
}
}
ans = min(ans, dp[MAX] + cost[i]);
}
if (ans == INF)
printf("-1\n");
else
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, now, top, ans;
int l[310], c[310], q[10000000];
map<int, int> f;
int gcd(int a, int b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
scanf("%d", &n);
ans = 99999999;
for (int i = 1; i <= n; ++i) scanf("%d", &l[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
f[0] = 0;
for (int i = 1; i <= n; ++i) {
map<int, int>::iterator it = f.begin();
for (; it != f.end(); ++it) {
now = gcd(l[i], it->first);
q[++top] = now;
if (f[now] != 0) {
f[now] = min(f[now], it->second + c[i]);
} else {
f[now] = it->second + c[i];
}
}
}
if (f[1] != 0) {
printf("%d", f[1]);
} else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
unordered_map<long long, long long> vm;
void reduce(long long val, long long cost) {
unordered_map<long long, long long>::iterator it;
vector<pair<long long, long long> > to_add;
to_add.push_back(make_pair(val, cost));
for (it = vm.begin(); it != vm.end(); ++it) {
to_add.push_back(make_pair(gcd(it->first, val), it->second + cost));
}
for (int i = 0; i < to_add.size(); ++i) {
long long cur = vm[to_add[i].first];
if (cur > 0) {
vm[to_add[i].first] = min(vm[to_add[i].first], to_add[i].second);
} else {
vm[to_add[i].first] = to_add[i].second;
}
}
}
void solveB() {
int n;
cin >> n;
vector<long long> val(n), cost(n);
for (int i = 0; i < n; ++i) {
cin >> val[i];
}
for (int i = 0; i < n; ++i) {
cin >> cost[i];
}
for (int i = 0; i < n; ++i) {
reduce(val[i], cost[i]);
}
long long ans = vm[1];
if (ans == 0) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
int main() {
solveB();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> dp;
int c[333], v[333];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int Min(int x, int y) { return x < y ? x : y; }
int main() {
int n;
while (scanf("%d", &n) != EOF) {
map<int, int>::iterator it;
dp.clear();
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
dp[0] = 0;
for (int i = 1; i <= n; i++)
for (it = dp.begin(); it != dp.end(); it++) {
int t = gcd(v[i], it->first);
if (dp.find(t) == dp.end())
dp[t] = it->second + c[i];
else
dp[t] = Min(dp[t], it->second + c[i]);
}
if (dp.find(1) == dp.end())
printf("-1\n");
else
printf("%d\n", dp[1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[305], c[305], divisor[305], sz = 0;
vector<int> prime;
void primes() {
int lim = sqrtl(1000000000);
for (int i = 2; i <= lim; i++) {
bool flag = true;
for (int j = 2; j < i; j++) {
if (i % j) continue;
flag = false;
break;
}
if (flag) prime.push_back(i);
}
}
void set_d(int val) {
sz = 0;
for (int i = 0; i < prime.size(); i++) {
if (prime[i] * prime[i] > val) break;
bool flag = false;
while (val % prime[i] == 0) {
flag = true;
val /= prime[i];
}
if (flag) divisor[sz++] = prime[i];
}
if (val > 1) divisor[sz++] = val;
}
int create_mask(int val) {
int bit = 1, mask = 0;
for (int i = 0; i < sz; i++) {
if (val % divisor[i] == 0) mask = mask | bit;
bit *= 2;
}
return mask;
}
int solve() {
int ans = 10000000;
for (int cu = 1; cu < n + 1; cu++) {
set_d(a[cu]);
int tot = 1 << sz;
int dp[tot];
for (int j = 0; j < tot; j++) dp[j] = 10000000;
for (int i = 1; i < n + 1; i++) {
int mask = create_mask(a[i]);
dp[mask] = min(dp[mask], c[i]);
for (int tmp = 0; tmp < tot; tmp++)
dp[tmp & mask] = min(dp[tmp & mask], dp[tmp] + c[i]);
}
ans = min(ans, dp[0] + c[cu]);
}
if (ans - 10000000) return ans;
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
primes();
int mnc = 10000000;
cin >> n;
for (int i = 1; i < n + 1; i++) cin >> a[i];
for (int i = 1; i < n + 1; i++) {
cin >> c[i];
if (a[i] == 1) mnc = min(mnc, c[i]);
}
cout << min(solve(), mnc);
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.insert({l[i], c[i]});
else
um[l[i]] = min(um[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;
int N;
int u[303], v[303];
map<int, int> dp;
vector<int> st;
int gcd(int a, int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", &u[i]);
}
for (int i = 0; i < N; ++i) {
scanf("%d", &v[i]);
}
vector<int> tmp;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < st.size(); ++j) {
int g = gcd(u[i], st[j]);
if (dp.count(g)) {
dp[g] = min(dp[g], v[i] + dp[st[j]]);
} else {
tmp.push_back(g);
dp[g] = v[i] + dp[st[j]];
}
}
if (dp.count(u[i])) {
dp[u[i]] = min(dp[u[i]], v[i]);
} else {
tmp.push_back(u[i]);
dp[u[i]] = v[i];
}
while (!tmp.empty()) {
st.push_back(tmp.back());
tmp.pop_back();
}
}
if (dp.count(1)) {
printf("%d\n", dp[1]);
} else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = (int)1e9;
int mark[100000];
int N;
int dp[600];
int val[303], cost[303];
vector<int> primes;
vector<int> factors[303];
int main() {
for (int i = 2; i * i <= 100000; ++i) {
for (int j = 2; i * j <= 100000; ++j) {
mark[i * j] = 1;
}
}
for (int i = 2; i <= 100000; ++i) {
if (mark[i] == 0) primes.push_back(i);
}
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", &val[i]);
bool isprime = true;
for (int k = 0; k < primes.size(); ++k) {
if (val[i] % primes[k]) continue;
isprime = false;
factors[i].push_back(primes[k]);
}
if (isprime && val[i] != 1) factors[i].push_back(val[i]);
}
for (int i = 0; i < N; ++i) {
scanf("%d", &cost[i]);
}
int ans = INF;
for (int k = 0; k < N; ++k) {
for (int i = 0; i < 600; ++i) dp[i] = INF;
dp[(1 << ((int)factors[k].size())) - 1] = cost[k];
for (int i = 0; i < N; ++i) {
if (i == k) continue;
int bm = 0;
for (int j = 0; j < factors[k].size(); ++j) {
for (int jj = 0; jj < factors[i].size(); ++jj) {
if (factors[k][j] == factors[i][jj]) {
bm |= (1 << j);
break;
}
}
}
for (int j = 0; j < (1 << 9); ++j) {
int g = bm & j;
dp[g] = min(dp[g], dp[j] + cost[i]);
}
}
ans = min(ans, dp[0]);
}
if (ans != INF) {
printf("%d\n", ans);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
size_t gcd(size_t a, size_t b) {
while (a && b) {
size_t rem = a % b;
a = b;
b = rem;
}
return a + b;
}
long solve(std::vector<size_t> const &len, std::vector<size_t> const &cst) {
std::map<size_t, size_t> dt;
for (size_t i = 0; i != len.size(); ++i)
if (dt.find(len[i]) == dt.end())
dt[len[i]] = cst[i];
else
dt[len[i]] = std::min(cst[i], dt[len[i]]);
for (size_t i = 0; i != len.size(); ++i) {
typename std::map<size_t, size_t>::iterator const end = dt.end();
for (typename std::map<size_t, size_t>::iterator it = dt.begin(); it != end;
++it) {
size_t const div = gcd(len[i], it->first);
size_t const cost = cst[i] + it->second;
if (dt.find(div) == dt.end())
dt[div] = cost;
else
dt[div] = std::min(dt[div], cost);
}
}
typename std::map<size_t, size_t>::iterator const it = dt.find(1);
return it == dt.end() ? -1 : it->second;
}
int main() {
size_t n;
std::cin >> n;
std::vector<size_t> len(n, 0);
std::vector<size_t> cst(n, 0);
for (size_t i = 0; i != n; ++i) std::cin >> len[i];
for (size_t i = 0; i != n; ++i) std::cin >> cst[i];
std::cout << solve(len, cst) << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nxt() {
int n;
scanf("%d", &n);
return n;
}
int gcd(int a, int b) {
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n = nxt();
int l[n];
int c[n];
for (int i = 0; i < n; ++i) {
l[i] = nxt();
}
for (int i = 0; i < n; ++i) {
c[i] = nxt();
}
map<int, int> cost;
cost[0] = 0;
for (int i = 0; i < n; ++i) {
map<int, int> tmp = cost;
for (pair<int, int> t : cost) {
int q = gcd(t.first, l[i]);
if (tmp.count(q)) {
tmp[q] = min(tmp[q], t.second + c[i]);
} else {
tmp[q] = t.second + c[i];
}
}
cost = tmp;
}
if (cost.count(1)) {
cout << cost[1] << "\n";
} else {
cout << "-1"
<< "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> dp;
long long N;
long long L[300];
long long C[300];
const long long INF = 10000000000000000;
inline long long gcd(long long a, long long b) {
if (a == INF) return b;
if (b == 0)
return a;
else
return gcd(b, a % b);
}
inline long long def(long long x) { return x == 0 ? INF : x; }
int main() {
scanf("%lld", &N);
for (long long i = 0; i < N; i++) scanf("%lld", &L[i]);
for (long long i = 0; i < N; i++) scanf("%lld", &C[i]);
for (long long i = 0; i < N; i++) {
long long adding = L[i];
long long cost = C[i];
dp[adding] = min(def(dp[adding]), cost);
for (auto& p : dp) {
long long current = p.first;
long long currentcost = p.second;
long long nextnum = gcd(current, adding);
dp[nextnum] = min(def(dp[nextnum]), currentcost + cost);
}
for (auto& p : dp) {
("(%lld,%lld)", p.first, p.second);
}
("\n");
}
printf("%lld\n", dp[1] == 0 ? -1 : dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> map1;
long long arr[302];
long long cost[302];
long long dp[301][1 << 9];
int mask[302];
vector<int> factors[302];
long long n, N;
long long min(long long x, long long y) {
if (x <= y)
return x;
else
return y;
}
int solve(int x, int y) {
if (x == n + 1) {
if (y == (1 << factors[N].size()) - 1) {
return 0;
} else {
return 1000000000;
}
}
if (dp[x][y] != -1) {
return dp[x][y];
}
int ret = 1000000000;
ret = min(1000000000, solve(x + 1, y));
ret = min(ret, cost[x] + solve(x + 1, mask[x] | y));
dp[x][y] = ret;
return ret;
}
int main() {
long long i, j, k, l, m, t;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
m = arr[i];
for (j = 2; j * j <= arr[i]; j++) {
if (m % j == 0) {
factors[i].push_back(j);
while (m % j == 0) {
m /= j;
}
}
}
if (m != 1) factors[i].push_back(m);
}
for (i = 1; i <= n; i++) cin >> cost[i];
long long ans = 1000000000LL;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
mask[j] = 0;
for (k = 0; k < factors[i].size(); k++) {
if (arr[j] % factors[i][k] != 0) mask[j] |= (1 << k);
}
}
for (j = 1; j <= n; j++) {
for (k = 0; k <= 1 << factors[i].size(); k++) dp[j][k] = -1;
}
m = cost[i];
N = i;
m += solve(i, 0);
N = factors[i].size();
ans = min(ans, m);
}
if (ans != 1000000000)
cout << ans << endl;
else
cout << "-1\n";
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> dp;
map<int, int>::iterator it;
int num[305];
int cost[305];
int gcd(int a, int b) { return a == 0 ? b : gcd(b % a, a); }
int main() {
int n;
scanf("%d", &n);
bool ans = true;
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++) scanf("%d", &cost[i]);
int tmp = num[1];
for (int i = 2; i <= n && tmp != 1; i++) tmp = gcd(tmp, num[i]);
if (tmp != 1) ans = false;
if (ans) {
for (int i = 1; i <= n; i++) {
int a = num[i];
int b = cost[i];
for (it = dp.begin(); it != dp.end(); it++) {
int c = gcd(a, it->first);
if (dp.find(c) != dp.end())
dp[c] = min(dp[c], it->second + b);
else
dp[c] = it->second + b;
}
if (dp.find(a) != dp.end())
dp[a] = min(dp[a], b);
else
dp[a] = b;
}
printf("%d\n", dp[1]);
} else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 305;
const int Inf = 1000000000;
const int Maxm = 1 << 13;
int n;
int l[Maxn], c[Maxn];
int mask[Maxn];
int dp[Maxm];
int res = Inf;
int Solve(int v) {
vector<int> pr;
int num = l[v];
for (int i = 2; i * i <= num; i++)
if (num % i == 0) {
pr.push_back(i);
while (num % i == 0) num /= i;
}
if (num > 1) pr.push_back(num);
for (int i = 0; i < n; i++)
if (i != v) {
mask[i] = 0;
for (int j = 0; j < pr.size(); j++)
if (l[i] % pr[j]) mask[i] |= 1 << j;
}
dp[0] = 0;
for (int i = 1; i < 1 << pr.size(); i++) dp[i] = Inf;
for (int i = 0; i + 1 < 1 << pr.size(); i++)
for (int j = 0; j < n; j++)
if (j != v) dp[i | mask[j]] = min(dp[i | mask[j]], dp[i] + c[j]);
return dp[(1 << pr.size()) - 1] + c[v];
}
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]);
for (int i = 0; i < n; i++) res = min(res, Solve(i));
printf("%d\n", res < Inf ? res : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(1e9);
const long long INF64 = (long long)(INF) * (long long)(INF);
const long double eps = 1e-2;
const long double PI = (long double)(3.1415926535897932384626433832795);
const int N = 305;
int a[N];
int c[N];
int n, ans = INF;
map<int, int> d[N];
int gcd(int a, int b) { return a == 0 ? b : gcd(b % a, a); }
int main() {
srand(time(NULL));
cin >> n;
vector<pair<int, int> > p(n);
for (int i = 0; i < (int)(n); i++) cin >> p[i].first;
for (int i = 0; i < (int)(n); i++) cin >> p[i].second;
random_shuffle((p).begin(), (p).end());
for (int i = 0; i < (int)(n); i++) a[i] = p[i].first, c[i] = p[i].second;
int pos = 0;
for (int i = 0; i < (int)(n); i++) pos = gcd(pos, a[i]);
if (pos > 1) {
cout << -1;
return 0;
}
d[0][0] = 0;
for (int i = 0; i < (int)(n); i++) {
for (map<int, int>::iterator it = d[i].begin(); it != d[i].end(); it++) {
if (d[i + 1].count(it->first))
d[i + 1][it->first] = min(d[i + 1][it->first], it->second);
else
d[i + 1][it->first] = it->second;
int g = gcd(it->first, a[i]);
if (d[i + 1].count(g))
d[i + 1][g] = min(d[i + 1][g], it->second + c[i]);
else
d[i + 1][g] = it->second + c[i];
}
}
int ans = INF;
for (int i = 0; i < (int)(n + 1); i++)
if (d[i].count(1)) ans = min(ans, d[i][1]);
if (ans > INF / 2)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long mul(long long x, long long y, long long Z) {
long long tmp = x / (long double)Z * y + 1e-3;
return (x * y + Z - tmp * Z) % Z;
}
long long MUL(long long x, long long p, long long Z) {
long long y = 1;
while (p) {
if (p & 1) y = mul(y, x, Z);
x = mul(x, x, Z);
p >>= 1;
}
return y;
}
bool miller_rabin(long long n) {
if (n <= 1) return 0;
if (n == 2) return 1;
if (n % 2 == 0) return 0;
long long p = n - 1;
srand(time(NULL));
int TIMES = 8;
for (int i = 1; i <= TIMES; i++) {
long long x = rand() % (n - 1) + 1;
if (MUL(x, p, n) != 1) return 0;
}
return 1;
}
long long gcd(long long a, long long b) {
if (a < b) {
swap(a, b);
}
while (a % b) {
long long r = a % b;
a = b;
b = r;
}
return b;
}
int a[400], c[400];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
while (cin >> n) {
map<int, int> dp;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
if (dp.find(a[i]) == dp.end())
dp[a[i]] = c[i];
else
dp[a[i]] = min(dp[a[i]], c[i]);
}
map<int, int>::iterator it;
for (int i = 0; i < n; i++) {
for (it = dp.begin(); it != dp.end(); it++) {
long long t = gcd(it->first, a[i]);
if (dp.find(t) == dp.end())
dp[t] = c[i] + it->second;
else
dp[t] = min(dp[t], c[i] + it->second);
}
}
if (dp.find(1) != dp.end())
cout << dp[1] << endl;
else
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int L[310], C[310], n;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
map<int, int> mp[2];
map<int, int>::iterator it;
int now = 1, pre = 0;
void update(int cur, int a, int b) {
if (mp[cur].count(a))
mp[cur][a] = min(mp[cur][a], b);
else
mp[cur][a] = b;
}
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[pre][L[1]] = C[1];
for (int i = 2; i <= n; i++) {
mp[now].clear();
mp[now][L[i]] = C[i];
for (it = mp[pre].begin(); it != mp[pre].end(); it++) {
int a = it->first, b = it->second;
update(now, a, b);
update(now, gcd(a, L[i]), b + C[i]);
}
swap(now, pre);
}
if (mp[pre].count(1))
printf("%d\n", mp[pre][1]);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l[1001], c[1001];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
map<int, int> M;
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]));
for (int(i) = (0); (i) < (n); (i)++) {
vector<pair<int, int> > aux;
aux.push_back(make_pair(l[i], c[i]));
for (map<int, int>::iterator it = M.begin(); it != M.end(); it++) {
aux.push_back(make_pair(gcd(it->first, l[i]), it->second + c[i]));
}
for (int(j) = (0); (j) < (aux.size()); (j)++) {
int caux = M[aux[j].first];
if (caux == 0)
M[aux[j].first] = aux[j].second;
else
M[aux[j].first] = min(caux, aux[j].second);
}
}
if (M[1] == 0) M[1] = -1;
cout << M[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[310];
int c[310];
map<int, int> mp;
int gcd(int a, int b) { return a == 0 ? b : gcd(b % a, a); }
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];
}
mp[0] = 0;
for (int i = 1; i <= n; i++) {
map<int, int> tmp;
map<int, int>::iterator it = mp.begin();
for (; it != mp.end(); it++) {
int cmp = mp[it->first] + c[i];
int pos = gcd(it->first, l[i]);
if (mp.count(pos) == 0 || mp[pos] > cmp) {
if (tmp.count(pos) && tmp[pos] < cmp) continue;
tmp[pos] = cmp;
}
}
it = tmp.begin();
for (; it != tmp.end(); it++) {
mp[it->first] = it->second;
}
}
if (mp[1] != 0) {
cout << mp[1] << endl;
} else {
cout << "-1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000];
long long c[1000];
map<long long, long long> m[301];
long long gcd(long long a, long long b) {
if (a * b > 0)
gcd(b % a, a);
else
return a + b;
}
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> c[i];
m[0][a[0]] = c[0];
m[0][0] = 0;
for (long long i = 1; i <= n; i++)
for (map<long long, long long>::iterator it = m[i - 1].begin();
it != m[i - 1].end(); it++) {
if (!(m[i].count(it->first))) {
m[i][it->first] = m[i - 1][it->first];
} else {
m[i][it->first] = min(m[i][it->first], m[i - 1][it->first]);
}
if (!(m[i].count(gcd(it->first, a[i]))))
m[i][gcd(it->first, a[i])] = m[i - 1][it->first] + c[i];
else
m[i][gcd(it->first, a[i])] = min(m[i - 1][it->first] + c[i],
(long long)m[i][gcd(it->first, a[i])]);
}
if (!(m[n].count(1)))
cout << -1;
else
cout << m[n][1] << endl;
}
|
#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];
L.erase(L.begin() + i);
C.erase(C.begin() + i);
fill(dp[0], dp[0] + (1 << m), INF);
dp[0][0] = 0;
for (int j = 0; j < n - 1; 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][(1 << m) - 1]);
L.insert(L.begin() + i, sl);
C.insert(C.begin() + i, sc);
}
if (ans < INF)
printf("%d\n", ans);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
for (;;) {
if (a == 0) return b;
b %= a;
if (b == 0) return a;
a %= b;
}
}
long long int sz = 0;
bool b[1000000];
int pr[1234567];
void seive() {
for (int i = 2; i <= 1e5; i++) {
if (b[i]) continue;
pr[sz] = i;
sz++;
for (int j = i; j <= 1e5; j += i) {
b[j] = 1;
}
}
}
vector<long long int> v;
void f(long long int c) {
pr[0] = 2;
for (int i = 0; i < sz; i++) {
if (c % pr[i] == 0) {
v.push_back(pr[i]);
}
}
return;
}
map<long long int, long long int> dp[301];
long long int n;
long long int a[1234];
long long int c[1345];
long long int solve(long long int i, long long int ggcd) {
if (i == n) {
if (ggcd == 1) return 0;
return 1e12;
}
if (dp[i].find(ggcd) != dp[i].end()) return dp[i][ggcd];
long long int res = 0;
if (ggcd == 0) {
res = solve(i + 1, ggcd);
res = min(res, solve(i + 1, a[i]) + c[i]);
} else {
res = solve(i + 1, ggcd);
res = min(res, solve(i + 1, gcd(ggcd, a[i])) + c[i]);
}
return dp[i][ggcd] = res;
}
int main() {
ios_base ::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
long long int sol = solve(0, 0);
if (sol == 1e12) {
cout << -1;
} else
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[310], n, cst[310];
int dp[310][1 << 10];
int cc[1 << 10];
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int func(int here, int ch) {
if (here == n) {
if (ch == 0)
return 0;
else
return 1234567890;
}
int &ret = dp[here][ch];
if (ret != -1) return ret;
ret = 1234567890;
ret = min(ret, func(here + 1, ch));
ret = min(ret, func(here + 1, (ch & cc[here])) + cst[here]);
return ret;
}
int p[33000];
vector<int> vt;
int main() {
for (int i = 2; i < 33000; i++) {
if (p[i]) continue;
vt.push_back(i);
for (int y = i + i; y < 33000; y += i) {
p[y] = 1;
}
}
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &cst[i]);
int ch = a[0];
for (int i = 1; i < n; i++) ch = gcd(ch, a[i]);
if (ch != 1) {
puts("-1");
return 0;
}
int dap = 1234567890;
for (int i = 0; i < n; i++) {
vector<int> vt1;
for (int y = 0; y < vt.size(); y++) {
if (a[i] % vt[y] == 0) {
vt1.push_back(vt[y]);
while (a[i] % vt[y] == 0) {
a[i] /= vt[y];
}
}
}
if (a[i] != 1) vt1.push_back(a[i]);
for (int y = i + 1; y < n; y++) {
int xx = 0;
for (int z = 0; z < vt1.size(); z++)
if (a[y] % vt1[z] == 0) xx += (1 << z);
cc[y] = xx;
}
memset(dp, -1, sizeof(dp));
dap = min(dap, func(i + 1, (1 << vt1.size()) - 1) + cst[i]);
}
printf("%d\n", dap);
}
|
#include <bits/stdc++.h>
using namespace std;
int l[305], c[305];
map<int, int> hh;
map<int, int>::iterator it;
int gcd(int x, int y) {
if (x < y) return gcd(y, x);
if (y == 0) return x;
if (x % y == 0) return y;
return gcd(y, x % y);
}
int main() {
int i, j, n, m, num;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &l[i]);
for (i = 1; i <= n; i++) scanf("%d", &c[i]);
hh[0] = 0;
for (i = 1; i <= n; i++) {
for (it = hh.begin(); it != hh.end(); it++) {
int num = gcd(it->first, l[i]);
if (hh[num] == 0)
hh[num] = it->second + c[i];
else
hh[num] = min(hh[num], it->second + c[i]);
}
}
if (hh[1])
printf("%d", hh[1]);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
long long len[1010], cost[1010], dp[500050], g[500050];
map<int, int> ma;
long long gcd(long long a, long long b) { return a % b ? gcd(b, a % b) : b; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld", &len[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &cost[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= cnt; j++) {
int t = gcd(len[i], g[j]);
if (!ma[t]) {
g[++cnt] = t;
ma[t] = cnt;
dp[cnt] = dp[j] + cost[i];
} else {
dp[ma[t]] = min(dp[ma[t]], dp[j] + cost[i]);
}
}
if (!ma[len[i]]) {
g[++cnt] = len[i];
ma[len[i]] = cnt;
dp[cnt] = cost[i];
} else {
dp[ma[len[i]]] = min(dp[ma[len[i]]], cost[i]);
}
}
if (ma[1] == 0)
printf("-1\n");
else
printf("%d\n", dp[ma[1]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int inf = 1e9;
int n;
int a[333], b[333];
int f[333][33333];
int main() {
read(n);
for (int i = 0; i < n; i++) read(a[i]);
for (int i = 0; i < n; i++) read(b[i]);
vector<int> divs;
for (int i = 0; i < n; i++) {
for (int j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
divs.push_back(j);
if (j * j < a[i]) {
divs.push_back(a[i] / j);
}
}
}
}
sort(divs.begin(), divs.end());
divs.resize(unique(divs.begin(), divs.end()) - divs.begin());
int sz = divs.size();
for (int i = 0; i <= n; i++) {
for (int j = 0; j < sz; j++) {
f[i][j] = inf;
}
}
for (int i = 0; i < n; i++) {
f[i][lower_bound(divs.begin(), divs.end(), a[i]) - divs.begin()] = b[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < sz; j++) {
if (f[i][j] == inf) {
continue;
}
if (f[i][j] < f[i + 1][j]) {
f[i + 1][j] = f[i][j];
}
int u = gcd(divs[j], a[i]);
int pos = lower_bound(divs.begin(), divs.end(), u) - divs.begin();
if (f[i][j] + b[i] < f[i + 1][pos]) {
f[i + 1][pos] = f[i][j] + b[i];
}
}
}
printf("%d\n", (f[n][0] == inf ? -1 : f[n][0]));
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int inf = 1e9;
int n, l[maxn], c[maxn], ans, cnt, pri[maxn], lst, cur, p[maxn], st[maxn],
f[maxn];
bool tf[maxn];
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);
for (int i = 2; i <= 100000; i++) {
if (!tf[i]) pri[++cnt] = i;
for (int j = 1; j <= cnt && i * pri[j] <= 100000; j++) {
tf[i * pri[j]] = true;
if (i % pri[j] == 0) break;
}
}
ans = inf;
for (int i = 1; i <= n; i++) {
lst = l[i];
cur = 0;
for (int j = 1; j <= cnt && pri[j] * pri[j] <= lst; j++)
if (lst % pri[j] == 0) {
p[++cur] = pri[j];
while (lst % pri[j] == 0) lst /= pri[j];
}
if (lst != 1) p[++cur] = lst;
for (int j = 1; j <= n; j++) {
st[j] = 0;
for (int k = 1; k <= cur; k++)
if (l[j] % p[k] == 0) st[j] |= (1 << (k - 1));
}
for (int i = 0; i < (1 << 10); i++) f[i] = inf;
f[(1 << cur) - 1] = c[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j < (1 << cur); j++)
f[st[i] & j] = min(f[st[i] & j], f[j] + c[i]);
ans = min(ans, f[0]);
}
if (ans >= inf)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[350], c[350];
int a[1000];
map<int, int> dp;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
map<int, int>::iterator it;
for (int i = 1; i <= n; i++) cin >> l[i];
for (int i = 1; i <= n; i++) cin >> c[i];
dp.clear();
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (it = dp.begin(); it != dp.end(); it++) {
int t = gcd(l[i], it->first);
if (dp.count(t))
dp[t] = min(dp[t], it->second + c[i]);
else
dp[t] = it->second + c[i];
}
}
if (!dp.count(1))
cout << "-1" << endl;
else
cout << dp[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 310;
const int maxL = 1000;
const int INF = 1e9;
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int n;
int l[maxN], c[maxN];
map<int, int> dp[maxN];
int main() {
cin >> n;
int g = 0;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
dp[0][0] = 0;
int currD = 0, currd = 0;
for (int i = 0; i < n; i++) {
for (map<int, int>::iterator d = dp[i].begin(); d != dp[i].end(); ++d) {
currD = gcd(d->first, l[i]);
currd = d->first;
if (dp[i + 1].find(currD) == dp[i + 1].end()) dp[i + 1][currD] = INF;
if (dp[i + 1].find(currd) == dp[i + 1].end()) dp[i + 1][currd] = INF;
dp[i + 1][currD] = min(dp[i + 1][currD], d->second + c[i]);
dp[i + 1][currd] = min(dp[i + 1][currd], d->second);
}
}
if (dp[n].find(1) == dp[n].end())
cout << "-1";
else
cout << dp[n][1];
return 0;
}
|
#include <bits/stdc++.h>
int l[305], c[305];
std::map<int, int> dp;
inline int gcd(int a, int b) {
while (a ^= b ^= a ^= b %= a)
;
return b;
}
int main(int argc, char** argv) {
int n;
std::scanf("%d", &n);
for (int i = 0; i < n; ++i) {
std::scanf("%d", l + i);
}
for (int i = 0; i < n; ++i) {
std::scanf("%d", c + i);
}
for (int i = 0; i < n; ++i) {
dp[l[i]] = std::min(dp[l[i]], c[i]);
for (auto j : dp) {
int g = gcd(l[i], j.first);
dp[g] = std::min(dp[g] ? dp[g] : 0x3f3f3f3f, j.second + c[i]);
}
}
std::printf("%d", dp[1] ? dp[1] : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
long long nod(long long a, long long b) {
if (b == 0) return a;
return nod(b, a % b);
}
long long a[310];
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) {
long long q;
cin >> q;
if (mp.find(a[i]) == mp.end())
mp[a[i]] = q;
else
mp[a[i]] = min(mp[a[i]], q);
}
for (long long i = 1; i <= n; i++) {
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it) {
long long qw = (*it).first;
qw = nod(qw, a[i]);
if (mp.find(qw) == mp.end())
mp[qw] = mp[a[i]] + (*it).second;
else
mp[qw] = min(mp[qw], mp[a[i]] + (*it).second);
}
}
if (mp.find(1) == mp.end())
cout << -1;
else
cout << mp[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long ret = 0, f = 1;
char x = getchar();
while (!(x >= '0' && x <= '9')) {
if (x == '-') f = -1;
x = getchar();
}
while (x >= '0' && x <= '9') ret = ret * 10 + x - '0', x = getchar();
return ret * f;
}
char get_char() {
char x = getchar();
while (!((x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z'))) x = getchar();
return x;
}
const int L_N = 300 + 10;
const int INF = 1e9 + 10;
int Len[L_N], Cost[L_N], N;
int f[L_N][1 << 11];
int have[L_N], ps[L_N], pn;
void fenjie(int n) {
memset(ps, 0, sizeof(ps)), pn = 0;
int m = sqrt(n) + 5;
for (int i = (2); i <= (m); i++) {
if (n == 1) break;
if (n % i == 0) {
ps[++pn] = i;
while (n % i == 0) n /= i;
}
}
if (n > 1) ps[++pn] = n;
}
void cal_have() {
for (int i = (1); i <= (N); i++) {
have[i] = 0;
int n = Len[i];
for (int j = (1); j <= (pn); j++) {
if (n % ps[j] != 0) have[i] |= 1 << (j - 1);
}
}
}
int main() {
N = read();
for (int i = (1); i <= (N); i++) Len[i] = read();
for (int i = (1); i <= (N); i++) Cost[i] = read();
int ans = INF;
for (int k = (1); k <= (N); k++) {
fenjie(Len[k]);
cal_have();
for (int i = (0); i <= (N); i++)
for (int j = (0); j <= (1 << pn); j++) f[i][j] = INF;
f[0][0] = Cost[k];
for (int i = (0); i <= (N - 1); i++)
for (int j = (0); j <= (1 << pn); j++) {
if (f[i][j] >= INF) continue;
int ts = j | have[i + 1];
f[i + 1][j] = min(f[i + 1][j], f[i][j]);
f[i + 1][ts] = min(f[i + 1][ts], f[i][j] + Cost[i + 1]);
}
ans = min(ans, f[N][(1 << pn) - 1]);
}
if (ans >= INF) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, long long>, long long> dp;
long long nums[512];
long long costs[512];
int n;
long long gcd(long long a, long long b) { return a ? (gcd(b % a, a)) : b; }
long long calcdp(int i, long long d) {
if (dp.count(make_pair(i, d))) return dp[make_pair(i, d)];
dp[make_pair(i, d)] = 1000000000000LL;
long long &ans = dp[make_pair(i, d)];
if (i == n) {
if (d == 1) {
ans = 0;
}
return ans;
}
ans = min(ans, calcdp(i + 1, d));
ans = min(ans, calcdp(i + 1, gcd(d, nums[i])) + costs[i]);
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < (int)(n); ++i) cin >> nums[i];
for (int i = 0; i < (int)(n); ++i) cin >> costs[i];
long long ans = calcdp(0, 0);
if (ans < 1000000000000LL)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e4 + 9;
bool mark[maxn];
int pn;
int pri[maxn];
void ini() {
int a, b, c, d, e, f, g, h;
for (a = 2; a <= 4e4; a++) {
if (mark[a]) continue;
pri[pn++] = a;
for (d = a; d <= 4e4; d += a) {
mark[d] = 1;
}
}
}
int arr[1111];
int cost[1111];
int yin[111];
int num;
void sol(int a) {
num = 0;
for (int i = 0; i < pn && a > 1; i++) {
if (a % pri[i] == 0) {
yin[num++] = pri[i];
}
while (a % pri[i] == 0) {
a /= pri[i];
}
}
if (a > 1) yin[num++] = a;
}
int dp[11111];
int main() {
int a, b, c, d, e, f, g, h;
ini();
scanf("%d", &a);
for (int d = 1; d <= a; d++) {
scanf("%d", &arr[d]);
}
for (int d = 1; d <= a; d++) {
scanf("%d", &cost[d]);
}
g = 1e9;
for (d = 1; d <= a; d++) {
sol(arr[d]);
for (e = 0; e < (1 << num); e++) {
dp[e] = 1e9;
}
dp[(1 << num) - 1] = cost[d];
for (e = d + 1; e <= a; e++) {
h = 0;
for (int i = 0; i < num; i++) {
if (arr[e] % yin[i] == 0) {
h += (1 << i);
}
}
for (int i = (1 << num) - 1; i > -1; i--) {
dp[i & h] = min(dp[i & h], dp[i] + cost[e]);
}
}
g = min(g, dp[0]);
}
if (g == 1e9) {
printf("-1\n");
} else
printf("%d\n", g);
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 main() {
int n, l[305], c[305];
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i];
for (int i = 1; i <= n; i++) cin >> c[i];
map<int, int> d, old_d;
old_d[l[1]] = c[1];
d = old_d;
for (int i = 2; i <= n; i++) {
d = old_d;
if (d.find(l[i]) == d.end())
d[l[i]] = c[i];
else if (c[i] < d[l[i]])
d[l[i]] = c[i];
for (auto x = old_d.begin(); x != old_d.end(); x++) {
int g = (*x).first, v = (*x).second;
int ng = gcd(g, l[i]), nv = v + c[i];
if (d.find(ng) == d.end())
d[ng] = nv;
else if (nv < d[ng])
d[ng] = nv;
}
old_d = d;
}
if (d.find(1) == d.end())
cout << -1 << endl;
else
cout << d[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
inline int read() {
int a = 0, q = 0;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') q = 1, ch = getchar();
while (ch >= '0' && ch <= '9')
a = (a << 3) + (a << 1) + ch - 48, ch = getchar();
return q ? -a : a;
}
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int N = 1000;
int num[N], mon[N], n, temp;
int main() {
while (~scanf("%d", &n)) {
for (register int i = 1; i <= n; ++i) num[i] = read();
for (register int i = 1; i <= n; ++i) mon[i] = read();
m.clear();
map<int, int>::iterator it;
m[0] = 0;
for (register int i = 1; i <= n; ++i) {
for (it = m.begin(); it != m.end(); ++it) {
temp = gcd(num[i], it->first);
int temp1 = it->second + mon[i];
if (m[temp] && m[temp] < temp1) continue;
m[temp] = temp1;
}
}
if (!m[1])
printf("-1\n");
else
printf("%d\n", m[1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int>> arr(310);
map<long long, long long> mm;
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b, a % b);
}
void build() {
mm[0] = 0;
long long temp;
map<long long, long long>::iterator it;
for (int i = 0; i < n; i++) {
for (it = mm.begin(); it != mm.end(); it++) {
temp = gcd(arr[i].first, (*it).first);
if (mm.find(temp) != mm.end())
mm[temp] = min(mm[temp], arr[i].second + (*it).second);
else
mm[temp] = arr[i].second + (*it).second;
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i].first;
for (int i = 0; i < n; i++) cin >> arr[i].second;
build();
if (mm.find(1) == mm.end()) {
cout << "-1";
return 0;
}
cout << mm[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 309, INF = (1 << 30);
int n, arr[MX], cost[MX];
map<int, int> dp[MX];
int gcd(int x, int y) {
if (x % y == 0) return y;
return gcd(y, x % y);
}
int calc(int x, int y) {
if (dp[x].count(y)) return dp[x][y];
int &ret = dp[x][y];
ret = INF;
if (y == 1) {
ret = 0;
return ret;
}
for (int j = x + 1; j <= n; j++)
ret = min(ret, calc(j, gcd(max(arr[j], y), min(arr[j], y))) + cost[j]);
return ret;
}
int main() {
cin >> n;
for (int j = 1; j <= n; j++) cin >> arr[j];
for (int j = 1; j <= n; j++) cin >> cost[j];
int ans = INF;
for (int j = 1; j <= n; j++) ans = min(ans, calc(j, arr[j]) + cost[j]);
if (ans == INF)
cout << -1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
struct Card {
int len, cost;
};
const bool debug = 0;
const int INF = (int)1e9 + 7;
int solve(const std::vector<Card>& cards) {
if (debug) {
std::cout << std::string(80, '-') << std::endl;
for (auto& it : cards) {
std::cout << it.len << ' ' << it.cost << std::endl;
}
}
const int n = (int)cards.size();
int answ = INF, leadingBit[512] = {};
for (int mask = 1; mask < 512; ++mask) {
for (int bit = 0; bit < 9; ++bit) {
if ((mask >> bit) & 1) {
leadingBit[mask] = bit;
}
}
}
for (int i = 0; i < n; ++i) {
int primes[9], size = 0;
{
int number = cards[i].len;
for (int j = 2; j * j <= number; ++j) {
if (number % j == 0) {
primes[size++] = j;
while (number % j == 0) {
number /= j;
}
}
}
if (number > 1) {
primes[size++] = number;
}
assert(size <= 9);
}
if (debug) {
std::cout << std::string(80, '-') << std::endl;
std::cout << "base card is {" << cards[i].len << ", " << cards[i].cost
<< "}" << std::endl;
std::cout << "size = " << size << ", primes:";
for (int j = size - 1; j >= 0; --j) {
std::cout << " " << primes[j];
}
std::cout << std::endl;
}
std::vector<int> curr(1 << size, INF), next;
curr.back() = cards[i].cost;
next = curr;
int gcd[512];
for (int j = 0; j < n; ++j) {
if (j == i) continue;
std::fill(gcd, gcd + (1 << size), 0);
int a = cards[j].len, c = cards[j].cost;
if (debug) {
std::cout << "try to add card {" << a << ", " << c << "}" << std::endl;
}
for (int mask = 1; mask < (1 << size); ++mask) {
int b = leadingBit[mask];
int p = primes[b];
int from = mask ^ (1 << b);
int to = gcd[mask] = (a % p == 0 ? (gcd[from] | (1 << b)) : gcd[from]);
next[to] = std::min(next[to], curr[mask] + c);
if (debug) {
std::cout << std::endl;
std::cout << "\tfrom = " << std::bitset<9>(from).to_string()
<< ", gcd = " << std::bitset<9>(gcd[from]).to_string()
<< std::endl;
std::cout << "\tmask = " << std::bitset<9>(mask).to_string()
<< ", gcd = " << std::bitset<9>(gcd[mask]).to_string()
<< std::endl;
std::cout << "\t to = " << std::bitset<9>(to).to_string()
<< ", gcd = " << std::bitset<9>(gcd[to]).to_string()
<< std::endl;
std::cout << std::endl;
}
}
curr = next;
}
answ = std::min(answ, curr[0]);
}
return answ == INF ? -1 : answ;
}
int main() {
int n;
while (std::cin >> n) {
std::vector<Card> cards(n);
for (auto& it : cards) {
std::cin >> it.len;
}
for (auto& it : cards) {
std::cin >> it.cost;
}
std::cout << solve(cards) << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[10101010];
long long a[101010], b[101010];
vector<int> d;
set<long long> s;
int m;
void f(int x) {
for (long long i = 1; i * i <= x; ++i)
if (x % i == 0) {
s.insert(i);
s.insert(x / i);
}
s.insert(x);
}
int bp(long long x) {
int l = 0, r = m - 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (d[mid] < x)
l = mid;
else
r = mid;
}
if (d[l] == x)
return l;
else
return r;
}
int f_gcd(long long a, long long b) {
if (a < b) swap(a, b);
while (a && b) {
a %= b;
swap(a, b);
}
return a + b;
}
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
f(a[i]);
}
for (set<long long>::iterator it = s.begin(); it != s.end(); ++it)
d.push_back(*it);
m = d.size();
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < m; ++i) dp[i] = 2e18;
for (int i = 0; i < n; ++i) {
int pos = bp(a[i]);
dp[pos] = min(dp[pos], b[i]);
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int gcd = f_gcd(a[i], d[j]);
int pos = bp(gcd);
dp[pos] = min(dp[pos], dp[j] + b[i]);
}
if (dp[0] == 2e18)
cout << -1;
else
cout << dp[0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sigma_size = 26;
const int N = 100 + 50;
const int MAXN = 300 + 50;
const int inf = 0x3fffffff;
const double eps = 1e-8;
const int mod = 100000000 + 7;
int n;
int a[MAXN], c[MAXN];
map<int, int> mp;
vector<int> vec;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
while (~scanf("%d", &n)) {
mp.clear();
vec.clear();
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
int res = a[1];
for (int i = 2; i <= n; i++) res = gcd(res, a[i]);
if (res != 1) {
printf("-1\n");
continue;
}
for (int i = 1; i <= n; i++) {
if (mp[a[i]] == 0) {
mp[a[i]] = c[i];
vec.push_back(a[i]);
} else if (mp[a[i]] > c[i])
mp[a[i]] = c[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < vec.size(); j++) {
int tmp = gcd(a[i], vec[j]);
if (mp[tmp] == 0) {
vec.push_back(tmp);
mp[tmp] = mp[vec[j]] + mp[a[i]];
} else if (mp[tmp] > mp[vec[j]] + mp[a[i]])
mp[tmp] = mp[vec[j]] + mp[a[i]];
}
}
printf("%d\n", mp[1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l[310], c[310], m, t, rec[20], p[310], ans;
int f[310][1200];
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]);
ans = 1000000000;
for (int i = 1; i <= n; i++) {
memset(f, 255, sizeof(f));
t = l[i];
m = 0;
for (int j = 2; j * j <= t; j++)
if (t % j == 0) {
m++;
rec[m] = j;
while (t % j == 0) t /= j;
}
if (t != 1) {
m++;
rec[m] = t;
}
memset(p, 0, sizeof(p));
for (int j = 1; j <= n; j++) {
t = 1;
for (int k = 1; k <= m; k++) {
if (l[j] % rec[k] == 0) p[j] |= t;
t <<= 1;
}
}
f[0][p[i]] = 0;
for (int j = 0; j < n; j++) {
for (int k = 0; k <= p[i]; k++) f[j + 1][k] = f[j][k];
for (int k = 0; k <= p[i]; k++)
if (f[j][k] != -1) {
if (j + 1 != i) {
if (f[j + 1][k & p[j + 1]] == -1)
f[j + 1][k & p[j + 1]] = f[j][k] + c[j + 1];
else
f[j + 1][k & p[j + 1]] =
min(f[j][k] + c[j + 1], f[j + 1][k & p[j + 1]]);
} else {
if (f[j + 1][k & p[j + 1]] == -1)
f[j + 1][k & p[j + 1]] = f[j][k];
else
f[j + 1][k & p[j + 1]] = min(f[j][k], f[j + 1][k & p[j + 1]]);
}
}
}
for (int j = 0; j <= n; j++)
if (f[j][0] != -1) ans = min(f[j][0] + c[i], ans);
}
if (ans != 1000000000)
printf("%d\n", ans);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int l[300];
int c[300];
bool divs[35100];
int primec;
int primes[10000];
int tegc[300];
int teg[300][11];
int arr[1 << 11];
unsigned int jag[300];
int main() {
cout << fixed << setprecision(10);
for (int j = 2; j < 35000; ++j) {
if (!divs[j]) {
primes[primec++] = j;
int k = j;
while (k < 35000) {
divs[k] = true;
k += j;
}
}
}
cin >> n;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
cin >> l[i];
int k = l[i], m = 0;
for (int(j) = 0; (j) < (int)(primec); ++(j)) {
if (!(k % primes[j])) {
teg[i][m++] = primes[j];
while (!(k % primes[j])) {
k /= primes[j];
}
}
}
if (k > 1) {
teg[i][m++] = k;
}
tegc[i] = m;
}
for (int(i) = 0; (i) < (int)(n); ++(i)) {
cin >> c[i];
}
int best = INT_MAX;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
fill_n(jag, n, 0);
for (int(j) = 0; (j) < (int)(n); ++(j)) {
for (int(k) = 0; (k) < (int)(tegc[i]); ++(k)) {
if (l[j] % teg[i][k]) {
jag[j] |= 1 << k;
}
}
}
fill_n(arr, 1 << tegc[i], INT_MAX / 2);
arr[0] = 0;
for (int(j) = 0; (j) < (int)(1 << tegc[i]); ++(j)) {
for (int(k) = 0; (k) < (int)(n); ++(k)) {
arr[j | jag[k]] = min(arr[j | jag[k]], arr[j] + c[k]);
}
}
best = min((arr[(1 << tegc[i]) - 1]) + c[i], best);
}
if (best > (INT_MAX / 2 - 100))
cout << -1;
else
cout << best;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void smain();
int main() {
ios_base::sync_with_stdio(false);
smain();
return 0;
}
map<long long, long long> m;
set<pair<long long, long long> > que;
void add(long long n, long long c) {
if (m.count(n) > 0) {
long long p = m[n];
if (p <= c) return;
que.erase(que.find(make_pair(p, n)));
}
m[n] = c;
que.insert(make_pair(c, n));
}
long long gcd(long long a, long long b) {
while (a && b) {
if (b > a) swap(a, b);
a = a % b;
}
return a + b;
}
void smain() {
long long n;
cin >> n;
vector<long long> l(n), c(n);
for (long long i = 0; i < n; i++) {
cin >> l[i];
}
for (long long i = 0; i < n; i++) {
cin >> c[i];
add(l[i], c[i]);
}
long long nn, cc;
while (!que.empty()) {
cc = que.begin()->first;
nn = que.begin()->second;
que.erase(que.begin());
for (long long i = 0; i < n; i++) {
add(gcd(nn, l[i]), cc + c[i]);
}
}
if (m.count(1) == 0) {
cout << "-1";
} else
cout << m[1];
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int main() {
int n;
cin >> n;
map<int, int> m;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; ++i) cin >> a[i].first;
for (int i = 0; i < n; ++i) cin >> a[i].second;
for (int i = 0; i < n; ++i) {
int l = a[i].first;
int c = a[i].second;
vector<pair<int, int> > v;
for (auto it = m.begin(); it != m.end(); ++it)
v.push_back(make_pair(gcd(it->first, l), it->second + c));
v.push_back(make_pair(l, c));
for (int i = 0; i < v.size(); ++i)
if (m[v[i].first])
m[v[i].first] = min(m[v[i].first], v[i].second);
else
m[v[i].first] = v[i].second;
}
if (m[1] == 0) {
cout << -1 << endl;
return 0;
}
cout << m[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> p;
int q[310][2] = {
0,
};
void ins(int x, int y) {
int r = p[x];
if (r == 0 || y < r) p[x] = y;
}
int gcd(int x, int y) {
for (;;) {
int t = x % y;
if (t == 0) break;
x = y;
y = t;
}
return y;
}
int main() {
int n;
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) scanf("%d", &q[i][0]);
for (i = 0; i < n; i++) scanf("%d", &q[i][1]);
for (i = 0; i < n; i++) {
ins(q[i][0], q[i][1]);
map<int, int>::iterator it;
for (it = p.begin(); it != p.end(); ++it) {
int v0 = gcd(it->first, q[i][0]);
int v1 = (it->second) + q[i][1];
ins(v0, v1);
}
}
if (p[1] != 0)
printf("%d\n", p[1]);
else
puts("-1");
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;
const int maxn = 300, maxc = 1e5;
int n, l[maxn + 5], c[maxn + 5];
map<int, bool> vis;
map<int, long long> f;
priority_queue<pair<long long, int> > q;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int dread() {
int x = 0;
bool f = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) f ^= (ch == '-');
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + (ch ^ 48);
return f ? -x : x;
}
inline void Kaslana() {
n = dread();
for (int i = 1; i <= n; ++i) l[i] = dread();
for (int i = 1; i <= n; ++i) c[i] = dread();
}
inline void Raiden() {
for (int i = 1; i <= n; ++i) q.push(make_pair(f[0] = 0, 0));
for (int x; !q.empty();) {
x = q.top().second, q.pop();
if (vis.find(x) == vis.end())
vis[x] = 1;
else
continue;
if (x == 1) return;
for (int i = 1; i <= n; ++i) {
int y = gcd(l[i], x);
if (f.find(y) == f.end() || f[y] > f[x] + c[i]) {
f[y] = f[x] + c[i];
q.push(make_pair(-f[y], y));
}
}
}
}
inline void Zaychik() {
if (vis.find(1) == vis.end())
puts("-1");
else
printf("%lld\n", f[1]);
}
signed main() {
Kaslana(), Raiden(), Zaychik();
return 0;
}
|
#include <bits/stdc++.h>
int gcd(int a, int b) {
while (b != 0) {
auto tmp = b;
b = a % b;
a = tmp;
}
return a;
}
int set_gcd(std::set<int> const& s) {
auto ret = 0;
for (auto number : s) ret = gcd(ret, number);
return ret;
}
typedef std::priority_queue<std::tuple<int, int, std::set<int>>,
std::vector<std::tuple<int, int, std::set<int>>>,
std::greater<std::tuple<int, int, std::set<int>>>>
min_heap;
int solve(std::map<int, int> const& cards_costs) {
min_heap heap;
std::set<int> card_set;
int cost, gcd;
heap.push(std::tuple<int, int, std::set<int>>());
std::map<int, int> memo;
while (!heap.empty()) {
std::tie(cost, gcd, card_set) = heap.top();
heap.pop();
if (gcd == 1) return cost;
for (auto card_cost : cards_costs) {
if (!card_set.count(card_cost.first)) {
auto s = card_set;
s.insert(card_cost.first);
auto c = cost + card_cost.second;
gcd = set_gcd(s);
if (memo.find(gcd) == memo.end() || memo[gcd] > c) {
memo[gcd] = c;
heap.push(std::tuple<int, int, std::set<int>>(c, gcd, s));
}
}
}
}
return -1;
}
int main(int argc, char* argv[]) {
std::map<int, int> cards_costs;
std::vector<int> cards, costs;
auto size = 0;
std::cin >> size;
for (int i = 0; i < size; ++i) {
int tmp;
std::cin >> tmp;
cards.push_back(tmp);
}
for (int i = 0; i < size; ++i) {
int tmp;
std::cin >> tmp;
costs.push_back(tmp);
}
for (size_t i = 0; i < cards.size(); ++i)
if (cards_costs.find(cards[i]) == cards_costs.end() ||
cards_costs[cards[i]] > costs[i])
cards_costs[cards[i]] = costs[i];
std::cout << solve(cards_costs) << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 100000000007;
vector<long long> v;
int n;
long long dp[302][1025];
long long arr[301], cost[301];
void foo(int ind, int x) {
if (ind > n) return;
unsigned int num = 0;
for (int i = 0; i < v.size(); i++) {
if (arr[ind] % v[i] == 0)
num = num << 1 | 1;
else
num = num << 1;
}
int m = 1 << v.size();
for (int i = 0; i < m; i++)
dp[ind + 1][i] =
min(dp[ind][i], dp[ind][(i | (num ^ (m - 1)))] + cost[ind]);
foo(ind + 1, x);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) cin >> cost[i];
for (int i = 0; i < n; i++) {
v.clear();
int y = arr[i];
for (int j = 2; j * j <= arr[i]; j++) {
if (y % j == 0) v.push_back(j);
while (y % j == 0) y /= j;
}
if (y > 1) v.push_back(y);
for (int j = 0; j < (1 << v.size()); j++) dp[0][j] = 100000000007;
dp[0][(1 << v.size()) - 1] = cost[i];
foo(0, i);
ans = min(ans, dp[n][0]);
}
if (ans < 100000000007)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.