solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
n, nb = map(int, input().split())
nl = list(map(int, input().split()))
m, mb = map(int, input().split())
ml = list(map(int, input().split()))
x = 0
y = 0
for i in nl:
x = x*nb+i
for i in ml:
y = y*mb+i
if x == y :
print('=')
elif x > y:
print('>')
else:
print('<')
| 7 | PYTHON3 |
def input_to_10():
n, base = map(int, input().split())
res = 0
for el in map(int, input().split()):
res = el + res * base
return res
a = input_to_10()
b = input_to_10()
if a == b:
print('=')
elif a < b:
print('<')
else:
print('>') | 7 | PYTHON3 |
n,b1 = (int(x) for x in input().split())
s = input().split()
x1,x2 = (0,0)
for i in range(n):
x1 += int(s[i])*(b1**(n-i-1))
n,b2 = (int(x) for x in input().split())
s = input().split()
for i in range(n):
x2 += int(s[i])*(b2**(n-i-1))
if(x1 == x2):
print('=')
elif(x1 < x2):
print('<')
else:
print('>') | 7 | PYTHON3 |
# import sys
# sys.stdin = open('cf602a.in')
n, bx = map(int, input().split())
x = list(map(int, input().split()))
m, by = map(int, input().split())
y = list(map(int, input().split()))
xx = sum(v * bx**(len(x) - i - 1) for i, v in enumerate(x))
yy = sum(v * by**(len(y) - i - 1) for i, v in enumerate(y))
if xx < yy:
print('<')
elif xx == yy:
print('=')
else:
print('>') | 7 | PYTHON3 |
n, bx = map(int, input().split())
x = list(map(int, input().split()))[::-1]
m, by = map(int, input().split())
y = list(map(int, input().split()))[::-1]
d1 = 0
deg = 1
for d in x:
d1 += d * deg
deg *= bx
d2 = 0
deg = 1
for d in y:
d2 += d * deg
deg *= by
print('>' if d1 > d2 else '<' if d1 < d2 else '=')
| 7 | PYTHON3 |
n,m = map(int, input().split())
f = list(map(int, input().split()))
f.reverse()
x = 0
x1 = 1
y = 0
y1 = 1
for i in range(n):
x += x1 * f[i]
x1 *= m
n,m = map(int, input().split())
f = list(map(int, input().split()))
f.reverse()
for i in range(n):
y += y1 * f[i]
y1 *= m
#print(x)
#print(y)
if ( x < y ):
print ("<")
elif ( x == y):
print ("=")
else:
print (">")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, bx, m, by;
long long x = 0, y = 0;
int temp;
cin >> n >> bx;
for (int i = 0; i < n; i++) {
cin >> temp;
x *= bx;
x += temp;
}
cin >> m >> by;
for (int i = 0; i < m; i++) {
cin >> temp;
y *= by;
y += temp;
}
if (x == y)
cout << '=' << endl;
else if (x < y)
cout << '<' << endl;
else
cout << '>' << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 3000000000000000000LL;
long long dp[1000001][3];
void pf(long a, set<long long> &s) {
long long i;
for (i = 2; i * i <= a; ++i) {
if (a % i == 0) {
s.insert(i);
while (a % i == 0) a /= i;
}
}
if (a > 1) s.insert(a);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long i, j;
long long n;
long long A, B;
cin >> n >> A >> B;
vector<long long> a(n);
for (i = 0; i < n; ++i) cin >> a[i];
set<long long> p;
pf(a[0] - 1, p);
pf(a[0], p);
pf(a[0] + 1, p);
pf(a[n - 1] - 1, p);
pf(a[n - 1], p);
pf(a[n - 1] + 1, p);
long long ans = INF;
for (__typeof(p.begin()) it = p.begin(); it != p.end(); it++) {
int d = *it;
for (i = 0; i < 3; ++i) dp[0][i] = 0;
for (i = 0; i < n; ++i) {
long x = a[i] % d;
if (x == 0) {
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = min(dp[i][0], dp[i][1] + A);
dp[i + 1][2] = min(dp[i][1], dp[i][2]);
} else if (x == 1 || x == d - 1) {
dp[i + 1][0] = dp[i][0] + B;
dp[i + 1][1] = min(dp[i][0] + B, dp[i][1] + A);
dp[i + 1][2] = min(dp[i][1] + B, dp[i][2] + B);
} else {
dp[i + 1][0] = INF;
dp[i + 1][1] = min(dp[i][0], dp[i][1]) + A;
dp[i + 1][2] = dp[i + 1][1];
}
}
long long tmp = INF;
for (i = 0; i < 3; ++i) tmp = min(tmp, dp[n][i]);
ans = min(ans, tmp);
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long arr[(int)(1e6 + 10)], n, a, b, ans = 1e16;
vector<long long> d;
void div(long long x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
d.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) d.push_back(x);
}
long long solve(long long x) {
long long op1 = 0, op2 = 0, op3 = 0, cur = 1e16;
for (int i = 1; i <= n; i++) {
cur = 1e16;
if (arr[i] % x == 0)
cur = 0;
else if ((arr[i] + 1) % x == 0 or (arr[i] - 1) % x == 0)
cur = b;
op1 += cur;
op2 += a;
op3 += cur;
op1 = min((long long)1e16, op1);
op2 = min(op1, op2);
op3 = min(op3, op2);
}
return op3;
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) scanf("%lld", &arr[i]);
for (int i = -1; i <= 1; i++) div(arr[1] + i), div(arr[n] + i);
sort(d.begin(), d.end());
d.erase(unique(d.begin(), d.end()), d.end());
for (__typeof(d.begin()) i = d.begin(); i != d.end(); i++)
ans = min(ans, solve(*i));
cout << ans << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct __io_dev {
__io_dev(const bool& __fastio = false) {
if (__fastio) ios_base::sync_with_stdio(false), cin.tie(nullptr);
srand(time(nullptr));
if (!string("").empty())
freopen(
""
".in",
"r", stdin),
freopen(
""
".out",
"w", stdout);
}
~__io_dev() { fprintf(stderr, "%.6f ms\n", 1e3 * clock() / CLOCKS_PER_SEC); }
} __io(false);
const long long inf = (long long)1e+9 + 7ll;
const long long linf = (long long)1e+18 + 7ll;
const long double eps = (long double)1e-9;
const long double pi = acosl((long double)-1.0);
const int alph = 26;
const int sqr = 3017;
static char buff[(int)2e6 + 17];
long long __p[3] = {29ll, 31ll, 33ll};
long long __mod[3] = {inf, inf + 2ll, 14881337ll};
const int maxn = (int)3e6 + 17;
int n;
long long a, b;
long long A[maxn], dp[maxn][3];
set<long long> D;
void add(long long x) {
for (long long i = 2; i * i <= x; ++i)
for (; x % i == 0; x /= i, D.insert(i))
;
if (x != 1) D.insert(x);
}
long long solve(long long d) {
dp[0][0] = 0, dp[0][1] = dp[0][2] = linf;
for (long long i = (long long)1; i < (long long)n + 1; ++i) {
if (A[i] % d == 0) {
dp[i][0] = dp[i - 1][0];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]);
}
if ((A[i] + 1) % d == 0 || (A[i] - 1) % d == 0) {
dp[i][0] = dp[i - 1][0] + b;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][2] = min(linf, min(dp[i - 1][1], dp[i - 1][2]) + b);
}
if (A[i] % d != 0 && (A[i] + 1) % d != 0 && (A[i] - 1) % d != 0) {
dp[i][0] = linf;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][2] = linf;
}
}
return min(dp[n][0], min(dp[n][1], dp[n][2]));
}
int main() {
scanf("%d %lld %lld", &n, &a, &b);
for (long long i = 0ll; i < (long long)n; ++i) scanf("%lld", A + i + 1);
add(A[1] - 1), add(A[1]), add(A[1] + 1);
add(A[n] - 1), add(A[n]), add(A[n] + 1);
long long ans = linf;
for (auto i : D) ans = min(ans, solve(i));
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int TEN_18 = 10000000000000000;
long long int n, a, b;
long long int l[1000100];
vector<long long int> test;
void fillTest(long long int x) {
if (x % 2 == 0) test.push_back(2);
while (x % 2 == 0) x = x / 2;
for (long long int i = 3; i <= sqrt(x); i = i + 2) {
if (x % i == 0) test.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 2) test.push_back(x);
}
long long int solve(long long int p) {
long long int s1[n + 1], s2[n + 1], dp[n + 1], c[n + 1];
for (int i = 0; i < n + 1; i++) {
s1[i] = dp[i] = 0;
c[i] = TEN_18;
}
for (int i = 0; i < n; i++) {
if (l[i] % p == 0)
c[i] = 0;
else if ((l[i] + 1) % p == 0 || (l[i] - 1) % p == 0)
c[i] = b;
}
s2[n] = 0LL;
for (int i = n - 1; i >= 0; i--) {
s2[i] = min(c[i] + s2[i + 1], TEN_18);
dp[i] = min(dp[i + 1] + a, s2[i]);
}
long long int result = dp[0];
s1[0] = 0LL;
for (int i = 1; i < n; i++) {
s1[i] = min(s1[i - 1] + c[i - 1], TEN_18);
result = min(s1[i] + dp[i], result);
}
return result;
}
int main() {
while (scanf("%lld %lld %lld", &n, &a, &b) != EOF) {
test.clear();
for (int i = 0; i < n; i++) scanf("%lld", &l[i]);
fillTest(l[0]);
fillTest(l[0] + 1);
fillTest(l[0] - 1);
fillTest(l[n - 1]);
fillTest(l[n - 1] + 1);
fillTest(l[n - 1] - 1);
long long int ans = TEN_18;
for (int i = 0; i < test.size(); i++) {
ans = min(ans, solve(test[i]));
}
printf("%lld\n", ans);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int shu[1100000];
int sushu[110000];
long long dai[1100000];
long long ans;
int n;
long long a[1100000];
long long aa, bb;
int aaa, bbb;
map<long long, int> w1, wn;
int main() {
for (int i = 2; i <= 1000000; i++) {
if (!shu[i]) {
for (int j = i * 2; j <= 1000000; j += i) shu[j] = 1;
}
}
for (int i = 2; i <= 1000000; i++) {
if (!shu[i]) {
sushu[0]++;
sushu[sushu[0]] = i;
}
}
scanf("%d%d%d", &n, &aaa, &bbb);
aa = aaa;
bb = bbb;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[i] = x;
}
for (int i = 1; i <= sushu[0]; i++) {
if (a[1] % sushu[i] == 0) w1[sushu[i]] = 1;
if ((a[1] - 1) % sushu[i] == 0) w1[sushu[i]] = 1;
if ((a[1] + 1) % sushu[i] == 0) w1[sushu[i]] = 1;
w1[a[1]] = 1;
w1[a[1] + 1] = 1;
w1[a[1] - 1] = 1;
if (a[n] % sushu[i] == 0) wn[sushu[i]] = 1;
if ((a[n] - 1) % sushu[i] == 0) wn[sushu[i]] = 1;
if ((a[n] + 1) % sushu[i] == 0) wn[sushu[i]] = 1;
wn[a[n]] = 1;
wn[a[n] - 1] = 1;
wn[a[n] + 1] = 1;
}
sushu[0]++;
sushu[sushu[0]] = a[1];
sushu[0]++;
sushu[sushu[0]] = a[1] + 1;
sushu[0]++;
sushu[sushu[0]] = a[n];
sushu[0]++;
sushu[sushu[0]] = a[n] + 1;
sushu[0]++;
sushu[sushu[0]] = a[1] - 1;
sushu[0]++;
sushu[sushu[0]] = a[n] - 1;
ans = -1;
for (int i = 1; i <= sushu[0]; i++) {
if (sushu[i] == 1) continue;
if ((!w1[sushu[i]]) && (!wn[sushu[i]])) {
} else {
long long q = sushu[i];
for (int j = 1; j <= n; j++) {
if (a[j] % q == 0) {
dai[j] = 0;
} else {
if (((a[j] + 1) % q == 0) || ((a[j] - 1) % q == 0)) {
dai[j] = bb;
} else {
dai[j] = aa * (long long)100;
}
}
}
int ji = 0;
long long temp = 0;
long long anss;
for (int j = 2; j <= n; j++) dai[j] += dai[j - 1];
anss = dai[n];
for (int j = 1; j <= n; j++) {
temp += dai[j] - dai[j - 1];
ji++;
if (temp >= (long long)ji * aa) {
anss = min(anss, dai[j - ji] + dai[n] - dai[j] + (long long)ji * aa);
} else {
temp = 0;
ji = 0;
}
}
if (ans == -1) ans = anss;
ans = min(ans, anss);
}
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD9 = 1e9 + 7;
const int MOD91 = 1e9 + 9;
const long long MOD12 = 1e12 + 39LL;
const long long MOD15 = 1e15 + 37LL;
const long long INF = 1e16;
const int base = 1e9;
const int MAX = 2e6;
const long double EPS = 1e-10;
set<long long> prime;
void fp(long long x) {
long long i = 2;
prime.insert(i);
while (x > 1 && i <= sqrt(x)) {
if (x % i == 0) prime.insert(i);
while (x % i == 0) {
x /= i;
}
i++;
}
if (x != 1) {
prime.insert(x);
}
}
long long dp[3][MAX];
long long a, b, n;
long long c[MAX];
int main() {
cin >> n >> a >> b;
for (int i = (0); i < (n); ++i) {
scanf("%I64d", &c[i]);
}
long long ans = INF;
fp(c[0]);
fp(c[0] - 1);
fp(c[0] + 1);
fp(c[n - 1]);
fp(c[n - 1] - 1);
fp(c[n - 1] + 1);
for (auto &p : prime) {
for (int i = (0); i < (n + 1); ++i) {
for (int j = (0); j < (3); ++j) {
dp[j][i] = INF;
}
}
if (c[0] % p == 0) {
dp[0][0] = 0;
} else if ((c[0] + 1) % p == 0 || (c[0] - 1) % p == 0) {
dp[0][0] = b;
}
dp[1][0] = a;
for (int i = 0; i < n - 1; ++i) {
if (c[i + 1] % p == 0) {
dp[0][i + 1] = min(dp[0][i + 1], dp[0][i]);
dp[2][i + 1] = min(dp[2][i + 1], dp[2][i]);
dp[2][i + 1] = min(dp[2][i + 1], dp[1][i]);
}
if ((c[i + 1] + 1) % p == 0) {
dp[0][i + 1] = min(dp[0][i + 1], dp[0][i] + b);
dp[2][i + 1] = min(dp[2][i + 1], dp[2][i] + b);
dp[2][i + 1] = min(dp[2][i + 1], dp[1][i] + b);
}
if ((c[i + 1] - 1) % p == 0) {
dp[0][i + 1] = min(dp[0][i + 1], dp[0][i] + b);
dp[2][i + 1] = min(dp[2][i + 1], dp[2][i] + b);
dp[2][i + 1] = min(dp[2][i + 1], dp[1][i] + b);
}
dp[1][i + 1] = min(dp[1][i + 1], min(dp[1][i] + a, dp[0][i] + a));
}
for (int i = 0; i < 3; ++i) {
ans = min(ans, dp[i][n - 1]);
}
}
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 100010;
const int maxp = 20010;
int prime[maxp], prime_n;
int divisors[maxn], divisorset[maxn], phi[maxn], mu[maxn];
bool isprime[maxn];
void gen(int n) {
prime_n = 0;
memset(isprime, 1, sizeof isprime);
isprime[0] = isprime[1] = 0;
phi[1] = 1;
for (int i = 2; i < n; ++i) {
if (isprime[i]) {
prime[prime_n++] = i;
divisors[i] = 1;
phi[i] = i - 1;
mu[i] = -1;
}
for (int j = 0, k; j < prime_n && (k = i * prime[j]) < n; ++j) {
isprime[k] = 0;
divisors[k] = divisors[i] + divisors[prime[j]];
if (!(i % prime[j])) {
phi[k] = phi[i] * prime[j];
divisorset[k] = divisorset[i];
mu[k] = 0;
break;
} else {
phi[k] = phi[i] * (prime[j] - 1);
divisorset[k] = divisorset[i] + 1;
mu[k] = -mu[i];
}
}
}
}
int pri[maxp * 6];
int get_pri(int n, int *pri) {
int pri_n = 0;
for (int i = 0, p; (p = prime[i]) <= n / p; ++i)
if (n % p == 0) {
pri[pri_n] = p;
while (n % p == 0) n /= p;
++pri_n;
}
if (n > 1) {
pri[pri_n] = n;
++pri_n;
}
return pri_n;
}
const int MAXN = 1000010;
int n, A, B;
int a[MAXN];
long long f[MAXN][3];
long long calc(int d) {
for (int i = 1; i <= n; ++i) {
f[i][1] = min(f[i - 1][0], f[i - 1][1]) + A;
if (a[i] % d == 0) {
f[i][0] = f[i - 1][0];
f[i][2] = min(f[i - 1][1], f[i - 1][2]);
} else if ((a[i] + 1) % d == 0 || (a[i] - 1) % d == 0) {
f[i][0] = f[i - 1][0] + B;
f[i][2] = min(f[i - 1][1], f[i - 1][2]) + B;
} else {
f[i][0] = INF;
f[i][2] = INF;
}
}
return min(f[n][0], min(f[n][1], f[n][2]));
}
void solve() {
scanf("%d%d%d", &n, &A, &B);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
int num = 0;
for (int d = -1; d <= 1; ++d) {
num += get_pri(a[1] + d, pri + num);
num += get_pri(a[n] + d, pri + num);
}
sort(pri, pri + num);
num = unique(pri, pri + num) - pri;
long long res = INF;
for (int i = 0; i < num; ++i) {
int p = pri[i];
long long x = calc(p);
res = min(res, x);
}
printf("%I64d\n", res);
}
int main() {
gen(100000);
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int INF = 1e9 + 100;
const LL INF64 = INF * 1LL * INF;
vector<int> factorize(int x) {
vector<int> fact;
for (int i = 2; i * 1LL * i <= x; ++i) {
if (x % i == 0) {
fact.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) {
fact.push_back(x);
}
return fact;
}
int is_good(int x, int pr) {
return x % pr == 0 || (x + 1) % pr == 0 || (x - 1) % pr == 0;
}
int cost(int x, int pr) {
if (x % pr == 0)
return 0;
else if ((x + 1) % pr == 0 || (x - 1) % pr == 0)
return 1;
else
return INF;
}
LL check(vector<int> &ar, int pr, LL a, LL b) {
vector<vector<LL>> dp(2, vector<LL>(3, INF64));
dp[0][0] = 0;
for (int i = 0; i < ar.size(); ++i) {
for (int j = 0; j < 3; ++j) {
if (j == 0) {
dp[!(i & 1)][0] =
min(dp[!(i & 1)][0], dp[i & 1][0] + cost(ar[i], pr) * b);
}
if (j == 1 || j == 0) {
dp[!(i & 1)][1] = min(dp[!(i & 1)][1], dp[i & 1][j] + a);
dp[!(i & 1)][2] = min(dp[!(i & 1)][2], dp[i & 1][j] + a);
}
if (j == 2) {
dp[!(i & 1)][2] =
min(dp[!(i & 1)][2], dp[i & 1][j] + cost(ar[i], pr) * b);
}
}
dp[i & 1][0] = dp[i & 1][1] = dp[i & 1][2] = INF64;
}
return min(dp[ar.size() & 1][0], dp[ar.size() & 1][2]);
}
void solve() {
int n, a, b;
cin >> n >> a >> b;
vector<int> ar(n);
for (auto &it : ar) cin >> it;
set<int> factors;
auto v = factorize(ar.front());
factors.insert(v.begin(), v.end());
v = factorize(ar.front() + 1);
factors.insert(v.begin(), v.end());
v = factorize(ar.front() - 1);
factors.insert(v.begin(), v.end());
v = factorize(ar.back());
factors.insert(v.begin(), v.end());
v = factorize(ar.back() + 1);
factors.insert(v.begin(), v.end());
v = factorize(ar.back() - 1);
factors.insert(v.begin(), v.end());
LL ans = INF * 1LL * INF;
for (auto pr : factors) {
ans = min(ans, check(ar, pr, a, b));
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
solve();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
vector<int> pr;
void gao(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
pr.push_back(i);
while (x % i == 0) {
x /= i;
}
}
if (x != 1) pr.push_back(x);
}
long long p1[3000100], p2[3000100];
int aa[3000100];
int n;
int a, b;
long long solve(int x) {
p2[n + 1] = 0;
for (int i = n; i >= 1; i--) {
p2[i] = 1LL << 60;
if (aa[i] % x == 0)
p2[i] = p2[i + 1];
else if ((aa[i] + 1) % x == 0 || (aa[i] - 1) % x == 0)
p2[i] = p2[i + 1] + (long long)b;
}
p1[0] = 0;
for (int i = 1; i <= n; i++) {
p1[i] = 1LL << 60;
if (aa[i] % x == 0)
p1[i] = p1[i - 1];
else if ((aa[i] + 1) % x == 0 || (aa[i] - 1) % x == 0)
p1[i] = p1[i - 1] + (long long)b;
}
long long m = -a;
long long ans = 1LL << 60;
for (int i = 1; i <= n; i++) {
ans = min(ans, p2[i] + (long long)i * a + m);
m = min(m, p1[i] - (long long)(i + 1) * a);
}
for (int i = 1; i <= n; i++) {
ans = min(ans, p1[i] + (long long)(n - i) * a);
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", &aa[i]);
gao(aa[1]);
gao(aa[1] - 1);
gao(aa[1] + 1);
gao(aa[n]);
gao(aa[n] - 1);
gao(aa[n] + 1);
long long ans = 1LL << 60;
for (auto p : pr) ans = min(ans, solve(p));
printf("%lld", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
vector<int> get_primes(int n) {
vector<int> res;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
while (n % i == 0) n /= i;
}
}
if (n != 1) res.push_back(n);
return res;
}
const long long inf = 1e16;
long long get_min_first(const vector<int>& v, long long a, long long b) {
vector<int> f = get_primes(v[0]);
long long res = inf;
const int UNOPENED = 0;
const int OPENED = 1;
const int CLOSED = 2;
for (auto p : f) {
long long dp[3];
for (int i = 0; i < 3; i++) {
dp[i] = 0;
}
for (int i = 1; i < v.size(); i++) {
dp[OPENED] = min(dp[OPENED] + a, dp[UNOPENED] + a);
if (v[i] % p != 0) {
if ((v[i] + 1) % p == 0 || (v[i] - 1) % p == 0) {
dp[UNOPENED] += b;
dp[CLOSED] += b;
} else {
dp[UNOPENED] = inf;
dp[CLOSED] = inf;
}
}
dp[CLOSED] = min(dp[CLOSED], dp[OPENED]);
}
res = min(res, *min_element(dp, dp + 3));
}
return res;
}
int main() {
long long n, a, b;
cin >> n >> a >> b;
vector<int> v(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
long long ans = inf;
ans = min(ans, get_min_first(v, a, b));
v[0]++;
ans = min(ans, b + get_min_first(v, a, b));
v[0] -= 2;
ans = min(ans, b + get_min_first(v, a, b));
v[0]++;
reverse(v.begin(), v.end());
ans = min(ans, get_min_first(v, a, b));
v[0]++;
ans = min(ans, b + get_min_first(v, a, b));
v[0] -= 2;
ans = min(ans, b + get_min_first(v, a, b));
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const long long inf = 1000000000000000000L;
int arr[N];
long long prefix[N], cost[N], suffix[N];
set<int> factors;
set<int>::iterator it;
void pf(long long x) {
for (int i = x - 1; i <= x + 1; i++) {
int p = i;
for (int j = 2; j * j <= i; j++) {
if (p % j == 0) {
factors.insert(j);
while (p % j == 0) p /= j;
}
}
if (p != 1) factors.insert(p);
}
}
int main() {
int n, a, b, p;
scanf("%d %d %d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
if (n == 1) {
printf("0\n");
return 0;
}
pf(arr[1]);
pf(arr[n]);
long long ans = inf;
for (it = factors.begin(); it != factors.end(); ++it) {
int p = *it;
prefix[0] = 0LL;
for (int i = 1; i <= n; i++) {
if (arr[i] % p == 0)
cost[i] = 0LL;
else if ((arr[i] + 1) % p == 0 || (arr[i] - 1) % p == 0)
cost[i] = (long long)b;
else
cost[i] = inf;
prefix[i] = prefix[i - 1] + cost[i];
if (prefix[i] > inf) prefix[i] = inf;
}
prefix[0] = inf;
suffix[n + 1] = 0LL;
long long suffix_sum = 0LL;
for (int i = n; i > 0; i--) {
suffix_sum += cost[i];
if (suffix_sum > inf) suffix_sum = inf;
suffix[i] = min(a + suffix[i + 1], suffix_sum);
}
ans = min(ans, suffix[1]);
for (int i = 2; i <= n; i++) {
ans = min(ans, prefix[i - 1] + suffix[i]);
}
}
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long arr[(int)(1e6 + 10)], n, a, b, ans = 1e16;
vector<long long> d;
void div(long long x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
d.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) d.push_back(x);
}
long long solve(long long x) {
long long op1 = 0, op2 = 0, op3 = 0, cur = 1e16;
for (int i = 1; i <= n; i++) {
cur = 1e16;
if (arr[i] % x == 0)
cur = 0;
else if ((arr[i] + 1) % x == 0 or (arr[i] - 1) % x == 0)
cur = b;
op1 += cur;
op2 += a;
op3 += cur;
op1 = min((long long)1e16, op1);
op2 = min(op1, op2);
op3 = min(op3, op2);
}
return op3;
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) scanf("%lld", &arr[i]);
for (int i = -1; i <= 1; i++) div(arr[1] + i), div(arr[n] + i);
sort(d.begin(), d.end());
d.erase(unique(d.begin(), d.end()), d.end());
for (__typeof(d.begin()) i = d.begin(); i != d.end(); i++)
ans = min(ans, solve(*i));
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
int m, n, a, b;
int t[maxn];
long long d[maxn][3];
vector<int> fac;
long long solve(int tt, int B) {
fac.clear();
for (int i = 2; i * i <= tt; ++i) {
if (tt % i == 0) {
fac.push_back(i);
if (i * i != tt) fac.push_back(tt / i);
while (tt % i == 0) tt /= i;
}
if (tt == 1) break;
}
if (tt > 1) fac.push_back(tt);
sort(fac.begin(), fac.end());
long long res = INF;
for (int i = 0; i < fac.size(); ++i) {
int pr = fac[i];
memset(d, INF, sizeof d);
d[1][0] = B;
for (int j = 2; j <= n; ++j) {
if (t[j - 1] % pr) {
if (t[j - 1] % pr == 1 || t[j - 1] % pr == pr - 1) {
d[j][0] = min(d[j][0], d[j - 1][0] + b);
d[j][2] = min(d[j][2], min(d[j - 1][1], d[j - 1][2]) + b);
}
d[j][1] = min(d[j][1], min(d[j - 1][0], d[j - 1][1]) + a);
} else {
d[j][0] = d[j - 1][0];
d[j][1] = min(d[j][1], d[j - 1][1] + a);
d[j][2] = min(d[j - 1][2], d[j - 1][1]);
}
}
res = min(res, min(d[n][0], min(d[n][1], d[n][2])));
}
return res;
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 0; i < n; ++i) scanf("%d", t + i);
long long ans = INF;
ans = min(ans, solve(t[0] - 1, b));
ans = min(ans, solve(t[0], 0));
ans = min(ans, solve(t[0] + 1, b));
reverse(t, t + n);
ans = min(ans, solve(t[0] - 1, b));
ans = min(ans, solve(t[0], 0));
ans = min(ans, solve(t[0] + 1, b));
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e6 + 9, INF = 1e16;
long long arr[MX], dp[MX][3];
set<long long> s;
void FUN(long long x) {
if (x == 2) return;
for (long long i = 2; i * i <= x; i++)
while (x > 1 && x % i == 0) x /= i, s.insert(i);
if (x > 1) s.insert(x);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, a, b;
cin >> n >> a >> b;
for (long long i = 0; i < n; i++) cin >> arr[i];
FUN(arr[0] + 1);
FUN(arr[0]);
FUN(arr[0] - 1);
FUN(arr[n - 1] + 1);
FUN(arr[n - 1]);
FUN(arr[n - 1] - 1);
long long minn = 1e18;
for (long long x : s) {
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (long long i = 1; i <= n; i++) {
if (arr[i - 1] % x == 0 || arr[i - 1] % x == 1 ||
arr[i - 1] % x == x - 1) {
dp[i][0] = dp[i - 1][0] + b * (arr[i - 1] % x != 0);
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + b * (arr[i - 1] % x != 0);
} else {
dp[i][0] = dp[i][2] = INF;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
}
dp[i][0] = min(INF, dp[i][0]), dp[i][1] = min(INF, dp[i][1]),
dp[i][2] = min(INF, dp[i][2]);
}
minn = min(min(minn, dp[n][0]), min(dp[n][1], dp[n][2]));
}
cout << minn;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 1e9 + 7;
const double PI = acos(-1);
int prime[100000];
int isprime[100000];
int num;
int ai[1000050];
int ok[100000];
void init() {
memset(prime, 0, sizeof(prime));
memset(isprime, 0, sizeof(isprime));
for (int i = 2; i < 100000; i++) {
if (!isprime[i]) {
prime[num++] = i;
}
for (int j = i * 2; j < 100000; j += i) {
isprime[j] = 1;
}
}
}
long long n, a, b;
long long dp[1000050][3];
long long solve(int aa) {
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < 3; j++) dp[i][j] = 1e18;
}
dp[0][0] = 0;
dp[0][1] = 0;
for (int i = 0; i < n; i++) {
if (((ai[i] - 1) % aa == 0) || (((ai[i] + 1) % aa == 0))) {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + b);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + a);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + a);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][1] + b);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][2] + b);
} else if (ai[i] % aa == 0) {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0]);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + a);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][1]);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][2]);
} else {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + a);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + a);
}
}
long long res = min(dp[n][0], dp[n][1]);
res = min(res, dp[n][2]);
return res;
}
int main() {
cin >> n >> a >> b;
memset(ok, 0, sizeof(ok));
init();
for (int i = 0; i < n; i++) scanf("%d", &ai[i]);
long long ans = 1e18;
long long zz = 0;
for (int j = -1; j <= 1; j++) {
int mm = ai[0] + j;
for (int i = 0; i < num; i++) {
if (mm % prime[i] == 0) {
while (mm % prime[i] == 0) mm /= prime[i];
if (ok[prime[i]]) continue;
ans = min(ans, solve(prime[i]));
ok[prime[i]] = 1;
}
}
if (mm != 1) {
ans = min(ans, solve(mm));
zz = mm;
}
}
for (int j = -1; j <= 1; j++) {
int mm = ai[n - 1] + j;
for (int i = 0; i < num; i++) {
if (mm % prime[i] == 0) {
while (mm % prime[i] == 0) mm /= prime[i];
if (ok[prime[i]]) continue;
ans = min(ans, solve(prime[i]));
ok[prime[i]] = 1;
}
}
if (mm != 1) {
ans = min(ans, solve(mm));
zz = mm;
}
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long INF = 1e18;
long long dp[N][3];
long long val[N];
long long a, b;
int n;
vector<long long> gcd;
void init(long long x) {
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) gcd.push_back(i);
while (x % i == 0) x /= i;
}
if (x != 1) gcd.push_back(x);
}
long long solve(long long g) {
long long temp;
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 1; i <= n; i++) {
temp = 1e18;
if ((val[i] + 1) % g == 0 || (val[i] - 1) % g == 0) temp = b;
if (val[i] % g == 0) temp = 0;
dp[i][0] = dp[i - 1][0] + temp;
dp[i][0] = min(dp[i][0], INF);
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + temp;
dp[i][2] = min(dp[i][2], INF);
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][1] = min(dp[i][1], INF);
}
return min(dp[n][0], min(dp[n][1], dp[n][2]));
}
int main() {
scanf("%d%I64d%I64d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%I64d", &val[i]);
gcd.clear();
init(val[1]);
init(val[1] + 1);
init(val[1] - 1);
init(val[n]);
init(val[n] + 1);
init(val[n] - 1);
sort(gcd.begin(), gcd.end());
gcd.erase(unique(gcd.begin(), gcd.end()), gcd.end());
long long ans = 2e18;
for (int i = 0; i < gcd.size(); i++) {
ans = min(solve(gcd[i]), ans);
}
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 1e5 + 1;
bool prime[N];
map<int, int> M;
int A[10 * N];
long long dp[10 * N][3];
int cur_prime, n, a, b;
long long solve(int ind, int flag) {
if (ind == 1) {
long long ret;
if (flag == 0) {
if (A[ind] % cur_prime == 0)
ret = 0;
else if ((A[ind] + 1) % cur_prime == 0 || (A[ind] - 1) % cur_prime == 0)
ret = (long long)b;
else
ret = (long long)1e16;
} else if (flag == 1) {
ret = (long long)a;
} else {
ret = (long long)a;
}
return ret;
}
if (dp[ind][flag] != -1) return dp[ind][flag];
long long& ret = dp[ind][flag];
ret = LLONG_MAX;
if (flag == 0) {
if (A[ind] % cur_prime == 0) {
ret = solve(ind - 1, 0);
} else if ((A[ind] + 1) % cur_prime == 0 || (A[ind] - 1) % cur_prime == 0) {
ret = b + solve(ind - 1, 0);
} else {
ret = (long long)1e16;
}
} else if (flag == 1) {
ret = min(solve(ind - 1, 0) + a, solve(ind - 1, 1) + a);
} else {
ret = min(ret, a + solve(ind - 1, 0));
ret = min(ret, a + solve(ind - 1, 1));
long long ty;
if (A[ind] % cur_prime == 0)
ty = 0;
else if ((A[ind] + 1) % cur_prime == 0 || (A[ind] - 1) % cur_prime == 0)
ty = b;
else
ty = (long long)1e16;
ret = min(ret, ty + solve(ind - 1, 2));
}
return ret;
}
void seive() {
for (int i = 2; i < N; i++) prime[i] = true;
for (int i = 2; i * i < N; i++) {
if (prime[i]) {
for (int j = 2 * i; j < N; j += i) {
prime[j] = false;
}
}
}
}
int main() {
seive();
scanf("%d", &n);
scanf("%d", &a);
scanf("%d", &b);
for (int i = 1; i < n + 1; i++) {
scanf("%d", &A[i]);
}
if (n == 1) {
printf("%d\n", 0);
return 0;
}
vector<int> cand;
cand.push_back(A[1]);
cand.push_back(A[1] + 1);
cand.push_back(A[1] - 1);
cand.push_back(A[n]);
cand.push_back(A[n] + 1);
cand.push_back(A[n] - 1);
for (int x : cand) {
if (x == 1) continue;
for (int i = 1; i < N; i++) {
if (prime[i] && x % i == 0) {
M[i];
while (x % i == 0) x /= i;
}
}
if (x > 1) M[x];
}
long long ans = LLONG_MAX;
for (auto itr = M.begin(); itr != M.end(); ++itr) {
memset(dp, -1, sizeof(dp));
cur_prime = itr->first;
ans = min(ans, min(solve(n, 0), min(solve(n, 1), solve(n, 2))));
}
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, tot;
long long A, B, a[1000005], ans = 1ll << 60, f[1000005][3];
void Cal(long long x) {
long long sum, w;
for (int i = 1; i <= n; i++) {
if (a[i] % x == 0)
w = 0;
else if (a[i] % x == 1 || a[i] % x == x - 1)
w = B;
else
w = 1ll << 35;
f[i][0] = f[i - 1][0] + w;
f[i][1] = min(f[i - 1][0], f[i - 1][1]) + A;
f[i][2] = min(f[i - 1][1], f[i - 1][2]) + w;
}
sum = min(f[n][0], min(f[n][1], f[n][2]));
ans = min(sum, ans);
}
void Push(long long x) {
if (x <= 1) return;
long long t = x;
for (long long i = 2; i * i <= x; i++) {
if (t % i == 0) {
Cal(i);
while (t % i == 0) t /= i;
}
if (t == 1) break;
}
if (t != 1) Cal(t);
}
int main() {
scanf("%d%I64d%I64d", &n, &A, &B);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
Push(a[1]);
Push(a[1] - 1);
Push(a[1] + 1);
Push(a[n]);
Push(a[n] - 1);
Push(a[n] + 1);
printf("%I64d", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
set<int> p;
int A[N];
int n;
long long a, b;
int mark[N];
long long prefix[N], suffix[N];
long long ans = LLONG_MAX;
void compute(int x) {
memset(mark, 0, sizeof mark);
memset(prefix, -1, sizeof prefix);
memset(suffix, -1, sizeof suffix);
for (int i = 1; i <= n; i++) {
if ((A[i] % x) == 0)
continue;
else if ((A[i] % x) == 1 or (A[i] % x) == x - 1)
mark[i] = 1;
else
mark[i] = 2;
}
prefix[0] = suffix[n + 1] = 0;
for (int i = 1; i <= n; i++) {
if (mark[i] == 2)
break;
else
prefix[i] = prefix[i - 1] + (mark[i] == 1);
}
for (int i = n; i >= 1; i--) {
if (mark[i] == 2)
break;
else
suffix[i] = suffix[i + 1] + (mark[i] == 1);
}
for (int i = n; i >= 1; i--) {
if (suffix[i] == -1) break;
ans = min(ans, suffix[i] * b + (i - 1) * 1LL * a);
}
suffix[n + 1] = (n + 1) * 1LL * a;
for (int i = n; i >= 1; i--) {
if (suffix[i] == -1)
suffix[i] = suffix[i + 1];
else
suffix[i] = min(suffix[i + 1], suffix[i] * b + i * 1LL * a);
}
for (int i = 1; i <= n; i++) {
if (prefix[i] == -1) break;
ans = min(ans, prefix[i] * b + suffix[i + 1] - a * 1LL * (i + 1));
}
}
void solve(int x) {
if (x == 1) return;
p.clear();
for (long long i = 2; i * i <= x;) {
if ((x % i) == 0) {
p.insert(i);
x /= i;
} else
i++;
}
if (x != 1) p.insert(x);
for (auto it : p) compute(it);
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) cin >> A[i];
solve(A[1]);
solve(A[1] + 1);
solve(A[1] - 1);
solve(A[n]);
solve(A[n] + 1);
solve(A[n] - 1);
cout << ans;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e18 + 10;
long long n, a, b;
long long x[1000100], f[1000100], g[1000100];
vector<long long> prime;
bool isprime[1000100];
set<long long> s;
void getPrime() {
int i, j;
for (i = 0; i < 1000100; i++) isprime[i] = true;
isprime[0] = isprime[1] = 0;
for (i = 2; i < 1000100; i++) {
if (!isprime[i]) continue;
for (j = 2 * i; j < 1000100; j += i) isprime[j] = false;
}
prime.clear();
for (i = 2; i < 1000100; i++) prime.push_back(i);
}
long long change(long long a, long long p) {
if (a % p == 0) return 0;
if ((a + 1) % p == 0 || (a - 1) % p == 0) return b;
return -1;
}
long long Solve(long long p) {
int L = n + 1, R = 0, i, tag = 0;
long long t, G, res;
f[0] = 0;
for (i = 1; i <= n; i++) {
t = change(x[i], p);
if (t == -1) {
L = i;
tag = 1;
}
if (tag)
f[i] = MAX;
else
f[i] = f[i - 1] + t;
}
g[n + 1] = 0;
tag = 0;
for (i = n; i > 0; i--) {
t = change(x[i], p);
if (t == -1) {
R = i;
tag = 1;
}
if (tag)
g[i] = MAX;
else
g[i] = g[i + 1] + t;
}
G = g[n + 1] + (n + 1) * a;
res = f[n];
for (i = n; i >= 0; i--) {
res = min(res, f[i] - (i + 1) * a + G);
G = min(G, g[i] + i * a);
}
return res;
}
void Get(long long a) {
if (a == 0 || a == 1) return;
int i, l = prime.size(), t;
for (i = 0; i < l; i++) {
t = prime[i];
if (t * t > a) break;
while (a % t == 0) {
if (s.find(t) == s.end()) s.insert(t);
a /= t;
}
}
if (a > 1) s.insert(a);
}
void Init() {
s.clear();
Get(x[1]);
Get(x[1] + 1);
Get(x[1] - 1);
Get(x[n]);
Get(x[n] + 1);
Get(x[n] - 1);
}
int main() {
int i, j;
long long ans;
set<long long>::iterator it;
getPrime();
scanf("%I64d%I64d%I64d", &n, &a, &b);
for (i = 1; i <= n; i++) scanf("%I64d", &x[i]);
Init();
ans = MAX;
for (it = s.begin(); it != s.end(); it++) ans = min(ans, Solve(*it));
printf("%I64d", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, res;
long long dp[1000100][3];
vector<long long> vet;
set<long long> primes;
bool is_prime(long long val) {
bool prime = true;
for (long long i = 2; i * i <= val; i++) {
if (val % i) continue;
prime = false;
break;
}
return prime;
}
void decompose(long long num) {
for (long long i = 2; i * i <= num; i++) {
if (!is_prime(i)) continue;
if (!(num % i)) {
primes.insert(i);
primes.insert(num / i);
}
}
if (is_prime(num)) primes.insert(num);
}
bool one_diff(long long val, long long p) {
return (val % p == 1 || val % p == p - 1);
}
long long fmin(long long a, long long b) {
if (a < b) return a;
return b;
}
long long f(long long p) {
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
long long inc;
for (int j = 1; j <= n; j++) {
if (one_diff(vet[j - 1], p))
inc = b;
else if (!(vet[j - 1] % p))
inc = 0;
else
inc = -1;
if (inc == -1) {
dp[j][0] = -1;
dp[j][2] = -1;
if (dp[j - 1][0] == -1)
dp[j][1] = dp[j - 1][1] + a;
else
dp[j][1] = fmin(dp[j - 1][0], dp[j - 1][1]) + a;
continue;
}
if (dp[j - 1][0] == -1)
dp[j][0] = -1;
else
dp[j][0] = dp[j - 1][0] + inc;
if (j == 1 && !one_diff(vet[n - 1], p) && vet[n - 1] % p)
dp[j][1] = inc;
else {
dp[j][1] = dp[j - 1][1] + a;
if (dp[j - 1][0] != -1) dp[j][1] = fmin(dp[j][1], dp[j - 1][0] + a);
}
dp[j][2] = dp[j - 1][1] + inc;
if (dp[j - 1][2] != -1) dp[j][2] = fmin(dp[j][2], dp[j - 1][2] + inc);
}
long long acm;
acm = dp[n][1];
if (dp[n][0] != -1) acm = fmin(acm, dp[n][0]);
if (dp[n][2] != -1) acm = fmin(acm, dp[n][2]);
return acm;
}
int main() {
cin >> n >> a >> b;
vet = vector<long long>(n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &vet[i]);
}
for (int i = -1; i <= 1; i++) {
decompose(vet[0] + i);
decompose(vet[n - 1] + i);
}
res = (long long)1000000007 * (long long)1000000007;
for (set<long long>::iterator it = primes.begin(); it != primes.end(); it++)
res = fmin(res, f(*it));
cout << res << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
int n, A, B, a[maxn];
long long dp[maxn][3];
long long solve(int x, int y) {
if (x == 1) return LLONG_MAX;
vector<int> facs;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
facs.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) facs.push_back(x);
long long ans = LLONG_MAX;
for (int j = 0; j < facs.size(); j++) {
memset(dp, 0x3f, sizeof(dp));
dp[1][0] = y;
for (int i = 2; i <= n; i++) {
if ((a[i] - 1) % facs[j] == 0) {
dp[i][0] = min(dp[i][0], dp[i - 1][0] + B);
dp[i][2] = min(dp[i][2], min(dp[i - 1][1], dp[i - 1][2]) + B);
}
if ((a[i] + 1) % facs[j] == 0) {
dp[i][0] = min(dp[i][0], dp[i - 1][0] + B);
dp[i][2] = min(dp[i][2], min(dp[i - 1][1], dp[i - 1][2]) + B);
}
if (a[i] % facs[j] == 0) {
dp[i][0] = min(dp[i][0], dp[i - 1][0]);
dp[i][2] = min(dp[i][2], min(dp[i - 1][1], dp[i - 1][2]));
}
dp[i][1] = min(dp[i][1], min(dp[i - 1][0], dp[i - 1][1]) + A);
}
ans = min(ans, dp[n][0]);
ans = min(ans, dp[n][1]);
ans = min(ans, dp[n][2]);
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &A, &B);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long ans = LLONG_MAX;
ans = min(ans, solve(a[1] - 1, B));
ans = min(ans, solve(a[1], 0));
ans = min(ans, solve(a[1] + 1, B));
reverse(a + 1, a + 1 + n);
ans = min(ans, solve(a[1] - 1, B));
ans = min(ans, solve(a[1], 0));
ans = min(ans, solve(a[1] + 1, B));
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace output {
void pr(short x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(int x) { cout << x; }
void pr(long long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(double x) { cout << x; }
void pr(long double x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char* x) { cout << x; }
void pr(const string& x) { cout << x; }
void pr(bool x) { cout << (x ? "true" : "false"); }
template <class S, class T>
void pr(const pair<S, T>& x) {
pr(0 ? "(" : ""), pr(x.first), pr(0 ? ", " : " "), pr(x.second),
pr(0 ? ")" : "");
}
template <class T>
void pr(const vector<T>& x) {
pr(0 ? "{" : "");
bool _ = 0;
for (const auto& v : x) pr(_ ? 0 ? ", " : " " : ""), pr(v), _ = 1;
pr(0 ? "}" : "");
}
template <class T>
void pr(const set<T>& x) {
pr(0 ? "{" : "");
bool _ = 0;
for (const auto& v : x) pr(_ ? 0 ? ", " : " " : ""), pr(v), _ = 1;
pr(0 ? "}" : "");
}
template <class T>
void pr(const multiset<T>& x) {
pr(0 ? "{" : "");
bool _ = 0;
for (const auto& v : x) pr(_ ? 0 ? ", " : " " : ""), pr(v), _ = 1;
pr(0 ? "}" : "");
}
template <class S, class T>
void pr(const map<S, T>& x) {
pr(0 ? "{" : "");
bool _ = 0;
for (const auto& v : x) pr(_ ? 0 ? ", " : " " : ""), pr(v), _ = 1;
pr(0 ? "}" : "");
}
template <class S, class... T>
void pr(const S& a, const T&... b) {
pr(a);
if (sizeof...(b))
pr(" "), pr(b...);
else
pr("\n");
}
} // namespace output
using namespace output;
const long long MN = 1e6 + 6, inf = 1LL << 60;
long long n, a, b, arr[MN], dp[MN][3], i, j, ans;
long long chk(long long p, long long s, long long e) {
for (long long j = 0; j < 3; j++) dp[s - 1][j] = 0;
for (long long i = s; i <= e; i++) {
for (long long j = 0; j < 3; j++) dp[i][j] = inf;
long long k = arr[i] / p, t = k * p;
dp[i][1] = min(dp[i - 1][1], dp[i - 1][0]) + a;
if (t == arr[i]) {
dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]);
dp[i][0] = dp[i - 1][0];
} else if (t == arr[i] - 1 || t + p == arr[i] + 1) {
dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]) + b;
dp[i][0] = dp[i - 1][0] + b;
}
}
long long res = inf;
for (long long j = 0; j < 3; j++) res = min(res, dp[e][j]);
return res;
}
long long go(long long t, long long s, long long e) {
if (t <= 1) return inf;
long long r = t, res = inf;
for (long long i = 2; i * i <= t; i++) {
if (r % i == 0) {
while (r % i == 0) r /= i;
res = min(res, chk(i, s, e));
}
}
if (r != 1) res = min(res, chk(r, s, e));
return res;
}
int main() {
scanf("%lld%lld%lld", &n, &a, &b);
ans = inf;
for (i = 1; i <= n; i++) scanf("%lld", &arr[i]);
if (n == 1)
pr(arr[1] > 1 ? 0 : b);
else {
for (i = -1; i <= 1; i++) {
ans = min(ans, go(arr[1] + i, 2, n) + abs(i) * b);
ans = min(ans, go(arr[n] + i, 1, n - 1) + abs(i) * b);
}
pr(ans);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
long long int dp[1000002][3];
bool val[40002];
set<long long int> s;
void get(long long int z) {
long long int i, p;
bool f = false;
p = v.size();
for (i = 0; i < p; i++) {
f = false;
while (z % v[i] == 0) {
z = z / v[i];
f = true;
}
if (f == true) s.insert(v[i]);
if (z != 1) s.insert(z);
}
}
int main() {
long long int a, b, c, d = 1e18, e, i, j, p, q, t = 1e18;
long long int y[1000002];
cin >> a >> b >> c;
for (i = 1; i <= a; i++) {
scanf("%lld", &y[i]);
}
for (i = 2; i <= 40000; i++) {
if (val[i]) continue;
v.push_back(i);
for (j = i; j <= 40000; j = j + i) val[j] = false;
}
get(y[1]);
get(y[1] - 1);
get(y[1] + 1);
get(y[a]);
get(y[a] + 1);
get(y[a] - 1);
q = s.size();
for (set<long long int>::iterator it = s.begin(); it != s.end(); it++) {
e = *it;
if (y[1] % e == 0) {
dp[1][0] = 0;
} else if ((y[1] + 1) % e == 0) {
dp[1][0] = c;
} else if ((y[1] - 1) % e == 0) {
dp[1][0] = c;
} else
dp[1][0] = t;
dp[1][1] = b;
dp[1][2] = b;
for (i = 2; i <= a; i++) {
if (y[i] % e == 0) {
dp[i][0] = dp[i - 1][0];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + b;
dp[i][2] = min(dp[i][1], dp[i - 1][2]);
} else if (((y[i] - 1) % e == 0) || ((y[i] + 1) % e == 0)) {
dp[i][0] = dp[i - 1][0] + c;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + b;
dp[i][2] = min(dp[i][1], dp[i - 1][2] + c);
} else {
dp[i][0] = t;
dp[i][1] = dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + b;
dp[i][2] = dp[i][1];
}
}
d = min(d, dp[a][0]);
d = min(d, dp[a][1]);
d = min(d, dp[a][2]);
}
cout << d;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void upmax(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline void upmin(T& a, T b) {
if (a > b) a = b;
}
const int maxn = 1000007;
const int maxm = 200007;
const int mod = 1000000007;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-7;
typedef int arr[maxn];
typedef int adj[maxm];
inline int fcmp(double a, double b) {
if (fabs(a - b) <= eps) return 0;
if (a < b - eps) return -1;
return 1;
}
inline int add(int a, int b) { return ((long long)a + b) % mod; }
inline int mul(int a, int b) { return ((long long)a * b) % mod; }
inline int dec(int a, int b) { return add(a, mod - b % mod); }
inline int Pow(int a, int b) {
int t = 1;
while (b) {
if (b & 1) t = mul(t, a);
a = mul(a, a), b >>= 1;
}
return t;
}
template <typename Type>
inline Type RD() {
char c = getchar();
Type x = 0, flag = 1;
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
flag = -1;
else
x = c - '0';
while (isdigit(c = getchar())) x = x * 10 + c - '0';
return x * flag;
}
inline char rdch() {
char c = getchar();
while (!isalpha(c)) c = getchar();
return c;
}
const int N = 100000;
arr pr, vis;
int ptt;
inline void sieve() {
for (int i = 2, _ = N; i <= _; i++) {
if (!vis[i]) pr[++ptt] = i;
for (int j = 1, _ = ptt; j <= _; j++)
if (pr[j] * i > N)
break;
else {
vis[pr[j] * i] = 1;
if (i % pr[j] == 0) break;
}
}
}
int fact[120], tot;
inline void gf(int n) {
int m = (int)(sqrt(n) + 0.5);
for (int i = 1, _ = ptt; i <= _; i++)
if (pr[i] > m)
break;
else if (n % pr[i] == 0) {
fact[++tot] = pr[i];
while (n % pr[i] == 0) n /= pr[i];
}
if (n != 1) fact[++tot] = n;
}
arr v;
int n, a, b;
void input() {
n = RD<int>(), a = RD<int>(), b = RD<int>();
for (int i = 1, _ = n; i <= _; i++) v[i] = RD<int>();
gf(v[1]), gf(v[1] + 1), gf(v[1] - 1);
gf(v[n]), gf(v[n] + 1), gf(v[n] - 1);
sort(fact + 1, fact + tot + 1);
tot = unique(fact + 1, fact + tot + 1) - fact - 1;
}
long long f[maxn][4];
inline long long dp(int p) {
memset(f, (0x3f), sizeof(f));
f[0][0] = 0;
for (int i = 1, _ = n; i <= _; i++) {
if (i == 1) {
f[i][1] = a;
}
if (v[i] % p == 0) {
if (i != n) upmin(f[i][3], f[i - 1][1]);
upmin(f[i][0], f[i - 1][0]);
upmin(f[i][3], min(f[i - 1][2], f[i - 1][3]));
}
if (i != n) upmin(f[i][1], f[i - 1][1] + a);
upmin(f[i][2], min(f[i - 1][2], f[i - 1][0]) + a);
if ((v[i] + 1) % p == 0 || (v[i] - 1) % p == 0) {
upmin(f[i][0], f[i - 1][0] + b), upmin(f[i][3], f[i - 1][2] + b);
upmin(f[i][3], f[i - 1][3] + b);
if (i != n) upmin(f[i][3], f[i - 1][1] + b);
}
}
long long ret = inf;
for (int i = 0, _ = 3; i <= _; i++) upmin(ret, f[n][i]);
return ret;
}
void solve() {
long long ans = inf;
for (int i = 1, _ = tot; i <= _; i++) {
upmin(ans, dp(fact[i]));
}
cout << ans << "\n";
}
int main() {
sieve();
input();
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a, b;
set<int> primes;
void func(int num) {
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
primes.insert(i);
while (num % i == 0) num /= i;
}
}
if (num != 1) primes.insert(num);
}
long long calc(vector<int> &A, int p) {
int si = -1, ei = -1;
vector<long long> val(n + 3, 0);
for (int i = 1; i <= n; i++) {
if (A[i] % p == 0) {
val[i] = 0;
} else {
if (((A[i] - 1) % p == 0) || (A[i] + 1) % p == 0) {
val[i] = b;
} else {
val[i] = -1;
si = i;
break;
}
}
}
for (int i = n; i >= 1; i--) {
if (A[i] % p == 0) {
val[i] = 0;
} else {
if (((A[i] - 1) % p == 0) || (A[i] + 1) % p == 0) {
val[i] = b;
} else {
val[i] = -1;
ei = i;
break;
}
}
}
if (si == -1) {
for (int i = 2; i <= n; i++) {
val[i] += val[i - 1];
}
vector<long long> arr(n + 3);
arr[1] = a;
long long v = min(val[n], a + val[n] - val[1]);
for (int i = 2; i <= n; i++) {
arr[i] = min(arr[i - 1], val[i - 1]) + a;
v = min(v, arr[i] + val[n] - val[i]);
}
return v;
} else {
for (int i = 2; i < si; i++) {
val[i] += val[i - 1];
}
for (int i = n - 1; i > ei; i--) {
val[i] += val[i + 1];
}
long long ans = a * (ei - si + 1);
long long v = min((si - 1) * a, val[si - 1]);
for (int i = si - 1; i >= 2; i--) {
v = min(v, a * (si - i) + val[i - 1]);
}
ans += v;
v = min(a * (n - ei), val[ei + 1]);
for (int i = ei + 1; i <= n; i++) {
v = min(v, a * (i - ei) + val[i + 1]);
}
ans += v;
return ans;
}
}
int main() {
cin >> n >> a >> b;
if (a == 0 || b == 0) {
cout << 0 << endl;
return 0;
}
vector<int> A(n + 1);
for (int i = 1; i <= n; i++) cin >> A[i];
func(A[1]);
func(A[1] + 1);
if (A[1] != 2) func(A[1] - 1);
func(A[n]);
func(A[n] + 1);
if (A[n] != 2) func(A[n] - 1);
vector<int> ps;
while (!primes.empty()) {
ps.push_back(*primes.begin());
primes.erase(primes.begin());
}
long long ans = (n - 1) * a;
for (int i = 0; i < ps.size(); i++) {
ans = min(ans, calc(A, ps[i]));
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000100;
int n, arr[MAX];
long long mem[MAX][3], a, b, ans = (1LL << 60);
vector<int> factorize(int num) {
vector<int> ret;
for (int i = 2; i <= num / i; i += 1 + (i & 1))
while (num % i == 0) ret.push_back(i), num /= i;
if (num > 1) ret.push_back(num);
return ret;
}
long long dp(int idx, int flag, int p) {
if (idx == n) return 0;
long long &ret = mem[idx][flag];
if (ret != -1) return ret;
if (arr[idx] % p == 0)
ret = dp(idx + 1, 2 * (flag != 0), p);
else if ((arr[idx] - 1) % p == 0 || (arr[idx] + 1) % p == 0)
ret = b + dp(idx + 1, 2 * (flag != 0), p);
else
ret = (1LL << 60);
if (flag < 2) ret = min(ret, a + dp(idx + 1, 1, p));
return ret;
}
int main() {
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> arr[i];
int f[6] = {arr[0], arr[0] - 1, arr[0] + 1,
arr[n - 1], arr[n - 1] - 1, arr[n - 1] + 1};
set<int> s;
for (int i = 0; i < 6; i++) {
vector<int> temp = factorize(f[i]);
s.insert(temp.begin(), temp.end());
}
for (int p : s) {
memset(mem, -1, (n + 1) * sizeof mem[0]);
ans = min(ans, dp(0, 0, p));
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
char c;
bool neg = false;
while (!isdigit(c = getchar()) && c != '-')
;
x = 0;
if (c == '-') {
neg = true;
c = getchar();
}
do {
x = x * 10 + c - '0';
} while (isdigit(c = getchar()));
if (neg) x = -x;
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x < 10) {
putchar(char(x + 48));
} else {
write(x / 10);
putchar(char(48 + x % 10));
}
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
int n, a[1000005], A, B;
long long res;
vector<int> P;
void pt(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
while (x % i == 0) x /= i;
P.push_back(i);
}
}
if (x > 1) P.push_back(x);
}
long long f[1000005][3];
void solve(int k) {
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= 2; ++j) f[i][j] = 1e16;
if (a[1] % k == 0)
f[1][0] = 0;
else if ((a[1] + 1) % k == 0 || (a[1] - 1) % k == 0)
f[1][0] = B;
f[1][1] = A;
f[1][2] = A;
for (int i = 2; i <= n; ++i) {
if (a[i] % k == 0)
f[i][0] = f[i - 1][0];
else if ((a[i] + 1) % k == 0 || (a[i] - 1) % k == 0)
f[i][0] = f[i - 1][0] + B;
f[i][1] = min(f[i - 1][1], f[i - 1][0]) + A;
if (a[i] % k == 0)
f[i][2] = min(f[i - 1][2], f[i - 1][1]);
else if ((a[i] - 1) % k == 0 || (a[i] + 1) % k == 0)
f[i][2] = min(f[i - 1][2], f[i - 1][1]) + B;
}
res = min(res, min(f[n][0], min(f[n][1], f[n][2])));
}
int main() {
cin.tie(0);
cout.tie(0);
read(n);
read(A);
read(B);
for (int i = 1; i <= n; ++i) read(a[i]);
res = 1e18;
pt(a[1]);
pt(a[1] + 1);
pt(a[1] - 1);
pt(a[n]);
pt(a[n] + 1);
pt(a[n] - 1);
sort(P.begin(), P.end());
solve(P[0]);
for (int i = 1; i < P.size(); ++i) {
if (P[i] == P[i - 1]) continue;
solve(P[i]);
}
write(res);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, *x;
long long a, b;
long long solve(int d) {
char* type = new char[n];
vector<int> pos;
for (int i = 0; i < n; i++) {
if (x[i] % d == 0)
type[i] = 0;
else if ((x[i] - 1) % d == 0 || (x[i] + 1) % d == 0)
type[i] = 1;
else
type[i] = 2;
if (type[i] > 0) pos.push_back(i);
}
if (pos.empty()) return 0;
if (pos.size() == 1) {
if (type[pos[0]] == 1)
return min(a, b);
else
return a;
}
long long dd = 0, dl = 0;
bool good = 1;
vector<long long> left;
left.resize(pos.size());
for (int i = 0; i < pos.size() - 1; i++) {
if (type[pos[i]] == 2) good = 0;
if (type[pos[i]] == 1 && good) dd += -(pos[i + 1] - pos[i]) * a + b;
dl = min(dl, dd);
left[i] = dl;
}
if (type[pos.back()] == 1 && good) {
dd += -a + b;
dl = min(dl, dd);
left[pos.size() - 1] = dl;
}
dd = 0;
long long dr = 0;
good = 1;
vector<long long> right;
right.resize(pos.size());
for (int i = pos.size() - 1; i > 0; i--) {
if (type[pos[i]] == 2) good = 0;
if (type[pos[i]] == 1 && good) dd += -(pos[i] - pos[i - 1]) * a + b;
dr = min(dr, dd);
right[i] = dr;
}
if (type[pos[0]] == 1 && good) {
dd += -a + b;
dr = min(dr, dd);
right[0] = dr;
}
long long cost = (pos.back() - pos[0] + 1) * a;
dd = min(0ll, right[1]);
right.push_back(0);
right.push_back(0);
for (int i = 0; i < pos.size(); i++) dd = min(dd, left[i] + right[i + 2]);
cost += dd;
delete[] type;
return cost;
}
int main() {
scanf("%d%I64d%I64d", &n, &a, &b);
x = new int[n];
for (int i = 0; i < n; i++) scanf("%d", x + i);
int y[6] = {x[0], x[0] - 1, x[0] + 1, x[n - 1], x[n - 1] - 1, x[n - 1] + 1};
long long pen[6] = {0, b, b, 0, b, b};
long long ssol = max(n * b, n * a) + 10;
int* x0 = x;
int n0 = n;
for (int i = 0; i < 6; i++) {
if (i == 1 || i == 2) {
n = n - 1;
x += 1;
} else if (i == 4 || i == 5) {
n = n - 1;
}
for (int d = 2; d * d <= y[i]; d++) {
if (y[i] % d == 0) ssol = min(ssol, solve(d) + pen[i]);
while (y[i] % d == 0) y[i] /= d;
}
if (y[i] > 1) ssol = min(ssol, solve(y[i]) + pen[i]);
n = n0;
x = x0;
}
printf("%I64d", ssol);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ii = pair<int, int>;
using vii = vector<ii>;
using l = long long;
using vl = vector<l>;
using vvl = vector<vl>;
using ll = pair<l, l>;
using vll = vector<ll>;
using vvll = vector<vll>;
using lu = unsigned long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
const int INF = numeric_limits<int>::max();
const double EPS = 1e-10;
const l e5 = 100000, e6 = 1000000, e7 = 10000000, e9 = 1000000000;
const l MAX_PRIME = 1000000;
vl sieve_primes() {
bitset<MAX_PRIME + 1> b;
vl primes;
primes.emplace_back(2);
for (l i = 3; i <= MAX_PRIME; i += 2) {
if (b[i]) continue;
primes.emplace_back(i);
for (l j = i * i; j <= MAX_PRIME; j += i) b.set(j);
}
return primes;
}
vl factorize_to_primes(vl& primes, l n) {
vl factors;
auto p = primes.begin();
while (p != primes.end() && (*p) * (*p) <= n) {
if (n % *p == 0) {
factors.emplace_back(*p);
while (n % *p == 0) n /= *p;
}
p++;
}
if (n != 1) factors.emplace_back(n);
return factors;
}
l penalty(l x, l p, l b) {
if (x == 0) return 0;
if (x == 1 || x == p - 1) return b;
return -1;
}
l cost(vl& v, l p, l a, l b) {
l sa = 0;
l remove_from = 0;
l best_sa = 0;
l total = 0;
for (l i = 1; i < v.size(); i++) {
l x = penalty(v[i] % p, p, b);
total += x;
if (x < 0) {
remove_from = i;
break;
}
sa += x - a;
best_sa = max(best_sa, sa);
sa = max(0LL, sa);
}
if (remove_from) {
l remove_to = 0;
for (l i = v.size() - 1; i >= remove_from; i--) {
l x = penalty(v[i] % p, p, b);
if (x < 0) {
remove_to = i;
break;
}
}
total = (remove_to - remove_from + 1) * a;
sa = 0;
l t = 0;
for (l i = remove_from - 1; i > 0; i--) {
l x = penalty(v[i] % p, p, b);
total += x;
sa += x - a;
t = max(sa, t);
}
total -= t;
sa = t = 0;
for (l i = remove_to + 1; i < v.size(); i++) {
l x = penalty(v[i] % p, p, b);
total += x;
sa += x - a;
t = max(sa, t);
}
total -= t;
} else {
total -= best_sa;
}
return total;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
l n, a, b;
auto primes = sieve_primes();
while (cin >> n >> a >> b) {
vl v(n);
l best_cost = (n - 1) * a;
for (l i = 0; i < n; i++) cin >> v[i];
for (l j = -1; j <= 1; j++) {
auto f = factorize_to_primes(primes, v[0] + j);
for (auto p : f) {
if (p == 1) continue;
best_cost = min(best_cost, cost(v, p, a, b) + (j == 0 ? 0 : b));
}
}
reverse(v.begin(), v.end());
for (l j = -1; j <= 1; j++) {
auto f = factorize_to_primes(primes, v[0] + j);
for (auto p : f) {
if (p == 1) continue;
best_cost = min(best_cost, cost(v, p, a, b) + (j == 0 ? 0 : b));
}
}
cout << best_cost << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const long long inf = 1e18;
int c[N];
long long dp[3][N];
vector<int> v;
int n;
long long a, b;
long long cal(int x) {
for (int i = 0; i < 3; i++) {
dp[i][0] = inf;
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
if (c[i] % x == 0) {
dp[0][i] = dp[0][i - 1];
dp[1][i] = min(dp[0][i - 1], dp[1][i - 1]) + a;
dp[2][i] = min(dp[1][i - 1], dp[2][i - 1]);
} else if ((c[i] - 1) % x == 0 || (c[i] + 1) % x == 0) {
dp[0][i] = dp[0][i - 1] + b;
dp[1][i] = min(dp[0][i - 1], dp[1][i - 1]) + a;
dp[2][i] = min(dp[1][i - 1], dp[2][i - 1]) + b;
} else {
dp[0][i] = inf;
dp[1][i] = min(dp[0][i - 1], dp[1][i - 1]) + a;
dp[2][i] = inf;
}
}
long long ans = inf;
for (int i = 0; i < 3; i++) {
ans = min(ans, dp[i][n]);
}
return ans;
}
long long f(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
v.push_back(i);
while (x % i == 0) {
x /= i;
}
}
}
long long ans = inf;
if (x != 1) v.push_back(x);
for (int i = 0; i < v.size(); i++) {
ans = min(ans, cal(v[i]));
}
return ans;
}
int main() {
scanf("%d%I64d%I64d", &n, &a, &b);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
long long ans = inf;
for (int i = c[1] - 1; i <= c[1] + 1; i++) {
ans = min(ans, f(i));
}
for (int i = c[n] - 1; i <= c[n] + 1; i++) ans = min(ans, f(i));
printf("%I64d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[1000100][3];
int val[1000100];
long long a, b;
int prime[1000100];
int vis[1000100];
int n, cnt, fac[1000100];
void init() {
for (int i = 2; i < 1000100; i++) {
if (!vis[i]) prime[cnt++] = i;
for (int j = 0; j < cnt && prime[j] * i < 1000100; j++) {
vis[prime[j] * i] = 1;
if (i % prime[j] == 0) break;
}
}
}
long long solve(int st, int ed, int v) {
memset(dp, 0x3f3f3f3f3f3f3f3f, sizeof(dp));
dp[st - 1][0] = 0;
for (int i = st; i <= ed; i++) {
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
if (val[i] % v != 0) {
if ((val[i] + 1) % v == 0 || (val[i] - 1) % v == 0) {
dp[i][0] = dp[i - 1][0] + b;
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + b;
}
} else {
dp[i][0] = dp[i - 1][0];
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]);
}
}
return min(min(dp[ed][0], dp[ed][1]), dp[ed][2]);
}
int factor(int x) {
int tot = 0;
for (int j = 0; j < cnt && x >= prime[j]; j++) {
if (x % prime[j] == 0) {
fac[tot++] = prime[j];
while (x % prime[j] == 0) x /= prime[j];
}
}
if (x != 1) fac[tot++] = x;
return tot;
}
int main() {
int t, C = 1;
init();
while (scanf("%d%lld%lld", &n, &a, &b) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
long long ans = a * (long long)n;
for (int i = -1; i <= 1; i++) {
long long cost = i == 0 ? 0 : b;
int len = factor(val[n] + i);
for (int j = 0; j < len; j++)
ans = min(ans, solve(1, n - 1, fac[j]) + cost);
len = factor(val[1] + i);
for (int j = 0; j < len; j++) ans = min(ans, solve(2, n, fac[j]) + cost);
}
printf("%lld\n", ans);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 3;
const long long inf = 1e15;
long long v[nmax], k, t[93], n, a, b, d[nmax][3], sol, p;
void divizor(long long usu) {
for (long long i = 2; i * i <= usu; ++i) {
if (usu % i == 0) {
t[++k] = i;
while (usu % i == 0) usu /= i;
}
}
if (usu > 1) t[++k] = usu;
}
void clean() {
for (int i = 1; i <= n; ++i) {
d[i][0] = inf;
d[i][1] = inf;
d[i][2] = inf;
}
}
void solve() {
divizor(v[1]);
divizor(v[1] - 1);
divizor(v[1] + 1);
divizor(v[n]);
divizor(v[n] - 1);
divizor(v[n] + 1);
sort(t + 1, t + k + 1);
sol = inf;
for (int i = 1; i <= k; ++i) {
clean();
if (t[i] == t[i - 1]) continue;
p = t[i];
for (int j = 1; j <= n; ++j) {
if (v[j] % p == 0) {
d[j][0] = d[j - 1][0];
d[j][1] = min(d[j - 1][0] + a, d[j - 1][1] + a);
d[j][2] = min(d[j - 1][1], d[j - 1][2]);
continue;
}
if ((v[j] - 1) % p == 0 || (v[j] + 1) % p == 0) {
d[j][0] = d[j - 1][0] + b;
d[j][1] = min(d[j - 1][0] + a, d[j - 1][1] + a);
d[j][2] = min(d[j - 1][1] + b, d[j - 1][2] + b);
continue;
}
d[j][1] = min(d[j - 1][0] + a, d[j - 1][1] + a);
}
sol = min(min(sol, d[n][0]), min(d[n][1], d[n][2]));
}
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; ++i) cin >> v[i];
solve();
cout << sol;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const long long inf = 1000000000000000000LL;
int a[N];
long long prefix_cost[N], cost[N], suffix_cost[N];
set<int> factors;
set<int>::iterator it;
void pf(int x) {
for (int j = x - 1; j <= x + 1; j++) {
int d = j;
for (int i = 2; i * i <= j; i++) {
if (d % i == 0) {
factors.insert(i);
while (d % i == 0) d /= i;
}
}
if (d != 1) factors.insert(d);
}
}
int main() {
int n, p, A, B;
scanf("%d %d %d", &n, &A, &B);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n == 1) {
printf("0\n");
return 0;
}
pf(a[1]);
pf(a[n]);
long long ans = inf;
for (it = factors.begin(); it != factors.end(); ++it) {
prefix_cost[0] = 0LL;
p = *it;
for (int i = 1; i <= n; i++) {
if (a[i] % p == 0)
cost[i] = 0LL;
else if ((a[i] + 1) % p == 0 || (a[i] - 1) % p == 0)
cost[i] = (long long)B;
else
cost[i] = inf;
prefix_cost[i] = prefix_cost[i - 1] + cost[i];
if (prefix_cost[i] > inf) prefix_cost[i] = inf;
}
prefix_cost[0] = inf;
suffix_cost[n + 1] = 0LL;
long long suffix_sum = 0LL;
for (int i = n; i > 0; i--) {
suffix_sum += cost[i];
if (suffix_sum > inf) suffix_sum = inf;
suffix_cost[i] = min(A + suffix_cost[i + 1], suffix_sum);
}
ans = min(ans, suffix_cost[1]);
for (int i = 2; i <= n; i++)
ans = min(ans, prefix_cost[i - 1] + suffix_cost[i]);
}
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a, b;
set<int> trobat;
vector<int> divisors;
void divisor(int n) {
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
if (not trobat.count(i)) {
divisors.push_back(i);
trobat.insert(i);
}
n /= i;
} else
i++;
}
if (n != 1 and not trobat.count(n)) {
divisors.push_back(n);
trobat.insert(n);
}
}
int main() {
int n;
cin >> n >> a >> b;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
divisor(v[0] + 1);
divisor(v[0] - 1);
divisor(v[0]);
divisor(v[n - 1]);
divisor(v[n - 1] + 1);
divisor(v[n - 1] - 1);
long long int m = 10000000000000000;
int primer;
vector<vector<long long int> > dp(n, vector<long long int>(3, -1));
for (int i = 0; i < divisors.size(); i++) {
primer = divisors[i];
if (v[0] % primer == 0) {
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
} else if ((v[0] + 1) % primer == 0 or (v[0] - 1) % primer == 0) {
dp[0][0] = min(a, b);
dp[0][1] = min(a, b);
dp[0][2] = b;
} else {
dp[0][0] = a;
dp[0][1] = a;
dp[0][2] = 10000000000000000;
}
for (int k = 1; k < n; k++) {
for (int j = 0; j < 3; j++) {
if (j == 0) {
if (v[k] % primer == 0) {
dp[k][0] = dp[k - 1][0];
} else if ((v[k] + 1) % primer == 0 or (v[k] - 1) % primer == 0) {
dp[k][0] = min(b + dp[k - 1][0], a + dp[k - 1][1]);
} else
dp[k][0] = a + dp[k - 1][1];
}
if (j == 1) {
if (v[k] % primer == 0) {
dp[k][1] = min(a + dp[k - 1][1], dp[k - 1][2]);
} else if ((v[k] + 1) % primer == 0 or (v[k] - 1) % primer == 0) {
dp[k][1] = min(b + dp[k - 1][2], a + dp[k - 1][1]);
} else
dp[k][1] = a + dp[k - 1][1];
}
if (j == 2) {
if (v[k] % primer == 0) {
dp[k][2] = dp[k - 1][2];
} else if ((v[k] + 1) % primer == 0 or (v[k] - 1) % primer == 0) {
dp[k][2] = b + dp[k - 1][2];
} else
dp[k][2] = 10000000000000000;
}
}
}
m = min(m, dp[n - 1][0]);
}
cout << m << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const long long INF = 1e17;
vector<int> div1[3], divn[3];
long long n, t[N], a, b;
long long dp[N][2][3];
vector<int> divisor(int x) {
int i = 2;
vector<int> ans;
while (i * i <= x) {
if (x % i == 0) {
ans.push_back(i);
while (x % i == 0) x /= i;
}
i++;
}
if (x != 1) ans.push_back(x);
return ans;
}
void Init() {
div1[0] = divisor(t[1] - 1);
div1[1] = divisor(t[1]);
div1[2] = divisor(t[1] + 1);
divn[0] = divisor(t[n] - 1);
divn[1] = divisor(t[n]);
divn[2] = divisor(t[n] + 1);
}
long long Solve(int div, int cp) {
for (int k = 1; k <= n; k++)
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 2; j++) dp[k][i][j] = INF;
dp[1][0][0] = 0;
for (int i = 2; i <= n; i++)
for (int j = 0; j <= 1; j++) {
if (t[i] % div)
dp[i][j][0] = INF;
else
dp[i][j][0] =
min(dp[i - 1][j][1], min(dp[i - 1][j][0], dp[i - 1][j][2]));
if ((t[i] + 1) % div == 0 || (t[i] - 1) % div == 0)
dp[i][j][1] =
b + min(dp[i - 1][j][0], min(dp[i - 1][j][1], dp[i - 1][j][2]));
if (j == 0)
dp[i][j][2] = INF;
else
dp[i][j][2] = a + min(min(dp[i - 1][j - 1][0], dp[i - 1][j - 1][1]),
dp[i - 1][j][2]);
}
long long ans = INF;
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 2; j++) ans = min(ans, dp[n][i][j]);
ans += cp;
return ans;
}
long long Solve2(int div, int cp) {
for (int k = 1; k <= n; k++)
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 2; j++) dp[k][i][j] = INF;
dp[0][0][0] = 0;
for (int i = 1; i <= n - 1; i++)
for (int j = 0; j <= 1; j++) {
if (t[i] % div)
dp[i][j][0] = INF;
else
dp[i][j][0] =
min(dp[i - 1][j][1], min(dp[i - 1][j][0], dp[i - 1][j][2]));
if ((t[i] + 1) % div == 0 || (t[i] - 1) % div == 0)
dp[i][j][1] =
b + min(dp[i - 1][j][0], min(dp[i - 1][j][1], dp[i - 1][j][2]));
if (j == 0)
dp[i][j][2] = INF;
else
dp[i][j][2] = a + min(min(dp[i - 1][j - 1][0], dp[i - 1][j - 1][1]),
dp[i - 1][j][2]);
}
long long ans = INF;
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 2; j++) ans = min(ans, dp[n - 1][i][j]);
ans += cp;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) cin >> t[i];
Init();
long long res = INF;
for (int i = 0; i <= 2; i++) {
int cp;
if (i == 1)
cp = 0;
else
cp = b;
for (int j = 0; j < div1[i].size(); j++)
res = min(res, Solve(div1[i][j], cp));
}
for (int i = 0; i <= 2; i++) {
int cp;
if (i == 1)
cp = 0;
else
cp = b;
for (int j = 0; j < divn[i].size(); j++)
res = min(res, Solve2(divn[i][j], cp));
}
cout << res;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e6 + 9, INF = 1e16;
long long arr[MX], dp[MX][3];
set<long long> s;
void FUN(long long x) {
if (x == 2) return;
for (long long i = 2; i * i <= x; i++)
while (x > 1 && x % i == 0) x /= i, s.insert(i);
if (x > 1) s.insert(x);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, a, b;
cin >> n >> a >> b;
for (long long i = 0; i < n; i++) cin >> arr[i];
FUN(arr[0] + 1);
FUN(arr[0]);
FUN(arr[0] - 1);
FUN(arr[n - 1] + 1);
FUN(arr[n - 1]);
FUN(arr[n - 1] - 1);
long long minn = 1e18;
for (long long x : s) {
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (long long i = 1; i <= n; i++) {
if (arr[i - 1] % x == 0 || arr[i - 1] % x == 1 ||
arr[i - 1] % x == x - 1) {
dp[i][0] = dp[i - 1][0] + b * (arr[i - 1] % x != 0);
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + b * (arr[i - 1] % x != 0);
} else {
dp[i][0] = dp[i][2] = INF;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
}
dp[i][0] = min(INF, dp[i][0]), dp[i][1] = min(INF, dp[i][1]),
dp[i][2] = min(INF, dp[i][2]);
}
minn = min(min(minn, dp[n][0]), min(dp[n][1], dp[n][2]));
}
cout << minn;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, arr[1000006 + 10];
long long dp[1000006][3], ans = (1ll << 60);
void solve(int p) {
dp[0][0] = arr[0] % p == 0 ? 0 : b;
dp[0][1] = (1ll << 60);
dp[0][2] = dp[0][0];
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i][1] = dp[i][2] = (1ll << 60);
for (int j = -1; j <= 1; j++) {
if ((arr[i] + j) % p == 0) {
if (j == 0) {
dp[i][0] = min(dp[i][0], dp[i - 1][0]);
dp[i][2] = min(dp[i][2], min(dp[i - 1][2], dp[i - 1][1]));
} else {
dp[i][0] = min(dp[i][0], dp[i - 1][0] + b);
dp[i][2] = min(dp[i][2], min(dp[i - 1][2] + b, dp[i - 1][1] + b));
}
}
}
dp[i][1] = min(dp[i][1], min(dp[i - 1][0] + a, dp[i - 1][1] + a));
}
ans = min(ans, min(dp[n - 1][0], min(dp[n - 1][1], dp[n - 1][2])));
}
int main() {
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> arr[i];
set<int> st;
for (int i = -1; i <= 1; i++) {
int num = arr[0] + i;
for (int j = 2; j * j <= num; j++) {
if (num % j == 0) {
st.insert(j);
while (num % j == 0) num /= j;
}
}
if (num > 1) st.insert(num);
}
set<int>::iterator it;
for (it = st.begin(); it != st.end(); it++) solve(*it);
reverse(arr, arr + n);
st.clear();
for (int i = -1; i <= 1; i++) {
int num = arr[0] + i;
for (int j = 2; j * j <= num; j++) {
if (num % j == 0) {
st.insert(j);
while (num % j == 0) num /= j;
}
}
if (num > 1) st.insert(num);
}
for (it = st.begin(); it != st.end(); it++) solve(*it);
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long INF = 1e16;
int abs(int x) { return x > 0 ? x : -x; }
void primeDiv(int a, vector<int>& p) {
p.clear();
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) {
p.push_back(i);
while (a % i == 0) a /= i;
}
}
if (a > 1) p.push_back(a);
}
int n, a[N];
long long x, y, dp[N][3];
bool check(int x, int p) {
bool ok = false;
for (int d = -1; d <= 1; ++d) ok |= ((x + d) % p == 0);
return ok;
}
long long solve(int p) {
for (int i = 0; i < 3; ++i) dp[0][i] = 0;
for (int i = 1; i <= n; ++i) {
dp[i][1] = min(dp[i - 1][1], dp[i - 1][0]) + x;
if (!check(a[i - 1], p))
dp[i][0] = dp[i][2] = INF;
else {
dp[i][0] = dp[i - 1][0] + y * (a[i - 1] % p != 0);
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + y * (a[i - 1] % p != 0);
}
}
long long res = INF;
for (int i = 0; i < 3; ++i) res = min(res, dp[n][i]);
return res;
}
int main() {
scanf("%d%I64d%I64d", &n, &x, &y);
for (int* it = a; it < a + n; ++it) scanf("%d", it);
long long ans = INF;
vector<int> prime;
for (int d = -1; d <= 1; ++d) {
primeDiv(a[0] + d, prime);
for (int p : prime) ans = min(ans, solve(p));
}
for (int d = -1; d <= 1; ++d) {
primeDiv(a[n - 1] + d, prime);
for (int p : prime) ans = min(ans, solve(p));
}
printf("%I64d", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename C, typename T = decay<decltype(*begin(declval<C>()))>,
typename enable_if<!is_same<C, string>::value>::type * = nullptr>
ostream &operator<<(ostream &os, const C &c) {
bool f = true;
os << "[";
for (const auto &x : c) {
if (!f) os << ", ";
f = false;
os << x;
}
return os << "]";
}
template <typename T>
void debug(string s, T x) {
cerr << s << " = " << x << "\n";
}
template <typename T, typename... Args>
void debug(string s, T x, Args... args) {
cerr << s.substr(0, s.find(',')) << " = " << x << " | ";
debug(s.substr(s.find(',') + 2), args...);
}
const long long INF = 2e18;
int c[1000005];
long long dp[1000005][3];
unordered_set<int> st;
void factor(int x) {
for (int i = 2; 1LL * i * i <= x; i++)
if (x % i == 0) {
st.insert(i);
while (x % i == 0) x /= i;
}
if (x > 1) st.insert(x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> c[i];
factor(c[0] - 1);
factor(c[0]);
factor(c[0] + 1);
factor(c[n - 1] - 1);
factor(c[n - 1]);
factor(c[n - 1] + 1);
long long ret = LLONG_MAX;
for (int p : st) {
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1][1] = min(dp[i][0], dp[i][1]) + a;
if (c[i] % p == 0) {
dp[i + 1][0] = dp[i][0];
dp[i + 1][2] = min(dp[i][1], dp[i][2]);
} else if ((c[i] - 1) % p == 0 || (c[i] + 1) % p == 0) {
dp[i + 1][0] = dp[i][0] + b;
dp[i + 1][2] = min(dp[i][1], dp[i][2]) + b;
} else {
dp[i + 1][0] = dp[i + 1][2] = INF;
}
}
ret = min({ret, dp[n][0], dp[n][1], dp[n][2]});
}
cout << ret << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 1000;
int n, x, y;
int a[maxn];
vector<int> prime;
bool l1[maxn], r1[maxn];
int l2[maxn], r2[maxn];
const long long inf = (long long)1e18;
void factor(int x) {
int v = x;
for (int i = 2; 1ll * i * i <= x; i++)
if (v % i == 0) {
prime.push_back(i);
while (v % i == 0) v /= i;
}
if (v > 1) prime.push_back(v);
}
int main() {
scanf("%d%d%d", &n, &x, &y);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
prime.clear();
factor(a[1]);
factor(a[1] - 1);
factor(a[1] + 1);
factor(a[n]);
factor(a[n] + 1);
factor(a[n] - 1);
sort(prime.begin(), prime.end());
long long ans = inf;
for (int t = 0; t < (int)prime.size(); t++)
if (t == 0 || prime[t] != prime[t - 1]) {
int g = prime[t];
l1[0] = 1;
l2[0] = 0;
for (int i = 1; i <= n; i++) {
l1[i] =
l1[i - 1] && (a[i] % g == 0 || a[i] % g == g - 1 || a[i] % g == 1);
l2[i] = l2[i - 1] + (a[i] % g == 0 ? 0 : 1);
}
r1[n + 1] = 1;
r2[n + 1] = 0;
for (int i = n; i > 0; i--) {
r1[i] =
r1[i + 1] && (a[i] % g == 0 || a[i] % g == g - 1 || a[i] % g == 1);
r2[i] = r2[i + 1] + (a[i] % g == 0 ? 0 : 1);
}
long long cur = inf;
if (l1[n]) cur = min(cur, 1ll * l2[n] * y);
long long lft = inf;
for (int j = 1; j <= n; j++) {
if (j >= 2 && l1[j - 1])
lft = min(lft, 1ll * l2[j - 1] * y - 1ll * x * j);
if (r1[j + 1])
cur = min(cur, lft + 1ll * (j + 1) * x + 1ll * r2[j + 1] * y);
}
for (int j = 1; j < n; j++) {
if (r1[j + 1]) cur = min(cur, 1ll * r2[j + 1] * y + 1ll * j * x);
}
ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const double EPS = 1e-10;
double zero(double d) { return d < EPS ? 0.0 : d; }
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
for (int i = 0; i < (int)(a.size()); i++) os << (i ? " " : "") << a[i];
return os << ']';
}
string toString(int i) {
stringstream ss;
ss << i;
return ss.str();
}
const int MOD = 1000000007;
long long fpow(long long a, long long k, int M) {
long long res = 1ll;
long long x = a;
while (k != 0) {
if ((k & 1) == 1) res = (res * x) % M;
x = (x * x) % M;
k >>= 1;
}
return res;
}
struct prepare {
prepare() {
cout.setf(ios::fixed, ios::floatfield);
cout.precision(8);
ios_base::sync_with_stdio(false);
}
} _prepare;
set<int> enumPrimeFactors(int a) {
set<int> ans;
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
ans.insert(i);
a /= i;
}
}
if (a != 1) ans.insert(a);
return ans;
}
int main() {
const long long INF = (1ll << 60);
int n, a, b;
cin >> n >> a >> b;
vector<int> nums(n);
for (int i = 0; i < (int)(n); i++) cin >> nums[i];
set<int> factors;
for (int i = -1; i < (int)(1 + 1); i++) {
set<int> tmp = enumPrimeFactors(nums[0] + i);
set<int> tmp2 = enumPrimeFactors(nums[n - 1] + i);
factors.insert(((tmp).begin()), ((tmp).end()));
factors.insert(((tmp2).begin()), ((tmp2).end()));
}
long long ans = INF;
vector<vector<long long> > dp(n + 1, vector<long long>(3, INF));
for (__typeof((factors).begin()) fact = (factors).begin();
fact != (factors).end(); fact++) {
for (int i = 0; i < (int)(n + 1); i++)
fill(((dp[i]).begin()), ((dp[i]).end()), INF);
dp[0][0] = 0;
for (int i = 0; i < (int)(n); i++) {
for (int j = -1; j < (int)(1 + 1); j++) {
if ((nums[i] + j) % (*fact) == 0) {
chmin(dp[i + 1][0], dp[i][0] + (long long)b * abs(j));
chmin(dp[i + 1][2], dp[i][1] + (long long)b * abs(j));
chmin(dp[i + 1][2], dp[i][2] + (long long)b * abs(j));
}
}
chmin(dp[i + 1][1], dp[i][0] + a);
chmin(dp[i + 1][1], dp[i][1] + a);
}
for (int i = 0; i < (int)(3); i++) chmin(ans, dp[n][i]);
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1ll << 60);
int n, a, b;
int aa[1000011];
long long p1[1000011], p2[1000011];
int vec[1000011] = {}, num = 0;
bool vis[1000011] = {};
void getprime(int q) {
for (int i = 2; i * i <= q; i++) {
if (q % i != 0) continue;
while (q % i == 0) q = q / i;
if (vis[i] == true) continue;
vis[i] = true;
num++;
vec[num] = i;
}
if (q != 1) {
num++;
vec[num] = q;
}
}
long long solve(int k) {
long long ans = inf;
for (int i = 1; i <= n; i++) {
p1[i] = p2[i] = inf;
}
p1[0] = p2[n + 1] = 0;
for (int i = 1; i <= n; i++) {
if (aa[i] % k == 0)
p1[i] = p1[i - 1];
else if ((aa[i] + 1) % k == 0 || (aa[i] - 1) % k == 0)
p1[i] = p1[i - 1] + b;
}
for (int i = n; i >= 1; i--) {
if (aa[i] % k == 0)
p2[i] = p2[i + 1];
else if ((aa[i] + 1) % k == 0 || (aa[i] - 1) % k == 0)
p2[i] = p2[i + 1] + b;
}
long long mv = -a;
for (int i = 1; i <= n; i++) {
ans = min(ans, p2[i] + (long long)i * a + mv);
mv = min(mv, p1[i] - (long long)(i + 1) * a);
}
for (int i = 1; i <= n; i++) {
ans = min(ans, p1[i] + (long long)(n - i) * a);
}
return ans;
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) {
scanf("%d", &aa[i]);
}
getprime(aa[1]);
getprime(aa[1] + 1);
getprime(aa[1] - 1);
getprime(aa[n]);
getprime(aa[n] + 1);
getprime(aa[n] - 1);
long long ans = inf;
for (int i = 1; i <= num; i++) {
ans = min(ans, solve(vec[i]));
}
cout << ans;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e9 + 9;
const int N = 1e6 + 10;
int n;
long long ans, a, b;
long long f[N];
vector<long long> p;
map<long long, bool> use;
int type[N];
int s[N];
void getp(long long x) {
while (!(x & 1LL)) x >>= 1LL;
for (long long i = 3; i * i <= x; i += 2)
if (x % i == 0) {
do {
x /= i;
} while (x % i == 0);
if (!use[i]) {
use[i] = true;
p.push_back(i);
}
}
if (x > 2 && !use[x]) {
use[x] = true;
p.push_back(x);
}
}
void init() {
scanf("%d %I64d %I64d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%I64d", &f[i]);
p.push_back(2);
use[2] = true;
ans = (n - 1LL) * a;
for (long long i = -1; i <= 1; i++) {
if (f[1] + i > 1) getp(f[1] + i);
if (f[n] + i > 1) getp(f[n] + i);
}
}
void getans(long long p0) {
int l = 1, r = 0;
long long s0, s1, s2, mp;
s[0] = 0;
for (int i = 1; i <= n; i++) {
mp = f[i] % p0;
if (mp == 0)
type[i] = 0;
else if (mp == p0 - 1 || mp == 1)
type[i] = 1;
else {
l = (r == 0) ? i : l;
r = i;
type[i] = 0;
}
s[i] = s[i - 1] + type[i];
}
if (l <= r) {
s0 = a * (r - l + 1LL);
s1 = a * (l - 1);
s2 = a * (n - r);
for (long long i = 1; i < l; i++) s1 = min(s1, s[i] * b + (l - i - 1) * a);
for (long long i = n; i > r; i--)
s2 = min(s2, (s[n] - s[i - 1]) * b + (i - r - 1) * a);
} else {
long long dp = 0;
s1 = s2 = 0, s0 = a * (n - 1LL);
for (long long i = 1; i <= n; i++) {
dp = min(s[i] * b, dp + a);
s0 = min(s0, dp + (s[n] - s[i]) * b);
}
}
ans = min(ans, s0 + s1 + s2);
}
void work() {
for (int i = 0; i < p.size(); i++) getans(p[i]);
printf("%I64d\n", ans);
}
int main() {
init();
work();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
const long long Max = 1e16;
int n, A[maxn + 1], a, b;
vector<int> B;
long long Dp[maxn + 1][4], ans;
void Init(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) B.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) B.push_back(x);
}
void DP(int x) {
for (int i = 1; i <= n; i++) {
long long val = 1e16;
if (A[i] % x == 0) val = 0;
if ((A[i] + 1) % x == 0 || (A[i] - 1) % x == 0) val = b;
Dp[i][1] = min(Dp[i - 1][1] + val, Max);
Dp[i][2] = min(Max, min(Dp[i - 1][1], Dp[i - 1][2]) + a);
Dp[i][3] =
min(Max, min(Dp[i - 1][1], min(Dp[i - 1][2], Dp[i - 1][3])) + val);
}
ans = min(ans, min(Dp[n][1], min(Dp[n][2], Dp[n][3])));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = -1; i <= 1; i++) Init(A[1] + i), Init(A[n] + i);
sort(B.begin(), B.end());
B.erase(unique(B.begin(), B.end()), B.end());
ans = Max;
for (int i = 0; i < B.size(); i++) DP(B[i]);
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int SQN = 31630;
const int MAXN = 1e6 + 1;
vector<int> prosti_brojevi;
bool prost[SQN];
const long long inf = (long long)1e17;
long long n, A, B;
long long minV = inf;
int niz[MAXN];
long long dp[MAXN][3];
void solve() {
for (int k = 0; k < prosti_brojevi.size(); k++) {
long long cp = prosti_brojevi[k];
long long delta;
if (niz[0] % cp == 0)
delta = 0;
else if ((niz[0] - 1) % cp == 0 || (niz[0] + 1) % cp == 0)
delta = B;
else
delta = inf;
dp[0][0] = delta;
dp[0][2] = dp[0][1] = A;
for (int i = 1; i < n; i++) {
if (niz[i] % cp == 0)
delta = 0;
else if ((niz[i] - 1) % cp == 0 || (niz[i] + 1) % cp == 0)
delta = B;
else
delta = inf;
dp[i][0] = dp[i - 1][0] + delta;
dp[i][1] = min(dp[i - 1][1] + delta, dp[i - 1][2] + delta);
dp[i][2] = min(dp[i - 1][0] + A, dp[i - 1][2] + A);
dp[i][0] = min(dp[i][0], inf);
dp[i][1] = min(dp[i][1], inf);
dp[i][2] = min(dp[i][2], inf);
}
minV = min(minV, min(dp[n - 1][0], min(dp[n - 1][1], dp[n - 1][2])));
}
}
set<long long> brojiproste;
void generatePrimes() {
for (int i = 0; i < SQN; i++) prost[i] = true;
prost[0] = prost[1] = false;
for (int i = 2; i < SQN; i++) {
if (!prost[i]) continue;
for (int j = i * 2; j < SQN; j += i) prost[j] = false;
}
long long mogucnosti[] = {niz[0], niz[0] + 1, niz[0] - 1,
niz[n - 1], niz[n - 1] + 1, niz[n - 1] - 1};
for (int i = 0; i < 6; i++) {
for (int j = 2; j < SQN; j++) {
if (!prost[j]) continue;
if (mogucnosti[i] % j == 0) brojiproste.insert(j);
while (mogucnosti[i] % j == 0) {
mogucnosti[i] /= j;
}
}
if (mogucnosti[i] > 1) brojiproste.insert(mogucnosti[i]);
}
for (set<long long>::iterator iter = brojiproste.begin();
iter != brojiproste.end(); iter++) {
prosti_brojevi.push_back(*iter);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> A >> B;
for (int i = 0; i < n; i++) cin >> niz[i];
generatePrimes();
solve();
cout << minV << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, A, B;
int a[1000010];
bool vis[1000010];
vector<int> p;
void init() {
for (int i = 2; i < 40000; i++) {
if (vis[i]) continue;
int x = i * 2;
while (x < 40000) {
vis[x] = true;
x += i;
}
}
for (int i = 2; i < 40000; i++) {
if (!vis[i]) p.push_back(i);
}
}
long long dp[1000010][3];
long long getcost(int x, int y) {
long long inf = (long long)n * (1e9);
if (x % y == 0) return 0;
if ((x + 1) % y == 0 || (x - 1) % y == 0) return B;
return inf;
}
long long solve(int prime) {
long long inf = (long long)n * (1e9);
dp[1][0] = getcost(a[1], prime);
dp[1][1] = A;
dp[1][2] = inf;
for (int i = 2; i <= n; i++) {
dp[i][0] = min(inf, getcost(a[i], prime) + dp[i - 1][0]);
dp[i][1] = min(inf, min(dp[i - 1][0], dp[i - 1][1]) + A);
dp[i][2] = min(inf, min(dp[i - 1][2], dp[i - 1][1]) + getcost(a[i], prime));
}
return min(dp[n][0], min(dp[n][1], dp[n][2]));
}
int main() {
init();
scanf("%d%d%d", &n, &A, &B);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
int op[6] = {0, -1, 1, 0, -1, 1};
int num[6] = {a[1], a[1], a[1], a[n], a[n], a[n]};
long long ans = -1;
for (int i = 0; i < 6; i++) {
int x = op[i] + num[i], len = p.size();
for (int j = 0; j < len; j++) {
if (x == 1) break;
if (x % p[j] == 0) {
while (x % p[j] == 0) x /= p[j];
long long tmp = solve(p[j]);
if (ans == -1 || ans > tmp) ans = tmp;
}
}
if (x != 1) {
long long tmp = solve(x);
if (ans == -1 || ans > tmp) ans = tmp;
}
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e6 + 3;
set<int> p;
void f(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
do x /= i;
while (x % i == 0);
p.insert(i);
}
if (x != 1) p.insert(x);
}
int n;
long long a, b;
int arr[MAXN];
long long solve(int g) {
static long long s[MAXN];
memset(s, 0, sizeof(s));
int ll = -1, rr = 0;
int cntb = 0;
for (int i = 0; i < n; i++) {
int x = arr[i];
if (x % g == 0) continue;
if ((x + 1) % g == 0 || (x - 1) % g == 0) {
s[i] = 1;
cntb++;
} else {
s[i] = 2;
if (ll == -1) ll = i;
rr = i;
}
}
if (ll == -1) {
for (int i = 1; i < n; i++) s[i] += s[i - 1];
long long reduce = 0;
long long trace = -a;
int j = -1;
for (int i = 0; i < n; i++) {
long long _trace = b * s[i] - a * i;
long long score = _trace + trace;
if (score > reduce) {
reduce = score;
rr = i;
ll = j + 1;
}
_trace = -_trace;
if (_trace > trace) {
trace = _trace;
j = i;
}
}
for (int i = n - 1; i > 0; i--) s[i] -= s[i - 1];
} else {
long long reduce = 0;
int cnt = 0, tll = ll;
for (int i = ll - 1; i >= 0; i--)
if (s[i]) {
cnt++;
long long t = (long long)cnt * b - (long long)(ll - i) * a;
if (t > reduce) {
reduce = t;
tll = i;
}
}
ll = tll;
cnt = 0;
reduce = 0;
int trr = rr;
for (int i = rr + 1; i < n; i++)
if (s[i]) {
cnt++;
long long t = (long long)cnt * b - (long long)(i - rr) * a;
if (t > reduce) {
reduce = t;
trr = i;
}
}
rr = trr;
}
long long ret = 0;
if (ll != -1) {
for (int i = 0; i < ll; i++)
if (s[i]) ret += b;
for (int i = rr + 1; i < n; i++)
if (s[i]) ret += b;
ret += (long long)(rr - ll + 1) * a;
if (ll == 0 && rr == n - 1) ret += b - a;
} else
for (int i = 0; i < n; i++)
if (s[i]) ret += b;
return ret;
}
int main() {
cin >> n >> a >> b;
for (int i = 0; i < n; i++) scanf("%d", arr + i);
for (int i = -1; i <= 1; i++) {
f(arr[0] + i);
f(arr[n - 1] + i);
}
long long ans = -1;
for (set<int>::iterator iter = p.begin(); iter != p.end(); iter++) {
long long temp = solve(*iter);
if (ans == -1 || temp < ans) ans = temp;
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void addp(int a, vector<int>& P) {
int x = a;
for (int p = 2; p * p <= a; p++) {
if (x % p == 0) {
P.push_back(p);
while (x % p == 0) x = x / p;
}
}
if (x > 1) {
P.push_back(x);
}
}
int main() {
int n;
scanf("%d", &n);
long long a, b;
scanf("%I64d %I64d", &a, &b);
if (n == 1) {
printf("0");
return 0;
}
vector<int> A(n);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
vector<int> P;
for (int i = -1; i < 2; i++) {
addp(A[0] + i, P);
addp(A[n - 1] + i, P);
}
sort(P.begin(), P.end());
P.erase(unique(P.begin(), P.end()), P.end());
long long INF = 1e18;
long long ans = INF;
for (int p : P) {
vector<long long> C(n);
for (int i = 0; i < n; i++) {
if (A[i] % p == 0)
C[i] = 0;
else if ((A[i] + 1) % p == 0 || (A[i] - 1) % p == 0)
C[i] = b;
else
C[i] = -1;
}
vector<pair<int, long long> > dp(n);
long long sall = 0;
int numx = 0;
for (int i = 0; i < n; i++) (C[i] == -1) ? numx++ : sall += C[i];
dp[0] = {numx, sall};
if (C[0] < 0) {
dp[0] = {numx - 1, sall + a};
} else
dp[0] = min(dp[0], {numx, sall - C[0] + a});
long long cur = INF;
if (dp[0].first == 0) cur = dp[0].second;
for (int i = 1; i < n; i++) {
dp[i] = {numx, sall};
if (C[i] < 0) {
dp[i] = {numx - 1, sall + a};
} else
dp[i] = min(dp[i], {numx, sall + a - C[i]});
int x = dp[i - 1].first;
long long y = dp[i - 1].second;
if (C[i] < 0) {
dp[i] = min(dp[i], {x - 1, y + a});
} else
dp[i] = min(dp[i], {x, y + a - C[i]});
if (dp[i].first == 0) cur = min(cur, dp[i].second);
}
ans = min(ans, cur);
}
printf("%I64d", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e15 + 1;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
long long n, f[maxn][3], a, b, s[maxn], res(+oo);
void Check(int x, int w) {
f[1][0] = f[1][1] = f[1][2] = w;
for (int i = 2; i <= n; ++i) {
f[i][0] = f[i - 1][0];
f[i][2] = f[i - 1][2];
if (s[i] % x != 0) {
if ((s[i] - 1) % x == 0 || (s[i] + 1) % x == 0)
f[i][0] += b, f[i][2] += b;
else
f[i][0] = +oo, f[i][2] = +oo;
}
f[i][1] = min(f[i - 1][1], f[i - 1][0]) + a;
f[i][2] = min(f[i][2], f[i][1]);
}
res = min(res, min(f[n][0], min(f[n][1], f[n][2])));
}
void Factorize(int x, int w) {
if (x <= 1) return;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
while (x % i == 0) x /= i;
Check(i, w);
}
if (x != 1) Check(x, w);
}
void Init() {
cin >> n >> a >> b;
for (int i = 1; i <= n; ++i) cin >> s[i];
Factorize(s[1] - 1, b);
Factorize(s[1], 0);
Factorize(s[1] + 1, b);
for (int i = 1; i <= n / 2 + 1; ++i) swap(s[i], s[n + 1 - i]);
Factorize(s[1] - 1, b);
Factorize(s[1], 0);
Factorize(s[1] + 1, b);
Check(5, b);
cout << res;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Init();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
long long A, B;
long long ans = 1e18;
long long dp[1100000][3];
int a[2000000], n;
vector<int> v1;
void gcd(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
v1.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) v1.push_back(x);
}
void javab(int x) {
int k, j;
for (int i = 1; i <= n; i++) {
dp[i][0] = dp[i][1] = dp[i][2] = 1e18;
int s = -1;
if (a[i - 1] % x == 0)
s = 0;
else if ((a[i - 1] + 1) % x == 0 || (a[i - 1] - 1) % x == 0)
s = 1;
if (s != -1) {
dp[i][0] = dp[i - 1][0] + B * (long long)(s);
dp[i][2] = dp[i - 1][2] + B * (long long)(s);
dp[i][2] = min(dp[i][2], dp[i - 1][0] + B * (long long)(s));
dp[i][2] = min(dp[i][2], dp[i - 1][1] + B * (long long)(s));
}
dp[i][1] = dp[i - 1][1] + A;
dp[i][1] = min(dp[i][1], dp[i - 1][0] + A);
}
long long q = min(dp[n][0], dp[n][1]);
q = min(q, dp[n][2]);
ans = min(ans, q);
}
int main() {
cin >> n >> A >> B;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
gcd(a[0]);
gcd(a[0] - 1);
gcd(a[0] + 1);
gcd(a[n - 1]);
gcd(a[n - 1] + 1);
gcd(a[n - 1] - 1);
sort(v1.begin(), v1.end());
vector<int> v2;
v2.push_back(v1[0]);
for (int i = 1; i < v1.size(); i++)
if (v1[i] != v1[i - 1]) v2.push_back(v1[i]);
v1 = v2;
for (int i = 0; i < v1.size(); i++) javab(v1[i]);
cout << ans;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N;
long long A, B;
long long arr[1100000];
set<long long> pri;
long long ans = 1000000000000000001ll;
void genprime(long long u) {
if (u == 1ll) {
return;
}
int x = (int)(sqrt(u));
for (long long i = 2; i <= x; i++) {
if (u % i == 0) {
pri.insert(i);
while (u % i == 0) {
u /= i;
}
}
}
if (u > 1) {
pri.insert(u);
}
return;
}
long long cost(long long p) {
long long a = 0, b = 0, c = 0;
for (int i = 0; i < N; i++) {
if (arr[i] % p == 0ll) {
b += A;
} else if ((arr[i] - 1) % p == 0ll || (arr[i] + 1) % p == 0ll) {
a += B;
c += B;
b += A;
} else {
a += 1000000000000000001ll;
c += 1000000000000000001ll;
b += A;
}
a = min(a, 1000000000000000001ll);
b = min(b, a);
c = min(c, b);
}
return c;
}
int readint() {
char c = ' ';
while (c < '0') {
c = getchar();
}
int res = 0;
while (c >= '0') {
res = 10 * res + c - '0';
c = getchar();
}
return res;
}
long long readll() {
char c = ' ';
while (c < '0') {
c = getchar();
}
long long res = 0;
while (c >= '0') {
res = 10 * res + c - '0';
c = getchar();
}
return res;
}
int32_t main() {
if (fopen("cf624d.in", "r")) {
freopen("cf624d.in", "r", stdin);
freopen("cf624d.out", "w", stdout);
}
N = readint();
A = readll();
B = readll();
for (int i = 0; i < N; i++) {
arr[i] = readll();
}
genprime(arr[0]);
genprime(arr[0] - 1);
genprime(arr[0] + 1);
genprime(arr[N - 1]);
genprime(arr[N - 1] - 1);
genprime(arr[N - 1] + 1);
for (set<long long>::iterator it = pri.begin(); it != pri.end(); it++) {
long long p = *it;
ans = min(ans, cost(p));
}
cout << ans << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111111;
const int M = 111111;
vector<int> vec;
int a[N];
int n, A, B;
long long dp[N][3];
void get_pri_factor(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
vec.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) vec.push_back(x);
}
long long get_cost(int x, int y) {
if (x % y == 0) return 0;
if ((x + 1) % y == 0) return B;
if ((x - 1) % y == 0) return B;
return LLONG_MAX;
}
void check_min(long long &a, long long b) {
if (a > b) a = b;
}
void solve() {
get_pri_factor(a[1]);
get_pri_factor(a[1] - 1);
get_pri_factor(a[1] + 1);
get_pri_factor(a[n]);
get_pri_factor(a[n] - 1);
get_pri_factor(a[n] + 1);
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
long long ans = LLONG_MAX;
for (int k = 0; k < vec.size(); k++) {
int x = vec[k];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 2; j++) {
dp[i][j] = LLONG_MAX;
}
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
long long cost = get_cost(a[i], x);
if (dp[i - 1][0] < LLONG_MAX) {
if (cost < LLONG_MAX) check_min(dp[i][0], dp[i - 1][0] + cost);
check_min(dp[i][1], dp[i - 1][0] + A);
}
if (dp[i - 1][1] < LLONG_MAX) {
check_min(dp[i][1], dp[i - 1][1] + A);
if (cost < LLONG_MAX) dp[i][2] = min(dp[i][2], dp[i - 1][1] + cost);
}
if (dp[i - 1][2] < LLONG_MAX) {
if (cost < LLONG_MAX) check_min(dp[i][2], dp[i - 1][2] + cost);
}
}
ans = min(ans, min(dp[n][0], min(dp[n][1], dp[n][2])));
}
cout << ans << endl;
}
int main() {
scanf("%d%d%d", &n, &A, &B);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int SQN = 31630;
const int MAXN = 1e6 + 1;
vector<int> prosti_brojevi;
bool prost[SQN];
const long long inf = (long long)1e17;
long long n, A, B;
long long minV = inf;
int niz[MAXN];
long long dp[MAXN][3];
void solve() {
for (int k = 0; k < prosti_brojevi.size(); k++) {
long long cp = prosti_brojevi[k];
long long delta;
if (niz[0] % cp == 0)
delta = 0;
else if ((niz[0] - 1) % cp == 0 || (niz[0] + 1) % cp == 0)
delta = B;
else
delta = inf;
dp[0][0] = delta;
dp[0][2] = dp[0][1] = A;
for (int i = 1; i < n; i++) {
if (niz[i] % cp == 0)
delta = 0;
else if ((niz[i] - 1) % cp == 0 || (niz[i] + 1) % cp == 0)
delta = B;
else
delta = inf;
dp[i][0] = dp[i - 1][0] + delta;
dp[i][1] = min(dp[i - 1][1] + delta, dp[i - 1][2] + delta);
dp[i][2] = min(dp[i - 1][0] + A, dp[i - 1][2] + A);
dp[i][0] = min(dp[i][0], inf);
dp[i][1] = min(dp[i][1], inf);
dp[i][2] = min(dp[i][2], inf);
}
minV = min(minV, min(dp[n - 1][0], min(dp[n - 1][1], dp[n - 1][2])));
}
}
set<long long> brojiproste;
void generatePrimes() {
for (int i = 0; i < SQN; i++) prost[i] = true;
prost[0] = prost[1] = false;
for (int i = 2; i < SQN; i++) {
if (!prost[i]) continue;
for (int j = i * 2; j < SQN; j += i) prost[j] = false;
}
long long mogucnosti[] = {niz[0], niz[0] + 1, niz[0] - 1,
niz[n - 1], niz[n - 1] + 1, niz[n - 1] - 1};
for (int i = 0; i < 6; i++) {
for (int j = 2; j < SQN; j++) {
if (!prost[j]) continue;
if (mogucnosti[i] % j == 0) brojiproste.insert(j);
while (mogucnosti[i] % j == 0) {
mogucnosti[i] /= j;
}
}
if (mogucnosti[i] > 1) brojiproste.insert(mogucnosti[i]);
}
for (set<long long>::iterator iter = brojiproste.begin();
iter != brojiproste.end(); iter++) {
prosti_brojevi.push_back(*iter);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> A >> B;
for (int i = 0; i < n; i++) cin >> niz[i];
generatePrimes();
solve();
cout << minV << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000100;
int n, arr[MAX];
long long mem[MAX][3], a, b, ans = (1LL << 60);
vector<int> factorize(int num) {
vector<int> ret;
for (int i = 2; i <= num / i; i += 1 + (i & 1))
while (num % i == 0) ret.push_back(i), num /= i;
if (num > 1) ret.push_back(num);
return ret;
}
long long dp(int idx, int flag, int p) {
if (idx == n) return 0;
long long &ret = mem[idx][flag];
if (ret != -1) return ret;
if (arr[idx] % p == 0)
ret = dp(idx + 1, 2 * (flag != 0), p);
else if ((arr[idx] - 1) % p == 0 || (arr[idx] + 1) % p == 0)
ret = b + dp(idx + 1, 2 * (flag != 0), p);
else
ret = (1LL << 60);
if (flag < 2) ret = min(ret, a + dp(idx + 1, 1, p));
return ret;
}
int main() {
cin >> n >> a >> b;
for (int i = 0; i < n; i++) scanf("%d", arr + i);
int f[6] = {arr[0], arr[0] - 1, arr[0] + 1,
arr[n - 1], arr[n - 1] - 1, arr[n - 1] + 1};
set<int> s;
for (int i = 0; i < 6; i++) {
vector<int> temp = factorize(f[i]);
s.insert(temp.begin(), temp.end());
}
for (int p : s) {
memset(mem, -1, (n + 1) * sizeof mem[0]);
ans = min(ans, dp(0, 0, p));
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, *x;
long long a, b;
const long long INF = 1e16;
long long solve(int d) {
char* type = new char[n];
vector<int> pos;
for (int i = 0; i < n; i++) {
if (x[i] % d == 0)
type[i] = 0;
else if ((x[i] - 1) % d == 0 || (x[i] + 1) % d == 0)
type[i] = 1;
else
type[i] = 2;
if (type[i] > 0) pos.push_back(i);
}
if (pos.empty()) return 0;
if (pos.size() == 1) {
if (type[pos[0]] == 1)
return min(a, b);
else
return a;
}
long long dd = 0, dl = 0;
bool good = 1;
vector<long long> left;
left.resize(pos.size());
for (int i = 0; i < pos.size() - 1; i++) {
if (type[pos[i]] == 2) good = 0;
if (type[pos[i]] == 1 && good) dd += -(pos[i + 1] - pos[i]) * a + b;
dl = min(dl, dd);
left[i] = dl;
}
if (type[pos.back()] == 1 && good) {
dd += -a + b;
dl = min(dl, dd);
left[pos.size() - 1] = dl;
}
dd = 0;
long long dr = 0;
good = 1;
vector<long long> right;
right.resize(pos.size());
for (int i = pos.size() - 1; i > 0; i--) {
if (type[pos[i]] == 2) good = 0;
if (type[pos[i]] == 1 && good) dd += -(pos[i] - pos[i - 1]) * a + b;
dr = min(dr, dd);
right[i] = dr;
}
if (type[pos[0]] == 1 && good) {
dd += -a + b;
dr = min(dr, dd);
right[0] = dr;
}
long long cost = (pos.back() - pos[0] + 1) * a;
dd = min(0ll, right[1]);
right.push_back(0);
right.push_back(0);
for (int i = 0; i < pos.size(); i++) dd = min(dd, left[i] + right[i + 2]);
cost += dd;
delete[] type;
return cost;
}
long long solve2(int r) {
long long s1 = 0, s2 = 0, s3 = 0;
for (int i = 0; i < n; ++i) {
long long cost = INF;
if (x[i] % r == 0) {
cost = 0;
} else if ((x[i] - 1) % r == 0 || (x[i] + 1) % r == 0) {
cost = b;
}
s1 += cost, s2 += a, s3 += cost;
s1 = min(s1, INF), s2 = min(s2, s1), s3 = min(s2, s3);
}
return s3;
}
int main() {
scanf("%d%I64d%I64d", &n, &a, &b);
x = new int[n];
for (int i = 0; i < n; i++) scanf("%d", x + i);
int y[6] = {x[0], x[0] - 1, x[0] + 1, x[n - 1], x[n - 1] - 1, x[n - 1] + 1};
long long pen[6] = {0, b, b, 0, b, b};
long long ssol = max(n * b, n * a) + 10;
int* x0 = x;
int n0 = n;
for (int i = 0; i < 6; i++) {
if (i == 1 || i == 2) {
n = n - 1;
x += 1;
} else if (i == 4 || i == 5) {
n = n - 1;
}
for (int d = 2; d * d <= y[i]; d++) {
if (y[i] % d == 0) ssol = min(ssol, solve2(d) + pen[i]);
while (y[i] % d == 0) y[i] /= d;
}
if (y[i] > 1) ssol = min(ssol, solve2(y[i]) + pen[i]);
n = n0;
x = x0;
}
printf("%I64d", ssol);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long P[(1000006) >> 1] = {2}, L(1), cn[(1000006) >> 5];
void gen() {
(cn[0 >> 6] |= 1ULL << ((0 & 63))), (cn[1 >> 6] |= 1ULL << ((1 & 63)));
int Q(1 + sqrt((1 << 17)));
for (int k(3); k <= Q; k += 2)
if (!((cn[k >> 6] >> (k & 63)) & 1))
for (long long h(k << 1), j(k * k); j < (1 << 17); j += h)
(cn[j >> 6] |= 1ULL << ((j & 63)));
for (int i(3); i < (1 << 17); i += 2)
if (!((cn[i >> 6] >> (i & 63)) & 1)) P[L++] = i;
}
int fc(int N, int *f, int *c) {
int L(0);
for (int i(0), h(0); N >= P[i] * P[i]; ++i, h = 0) {
while (!(N % P[i])) ++h, N /= P[i];
if (h) f[L] = P[i], c[L++] = h;
}
if (N > 1) f[L] = N, c[L++] = 1;
return L;
}
int N, A[(1000006)], a, b, f[16], c[16], W, sx[] = {1, 0, -1};
long long dp[(1000006)][2][2], B((1ll << 60));
long long dyn(int u, int d, int f) {
if (u == N) return 0;
long long &v(dp[u][d][f]);
if (~v) return v;
v = (1ll << 60);
for (int i(0); i < 3; i++)
if (!((A[u] + sx[i]) % W)) v = min(v, dyn(u + 1, d, 0) + (sx[i] ? b : 0));
if (!d || f) v = min(v, a + dyn(u + 1, 1, 1));
return v;
}
int main(void) {
gen();
scanf("%d%d%d", &N, &a, &b), ga(N, A);
for (int i(0); i < 3; i++) {
int l = fc(A[0] + sx[i], f, c), p(sx[i] ? b : 0);
for (int i(0); i < l; i++)
(memset(dp, -1, sizeof(dp))), W = f[i], B = min(B, dyn(1, 0, 0) + p);
}
--N;
for (int i(0); i < 3; i++) {
(memset(dp, -1, sizeof(dp)));
int l = fc(A[N] + sx[i], f, c), p(sx[i] ? b : 0);
for (int i(0); i < l; i++)
(memset(dp, -1, sizeof(dp))), W = f[i], B = min(B, dyn(0, 1, 1) + p);
}
printf("%lld\n", B);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) swap(b, a);
while (b != 0) {
int tmp = b;
b = a % b;
a = tmp;
}
return a;
}
int n;
long long x, y;
vector<pair<int, long long> > ra[1000111], rb[1000111], rc[1000111];
void solve(vector<int> &a, vector<pair<int, long long> > r[]) {
vector<pair<int, long long> > d;
d.push_back(make_pair(a[0], 0LL));
d.push_back(make_pair(a[0] - 1, y));
d.push_back(make_pair(a[0] + 1, y));
r[0] = d;
for (int i = 1; i < n; ++i) {
vector<pair<int, long long> > dd;
for (int j = 0; j < d.size(); ++j) {
int d1 = gcd(d[j].first, a[i] - 1);
int d2 = gcd(d[j].first, a[i]);
int d3 = gcd(d[j].first, a[i] + 1);
if (d1 != 1) dd.push_back(make_pair(d1, d[j].second + y));
if (d2 != 1) dd.push_back(make_pair(d2, d[j].second));
if (d3 != 1) dd.push_back(make_pair(d3, d[j].second + y));
}
sort(dd.begin(), dd.end());
d.clear();
for (int j = 0; j < dd.size(); ++j) {
if (!d.empty() && d.back().first == dd[j].first)
d.back().second = min(d.back().second, dd[j].second);
else
d.push_back(dd[j]);
}
r[i] = d;
}
}
long long ans = 1000000000000000000LL;
void update(int i, vector<pair<int, long long> > &rb) {
for (int j = 0; j < ra[n - 1 - i].size(); ++j)
for (int k = 0; k < rb.size(); ++k)
if (gcd(ra[n - 1 - i][j].first, rb[k].first) != 1)
ans = min(ans, ra[n - 1 - i][j].second + rb[k].second);
}
void reform(vector<pair<int, long long> > r[]) {
vector<pair<int, long long> > r2;
r2.push_back(make_pair(0, x));
for (int i = 1; i < n; ++i) {
update(i, r2);
vector<pair<int, long long> > dd;
dd = r2;
for (int j = 0; j < r2.size(); ++j) dd[j].second += x;
for (int j = 0; j < r[i - 1].size(); ++j) {
pair<int, long long> q = r[i - 1][j];
q.second += x;
dd.push_back(q);
}
for (int j = 0; j < dd.size(); ++j) {
for (int k = j + 1; k < dd.size(); ++k) {
if (dd[j].first && dd[k].second <= dd[j].second &&
dd[k].first % dd[j].first == 0) {
dd[j] = dd.back();
dd.pop_back();
--j;
break;
}
if (dd[k].first && dd[j].second <= dd[k].second &&
dd[j].first % dd[k].first == 0) {
dd[k] = dd.back();
dd.pop_back();
--k;
}
}
}
sort(dd.begin(), dd.end());
vector<pair<int, long long> > d(1, dd[0]);
for (int j = 1; j < dd.size(); ++j) {
if (d.back().first == dd[j].first)
d.back().second = min(d.back().second, dd[j].second);
else
d.push_back(dd[j]);
}
r2 = d;
}
for (int j = 0; j < r2.size(); ++j) ans = min(ans, r2[j].second);
}
long long solve2() {
for (int j = 0; j < ra[n - 1].size(); ++j)
ans = min(ans, ra[n - 1][j].second);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> x >> y;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
solve(a, ra);
for (int i = 0, j = n - 1; i < j; ++i, --j) swap(a[i], a[j]);
solve(a, rc);
reform(rc);
long long res = solve2();
cout << res << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e6) + 10;
long long dp[maxn][3];
int arr[maxn];
int n, a, b;
long long solve(int x, int y) {
if (x == 1) return LLONG_MAX;
vector<int> vp;
for (int i = 2; 1ll * i * i <= x; i++) {
if (x % i == 0) {
vp.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) vp.push_back(x);
long long ans = LLONG_MAX;
for (int i : vp) {
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = y;
dp[0][2] = y;
for (int j = 1; j < n; j++) {
dp[j][1] = min(dp[j][1], a + min(dp[j - 1][1], dp[j - 1][0]));
if (arr[j] % i == 0) {
dp[j][0] = min(dp[j - 1][0], dp[j][0]);
dp[j][2] = min(dp[j][2], min(dp[j - 1][1], dp[j - 1][2]));
}
if ((arr[j] + 1) % i == 0 || (arr[j] - 1) % i == 0) {
dp[j][2] = min(dp[j][2], min(dp[j - 1][1], dp[j - 1][2]) + b);
dp[j][0] = min(dp[j][0], dp[j - 1][0] + b);
}
}
ans = min(ans, dp[n - 1][0]);
ans = min(ans, dp[n - 1][1]);
ans = min(ans, dp[n - 1][2]);
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
long long ans = LLONG_MAX;
ans = min(ans, solve(arr[0], 0));
ans = min(ans, solve(arr[0] + 1, b));
ans = min(ans, solve(arr[0] - 1, b));
reverse(arr, arr + n);
ans = min(ans, solve(arr[0] + 1, b));
ans = min(ans, solve(arr[0] - 1, b));
ans = min(ans, solve(arr[0], 0));
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INFint = 2e9;
const unsigned long long INF = 1e18;
const int MOD = 1e9 + 7;
set<int> all;
vector<int> v;
unsigned long long a, b;
void factorize(int x) {
vector<int> cur;
for (int d = 2; 1ll * d * d <= x; d += 1 + (d != 2)) {
if (x % d == 0) {
cur.push_back(d);
while (x % d == 0) x /= d;
}
}
if (x > 1) all.insert(x);
all.insert(cur.begin(), cur.end());
}
unsigned long long price(int x, int p) {
int r = min(x % p, p - x % p);
if (r > 1) return INF;
return b * r;
}
unsigned long long solve(int p) {
int n = v.size();
vector<vector<unsigned long long> > dp(n, vector<unsigned long long>(3, INF));
dp[0][0] = price(v[0], p);
dp[0][1] = a;
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + price(v[i], p);
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + price(v[i], p);
dp[i][0] = min(dp[i][0], INF);
dp[i][1] = min(dp[i][1], INF);
dp[i][2] = min(dp[i][2], INF);
}
return min(dp[n - 1][0], min(dp[n - 1][1], dp[n - 1][2]));
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n >> a >> b;
v.resize(n);
for (auto &x : v) cin >> x;
for (int d = -1; d < 2; d++) {
factorize(v[0] + d);
factorize(v.back() + d);
}
vector<int> cur(all.begin(), all.end());
unsigned long long ans = INF;
for (auto p : cur) {
ans = min(ans, solve(p));
}
cout << ans;
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAX = 1e6 + 5;
int n, l, e[MAX], p[MAX], a, b;
long long dp[MAX][3];
void factor(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
while (x % i == 0) x /= i;
p[++l] = i;
}
}
if (x > 1) p[++l] = x;
}
bool can(int x, int p) {
return (x - 1) % p == 0 || x % p == 0 || (x + 1) % p == 0;
}
int cost(int x, int p) { return x % p == 0 ? 0 : b; }
long long solve(int p) {
for (int i = 1; i <= n + 1; i++)
for (int j = 0; j < 3; j++) dp[i][j] = INF;
dp[n + 1][0] = dp[n + 1][1] = dp[n + 1][2] = 0;
for (int i = n; i > 0; i--) {
int r = can(e[i], p);
int ct = cost(e[i], p);
if (r == 1) dp[i][0] = dp[i + 1][0] + ct;
dp[i][0] = min(dp[i][0], dp[i + 1][1] + a);
if (r == 1) dp[i][1] = dp[i + 1][2] + ct;
dp[i][1] = min(dp[i][1], dp[i + 1][1] + a);
if (r == 1) dp[i][2] = dp[i + 1][2] + ct;
}
return dp[1][0];
}
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", &e[i]);
factor(e[1] - 1);
factor(e[1] + 1);
factor(e[1]);
factor(e[n] - 1);
factor(e[n] + 1);
factor(e[n]);
long long sol = INF;
for (int i = 1; i <= l; i++) sol = min(sol, solve(p[i]));
printf("%I64d\n", sol);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 999999999;
const int mod = 1000000007;
inline int Getint() {
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
int ret = 0;
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret;
}
long long f[1000010][3];
int a[1000010];
int n, costa, costb;
inline void Add(set<int> &s, int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
s.insert(i);
while (x % i == 0) x /= i;
}
}
if (x != 1) s.insert(x);
}
inline bool Check(int x, int y) {
return x % y == 0 || (x - 1) % y == 0 || (x + 1) % y == 0;
}
inline bool Check2(int x, int y) { return x % y != 0; }
inline long long Calc(int x) {
memset(f, 0, sizeof(f));
f[0][0] = 0;
f[0][1] = f[0][2] = (long long)inf * inf;
for (int i = 1; i <= n; i++) {
f[i][0] = f[i][1] = f[i][2] = (long long)inf * inf;
if (Check(a[i], x)) {
int cur = Check2(a[i], x);
f[i][0] = min(f[i][0], f[i - 1][0] + Check2(a[i], x) * costb);
f[i][2] =
min(f[i][0], min(f[i - 1][1], f[i - 1][2]) + Check2(a[i], x) * costb);
}
f[i][1] = min(f[i][1], min(f[i - 1][0], f[i - 1][1]) + costa);
}
return min(f[n][0], min(f[n][1], f[n][2]));
}
inline void Work() {
set<int> s;
Add(s, a[1] - 1), Add(s, a[1]), Add(s, a[1] + 1);
Add(s, a[n] - 1), Add(s, a[n]), Add(s, a[n] + 1);
long long ans = (long long)inf * inf;
for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
ans = min(ans, Calc(*it));
}
cout << ans << endl;
}
int main() {
n = Getint(), costa = Getint(), costb = Getint();
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i++) {
a[i] = Getint();
}
Work();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1LL << 60);
const int N = 1e6 + 1;
long long n, a, b;
vector<long long> ve;
int p;
long long memo[N][3][2];
long long solve(int i, int flag, bool ok) {
if (i == n) return (ok ? 0 : inf);
long long &ret = memo[i][flag][ok];
if (ret != -1) return ret;
ret = inf;
if (flag == 2) {
if (ve[i] % p == 0)
ret = solve(i + 1, flag, true);
else if ((ve[i] - 1) % p == 0 || (ve[i] + 1) % p == 0)
ret = b + solve(i + 1, flag, true);
}
if (flag == 1) {
ret = a + solve(i + 1, 1, ok);
if (ve[i] % p == 0)
ret = min(ret, solve(i + 1, 2, true));
else if ((ve[i] - 1) % p == 0 || (ve[i] + 1) % p == 0)
ret = min(ret, b + solve(i + 1, 2, true));
}
if (flag == 0) {
ret = a + solve(i + 1, 1, ok);
if (ve[i] % p == 0)
ret = min(ret, solve(i + 1, flag, true));
else if ((ve[i] - 1) % p == 0 || (ve[i] + 1) % p == 0)
ret = min(ret, b + solve(i + 1, flag, true));
}
return ret;
}
bitset<N> isprime;
vector<int> primes;
void sieve() {
isprime.set();
primes.push_back(2);
for (int i = 3; i * i <= N; i += 2) {
for (int j = i * 2; j <= N; j += i) isprime[j] = 0;
}
for (int i = 3; i <= N; i += 2)
if (isprime[i]) primes.push_back(i);
}
set<int> se;
void fact(int n) {
int PF_idx = 0, PF = primes[PF_idx];
while (PF * PF <= n) {
if (n % PF == 0) {
se.insert(PF);
while (n % PF == 0) n /= PF;
}
PF = primes[++PF_idx];
}
if (n > 1) se.insert(n);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
sieve();
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
ve.push_back(x);
if (i == 0 || i == n - 1) {
fact(x);
fact(x - 1);
fact(x + 1);
}
}
long long ret = inf;
for (auto i : se) {
p = i;
memset(memo, -1, sizeof memo);
ret = min(ret, solve(0, 0, 0));
}
cout << ret << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000005;
const int X_NOTB = 0;
const int X_BEG = 1;
const int X_END = 2;
const long long INF = 1000000000000000000LL;
int mas[MAX_N];
long long dp[MAX_N][3];
set<int> st;
long long n, a, b;
void razlozh(int x) {
int p = 2;
while (p * p <= x) {
if (x % p == 0) st.insert(p);
while (x % p == 0) x /= p;
p++;
}
if (x > 1) st.insert(x);
return;
}
long long get_ans(int p) {
for (int i = 0; i < MAX_N; i++)
for (int j = 0; j < 3; j++) dp[i][j] = INF;
dp[0][X_NOTB] = dp[0][X_END] = dp[0][X_BEG] = 0;
for (int i = 0; i < n; i++) {
if (mas[i] % p == 0) {
dp[i + 1][X_NOTB] = dp[i][X_NOTB];
dp[i + 1][X_BEG] = min(dp[i][X_BEG], dp[i][X_NOTB]) + a;
dp[i + 1][X_END] = min(dp[i][X_END], dp[i][X_BEG]);
} else if ((mas[i] + 1) % p == 0 || (mas[i] - 1) % p == 0) {
dp[i + 1][X_NOTB] = dp[i][X_NOTB] + b;
dp[i + 1][X_BEG] = min(dp[i][X_BEG], dp[i][X_NOTB]) + a;
dp[i + 1][X_END] = min(dp[i][X_END], dp[i][X_BEG]) + b;
} else {
dp[i + 1][X_NOTB] = INF;
dp[i + 1][X_BEG] = min(dp[i][X_BEG], dp[i][X_NOTB]) + a;
dp[i + 1][X_END] = INF;
}
}
long long ans = min(dp[n][X_NOTB], dp[n][X_END]);
if (dp[n][X_BEG] < ans) {
if (dp[n][X_BEG] == n * a) {
if (mas[0] % p == 0 || (mas[0] - 1) % p == 0 || (mas[0] + 1) % p == 0)
ans = min(ans, (n - 1) * a + b);
} else
ans = dp[n][X_BEG];
}
return ans;
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 0; i < n; i++) scanf("%d", &mas[i]);
razlozh(mas[0] - 1);
razlozh(mas[0]);
razlozh(mas[0] + 1);
razlozh(mas[n - 1] - 1);
razlozh(mas[n - 1]);
razlozh(mas[n - 1] + 1);
long long ans = INF;
for (set<int>::iterator i = st.begin(); i != st.end(); i++) {
long long sum = get_ans(*i);
ans = min(ans, sum);
}
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-12;
const long long INF = 1000LL * 1000 * 1000 * 1000 * 1000 * 1000 + 1912;
const int maxn = 1000000 + 1912;
int n, a[maxn];
int x, y;
void ReadData() {
cin >> n >> x >> y;
for (int i = 1; i <= n; i++) cin >> a[i];
}
long long dp[maxn][3];
void minimize(long long &a, const long long &b) {
if (a > b) a = b;
}
long long Solve(int p) {
long long res = INF;
for (int i = 0; i <= n; i++)
for (int j = 0; j < 3; j++) dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
if (a[i] % p == 0) {
minimize(dp[i][0], dp[i - 1][0]);
}
if ((a[i] + 1) % p == 0 || (a[i] - 1) % p == 0) {
minimize(dp[i][0], dp[i - 1][0] + y);
}
minimize(dp[i][1], dp[i - 1][1] + x);
minimize(dp[i][1], dp[i - 1][0] + x);
if (a[i] % p == 0) {
minimize(dp[i][2], dp[i - 1][2]);
minimize(dp[i][2], dp[i - 1][1]);
}
if ((a[i] + 1) % p == 0 || (a[i] - 1) % p == 0) {
minimize(dp[i][2], dp[i - 1][2] + y);
minimize(dp[i][2], dp[i - 1][1] + y);
}
}
res = min(dp[n][0], min(dp[n][1], dp[n][2]));
return res;
}
void Process() {
if (n == 1) {
int res = 0;
if (a[1] == 1) res = y;
cout << res << endl;
return;
}
long long res = 1LL * n * x;
for (int k = -1; k <= 1; k++) {
int z = a[1] + k;
for (int i = 2; i <= sqrt(z); i++) {
bool ok = (z % i == 0);
while (z % i == 0) {
z /= i;
}
if (ok) res = min(res, Solve(i));
}
if (z > 1) res = min(res, Solve(z));
z = a[n] + k;
for (int i = 2; i <= sqrt(z); i++) {
bool ok = (z % i == 0);
while (z % i == 0) {
z /= i;
}
if (ok) res = min(res, Solve(i));
}
if (z > 1) res = min(res, Solve(z));
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ReadData();
Process();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, -1, 1};
void arquivo() {
freopen("", "r", stdin);
freopen("", "w", stdout);
}
const int N = 5000100;
int n;
long long a, b;
int v[N];
bool memo[N][3];
long long pd[N][3];
int atPrime;
long long func(int pos, int op) {
if (pos == n) return 0LL;
if (memo[pos][op]) return pd[pos][op];
long long ret = 1000000000000000001LL;
if (!op) {
ret = func(pos + 1, 1) + a;
if (v[pos] % atPrime == 0) ret = min(ret, func(pos + 1, 0));
if ((v[pos] + 1) % atPrime == 0) ret = min(ret, func(pos + 1, 0) + b);
if ((v[pos] - 1) % atPrime == 0) ret = min(ret, func(pos + 1, 0) + b);
} else if (op == 1) {
ret = func(pos + 1, 1) + a;
if (v[pos] % atPrime == 0) ret = min(ret, func(pos + 1, 2));
if ((v[pos] + 1) % atPrime == 0) ret = min(ret, func(pos + 1, 2) + b);
if ((v[pos] - 1) % atPrime == 0) ret = min(ret, func(pos + 1, 2) + b);
} else {
if (v[pos] % atPrime == 0) ret = min(ret, func(pos + 1, 2));
if ((v[pos] + 1) % atPrime == 0) ret = min(ret, func(pos + 1, 2) + b);
if ((v[pos] - 1) % atPrime == 0) ret = min(ret, func(pos + 1, 2) + b);
}
memo[pos][op] = 1;
return pd[pos][op] = ret;
}
void fatora(long long x, set<int> &all) {
for (long long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
all.insert(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) all.insert(x);
}
int main() {
scanf("%d %lld %lld", &n, &a, &b);
set<int> all;
long long x;
for (int i = 0; i < n; ++i) {
scanf("%d", v + i);
}
for (int i = 0; i < 1; ++i) {
x = v[i];
fatora(x, all);
x = v[i] + 1;
fatora(x, all);
x = v[i] - 1;
fatora(x, all);
}
for (int i = n - 1; i < n; ++i) {
x = v[i];
fatora(x, all);
x = v[i] + 1;
fatora(x, all);
x = v[i] - 1;
fatora(x, all);
}
long long ans = (long long)(n - 1LL) * a;
for (set<int>::iterator it = all.begin(); it != all.end(); it++) {
atPrime = *it;
if (atPrime == 1) continue;
memset(memo, 0, sizeof memo);
for (int j = n - 1; j >= 0; --j) {
func(j, 0);
func(j, 1);
func(j, 2);
}
ans = min(ans, func(0, 0));
}
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, b, c;
int a[1000001];
vector<int> q;
long long dp[1000001][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> b >> c;
for (int i = 1; i <= n; ++i) cin >> a[i];
int x = a[1];
for (int i = 2; i <= sqrt(x); ++i) {
if (x % i != 0) continue;
q.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) q.push_back(x);
x = a[n];
for (int i = 2; i <= sqrt(x); ++i) {
if (x % i != 0) continue;
q.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) q.push_back(x);
x = a[n] - 1;
for (int i = 2; i <= sqrt(x); ++i) {
if (x % i != 0) continue;
q.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) q.push_back(x);
x = a[n] + 1;
for (int i = 2; i <= sqrt(x); ++i) {
if (x % i != 0) continue;
q.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) q.push_back(x);
x = a[1] - 1;
for (int i = 2; i <= sqrt(x); ++i) {
if (x % i != 0) continue;
q.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) q.push_back(x);
x = a[1] + 1;
for (int i = 2; i <= sqrt(x); ++i) {
if (x % i != 0) continue;
q.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) q.push_back(x);
long long ans = 1e18;
for (int i = 0; i < q.size(); ++i) {
int x = q[i];
for (int i = 1; i <= n; ++i) {
dp[i][0] = 1e18;
dp[i][1] = 1e18;
dp[i][2] = 1e18;
if (a[i] % x == 0) dp[i][0] = dp[i - 1][0];
if ((a[i] + 1) % x == 0 && dp[i - 1][0] != 1e18)
dp[i][0] = min(dp[i][0], dp[i - 1][0] + c);
if ((a[i] - 1) % x == 0 && dp[i - 1][0] != 1e18)
dp[i][0] = min(dp[i][0], dp[i - 1][0] + c);
if (dp[i - 1][0] != 1e18) dp[i][1] = dp[i - 1][0] + b;
dp[i][1] = min(dp[i][1], dp[i - 1][1] + b);
if (a[i] % x == 0) dp[i][2] = dp[i - 1][2];
if ((a[i] + 1) % x == 0) dp[i][2] = min(dp[i][2], dp[i - 1][2] + c);
if ((a[i] - 1) % x == 0) dp[i][2] = min(dp[i][2], dp[i - 1][2] + c);
dp[i][2] = min(dp[i][2], dp[i][1]);
}
ans = min(ans, dp[n][0]);
ans = min(ans, dp[n][1]);
ans = min(ans, dp[n][2]);
}
cout << ans;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int n, x, y;
vector<int> a;
long long f[maxn][3];
long long Cost(int num, int gcd, int del) {
if (del) return x;
num %= gcd;
if (num == 0) return 0;
if (num == 1 || num == gcd - 1) return y;
return 1e15;
}
long long Calc(int gcd) {
f[n][0] = f[n][1] = f[n][2] = 0;
for (int i = n - 1; i >= 0; --i) {
long long c0 = Cost(a[i], gcd, 0);
long long c1 = Cost(a[i], gcd, 1);
f[i][0] = min(f[i + 1][0] + c0, f[i + 1][1] + c1);
f[i][1] = min(f[i + 1][1] + c1, f[i + 1][2] + c0);
f[i][2] = f[i + 1][2] + c0;
if (f[i][0] > 1e17) f[i][0] = 1e17;
if (f[i][1] > 1e17) f[i][1] = 1e17;
if (f[i][2] > 1e17) f[i][2] = 1e17;
}
return f[0][0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> x >> y;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> candidate;
for (int x = -1; x <= 1; ++x) {
candidate.push_back(a[0] + x);
candidate.push_back(a.back() + x);
}
long long res = 1ll * n * x;
for (int gcd = 2; gcd * gcd <= 1e9; ++gcd) {
bool ok = false;
for (int &x : candidate)
while (x % gcd == 0) x /= gcd, ok = 1;
if (ok) res = min(res, Calc(gcd));
}
for (int gcd : candidate)
if (gcd != 1) res = min(res, Calc(gcd));
cout << res;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int c[N];
long long a, b;
vector<int> d;
void div(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
d.push_back(i);
while (n % i == 0) n /= i;
}
}
if (n > 1) d.push_back(n);
}
void f(int n) {
div(n);
div(n - 1);
div(n + 1);
}
long long L[N], R[N];
const long long inf = 1LL << 60;
long long ans = 1LL << 60;
long long sol(int fac, int n) {
long long ans = inf;
L[0] = 0;
for (int i = 1; i <= n; i++) {
L[i] = inf;
if (c[i] % fac == 0)
L[i] = L[i - 1];
else if ((c[i] - 1) % fac == 0 || (c[i] + 1) % fac == 0)
L[i] = L[i - 1] + b;
ans = min(ans, L[i] + (n - i) * a);
}
R[n + 1] = 0;
for (int i = n; i >= 1; i--) {
R[i] = inf;
if (c[i] % fac == 0)
R[i] = R[i + 1];
else if ((c[i] - 1) % fac == 0 || (c[i] + 1) % fac == 0)
R[i] = R[i + 1] + b;
}
for (int i = 1; i <= n; i++) L[i] -= i * a;
for (int i = 1; i <= n; i++) R[i] += (i - 1) * a;
long long mn = 0;
for (int i = 1; i <= n; i++) {
ans = min(ans, R[i] + mn);
mn = min(mn, L[i]);
}
return ans;
}
int main() {
int n;
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", c + i);
f(c[1]);
f(c[n]);
sort(d.begin(), d.end());
d.erase(unique(d.begin(), d.end()), d.end());
for (int i = 0; i < d.size(); i++) ans = min(ans, sol(d[i], n));
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
int n, A, B, a[maxn];
long long dp[maxn][3];
long long solve(int x, int y) {
if (x == 1) return LLONG_MAX;
vector<int> facs;
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
facs.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) facs.push_back(x);
long long ans = LLONG_MAX;
for (int j = 0; j < facs.size(); ++j) {
memset(dp, 0x3f, sizeof(dp));
dp[1][0] = y;
for (int i = 2; i <= n; ++i) {
if ((a[i] - 1) % facs[j] == 0) {
dp[i][0] = min(dp[i][0], dp[i - 1][0] + B);
dp[i][2] = min(dp[i][2], min(dp[i - 1][1], dp[i - 1][2]) + B);
}
if ((a[i] + 1) % facs[j] == 0) {
dp[i][0] = min(dp[i][0], dp[i - 1][0] + B);
dp[i][2] = min(dp[i][2], min(dp[i - 1][1], dp[i - 1][2]) + B);
}
if (a[i] % facs[j] == 0) {
dp[i][0] = min(dp[i][0], dp[i - 1][0]);
dp[i][2] = min(dp[i][2], min(dp[i - 1][1], dp[i - 1][2]));
}
dp[i][1] = min(dp[i][1], min(dp[i - 1][0], dp[i - 1][1]) + A);
}
ans = min(ans, dp[n][0]);
ans = min(ans, dp[n][1]);
ans = min(ans, dp[n][2]);
}
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
scanf("%d%d%d", &n, &A, &B);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
long long ans = LLONG_MAX;
ans = min(ans, solve(a[1] - 1, B));
ans = min(ans, solve(a[1], 0));
ans = min(ans, solve(a[1] + 1, B));
reverse(a + 1, a + 1 + n);
ans = min(ans, solve(a[1] - 1, B));
ans = min(ans, solve(a[1], 0));
ans = min(ans, solve(a[1] + 1, B));
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a, b;
vector<long long> v, p;
vector<vector<long long> > dp;
void fill_p();
long long solve(long long x);
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b;
v.resize(n);
for (int i = 0; i < n; ++i) cin >> v[i];
fill_p();
long long res = (long long)1e18;
for (int i = 0; i < p.size(); ++i) res = min(res, solve(p[i]));
cout << res << endl;
return 0;
}
long long solve(long long x) {
dp.assign(n + 1, vector<long long>(3, (long long)1e18));
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 0; i < n; ++i) {
dp[i + 1][1] = min(dp[i][0], dp[i][1]) + a;
if (v[i] % x == 0) {
dp[i + 1][0] = dp[i][0];
dp[i + 1][2] = min(dp[i][1], dp[i][2]);
} else if ((v[i] % x == 1) || (v[i] % x == x - 1)) {
dp[i + 1][0] = dp[i][0] + b;
dp[i + 1][2] = min(dp[i][1], dp[i][2]) + b;
}
}
long long res = (long long)1e18;
for (int j = 0; j < 3; ++j) res = min(res, dp[n][j]);
return res;
}
void fill_p() {
vector<long long> w;
w.push_back(v[0]);
w.push_back(v[0] + 1);
w.push_back(v[0] - 1);
w.push_back(v[n - 1]);
w.push_back(v[n - 1] + 1);
w.push_back(v[n - 1] - 1);
set<long long> S;
for (int i = 0; i < w.size(); ++i) {
long long x = w[i];
for (long long j = 2; j * j <= x; ++j) {
if (x % j == 0) {
S.insert(j);
while (x % j == 0) x /= j;
}
}
if (x > 1) S.insert(x);
}
for (set<long long>::iterator it = S.begin(); it != S.end(); ++it)
p.push_back(*it);
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
bool is_prime(long long n) {
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
vector<long long> fact(long long n) {
vector<long long> ans;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
ans.push_back(i);
while (n % i == 0) {
n /= i;
}
}
}
if (n > 1) ans.push_back(n);
return ans;
}
long long getPow(long long a, long long b) {
long long res = 1ll, tp = a;
while (b) {
if (b & 1ll) {
res *= tp;
}
tp *= tp;
b >>= 1ll;
}
return res;
}
long long vec_mult(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3) {
return abs((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1));
}
void ok() {
cout << "YES" << endl;
exit(0);
}
void no() {
cout << "NO" << endl;
exit(0);
}
inline long long nxt() {
long long x;
cin >> x;
return x;
}
const long long N = 3e3 + 10, inf = 2e16;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long n = nxt(), a = nxt(), b = nxt();
vector<long long> mas(n + 1);
for (int i = 1; i <= n; i++) {
mas[i] = nxt();
}
vector<long long> arr = {mas[1], mas[1] + 1, mas[1] - 1,
mas[n], mas[n] - 1, mas[n] + 1};
vector<long long> factors;
for (auto t : arr) {
vector<long long> cur = fact(t);
for (auto x : cur) {
factors.push_back(x);
}
}
sort((factors).begin(), (factors).end());
(factors).resize(unique((factors).begin(), (factors).end()) -
(factors).begin());
long long ans = inf;
vector<vector<long long>> dp(n + 1, vector<long long>(3));
for (int j = 0; j < 3; j++) {
dp[0][j] = 0;
}
for (int i = 0; i < factors.size(); i++) {
long long p = factors[i];
for (int j = 1; j <= n; j++) {
long long type;
if (mas[j] % p == 0)
type = 0;
else if ((mas[j] - 1) % p == 0 || (mas[j] + 1) % p == 0)
type = 1;
else
type = 2;
if (type == 0) {
dp[j][0] = dp[j - 1][0];
dp[j][1] = min(dp[j - 1][0], dp[j - 1][1]) + a;
dp[j][2] = min(dp[j - 1][1], dp[j - 1][2]);
}
if (type == 1) {
dp[j][0] = dp[j - 1][0] + b;
dp[j][1] = min(dp[j - 1][0], dp[j - 1][1]) + a;
dp[j][2] = min(dp[j - 1][1], dp[j - 1][2]) + b;
}
if (type == 2) {
for (int t = 0; t < 3; t++) {
dp[j][t] = inf;
}
dp[j][1] = min(dp[j - 1][1], dp[j - 1][0]) + a;
}
}
for (auto x : dp[n]) {
ans = min(ans, x);
}
}
cout << ans;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int P_MAX = 100000;
bool P[P_MAX];
int N, A, B;
vector<int> V;
long long dp[1000010][3];
long long solve(int d) {
for (int i = 0; i <= N; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + A);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + A);
if (V[i] % d == 0) {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0]);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][1]);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][2]);
} else if ((V[i] + 1) % d == 0 || (V[i] - 1) % d == 0) {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + B);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][1] + B);
dp[i + 1][2] = min(dp[i + 1][2], dp[i][2] + B);
}
}
return min(dp[N][0], min(dp[N][1], dp[N][2]));
}
int main() {
for (int p = 2; p < P_MAX; p++) {
P[p] = true;
}
for (int p = 2; p < P_MAX; p++) {
if (!P[p]) continue;
for (int i = p + p; i < P_MAX; i += p) {
P[i] = false;
}
}
cin >> N >> A >> B;
for (int i = 0; i < N; i++) {
int t;
cin >> t;
V.push_back(t);
}
long long ans = INF;
int cands[] = {V[0], V[0] + 1, V[0] - 1,
V[N - 1], V[N - 1] + 1, V[N - 1] - 1};
for (int i = 0; i < 6; i++) {
int cand = cands[i];
for (int p = 2; p < P_MAX; p++) {
if (!P[p]) continue;
if (cand % p != 0) continue;
while (cand % p == 0) cand /= p;
ans = min(ans, solve(p));
}
if (cand != 1) ans = min(ans, solve(cand));
}
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
istream* pin;
intmax_t tmin = std::numeric_limits<intmax_t>::min();
intmax_t tmax = std::numeric_limits<intmax_t>::max();
intmax_t konstansmod = (1e9) + 7;
template <typename T>
vector<T> read(int num = -1, int szorzo = 1, istream& in = *pin) {
vector<T> container;
if (num == -1) in >> num;
num *= szorzo;
for (int i = 0; i < num; i++) {
T q;
in >> q;
container.push_back(q);
}
return container;
}
struct printer {
ostream* o;
printer(ostream& a = cout) : o(&a) {}
void pr() { *o << "\n"; }
template <typename T>
void pr(T intmax_t) {
*o << std::setprecision(9) << intmax_t << "\n";
}
template <typename T>
void pr(vector<T> intmax_t) {
for (T w : intmax_t) pr(w);
pr();
}
template <typename T, typename... Args>
void pr(T value, Args... args) {
pr(value);
pr(args...);
}
};
template <typename H1>
void show(std::ostream& out, const char* label, H1&& value) {
out << label << "=";
printer(out).pr(value);
}
template <typename H1, typename... T>
void show(std::ostream& out, const char* label, H1&& value, T&&... rest) {
const char* pcomma = strchr(label, ',');
out.write(label, pcomma - label) << "=";
printer(out).pr(value);
show(out, pcomma + 1, std::forward<T>(rest)...);
}
void print(bool b) { cout << (b ? "Yes" : "No") << "\n"; }
void solve();
int main(int argc, char** argv) {
srand((unsigned)time(NULL));
ifstream* argfile = NULL;
string filename = "";
if (argc >= 2 && filename.length() == 0) filename = argv[1];
if (filename.length() > 0) {
argfile = new ifstream(filename);
if (!argfile->is_open()) {
cerr << "file cant be opened,exiting. Filename:" << filename << "\n";
cerr << "Error: " << strerror(errno) << "\n";
return 1;
}
}
if (argfile) std::cin.rdbuf(argfile->rdbuf());
istream& myfile = argfile ? *argfile : cin;
pin = &myfile;
int num;
solve();
return 0;
myfile >> num;
for (int i = 0; i < num; i++) {
cout << "Case #" << (i + 1) << ": ";
solve();
}
return 0;
}
vector<intmax_t> decompose(intmax_t n) {
vector<intmax_t> ret;
intmax_t i(2);
while (n % i == intmax_t(0)) {
ret.push_back(i);
n /= i;
}
++i;
while (n != 1) {
while (n % i == intmax_t(0)) {
ret.push_back(i);
n /= i;
}
i += 2;
}
return ret;
}
void solve() {
intmax_t rret = tmax;
intmax_t n, a, b;
cin >> n >> a >> b;
vector<intmax_t> nums;
nums.reserve(1000002);
nums.push_back(0);
for (int i = 0; i < n; i++) {
intmax_t e;
cin >> e;
nums.push_back(e);
}
unordered_set<intmax_t> tt;
for (int z = 1; z <= n; z += max((int)n - 1, (int(1))))
for (int j2 = nums[z] - 1; j2 < nums[z] + 2; j2++) {
intmax_t j = j2;
for (intmax_t i2 = 2; i2 * i2 <= j; ++i2) {
if (j % i2 == 0) {
tt.insert(i2);
if (i2 * i2 != j) tt.insert(j / i2);
while (j % i2 == 0) j /= i2;
}
if (j == 1) break;
}
if (j > 1) tt.insert(j);
}
for (intmax_t fact : tt) {
intmax_t ret = tmax;
int pontnum = 0;
intmax_t megtakar = 0;
intmax_t aktmegtak = 0;
intmax_t ba = b - a;
bool elsorosszpontos = false;
bool rosszpontos = false;
for (intmax_t j = 1; j < nums.size(); j++) {
elsorosszpontos = false;
intmax_t modi = nums[j] % fact;
if (modi == 0) {
aktmegtak -= a;
if (!rosszpontos) aktmegtak = max(aktmegtak, (intmax_t)0);
} else {
pontnum++;
if (modi != 1 && modi != fact - 1) {
megtakar = tmin;
if (!rosszpontos) elsorosszpontos = true;
rosszpontos = true;
}
intmax_t newtakar = aktmegtak + (ba);
aktmegtak = newtakar;
megtakar = max(megtakar, newtakar);
if (newtakar < (ba) && (!rosszpontos || elsorosszpontos)) {
aktmegtak = ba;
megtakar = max(megtakar, newtakar);
}
}
}
show(std::cerr,
"pontnum, megtakar, fact, pontnum * b - megtakar, aktmegtak", pontnum,
megtakar, fact, pontnum * b - megtakar, aktmegtak);
ret = pontnum * b - megtakar;
rret = min(ret, rret);
}
printer().pr(rret);
;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[N];
vector<int> pp;
long long n, A, B;
void prime(int first) {
int i;
for (i = 2; i <= sqrt(first); ++i)
if (first % i == 0) {
while (first % i == 0) first /= i;
pp.push_back(i);
}
if (first > 1) pp.push_back(first);
}
long long get(int r) {
int i;
long long T = n * A, K = 0;
priority_queue<pair<long long, int> > q;
for (i = n; i >= 1; --i) {
T -= A;
if (a[i] % r != 0) {
if (((a[i] + 1) % r == 0 || (a[i] - 1) % r == 0))
K += B;
else
break;
}
q.push(make_pair(-(T + K), i));
}
long long ret = 8e18;
if (!q.empty()) ret = -q.top().first;
K = 0, T = 0;
for (i = 1; i < n; ++i) {
if (a[i] % r != 0) {
if (((a[i] + 1) % r == 0 || (a[i] - 1) % r == 0))
K += B;
else
break;
}
T += A;
while (!q.empty()) {
if (q.top().second > i) break;
q.pop();
}
ret = min(ret, K + A * (n - i));
if (!q.empty()) ret = min(ret, K - q.top().first - T);
}
return ret;
}
int main() {
int i, j, k;
cin >> n >> A >> B;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = -1; i <= 1; ++i) prime(a[1] + i), prime(a[n] + i);
sort(pp.begin(), pp.end());
vector<int>::iterator it = unique(pp.begin(), pp.end());
pp.resize(distance(pp.begin(), it));
long long ret = 8e18;
for (i = 0; i < pp.size(); ++i) ret = min(ret, get(pp[i]));
cout << ret << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 1000;
int n, x, y;
int a[maxn];
vector<int> prime;
bool l1[maxn], r1[maxn];
int l2[maxn], r2[maxn];
const long long inf = (long long)1e18;
void factor(int x) {
int v = x;
for (int i = 2; 1ll * i * i <= x; i++)
if (v % i == 0) {
prime.push_back(i);
while (v % i == 0) v /= i;
}
if (v > 1) prime.push_back(v);
}
int main() {
scanf("%d%d%d", &n, &x, &y);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
prime.clear();
factor(a[1]);
factor(a[1] - 1);
factor(a[1] + 1);
factor(a[n]);
factor(a[n] + 1);
factor(a[n] - 1);
sort(prime.begin(), prime.end());
long long ans = inf;
for (int t = 0; t < (int)prime.size(); t++)
if (t == 0 || prime[t] != prime[t - 1]) {
int g = prime[t];
l1[0] = 1;
l2[0] = 0;
for (int i = 1; i <= n; i++) {
l1[i] =
l1[i - 1] && (a[i] % g == 0 || a[i] % g == g - 1 || a[i] % g == 1);
l2[i] = l2[i - 1] + (a[i] % g == 0 ? 0 : 1);
}
r1[n + 1] = 1;
r2[n + 1] = 0;
for (int i = n; i > 0; i--) {
r1[i] =
r1[i + 1] && (a[i] % g == 0 || a[i] % g == g - 1 || a[i] % g == 1);
r2[i] = r2[i + 1] + (a[i] % g == 0 ? 0 : 1);
}
long long cur = inf;
if (l1[n]) cur = min(cur, 1ll * l2[n] * y);
long long lft = inf;
for (int j = 1; j <= n; j++) {
if (j >= 2 && l1[j - 1])
lft = min(lft, 1ll * l2[j - 1] * y - 1ll * x * j);
if (r1[j + 1])
cur = min(cur, lft + 1ll * (j + 1) * x + 1ll * r2[j + 1] * y);
}
for (int j = 1; j < n; j++) {
if (r1[j + 1]) cur = min(cur, 1ll * r2[j + 1] * y + 1ll * j * x);
}
ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int N = 1000001;
const long long INF = ~0ull >> 2;
int mpf[N], p[N], pn;
int n, a, b;
int c[N];
long long ans = INF;
long long dp0[N], dp1[N], dp2[N];
inline void update(long long &a, long long b) {
if (a > b) {
a = b;
}
}
void test(int d, int c[], int e) {
for (int i = 1; i < n; i++) {
dp0[i] = dp1[i] = dp2[i] = INF;
int t = c[i] % d;
if (t == 0) {
update(dp0[i], dp0[i - 1]);
update(dp2[i], dp2[i - 1]);
} else if (t == 1 || t == d - 1) {
update(dp0[i], dp0[i - 1] + b);
update(dp2[i], dp2[i - 1] + b);
}
update(dp1[i], dp1[i - 1] + a);
update(dp1[i], dp0[i]);
update(dp2[i], dp1[i]);
}
update(ans, e + dp2[n - 1]);
}
void cal(int x, int c[], int e) {
for (int i = 0; i < pn; i++) {
while (x % p[i] == 0) {
test(p[i], c, e);
x /= p[i];
}
}
if (x != 1) {
test(x, c, e);
}
}
int main() {
for (int i = 2; i < N; i++) {
if (mpf[i] == 0) {
mpf[i] = p[pn++] = i;
} else {
for (int j = 0; j < pn && i * p[j] < N && p[j] < mpf[i]; j++) {
mpf[i * p[j]] = p[j];
}
}
}
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
cal(c[1], c + 1, 0);
cal(c[1] + 1, c + 1, b);
cal(c[1] - 1, c + 1, b);
cal(c[n], c, 0);
cal(c[n] + 1, c, b);
cal(c[n] - 1, c, b);
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long segs[] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
long long n, a, b, val[1000005], dp[1000005][3];
bool primes[1000005];
vector<long long> pms;
bool reachable[1000005][3];
set<long long> check;
void sieve() {
primes[0] = primes[1] = false;
pms.push_back(2);
for (long long i = 4; i < 1000005; i += 2) {
primes[i] = false;
}
for (long long i = 3; i < 1000005; i += 2) {
if (primes[i]) {
pms.push_back(i);
for (long long j = 2 * i; j < 1000005; j += i) {
primes[j] = false;
}
}
}
}
void getPrimes(long long x) {
long long ox = x;
for (long long i = 0; x && pms[i] <= (long long)(sqrt(ox) + 10); i++) {
while (x && x % pms[i] == 0) {
check.insert(pms[i]);
x /= pms[i];
}
}
if (x > 1) check.insert(x);
}
int main() {
memset(primes, true, sizeof(primes));
std::ios::sync_with_stdio(false);
sieve();
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> val[i];
}
for (int i = -1; i <= 1; i++) {
getPrimes(val[0] + i);
getPrimes(val[n - 1] + i);
}
long long res = 10e16;
for (long long p : check) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = 0;
}
}
memset(reachable, false, sizeof(reachable));
for (int i = 0; i < n; i++) {
if (val[i] % p && val[i] > 1) {
if (i == 0) {
if ((val[i] + 1) % p == 0 || (val[i] - 1) % p == 0) {
reachable[0][0] = reachable[0][2] = true;
dp[i][0] = b;
dp[i][2] = b;
}
dp[i][1] = a;
reachable[0][1] = true;
} else {
reachable[i][1] = true;
dp[i][1] = dp[i - 1][1] + a;
if ((val[i] + 1) % p == 0 || (val[i] - 1) % p == 0) {
if (reachable[i - 1][0]) {
dp[i][0] = dp[i - 1][0] + b;
reachable[i][0] = true;
dp[i][1] = min(dp[i][1], dp[i - 1][0] + a);
}
dp[i][2] = dp[i - 1][1] + b;
reachable[i][2] = true;
if (reachable[i - 1][2]) {
dp[i][2] = min(dp[i][2], dp[i - 1][2] + b);
reachable[i][2] = true;
}
}
}
} else {
if (!i) {
dp[0][0] = dp[0][2] = 0;
dp[0][1] = a;
reachable[0][0] = reachable[0][1] = reachable[0][2] = true;
continue;
}
dp[i][1] = dp[i - 1][1] + a;
dp[i][2] = dp[i - 1][1];
reachable[i][1] = true;
reachable[i][2] = true;
if (reachable[i - 1][0]) {
reachable[i][0] = true;
dp[i][0] = dp[i - 1][0];
dp[i][1] = min(dp[i][1], dp[i - 1][0]);
}
if (reachable[i - 1][2]) {
dp[i][2] = min(dp[i][2], dp[i - 1][2]);
}
}
}
for (int i = 0; i < 3; i++) {
if (reachable[n - 1][i]) res = min(res, dp[n - 1][i]);
}
}
cout << res << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::deque;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::queue;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::unordered_map;
using std::unordered_set;
using std::vector;
void init() {
std::iostream::sync_with_stdio(0);
cout << std::fixed;
cout.precision(10);
cerr << std::fixed;
cerr.precision(10);
srand(time(0));
}
const int MAXN = 1e6 + 1;
long long arr[MAXN];
long long dp[MAXN][3];
int n;
long long a, b;
const long long INF = 1e18;
vector<int> fact(int x) {
vector<int> res;
int k = x;
for (int i = 2; i * i <= k; ++i)
if (!(x % i)) {
x /= i;
res.push_back(i);
}
if (x > 1) res.push_back(x);
return res;
}
long long solve(int p) {
for (int i = 0; i <= n; ++i)
for (int j = 0; j < 3; ++j) dp[i][j] = INF;
for (int i = 0; i < 3; ++i) dp[0][i] = 0;
for (int i = 1; i <= n; ++i) {
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
if (arr[i] % p == 0) {
dp[i][0] = dp[i - 1][0];
dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]);
} else if ((arr[i] + 1) % p == 0 || (arr[i] - 1) % p == 0) {
dp[i][0] = dp[i - 1][0] + b;
dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]) + b;
}
}
long long ans = INF;
for (int i = 0; i < 3; ++i) ans = min(ans, dp[n][i]);
return ans;
}
int main() {
init();
cin >> n >> a >> b;
for (int i = 1; i <= n; ++i) cin >> arr[i];
set<int> ma;
for (int i = -1; i <= 1; ++i) {
vector<int> tmp;
tmp = fact(arr[1] + i);
for (auto j : tmp) ma.insert(j);
tmp = fact(arr[n] + i);
for (auto j : tmp) ma.insert(j);
}
long long ans = INF;
for (auto i : ma) ans = min(ans, solve(i));
cout << ans << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, st, ed, ara[1000010], na[1000010], len, t[10], pr;
set<int> s;
set<int>::iterator it;
unsigned long long dp[1000010][5][2];
bool vis[1000010][5][2];
unsigned long long solve(int pos, int st, int fe) {
if (pos > len) {
if (fe && st == 1) return LLONG_MAX;
return 0;
}
if (vis[pos][st][fe]) return dp[pos][st][fe];
unsigned long long op = LLONG_MAX;
if (na[pos] % pr == 0) {
if (st == 0 || st == 2)
op = solve(pos + 1, st, fe);
else
op = min(a + solve(pos + 1, 1, fe || (pos == 1)), solve(pos + 1, 2, fe));
} else {
if (((ara[pos] - 1) % pr == 0) || ((ara[pos] + 1) % pr == 0)) {
if (st == 0 || st == 2)
op = b + solve(pos + 1, st, fe);
else
op = b + solve(pos + 1, 2, fe);
}
if (st != 2) op = min(op, a + solve(pos + 1, 1, fe || (pos == 1)));
}
vis[pos][st][fe] = 1;
return dp[pos][st][fe] = op;
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", &ara[i]);
for (st = 1; st <= n && !ara[st]; st++)
;
for (ed = n; ed >= 1 && !ara[ed]; ed--)
;
for (int i = st; i <= ed; i++) na[++len] = ara[i];
t[1] = na[1], t[2] = na[1] - 1, t[3] = na[1] + 1, t[4] = na[len],
t[5] = na[len] - 1, t[6] = na[len] + 1;
for (int i = 1; i <= 6; i++) {
if (t[i] > 1) {
int sq = sqrt(t[i]);
for (int j = 2; j <= sq && t[i] > 1; j++) {
if (t[i] % j == 0) s.insert(j);
while (t[i] % j == 0) t[i] /= j;
}
if (t[i] != 1) s.insert(t[i]);
}
}
unsigned long long ans = LLONG_MAX;
for (it = s.begin(); it != s.end(); it++) {
pr = *it;
ans = min(ans, solve(1, 0, 0));
memset(vis, 0, sizeof vis);
}
if (ans == LLONG_MAX) ans = 0;
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
int n, arr[1000001], a, b;
vector<int> p;
void doit(int x) {
long long y = 2;
while (y * y <= x) {
int cnt = 0;
while (x % y == 0) x /= y, cnt++;
if (cnt) p.push_back(y);
y++;
}
if (x > 1) p.push_back(x);
}
long long dp[1000001][3], d, inf = 1ll << 58;
long long rec(int p, int s) {
if (p == n) return 0;
if (~dp[p][s]) return dp[p][s];
long long ret = inf;
if (s == 0) {
ret = rec(p + 1, 1) + a;
long long tmp = rec(p + 1, 0);
int need = arr[p] % d;
if (need == 0) {
ret = min(ret, tmp);
} else if (need == 1 || need == d - 1) {
tmp += b;
ret = min(ret, tmp);
}
} else if (s == 1) {
ret = rec(p + 1, 1) + a;
long long tmp = rec(p + 1, 2);
int need = arr[p] % d;
if (need == 0) {
ret = min(ret, tmp);
} else if (need == 1 || need == d - 1) {
tmp += b;
ret = min(ret, tmp);
}
} else {
long long tmp = rec(p + 1, 2);
int need = arr[p] % d;
if (need == 0) {
ret = min(ret, tmp);
} else if (need == 1 || need == d - 1) {
tmp += b;
ret = min(ret, tmp);
}
}
return dp[p][s] = ret;
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
doit(arr[0]);
doit(arr[0] - 1);
doit(arr[0] + 1);
doit(arr[n - 1]);
doit(arr[n - 1] - 1);
doit(arr[n - 1] + 1);
sort((p).begin(), (p).end());
(p).resize(unique((p).begin(), (p).end()) - (p).begin());
long long ans = 1ll << 60;
for (int i = 0; i < p.size(); i++) {
memset((dp), (-1), sizeof(dp));
d = p[i];
ans = min(ans, rec(0, 0));
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9;
const long long linf = 1e18;
long long powm(long long a, long long p, long long m) {
long long r = 1 % m;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
int v[1000000];
set<int> var;
void fact(int x) {
for (int i = 2; i * i <= x; ++i)
for (; x % i == 0; x /= i) var.insert(i);
if (x > 1) var.insert(x);
}
int main() {
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
for (int i = 0; i < n; ++i) scanf("%d", v + i);
for (int i = -1; i < 2; ++i) {
fact(v[0] + i);
fact(v[n - 1] + i);
}
vector<int> s(var.begin(), var.end());
vector<vector<long long> > dp(3, vector<long long>(s.size(), 0));
for (int i = 0; i < n; ++i) {
vector<vector<long long> > tmp(3, vector<long long>(s.size(), linf));
for (int j = 0; j < s.size(); ++j)
for (int k = 0; k < 3; ++k)
if (dp[k][j] < linf) {
for (int d = -1; d < 2; ++d)
if ((v[i] + d) % s[j] == 0) {
if (k == 0 || k == 2)
tmp[k][j] = min(tmp[k][j], dp[k][j] + abs(d) * b);
if (k == 1) tmp[2][j] = min(tmp[2][j], dp[k][j] + abs(d) * b);
}
if (k < 2) tmp[1][j] = min(tmp[1][j], dp[k][j] + a);
}
dp = tmp;
}
long long ans = 1ll * (n - 1) * a;
for (int j = 0; j < s.size(); ++j)
for (int k = 0; k < 3; ++k) ans = min(ans, dp[k][j]);
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const int MOD = int(1e9) + 7;
const unsigned long long N = 1000010;
const long long INFll = 1ll * INF * INF;
const long double ldINF = 1e+018;
const long double EPS = 0.000000001;
const int sdx[4] = {-1, 0, 1, 0};
const int sdy[4] = {0, 1, 0, -1};
const long double PI = 3.1415926535897932384;
template <typename T>
ostream& operator<<(ostream& out, pair<T, T>& a) {
out << a.first << " " << a.second;
return out;
}
template <typename T>
istream& operator>>(istream& in, pair<T, T>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& a) {
for (int i = 0; i < a.size(); ++i) in >> a[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> a) {
for (int i = 0; i < a.size(); ++i)
if (i == a.size() - 1)
out << a[i];
else
out << a[i] << " ";
return out;
}
map<int, bool> used;
vector<int> c;
void go(int x) {
int d = 2;
while (1ll * d * d <= 1ll * x) {
if (x % d == 0) {
if (!used[d]) {
c.push_back(d);
used[d] = true;
}
while (x % d == 0) x /= d;
}
d = (d == 2 ? 3 : d + 1);
}
if (x > 1 && !used[x]) {
c.push_back(x);
used[x] = true;
}
}
int main() {
cin.tie(0);
int n;
unsigned long long a, b;
scanf("%d%I64d%I64d", &n, &a, &b);
vector<int> v(n);
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
go(v[0]);
go(v[0] - 1);
go(v[0] + 1);
go(v.back());
go(v.back() + 1);
go(v.back() - 1);
unsigned long long ans = INFll;
for (int x = 0; x < c.size(); x++) {
int p = c[x];
unsigned long long dp[n + 10][4];
for (int i = 0; i < n + 2; i++) dp[i][0] = dp[i][1] = dp[i][2] = 0;
int m = v[0] % p;
int cnt = min(m, p - m);
unsigned long long value = cnt * b;
dp[0][0] = (cnt < 2 ? value : INFll);
dp[0][1] = a;
dp[0][2] = INFll;
for (int i = 1; i < n; i++) {
m = v[i] % p;
cnt = min(m, p - m);
value = cnt * b;
dp[i][0] = (cnt < 2 ? dp[i - 1][0] + value : INFll);
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
if (cnt < 2)
dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]) + value;
else
dp[i][2] = INFll;
}
ans = min(ans, dp[n - 1][0]);
ans = min(ans, dp[n - 1][1]);
ans = min(ans, dp[n - 1][2]);
}
cout << ans << endl;
if (0)
cerr << fixed << setprecision(0)
<< "TIME = " << clock() / (long double)CLOCKS_PER_SEC * 1000 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e6 + 9, INF = 1e16;
long long arr[MX], dp[MX][3];
set<long long> s;
void FUN(long long x) {
if (x == 2) return;
for (long long i = 2; i * i <= x; i++)
while (x > 1 && x % i == 0) x /= i, s.insert(i);
if (x > 1) s.insert(x);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, a, b;
cin >> n >> a >> b;
for (long long i = 0; i < n; i++) cin >> arr[i];
FUN(arr[0] + 1);
FUN(arr[0]);
FUN(arr[0] - 1);
FUN(arr[n - 1] + 1);
FUN(arr[n - 1]);
FUN(arr[n - 1] - 1);
long long minn = 1e18;
for (long long x : s) {
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (long long i = 1; i <= n; i++) {
if (arr[i - 1] % x == 0 || arr[i - 1] % x == 1 ||
arr[i - 1] % x == x - 1) {
dp[i][0] = dp[i - 1][0] + b * (arr[i - 1] % x != 0);
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + b * (arr[i - 1] % x != 0);
} else {
dp[i][0] = dp[i][2] = INF;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
}
dp[i][0] = min(INF, dp[i][0]), dp[i][1] = min(INF, dp[i][1]),
dp[i][2] = min(INF, dp[i][2]);
}
minn = min(min(minn, dp[n][0]), min(dp[n][1], dp[n][2]));
}
cout << minn;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
const long long inf = 1ll << 42;
int n, a, b, color, l[maxn], bio[maxn][3];
long long dp[maxn][3], sol = 1ll << 62;
long long rek(int p, int na, int id);
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
int d = max(sqrt(l[0]), sqrt(l[n - 1]));
vector<int> v{l[0] - 1, l[0], l[0] + 1, l[n - 1] - 1, l[n - 1], l[n - 1] + 1};
set<int> pr;
for (int i = 2; i <= d; i++) {
for (int j = 0; j < 6; j++) {
bool ima = false;
while (v[j] % i == 0) {
v[j] /= i;
ima = true;
}
if (ima) {
pr.insert(i);
}
}
}
for (int i = 0; i < 6; i++) {
if (v[i] != 1) {
pr.insert(v[i]);
}
}
for (int i : pr) {
color++;
if (rek(i, n - 1, 0) >= 0) sol = min(sol, rek(i, n - 1, 0));
}
cout << sol << endl;
}
long long rek(int p, int na, int id) {
if (na == -1) return 0;
if (bio[na][id] == color) return dp[na][id];
bio[na][id] = color;
int x = l[na];
long long c = inf;
if ((x + 1) % p == 0 || (x - 1) % p == 0)
c = b;
else if (x % p == 0)
c = 0;
if (id == 0)
return dp[na][id] = min(c + rek(p, na - 1, 0), a + rek(p, na - 1, 1));
if (id == 1)
return dp[na][id] = min(c + rek(p, na - 1, 2), a + rek(p, na - 1, 1));
return dp[na][id] = c + rek(p, na - 1, 2);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> ar;
long long int dp[1000005][4];
set<int> prime;
int n, a, b;
long long int ans = 1e18;
void factorise(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
prime.insert(i);
while (n % i == 0) {
n = n / i;
}
}
}
if (n > 1) prime.insert(n);
}
void solve(int gcd) {
for (int i = 0; i <= n; i++) {
dp[i][0] = dp[i][1] = dp[i][2] = 1E15;
}
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 0; i < n; i++) {
long long int cost = 1E15;
int rem = ar[i] % gcd;
if (rem == 1 || rem == gcd - 1) {
cost = b;
} else if (rem == 0)
cost = 0;
for (int j = 0; j < 3; j++) {
if (j == 2) {
dp[i + 1][2] = min(dp[i + 1][2], dp[i][2] + cost);
} else if (j == 1) {
dp[i + 1][2] = min(dp[i + 1][2], dp[i][1] + a);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + a);
dp[i][1] = min(dp[i][1], dp[i][2]);
} else {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + cost);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + a);
dp[i][1] = min(dp[i][1], dp[i][0]);
}
}
}
ans = min(ans, dp[n][0]);
ans = min(ans, dp[n][1]);
ans = min(ans, dp[n][2]);
}
int main() {
cin >> n >> a >> b;
ar.resize(n);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = -1; i <= 1; i++) {
factorise(ar[0] + i);
factorise(ar[n - 1] + i);
}
set<int>::iterator it;
for (it = prime.begin(); it != prime.end(); it++) {
solve(*it);
}
cout << ans;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, st, ed, ara[1000010], na[1000010], len, t[10], pr;
set<int> s;
set<int>::iterator it;
unsigned long long dp[1000010][5][2];
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", &ara[i]);
for (st = 1; st <= n && !ara[st]; st++)
;
for (ed = n; ed >= 1 && !ara[ed]; ed--)
;
for (int i = st; i <= ed; i++) na[++len] = ara[i];
t[1] = na[1], t[2] = na[1] - 1, t[3] = na[1] + 1, t[4] = na[len],
t[5] = na[len] - 1, t[6] = na[len] + 1;
for (int i = 1; i <= 6; i++) {
if (t[i] > 1) {
int sq = sqrt(t[i]);
for (int j = 2; j <= sq && t[i] > 1; j++) {
if (t[i] % j == 0) s.insert(j);
while (t[i] % j == 0) t[i] /= j;
}
if (t[i] != 1) s.insert(t[i]);
}
}
unsigned long long ans = LLONG_MAX;
for (it = s.begin(); it != s.end(); it++) {
pr = *it;
for (int pos = len + 1; pos >= 1; pos--) {
for (int st = 2; st >= 0; st--) {
for (int fe = 1; fe >= 0; fe--) {
if (pos > len) {
if (fe && st == 1)
dp[pos][st][fe] = LLONG_MAX;
else
dp[pos][st][fe] = 0;
continue;
}
unsigned long long op = LLONG_MAX;
if (na[pos] % pr == 0) {
if (st == 0 || st == 2)
op = dp[pos + 1][st][fe];
else
op =
min(a + dp[pos + 1][1][fe || (pos == 1)], dp[pos + 1][2][fe]);
} else {
if (((ara[pos] - 1) % pr == 0) || ((ara[pos] + 1) % pr == 0)) {
if (st == 0 || st == 2)
op = b + dp[pos + 1][st][fe];
else
op = b + dp[pos + 1][2][fe];
}
if (st != 2) op = min(op, a + dp[pos + 1][1][fe || (pos == 1)]);
}
dp[pos][st][fe] = op;
}
}
}
ans = min(ans, dp[1][0][0]);
}
if (ans == LLONG_MAX) ans = 0;
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[95]{};
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int m;
scanf("%d", &m);
arr[m] = 1;
}
int c = 0;
int ans = 0;
int i;
for (i = 1; i <= 90; i++) {
c++;
if (arr[i] != 0) {
c = 0;
}
if (c == 15) {
break;
}
}
if (i == 91) i--;
cout << i;
}
| 7 | CPP |
n=int(input())
tl = list(map(int, input().split()))
time=cnt=0
while cnt <15 and time<90:
time+=1
if tl.count(time)>0:
cnt=0
else:
cnt+=1
print(time) | 7 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
def main():
if a[0] > 15:
print(15)
return
last_interval = a[0]
i = 0
while i < n:
count = a[i] + 15
if i + 1 >= n:
# we're at the last interval
last_interval = a[i]
break
if count < a[i+1]:
# past 15 'boring' minutes until the next interesting interval
print(count)
return
i += 1
# handle last interval
if last_interval + 15 < 90:
print(last_interval + 15)
else:
print(90)
return
if __name__ == "__main__":
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, i, j, k, m, n, v;
cin >> n;
int A[n];
cin >> A[0];
if (A[0] > 15) {
cout << 15;
return (0);
}
for (j = 1; j < n; j++) {
cin >> A[j];
}
for (i = 1; i < n; i++) {
if ((A[i] - A[i - 1]) > 15) {
cout << A[i - 1] + 15;
return (0);
}
}
if (90 - A[n - 1] > 15)
cout << A[n - 1] + 15;
else
cout << 90;
return (0);
}
| 7 | CPP |
n = int(input())
t = [0] + [int(x) for x in input().split(' ')]
answer = min(90, t[-1] + 15)
for i in range(n):
if t[i + 1] - t[i] > 15:
answer = min(t[i] + 15, 90)
break
print(answer)
| 7 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
diff=0
for i in a:
if(i-diff>15):
break
else:
diff=i
diff=min(90,diff+15)
print(diff) | 7 | PYTHON3 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.