text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
void RD(int &x) { scanf("%d", &x); }
void RD(long long &x) { scanf("%I64d", &x); }
void RD(unsigned int &x) { scanf("%u", &x); }
void RD(double &x) { scanf("%lf", &x); }
void RD(int &x, int &y) { scanf("%d%d", &x, &y); }
void RD(long long &x, long long &y) { scanf("%I64d%I64d", &x, &y); }
void RD(unsigned int &x, unsigned int &y) { scanf("%u%u", &x, &y); }
void RD(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void RD(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void RD(long long &x, long long &y, long long &z) {
scanf("%I64d%I64d%I64d", &x, &y, &z);
}
void RD(unsigned int &x, unsigned int &y, unsigned int &z) {
scanf("%u%u%u", &x, &y, &z);
}
void RD(double &x, double &y, double &z) { scanf("%lf%lf%lf", &x, &y, &z); }
void RD(char &x) { x = getchar(); }
void RD(char *s) { scanf("%s", s); }
void RD(string &s) { cin >> s; }
void PR(int x) { printf("%d\n", x); }
void PR(long long x) { printf("%I64d\n", x); }
void PR(unsigned int x) { printf("%u\n", x); }
void PR(double x) { printf("%.6lf\n", x); }
void PR(char x) { printf("%c\n", x); }
void PR(char *x) { printf("%s\n", x); }
void PR(string x) { cout << x << endl; }
const int N = 5005;
long long a[N], p[N], q[N];
int n, f[N];
int OK(int x, int y) {
if (q[x] % q[y]) return 0;
return p[y] - p[x] == y - x || p[y] <= y - x - 1;
}
int main() {
RD(n);
int i, j;
for (i = 1; i <= n; i++) RD(a[i]);
for (i = 1; i <= n; i++) {
p[i] = 0;
while (a[i] % 2 == 0) p[i]++, a[i] >>= 1;
q[i] = a[i];
}
for (i = 1; i <= n; i++) {
f[i] = i - 1;
for (j = 1; j < i; j++)
if (OK(j, i)) {
f[i] = ((f[i]) < (f[j] + i - j - 1) ? (f[i]) : (f[j] + i - j - 1));
}
}
int ans = n;
for (i = 1; i <= n; i++)
ans = ((ans) < (f[i] + n - i) ? (ans) : (f[i] + n - i));
PR(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100003;
const int MOD = 1000000007;
int n;
long long a[N];
int dp[N];
int main() {
while (scanf("%d", &n) == 1) {
for (int i = n - 1; i >= 0; --i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
dp[i] = max(dp[i], 1);
long long t = a[i];
for (int j = i + 1; j < n; ++j) {
if (t & 1) {
if (a[j] % t == 0) dp[j] = max(dp[j], dp[i] + 1);
} else {
t /= 2;
if (a[j] % t == 0 && (a[j] / t % 2 == 1))
dp[j] = max(dp[j], dp[i] + 1);
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans = max(ans, dp[i]);
}
printf("%d\n", n - ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int f[5100], b[5100];
long long a[5100];
int n;
bool solve(int i, int j) {
int len = i - j;
if (a[j] % a[i] != 0) return 0;
if (b[i] < len) return 1;
return b[i] == b[j] + len;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
for (; a[i] % 2 == 0; a[i] /= 2) b[i]++;
}
for (int i = 1; i <= n; i++) f[i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++)
if (solve(i, j)) f[i] = max(f[j] + 1, f[i]);
int ans = n - 1;
for (int i = 1; i <= n; i++) ans = min(ans, n - f[i]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[5005], dp[5005], cnt[5005], b[5005];
int main() {
while (cin >> n) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i <= n; ++i) dp[i] = 1000000000000L;
for (int i = 0; i < n; ++i) {
cin >> a[i];
while (a[i] > 0 && a[i] % 2 == 0) a[i] /= 2, cnt[i]++;
}
a[n] = 1;
cnt[n] = 0;
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
dp[i] = i;
for (int j = 0; j < i; ++j)
if (a[j] % a[i] == 0 &&
(cnt[i] == 0 || (i - j) == (cnt[i] - cnt[j]) || (i - j) > cnt[i]))
dp[i] = min(dp[i], dp[j] + i - j - 1);
}
cout << dp[n] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, a[5100], dp[5100], p2[5100];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
int i, j;
for (i = 1; i <= N; i++) {
cin >> a[i];
while (a[i] % 2 == 0) a[i] /= 2, p2[i]++;
}
dp[1] = 0;
long long res = N - 1;
for (i = 2; i <= N; i++) {
dp[i] = i - 1;
for (j = i - 1; j > 0; j--) {
if (a[j] % a[i] != 0) continue;
if (p2[i] - p2[j] == i - j || p2[i] < i - j)
dp[i] = min(dp[i], i - j - 1 + dp[j]);
}
res = min(res, dp[i] + (N - i));
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5005;
long long a[N], cnt[N], dp[N];
bool ok(int j, int i) {
if (a[j] % a[i]) return false;
if (cnt[i] == 0) return true;
if (cnt[i] - cnt[j] == i - j) return true;
if (cnt[i] < i - j) return true;
return false;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
while (a[i] % 2 == 0) {
a[i] /= 2;
cnt[i]++;
}
}
a[n] = 1;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = i;
for (int j = 0; j < i; j++) {
if (ok(j, i)) dp[i] = std::min(dp[i], dp[j] + i - j - 1);
}
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
int64_t N;
int64_t as[5000];
int64_t dp[5000];
int main() {
scanf("%I64d", &N);
for (int64_t i = 0; i < N; i++) {
scanf("%I64d", &as[i]);
}
int64_t best = N - 1;
for (int64_t i = 1; i < N; i++) {
dp[i] = i;
int64_t v = as[i];
for (int64_t j = i - 1; j >= 0; j--) {
if (v % 2 == 0) {
v /= 2;
if ((as[j] % v == 0) && ((as[j] / v) % 2 == 1)) {
dp[i] = std::min(dp[i], dp[j] + i - j - 1);
}
} else {
if (as[j] % v == 0) {
dp[i] = std::min(dp[i], dp[j] + i - j - 1);
}
}
}
best = std::min(best, dp[i] + N - i - 1);
}
printf("%I64d\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void RD(int &x) { scanf("%d", &x); }
void RD(long long &x) { scanf("%I64d", &x); }
void RD(unsigned int &x) { scanf("%u", &x); }
void RD(double &x) { scanf("%lf", &x); }
void RD(int &x, int &y) { scanf("%d%d", &x, &y); }
void RD(long long &x, long long &y) { scanf("%I64d%I64d", &x, &y); }
void RD(unsigned int &x, unsigned int &y) { scanf("%u%u", &x, &y); }
void RD(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void RD(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void RD(long long &x, long long &y, long long &z) {
scanf("%I64d%I64d%I64d", &x, &y, &z);
}
void RD(unsigned int &x, unsigned int &y, unsigned int &z) {
scanf("%u%u%u", &x, &y, &z);
}
void RD(double &x, double &y, double &z) { scanf("%lf%lf%lf", &x, &y, &z); }
void RD(char &x) { x = getchar(); }
void RD(char *s) { scanf("%s", s); }
void RD(string &s) { cin >> s; }
void PR(int x) { printf("%d\n", x); }
void PR(long long x) { printf("%I64d\n", x); }
void PR(unsigned int x) { printf("%u\n", x); }
void PR(double x) { printf("%.6lf\n", x); }
void PR(char x) { printf("%c\n", x); }
void PR(char *x) { printf("%s\n", x); }
void PR(string x) { cout << x << endl; }
const int N = 5005;
long long a[N], p[N], q[N];
int n, f[N];
int OK(int x, int y) {
if (q[x] % q[y]) return 0;
if (!p[y]) return 1;
return p[y] - p[x] == y - x || p[y] <= y - x - 1;
}
int main() {
RD(n);
int i, j;
for (i = 1; i <= n; i++) RD(a[i]);
for (i = 1; i <= n; i++) {
p[i] = 0;
while (a[i] % 2 == 0) p[i]++, a[i] >>= 1;
q[i] = a[i];
}
for (i = 1; i <= n; i++) {
f[i] = i - 1;
for (j = 1; j < i; j++)
if (OK(j, i)) {
f[i] = ((f[i]) < (f[j] + i - j - 1) ? (f[i]) : (f[j] + i - j - 1));
}
}
int ans = n;
for (i = 1; i <= n; i++)
ans = ((ans) < (f[i] + n - i) ? (ans) : (f[i] + n - i));
PR(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
int n, dp[MAXN], two[MAXN];
long long a[MAXN], b[MAXN];
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
scanf("%I64d", &a[i]);
two[i] = __builtin_ctzll(a[i]);
b[i] = a[i] >> two[i];
}
dp[0] = 1;
for (int i = (1); i < (n); i++) {
dp[i] = 1;
for (int j = (0); j < (i); j++) {
if (b[j] % b[i] == 0 && (two[i] - two[j] == i - j || two[i] < i - j)) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
}
printf("%d\n", n - *max_element(dp, dp + n));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
long long ln, lk, lm;
int v2(long long &x) {
int a = 0;
while (x % 2 == 0) {
a++;
x /= 2;
}
return a;
}
long long a[5105], v[5105];
int dp[5105];
bool ck(int i, int j) {
long long ai = a[i], aj = a[j];
int vi = v[i], vj = v[j];
if (ai % aj == 0) {
if (vi + j - i == vj || vj <= j - i - 1) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) {
scanf("%lld", a + i);
v[i] = v2(a[i]);
}
for (int(j) = 0; (j) < (int)(n); (j)++) {
dp[j] = 1;
for (int(i) = 0; (i) < (int)(j); (i)++)
if (ck(i, j)) dp[j] = max(dp[j], dp[i] + 1);
}
int ans = 0;
for (int(i) = 0; (i) < (int)(n); (i)++) ans = max(ans, dp[i]);
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10000;
long long a[MAXN], b[MAXN], f[MAXN];
int check(int i, int j) {
if (a[i] % a[j] != 0) return false;
if (b[j] == 0) return true;
if (b[i] + (j - i) == b[j]) return true;
if (j - i - 1 >= b[j]) return true;
return false;
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) b[i] = 0;
for (int i = 1; i <= n; i++) {
while (a[i] % 2 == 0) {
a[i] /= 2;
b[i]++;
}
}
n++;
a[n] = 1;
b[n] = 0;
for (int i = 1; i <= n; i++) f[i] = i - 1;
for (int i = 1; i < n; i++)
for (int j = i + 1; j <= n; j++)
if (check(i, j)) {
f[j] = min(f[i] + (j - i - 1), f[j]);
}
cout << f[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 10;
long long ans, n;
long long dp[maxn], t2[maxn], a[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) {
a[i] /= 2;
t2[i]++;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) {
if ((t2[j] + i - j == t2[i] || t2[i] <= i - j - 1) && a[j] % a[i] == 0)
dp[i] = max(dp[i], dp[j]);
}
dp[i]++;
ans = max(ans, dp[i]);
}
cout << n - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[5001];
int pw2[5001], dp[5001];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", a + i);
while (a[i] % 2 == 0) {
++pw2[i];
a[i] /= 2;
}
}
int ans = 1000000000;
for (int i = 1; i <= n; ++i) {
dp[i] = i - 1;
for (int j = 1; j < i; ++j)
if ((a[j] % a[i] == 0) && (j < i - pw2[i] || pw2[j] == pw2[i] - (i - j)))
dp[i] = min(dp[i], dp[j] + (i - j - 1));
ans = min(ans, dp[i] + (n - i));
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int f[6000];
long long a[6000];
int main() {
scanf("%d", &n);
for (int i = n - 1; i >= 0; --i) cin >> a[i];
for (int i = 0; i < n; ++i) {
f[i] = max(f[i], 1);
long long k = a[i];
for (int j = i + 1; j < n; ++j) {
if (k & 1) {
if (a[j] % k == 0) f[j] = max(f[i] + 1, f[j]);
} else {
k /= 2;
if (a[j] % k == 0 && a[j] / k % 2 == 1) f[j] = max(f[j], f[i] + 1);
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) ans = max(ans, f[i]);
printf("%d\n", n - ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, two[5010], dp[5010];
long long a[5010];
int work(int s) {
if (s > n) return 0;
if (dp[s] != -1) return dp[s];
dp[s] = 0;
for (int i = s + 1; i <= n; i++)
if (s == 0)
dp[s] = max(dp[s], work(i) + 1);
else if (a[s] % a[i] == 0)
if (two[i] - two[s] == i - s || two[i] <= i - s - 1)
dp[s] = max(dp[s], work(i) + 1);
return dp[s];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
two[i] = 0;
while (!(a[i] & 1)) {
two[i]++;
a[i] >>= 1;
}
}
memset(dp, -1, sizeof(dp));
printf("%d\n", n - work(0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
int qpow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ret;
}
int n;
int num2[5005], dp[5005];
long long a[5005];
bool good(long long x, long long y) { return x % y == 0; }
int main() {
scanf("%d", &n);
for (int(i) = (1); (i) <= (n); (i)++) scanf("%lld", a + i);
for (int(i) = (1); (i) <= (n); (i)++) {
while (!(a[i] & 1)) a[i] >>= 1, num2[i]++;
}
for (int(i) = (1); (i) <= (n); (i)++) dp[i] = 1;
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (i - 1); (j) >= (1); (j)--) {
if ((num2[j] + i - j == num2[i] || num2[i] < i - j) && good(a[j], a[i]))
chmax(dp[i], dp[j] + 1);
}
int ans = 0;
for (int(i) = (1); (i) <= (n); (i)++) ans = max(ans, dp[i]);
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, f[5010], b[5010];
long long a[5010];
bool judge(int l, int r) {
if (l == 0 || r == n + 1) return true;
if (a[l] % a[r])
return false;
else if (b[l] + r - l != b[r] && r - l - 1 < b[r])
return false;
return true;
}
int main() {
memset(f, 0x3f, sizeof f);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
while (1) {
if (a[i] & 1) break;
b[i]++;
a[i] >>= 1;
}
}
f[0] = 0;
for (int i = 1; i <= n + 1; i++)
for (int j = 0; j < i; j++)
if (judge(j, i)) f[i] = min(f[i], f[j] + i - j - 1);
cout << f[n + 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[5050];
int t[5050];
bool can(int x, int y) {
if (a[x] % a[y] != 0) return 0;
if (y - x == t[y] - t[x]) return 1;
if (y - t[y] > x) return 1;
return 0;
}
int dp[5050];
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
t[i] = 0;
while (a[i] % 2 == 0) a[i] /= 2, t[i]++;
}
memset(dp, 0, sizeof(dp));
int ans = 0;
for (int i = 1; i <= n; i++) {
dp[i] = 1;
for (int j = 1; j < i; j++)
if (can(j, i)) dp[i] = max(dp[i], dp[j] + 1);
ans = max(ans, dp[i]);
}
printf("%d\n", n - ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const bool read_file = false;
const char fi[] = "XX.INP";
const char fo[] = "XX.OUT";
void set_up() {
if (read_file) {
freopen(fi, "r", stdin);
freopen(fo, "w", stdout);
}
cin.clear();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void just_do_it();
int main() {
set_up();
just_do_it();
}
const int ms = 5e3 + 20;
int n;
long long a[ms];
int c[ms];
int f[ms];
int dp[ms];
bool check(int j, int i, int deg) {
long long x = a[j];
long long y = a[i];
int m = c[j];
int n = c[i];
if (x % y == 0) {
if (n - m == deg || deg - 1 >= n) {
return true;
} else {
return false;
}
} else {
return false;
}
}
void just_do_it() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) {
a[i] /= 2;
c[i]++;
}
}
fill_n(dp, ms, ms);
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = min(dp[i], i);
for (int j = 0; j < i; j++) {
if (check(j, i, i - j)) {
dp[i] = min(dp[i], dp[j] + i - j - 1);
}
}
}
int res = ms;
for (int i = 0; i < n; i++) {
res = min(res, dp[i] + n - i - 1);
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 10;
long long n, a[MAXN], f[MAXN];
long long p[MAXN], ans;
int main() {
cin >> n;
ans = n;
for (long long i = (1); i <= (n); i++) {
cin >> a[i];
while (a[i] % 2 == 0) {
a[i] /= 2;
p[i]++;
}
}
for (long long i = (2); i <= (n); i++) {
f[i] = i - 1;
for (long long j = (i - 1); j >= (1); j--) {
long long len = i - j - 1;
if (a[j] % a[i] == 0 && (p[i] <= len || p[i] - p[j] == len + 1))
f[i] = (f[i] < f[j] + len ? f[i] : f[j] + len);
}
}
for (long long i = (1); i <= (n); i++) {
ans = (ans < f[i] + n - i ? ans : f[i] + n - i);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100000];
int dp[100000];
bool f(long long x, long long y, int step) {
if (x & 1) {
return y % x == 0;
} else {
if (step < 55 && ((x >> step) << step) == x) {
x >>= step;
return y % x == 0 && ((y / x) & 1);
} else {
int i;
for (i = 32; i > 0; i >>= 1)
if (((x >> i) << i) == x) x >>= i;
return y % x == 0;
}
}
}
int main() {
int i, j, k, n, an = 1;
scanf("%d", &n);
for (i = 1; i <= n; i++) cin >> a[n - i + 1];
dp[1] = 1;
for (i = 2; i <= n; i++) {
dp[i] = 1;
for (j = 1; j < i; j++)
if (f(a[j], a[i], i - j)) {
dp[i] = max(dp[i], dp[j] + 1);
}
an = max(an, dp[i]);
}
cout << n - an << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[5005][5005], c[5005];
long long a[5005], b[5005];
bool pd(int x, int y, int z) {
if (x == 0) return 1;
if (y == 0) return x <= z;
return x < z || x - y == z;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
b[i] = a[i];
while (!(b[i] & 1)) b[i] >>= 1, c[i]++;
}
a[n + 1] = b[n + 1] = 1;
memset(dp, 0x3f, sizeof dp);
dp[n][n] = 0;
dp[n][n + 1] = 1;
for (int i = n; i >= 2; i--) {
for (int j = i; j <= n + 1; j++)
if (dp[i][j] < 5005) {
dp[i - 1][j] = min(dp[i - 1][j], dp[i][j] + 1);
if (a[i - 1] % b[j] == 0 && pd(c[j], c[i - 1], j - i + 1))
dp[i - 1][i - 1] = min(dp[i - 1][i - 1], dp[i][j]);
}
}
int Ans = n;
for (int i = 1; i <= n; i++) Ans = min(Ans, dp[1][i]);
printf("%d\n", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5010;
long long ans = 1 << 28, n, seq[N], p2s[N], dp[N];
int main() {
cin >> n;
for (int i = 0; n - i; ++i) {
cin >> seq[i];
while (!(seq[i] & 1)) {
seq[i] /= 2;
++p2s[i];
}
dp[i] = i;
for (int j = i - 1; j + 1; --j)
if (!(seq[j] % seq[i]) &&
((p2s[i] <= i - j - 1) || (p2s[i] - p2s[j] == i - j)))
dp[i] = min(dp[i], dp[j] + i - j - 1);
ans = min(ans, dp[i] + n - i - 1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
const long long LINF = 1e15;
const int N_ = 5005;
int N;
long long D[N_], E[N_];
int P2[N_];
int Table[N_];
int res = -1;
int main() {
int i, j, k;
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%I64d", &D[i]);
long long &tmp = E[i];
tmp = D[i];
while ((tmp & 1) == 0) tmp >>= 1, ++P2[i];
}
for (i = N; i > 0; i--) {
Table[i] = 1;
for (j = i + 1; j <= N; j++) {
bool c1 = (Table[i] <= Table[j]);
bool c2 = (E[i] % E[j] == 0);
bool c3 = (P2[j] == P2[i] + (j - i) || P2[j] < (j - i));
if (c1 && c2 && c3) Table[i] = Table[j] + 1;
}
}
for (i = 1; i <= N; i++) {
res = max(res, Table[i]);
}
printf("%d\n", N - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, l, f[5005], b[5005], ans;
long long a[5005];
int main() {
scanf("%d", &n);
for (i = n; i > 0; --i) {
scanf("%I64d", &a[i]);
b[i] = 0;
while (a[i] % 2 == 0) {
++b[i];
a[i] /= 2;
}
}
a[0] = 1;
b[0] = 0;
for (i = 0; i <= n; ++i) f[i] = i;
for (i = 1; i <= n; ++i) {
for (j = 0; j < i; ++j) {
if ((b[j] < i - j || b[i] == b[j] - i + j) && a[i] % a[j] == 0)
f[i] = min(f[i], f[j] + i - j - 1);
}
}
ans = n;
for (i = 0; i <= n; ++i) {
if (ans > f[i] + n - i) ans = f[i] + n - i;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, dp[5500];
long long a[5500];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%I64d", &a[i]);
dp[0] = 0;
for (int i = 1; i <= N; i++) {
dp[i] = i - 1;
long long x = a[i];
for (int j = i - 1; j >= 1; j--) {
if (x % 2) {
if (a[j] % x == 0) dp[i] = min(dp[i], dp[j] + i - j - 1);
} else {
if (a[j] % (x / 2) == 0 && a[j] / (x / 2) % 2 == 1)
dp[i] = min(dp[i], dp[j] + i - j - 1);
x /= 2;
}
}
}
int ans = N;
for (int i = 1; i <= N; i++) ans = min(ans, dp[i] + N - i);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5005;
long long a[N], cnt[N], dp[N];
bool ok(int j, int i) {
if (a[j] % a[i]) return false;
if (cnt[i] == 0)
return true;
else {
if (cnt[i] - cnt[j] == i - j) return true;
if (cnt[i] < i - j) return true;
return false;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
while (a[i] % 2 == 0) {
a[i] /= 2;
cnt[i]++;
}
}
a[n] = 1;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = i;
for (int j = 0; j < i; j++) {
if (ok(j, i)) dp[i] = std::min(dp[i], dp[j] + i - j - 1);
}
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 5005;
int f[N], cnt[N];
long long val[N];
bool jud(int i, int j) {
if (val[i] % val[j]) return 0;
if (!cnt[j]) return 1;
if (cnt[j] + 1 <= j - i) return 1;
if (cnt[j] - cnt[i] == j - i) return 1;
return 0;
}
int main() {
scanf("%d", &n);
int r = 0;
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &val[i]);
while (val[i] && val[i] % 2 == 0) val[i] /= 2, cnt[i]++;
int z = val[i];
for (int j = i - 1; j; --j)
if (jud(j, i)) f[i] = max(f[j] + 1, f[i]);
r = max(r, f[i]);
}
cout << n - r - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 7;
const int M = 100000 + 2;
const int inf = 1e9 + 7;
const long long linf = 1ll * inf * inf + 7;
const double pi = acos(-1);
const double eps = 1e-9;
const bool multipleTest = 0;
int n;
int dp[N];
long long a[N];
int cnt[N];
bool can(int i, int j) {
if (a[i] % a[j] != 0) return false;
if (cnt[j] == 0) return true;
if (cnt[j] + 1 <= j - i) return true;
if (cnt[j] - cnt[i] == j - i) return true;
return false;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
while (a[i] % 2 == 0) {
++cnt[i];
a[i] >>= 1;
}
dp[i] = i - 1;
for (int j = 1; j < i; ++j) {
if (can(j, i)) dp[i] = min(dp[i], dp[j] + i - j - 1);
}
}
int ans = n;
for (int i = 1; i <= n; ++i) ans = min(ans, dp[i] + n - i);
cout << ans << '\n';
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
long long a[maxn], b[maxn], dp[maxn];
long long n, ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
ans = n;
for (int y = 1; y <= n; y++) {
cin >> a[n + 1 - y];
while (!(a[n + 1 - y] & 1)) a[n + 1 - y] /= 2, b[n + 1 - y]++;
}
for (int y = 1; y <= n; y++) {
dp[y] = 1;
for (int x = 1; x < y; x++) {
if (a[y] % a[x] != 0) continue;
if ((y - x >= b[x] + (b[y] != 0)) || (y - x == b[x] - b[y]))
dp[y] = max(dp[y], dp[x] + 1);
}
ans = min(ans, n - dp[y]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<long long> in, d2, nech;
int main() {
scanf("%d", &N);
in.resize(N);
d2.resize(N, 0);
nech.resize(N, 0);
for (int i = 0; i < N; ++i) scanf("%Ld", &in[i]);
for (int i = 0; i < N; ++i) {
nech[i] = in[i];
while (!(nech[i] & 1)) {
nech[i] >>= 1;
++d2[i];
}
}
vector<int> dp(N, 1);
for (int i = 1; i < N; ++i) {
for (int j = 0; j < i; ++j) {
if (nech[j] % nech[i] != 0) continue;
if (d2[i] >= i - j && d2[j] != d2[i] - (i - j)) continue;
(dp[i]) = max((dp[i]), (1 + dp[j]));
}
}
int ans = 0;
for (int i = 0; i < N; ++i) (ans) = max((ans), (dp[i]));
printf("%d\n", N - ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 5100;
long long a[maxN];
int f2[maxN];
int n;
int dp[maxN];
bool check(int i, int j) {
if (a[i] % a[j] == 0) {
if (f2[i] + j - i == f2[j] || f2[j] < j - i) {
return true;
}
}
return false;
}
int main() {
cin >> n;
int res = n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
while (a[i] % 2 == 0) {
a[i] /= 2;
++f2[i];
}
}
dp[0] = 1;
res = min(res, n - dp[0]);
for (int i = 1; i < n; ++i) {
dp[i] = 1;
for (int j = 0; j < i; ++j) {
if (check(j, i)) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
res = min(res, n - dp[i]);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10001;
int n;
long long f[maxn], b[maxn], a[maxn];
inline long long max(long long a, long long b) { return a > b ? a : b; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
while (a[i] % 2 == 0) {
a[i] /= 2;
b[i]++;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i - 1; j++)
if (a[j] % a[i] == 0 && (b[j] + i - j == b[i] || b[i] <= i - j - 1))
f[i] = max(f[i], f[j]);
f[i]++;
ans = max(ans, f[i]);
}
cout << n - ans << endl;
fclose(stdin);
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[5000];
int f[5000], ans;
int main() {
int n;
{
char ch;
while (!isdigit(ch = getchar()))
;
n = ch - 48;
while (isdigit(ch = getchar())) n = n * 10 + ch - 48;
};
ans = n;
for (int i = -1; ++i != n;) {
char ch;
while (!isdigit(ch = getchar()))
;
a[i] = ch - 48;
while (isdigit(ch = getchar())) a[i] = a[i] * 10 + ch - 48;
};
for (int i = 0; ++i != n;) {
f[i] = i;
long long x = a[i];
for (int j = i; j--;) {
if ((a[j] << 1) % x == 0 && ((x & 1) || a[j] % x != 0)) {
f[i] = min(f[i], f[j] + i - j - 1);
}
if (~x & 1) x >>= 1;
}
ans = min(ans, f[i] + n - 1 - i);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long A[200006], pr[200006];
long long dp[200006];
void solve() {
cin >> n;
for (long long i = (1), iend = (n); i <= iend; ++i) {
scanf("%lld", A + i);
while (A[i] % 2 == 0) A[i] /= 2, ++pr[i];
}
long long re = n + 1;
for (long long i = (1), iend = (n); i <= iend; ++i) {
dp[i] = i - 1;
for (long long j = (1), jend = (i - 1); j <= jend; ++j) {
if (A[j] % A[i] == 0 && (pr[i] < i - j || pr[i] - pr[j] == i - j))
dp[i] = min(dp[i], dp[j] + (i - j - 1));
}
re = min(re, dp[i] + n - i);
}
cout << re << endl;
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1039714778;
template <typename T>
inline void chmin(T &x, const T &b) {
x = (x < b ? x : b);
}
template <typename T>
inline void chmax(T &x, const T &b) {
x = (x > b ? x : b);
}
int n;
long long a[5005];
int dp[5005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%lld", a + i);
}
reverse(a, a + n);
memset(dp, 0x3f, sizeof(dp));
int res = inf;
for (int i = 0; i < n; i++) {
chmin(dp[i], i);
for (int j = i + 1; j < n; j++) {
long long t = a[i], rm = j - i - 1;
while (t % 2 == 0 && rm > 0) t /= 2, rm--;
if (((t & 1) && a[j] % t == 0) || ((t % 2 == 0) && a[j] % t == t / 2)) {
chmin(dp[j], dp[i] + (j - i - 1));
}
}
chmin(res, dp[i] + n - i - 1);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100003;
const int MOD = 1000000007;
int n;
long long a[N];
int dp[N];
int main() {
while (scanf("%d", &n) == 1) {
for (int i = n - 1; i >= 0; --i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
dp[i] = max(dp[i], 1);
long long k = a[i];
for (int j = i + 1; j < n; ++j) {
if (k & 1) {
if (a[j] % k == 0) dp[j] = max(dp[i] + 1, dp[j]);
} else {
k /= 2;
if (a[j] % k == 0 && a[j] / k % 2 == 1) dp[j] = max(dp[j], dp[i] + 1);
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans = max(ans, dp[i]);
}
printf("%d\n", n - ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[6000];
long long mem[6000];
int tp[6000];
long long tp1[6000];
int n;
long long val[6000];
int ok[6000][6000];
int get(int id) {
if (id == (n - 1)) return 0;
if (vis[id]) return mem[id];
int i, ret = 0;
for (i = id + 1; i < n; i++) {
if (ok[id][i]) ret = max(ret, 1 + get(i));
}
vis[id] = 1;
mem[id] = ret;
return ret;
}
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%I64d", &val[i]);
for (i = 0; i < n; i++) {
long long t = 1;
for (j = 0; j <= 60; j++) {
if ((val[i] % t) == 0) {
tp[i] = j;
tp1[i] = t;
}
t *= 2;
}
}
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) {
if (((val[i] / tp1[i]) % (val[j] / tp1[j])) == 0) {
if ((j - tp[j]) <= i) {
if ((j - tp[j]) == (i - tp[i])) ok[i][j] = 1;
} else {
ok[i][j] = 1;
}
}
}
int ans = 0;
for (i = 0; i < n; i++) {
ans = max(ans, get(i) + 1);
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
long long b[MAXN + 10], e[MAXN + 10];
int git(int i, int j) {
if (b[i] % b[j] != 0) {
return 0;
}
if (e[j] == e[i] + (j - i)) {
return 1;
}
if (e[j] < j - i) {
return 1;
}
return 0;
}
int dp[MAXN + 10];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
scanf("%lld", &b[i]);
while (b[i] % 2 == 0) {
++e[i];
b[i] /= 2;
}
}
int res = 0;
for (int i = 0; i < (n); ++i) {
dp[i] = 1;
for (int j = 0; j < (i); ++j) {
if (git(j, i)) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
res = max(res, dp[i]);
}
printf("%d\n", n - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[5050];
int t[5050];
int dp[5050];
int get(int p) {
if (dp[p] + 1) return dp[p];
if (p == 0) return 0;
int ret = p;
for (int i = p - 1; i >= 0; i--) {
;
if (v[i] % v[p]) continue;
if (t[p] > p - i - 1 && t[i] != t[p] - p + i) continue;
ret = min(ret, get(i) + p - i - 1);
};
return dp[p] = ret;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", v + i);
while (v[i] % 2 == 0) v[i] /= 2, t[i]++;
}
memset(dp, -1, sizeof(dp));
int ans = n;
for (int i = n - 1; i >= 0; i--) ans = min(ans, get(i) + n - i - 1);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5000 + 10;
long long int a[M];
int dp[M];
long long int maxodd[M];
long long int fac2[M];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
long long int tmp = a[i];
while (tmp % 2 == 0) {
fac2[i]++;
tmp = tmp / 2;
}
maxodd[i] = tmp;
}
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = 1;
for (int j = 1; j <= i - 1; j++) {
if (maxodd[j] % maxodd[i] == 0) {
bool ok1 = (fac2[i] - fac2[j] == i - j);
bool ok2 = (fac2[i] <= i - j - 1);
if (ok1 || ok2) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
}
}
int res = dp[1];
for (int i = 1; i <= n; i++) {
res = max(res, dp[i]);
}
cout << n - res << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long a[5010];
int best[5010];
int two[5010];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%I64d", a + i);
two[i] = 0;
while ((a[i] & (1LL << two[i])) == 0) {
++two[i];
}
best[i] = i;
}
int answer = n;
best[0] = 0;
for (int i = 0; i < n; ++i) {
if (best[i] + n - 1 - i < answer) {
answer = best[i] + n - 1 - i;
}
for (int j = i + 1; j < n; ++j) {
bool check = false;
if (a[j] % 2 == 1) {
if (a[i] % a[j] == 0) {
check = true;
}
} else {
if (j - i > two[j]) {
if (a[i] % (a[j] >> two[j]) == 0) {
check = true;
}
} else {
long long t = a[j] >> (j - i);
if (a[i] % t == 0 && (a[i] / t) % 2 == 1) {
check = true;
}
}
}
if (check && best[i] + j - i - 1 < best[j]) {
best[j] = best[i] + j - i - 1;
}
}
}
printf("%d\n", answer);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
long long a[N];
int dp[N], cnt[N];
bool ok(int i, int j) {
if (a[i] % a[j]) return false;
if (cnt[i] < cnt[j]) {
if (cnt[j] - cnt[i] > j - i) return false;
if (cnt[j] - cnt[i] == j - i) return true;
if (cnt[j] > j - i - 1) return false;
return true;
}
if (cnt[j] > j - i - 1) return false;
return true;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", a + i);
while (a[i] % 2 == 0) a[i] /= 2, cnt[i]++;
}
fill(dp, dp + n, 1);
for (int i = n - 1; i > -1; i--)
for (int j = i + 1; j < n; j++)
if (ok(i, j)) dp[i] = max(dp[i], dp[j] + 1);
int ans = n - 1;
for (int i = 0; i < n; i++) ans = min(ans, n - dp[i]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[6000], dp[6000], cnt[6000], b[6000];
int init() {
const int _106 = 1000001;
bool data[_106 + 100];
int prime[80000], cost[80000];
int a, b, k;
while (~scanf("%d%d%d", &a, &b, &k)) {
int _begin = 0, _end = 0, ii = 1;
while (_begin == 0) {
if (prime[ii] >= a) _begin = ii;
ii++;
}
while (_end == 0) {
if (prime[ii] >= b) _end = ii;
ii++;
}
int _beginc = 0, _endc = 0, kkkk;
kkkk = k;
if (prime[_end] > b) {
_end--;
}
_endc = b - prime[_end];
while (kkkk--) {
_endc = _endc + cost[_end - kkkk + 1];
}
kkkk = k;
if (a < prime[_begin]) {
_beginc = prime[_begin] - a;
}
while (kkkk--) {
_beginc = _beginc + cost[_begin + kkkk];
}
if (_end - _begin + 1 < k) {
printf("-1\n");
break;
}
int maxc = max(_beginc, _endc);
int s = 0;
for (int i = _begin + 1; i <= _begin + k; i++) {
s = s + k;
maxc = max(maxc, s);
}
for (int i = _begin + k + 1; i <= _end; i++) {
s = s + cost[i] - cost[i - k];
maxc = max(maxc, s);
}
printf("%d\n", maxc);
}
return 0;
}
int mian() {
int mapp[100][100], a[1000], ansk, ans[1000][4], n, hang[100];
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &hang[i]);
}
int k = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= hang[i]; j++) {
scanf("%d", &mapp[i][j]);
a[k++] = mapp[i][j];
}
}
sort(a, a + k);
ansk = 0;
k = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= hang[i]; j++) {
int t = a[k++];
if (mapp[i][j] == t) continue;
for (int i1 = i; i1 <= n; i1++) {
for (int j1 = 1; j1 <= hang[i1]; j1++) {
if (mapp[i1][j1] == t) {
ans[ansk][0] = i;
ans[ansk][1] = j;
ans[ansk][2] = i1;
ans[ansk][3] = j1;
ansk++;
swap(mapp[i][j], mapp[i1][j1]);
}
}
}
}
}
cout << ansk << endl;
for (int i = 0; i < ansk; i++) {
cout << ans[i][0] << " " << ans[i][1] << " " << ans[i][2] << " "
<< ans[i][3] << endl;
}
return 0;
}
int main() {
while (cin >> n) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i <= n; ++i) {
dp[i] = 10000000000000;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
while (a[i] > 0 && a[i] % 2 == 0) a[i] /= 2, cnt[i]++;
}
a[n] = 1;
cnt[n] = 0;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = i;
for (int j = 0; j < i; j++) {
if (a[j] % a[i] == 0 &&
(cnt[i] == 0 || (i - j) == (cnt[i] - cnt[j]) || (i - j) > cnt[i]))
dp[i] = min(dp[i], dp[j] + i - j - 1);
}
}
cout << dp[n] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void RD(int &x) { scanf("%d", &x); }
void RD(long long &x) { scanf("%I64d", &x); }
void RD(unsigned int &x) { scanf("%u", &x); }
void RD(double &x) { scanf("%lf", &x); }
void RD(int &x, int &y) { scanf("%d%d", &x, &y); }
void RD(long long &x, long long &y) { scanf("%I64d%I64d", &x, &y); }
void RD(unsigned int &x, unsigned int &y) { scanf("%u%u", &x, &y); }
void RD(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void RD(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void RD(long long &x, long long &y, long long &z) {
scanf("%I64d%I64d%I64d", &x, &y, &z);
}
void RD(unsigned int &x, unsigned int &y, unsigned int &z) {
scanf("%u%u%u", &x, &y, &z);
}
void RD(double &x, double &y, double &z) { scanf("%lf%lf%lf", &x, &y, &z); }
void RD(char &x) { x = getchar(); }
void RD(char *s) { scanf("%s", s); }
void RD(string &s) { cin >> s; }
void PR(int x) { printf("%d\n", x); }
void PR(long long x) { printf("%I64d\n", x); }
void PR(unsigned int x) { printf("%u\n", x); }
void PR(double x) { printf("%.6lf\n", x); }
void PR(char x) { printf("%c\n", x); }
void PR(char *x) { printf("%s\n", x); }
void PR(string x) { cout << x << endl; }
const int N = 5005;
long long a[N], p[N], q[N];
int n, f[N];
int OK(int x, int y) {
if (q[x] % q[y]) return 0;
if (!p[y]) return 1;
if (p[y] - p[x] == y - x) return 1;
return p[y] <= y - x - 1;
}
int main() {
RD(n);
int i, j;
for (i = 1; i <= n; i++) RD(a[i]);
for (i = 1; i <= n; i++) {
p[i] = 0;
while (a[i] % 2 == 0) p[i]++, a[i] >>= 1;
q[i] = a[i];
}
for (i = 1; i <= n; i++) {
f[i] = i - 1;
for (j = 1; j < i; j++)
if (OK(j, i)) {
f[i] = ((f[i]) < (f[j] + i - j - 1) ? (f[i]) : (f[j] + i - j - 1));
}
}
int ans = n;
for (i = 1; i <= n; i++)
ans = ((ans) < (f[i] + n - i) ? (ans) : (f[i] + n - i));
PR(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans, f[5005];
long long a[5005], x;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
for (int i = 1; i <= n; i++) {
f[i] = 1;
x = a[i];
for (int j = i - 1; j; j--) {
if (x & 1 ? (a[j] % x == 0) : (a[j] % x == x / 2))
f[i] = max(f[i], f[j] + 1);
x& 1 ? 0 : x >>= 1;
}
}
for (int i = 1; i <= n; i++) ans = max(f[i], ans);
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[5005][5005], precal[5005];
long long ara[5005];
int solve(int now, int prv) {
if (now < 0) return 0;
int &ret = dp[now][prv];
if (ret != -1) return ret;
long long prvval = (ara[prv] >> min(prv - now - 1, precal[prv]));
ret = 1 + solve(now - 1, prv);
if ((prvval % 2 && ara[now] % prvval == 0) ||
(prvval % 2 == 0 && ara[now] % prvval == (prvval >> 1)))
ret = min(ret, solve(now - 1, now));
return ret;
}
int main() {
int i, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &ara[i]);
precal[i] = __builtin_ctzll(ara[i]);
}
ara[n] = 1;
precal[n] = 0;
memset(dp, -1, sizeof(dp));
cout << solve(n - 1, n) << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5005;
long long a[N], cnt[N], dp[N];
bool ok(int j, int i) {
if (a[j] % a[i]) return false;
if (cnt[i] == 0)
return true;
else {
if (cnt[i] - cnt[j] == i - j) return true;
if (cnt[i] < i - j) return true;
}
return false;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
while (a[i] % 2 == 0) {
a[i] /= 2;
cnt[i]++;
}
}
a[n] = 1;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = i;
for (int j = 0; j < i; j++) {
if (ok(j, i)) dp[i] = std::min(dp[i], dp[j] + i - j - 1);
}
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s[5010];
int dp[5010];
long long even[5010];
long long odd[5010];
bool ok(int i, int j) {
if (odd[i] % odd[j] != 0) return false;
if (even[i] + j - i == even[j]) return true;
if (even[j] <= j - i - 1) return true;
return false;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &s[i]);
long long now = s[i];
even[i] = 0;
while (now % 2 == 0) {
even[i]++;
now /= 2;
}
odd[i] = now;
}
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = 0; j < i; j++)
if (ok(j, i)) dp[i] = max(dp[i], dp[j] + 1);
}
int mm = 0;
for (int i = 0; i < n; i++) mm = max(mm, dp[i]);
printf("%d\n", n - mm);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[5001];
int pw2[5001], dp[501];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", a + i);
while (a[i] % 2 == 0) {
++pw2[i];
a[i] /= 2;
}
}
int ans = 1000000000;
for (int i = 1; i <= n; ++i) {
dp[i] = i - 1;
for (int j = 1; j < i; ++j)
if ((a[j] % a[i] == 0) && (j < i - pw2[i] || pw2[j] == pw2[i] - (i - j)))
dp[i] = min(dp[i], dp[j] + (i - j - 1));
ans = min(ans, dp[i] + (n - i));
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
long long a[5005], f[5005], v[5005];
int n, dp[5005];
void init() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
for (f[i] = a[i]; f[i] % 2 == 0; f[i] /= 2) v[i]++;
}
}
void work() {
int i, j, ans = n;
for (i = 1; i <= n; ++i) {
dp[i] = 1;
for (j = 1; j <= i - 1; ++j) {
if (f[j] % f[i] == 0 && (v[j] + i - j == v[i] || v[i] <= i - j - 1))
dp[i] = max(dp[j] + 1, dp[i]);
}
ans = min(ans, n - dp[i]);
}
cout << ans << endl;
}
int main() {
init();
work();
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[10010];
int dp[10010], b[10010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) {
b[i]++;
a[i] /= 2;
}
}
dp[0] = 1;
int ans = n;
for (int i = 0; i < n; i++) {
dp[i] = i;
for (int j = 0; j < i; j++)
if (a[j] % a[i] == 0 && (b[j] + i - j == b[i] || b[i] <= i - j - 1))
dp[i] = min(dp[j] + i - j - 1, dp[i]);
ans = min(ans, n - i - 1 + dp[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
long long ans;
long long jc[4010];
long long c[4010][4010];
int w, n, b;
int main() {
int i, j;
for (i = 0; i <= 4000; ++i) {
c[i][0] = 1;
for (j = 1; j <= i; ++j) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= 1000000009) c[i][j] -= 1000000009;
}
}
jc[0] = 1;
for (i = 1; i <= 4000; ++i) jc[i] = jc[i - 1] * i % 1000000009;
scanf("%d%d%d", &n, &w, &b);
for (i = 2; n - i; ++i)
ans = (ans + c[w - 1][i - 1] * c[b - 1][n - i - 1] % 1000000009 * (i - 1)) %
1000000009;
ans = ans * jc[w] % 1000000009 * jc[b] % 1000000009;
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4010;
const int mod = 1e9 + 9;
int n, w, b;
int num[maxn * 2], inv[maxn * 2];
int pp(int a, int b) {
if (!b) return 1;
int cnt = pp(a, b / 2);
cnt = 1ll * cnt * cnt % mod;
if (b & 1) cnt = 1ll * cnt * a % mod;
return cnt;
}
int calc(int n, int m) {
if (n < m) return 0;
return 1ll * num[n] * num[n - 1] % mod * inv[m - 1] % mod * inv[n - m] % mod;
}
int main() {
cin >> n >> w >> b;
num[0] = 1;
for (int i = 1; i <= w + b; ++i) num[i] = 1ll * num[i - 1] * i % mod;
inv[w + b] = pp(num[w + b], mod - 2);
for (int i = w + b - 1; i >= 0; --i)
inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
int ans = 0;
for (int i = 1; i < n - 1; ++i) {
int cur = n - i - 1;
cur = 1ll * cur * calc(w, n - i) % mod * calc(b, i) % mod;
(ans += cur) %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
const int N = 4040;
int n, w, b;
long long fac[N], f[N][N], inv[N];
long long qpow(long long x, long long p) {
long long res = 1ll;
while (p) {
if (p & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
p >>= 1;
}
return res;
}
long long INV(long long k) { return qpow(k, mod - 2); }
long long calc(int x, int y) {
return fac[x] * inv[y] % mod * inv[x - y] % mod;
}
void init() {
fac[0] = 1ll;
inv[0] = 1ll;
for (int i = 1; i < N; i++) {
fac[i] = (fac[i - 1] * 1ll * i) % mod;
inv[i] = INV(fac[i]);
}
}
int main() {
scanf("%d%d%d", &n, &w, &b);
init();
for (int i = 1; i <= n; i++) {
for (int j = i; j < N; j++) {
f[i][j] = (fac[j] * calc(j - 1, i - 1)) % mod;
}
}
long long ans = 0;
for (int i = 1; i < n - 1; i++) {
ans =
(ans + f[n - i][w] * f[i][b] % mod * (1ll * n - 1ll * i - 1ll) % mod) %
mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fpow(int a, int n) {
long long ans = 1, tmp = a;
while (n) {
if (n & 1) ans = ans * tmp % 1000000009;
tmp = tmp * tmp % 1000000009, n >>= 1;
}
return ans;
}
int fac[1000000 + 5], inv[1000000 + 5], w, b, n, ans = 0;
long long c(int n, int m) {
return m > n ? 0
: fac[n] * 1ll * inv[m] % 1000000009 * inv[n - m] % 1000000009;
}
int main() {
scanf("%d%d%d", &n, &w, &b);
fac[0] = 1;
for (int i = 1; i <= 1000000; i++) fac[i] = fac[i - 1] * 1ll * i % 1000000009;
inv[1000000] = fpow(fac[1000000], 1000000009 - 2);
for (int i = 1000000; i; i--) inv[i - 1] = inv[i] * 1ll * i % 1000000009;
for (int i = 1; i < n - 1; i++)
for (int j = i + 1; j < n; j++)
ans += c(w - 1, i + n - j - 1) * c(b - 1, j - i - 1) % 1000000009,
ans %= 1000000009;
ans = ans * 1ll * fac[b] % 1000000009 * fac[w] % 1000000009;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 9;
int C[4009][4009];
long long fact[4009];
int n, w, b;
int main() {
fact[0] = 1;
for (int i = 1; i < 4009; i++) fact[i] = fact[i - 1] * i % MOD;
for (int i = 0; i < 4009; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
cin >> n >> w >> b;
long long ans = 0, len1, len2;
for (int i = 2; i < n; i++) {
for (int j = i; j < n; j++) {
len1 = j - i + 1;
len2 = n - len1;
ans = (ans + 1LL * C[b - 1][len1 - 1] * C[w - 1][len2 - 1] % MOD *
fact[b] % MOD * fact[w] % MOD) %
MOD;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct _ {
_() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
stringstream ss;
} _;
template <class A, class B>
ostream &operator<<(ostream &o, pair<A, B> t) {
o << "(" << t.first << ", " << t.second << ")";
return o;
}
template <class T>
inline string tostring(T first) {
_.ss.clear();
_.ss.str("");
_.ss << first;
return _.ss.str();
}
template <class T>
inline T convert(const string &s) {
char *p;
if (is_integral<T>())
return strtoll(s.c_str(), &p, 10);
else
return strtod(s.c_str(), &p);
}
template <class T>
void PV(T a, T b, int p = 0, int w = 0, string s = " ") {
int c = 0;
while (a != b) {
cout << setw(w) << *a++;
cout << ((a != b && (!p || ++c % p)) ? s : "\n");
}
cout.flush();
}
template <class T>
inline bool chmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool chmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
const long long linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = int(1e9) + 9;
const int N = 100010;
inline long long exp(long long first, long long n, long long m = mod) {
if (m == 0) m = LLONG_MAX;
first = first % m;
if (first < 0) first += m;
if (first == 0 || m == 1) return 0;
long long r = 1;
while (n > 0) {
if (n & 1) r = r * first % m;
first = first * first % m;
n >>= 1;
}
return r;
}
const int Z = 1000010;
long long ff[Z], iff[Z];
struct Factorial {
Factorial(int n = Z) {
ff[0] = 1;
for (int i = 1; i < n; i++) ff[i] = ff[i - 1] * i % mod;
iff[n - 1] = exp(ff[n - 1], mod - 2);
for (int i = n - 1; i > 0; i--) iff[i - 1] = iff[i] * i % mod;
}
} FF;
inline long long C(int n, int m) {
if (m < 0 || m > n) return 0;
return ff[n] * iff[m] % mod * iff[n - m] % mod;
}
int main() {
int n, a, b;
cin >> n >> a >> b;
long long res = 0;
for (int len = 1; len + 2 <= n; len++) {
res += (long long)C(b - 1, len - 1) * C(a - 1, n - len - 1) % mod * ff[a] %
mod * ff[b] % mod * (n - len - 1) % mod;
}
res %= mod;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long a, long long k) {
long long t;
for (t = 1; k;
t = (k & 1) ? t * a % 1000000009 : t, k >>= 1, a = a * a % 1000000009)
;
return t;
}
long long inv(long long a) { return qpow(a, 1000000009 - 2); }
long long fac(long long n) {
long long t;
for (t = 1; n; t = t * (n--) % 1000000009)
;
return t;
}
long long mul(long long a, long long b) { return a * b % 1000000009; }
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
long long ans = (w - 1);
ans = mul(ans, mul(fac(w), fac(b)));
ans = mul(ans, mul(fac(w + b - 3), inv(fac(n - 3))));
ans = mul(ans, inv(fac(w + b - n)));
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, b;
const int MOD = 1000000009;
long long c[4005][4005];
int main() {
for (int i = 0; i < 4005; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
c[i][j] = 1;
else {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
if (c[i][j] > MOD) c[i][j] -= MOD;
}
}
}
scanf("%d%d%d", &n, &w, &b);
long long ans = 0;
for (int i = 1; i < n; i++)
for (int j = 1; i + j < n; j++) {
int k = n - i - j;
ans = (ans + c[w - 1][n - j - 1] * c[b - 1][j - 1]) % MOD;
}
for (int i = 1; i <= w; i++) ans = ans * i % MOD;
for (int i = 1; i <= b; i++) ans = ans * i % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(0)
namespace orz {
inline void read(int &x) { scanf("%d", &x); }
inline void read(unsigned int &x) { scanf("%u", &x); }
inline void read(long long &x) { scanf("%I64d", &x); }
inline void read(unsigned long long &x) { scanf("%I64u", &x); }
inline void read(double &x) { scanf("%lf", &x); }
inline void read(long double &x) {
double tmp;
read(tmp);
x = tmp;
}
inline void read(char &x) { x = getchar(); }
inline void read(char *x) { scanf("%s", x); }
template <class T>
inline void read(T *a, int n) {
for (int i = (0); i < (n); ++i) read(a[i]);
}
template <class T1, class T2>
inline void read(T1 &a, T2 &b) {
read(a);
read(b);
}
template <class T1, class T2, class T3>
inline void read(T1 &a, T2 &b, T3 &c) {
read(a);
read(b);
read(c);
}
template <class T1, class T2, class T3, class T4>
inline void read(T1 &a, T2 &b, T3 &c, T4 &d) {
read(a);
read(b);
read(c);
read(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void read(T1 &a, T2 &b, T3 &c, T4 &d, T5 &e) {
read(a);
read(b);
read(c);
read(d);
read(e);
}
inline void write(int x) { printf("%d", x); }
inline void write(unsigned int x) { printf("%u", x); }
inline void write(long long x) { printf("%I64d", x); }
inline void write(unsigned long long x) { printf("%I64u", x); }
inline void write(double x) { printf("%.10lf", x); }
inline void write(long double x) { printf("%.10lf", (double)x); }
inline void write(char x) { putchar(x); }
inline void write(char *x) { printf("%s", x); }
template <class T>
inline void writes(T x) {
write(x);
putchar(' ');
}
template <class T1, class T2>
inline void writes(T1 a, T2 b) {
writes(a);
writes(b);
}
template <class T1, class T2, class T3>
inline void writes(T1 a, T2 b, T3 c) {
writes(a);
writes(b);
writes(c);
}
template <class T1, class T2, class T3, class T4>
inline void writes(T1 a, T2 b, T3 c, T4 d) {
writes(a);
writes(b);
writes(c);
writes(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void writes(T1 a, T2 b, T3 c, T4 d, T5 e) {
writes(a);
writes(b);
writes(c);
writes(d);
writes(e);
}
template <class T1, class T2>
inline void writesln(T1 a, T2 b) {
writes(a);
writes(b);
putchar('\n');
}
template <class T1, class T2, class T3>
inline void writesln(T1 a, T2 b, T3 c) {
writes(a);
writes(b);
writes(c);
putchar('\n');
}
template <class T1, class T2, class T3, class T4>
inline void writesln(T1 a, T2 b, T3 c, T4 d) {
writes(a);
writes(b);
writes(c);
writes(d);
putchar('\n');
}
template <class T1, class T2, class T3, class T4, class T5>
inline void writesln(T1 a, T2 b, T3 c, T4 d, T5 e) {
writes(a);
writes(b);
writes(c);
writes(d);
writes(e);
putchar('\n');
}
template <class T1, class T2>
inline void writeln(T1 a, T2 b) {
write(a);
write(b);
putchar('\n');
}
template <class T1, class T2, class T3>
inline void writeln(T1 a, T2 b, T3 c) {
write(a);
write(b);
write(c);
putchar('\n');
}
template <class T1, class T2, class T3, class T4>
inline void writeln(T1 a, T2 b, T3 c, T4 d) {
write(a);
write(b);
write(c);
write(d);
putchar('\n');
}
template <class T1, class T2, class T3, class T4, class T5>
inline void writeln(T1 a, T2 b, T3 c, T4 d, T5 e) {
write(a);
write(b);
write(c);
write(d);
write(e);
putchar('\n');
}
template <class T1, class T2>
inline void write(T1 a, T2 b) {
write(a);
write(b);
}
template <class T1, class T2, class T3>
inline void write(T1 a, T2 b, T3 c) {
write(a);
write(b);
write(c);
}
template <class T1, class T2, class T3, class T4>
inline void write(T1 a, T2 b, T3 c, T4 d) {
write(a);
write(b);
write(c);
write(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void write(T1 a, T2 b, T3 c, T4 d, T5 e) {
write(a);
write(b);
write(c);
write(d);
write(e);
}
template <class T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
template <class T>
inline void writeln(T *a, int n) {
for (int i = (0); i < (n); ++i) write(a[i]);
putchar('\n');
}
template <class T>
inline void writesln(T *a, int n) {
for (int i = (0); i < (n); ++i) writes(a[i]);
putchar('\n');
}
template <class T>
inline void writelnln(T *a, int n) {
for (int i = (0); i < (n); ++i) writeln(a[i]);
}
} // namespace orz
using namespace orz;
const long long MOD = 1000000009LL;
inline long long pow(long long x, int y) {
long long ans = 1;
for (int i = (30); i >= (0); --i) {
ans = ans * ans % MOD;
if (y & (1 << i)) ans = ans * x % MOD;
}
return ans;
}
long long fac[4086], invfac[4086];
inline long long C(int x, int y) {
if (x < y)
return 0;
else
return fac[x] * invfac[y] % MOD * invfac[x - y] % MOD;
}
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
fac[0] = invfac[0] = 1;
for (int i = (1); i <= (4008); ++i) {
fac[i] = fac[i - 1] * (long long)i % MOD;
invfac[i] = invfac[i - 1] * (long long)pow(i, MOD - 2) % MOD;
}
long long ans = 0;
for (int i = (2); i < (n); ++i)
ans = (ans + (long long)(i - 1) * fac[w] % MOD * fac[b] % MOD *
C(w - 1, i - 1) % MOD * C(b - 1, n - i - 1) % MOD) %
MOD;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[4005], v[4005], a;
const int p = 1e9 + 9;
long long C(int x, int y) { return (long long)s[x] * v[y] % p * v[x - y] % p; }
int main() {
s[0] = v[0] = s[1] = v[1] = 1;
for (int i = 2; i <= 4000; ++i) v[i] = (long long)(p - p / i) * v[p % i] % p;
for (int i = 2; i <= 4000; ++i)
s[i] = (long long)s[i - 1] * i % p, v[i] = (long long)v[i - 1] * v[i] % p;
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
for (int i = max(n - w, 1); i <= min(n - 2, b); ++i)
a = (a + (long long)(n - i - 1) * s[b] % p * s[w] % p * C(b - 1, i - 1) %
p * C(w - 1, n - i - 1)) %
p;
return !printf("%d\n", a);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65000000")
using namespace std;
template <typename T>
T mabs(const T &a) {
return a < 0 ? -a : a;
}
const double PI = acos(-1.0);
const int mod = 1e9 + 9;
long long toPow(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long C(int n, int k) {
long long res = 1;
for (int j = (1), ej = (k + 1); j < ej; j++)
res = (res * (n - j + 1) % mod) * toPow(j, mod - 2) % mod;
return res;
}
void run() {
int n, w, b;
cin >> n >> w >> b;
long long c = C(w + b - 3, n - 3);
for (int i = (2), ei = (w + 1); i < ei; i++) c = (c * i) % mod;
for (int i = (2), ei = (b + 1); i < ei; i++) c = (c * i) % mod;
c = c * (w - 1) % mod;
cout << c << endl;
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000 + 23;
const long long MOD = 1000000009;
long long F[maxn][maxn], P[maxn], ans;
int n, w, b;
void init() {
P[0] = 1;
for (int i = 1; i <= maxn - 1; i++) P[i] = (P[i - 1] * (long long)(i)) % MOD;
for (int i = 1; i <= maxn - 1; i++) F[i][1] = F[i][i] = P[i];
for (int i = 2; i <= maxn - 1; i++)
for (int j = 1; j <= i; j++)
F[i][j] = ((long long)(j)*F[i - 1][j - 1] +
(long long)(i + j - 1) * F[i - 1][j]) %
MOD;
}
int main() {
scanf("%d%d%d", &n, &w, &b);
init();
ans = 0;
for (int i = 1; i <= n - 2; i++)
ans = (ans + (((F[b][i] * F[w][n - i]) % MOD) * (long long)(n - i - 1))) %
MOD;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009;
int fac[4010], inv[4010];
int qpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) {
ans = (long long)ans * x % mod;
}
y >>= 1;
x = (long long)x * x % mod;
}
return ans;
}
inline int C(int x, int y) {
if (x < y) {
return 0;
}
return (long long)fac[x] * inv[x - y] % mod * inv[y] % mod;
}
int main() {
int n, w, b;
cin >> n >> w >> b;
fac[0] = 1, inv[0] = 1;
for (int i = 1; i <= 4000; i++) {
fac[i] = (long long)fac[i - 1] * i % mod;
inv[i] = qpow(fac[i], mod - 2);
}
int ans = 0;
for (int i = 2; i <= n; i++) {
for (int j = i; j < n; j++) {
ans = (ans + (long long)fac[w] * fac[b] % mod * C(w - 1, n - j + i - 2) %
mod * C(b - 1, j - i) % mod) %
mod;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long a, long long k) {
long long t;
for (t = 1; k;
t = (k & 1) ? t * a % 1000000009 : t, k >>= 1, a = a * a % 1000000009)
;
return t;
}
long long inv(long long a) { return qpow(a, 1000000009 - 2); }
long long fac(long long n) {
long long t;
for (t = 1; n; t = t * (n--) % 1000000009)
;
return t;
}
long long mul(long long a, long long b) { return a * b % 1000000009; }
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
long long ans = (w - 1);
ans = mul(ans, mul(fac(w), fac(b)));
ans = mul(ans, mul(fac(w + b - 3), inv(fac(n - 3))));
ans = mul(ans, inv(fac(w + b - n)));
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, b, ans;
int C[4010][4010];
int main() {
scanf("%d%d%d", &n, &w, &b);
for (int i = 0; i <= w || i <= b; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= 1000000009) C[i][j] -= 1000000009;
}
}
for (int i = 1; i <= n - 2 && i < w; i++)
for (int j = i + 1; j <= n - 1 && j - i <= b; j++) {
ans += 1ll * C[w - 1][i + n - j - 1] * C[b - 1][j - i - 1] % 1000000009;
if (ans >= 1000000009) ans -= 1000000009;
}
for (int i = 1; i <= w; i++) ans = 1ll * ans * i % 1000000009;
for (int i = 1; i <= b; i++) ans = 1ll * ans * i % 1000000009;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int n, w, b;
const long long int mod = 1000000009;
int C[4005][4005];
int main() {
for (int i = 0; i < 4003; ++i) {
C[i][0] = 1;
for (int j = 0; j < i; ++j)
C[i][j + 1] = (C[i - 1][j + 1] + C[i - 1][j]) % mod;
}
cin >> n >> w >> b;
long long int res = 0;
for (int l = 1; l < n - 1; ++l)
for (int r = l + 1; r < n; ++r) {
int len = r - l, wlen = n - len;
if (b - len < 0 || w - wlen < 0) continue;
res += C[b - 1][b - len] * (long long int)C[w - 1][w - wlen] % mod;
res %= mod;
}
for (int i = 0; i < w; ++i) res = res * (i + 1) % mod;
for (int i = 0; i < b; ++i) res = res * (i + 1) % mod;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m1, m2;
long long C[4005][4005], f[4005], ret;
long long MOD = 1000000009;
int main() {
for (int i = 0; i <= 4000; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
f[0] = 1;
for (int i = (1); i <= (4000); i++) f[i] = (f[i - 1] * i) % MOD;
ret = 0;
scanf("%d%d%d", &n, &m1, &m2);
for (int i = (1); i <= (m1); i++)
for (int j = (1); j <= (m2); j++)
if (i + j < n && n - j <= m1) {
ret += C[m2 - 1][j - 1] * f[m2] % MOD * C[m1 - 1][n - j - 1] % MOD *
f[m1] % MOD;
ret %= MOD;
}
printf("%d\n", (int)ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[4001][8001];
int main() {
int n, i, j, m, w, b, k;
while (~scanf("%d%d%d", &n, &w, &b)) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= max(w, b); j++)
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j - 1]) % 1000000009;
long long ans = 0;
for (i = 1; i <= n - 2; i++) {
long long add =
(dp[i][b] * dp[n - i][w] % 1000000009) * (n - i - 1) % 1000000009;
ans = (ans + add) % 1000000009;
}
for (i = 1; i <= w; i++) ans = ans * i % 1000000009;
for (i = 1; i <= b; i++) ans = ans * i % 1000000009;
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 10000 + 7, Mod = 1000000000 + 9;
;
long long n, w, b, Fac[N], Inv[N];
inline long long KSM(long long x, long long p) {
long long Ret = 1;
while (p) {
if (p & 1) Ret = Ret * x % Mod;
x = x * x % Mod, p >>= 1;
}
return Ret;
}
inline void Init(long long n) {
Fac[0] = 1;
for (long long i = (1), iLimit = (n); i <= iLimit; (++(i)))
Fac[i] = Fac[i - 1] * i % Mod;
Inv[n] = KSM(Fac[n], Mod - 2);
for (long long i = (n - 1), iLimit = (0); i >= iLimit; (--(i)))
Inv[i] = Inv[i + 1] * (i + 1) % Mod;
}
inline long long C(long long n, long long m) {
if (n < m) return 0;
return Fac[n] * Inv[m] % Mod * Inv[n - m] % Mod;
}
signed main() {
cin >> n >> w >> b;
Init(N - 1);
long long Ret = 0;
for (long long i = (1), iLimit = (n - 2); i <= iLimit; (++(i)))
for (long long j = (i + 1), jLimit = (n - 1); j <= jLimit; (++(j)))
(Ret += C(w - 1, i + n - j - 1) * C(b - 1, j - i - 1) % Mod) %= Mod;
cout << Ret * Fac[w] % Mod * Fac[b] % Mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long C[4001][4001];
long long n, W, B;
long long f;
void init(void) {
long long N = (((W) < (B)) ? (B) : (W));
C[0][0] = 1;
for (int i = 1; i <= N; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000009;
}
}
f = 1;
for (int i = 2; i <= W; ++i) {
f = (f * i) % 1000000009;
}
for (int i = 2; i <= B; ++i) {
f = (f * i) % 1000000009;
}
}
int main(int argc, char *argv[]) {
cin >> n >> W >> B;
init();
long long total = 0;
long long start = (((2) < (n - B)) ? (n - B) : (2));
long long end = (((W) > (n - 1)) ? (n - 1) : (W));
for (long long w = start; w <= end; ++w) {
long long b = n - w;
long long sub =
((((((w - 1) * C[W - 1][w - 1]) % 1000000009) * C[B - 1][b - 1]) %
1000000009) *
f) %
1000000009;
total = (total + sub) % 1000000009;
}
cout << total << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4000 + 10;
const int Mod = (int)1e9 + 9;
int n, w, b;
int P[MAX];
int f[MAX][MAX];
int main() {
scanf("%d%d%d", &n, &w, &b);
int i, j;
P[0] = 1;
for ((i) = (1); (i) != (MAX); ++(i)) P[i] = (long long)P[i - 1] * i % Mod;
f[0][0] = 1;
for ((i) = (1); (i) != (MAX); ++(i))
for ((j) = (1); (j) != (MAX); ++(j))
f[i][j] = (f[i - 1][j - 1] + (long long)f[i][j - 1] * (j - 1 + i)) % Mod;
long long ans = 0;
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (j + i < n && n - j - i > 0)
ans = (ans + (long long)f[n - i][w] * P[n - i] % Mod * f[i][b] % Mod *
P[i] % Mod) %
Mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long C[4005][4005], ans;
void yanghui() {
int i, j;
C[0][0] = C[1][0] = C[1][1] = 1;
for (i = 2; i <= 4000; i++) {
C[i][0] = C[i][i] = 1;
for (j = 1; j < i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000009;
}
}
int main() {
yanghui();
int n, w, b;
long long A[4005];
A[1] = 1;
for (int i = 2; i <= 4000; i++) A[i] = A[i - 1] * i % 1000000009;
scanf("%d%d%d", &n, &w, &b);
ans = 0;
for (int i = 1; i <= b; i++) {
int k = n - i;
if (k > w) continue;
if (k < 2) break;
;
ans = (ans + C[b - 1][i - 1] * C[w - 1][k - 1] % 1000000009 * (k - 1) %
1000000009) %
1000000009;
}
ans = ans * A[b] % 1000000009 * A[w] % 1000000009;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000009;
int c[4010][4010];
int main() {
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
memset(c, 0, sizeof(c));
for (int i = 0; i <= 4000; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % md;
}
int res = 0;
for (int i = 1; i <= n; i++)
for (int j = max(n - a, 1); j <= min(n - i - 1, b); j++) {
int k = n - i - j;
res = ((long long)c[a - 1][i + k - 1] * c[b - 1][j - 1] + res) % md;
}
for (int i = 1; i <= a; i++) res = (long long)res * i % md;
for (int i = 1; i <= b; i++) res = (long long)res * i % md;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long c[4010][4010];
long long je[4010];
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
int tmp = max(max(n, w), b);
for (int i = 0; i <= tmp; i++) {
c[i][0] = 1;
}
for (int i = 1; i <= tmp; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000009;
}
}
int tmp2 = max(w, b);
je[0] = 1;
for (int i = 1; i <= tmp2; i++) {
je[i] = (je[i - 1] * (long long)i) % 1000000009;
}
long long ans = 0;
for (int i = 1; i <= b; i++) {
long long tmp = n - i - 1;
if (!tmp) break;
;
tmp = (tmp * c[b - 1][i - 1]) % 1000000009;
tmp = (tmp * je[b]) % 1000000009;
tmp = (tmp * c[w - 1][n - 1 - i]) % 1000000009;
tmp = (tmp * je[w]) % 1000000009;
ans = (ans + tmp) % 1000000009;
};
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 4000 + 5;
const int mod = 1000 * 1000 * 1000 + 9;
int fac[maxN];
inline int power(int n, int k) {
if (k == 0) return 1;
int ans = power(n, k / 2);
ans = (1LL) * ans * ans % mod;
if (k & 1) ans = (1LL) * ans * n % mod;
return ans;
}
inline int C(int n, int k) {
if (n < k) return 0;
int ans = fac[n];
ans = (1LL) * ans * power(fac[k], mod - 2) % mod;
ans = (1LL) * ans * power(fac[n - k], mod - 2) % mod;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie();
fac[0] = 1;
for (int i = 1; i < maxN; i++) fac[i] = (1LL) * fac[i - 1] * i % mod;
int n, w, b;
cin >> n >> w >> b;
int ans = 0;
for (int j = 1; j < min(b + 1, n - 1); j++) {
int x = n - j;
int tmp1 = (1LL) * fac[b] * C(b - 1, j - 1) % mod;
int tmp2 = (1LL) * fac[w] * C(w - 1, n - j - 1) % mod;
ans += (1LL) * ((1LL) * tmp1 * tmp2 % mod) * (x - 1) % mod;
ans %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 9;
long long C[4005][4005];
long long P[4005];
inline long long Calc(int n, int k) { return C[n][k]; }
int main() {
C[0][0] = 1;
for (int i = 1; i <= 4000; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
P[0] = 1;
for (int i = 1; i <= 4000; i++) P[i] = (P[i - 1] * i) % MOD;
int n, x, y;
scanf("%d%d%d", &n, &x, &y);
long long ans = 0;
for (int i = 2; i < n; i++)
for (int j = i; j < n; j++) {
if (j - i + 1 > y) continue;
if (n - j > x - i + 1) continue;
ans = ans + ((Calc(x - 1, n - j + i - 2) * P[x] % MOD) *
Calc(y - 1, j - i) % MOD) *
P[y] % MOD;
ans = ans % MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 8005, mod = 1000000009;
int n, w, b, ans;
int fac[maxn], nfac[maxn], inv[maxn];
inline int c(int n, int m) {
return n < m ? 0 : 1ll * fac[n] * nfac[m] % mod * nfac[n - m] % mod;
}
int main() {
scanf("%d%d%d", &n, &w, &b);
fac[0] = nfac[0] = 1;
for (int i = 1; i <= w + b; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod;
inv[i] = i == 1 ? 1 : mod - 1ll * (mod / i) * inv[mod % i] % mod;
nfac[i] = 1ll * nfac[i - 1] * inv[i] % mod;
}
for (int i = 1; i <= n; i++)
ans = (ans + 1ll * fac[w] * c(w - 1, i - 1) % mod * fac[b] % mod *
c(b - 1, n - i - 1) % mod * (i - 1) % mod) %
mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double eps = 1e-9;
const int md = 1e9 + 9;
int dp[4020][4020];
int n, w, b;
int main() {
cin >> n >> w >> b;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= max(w, b); j++) {
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j - 1]) % md;
}
}
long long ans = 0;
for (int i = 1; i <= n - 2; i++) {
long long add =
(((long long)dp[i][b] * dp[n - i][w]) % md * (n - i - 1)) % md;
ans = (ans + add) % md;
}
for (int i = 1; i <= w; i++) {
ans = (ans * i) % md;
}
for (int i = 1; i <= b; i++) {
ans = (ans * i) % md;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long dp[4005][4005];
long long cal(long long x, long long y) {
if (y < 0) return 0;
if (x == 1) return 1;
long long &r = dp[x][y];
if (r != -1) return r;
r = cal(x, y - 1);
r += cal(x - 1, y - 1);
r %= 1000000009;
return r;
}
long long fac(long long n) {
long long m = 1;
for (long long i = 1; i <= n; i++) {
m *= i;
m %= 1000000009;
}
return m;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc, i, j, n, w, b;
while (cin >> n >> w >> b) {
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (i = 2; i < n; i++) {
long long p = n - i;
long long r = cal(i, w - 1);
long long r1 = cal(n - i, b - 1);
long long r2 = (r * r1) % 1000000009;
r2 = r2 * (i - 1);
r2 %= 1000000009;
ans += r2;
ans %= 1000000009;
}
long long p = ans * fac(w);
p %= 1000000009;
p = p * fac(b);
p %= 1000000009;
cout << p << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000009, maxn = 4010;
int cw[maxn], cb[maxn], inv[maxn], prm[maxn], tot, n, m, w, b;
int pow(int x, int k) {
int ret = 1;
for (; k; k >>= 1, x = (long long)x * x % p)
if (k & 1) ret = (long long)ret * x % p;
return ret;
}
int main() {
int ans = 0;
std::cin >> n >> w >> b;
m = max(w, b);
inv[1] = 1;
for (int i = 2; i <= m; i++) {
if (!inv[i]) {
inv[i] = pow(i, p - 2);
prm[++tot] = i;
}
for (int j = 1; i * prm[j] <= m; j++) {
inv[i * prm[j]] = (long long)inv[i] * inv[prm[j]] % p;
if (i % prm[j] == 0) break;
}
}
cw[0] = 1;
for (int i = 1; i < w; i++)
cw[i] = (long long)cw[i - 1] * inv[i] % p * (w - i) % p;
cb[0] = 1;
for (int i = 1; i < b; i++)
cb[i] = (long long)cb[i - 1] * inv[i] % p * (b - i) % p;
for (int i = max(1, n - w); i <= n - 2 && i <= b; i++)
ans = (ans + (long long)(n - i - 1) * cw[n - i - 1] % p * cb[i - 1]) % p;
for (int i = 2; i <= b; i++) ans = (long long)ans * i % p;
for (int i = 2; i <= w; i++) ans = (long long)ans * i % p;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4005;
const int MOD = 1e9 + 9;
int c[N][N], fact[N], n, w, b;
int main() {
fact[0] = 1;
for (int i = 1; i < N; ++i) fact[i] = 1LL * fact[i - 1] * i % MOD;
for (int i = 0; i < N; ++i)
for (int j = c[i][0] = 1; j <= i; ++j) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
if (c[i][j] >= MOD) c[i][j] -= MOD;
}
cin >> n >> w >> b;
int ans = 0;
for (int i = 2; i <= n; ++i)
for (int j = i; j < n; ++j) {
int len = j - i + 1;
if (n - len - 1 >= 0)
ans = (ans + (1LL * fact[b] * c[b - 1][len - 1] % MOD) *
(1LL * fact[w] * c[w - 1][n - len - 1] % MOD)) %
MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fac[12000], ans, C[5100][5100];
const int mo = 1000000009;
int i, j, k, l, n, m, a, b, x;
int main() {
for (i = 0; i <= 4000; ++i)
for (j = 0; j <= i; ++j)
C[i][j] = j == 0 ? 1 : (C[i - 1][j - 1] + C[i - 1][j]) % mo;
fac[0] = 1;
for (i = 1; i <= 4000; ++i) fac[i] = (fac[i - 1] * i) % mo;
scanf("%d%d%d", &n, &a, &b);
ans = 0;
for (x = 1; x < n; ++x)
ans = (ans + fac[b] * C[b - 1][x - 1] % mo * fac[a] % mo *
C[a - 1][n - x - 1] % mo * (n - x - 1) % mo) %
mo;
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans, C1[4000 + 1], C2[4000 + 1];
void Init(long long *C, int m) {
C[0] = C[1] = 1;
for (int i = 2; i < m; i++) {
C[i] = 1;
for (int j = i - 1; j > 0; j--) C[j] = (C[j - 1] + C[j]) % 1000000009;
}
}
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
Init(C1, b);
Init(C2, w);
int bin = max(1, n - w);
int end = min(n - 2, b);
for (int i = bin; i <= end; i++) {
int k = n - i;
ans = (ans + C1[i - 1] * C2[k - 1] % 1000000009 * (k - 1) % 1000000009) %
1000000009;
}
int i;
for (i = 1; i <= b && i <= w; i++)
ans = ans * i % 1000000009 * i % 1000000009;
while (i <= b) ans = ans * (i++) % 1000000009;
while (i <= w) ans = ans * (i++) % 1000000009;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4000 + 5, mod = 1000000009;
int n, x, y;
long long P[N], d[N][N];
int main() {
scanf("%d", &n);
scanf("%d", &x);
scanf("%d", &y);
d[0][0] = 1;
for (int i = 1; i <= max(x, y); i++)
for (int j = 1; j <= min(n, i); j++)
d[i][j] = ((d[i - 1][j]) % mod + d[i - 1][j - 1]) % mod;
P[0] = 1;
for (int i = 1; i <= max(x, y); i++) P[i] = (P[i - 1] * i) % mod;
long long ans = 0;
for (int l = 2; l <= n - 1; l++)
for (int r = l; r <= n - 1; r++)
ans = (ans + (d[y][r - l + 1] * d[x][n - (r - l + 1)]) % mod) % mod;
ans = ans * ((P[x] * P[y]) % mod) % mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, w, b, f[2][4005], C[4005][4005], ans;
long long calcmod(long long k) {
long long i, res;
for (i = res = 1; i <= k; i++) res = res * i % 1000000009;
return res;
}
int main() {
long long i, j;
scanf("%I64d%I64d%I64d", &n, &w, &b);
memset(C, 0, sizeof(C));
for (i = 0; i < 4005; i++) C[i][0] = 1;
for (i = 1; i < 4005; i++)
for (j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000009;
f[0][1] = calcmod(w);
f[1][1] = calcmod(b);
for (i = 2; i <= w; i++) f[0][i] = f[0][1] * C[w - 1][i - 1] % 1000000009;
for (i = 2; i <= b; i++) f[1][i] = f[1][1] * C[b - 1][i - 1] % 1000000009;
ans = 0;
for (i = 2; i <= n - 1; i++)
ans = (ans + f[0][i] * (i - 1) % 1000000009 * f[1][n - i] % 1000000009) %
1000000009;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 8010;
const long long mod = 1e9 + 9;
long long F[N], iF[N], inv[N];
void prepare() {
inv[1] = 1;
for (int i = 2; i < N; ++i) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
F[0] = 1;
for (int i = 1; i < N; ++i) F[i] = F[i - 1] * i % mod;
iF[0] = 1;
for (int i = 1; i < N; ++i) iF[i] = iF[i - 1] * inv[i] % mod;
}
long long C(int n, int m) { return F[n] * iF[m] % mod * iF[n - m] % mod; }
int main() {
prepare();
int n, w, b;
while (scanf("%d%d%d", &n, &w, &b) != EOF) {
long long ans = 0;
for (int k = 1; k <= w - 1; ++k)
ans = (ans + C(w, k) * F[k] % mod * F[w - k] % mod) % mod;
ans = ans * F[b] % mod * C(w + b - 3, n - 3) % mod;
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9, maxn = 1e5;
long long t[maxn], r[maxn];
long long binpow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
long long inv(long long x) { return binpow(x, mod - 2); }
long long c_n_k(long long n, long long k) {
return t[n] * r[k] % mod * r[n - k] % mod;
}
int main() {
t[0] = r[0] = 1;
for (long long i = 1; i < maxn; i++)
t[i] = i * t[i - 1] % mod, r[i] = inv(t[i]);
long long n, w, b;
cin >> n >> w >> b;
long long ans = 0;
for (long long i = 1; i <= min(w - 1, n - 2); i++) {
for (long long j = 1; j <= min(w - i, n - i - 1); j++) {
long long extra_w = w - i - j;
long long extra_b = b - (n - i - j);
if (extra_b < 0 || extra_w < 0) continue;
ans = (ans + c_n_k(i + j - 1 + extra_w, i + j - 1) *
c_n_k(n - i - j - 1 + extra_b, n - i - j - 1)) %
mod;
}
}
ans = (ans * t[w]) % mod;
ans = (ans * t[b]) % mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4005;
const int P = 1e9 + 9;
int c[N][N], fact[N], n, w, b;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = 1LL * fact[i - 1] * i % P;
for (int i = 0; i < N; i++)
for (int j = c[i][0] = 1; j <= i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
if (c[i][j] >= P) c[i][j] -= P;
}
n = read();
w = read();
b = read();
int ans = 0;
for (int i = 2; i <= n; i++)
for (int j = i; j < n; j++) {
int len = j - i + 1;
if (n - len - 1 >= 0)
ans = (ans + (1LL * fact[b] * c[b - 1][len - 1] % P) *
(1LL * fact[w] * c[w - 1][n - len - 1] % P)) %
P;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
const long long mod = 1000000009L;
long long fac[8888];
long long inv[8888];
long long n, w, b;
long long bin(long long a, long long n = mod - 2) {
long long res = 1;
while (n) {
if (n & 1) res = (res * a) % mod;
a = (a * a) % mod;
n >>= 1;
}
return res;
}
long long C(long long n, long long k) {
return (((fac[n] * inv[k]) % mod) * inv[n - k]) % mod;
}
int main() {
cin >> n >> w >> b;
long long i, j, k;
fac[0] = 1;
for (i = 1; i <= 4444; ++i) fac[i] = (1ll * fac[i - 1] * i) % mod;
for (i = 0; i <= 4444; ++i) {
inv[i] = bin(fac[i]);
}
long long ans = 0;
for (i = 1; i < n - 1; ++i) {
for (j = 1; i + j < n; ++j) {
k = n - i - j;
if (i + k > w || j > b) continue;
ans += (((fac[w] * C(w - 1, i + k - 1)) % mod) *
((fac[b] * C(b - 1, j - 1)) % mod)) %
mod;
ans %= mod;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 9 + (int)1e9;
int n, W, B, binom[5000][5000], ans;
int main() {
cin >> n >> W >> B;
int tmp = max(W, B);
for (int i = 0; i <= tmp; i++)
for (int j = 0; j <= i; j++)
binom[i][j] =
(i && j) ? (binom[i - 1][j - 1] + binom[i - 1][j]) % MOD : 1;
for (int Y = 1; Y <= n - 2; Y++) {
int X = n - Y;
tmp = (long long)binom[W - 1][X - 1] * binom[B - 1][Y - 1] % MOD;
tmp = (long long)tmp * (n - Y - 1) % MOD;
(ans += tmp) %= MOD;
}
for (int i = 2; i <= W; i++) ans = (long long)ans * i % MOD;
for (int i = 2; i <= B; i++) ans = (long long)ans * i % MOD;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, fl = 1;
char st = getchar();
while (st < '0' || st > '9') {
if (st == '-') fl = -1;
st = getchar();
}
while (st >= '0' && st <= '9') x = x * 10 + st - '0', st = getchar();
return x * fl;
}
const int N = 1e6 + 10, mod = 1e9 + 9;
int n, b, w;
long long ans, fac[8005], invfac[8005];
inline long long ksm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
inline long long C(int x, int y) {
return fac[x] * invfac[y] % mod * invfac[x - y] % mod;
}
int main() {
ans = 1;
n = read();
w = read();
b = read();
fac[0] = 1;
fac[1] = 1;
for (int i = 2; i <= 8000; i++) fac[i] = fac[i - 1] * i % mod;
invfac[0] = invfac[1] = 1;
invfac[8000] = ksm(fac[8000], mod - 2);
for (int i = 7999; i >= 2; i--) {
invfac[i] = invfac[i + 1] * (i + 1) % mod;
}
ans = fac[w] * fac[b] % mod;
ans = ans * (w - 1) % mod;
ans = ans * C(w + b - 3, n - 3) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int mo = 1000000009;
using namespace std;
int n, w, b;
long long fac[8010];
long long mul(long long a, int b) {
long long ans = 1, w = a % mo;
while (b) {
if (b & 1) ans = (ans * w) % mo;
w = (w * w) % mo;
b /= 2;
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &w, &b);
fac[0] = 1;
for (int i = 1; i <= w + b; ++i) fac[i] = (fac[i - 1] * i) % mo;
long long ans = (fac[w] * fac[b]) % mo;
ans = (ans * (w - 1)) % mo;
ans = (ans * fac[w + b - 3]) % mo;
ans = (ans * mul(fac[n - 3], mo - 2)) % mo;
ans = (ans * mul(fac[w + b - n], mo - 2)) % mo;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000009LL;
long long c[4005][4005];
int n, w, b;
int main() {
c[0][0] = 1;
for (int i = 1; i <= 4000; i++) c[i][0] = 1;
for (int i = 1; i <= 4000; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
long long ans = 0LL;
scanf("%d%d%d", &n, &w, &b);
for (int i = 2; i < n; i++) {
for (int j = i; j < n; j++) {
ans = (ans + c[b - 1][j - i] * c[w - 1][n - (j - i + 1) - 1]) % mod;
}
}
long long a = 1;
for (int i = 1; i <= w; i++) a = (a * i) % mod;
long long c = 1;
for (int i = 1; i <= b; i++) c = (c * i) % mod;
printf("%I64d", ans * a % mod * c % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, b, c[4005][4005], f[4004];
int main() {
scanf("%d%d%d", &n, &w, &b);
f[0] = 1;
int ans = 0;
for (int i = 1; i <= 4000; i++) f[i] = 1ll * f[i - 1] * i % 1000000009;
for (int i = 0; i <= 4000; i++)
for (int j = 0; j <= i; j++) {
c[i][j] = !j ? 1 : (c[i - 1][j] + c[i - 1][j - 1]) % 1000000009;
}
for (int i = 1; i < n - 1; i++)
(ans += (1ll * c[b - 1][i - 1] * f[b] % 1000000009) *
(1ll * c[w - 1][n - i - 1] * f[w] % 1000000009) % 1000000009 *
(n - i - 1) % 1000000009) %= 1000000009;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 4005, mod = 1e9 + 9;
long long dp[size][size];
int main() {
int n, w, b;
for (int i = 0; i < size; i++) {
for (int j = 0; j <= i; j++) {
if (!j || j == i)
dp[i][j] = 1;
else {
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % mod;
}
}
}
scanf("%d %d %d", &n, &w, &b);
long long ans = 0LL;
for (int i = 1; i < n; i++) {
for (int j = 1; i + j < n; j++) {
int k = n - i - j;
ans = (ans + (dp[w - 1][i + k - 1]) * (dp[b - 1][j - 1])) % mod;
}
}
for (int i = 1; i <= w; i++) ans = ans * i % mod;
for (int i = 1; i <= b; i++) ans = ans * i % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kmod = 1e9 + 9;
long long pow(long long base, long long exp) {
if (exp == 1) return base;
long long aux = pow(base, exp >> 1);
aux = aux * aux % kmod;
if (exp & 1) aux = aux * base % kmod;
return aux;
}
long long fact[5005], invfact[5005];
void pregen() {
fact[0] = 1;
for (long long i = 1; i <= 5000; ++i) fact[i] = fact[i - 1] * i % kmod;
invfact[5000] = pow(fact[5000], kmod - 2);
for (long long i = 4999; i > 1; --i)
invfact[i] = invfact[i + 1] * (i + 1) % kmod;
invfact[1] = invfact[0] = 1;
}
long long comb(int big, int smal) {
if (smal < 0 || big < 0 || smal > big) return 0;
return fact[big] * invfact[smal] % kmod * invfact[big - smal] % kmod;
}
int main() {
pregen();
int n, w, b;
cin >> n >> w >> b;
long long ans = 0;
for (int i = 2; i < n; ++i)
ans =
(ans + fact[w] * fact[b] % kmod * (i - 1) % kmod * comb(w - 1, i - 1) %
kmod * comb(b - 1, n - i - 1) % kmod) %
kmod;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int ksm(int a, int b, int p) {
int s = 1;
while (b) {
if (b & 1) s = (long long)s * a % p;
a = (long long)a * a % p;
b >>= 1;
}
return s;
}
const int mod = 1e9 + 9, N = 4005;
int c[N][N], fac[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
fac[0] = 1;
for (int i = 1; i <= 4000; i++) fac[i] = (long long)fac[i - 1] * i % mod;
for (int i = 0; i <= 4000; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
int n, w, b;
cin >> n >> w >> b;
long long ans = 0;
for (int i = 2; i < n; i++) {
int j = n - i;
int s1 = (long long)fac[w] * c[w - 1][i - 1] % mod;
int s2 = (long long)fac[b] * c[b - 1][n - i - 1] % mod;
ans = (ans + (long long)s1 * s2 % mod * (i - 1) % mod) % mod;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, p, k, fac[10005], w, b;
const int Mo = (int)1e9 + 9;
int power(int x, int y) {
int sum = 1;
for (; y; y >>= 1) {
if (y & 1) sum = 1ll * sum * x % Mo;
x = 1ll * x * x % Mo;
}
return sum;
}
int C(int x, int y) {
return 1ll * fac[x] * power(fac[y], Mo - 2) % Mo * power(fac[x - y], Mo - 2) %
Mo;
}
int main() {
fac[0] = 1;
for (i = 1; i < 10005; ++i) fac[i] = 1ll * fac[i - 1] * i % Mo;
scanf("%d%d%d", &n, &w, &b);
int ans =
1ll * fac[w] * fac[b] % Mo * (w - 1) % Mo * C(w + b - 3, n - 3) % Mo;
printf("%d\n", ans);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.