text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int n, k;
double dp[2][1005];
int main() {
std::scanf("%d%d", &n, &k);
int cur = 1;
for (int i = 1; i <= n; i++, cur ^= 1) {
for (int j = 0; j <= 1000; j++) {
dp[cur][j] = 0.0;
dp[cur][j] += (k - 1.0) / k * dp[cur ^ 1][j];
dp[cur][j] += 1.0 / k * 1.0 / (j + 1) * (dp[cur ^ 1][j + 1] + j);
dp[cur][j] +=
1.0 / k * (double)j / (j + 1) * (dp[cur ^ 1][j] + (j + 1) / 2.0);
}
}
std::printf("%.11lf", dp[cur ^ 1][1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = (int)1e5 + 7;
const int MaxB = (int)7e2;
int n, k;
long double dp[2][MaxB + 7];
int main() {
scanf("%d", &n);
scanf("%d", &k);
int x = 1, y = 0;
for (int i = 1; i <= n; ++i) {
x ^= 1;
y ^= 1;
for (int j = 1; j <= MaxB; ++j) {
dp[y][j] =
(j * dp[x][j] + dp[x][j + 1] + j * (j + 1) / 2 + j) / (k * (j + 1)) +
dp[x][j] * (k - 1) / k;
}
}
printf("%.9lf", k * (double)dp[y][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXLEV = 1000;
int n, k, lev;
double f[MAXLEV + 10];
int main() {
scanf("%d%d", &n, &k);
lev = min(n, MAXLEV);
while (n--) {
for (int i = 1; i <= lev; ++i) {
f[i] = (i / 2.0 + (i + i * f[i] + f[i + 1]) / (i + 1)) / k +
f[i] * (k - 1) / k;
}
}
printf("%.100f\n", f[1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
struct IO {
char buf[(1 << 20)], *p1, *p2;
char pbuf[(1 << 20)], *pp;
IO() : p1(buf), p2(buf), pp(pbuf) {}
inline char gc() {
return getchar();
if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, (1 << 20), stdin);
return p1 == p2 ? ' ' : *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
register double tmp = 1;
register bool sign = 0;
x = 0;
register char ch = gc();
for (; !(ch >= '0' && ch <= '9'); ch = gc())
if (ch == '-') sign = 1;
for (; (ch >= '0' && ch <= '9'); ch = gc()) x = x * 10 + (ch - '0');
if (ch == '.')
for (ch = gc(); (ch >= '0' && ch <= '9'); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if (sign) x = -x;
}
inline void read(char *s) {
register char ch = gc();
for (; blank(ch); ch = gc())
;
for (; !blank(ch); ch = gc()) *s++ = ch;
*s = 0;
}
inline void read(char &c) {
for (c = gc(); blank(c); c = gc())
;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
} io;
const int mod = 1e9 + 7;
const int mo = 998244353;
const int N = 1e5 + 5;
const int M = 905;
int n, m;
double f[2][M];
int main() {
io.read(n), io.read(m);
double P = 1.0 / (1.0 * m);
for (int i = (1); i <= (n); i++) {
memset(f[i & 1], 0, sizeof(f[i & 1]));
for (int j = (1); j <= (min(900, n)); j++) {
double gs1 = (f[(i - 1) & 1][j + 1] + j) * P;
gs1 = gs1 / (1.0 * (j + 1));
double gs2 = (f[(i - 1) & 1][j] + (j + 1) / 2.0) * P;
gs2 = gs2 * j / (1.0 * (j + 1));
double gs3 = (f[(i - 1) & 1][j]) * (m - 1) / (1.0 * m);
f[i & 1][j] += gs1 + gs2 + gs3;
}
}
printf("%.12lf\n", f[n & 1][1] * m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, cur = 0;
double E[2][805];
int main() {
int i, j;
scanf("%d %d", &n, &k);
for (i = n; i >= 1; i--) {
cur ^= 1;
for (j = 1; j < 805; j++) {
E[cur][j] = E[cur ^ 1][j] * (1.0 * j / (j + 1)) + j / 2.0;
E[cur][j] += (E[cur ^ 1][j + 1] + j) * (1.0 / (j + 1));
E[cur][j] = E[cur][j] * 1.0 / k + 1.0 * E[cur ^ 1][j] * (k - 1) / k;
}
}
printf("%.9lf", E[cur][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxj = 750;
int n, k;
double dp[2][maxj];
int main() {
fill(dp[0], dp[0] + maxj, 0.0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < maxj - 1; j++) {
double kk = (double)k;
double jj = (double)j;
dp[1][j] = 1.0 / (kk * (jj + 1.0)) *
(jj * (jj + 3.0) / 2.0 + jj * dp[0][j] + dp[0][j + 1]) +
(1.0 - 1.0 / kk) * dp[0][j];
}
for (int j = 1; j < maxj - 1; j++) {
dp[0][j] = dp[1][j];
}
}
cout << fixed << setprecision(10) << k * dp[1][1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
double d[2][1001];
int main() {
int n, k, i, j, togle = 0;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
for (j = 1; j <= 1000; j++) {
d[!togle][j] = 1.0 / k / (j + 1) *
(j * d[togle][j] + d[togle][j + 1] + j * (j + 3) / 2) +
1.0 * (k - 1) / k * d[togle][j];
}
togle = !togle;
}
printf("%.11lf\n", d[togle][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5;
double f[2][MAXN];
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
f[0][i] = 0;
}
for (int i = 1, d = 1; i <= n; i++, d ^= 1) {
for (int j = 1; j <= 600; j++) {
f[d][j] = 1.0 / k *
((j) / (j + 1.0) * (f[d ^ 1][j] + (j + 1.0) / 2.0) +
(1.0) / (j + 1) * (f[d ^ 1][j + 1] + j)) +
1.0 * (k - 1) / (k)*f[d ^ 1][j];
}
}
printf("%.10lf", k * f[n & 1][1]);
return 0;
}
|
#include <bits/stdc++.h>
double f[601], k;
int n, j;
int main() {
for (std::cin >> n >> k; n--;)
for (j = 1; j < 600; ++j)
f[j] = f[j] / k * (j / (j + 1.) + k - 1) +
(j / 2. + (f[j + 1] + j) / (j + 1.)) / k;
printf("%.15lf\n", k * f[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 1e3 + 5;
double dp[2][M];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= min(n, 1000); j++) {
dp[i & 1][j] =
1.0 * (k - 1) / k * dp[(i - 1) & 1][j] +
1.0 / k / (j + 1) * (dp[(i - 1) & 1][j + 1] + j) +
1.0 * j / k / (j + 1) * (dp[(i - 1) & 1][j] + (1 + j) / 2.0);
}
}
printf("%.10lf", dp[n & 1][1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5, maxm = 800;
int n, m, k;
long double inv[maxm + 3], dp[2][maxm + 3], ans;
int main() {
scanf("%d %d", &n, &k);
m = min(n + 1, maxm);
for (int i = 1; i <= maxm + 1; i++) {
inv[i] = (long double)1 / i;
}
int cur = 0, nxt = 1;
dp[cur][1] = 1;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= m; j++) {
dp[nxt][j] = 0;
}
for (int j = 1; j <= m; j++) {
long double x = inv[k] * inv[j + 1];
dp[nxt][j] += dp[cur][j] * (1 - x);
dp[nxt][j + 1] += dp[cur][j] * x;
ans += dp[cur][j] * ((j + 1) * (j + 2) / 2 - 1) * inv[j + 1];
}
swap(cur, nxt);
}
double res = ans;
printf("%.18lf\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double dp[2][100005];
long double vl[100005];
long double logsum[100005];
long double v1, v2;
void make() {
logsum[0] = logsum[1] = 0.0;
for (int i = 2; i < 100005; i++) logsum[i] = logsum[i - 1] + log(i);
}
long double per(int n, int k, int i) {
long double lg = logsum[n] - (logsum[i] + logsum[n - i]);
lg -= v1 * i;
lg += v2 * (n - i);
return exp(lg);
}
int main() {
make();
int n, k;
scanf("%d %d", &n, &k);
int pos = 0;
dp[pos][1] = 1.0;
vl[0] = 0.0;
for (int i = 1; i <= n; i++) {
pos ^= 1;
for (int j = 1; j <= min(i + 1, 1000); j++) dp[pos][j] = 0.0;
vl[i] = vl[i - 1];
for (int j = 1; j <= min(i, 1000); j++) {
dp[pos][j] += dp[pos ^ 1][j] * (long double)j / (long double)(j + 1);
dp[pos][j + 1] += dp[pos ^ 1][j] * 1.0 / (long double)(j + 1);
vl[i] += dp[pos ^ 1][j] *
((long double)j / 2.0 + (long double)j / (long double)(j + 1));
}
}
v1 = log(k), v2 = log(1.0 - 1.0 / (long double)k);
if (k == 1)
printf("%.10f\n", (double)vl[n]);
else {
long double ret = 0.0;
for (int i = 0; i <= n; i++) {
ret += per(n, k, i) * vl[i];
}
printf("%.10f\n", (double)(ret * k));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
ostream &operator<<(ostream &o, const vector<T> &t) {
o << '[';
for (__typeof((t).begin()) i = (t).begin(); i != (t).end(); ++i) {
if (i != t.begin()) o << ',';
o << *i;
}
return o << ']';
}
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &t) {
return o << '(' << t.first << ',' << t.second << ')';
}
template <int N, class Tp>
void out(ostream &, const Tp &) {}
template <int N, class Tp, class, class... Ts>
void out(ostream &o, const Tp &t) {
if (N) o << ',';
o << get<N>(t);
out<N + 1, Tp, Ts...>(o, t);
}
template <class... Ts>
ostream &operator<<(ostream &o, const tuple<Ts...> &t) {
o << '(';
out<0, tuple<Ts...>, Ts...>(o, t);
return o << ')';
}
template <class T>
void output(T *a, int n) {
for (int i = 0; i < (int)(n); ++i) {
if (i) cout << ',';
cout << a[i];
}
cout << endl;
}
template <class T>
void output(T *a, int n, int m) {
for (int i = 0; i < (int)(n); ++i) output(a[i], m);
}
template <class T>
void output(T t) {
if (t < 0) t = -t, putchar(45);
static int c[20];
int k = 0;
while (t) c[k++] = t % 10, t /= 10;
for (k || (c[k++] = 0); k; putchar(c[--k] ^ 48))
;
}
template <class S, class... T>
void output(S a, T... t) {
output(a);
putchar(' ');
output(t...);
}
template <class T>
bool input(T &t) {
int n = 1, c;
for (t = 0; !isdigit(c = getchar()) && ~c && c - 45;)
;
if (!~c) return 0;
for (c - 45 && (n = 0, t = c ^ 48); isdigit(c = getchar());
t = 10 * t + c - 48)
;
t = n ? -t : t;
return 1;
}
template <class S, class... T>
bool input(S &a, T &...t) {
input(a);
return input(t...);
}
const int M = 600;
double dp[2][M + 10];
int main() {
int n, k;
while (cin >> n >> k) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < (int)(n); ++i) {
int cur = i & 1;
int nxt = cur ^ 1;
memset(dp[nxt], 0, sizeof(dp[nxt]));
for (int j = 0; j < (int)(M); ++j) {
dp[nxt][j] += 1.0 / k / (j + 1) * (dp[cur][j + 1] + j);
dp[nxt][j] += 1.0 / k / (j + 1) * (j * dp[cur][j] + j * (j + 1) / 2);
dp[nxt][j] += (k - 1.0) / k * dp[cur][j];
}
}
double ans = dp[n & 1][1] * k;
printf("%.10f\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
const int tt = 1200;
double dp[tt + 1];
double sm[tt];
double p1[tt + 1];
int main() {
scanf("%d%d", &N, &K);
dp[1] = 1.0;
for (int(i) = 0; (i) < (tt + 1); (i)++) p1[i] = 1.0 / (i * K);
int sp = min(tt, N + 3);
for (int(i) = 0; (i) < (N); (i)++) {
for (int(j) = 0; (j) < (sp); (j)++) {
if (dp[j] < 1e-15) dp[j] = 0;
sm[j] += dp[j];
}
for (int j = sp - 1; j > 0; j--) {
double ad = dp[j - 1] * p1[j];
dp[j] += ad;
dp[j - 1] -= ad;
}
}
double res = 0;
for (int(j) = 0; (j) < (sp); (j)++)
res += sm[j] * (j) * (j + 3) / (j + j + 2);
printf("%.12f\n", res);
}
|
#include <bits/stdc++.h>
double E[2][555];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int f1 = 0, f2 = 1, mi = 550;
if (n < mi) mi = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j <= mi; j++)
E[f1][j] = E[f2][j] * (j * 1. / (j + 1) / k + (k - 1) * 1. / k) +
(j * 1. / 2 + j * 1. / (j + 1)) / k +
1. / (j + 1) * E[f2][j + 1] / k;
int t = f1;
f1 = f2;
f2 = t;
}
printf("%.10f\n", k * E[f2][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
double E[2][600];
int main() {
memset(E, 0, sizeof(E));
int n, k;
scanf("%d %d", &n, &k);
int now = 1;
for (int i = n - 1; i >= 0; i--) {
now ^= 1;
for (int j = 1; j < 600; j++)
E[now][j] = E[now ^ 1][j] * (j * 1. / (j + 1) / k + (k - 1) * 1. / k) +
(j * 1. / 2 + j * 1. / (j + 1)) / k +
1. / (j + 1) * E[now ^ 1][j + 1] / k;
}
printf("%.9f\n", k * E[now][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_NB_TOURS = 100 * 1000 + 1;
int nbTours, nbTypes;
double expect[2][700];
double cumul[700];
int main() {
cin >> nbTours >> nbTypes;
for (int iTour = nbTours; iTour > 0; iTour--) {
int c = iTour % 2;
int n = 1 - c;
for (int iPos = 1; iPos < 600; iPos++) {
cumul[iPos] = cumul[iPos - 1] + expect[c][iPos];
}
for (int iLevel = 1; iLevel < min(600, iTour + 2); iLevel++) {
expect[n][iLevel] = (nbTypes - 1) * expect[c][iLevel] / nbTypes;
expect[n][iLevel] += iLevel * ((iLevel + 1.) / 2 + expect[c][iLevel]) /
nbTypes / (iLevel + 1);
expect[n][iLevel] +=
(iLevel + expect[c][iLevel + 1]) / nbTypes / (iLevel + 1);
}
}
cout << fixed << setprecision(12);
cout << nbTypes * expect[0][1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double f[700], g[700];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= 666; ++j) {
if (i & 1) {
f[j] =
(g[j] * (k - 1) / (double)k + (g[j + 1] + j) * (1.0 / (k * j + k)) +
(g[j] + (1 + j) / (double)2) * (j * 1.0 / k / (j + 1)));
} else {
g[j] =
(f[j] * (k - 1) / (double)k + (f[j + 1] + j) * (1.0 / (k * j + k)) +
(f[j] + (1 + j) / (double)2) * (j * 1.0 / k / (j + 1)));
}
}
}
printf("%.10lf", n % 2 == 1 ? f[1] * k : g[1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 600;
long double dp[2][MAX + 10];
long double inv[MAX + 10];
int MAIN() {
int n, k;
cin >> n >> k;
dp[0][1] = 1.;
for (int i = 1; i < MAX + 10; i++) {
inv[i] = (long double)1. / i;
}
long double c = 1. / k;
long double ans = 0;
for (int i = 0; i < n; i++) {
int cur = i % 2, next = (i + 1) % 2;
for (int j = 1; j <= MAX; j++) {
ans += dp[cur][j] * j * (0.5 + inv[j + 1]);
}
for (int j = 1; j <= MAX; j++) {
dp[next][j] = dp[cur][j] * (1. - c * inv[j + 1]);
}
for (int j = 1; j <= MAX; j++) {
dp[next][j + 1] += dp[cur][j] * c * inv[j + 1];
}
for (int j = 1; j <= MAX; j++) {
if (dp[next][j] < 1e-100) {
dp[next][j] = 0;
}
}
}
cout << ans << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, ans = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return f * ans;
}
const int MAXN = 1e5 + 11;
double f[2][1001];
int N, K, cur;
int main() {
N = read(), K = read();
for (int i = 1; i <= N; i++) {
cur ^= 1;
memset(f[cur], 0, sizeof(f[cur]));
for (int j = 1; j <= 1000; j++) {
double p1 = (1 / (double)K), p2 = 1 - p1;
f[cur][j] += ((double)(f[cur ^ 1][j + 1] + j) / (double)(j + 1) +
(double)(f[cur ^ 1][j] + (double)(j + 1) / 2) * j /
(double)(j + 1)) *
p1;
f[cur][j] += f[cur ^ 1][j] * p2;
}
}
printf("%.10lf\n", f[cur][1] * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline string Next() {
string S;
cin >> S;
return S;
}
inline string NextLine() {
string S;
getline(cin, S);
return S;
}
inline int NextInt() {
int n;
scanf("%d", &n);
return n;
}
inline long long NextLong() {
long long n;
scanf("%lld", &n);
return n;
}
inline double NextDouble() {
double n;
scanf("%lf", &n);
return n;
}
const int N = (int)1e5 + 7;
const int B = (int)7e2;
int n, k;
long double f[2][B + 7];
int main() {
n = NextInt();
k = NextInt();
int cur = 1, nxt = 0;
for (int i = 1; i <= B; ++i) f[0][i] = 0;
for (int i = 1; i <= n; ++i) {
cur ^= 1;
nxt ^= 1;
for (int j = 1; j <= B; ++j) {
f[nxt][j] = (j * f[cur][j] + f[cur][j + 1] + j * (j + 1) / 2 + j) /
(k * (j + 1)) +
f[cur][j] * (k - 1) / k;
}
}
printf("%.9lf", k * (double)f[nxt][1]);
return 0;
}
|
#include <bits/stdc++.h>
const double EPS = 1e-50;
double dp[605];
int n, k;
int main() {
scanf("%d%d", &n, &k);
dp[1] = 1;
double ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 600; j; --j) {
double v = dp[j] < EPS ? 0 : dp[j], u = 1.0 / k / (j + 1.0);
ans += v * (j / 2.0 + j / (j + 1.0));
dp[j + 1] += v * u;
dp[j] = v * (1.0 - u);
}
}
printf("%.10f\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double ff[800][6];
double k;
int main() {
int n, i, j;
scanf("%d %lf", &n, &k);
for (i = 0; i < n; i++)
for (j = 1; j <= 700; j++) {
ff[j - 1][(i + 1) & 1] += 1 / k * 1 / (j) * (ff[j][i & 1] + j - 1);
ff[j][(i + 1) & 1] =
(ff[j][(i)&1] * j + (j + 1) * j / 2) * 1 / k * 1 / (j + 1) +
(k - 1) / k * ff[j][i & 1];
}
printf("%.9lf", ff[1][n & 1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 805;
double f[2][Maxn + 10], w[Maxn + 10];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int now = 0, last;
for (int i = 1; i <= n; ++i) {
now ^= 1, last = 1 - now;
;
for (int j = 1; j <= Maxn; ++j) {
f[now][j] = (k - 1.0) * 1.0 / k * f[last][j];
f[now][j] += 1.0 / k * (j * 1.0 / (j + 1) * (f[last][j] + (1.0 + j) / 2));
f[now][j] += 1.0 / k * (1.0 / (j + 1) * (f[last][j + 1] + j));
}
}
printf("%.10lf\n", f[now][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(1e6) + 5;
long double dp[N];
int main(void) {
int n, k;
cin >> n >> k;
long double ans = 0;
dp[1] = 1;
for (int cs = 1; cs <= n; ++cs) {
for (int j = min(cs, 1000); j; --j) {
const long double prob = dp[j] / (k * (j + 1));
ans += dp[j] * j * (0.5 + 1.0 / (j + 1));
dp[j] -= prob;
dp[j + 1] += prob;
}
}
cout << setprecision(10) << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000, maxl = 600;
double f[maxl + 5];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= min(n, maxl); j++)
f[j] = (f[j + 1] + j) / ((1. + j) * k) +
(f[j] + 0.5 * (1. + j)) * j / ((1. + j) * k) + f[j] * (k - 1) / k;
printf("%.10lf", f[1] * k);
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
int n, k;
const int N = 600;
const int maxn = 1 << 17;
long double dp[2][N];
long double p[100100];
const long double pi = std::acos(-1);
struct complex {
long double x, y;
inline complex(long double a = 0, long double b = 0) { x = a, y = b; }
inline complex operator*(const complex& b) const {
return complex(x * b.x - y * b.y, x * b.y + y * b.x);
}
inline void operator+=(const complex& b) { x += b.x, y += b.y; }
inline complex operator-(const complex& b) const {
return complex(x - b.x, y - b.y);
}
inline void operator/=(const int& lim) { x /= lim; }
};
complex wn[maxn << 1];
complex g[maxn];
inline complex pow(complex x, int b) {
complex ans = 1;
for (; b; b >>= 1, x = x * x)
if (b & 1) ans = ans * x;
return ans;
}
int rev[maxn], lim;
inline void init(int len) {
for (lim = 1; lim < len; lim <<= 1)
;
for (int i = 1; i < lim; ++i) rev[i] = rev[i >> 1] >> 1 | (i % 2 * lim / 2);
}
inline void fft(complex* a, int type) {
for (int i = 1; i < lim; ++i)
if (rev[i] > i) std::swap(a[i], a[rev[i]]);
for (int mid = 1; mid < lim; mid <<= 1)
for (int j = 0; j < lim; j += mid + mid)
for (int k = 0; k < mid; ++k) {
const complex x = a[mid + j + k] * wn[mid + k];
a[mid + j + k].x = a[j + k].x - x.x;
a[mid + j + k].y = a[j + k].y - x.y;
a[j + k] += x;
}
if (!type) {
std::reverse(a + 1, a + lim);
for (int i = 0; i < lim; ++i) a[i] /= lim;
}
}
int main() {
cin >> n >> k;
init(n + 1);
g[0] = (k - 1.) / k;
g[1] = 1. / k;
for (int mid = 1; mid < lim; mid <<= 1)
for (int i = 0; i < mid; ++i)
wn[mid + i] = complex(std::cos(pi * i / mid), std::sin(pi * i / mid));
fft(g, 1);
for (int i = 0; i < lim; ++i) g[i] = pow(g[i], n);
fft(g, 0);
dp[1][1] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < N; ++j) dp[0][j] = dp[1][j], dp[1][j] = 0;
p[i] = p[i - 1];
for (int j = 1; j + 1 < N; ++j) {
p[i] += dp[0][j] * j / (j + 1.);
p[i] += dp[0][j] * j / 2;
dp[1][j] += dp[0][j] * j / (j + 1.);
dp[1][j + 1] += dp[0][j] / (j + 1.);
}
}
long double ans = 0, su = 0;
for (int i = 0; i <= n; ++i) {
ans += g[i].x * p[i];
su += g[i].x;
}
printf("%.20Lf\n", ans * k);
}
|
#include <bits/stdc++.h>
using namespace std;
double f[100005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 524; j++)
f[j] = (1 / (j + 1.0) * (f[j + 1] + j) +
j / (j + 1.0) * (f[j] + (j + 1) / 2.0)) /
k +
(k - 1.0) / k * f[j];
printf("%.12lf\n", f[1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int MAXN = 100005;
const int MAGIC = 699;
vector<double> dp[2];
int main() {
for (int i = 0; i < (2); ++i) dp[i].resize(MAGIC);
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j < MAGIC && j + i <= n + 1; j++)
dp[1][j] = 1. * (k - 1) / k * dp[0][j] +
1. / k / (j + 1) *
(1. * j * dp[0][j] + 1. * j * (j + 3) / 2 + dp[0][j + 1]);
swap(dp[0], dp[1]);
}
printf("%.12lf\n", dp[0][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INT_MAX_VAL = (int)1e20;
int INT_MIN_VAL = (int)-1e20;
long long LONG_MAX_VAL = (long long)1e20;
long long LONG_MIN_VAL = (long long)-1e20;
double dp[2][700];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (long long(i) = 0LL; (i) < (700); (i)++) dp[0][i] = 0;
int n;
double k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
for (int t = 0; t + 1 < 700; ++t) {
dp[i % 2][t] = (t * dp[(i - 1) % 2][t] + dp[(i - 1) % 2][t + 1] +
t * (t + 3.) / 2.) /
(k * (t + 1)) +
(k - 1) * dp[(i - 1) % 2][t] / k;
}
}
double res = k * dp[n % 2][1];
cout << fixed << setprecision(10) << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
int n;
double dp[N], k;
int main() {
scanf("%d%lf", &n, &k);
for (int i = 1; i < N; i++) dp[i] = (i * 0.5 + i * 1.0 / (i + 1)) / k;
for (int i = 2; i <= n; i++) {
for (int j = 1; j + 1 < N && j <= n; j++) {
double ans = (k - 1) / k * dp[j];
double rate = 1.0 / k / (j + 1);
ans += rate * (j * dp[j] + dp[j + 1] + 0.5 * j * (j + 3));
dp[j] = ans;
}
}
printf("%.9f\n", dp[1] * k);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100000 + 1;
const int M = 800;
int n, k;
double iv[N];
double dp[2][M];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < N; i++) iv[i] = 1. / i;
int now = 1, pre = 0;
for (int i = 0; i < M; i++) dp[now][i] = 0;
for (int i = n - 1; i >= 0; i--) {
now ^= 1, pre ^= 1;
for (int j = 0; j < M - 1; j++) {
dp[now][j] = iv[k] * (iv[j + 1] * (dp[pre][j + 1] + j) +
j * iv[j + 1] * dp[pre][j] + j * iv[2]) +
(1 - iv[k]) * dp[pre][j];
}
}
printf("%.12f\n", k * dp[now][1]);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
inline int read() {
register int x = 0, dp = 1;
register char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') dp = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * dp;
}
void write(int x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(int x) {
write(x);
puts("");
}
double E[2][600];
int n, k;
int main() {
memset(E, 0, sizeof(E));
n = read(), k = read();
int now = 1;
for (int i = n - 1; i >= 0; i--) {
now ^= 1;
for (int j = 1; j < 600; j++)
E[now][j] = E[now ^ 1][j] * (j * 1. / (j + 1) / k + (k - 1) * 1. / k) +
(j * 1. / 2 + j * 1. / (j + 1)) / k +
1. / (j + 1) * E[now ^ 1][j + 1] / k;
}
printf("%.9f\n", k * E[now][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int maxn = 200200;
const int maxm = 600;
const int inf = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};
int n, k;
double dp[maxm];
double p[2][maxm];
int main() {
ios_base::sync_with_stdio(0);
while (cin >> n >> k) {
for (int j = 0; j < maxm; j++) {
dp[j] = 0;
p[0][j] = p[1][j] = 0;
}
p[0][1] = 1;
for (int i = 0; i < n; i++) {
for (int j = maxm - 2; j > 0; j--) {
if (p[0][j] < 1e-20) continue;
dp[j] += ((j + 1) / 2.0) * (j / (j + 1.0)) / k * p[0][j];
p[1][j] += (1 - 1.0 / (j + 1.0) / k) * p[0][j];
dp[j + 1] += j * (1 / (j + 1.0)) / k * p[0][j];
p[1][j + 1] += 1.0 / (j + 1.0) / k * p[0][j];
}
for (int j = 1; j < maxm; j++) {
p[0][j] = p[1][j];
p[1][j] = 0;
}
}
double sum = 0;
for (int j = 1; j < maxm; j++) sum += dp[j];
printf("%.15lf\n", k * sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double P[100003];
double p1[100003], p2[100003], e[100003];
int main() {
int n, k;
cin >> n >> k;
P[0] = 0;
P[1] = 1;
for (int i = 2; i <= n + 1; i++) P[i] = 0;
double answer = 0.0;
int max_touched = 1;
for (int j = 1; j <= n + 1; j++) {
p1[j] = ((k - 1.0) / k + (j + 0.0) / ((j + 1.0) * k));
p2[j] = 1.0 / k * 1.0 / (j + 1.0);
e[j] = 1.0 / k * (0.5 * j + j / (j + 1.0));
}
double max_prob, curr_probability, next_probability, limit;
limit = 1e-20;
int maxid = 1;
int maxx = 1;
for (int i = 1; i <= n; i++) {
int prev_max_touched = max_touched;
int next_maxid = -1;
max_touched = -1;
maxx++;
for (int j = maxx; j >= 1; j--) {
answer += P[j] * e[j];
P[j] = P[j] * p1[j] + P[j - 1] * p2[j - 1];
}
while (P[maxx] <= 1e-20 && maxx >= 100) maxx--;
}
printf("%1.10f\n", answer * k);
}
|
#include <bits/stdc++.h>
using namespace std;
double f[100005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 516; j++)
f[j] = (1 / (j + 1.0) * (f[j + 1] + j) +
j / (j + 1.0) * (f[j] + (j + 1) / 2.0)) /
k +
(k - 1.0) / k * f[j];
printf("%.12lf\n", f[1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n = 0;
double k = 0;
double f[2][601] = {0};
int main() {
scanf("%d%lf", &n, &k);
for (int i = 1; i <= n; ++i) {
int x;
for (int j = 1; j <= 600; ++j) {
f[i & 1][j] = ((f[i & 1 ^ 1][j] + (double)(j + 1) / 2) * j / (j + 1) +
(f[i & 1 ^ 1][j + 1] + j) / (j + 1)) /
k +
f[i & 1 ^ 1][j] * (1 - (double)1 / k);
}
}
printf("%0.10lf\n", f[n & 1][1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
long double a[650], b[650];
int main() {
int n, k;
cin >> n >> k;
long double ans = 0;
a[0] = 1;
for (int x = 1; x <= n; x++) {
for (int y = 0; y < 650; y++) {
b[y] = a[y];
b[y] -= a[y] * (1.0 / (y + 2)) * 1.0 / k;
if (y) b[y] += a[y - 1] * (1.0 / (y + 1)) * 1.0 / k;
ans += a[y] * (1.0 / (y + 2)) * (y * (y + 1) / 2 + 2 * (y + 1));
}
swap(a, b);
}
cout << fixed << setprecision(20) << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int N, K;
cin >> N >> K;
long double C = 0;
vector<long double> P(1000 + 47, 0);
P[1] = 1;
for (int i = 1; i <= N; i++) {
int t = 270 + max(0, int((i - 20000) / 80000.0 * 330));
for (int j = 1; j <= t; j++) C += P[j] * (j + 1 - 2.0 / (j + 1));
long double c = 1.0 / K;
for (int j = t + 9; j > 0; j--) P[j] += c * (P[j - 1] / j - P[j] / (j + 1));
}
cout << fixed << setprecision(10) << C / 2.0 + N / 2.0 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 30;
const int LEVEL = 720;
double dp[2][LEVEL];
int main() {
int n, k;
while (scanf("%d%d", &n, &k) != EOF) {
memset(dp, 0, sizeof(dp));
int cur = 0, pre = 1;
for (int i = 1; i <= n; ++i) {
swap(cur, pre);
for (int j = 1; j <= 700; ++j) {
dp[cur][j] =
((j * (dp[pre][j] + (j + 1) / 2.0) + dp[pre][j + 1] + j) / (j + 1) +
dp[pre][j] * (k - 1)) /
k;
}
}
printf("%.10f\n", dp[cur][1] * k);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops", "-ffast-math")
#pragma GCC optimize("-fno-math-errno")
#pragma GCC optimize("-funsafe-math-optimizations")
#pragma GCC optimize("-freciprocal-math")
#pragma GCC optimize("-fno-trapping-math")
#pragma GCC optimize("-ffinite-math-only")
#pragma GCC optimize("-ftree-vectorize")
#pragma GCC target("avx2", "sse4.2", "fma")
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
__inline__ __attribute__((always_inline)) unsigned int rnd() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? min(a, args...) : min(b, args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? max(b, args...) : max(a, args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 100005;
const int lim = 600;
double dp[2][lim + 5], f[2][lim + 5];
int main() {
int n, k;
read(n, k);
f[0][1] = 1;
for (int i = 0; i < n; ++i) {
memset(f[!(i & 1)], 0, sizeof(f[!(i & 1)]));
memset(dp[!(i & 1)], 0, sizeof(dp[!(i & 1)]));
for (int j = 0; j <= lim && j <= i + 1; ++j) {
double p = 1.0 / (k * (j + 1));
double A = 1.0 * (k - 1) / k, B = p * j;
f[!(i & 1)][j] += 1.0 * f[i & 1][j] * (A + B);
f[!(i & 1)][j + 1] += 1.0 * f[i & 1][j] * p;
dp[!(i & 1)][j] +=
1.0 * dp[i & 1][j] * (A + B) + 1.0 * f[i & 1][j] * j / (2.0 * k);
dp[!(i & 1)][j + 1] += 1.0 * (dp[i & 1][j] + f[i & 1][j] * j) * p;
}
}
double ans = 0;
for (int i = 0; i <= lim; ++i) ans += dp[n & 1][i];
printf("%.12lf\n", ans * k);
return 0;
}
|
#include <bits/stdc++.h>
double f[2][700 + 20], n, k;
int main() {
scanf("%lf%lf", &n, &k);
for (int i(1); i <= n; i++) {
for (int j(1); j <= 700; j++)
f[1][j] =
1 / (k * (j + 1)) * (j * f[0][j] + f[0][j + 1] + j * (j + 3) / 2) +
(k - 1) / k * f[0][j];
for (int j(1); j <= 700; j++) f[0][j] = f[1][j], f[1][j] = 0;
}
printf("%.12lf\n", f[0][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
const int maxlevel = 600;
vector<double> fi(maxlevel + 1, 0.0), oldfi(maxlevel + 1);
for (int i = 1; i <= n; i++) {
fi.swap(oldfi);
for (int l = 1; l <= maxlevel; l++) {
fi[l] = 0.0;
fi[l] += (k - 1.0) / (1.0 * k) * oldfi[l];
double p2 = 0.0;
if (l + 1 <= maxlevel)
p2 += (1.0 / (l + 1.0)) * (l + oldfi[l + 1]);
else
p2 += (1.0 / (l + 1.0)) *
(l + ((l + 1 + 1) / 2.0 * (i - 1.0) / (1.0 * k)));
p2 += (1.0 * l) / (l + 1.0) * oldfi[l];
p2 += l / 2.0;
fi[l] += p2 * (1.0 / k);
}
}
double ret = 1.0 * k * fi[1];
printf("%.10f\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,abm,mmx,tune=native")
using namespace std;
const int64_t INF = (int64_t)(2e18);
const int inf = (int)(1e9 + 7);
const int maxn = 500 * 1000 + 100;
chrono::time_point<chrono::steady_clock> cl;
double current_time() {
return (double)(chrono::steady_clock::now() - cl).count() / 1e9;
}
int n, k;
const int magic = 1500;
double e[2][magic];
int32_t main() {
cl = chrono::steady_clock::now();
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin.tie(nullptr);
long double res = 0;
cin >> n >> k;
for (int ii = 0; ii < n; ++ii) {
int i = ii % 2;
fill(&e[i ^ 1][0], &e[i ^ 1][magic], 0.0);
for (int x = 1; x < magic - 5; ++x) {
e[i ^ 1][x] += 1.0 * (k - 1) / k * e[i][x];
double p = 1.0 / (x + 1) * (x + e[i][x + 1]);
p += 1.0 * x / (x + 1) * e[i][x];
p += 1.0 * x / 2;
e[i ^ 1][x] += p / k;
}
}
cout << k * e[n % 2][1];
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
const int K = 600;
int n, k;
double ans = 0, f[2][1001], p[1001], p2[1001];
int main() {
scanf("%d%d", &n, &k);
f[1][1] = k;
for (int j = 1; j <= K; j++) {
p[j] = 1.0 / k * (1.0 * j / 2 + 1.0 * j / (j + 1));
p2[j] = 1.0 / k / (j + 1);
}
for (int i = 1; i <= n; i++) {
int k = i % 2;
for (int j = 1; j <= K; j++) f[k ^ 1][j] = f[k][j];
for (int j = 1; j < K; j++) {
ans += f[k][j] * p[j];
double now = f[k][j] * p2[j];
f[k ^ 1][j + 1] += now;
f[k ^ 1][j] -= now;
}
}
printf("%.10lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 525;
int n, k;
double f[2][N + 5];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= N; j++)
f[i & 1][j] =
(f[i & 1 ^ 1][j] * ((k - 1) * 1.0 / k) +
(f[i & 1 ^ 1][j + 1] + j) * (1. / (k * (j + 1))) +
(f[i & 1 ^ 1][j] + (1 + j) / 2.) * (j * 1. / (k * (j + 1))));
printf("%.10f\n", f[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int B = 551;
double f[2][B + 5];
int T, n, k, cur;
int main() {
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cin >> n >> k;
cur = 0;
for (int i = 1; i <= n; i++) {
cur ^= 1;
for (int j = 1; j <= n && j <= B; j++)
f[cur][j] = ((f[cur ^ 1][j] + (long double)(j + 1) / 2.0) *
(long double)j / (j + 1) +
(f[cur ^ 1][j + 1] + j) / (j + 1)) /
k +
(long double)(k - 1) / k * f[cur ^ 1][j];
}
cout << f[cur][1] * k;
return 0;
}
|
#include <bits/stdc++.h>
int n, d;
double f[2][610], g[2][610], F[100010], k;
int cnt, begin;
int main() {
scanf("%d %lf", &n, &k);
f[0][1] = k;
for (register int i = 0; i < n; i++) {
d ^= 1;
register int lim = (i + 1 < begin + 200 ? i + 1 : begin + 200) + 1;
for (register int j = begin; j <= lim; j++) f[d][j] = g[d][j] = 0, cnt++;
for (register int j = begin; j <= lim; j++) {
register double t1 = f[d ^ 1][j] / (j + 1) / k,
t2 = f[d ^ 1][j] / (j + 1) * j / k;
f[d][j + 1] += t1;
g[d][j + 1] += t1 * j;
f[d][j] += t2;
g[d][j] += f[d ^ 1][j] * j / 2 / k;
f[d][j] += f[d ^ 1][j] - t1 - t2;
cnt++;
}
for (register int j = begin; j <= lim; j++) F[i] += g[d][j], cnt++;
while (f[d][begin] < 1e-16) begin++;
}
register double Ans = 0;
for (register int i = 1; i <= n; i++) F[i] += F[i - 1];
printf("%0.10lf\n", F[n]);
return 0;
}
|
#include <bits/stdc++.h>
const int MX = 540;
int n, m, i, j, ii, i1;
double x, y, r, f[2][MX], s[MX];
int main() {
for (i = 1; i < MX; i++) s[i] = s[i - 1] + i;
for (i = 1; i < MX; i++) s[i] /= i;
scanf("%d%d", &n, &m);
x = (m - 1.) / m;
y = 1. - x;
for (i = 1; i <= n; i++) {
ii = i & 1;
i1 = 1 - ii;
for (j = 1; j < MX; j++) {
f[ii][j] = f[i1][j] * x;
f[ii][j] += (f[i1][j] + s[j]) * (j / (j + 1.)) * y;
f[ii][j] += (f[i1][j + 1] + j) / (j + 1.) * y;
}
}
printf("%.11lf\n", f[n & 1][1] * m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
inline void write(int x) {
static const int maxlen = 100;
static char s[maxlen];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int len = 0;
for (; x; x /= 10) s[len++] = x % 10 + '0';
for (int i = len - 1; i >= 0; --i) putchar(s[i]);
}
double f[720][2];
int n, m;
int main() {
int pre = 0, now = 1;
read(n);
read(m);
f[710][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 700; j++) {
f[j][now] = (m - 1.0) / m * f[j][pre] +
1.0 / m / (j + 1) *
(j * f[j][pre] + (j + 1) * j / 2 + f[j + 1][pre] + j);
}
swap(now, pre);
}
printf("%.10f\n", m * f[1][pre]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
int n, k, i, j;
double dp[2][805], ans;
int main() {
cin >> n >> k;
dp[0][1] = 1;
int x = 1, y = 0;
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
swap(x, y);
for (((j)) = (1); ((j)) <= ((800)); ((j))++) {
ans += dp[x][j] * (j / 2.0 + j / (j + 1.0));
}
dp[y][1] = 0;
for (((j)) = (1); ((j)) <= ((800)); ((j))++) {
dp[y][j] += dp[x][j] * (1 - 1.0 / k);
dp[y][j] += dp[x][j] * (1.0 / k) * (j / (j + 1.0));
dp[y][j + 1] = dp[x][j] * (1.0 / k) * (1.0 / (j + 1.0));
}
for (((j)) = (1); ((j)) <= ((800)); ((j))++)
if (dp[y][j] < 1e-100) dp[y][j] = 0.0;
}
printf("%.18f\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double f[100005];
int main() {
int n, m, t, i, j;
scanf("%d%d", &n, &m);
t = min(n, 80000000 / n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= t; j++) {
f[j] = 1.0 / m / (j + 1) * (j * f[j] + j * 0.5 * (j + 1) + f[j + 1] + j) +
(m - 1) * 1.0 / m * f[j];
}
}
printf("%.10lf\n", m * f[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i) {
if (i != v.begin()) os << ", ";
os << *i;
}
os << "]";
return os;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
const int T = 600;
vector<double> D(T + 2, 0);
for (int i = 0; i < (int)(n); ++i) {
vector<double> nD(T + 2, 0);
for (int el = (int)(1); el <= (int)(T); ++el)
nD[el] = (1 - 1.0 / k) * D[el] +
(el * (D[el] + (el + 1) / 2.0) + D[el + 1] + el) / k / (el + 1);
D.swap(nD);
}
printf("%.12lf\n", k * D[1]);
}
|
#include <bits/stdc++.h>
double dp[2][850];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int t = std::min(n, 800);
int now = 1;
for (int i = 1; i <= n; i++) {
for (int j = t; j >= 1; j--) {
dp[now][j] =
dp[now ^ 1][j] * (k - 1) / (1.0 * k) +
(j * dp[now ^ 1][j] + dp[now ^ 1][j + 1] + j * (j + 3) / 2.0) /
(1.0 * k * (j + 1));
}
now ^= 1;
}
printf("%.10f\n", k * dp[now ^ 1][1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 110000;
const int maxK = 610;
int n, k;
double d[2][maxK];
double t[maxK], s[maxK];
int main() {
for (int i = 1; i < maxK; ++i) {
t[i] = 1.0 / (double)(i + 1);
s[i] = (double)(i) * (double)(i + 1) * t[i] / 2.0;
}
cin >> n >> k;
double p = 1.0 / (double)(k);
double q = 1.0 - p;
int u = 0, v = 1;
memset(d[u], 0, sizeof(d[u]));
double res = 0.0;
d[u][1] = 1.0;
for (int steps = 0; steps < n; ++steps, swap(u, v)) {
memset(d[v], 0, sizeof(d[v]));
for (int i = 1; i < maxK; ++i) {
if (d[u][i] < 1e-100) d[u][i] = 0.0;
d[v][i] += d[u][i] * q;
if (i + 1 < maxK) {
d[v][i + 1] += d[u][i] * p * t[i];
res += d[u][i] * p * t[i] * (double)(i);
}
d[v][i] += d[u][i] * p * (1.0 - t[i]);
res += d[u][i] * p * s[i];
}
}
printf("%.10lf\n", res * (double)(k));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[100005];
double dp2[100005];
double n, k;
int main() {
cout << fixed << setprecision(12);
cin >> n >> k;
for (int i = 0; i < 100005; ++i) dp[i] = 0;
for (int t = 700; t >= 1; --t) {
for (int i = 0; i < 100005; ++i) dp2[i] = 0;
for (int n1 = 0; n1 <= 100000; ++n1) {
if (n1 == 0) {
dp2[n1] = 0;
continue;
}
dp2[n1] = (1 - 1 / (k * (t + 1))) * dp2[n1 - 1] + t / (2.0 * k) +
t / ((t + 1) * k) + 1 / (k * (t + 1)) * dp[n1 - 1];
}
for (int i = 0; i < 100005; ++i) dp[i] = dp2[i];
}
cout << k * dp[(int)n] << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"avx,avx2,fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long MOD = 1e9 + 7;
long double x[700];
long double x_[700];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0),
cout << fixed << setprecision(20);
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 700; j++) {
x_[j] = (j * x[j] + x[j + 1] + (long double)j * (j + 3) / 2.0) /
(long double)((j + 1) * k) +
x[j] - x[j] / (long double)k;
}
for (int j = 0; j < 700; j++) {
x[j] = x_[j];
}
}
cout << x[1] * (long double)k;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double dp[2][660], k;
int main() {
scanf("%d%lf", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 660; j++)
dp[i & 1][j] =
(1 / k) *
((j * dp[i & 1 ^ 1][j] + dp[i & 1 ^ 1][j + 1] + j) / (j + 1) +
(k - 1) * dp[i & 1 ^ 1][j] + j / 2.0);
printf("%.10f", k * dp[n & 1][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxj = 600;
int n, k;
double dp[2][maxj];
int main() {
fill(dp[0], dp[0] + maxj, 0.0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < maxj - 1; j++) {
double kk = (double)k;
double jj = (double)j;
dp[1][j] = 1.0 / (kk * (jj + 1.0)) *
(jj * (jj + 3.0) / 2.0 + jj * dp[0][j] + dp[0][j + 1]) +
(1.0 - 1.0 / kk) * dp[0][j];
}
for (int j = 1; j < maxj - 1; j++) {
dp[0][j] = dp[1][j];
}
}
cout << fixed << setprecision(10) << k * dp[1][1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int S = 550;
int n, k;
double f[2][905], ans;
int main() {
int i, j, t;
double s1, s2, s3;
bool p1, p2;
n = read();
k = read();
f[0][1] = 1;
p1 = 0;
p2 = 1;
double pre1 = 1.0 / k, pre2 = (double)(k - 1) / k;
for (i = 1; i <= n; i++) {
p1 ^= 1;
p2 ^= 1;
for (t = min(i + 1, S), j = 1; j <= t; j++) {
s1 = pre2 * f[p2][j];
s2 = pre1 / j * f[p2][j - 1];
s3 = pre1 * j / (j + 1) * f[p2][j];
ans += s2 * (j - 1);
ans += pre1 * f[p2][j] * j / 2;
f[p1][j] = s1 + s2 + s3;
}
}
printf("%.12lf", ans * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool now = 1;
double dp[2][1010];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
for (int j = min(n, 1000); j >= 1; j--) {
dp[now][j] = 0;
dp[now][j] += dp[now ^ 1][j + 1] + j;
dp[now][j] += 1.0 * j * dp[now ^ 1][j];
dp[now][j] += 1.0 * (j + 1) / 2.0 * j;
dp[now][j] /= (1.0 + j);
dp[now][j] += dp[now ^ 1][j] * (k - 1.0);
dp[now][j] /= 1.0 * k;
}
now ^= 1;
}
printf("%0.15lf\n", dp[now ^ 1][1] * 1.0 * k);
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][605];
int main() {
int n;
double k;
scanf("%d%lf", &n, &k);
for (int i = n - 1; i >= 0; i--)
for (int j = 1; j < 600; j++)
dp[i & 1][j] =
((1.0 * j * dp[(i + 1) % 2][j] + dp[(i + 1) % 2][j + 1] + 1.0 * j) /
(j + 1) +
0.5 * j + 1.0 * (k - 1) * dp[(i + 1) % 2][j]) /
k;
printf("%.10lf\n", k * dp[0][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LN = 666;
const int FN = 111111;
double mem[2][LN];
double K, noK;
int main() {
int n, k;
cin >> n >> k;
K = double(1) / k;
noK = double(k - 1) / k;
double *fw = mem[0], *fr = mem[1];
for (int fi = 1; fi <= n; ++fi) {
for (int l = 1; l < LN - 1; ++l) {
double& ans = fw[l] = 0;
ans += fr[l] * l / (l + 1) + l / 2.0;
ans += (fr[l + 1] + l) / (l + 1);
ans = ans * K + fr[l] * noK;
}
swap(fw, fr);
}
cout.precision(20);
cout << k * fr[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 700;
int n, k;
double dp[N];
double prev_dp[N];
int main() {
scanf("%d%d", &n, &k);
for (int it = 0; it < n; it++) {
for (int t = 1; t < N - 1; t++) {
double p1 = 1.0 / k;
dp[t] += p1 * (1.0 / (t + 1)) *
(t * prev_dp[t] + prev_dp[t + 1] + t * (t + 1) / 2 + t);
dp[t] += (1.0 - p1) * prev_dp[t];
}
copy(dp, dp + N, prev_dp);
fill(dp, dp + N, 0);
}
double ans = prev_dp[1];
printf("%.10lf\n", ans * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
double dp[2][605];
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 600; j++)
dp[i & 1][j] = (double)(k - 1) / k * dp[(i & 1) ^ 1][j] +
1.0 / k *
(dp[(i & 1) ^ 1][j + 1] / (j + 1) +
dp[(i & 1) ^ 1][j] * j / (j + 1) +
((double)(j + 2) * (j + 1) / 2 - 1) / (j + 1));
printf("%.15lf\n", dp[n & 1][1] * k);
}
|
#include <bits/stdc++.h>
const int N = 550;
double dp[N];
double mul[N];
int n, k;
int main() {
while (~scanf("%d %d", &n, &k)) {
for (int i = 1; i < N; i++) {
dp[i] = 0;
}
dp[1] = k;
for (int j = 1; j < N; j++)
mul[j] = ((double)j / 2 + (double)j / (j + 1)) / k;
double ans = 0;
for (int i = 0; i < n; i++) {
for (int j = N - 2; j >= 0; j--) {
double tmp = dp[j];
if (tmp < 1e-100) continue;
double div = (j + 1) * k;
ans += tmp * mul[j];
dp[j + 1] += tmp / div;
dp[j] = tmp * (1 - 1 / div);
}
}
printf("%.10lf\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace output {
void __(short x) { cout << x; }
void __(unsigned x) { cout << x; }
void __(int x) { cout << x; }
void __(long long x) { cout << x; }
void __(unsigned long long x) { cout << x; }
void __(double x) { cout << x; }
void __(long double x) { cout << x; }
void __(char x) { cout << x; }
void __(const char* x) { cout << x; }
void __(const string& x) { cout << x; }
void __(bool x) { cout << (x ? "true" : "false"); }
template <class S, class T>
void __(const pair<S, T>& x) {
__(1 ? "(" : ""), __(x.first), __(1 ? ", " : " "), __(x.second),
__(1 ? ")" : "");
}
template <class T>
void __(const vector<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const set<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const multiset<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class S, class T>
void __(const map<S, T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
void pr() { cout << "\n"; }
template <class S, class... T>
void pr(const S& a, const T&... b) {
__(a);
if (sizeof...(b)) __(' ');
pr(b...);
}
} // namespace output
using namespace output;
const int MN = 1e5 + 5, MS = 999;
int N, K, i, j, x, y;
long double f[MS], dp[2][MN], ans;
int main() {
scanf("%d%d", &N, &K);
for (i = 1; i < MS; i++) {
for (j = 1; j <= i; j++) f[i] += j;
f[i] = (f[i] + i) / (long double)(i + 1);
}
dp[1][0] = 1.0;
for (i = 1; i < MS; i++) {
for (j = 0; j < N; j++) dp[(i + 1) & 1][j] = 0.0;
for (j = 0; j < N; j++) {
ans += i / (long double)K / (long double)i * f[i] * dp[i & 1][j];
dp[i & 1][j + 1] += ((K - 1) * (i + 1) + i) / (long double)K /
(long double)(i + 1) * dp[i & 1][j];
dp[(i + 1) & 1][j + 1] +=
1 / (long double)K / (long double)(i + 1) * dp[i & 1][j];
}
}
printf("%.10Lf\n", ans * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1000;
int main() {
int n, k;
cin >> n >> k;
double dpPrev[MAXM + 1];
double dpNext[MAXM + 1];
for (int i = 0; i <= min(MAXM - 1, n); i++) dpPrev[i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= min(MAXM - 1, n); j++)
dpNext[j] =
(j * dpPrev[j] + dpPrev[j + 1] + j * (j + 3) / 2) / (k * (j + 1)) +
(double)(k - 1) / k * dpPrev[j];
for (int j = 0; j <= min(MAXM - 1, n); j++) dpPrev[j] = dpNext[j];
}
printf("%.12lf", k * dpPrev[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long fast_exp(long long a, long long b) {
if (b <= 0)
return 1;
else {
long long res = 1;
res = fast_exp(a, b / 2);
res = (res * res) % mod;
if (b % 2 == 1) res = (res * a) % mod;
return res;
}
}
const long long N = 2e5 + 1000;
const long double pi = acos(-1.0);
long double dp[2][N + 5] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
const int lim = 447 + 21 * 4;
dp[0][1] = 1;
long double ans = 0;
int cur = 0;
int next = (cur + 1) % 2;
int iter = 0;
long double inverse_k = 1 / (long double)k;
while (iter < n) {
for (int i = 1; i < lim; i++) dp[next][i] = 0;
long double avg = 0.5;
for (int i = 1; i < lim; i++) {
long double prob_inc = ((long double)1 / (i + 1));
long double prob_ninc = 1 - (long double)1 / (long double)(i + 1);
if (i == lim - 1) {
prob_inc = 0;
prob_ninc = 1;
}
long double prob = prob_inc * inverse_k;
dp[next][i] += dp[cur][i] * (1 - prob);
dp[next][i + 1] += dp[cur][i] * prob;
avg += 0.5;
ans += inverse_k * (avg * prob_ninc + (1 - prob_ninc) * i) * dp[cur][i];
}
swap(cur, next);
iter++;
}
cout << fixed << setprecision(12) << ans * k << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
const int maxlevel = 800;
vector<double> fi(maxlevel + 1, 0.0), oldfi(maxlevel + 1);
for (int i = 1; i <= n; i++) {
fi.swap(oldfi);
for (int l = 1; l <= maxlevel; l++) {
fi[l] = 0.0;
fi[l] += (k - 1.0) / (1.0 * k) * oldfi[l];
double p2 = 0.0;
if (l + 1 <= maxlevel)
p2 += (1.0 / (l + 1.0)) * (l + oldfi[l + 1]);
else
p2 += (1.0 / (l + 1.0)) * (l + 0.0);
p2 += (1.0 * l) / (l + 1.0) * oldfi[l];
p2 += l / 2.0;
fi[l] += p2 * (1.0 / k);
}
}
double ret = 1.0 * k * fi[1];
printf("%.10f\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class... Ts>
std::ostream &operator<<(std::ostream &os, const std::tuple<Ts...> &t) {
os << "(";
deploy<0, std::tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::queue<T> &q) {
auto qq = q;
os << "{";
for (; !qq.empty(); qq.pop()) {
os << qq.front() << (qq.size() != 1 ? ", " : "");
}
os << "}";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> &q) {
auto qq = q;
os << "{";
for (; !qq.empty(); qq.pop()) {
os << qq.top() << (qq.size() != 1 ? ", " : "");
}
os << "}";
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::pair<T, K> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::unordered_map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
const int64_t MAX = 100500;
const int64_t M = 605;
vector<double> dp[MAX];
inline double recur(int64_t rem, int64_t level) {
if (rem == 0) return 0;
level = min(level, M - 5);
double &res = dp[rem & 1][level];
if (res != -1) return res;
res = 0;
res +=
level / (level + 1.0) * (recur(rem - 1, level + 0) + level * 0.5 + 0.5);
res += 1.0 / (level + 1.0) * (recur(rem - 1, level + 1) + level);
return res;
}
int main() {
int64_t n, k;
cin >> n >> k;
double dat[MAX];
dp[0] = vector<double>(M, 0);
dp[1] = vector<double>(M, 0);
for (int64_t i = 0; i < ((int64_t)(MAX - 5)); ++i) {
int64_t index = 1 - (i & 1);
for (int64_t j = 0; j < ((int64_t)(M)); ++j) dp[index][j] = -1;
for (int64_t l = 0; l < ((int64_t)(M)); ++l) recur(i + 1, l);
dat[i] = dp[i & 1][1];
}
if (k == 1) {
printf("%0.20lf\n", (double)dat[n]);
return 0;
}
double ans = 0;
double in = log(1.0 / k);
double out = log((k - 1.0) / k);
double bef_total = log(1.0);
for (int64_t t = 0; t <= n; ++t) {
double total = bef_total;
total += in * t;
total += out * (n - t);
ans += exp(total) * dat[t];
bef_total += log(n - t);
bef_total -= log(t + 1);
}
printf("%0.20lf\n", (double)ans * k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 10000;
double t[2][MAX + 1];
double zostaje[MAX + 1];
double przejscie[MAX + 1];
double zysk[MAX + 1];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int m = min(n + 1, MAX);
double *cur = t[0];
double *nowy = t[1];
for (int j = (1); j <= (m - 1); ++j) {
zysk[j] = (double)(j + 2.0) / 2.0 - 1.0 / (double)(j + 1.0);
zysk[j] /= k;
przejscie[j] = 1.0 / (double)k / (double)(j + 1.0);
zostaje[j] = 1.0 - przejscie[j];
}
zysk[m] = (double)(m + 2.0) / 2.0 - 1.0 / (double)(m + 1.0);
zysk[m] /= k;
for (int i = 0; i < (n); ++i) {
for (int j = (1); j <= (m - 1); ++j) {
nowy[j] = zysk[j] + zostaje[j] * cur[j] + przejscie[j] * cur[j + 1];
}
nowy[m] = zysk[m] + cur[m];
swap(cur, nowy);
}
printf("%.12lf\n", cur[1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e3 + 10;
long long N, M;
double f[2][MAXN];
int main() {
scanf("%lld%lld", &N, &M);
for (long long i = 1; i <= N; i++) {
for (long long j = 1; j <= min(N, 1000LL); j++) {
f[i & 1][j] =
f[(i - 1) & 1][j] * (1.0 - (1.0 / M)) +
(f[(i - 1) & 1][j + 1] + j) * (1.0 / (M * (j + 1))) +
(f[(i - 1) & 1][j] + (1 + j) / 2.0) * (j * 1.0 / (M * (j + 1)));
}
}
printf("%.10f\n", f[N & 1][1] * M);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1.1e5;
int n;
double dp[2][N], k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < 666; j++)
dp[i & 1][j] = ((dp[i - 1 & 1][j + 1] + j) / (j + 1) + j / 2.0 +
dp[i - 1 & 1][j] * j / (j + 1)) /
k +
dp[i - 1 & 1][j] * (k - 1) / k;
}
printf("%.12lf", dp[n & 1][1] * k);
}
|
#include <bits/stdc++.h>
const int MAXN = 550;
int n, k;
double dp[2][MAXN + 5];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= MAXN; j++)
dp[i & 1][j] =
(dp[(i - 1) & 1][j] * ((k - 1) * 1.0 / k) +
(dp[(i - 1) & 1][j + 1] + j) * (1.0 / (k * (j + 1))) +
(dp[(i - 1) & 1][j] + (1 + j) / 2.0) * (j * 1.0 / (k * (j + 1))));
printf("%.10f\n", dp[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double f[2001], k[100001], s, ans;
int n;
int main() {
scanf("%d%lf", &n, &s);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= min(1000, n); j++) {
f[j] =
((f[j + 1] + double(j)) / double(j + 1.0) +
(double(j) * (f[j] + (double(j) + 1.0) / 2.0)) / double(j + 1.0)) /
s +
((s - 1.0) * f[j]) / s;
}
}
ans = f[1] * s;
printf("%.9lf\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
int n, k, cur;
long double dp[2][MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = n; i; --i) {
cur ^= 1;
int B = 701;
for (int j = 1; j < B; ++j) {
dp[cur][j] = (dp[cur ^ 1][j] + (1. + j) / 2) * j;
dp[cur][j] += (dp[cur ^ 1][j + 1] + j);
dp[cur][j] /= j + 1;
dp[cur][j] += dp[cur ^ 1][j] * (k - 1);
dp[cur][j] /= k;
}
}
long double ans = dp[cur][1] * k;
printf("%.20f\n", (double)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
double D[2][702];
int main() {
cin >> N >> K;
int act = 0;
for (int i = 1; i <= N; ++i) {
act = !act;
memset(D[act], 0, sizeof(D[act]));
for (int j = 1; j <= min(700, N); ++j)
D[act][j] = (1.0 / K) * (1.0 / (j + 1)) * (D[!act][j + 1] + j) +
(1.0 / K) * (1.0 * j / (j + 1)) * D[!act][j] +
(1.0 / K) * (1.0 / (j + 1)) * j * (j + 1) / 2 +
(1.0 * (K - 1) / K) * D[!act][j];
}
cout << fixed << setprecision(9) << 1.0 * K * D[act][1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long double f[2010], inv[2010], res, delta;
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int t = 2010 - 1; t + 1; t--) f[t] = 0, inv[t] = 1.0 / t;
f[1] = 1;
for (int round = 1; round <= n; round++) {
for (int t = 2000; t + 1; t--) {
if (fabs(f[t]) <= 1e-50) {
f[t] = 0;
continue;
}
res += f[t] * t * (0.5 + inv[t + 1]);
delta = f[t] * inv[t + 1] * inv[k];
f[t + 1] += delta;
f[t] -= delta;
}
}
printf("%.12lf\n", (double)res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
char ch = getchar();
T x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
double f[2][1009];
int main(int argc, char const *argv[]) {
int n = read<int>(), k = read<int>();
int temp = 1;
for (int(i) = (1); (i) <= (n); (i)++) {
for (int(j) = (min(n, 1000)); (j) >= (1); (j)--)
f[temp][j] = ((f[temp ^ 1][j + 1] + j) / (j + 1.0) +
j * (f[temp ^ 1][j] + (j + 1.0) / 2.0) / (j + 1.0)) /
(double)k +
(k - 1) * f[temp ^ 1][j] / (double)k;
temp ^= 1;
}
printf("%.10lf\n", k * f[temp ^ 1][1]);
return 0;
}
|
#include <bits/stdc++.h>
double f[2][600], n, k, i, j;
int p;
int main() {
scanf("%lf%lf", &n, &k);
p = 1;
for (i = n - 1; i >= 0; i--) {
p ^= 1;
for (j = 1; j < 600; j++)
f[p][(int)j] = f[p ^ 1][(int)j] * (j / (j + 1) / k + (k - 1) / k) +
(j * .5 + j / (j + 1)) / k +
f[p ^ 1][(int)j + 1] / (j + 1) / k;
}
printf("%.9lf", k * f[p][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1005;
double n, K, f[2][M], ans;
int main() {
cin >> n >> K;
for (int i = 1; i <= n; i++) {
int x = (i & 1), y = (x ^ 1);
for (int j = 1; j <= M; j++) {
f[x][j] = 1.0 * f[y][j] * (K - 1) / K;
f[x][j] += 1.0 * (f[y][j + 1] + j) * (1.0 / ((j + 1) * K));
f[x][j] += 1.0 * (f[y][j] + 1.0 * (j + 1) / 2.0) * j / ((j + 1) * K);
}
}
printf("%.10lf\n", f[(int)n & 1][1] * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_LEVEL = 600;
int n, k;
double f[2][MAX_LEVEL + 5];
double prob[2][MAX_LEVEL + 5];
int main() {
ios ::sync_with_stdio(false);
cin.tie(NULL);
cout << (fixed) << setprecision(16);
while (cin >> n >> k) {
memset(f, 0, sizeof f);
memset(prob, 0, sizeof prob);
f[0][1] = 0.0;
prob[0][1] = 1.0;
int row = 0;
for (int i = (0), _b = (n - 1); i <= _b; i++) {
memset(f[row ^ 1], 0, sizeof f[row ^ 1]);
memset(prob[row ^ 1], 0, sizeof prob[row ^ 1]);
for (int t = (1), _b = (MAX_LEVEL); t <= _b; t++)
if (prob[row][t] > 1e-30) {
double cur = prob[row][t] / (double)(t + 1) * (1 / (double)k);
prob[row ^ 1][t + 1] += cur;
f[row ^ 1][t + 1] += cur * (f[row][t] / prob[row][t] + t);
cur = prob[row][t] * t / (double)(t + 1) * (1 / (double)k);
prob[row ^ 1][t] += cur;
f[row ^ 1][t] += cur * (f[row][t] / prob[row][t]) +
(cur / t) * (t * (t + 1)) / 2.0;
cur = prob[row][t] * (k - 1) / (double)k;
prob[row ^ 1][t] += cur;
f[row ^ 1][t] += cur * (f[row][t] / prob[row][t]);
}
double sum = 0.0;
for (int t = (1), _b = (MAX_LEVEL); t <= _b; t++) sum += prob[row ^ 1][t];
for (int t = (1), _b = (MAX_LEVEL); t <= _b; t++) prob[row ^ 1][t] /= sum;
row = 1 - row;
}
double res = 0.0;
for (int t = (1), _b = (MAX_LEVEL); t <= _b; t++) res += f[row][t];
cout << res * k << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int n, k;
double f[2][610];
int main() {
scanf("%d%d", &n, &k);
for (int i = n; i >= 1; i--) {
memset(f[i % 2], 0, sizeof f[i % 2]);
for (int j = 1; j <= min(600, i + 1); j++) {
f[i % 2][j] += f[(i + 1) % 2][j] * ((double)k - 1) / ((double)k);
f[i % 2][j] +=
(f[(i + 1) % 2][j + 1] + ((double)j)) / ((double)k) / ((double)j + 1);
f[i % 2][j] += (f[(i + 1) % 2][j] * ((double)j) +
(((double)j + 1) * ((double)j) / 2.0)) /
((double)k) / ((double)j + 1);
}
}
double ans = f[1][1];
printf("%0.12f\n", ans * ((double)k));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long double eps = 1e-100, dp[2][1000 + 1], ans = 0;
int main() {
cin >> n >> k;
dp[0][1] = 1.0;
for (int i = 0; i < (n); ++i) {
int cur = i % 2, nxt = 1 - cur;
for (int j = 0; j < (1000); ++j)
ans += dp[cur][j] * (1.0 * j * (j + 3) / 2 / (j + 1));
for (int j = 0; j < (1000); ++j)
dp[nxt][j] = dp[cur][j] * (1.0 - 1.0 / k / (j + 1));
for (int j = 0; j < (1000); ++j) dp[nxt][j + 1] += dp[cur][j] / k / (j + 1);
for (int j = 0; j < (1000); ++j)
if (dp[nxt][j] < eps) dp[nxt][j] = 0;
}
printf("%.12f\n", (double)ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long double pra[2][707];
long double dp[2][707];
long double wyn;
long double gra;
long double tak, nie;
int x;
long double a, b, s;
double wyp;
void zer(int v) {
for (int i = 0; i <= 700; i++) {
dp[v][i] = 0.0;
pra[v][i] = 0.0;
}
}
int main() {
gra = 1;
gra /= 1000.0;
gra /= 1000.0;
gra /= 1000.0;
gra /= 1000.0;
gra /= 1000.0;
scanf("%d%d", &n, &k);
tak = 1.0 / k;
nie = 1.0 - tak;
pra[0][0] = 1.0;
for (int h = 0; h < n; h++) {
int i = h & 1;
zer(i ^ 1);
for (int j = 0; j <= 700; j++) {
if (pra[i][j] <= gra) continue;
if (k > 1) {
a = pra[i][j] * nie;
b = pra[i ^ 1][j];
dp[i ^ 1][j] = (dp[i][j] * a + dp[i ^ 1][j] * b) / (a + b);
pra[i ^ 1][j] = a + b;
}
a = pra[i][j] * tak * ((j + 1.0) / (j + 2.0));
b = pra[i ^ 1][j];
dp[i ^ 1][j] =
((dp[i][j] + ((j + 2.0) / 2.0)) * a + dp[i ^ 1][j] * b) / (a + b);
pra[i ^ 1][j] = a + b;
a = pra[i][j] * tak * (1.0 / (j + 2.0));
b = pra[i ^ 1][j + 1];
dp[i ^ 1][j + 1] =
(((dp[i][j] + (j + 1.0))) * a + dp[i ^ 1][j + 1] * b) / (a + b);
pra[i ^ 1][j + 1] = a + b;
}
}
for (int i = 0; i <= 700; i++) {
wyn += dp[n & 1][i] * pra[n & 1][i] * k;
}
wyp = wyn;
printf("%.11lf\n", wyp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
double f[2][100010];
int main() {
cin >> n >> k;
m = min(n, 650);
for (int i = 1; i <= n; i++) {
int d = i & 1;
for (int j = 0; j <= m; j++)
f[d][j] =
((f[1 - d][j + 1] + j + (f[1 - d][j] + (j + 1.0) / 2.0) * (0.0 + j)) /
(1.0 + j) +
(k - 1.0) * f[1 - d][j]) /
k;
}
printf("%.9lf", f[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const double eps = 1e-99;
int n, k, L, R;
double P[N], E[N];
int main() {
cin >> n >> k;
P[1] = E[1] = L = R = 1;
while (n--) {
for (int i = R; i >= L; i--) {
double p2 = 1.0 / k / (i + 1);
double p1 = 1.0 - p2;
E[i + 1] += p2 * E[i] + p2 * P[i] * (i + 1);
P[i + 1] += p2 * P[i];
E[i] = p1 * E[i] + p2 * P[i] * i * (i + 1) / 2;
P[i] = p1 * P[i];
}
for (R++; P[R] < eps; R--) P[R] = E[R] = 0;
for (L--; P[L] < eps; L++) P[L] = E[L] = 0;
}
double ans = 0;
for (int i = L; i <= R; i++) ans += E[i] - P[i] * i;
printf("%.10lf", ans * k);
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
double D[2][1010], P1, P2, P[2][1010], Res, PP[1010][3];
int n, k;
int main() {
int i, j, x;
scanf("%d%d", &n, &k);
P1 = 1.0 / k;
P[0][1] = 1.0;
for (i = 1; i <= 1000; i++) {
PP[i][0] = 1.0 - 1.0 / (1.0 + i) / (double)k;
PP[i][1] = 1.0 / (double)i / (double)k;
PP[i][2] = 1.0 / i * P1;
}
for (i = 1; i <= n; i++) {
x = i & 1;
for (j = 1; j <= 1000 && j <= i + 1; j++) {
P[x][j] = D[x][j] = 0;
P[x][j] += P[!x][j] * PP[j][0];
P[x][j] += P[!x][j - 1] * PP[j][1];
D[x][j] = D[!x][j] * (1.0 - P1);
P2 = (double)j / (double)(j + 1);
D[x][j] += (D[!x][j] + (1.0 + j) * 0.5 * P[!x][j]) * P1 * P2;
if (j != 1) D[x][j] += (D[!x][j - 1] + (j - 1) * P[!x][j - 1]) * PP[j][2];
if (P[x][j] < 1e-200) P[x][j] = 0;
if (D[x][j] < 1e-200) D[x][j] = 0;
}
}
for (i = 1; i <= 1000 && i <= n + 1; i++) {
Res += D[n & 1][i];
}
printf("%.11lf\n", Res * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101010;
const int MAXM = 1000;
int N, K;
long double prob[2][MAXM];
long double comb[MAXN];
long double s[2][MAXM];
long double ev[MAXN];
void make_prob() {
s[0][1] = 0;
ev[0] = 0;
prob[0][1] = 1;
for (int t = 1; t <= N; t++) {
for (int l = 1; l <= t + 1 && l < MAXM; l++) {
if (prob[0][l] + prob[0][l - 1] < 1E-16) continue;
s[1][l] = (s[0][l] + prob[0][l] * (l + 1) / 2) * l / (l + 1);
prob[1][l] = prob[0][l] * l / (l + 1);
s[1][l] += (s[0][l - 1] + prob[0][l - 1] * (l - 1)) / l;
prob[1][l] += prob[0][l - 1] / l;
ev[t] += s[1][l];
if (s[1][l] < s[1][l - 1] && s[1][l] < 1E-16) break;
}
swap(s[0], s[1]);
swap(prob[0], prob[1]);
}
}
void make_comb() {
long double lg = 0;
comb[0] = pow((K - 1.0) / K, N);
for (int i = 1; i < N; i++) {
lg += log(N - i + 1) - log(i);
if (K == 1)
comb[i] = 0;
else
comb[i] = exp(lg + (N - i) * log(K - 1) - N * log(K));
}
comb[N] = pow(1.0 / K, N);
}
int main() {
ios_base::sync_with_stdio(0);
;
cin >> N >> K;
make_prob();
make_comb();
long double ans = 0;
for (int i = 0; i <= N; i++) ans += comb[i] * ev[i];
ans *= K;
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double dp[2][610];
int main() {
scanf("%d%d", &n, &k);
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j < 600; j++) {
double t1 = (1.0 * j * dp[(i + 1) & 1][j] + dp[(i + 1) & 1][j + 1] + j) /
(j + 1) +
0.5 * j;
double t2 = (1.0 * (k - 1) * dp[(i + 1) & 1][j]);
dp[i & 1][j] = (t1 + t2) / k;
}
}
printf("%.10lf\n", k * dp[0][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
long double dp[2][700 + 5];
int main() {
int i, j, k, cur, pre;
long double r;
scanf("%d %d", &N, &K);
for (int mov = 1; mov <= N; mov++) {
cur = mov % 2;
pre = (cur + 1) % 2;
for (int val = 1; val <= 700 && val <= N; val++) {
r = dp[pre][val] * (K - 1.0) / K;
r += val / (2.0 * K);
r += dp[pre][val] * (val / ((val + 1.0) * K));
r += val / ((val + 1.0) * K);
if (val < 700) r += dp[pre][val + 1] * (1 / ((val + 1.0) * K));
dp[cur][val] = r;
}
}
printf("%.10lf\n", (double)dp[N % 2][1] * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxj = 550;
int n, k;
double dp[2][maxj];
int main() {
fill(dp[0], dp[0] + maxj, 0.0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < maxj - 1; j++) {
double kk = (double)k;
double jj = (double)j;
dp[1][j] = 1.0 / (kk * (jj + 1.0)) *
(jj * (jj + 3.0) / 2.0 + jj * dp[0][j] + dp[0][j + 1]) +
(1.0 - 1.0 / kk) * dp[0][j];
}
for (int j = 1; j < maxj - 1; j++) {
dp[0][j] = dp[1][j];
}
}
cout << fixed << setprecision(10) << k * dp[1][1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
double dp[800];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int ub = min(n, 700);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= ub; j++)
dp[j] = ((double)k - 1) / (double)k * dp[j] +
1.0 / k / ((double)j + 1) *
(dp[j + 1] + j + j * dp[j] + (j + 1.0) * j / 2);
printf("%.12lf\n", dp[1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long fast_exp(long long a, long long b) {
if (b <= 0)
return 1;
else {
long long res = 1;
res = fast_exp(a, b / 2);
res = (res * res) % mod;
if (b % 2 == 1) res = (res * a) % mod;
return res;
}
}
const long long N = 2e5 + 1000;
const long double pi = acos(-1.0);
long double dp[2][N + 5] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
const int lim = 1000;
dp[0][1] = 1;
long double ans = 0;
int cur = 0;
int next = (cur + 1) % 2;
int iter = 0;
long double inverse_k = 1 / (long double)k;
while (iter < n) {
for (int i = 1; i < lim; i++) dp[next][i] = 0;
for (int i = 1; i < lim; i++) {
long double prob_inc = ((long double)1 / (i + 1));
long double prob_ninc = 1 - (long double)1 / (long double)(i + 1);
dp[next][i] += dp[cur][i] * (1 - prob_inc * inverse_k);
dp[next][i + 1] += dp[cur][i] * (prob_inc)*inverse_k;
long double avg = (i + 1) / (long double)2;
ans += inverse_k *
(avg * dp[cur][i] * prob_ninc + (1 - prob_ninc) * i * dp[cur][i]);
}
swap(cur, next);
iter++;
}
cout << fixed << setprecision(12) << ans * k << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int B = 700;
int n, k;
double f[2][B + 10];
int main() {
scanf("%d %d", &n, &k);
double I = 1.0 / (double)(k);
int now = 0;
for (int i = 1; i <= n; i++) {
now ^= 1;
for (int j = 1; j <= B; j++) {
double t = 1.0 / (double)(j + 1);
f[now][j] = f[now ^ 1][j] * (1 - I);
f[now][j] += I * ((1 - t) * (f[now ^ 1][j] + 1) + t * f[now ^ 1][j + 1] +
(double)(j) / 2);
}
}
printf("%.10lf\n", k * f[now][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double D1[100005], D2[100005];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= 700; ++j) {
D2[j] = ((double)1 / (k * j + k)) *
(j * (j + 1) / 2 + j * D1[j] + j + D1[j + 1]) +
((k - 1.0) / k) * D1[j];
}
for (int j = 1; j <= 700; ++j) {
D1[j] = D2[j];
}
}
double sol = D1[1] * k;
printf("%.12lf\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long OO = 1LL << 61;
const long long MOD = 10007;
const int maxn = 100000 + 5;
double dp[2][600];
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
memset(dp, 0, sizeof dp);
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j < 600; j++) {
double t1 =
(1.0 * j * dp[(i + 1) % 2][j] + dp[(i + 1) % 2][j + 1] + 1.0 * j) /
(j + 1) +
0.5 * j;
double t2 = 1.0 * (k - 1) * dp[(i + 1) % 2][j];
dp[i % 2][j] = (t1 + t2) / k;
}
}
printf("%.10lf\n", k * dp[0][1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double k, f[2][610];
int read() {
int x = 0, f = 1, c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
int main() {
n = read();
k = 1. * read();
int now = 1;
for (int i = n - 1; i >= 0; i--) {
now ^= 1;
for (int j = 0; j <= 600; j++)
f[now][j] = f[now ^ 1][j + 1] / (k * (j + 1)) + j / (2 * k) +
j / (k * (j + 1)) +
f[now ^ 1][j] * ((1 - 1 / k) + j / (k * (j + 1)));
}
printf("%.10lf", k * f[now][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
double f[2][100010UL];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int blo = 526;
double p1 = (double)(k - 1) / (double)k, p2 = 1. / (double)k;
int lt = 1, nw = 0;
for (int i = 1; i <= n; ++i) {
lt ^= 1, nw ^= 1;
for (int j = 1; j <= 526; ++j) {
f[nw][j] = p1 * f[lt][j] +
p2 * ((double)j / (j + 1) * (f[lt][j] + (double)(j + 1) / 2.) +
1. / (double)(j + 1) * (f[lt][j + 1] + (double)j));
}
}
printf("%.10lf", f[nw][1] * k);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.