text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n;
int idxs[500500];
long long vals[500500];
long long l[500500], r[500500];
bool cmp_idx(int a, int b) { return vals[a] < vals[b]; }
void rem(int idx) {
l[r[idx]] = l[idx];
r[l[idx]] = r[idx];
}
int main() {
while (cin >> n) {
for (int i = 1; i <= n; ++i) {
cin >> vals[i];
idxs[i] = i;
l[i] = i - 1;
r[i] = i + 1;
}
vals[0] = vals[n + 1] = 0;
sort(idxs + 1, idxs + n + 1, cmp_idx);
int l_idx = 1, r_idx = n;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int idx = idxs[i];
ans += min(vals[l[idx]], vals[r[idx]]);
if (l_idx == idx) {
l_idx = r[idx];
} else if (r_idx == idx) {
r_idx = l[idx];
} else {
rem(idx);
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000ll;
const long long inf64 = inf * inf;
const double pi = acos(-1.0);
long long Abs(long long x) { return (x >= 0 ? x : -x); }
bool solve() {
int n;
cin >> n;
vector<int> a(n), l(n, -1), r(n, -1);
vector<bool> can(n, 1);
vector<pair<int, int> > b(n);
for (int i(0); i < n; i++) cin >> a[i], b[i] = make_pair(a[i], i);
sort((b).begin(), (b).end());
for (int i(1); i < n; i++) l[i] = i - 1;
for (int i(0); i < n - 1; i++) r[i] = i + 1;
int u, d;
d = 0, u = n - 1;
long long ans = 0;
for (int i(0); i < n - 2; i++) {
if (b[i].second == d)
ans += b[i].first, d = r[d];
else if (b[i].second == u)
ans += b[i].first, u = l[u];
else {
ans += min(a[l[b[i].second]], a[r[b[i].second]]);
r[l[b[i].second]] = r[b[i].second];
l[r[b[i].second]] = l[b[i].second];
}
}
cout << ans << '\n';
return true;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
long long n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int k, s = v.size();
cin >> k;
while (s > 1 && v[s - 1] <= k && v[s - 1] <= v[s - 2])
ans += min(k, v[s - 2]), v.pop_back(), s--;
v.push_back(k);
}
sort(v.begin(), v.end());
for (int i = 0; i < (int)v.size() - 2; i++) ans += v[i];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int ans;
long long int s[1000000];
int main() {
long long int x;
int n, i, t = -1;
scanf("%d", &n);
ans = 0;
for (i = 0; i < n; i++) {
scanf("%lld", &x);
while (t > 0 && s[t] <= s[t - 1] && s[t] <= x) {
ans = ans + min(s[t - 1], x);
t--;
}
t++;
s[t] = x;
}
sort(s, s + t + 1);
for (i = 0; i < t - 1; i++) ans = ans + s[i];
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 3;
int S[N], tp;
int main() {
int n;
long long ans = 0;
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
while (tp >= 2 && S[tp - 1] >= S[tp] && x >= S[tp]) {
ans += min(S[tp - 1], x);
--tp;
}
S[++tp] = x;
}
sort(S + 1, S + tp + 1);
for (register int i = 1; i <= tp - 2; i++) ans += S[i];
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n;
long long res;
int a[N];
stack<int> s;
priority_queue<int, vector<int>, greater<int> > q;
int main(void) {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) {
scanf("%d", a + i);
while (s.size() >= 2) {
int x = s.top();
s.pop();
int y = s.top();
if (x <= ((y) < (a[i]) ? (y) : (a[i])))
res += ((y) < (a[i]) ? (y) : (a[i]));
else {
s.push(x);
break;
}
}
s.push(a[i]);
}
while (!s.empty()) {
q.push(s.top());
s.pop();
}
while (q.size() > 2) {
res += q.top();
q.pop();
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65000000")
using namespace std;
int n;
pair<int, int> mas[500500];
set<pair<int, int> > st;
int main(int argc, const char* argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &mas[i].first);
mas[i].second = i;
st.insert(pair<int, int>(mas[i].second, mas[i].first));
}
sort(mas, mas + n);
long long answ = 0;
int bound = 0;
for (int i = 0; i < n - 2; ++i) {
answ += (mas[i].first - bound) * (long long)(n - 2 - i);
bound = mas[i].first;
pair<int, int> p(mas[i].second, mas[i].first);
set<pair<int, int> >::iterator it = st.find(p);
if (it != st.begin()) {
++it;
int ad = 0;
if (it != st.end()) ad = it->second - bound;
--it;
--it;
ad = min(ad, it->second - bound);
answ += ad;
++it;
}
st.erase(it);
}
cout << answ << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 500000;
int data[MAX_SIZE + 10], n;
int s[MAX_SIZE + 10], top;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", data + i);
long long ans = 0;
for (int i = 1; i <= n; i++) {
while (top > 1 && s[top - 2] >= s[top - 1] && data[i] >= s[top - 1]) {
ans += min(s[top - 2], data[i]);
--top;
}
s[top++] = data[i];
}
sort(s, s + top);
for (int i = 0; i < top - 2; i++) ans += s[i];
printf(
"%I64d"
"\n",
ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 4e18;
const int inf = 2e9;
const int N = 5e5 + 5;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int ne[N], pr[N], a[N];
queue<int> q;
bool done[N];
void check(int i) {
if (done[i]) return;
if (a[pr[i]] >= a[i] && a[i] <= a[ne[i]]) {
q.push(i);
done[i] = 1;
}
}
int main(void) {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pr[i] = i - 1;
ne[i] = i + 1;
}
ne[0] = 1;
pr[n + 1] = n;
for (i = 1; i <= n; ++i) check(i);
long long ans = 0;
while (q.size()) {
int now = q.front();
q.pop();
int next = ne[now];
int prev = pr[now];
ne[prev] = next;
pr[next] = prev;
ans += min(a[next], a[prev]);
check(next);
check(prev);
}
int now = ne[0];
while (now <= n) {
ans += min(a[pr[now]], a[ne[now]]);
now = ne[now];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 500111;
int a[MN], res[MN], cur, left_[MN], right_[MN], st[MN], n;
int it[MN * 3];
int better(int x, int y) {
if (!x) return y;
if (!y) return x;
if (a[x] > a[y])
return x;
else
return y;
}
void buildTree(int i, int l, int r) {
if (l == r) {
it[i] = l;
return;
}
int mid = (l + r) >> 1;
buildTree(((i) << 1), l, mid);
buildTree((((i) << 1) + 1), mid + 1, r);
it[i] = better(it[((i) << 1)], it[(((i) << 1) + 1)]);
}
int getMin(int i, int l, int r, int u, int v) {
if (v < l || r < u) return 0;
if (u <= l && r <= v) return it[i];
int res = u;
int mid = (l + r) >> 1;
res = better(getMin(((i) << 1), l, mid, u, v), res);
res = better(getMin((((i) << 1) + 1), mid + 1, r, u, v), res);
return res;
}
void init() {
int top = 0;
st[0] = 0;
for (int i = (1), _b = (n); i <= _b; i++) {
while (top && a[st[top]] < a[i]) --top;
left_[i] = st[top];
st[++top] = i;
}
top = 0;
st[0] = n + 1;
for (int i = (n), _b = (1); i >= _b; i--) {
while (top && a[st[top]] < a[i]) --top;
right_[i] = st[top];
st[++top] = i;
}
}
void solve(int l, int r) {
if (l + 1 >= r) return;
if (a[l] <= a[r]) {
int u = right_[l];
if (u == r) {
u = getMin(1, 1, n, l + 1, r - 1);
}
res[cur--] = u;
solve(l, u);
solve(u, r);
} else {
int u = left_[r];
if (u == l) {
u = getMin(1, 1, n, l + 1, r - 1);
}
res[cur--] = u;
solve(l, u);
solve(u, r);
}
}
int main() {
ios ::sync_with_stdio(false);
while (cin >> n) {
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
init();
buildTree(1, 1, n);
cur = n - 2;
solve(1, n);
set<int> s;
for (int i = (1), _b = (n); i <= _b; i++) s.insert(i);
long long sum = 0;
for (int turn = (1), _b = (n - 2); turn <= _b; turn++) {
int u = res[turn];
s.erase(u);
__typeof(s.begin()) next = s.lower_bound(u), prev = next;
--prev;
sum += min(a[*next], a[*prev]);
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, mod = 1e9 + 7;
const int N = 5e5 + 5;
set<pair<int, int> > S;
vector<pair<int, int> > v;
int h[N], a[N], x, n;
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
S.insert(make_pair(i, a[i]));
v.push_back(make_pair(a[i], i));
}
set<pair<int, int> >::iterator it, it2, it3;
sort(v.begin(), v.end());
for (__typeof(v.begin()) c = v.begin(); c != v.end(); c++) {
int index = c->second;
if (index == 1 || index == n) continue;
it2 = S.lower_bound(make_pair(index, 0));
it = it2;
it3 = it2;
it--;
it3++;
int cost = min(it->second, it3->second);
if (it2->second > cost) continue;
ans += cost;
S.erase(it2);
}
vector<int> v2;
for (__typeof(S.begin()) it = S.begin(); it != S.end(); it++)
v2.push_back(it->second);
sort(v2.begin(), v2.end());
for (int i = 0; i <= (int)v2.size() - 3; i++) ans += v2[i];
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[500050];
int chk[500050];
vector<int> checked;
int it[1048577];
int IT_MAX = 524288;
long long ANS = 0;
void update(int node, int val) {
it[node] = node - IT_MAX + 1;
while (node > 1) {
node /= 2;
if (d[it[2 * node]] > d[it[2 * node + 1]])
it[node] = it[2 * node];
else
it[node] = it[2 * node + 1];
}
return;
}
int get_MAX(int n1, int n2) {
int t = -1;
if (n1 == n2) return it[n1];
if (n1 % 2 == 1) {
t = it[n1];
n1++;
}
if (n1 == n2) {
if (t == -1)
return it[n1];
else
return (d[t] > d[it[n1]]) ? t : it[n1];
}
if (n2 % 2 == 0) {
if (t == -1)
t = it[n2];
else
t = (d[t] > d[it[n2]]) ? t : it[n2];
n2--;
}
int t2 = get_MAX(n1 / 2, n2 / 2);
if (t == -1)
return t2;
else
return (d[t] > d[t2]) ? t : t2;
}
void get_ans(int n1, int n2) {
if (n2 == n1 + 1) return;
ANS += min(d[n1], d[n2]);
int n3 = get_MAX(n1 + IT_MAX, n2 + IT_MAX - 2);
get_ans(n1, n3);
get_ans(n3, n2);
return;
}
int main() {
int N, i;
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%lld", &d[i]);
update(i - 1 + IT_MAX, d[i]);
}
chk[1] = chk[N] = 1;
int st = 1, en = N, mi;
while (st < en) {
if (d[st] > d[en]) {
mi = en - 1;
while (d[mi] <= d[en]) {
mi--;
if (st == mi) break;
}
if (st == mi)
break;
else {
chk[mi] = 1;
ANS += d[en];
en = mi;
}
} else {
mi = st + 1;
while (d[mi] <= d[st]) {
mi++;
if (en == mi) break;
}
if (en == mi)
break;
else {
chk[mi] = 1;
ANS += d[st];
st = mi;
}
}
}
for (i = 1; i <= N; i++)
if (chk[i] == 1) checked.push_back(i);
for (i = 0; i < checked.size() - 1; i++) {
get_ans(checked[i], checked[i + 1]);
}
printf("%lld", ANS);
return 0;
}
|
#include <bits/stdc++.h>
int num[500000], am;
long long int ans;
int min(int i1, int i2) {
if (i1 < i2) return i1;
return i2;
}
int max(int i1, int i2) {
if (i1 > i2) return i1;
return i2;
}
void read() {
scanf("%d", &num[am]);
am++;
while (am > 2 && (num[am - 2] <= num[am - 3] && num[am - 2] <= num[am - 1])) {
ans += min(num[am - 3], num[am - 1]);
num[am - 2] = num[am - 1];
am--;
}
}
void solve(int n) {
int i, j, k, l;
ans = 0;
if (n <= 2) {
if (n == 1) scanf("%d", &i);
if (n == 2) scanf("%d%d", &i, &j);
printf("0\n");
return;
}
am = 2;
scanf("%d%d", &num[0], &num[1]);
for (i = 0; i < n - 2; i++) read();
if (n <= 2) {
printf("%I64d\n", ans);
return;
}
if (num[0] <= num[1] && num[am - 2] <= num[am - 1]) {
for (i = 0; i < am - 2; i++) ans += num[i];
printf("%I64d\n", ans);
return;
}
if (num[0] >= num[1] && num[am - 2] >= num[am - 1]) {
for (i = 2; i < am; i++) ans += num[i];
printf("%I64d\n", ans);
return;
}
for (i = 0; i < am; i++) ans += num[i];
l = 0;
for (i = 0; i < am; i++)
if (num[l] < num[i]) l = i;
ans -= num[l];
ans -= max(num[l - 1], num[l + 1]);
printf("%I64d\n", ans);
}
int main() {
#pragma comment(linker, "/STACK:67108864")
int n;
while (scanf("%d", &n) != EOF) {
solve(n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 1 << 26;
char gc[SIZE], *pgc = gc;
char pc[SIZE], *ppc = pc;
clock_t clk = clock();
struct flusher {
flusher() { fread(gc, true, SIZE, stdin); }
~flusher() { fwrite(pc, true, ppc - pc, stdout); }
} Flusher;
int _Neg = 0;
template <class T>
void rd(T& x) {
x = _Neg = 0;
while (!isdigit(*pgc)) {
if ((*pgc++) == '-') {
_Neg = 1;
}
}
while (isdigit(*pgc)) {
x = x * 10 + *pgc++ - 48;
}
if (_Neg) {
x = -x;
}
}
int _Stk[233], _Top = 0;
template <class T>
void pt(T x, char c = '\n') {
if (x < 0) {
*ppc++ = '-';
x = -x;
}
do {
_Stk[++_Top] = x % 10;
x /= 10;
} while (x);
while (_Top) {
*ppc++ = _Stk[_Top--] + 48;
}
*ppc++ = c;
}
void pts(const string& str) {
int len = (int)str.size();
for (int i = 0; i <= len - 1; i++) {
*ppc++ = str[i];
}
*ppc++ = '\n';
}
template <class T>
void cmax(T& x, const T& y) {
x = (x > y) ? x : y;
}
template <class T>
void cmin(T& x, const T& y) {
x = (x < y) ? x : y;
}
int n;
const int N = 524288;
int a[N];
int st[N], top;
int main() {
rd(n);
for (int i = 1; i <= n; i++) {
rd(a[i]);
}
int64_t ans = 0;
for (int i = 1; i <= n; i++) {
int t3 = a[i];
while (top >= 2) {
int t2 = st[top--];
int t1 = st[top];
if (t1 >= t2 && t2 <= t3) {
ans += std::min(t1, t3);
} else {
st[++top] = t2;
break;
}
}
st[++top] = t3;
}
std::sort(st + 1, st + top + 1);
for (int i = 1; i <= top - 2; i++) ans += st[i];
pt(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
const int inf = 100000000;
struct elem {
long long val;
int l, r;
};
struct V {
long long val;
int ind;
};
bool compare(V x, V y) {
if (x.val < y.val) return true;
if (x.val == y.val && x.ind < y.ind) return true;
return false;
}
V a[MAXN];
elem L[MAXN];
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> a[i].val;
a[i].ind = i;
L[i].val = a[i].val;
L[i].l = i - 1;
L[i].r = i + 1;
}
int GlobalLeft = 1;
int GlobalRight = N;
sort(a + 1, a + N + 1, compare);
long long ans = 0;
a[N + 1].val = inf;
int pntL = 1, pntR = 1;
int Left = N;
while (pntL <= N && Left > 2) {
pntR = pntL;
while (a[pntR].val == a[pntL].val) pntR++;
int NextL = pntR;
pntR--;
while (pntL <= pntR && a[pntL].ind == GlobalLeft && Left > 2) {
ans += L[GlobalLeft].val;
GlobalLeft = L[GlobalLeft].r;
pntL++;
Left--;
}
while (pntL <= pntR && a[pntR].ind == GlobalRight && Left > 2) {
ans += L[GlobalRight].val;
GlobalRight = L[GlobalRight].l;
pntR--;
Left--;
}
while (pntL <= pntR && Left > 2) {
ans += min(L[L[a[pntL].ind].l].val, L[L[a[pntL].ind].r].val);
L[L[a[pntL].ind].l].r = L[a[pntL].ind].r;
L[L[a[pntL].ind].r].l = L[a[pntL].ind].l;
pntL++;
Left--;
}
pntL = NextL;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long X = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
X = (X << 3) + (X << 1) + ch - '0', ch = getchar();
return X * w;
}
const long long maxn = 1e6 + 10;
long long s[maxn], top;
long long ans;
long long n;
int main() {
n = read();
for (long long i = 1; i <= n; i++) {
long long x = read();
while (top > 1 && s[top - 1] >= s[top] && x >= s[top]) {
ans += min(s[top - 1], x);
top--;
}
s[++top] = x;
}
sort(s + 1, s + 1 + top);
for (long long i = 1; i <= top - 2; i++) {
ans += s[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
struct yo {
int val;
int id;
int next, prev;
};
vector<yo> a0, a;
int n, n0, x;
bool operator<(yo a, yo b) { return a.val < b.val; }
int main() {
cin >> n;
n0 = n;
if (n <= 2) {
cout << 0;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> x;
yo cur;
cur.val = x;
cur.id = i;
cur.next = i + 1;
cur.prev = i - 1;
a0.push_back(cur);
a.push_back(cur);
}
sort(a.begin(), a.end());
long long v = 0, ans = 0;
for (int i = 0; i < a.size() - 2; i++) {
int cur_id = a[i].id;
if (a0[cur_id].prev == -1) {
a0[a0[cur_id].next].prev = -1;
ans += (n - 2) * (a[i].val - v);
v += (a[i].val - v);
} else if (a0[cur_id].next == n0) {
a0[a0[cur_id].prev].next = n0;
ans += (n - 2) * (a[i].val - v);
v += (a[i].val - v);
} else {
ans += min(a0[a0[cur_id].prev].val, a0[a0[cur_id].next].val) - v;
a0[a0[cur_id].next].prev = a0[cur_id].prev;
a0[a0[cur_id].prev].next = a0[cur_id].next;
}
n--;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
bool cmp(int i, int j) { return a[i] < a[j]; }
int main() {
int n;
scanf("%d", &n);
a.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
set<int> s;
for (int i = 0; i < n; i++) s.insert(i);
vector<int> v;
for (int i = 0; i < n; i++) v.push_back(i);
sort(v.begin(), v.end(), cmp);
long long ans = 0;
for (int i = 0; i < n; i++) {
set<int>::iterator it = s.find(v[i]), l, r;
if (it == s.begin()) continue;
l = r = it;
l--;
r++;
if (r == s.end()) continue;
if (a[*it] > min(a[*l], a[*r])) continue;
ans += (long long)min(a[*l], a[*r]);
s.erase(it);
}
int i;
for (i = n - 1; i >= 0; i--)
if (s.find(v[i]) != s.end()) break;
for (i--; i >= 0; i--)
if (s.find(v[i]) != s.end()) break;
for (i--; i >= 0; i--)
if (s.find(v[i]) != s.end()) ans += a[v[i]];
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 500010;
int N, V[NMAX], Prev[NMAX], Next[NMAX];
long long Ans;
queue<int> Q;
bool Added[NMAX];
void Add(int X) {
if (Added[X]) return;
if (V[Prev[X]] >= V[X] && V[X] <= V[Next[X]]) {
Q.push(X);
Added[X] = 1;
}
}
int main() {
scanf("%i", &N);
for (int i = 1; i <= N; ++i) {
scanf("%i", &V[i]);
Prev[i] = i - 1;
Next[i] = i + 1;
}
Next[0] = 1;
Prev[N + 1] = N;
for (int i = 2; i < N; ++i) Add(i);
while (!Q.empty()) {
int X = Q.front();
Q.pop();
Next[Prev[X]] = Next[X];
Prev[Next[X]] = Prev[X];
Ans += min(V[Prev[X]], V[Next[X]]);
Add(Prev[X]);
Add(Next[X]);
}
for (int X = 0; X != N + 1; X = Next[X]) Ans += min(V[Prev[X]], V[Next[X]]);
printf("%I64d", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int N;
scanf(" %d", &N);
vector<int> A(N);
vector<pair<int, int> > ord(N);
for (int i = 0; i < N; i++) {
scanf(" %d", &A[i]);
ord[i].first = A[i];
ord[i].second = i;
}
sort(begin(ord), end(ord));
vector<int> nxt(N + 1, -1), prev(N + 1, -1);
for (int i = 0; i < N; i++) nxt[i] = i + 1, prev[i + 1] = i;
int l = 0, r = N - 1;
long long ans = 0, sub = 0;
for (int i = 0; i < N - 2; i++) {
if (ord[i].second == l || ord[i].second == r) {
ans += 1LL * (ord[i].first - sub) * (N - 2 - i);
sub = ord[i].first;
if (ord[i].second == l)
l = nxt[l];
else
r = prev[r];
continue;
}
int x = prev[ord[i].second], y = nxt[ord[i].second];
ans += min(A[x], A[y]) - sub;
prev[y] = x;
nxt[x] = y;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, -1, 0, 1, -1, 1, 1, -1};
template <class T>
inline bool get(T& n) {
char c, mul = 1;
n = 0;
while (!isdigit(c = getchar_unlocked()) && (c != EOF) && (c != '-'))
;
if (c == EOF) return false;
if (c == '-') {
c = getchar_unlocked();
mul = -1;
}
for (; isdigit(c); c = getchar_unlocked()) n = n * 10 + c - '0';
n *= mul;
return true;
}
inline void get(char& c) {
while (isspace(c = getchar_unlocked()))
;
}
int n;
int v[500050];
int l[500050], r[500050];
set<pair<int, int> > s;
int main() {
get(n);
for (int(i) = 0, _ = (n); (i) < _; ++i) {
get(v[i]);
s.insert(make_pair(v[i], i));
l[i] = i - 1;
r[i] = i + 1;
}
r[n - 1] = -1;
long long ans = 0;
int prev = 0;
while ((int)s.size() > 1) {
int pos = s.begin()->second;
int val = s.begin()->first;
s.erase(s.begin());
int left = l[pos], right = r[pos];
if (left >= 0 && right >= 0) ans += min(v[left], v[right]) - val;
ans += (val - prev) * ((int)s.size() - 1);
if (left >= 0) r[left] = right;
if (right >= 0) l[right] = left;
prev = val;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int a[N];
pair<int, int> p[N];
int pr[N], ne[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
p[i] = make_pair(a[i], i);
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
pr[i] = i - 1;
ne[i] = i + 1;
}
int low = 0, high = n - 1;
long long ans = 0;
for (int i = 0; i < n - 2; i++) {
int j = p[i].second;
if (j == low) {
ans += p[i].first;
low = ne[low];
continue;
}
if (j == high) {
ans += p[i].first;
high = pr[high];
continue;
}
int x = a[pr[j]];
int y = a[ne[j]];
if (x < y) {
ans += x;
} else {
ans += y;
}
pr[ne[j]] = pr[j];
ne[pr[j]] = ne[j];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
t lcm(t a, t b) {
return ((a * b) / __gcd(a, b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long ans = 0;
long long n, temp;
cin >> n;
pair<long long, long long> ip[n], org[n];
long long prev[n], nxt[n], lcorner = 0, rcorner = n - 1;
for (long long i = 0; i < n; i++) {
cin >> ip[i].first;
ip[i].second = i;
prev[i] = i - 1;
nxt[i] = i + 1;
org[i] = ip[i];
}
sort(ip, ip + n);
for (long long i = 0; i < (n - 2); i++) {
pair<long long, long long> cur = ip[i];
if (cur.second == lcorner) {
lcorner = nxt[lcorner];
ans += cur.first;
} else if (cur.second == rcorner) {
rcorner = prev[rcorner];
ans += cur.first;
} else {
nxt[prev[cur.second]] = nxt[cur.second];
prev[nxt[cur.second]] = prev[cur.second];
ans += min(org[prev[cur.second]].first, org[nxt[cur.second]].first);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5;
long long a[N];
signed main() {
long long n;
cin >> n;
long long m = -1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
m++;
cin >> a[m];
while (m >= 2 && a[m - 1] <= min(a[m - 2], a[m])) {
ans = ans + min(a[m - 2], a[m]);
a[m - 1] = a[m];
m--;
}
}
for (int i = 1; i <= m - 1; i++) {
ans = ans + min(a[i - 1], a[i + 1]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500010], b[500010], p = 0;
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
while (p >= 2 && b[p - 2] >= b[p - 1] && a[i] >= b[p - 1])
ans += min(b[p - 2], a[i]), p--;
b[p] = a[i];
p++;
}
sort(b, b + p);
for (int i = 0; i <= p - 3; i++) ans += b[i];
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int A = (int)1e9, N = 528228;
long long o;
set<pair<int, int> > g;
int i, e[2], d[2], t[2][N * 4], j, n, m, a[N];
void modi(int v, int l, int r, int g, int h) {
if (l == r) {
if (g)
t[0][v] = h, t[1][v] = h;
else
t[0][v] = -A, t[1][v] = A;
return;
}
int mid = (l + r) / 2;
if (h <= mid)
modi(v * 2, l, mid, g, h);
else
modi(v * 2 + 1, mid + 1, r, g, h);
t[0][v] = max(t[0][v * 2], t[0][v * 2 + 1]);
t[1][v] = min(t[1][v * 2], t[1][v * 2 + 1]);
}
long long get(int v, int l, int r, int _l, int _r) {
if (l > r || _l > _r) return A;
if (l == _l && r == _r) return t[1][v];
int mid = (l + r) / 2;
return min(get(v * 2, l, mid, _l, min(_r, mid)),
get(v * 2 + 1, mid + 1, r, max(_l, mid + 1), _r));
}
long long _get(int v, int l, int r, int _l, int _r) {
if (l > r || _l > _r) return -A;
if (l == _l && r == _r) return t[0][v];
int mid = (l + r) / 2;
return max(_get(v * 2, l, mid, _l, min(_r, mid)),
_get(v * 2 + 1, mid + 1, r, max(_l, mid + 1), _r));
}
int main() {
cin >> n;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
g.insert(make_pair(a[i], i + 1));
modi(1, 1, n, 1, i + 1);
}
for (i = 0; i < n - 2; i++) {
e[0] = (*g.begin()).first, e[1] = (*g.begin()).second, g.erase(*g.begin());
modi(1, 1, n, 0, e[1]);
d[0] = _get(1, 1, n, 1, e[1]), d[1] = get(1, 1, n, e[1], n);
if (d[0] != -A && d[1] != A)
o += min(a[d[0] - 1], a[d[1] - 1]);
else
o += e[0];
}
cout << o << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &_x_) {
_x_ = 0;
bool f = false;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = !f;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
_x_ = _x_ * 10 + ch - '0';
ch = getchar();
}
if (f) _x_ = -_x_;
}
const double eps = 1e-8;
const int maxn = 1e5 + 7;
const int mod = 1e9 + 7;
const long long inf = 1e15;
long long n, x, ans = 0;
stack<long long> s;
int main() {
read(n);
read(x);
s.push(x);
for (long long i = 2; i <= n; i++) {
read(x);
while (s.size() >= 2) {
long long a = s.top();
s.pop();
long long b = s.top();
if (a <= b && a <= x) {
ans += min(x, b);
} else {
s.push(a);
break;
}
}
s.push(x);
}
long long mi = 0, mx = 0, sum = 0;
while (!s.empty()) {
long long u = s.top();
s.pop();
sum += u;
if (u >= mx) {
mi = mx;
mx = u;
} else if (u > mi)
mi = u;
}
printf("%I64d\n", ans + sum - mi - mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const double EPS = 10e-9;
int const S = 1 << 19;
int n, a[S], leftlink[S], rightlink[S], decrease;
pair<int, int> tree[2 * S];
pair<int, int> Min() { return tree[1]; }
void Init() {
tree[S] = make_pair(INF, 0);
for (int i = 1; i <= (n); ++i) tree[i + S] = make_pair(a[i], i);
for (int i = n + 1; i <= (S - 1); ++i) tree[S + i] = make_pair(INF, i);
for (int i = S - 1; i >= (1); --i)
tree[i] = min(tree[2 * i], tree[2 * i + 1]);
}
void Delete(int p) {
for (tree[p + S] = make_pair(INF, p), p += S, p >>= 1; p; p >>= 1)
tree[p] = min(tree[p * 2], tree[p * 2 + 1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= (n); ++i) {
cin >> a[i];
leftlink[i] = i - 1;
rightlink[i] = i + 1;
}
rightlink[n] = 0;
Init();
pair<int, int> greedy;
long long ans = 0;
while (n) {
if (n <= 2) break;
greedy = Min();
Delete(greedy.second);
if (!leftlink[greedy.second]) {
ans += ((long long)(n - 2)) * (greedy.first - decrease);
leftlink[rightlink[greedy.second]] = 0;
decrease = greedy.first;
--n;
continue;
}
if (!rightlink[greedy.second]) {
ans += ((long long)(n - 2)) * (greedy.first - decrease);
decrease = greedy.first;
rightlink[leftlink[greedy.second]] = 0;
--n;
continue;
}
leftlink[rightlink[greedy.second]] = leftlink[greedy.second];
rightlink[leftlink[greedy.second]] = rightlink[greedy.second];
ans +=
min(a[leftlink[greedy.second]], a[rightlink[greedy.second]]) - decrease;
--n;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, l[N], r[N], tl, tr, a[N], ind[N];
long long ans;
inline void update(int x) {
r[l[x]] = r[x];
l[r[x]] = l[x];
if (x == tl) {
tl = r[x];
} else if (x == tr) {
tr = l[x];
}
}
inline bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
l[i] = i - 1, r[i] = i + 1;
ind[i] = i;
}
sort(ind + 1, ind + n + 1, cmp);
tl = 1, tr = n;
for (int i = 1; i <= n; i++) {
if (tl == tr || r[tl] == tr) {
break;
}
if (ind[i] == tl || ind[i] == tr) {
ans += a[ind[i]];
} else {
ans += min(a[l[ind[i]]], a[r[ind[i]]]);
}
update(ind[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, num, val, pos;
long long int ans = 0;
vector<pair<int, int> > V;
cin >> n;
int arr[n], left[n], right[n];
for (i = 0; i < n; i++) {
cin >> num;
arr[i] = num;
left[i] = i - 1;
right[i] = i + 1;
V.push_back(make_pair(num, i));
}
sort(V.begin(), V.end());
for (i = 0; i < n; i++) {
val = V[i].first;
pos = V[i].second;
if (pos == 0 || pos == n - 1) continue;
ans += min(arr[left[pos]], arr[right[pos]]);
if (arr[right[left[pos]]] < arr[right[pos]]) {
right[left[pos]] = right[pos];
}
if (arr[left[right[pos]]] < arr[left[pos]]) {
left[right[pos]] = left[pos];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[5 * 100010];
int pl[5 * 100010], pr[5 * 100010];
set<pair<int, int> > s;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p[i];
s.insert(make_pair(p[i], i));
pr[i] = i + 1;
pl[i] = i - 1;
}
pr[n - 1] = -1;
long long ans = 0;
int pos, d, prev = 0;
while (s.size() > 1) {
pos = s.begin()->second;
d = s.begin()->first;
s.erase(s.begin());
if (pl[pos] >= 0 && pr[pos] >= 0)
ans += min(p[pl[pos]] - d, p[pr[pos]] - d);
ans += (d - prev) * (s.size() - 1);
if (pr[pos] >= 0) pl[pr[pos]] = pl[pos];
if (pl[pos] >= 0) pr[pl[pos]] = pr[pos];
prev = d;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int a[500000];
long long ans = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[++m];
while (m > 2 && a[m - 1] <= min(a[m - 2], a[m])) {
ans += min(a[m - 2], a[m]);
a[m - 1] = a[m];
m--;
}
}
for (int i = 1; i < m; i++) {
ans += min(a[i - 1], a[i + 1]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
int n;
int a[523456];
list<int>::iterator next(list<int>::iterator it, int i) {
for (int j = 0; j < (i); j++) it++;
return it;
}
list<int>::iterator prev(list<int>::iterator it, int i) {
for (int j = 0; j < (i); j++) it--;
return it;
}
int main() {
scanf("%d", &n);
;
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
;
list<int> ls;
list<int>::iterator it, mx;
ls.push_back(0);
for (int i = 0; i < (n); i++) ls.push_back(a[i]);
ls.push_back(0);
it = next(ls.begin(), 1);
long long sum = 0;
while (*it != 0) {
if (*prev(it, 1) >= *(it) && *next(it, 1) >= *(it)) {
sum += min(*prev(it, 1), *next(it, 1));
it = ls.erase(it);
it--;
} else {
it++;
}
}
mx = ls.begin();
for (it = ls.begin(); it != ls.end(); ++it) {
if (*mx < *it) mx = it;
}
while (ls.size() > 4) {
int me, l = 0, r = 0;
me = min(*prev(mx, 1), *next(mx, 1));
if (prev(mx, 1) != ls.begin()) l = *prev(mx, 2);
if (next(mx, 2) != ls.end()) r = *next(mx, 2);
if (me > l && me > r) {
sum += me;
mx = ls.erase(mx);
if (*prev(mx, 1) > *(mx)) mx--;
} else {
if (l > r) {
sum += l;
ls.erase(prev(mx, 1));
} else {
sum += r;
ls.erase(next(mx, 1));
}
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T BIGMOD(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T DIS(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
T GCD(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T EUCLIDE(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
int Check(int N, int pos) { return (N & (1 << pos)); }
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
double DEG(double x) { return (180.0 * x) / ((2.0 * acos(0.0))); }
void P_ARR(int *ar, int a, int b) {
if (a > b) swap(a, b);
if (a <= b) cout << ar[a];
for (int i = a + 1; i <= b; i++) cout << " " << ar[i];
cout << endl;
}
void P_BIN(int n) {
if (n == 0) return;
P_BIN(n / 2);
printf("%d", n % 2);
}
int nxt[500007], prv[500007];
int ar[500007], aa[500007];
struct data {
int id, mxval;
data() {}
} tree[4 * 500007];
void build(int idx, int s, int e) {
if (s == e) {
tree[idx].mxval = ar[s];
tree[idx].id = s;
return;
}
int mid = (s + e) >> 1, l = (idx << 1), r = l | 1;
build(l, s, mid);
build(r, mid + 1, e);
if (tree[l].mxval < tree[r].mxval)
tree[idx] = tree[l];
else
tree[idx] = tree[r];
}
void update(int idx, int s, int e, int pos, int val) {
if (s == e) {
tree[idx].mxval = val;
return;
}
int mid = (s + e) >> 1, l = (idx << 1), r = l | 1;
if (pos <= mid)
update(l, s, mid, pos, val);
else
update(r, mid + 1, e, pos, val);
if (tree[l].mxval < tree[r].mxval)
tree[idx] = tree[l];
else
tree[idx] = tree[r];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int tc, cas = 1;
int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
z;
cin >> n;
for (i = 1; i <= n; i++) cin >> ar[i];
for (i = 1; i <= n; i++) {
nxt[i] = i + 1;
prv[i] = i - 1;
}
build(1, 1, n);
c = n - 2;
long long int ans = 0;
for (i = 1; i <= c; i++) {
data tt = tree[1];
x = prv[tt.id];
y = nxt[tt.id];
if (min(ar[x], ar[y]) == 0)
ans += ar[tt.id];
else
ans += min(ar[x], ar[y]);
nxt[x] = y;
prv[y] = x;
update(1, 1, n, tt.id, 1000000000);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 1000 + 10;
int a[MAXN], b[MAXN], n[MAXN];
bool mark[MAXN];
set<pair<int, int> > st;
int main() {
int m;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
b[i] = i - 1;
n[i] = i + 1;
st.insert(make_pair(a[i], i));
}
long long ans = 0;
while (!st.empty()) {
int i = st.begin()->second;
st.erase(st.begin());
if (i == 0 || i == m - 1) continue;
if (a[i] <= a[b[i]] && a[i] <= a[n[i]]) {
ans += min(a[b[i]], a[n[i]]);
n[b[i]] = n[i];
b[n[i]] = b[i];
mark[i] = true;
}
}
int mx[3] = {0, 0, 0};
for (int i = 0; i < m; i++) {
if (!mark[i]) {
mx[2] = a[i];
sort(mx, mx + 3, greater<int>());
ans += a[i];
mark[i] = true;
}
}
ans -= (mx[0] + mx[1]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int N = 500005;
int s[N];
int main() {
int n, top = 0;
long long ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
while (top > 1 && s[top - 2] >= s[top - 1] && x >= s[top - 1]) {
ans += min(x, s[top - 2]);
top--;
}
s[top++] = x;
}
sort(s, s + top);
for (int i = 0; i < top - 2; i++) ans += s[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[500005];
cin >> n;
int m = -1;
long long ans = 0;
for (int k = 0; k < n; ++k) {
cin >> a[++m];
while (m >= 2 && a[m - 1] <= min(a[m - 2], a[m])) {
ans += min(a[m - 2], a[m]);
a[m - 1] = a[m];
--m;
}
}
for (int k = 1; k < m; ++k) {
ans += min(a[k - 1], a[k + 1]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cmp(int x, int y) {
if (x > y)
return y;
else
return x;
}
int main(void) {
int n, i = 0;
long long int score = 0;
cin >> n;
int mas[500007];
for (int j = 0; j < n; j++) {
cin >> mas[i++];
while ((i > 2) && (mas[i - 2] <= min(mas[i - 3], mas[i - 1]))) {
score += min(mas[i - 1], mas[i - 3]);
mas[i - 2] = mas[i - 1];
i--;
}
}
sort(mas, mas + i);
for (int j = 0; j < i - 2; j++) score += mas[j];
cout << score;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500005];
bool cmp(int x, int y) { return (a[x] < a[y]); }
int main() {
int n;
scanf("%d", &n);
vector<int> v;
set<int> s;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
s.insert(i);
v.push_back(i);
}
sort(v.begin(), v.end(), cmp);
long long ans = 0;
queue<int> q;
for (int i : v) {
auto it = s.find(i);
if (it != s.begin() && next(it) != s.end())
ans += min(a[*prev(it)], a[*next(it)]);
else {
q.push(i);
if (q.size() > 2) {
ans += a[q.front()];
q.pop();
}
}
s.erase(it);
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using std::min;
const int N = 5e5 + 10;
int n;
long long tot, val[N], pre[N], nxt[N];
inline int calc(int p) {
if (p == 1 or p == n) return 0;
return min(val[pre[p]], val[nxt[p]]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%I64d", &val[i]), pre[i] = i - 1, nxt[i] = i + 1;
for (int i = 2; i <= n - 1; i = nxt[i]) {
while (val[pre[i]] >= val[i] and val[nxt[i]] >= val[i]) {
tot += calc(i);
nxt[pre[i]] = nxt[i];
pre[nxt[i]] = pre[i];
i = pre[i];
}
}
int p = 0, maxval = 0;
for (int i = nxt[1]; i <= n; i = nxt[i])
if (calc(i) > maxval) p = i, maxval = calc(i);
while (p > 1 and p < n) {
tot += calc(p);
nxt[pre[p]] = nxt[p];
pre[nxt[p]] = pre[p];
p = (calc(pre[p]) >= calc(nxt[p])) ? pre[p] : nxt[p];
}
printf("%I64d\n", tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 5e5 + 10;
long long n, a[maxN], nxt[maxN], prv[maxN];
set<pair<long long, long long> > s;
long long res = 0;
int32_t main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
prv[i] = i - 1;
nxt[i] = i + 1;
s.insert(make_pair(a[i], i));
}
long long l = 0, r = n - 1;
long long res = 0;
while (s.size() > 2) {
long long x = s.begin()->first;
long long pos = s.begin()->second;
s.erase(s.begin());
if (pos == l) {
res += x;
l = nxt[l];
} else if (pos == r) {
res += x;
r = prv[r];
} else {
res += min(a[prv[pos]], a[nxt[pos]]);
nxt[prv[pos]] = nxt[pos];
prv[nxt[pos]] = prv[pos];
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, A[555555];
int Next[555555], Prev[555555];
queue<int> q;
long long ans;
bool dip(int i) {
return i != 0 && i != N - 1 && A[Prev[i]] > A[i] && A[Next[i]] >= A[i];
}
int main(int argc, char *argv[]) {
scanf("%d", &N);
for (int i = 0; i < (N); i++) scanf("%d", A + i);
if (N == 1) {
printf("0\n");
return 0;
}
for (int i = 0; i < (N); i++) {
Next[i] = i + 1;
Prev[i] = i - 1;
}
for (int i = 0; i < (N); i++)
if (dip(i)) q.push(i);
while (!q.empty()) {
int n = q.front(), l = Prev[n], r = Next[n];
q.pop();
ans += min(A[l], A[r]);
Prev[r] = l;
Next[l] = r;
if (dip(l)) q.push(l);
if (dip(r)) q.push(r);
}
vector<int> v;
int p = 0;
while (p != N) {
v.push_back(p);
p = Next[p];
}
int l = 0, r = (int)v.size() - 1;
while (l + 1 != r) {
ans += min(A[v[l]], A[v[r]]);
if (min(A[v[l]], A[v[r - 1]]) > min(A[v[l + 1]], A[v[r]]))
r--;
else
l++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500001];
int main() {
scanf("%d", &n);
int i, top = -1;
long long ans = 0;
for (i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
while (top >= 1 && a[top] <= a[top - 1] && a[top] <= x) {
ans += min(a[top - 1], x);
top--;
}
a[++top] = x;
}
sort(a, a + top + 1);
for (i = 0; i < top - 1; i++) ans += a[i];
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, nxt[500005], prv[500005], a[500005];
long long rez;
pair<int, int> v[500005];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
v[i] = make_pair(a[i], i);
nxt[i] = i + 1;
prv[i] = i - 1;
}
sort(v, v + n);
int f = 0, l = n - 1;
for (int i = 0; i < n - 2; ++i) {
int ind = v[i].second;
if (ind == f) {
rez += v[i].first;
f = nxt[f];
continue;
}
if (ind == l) {
rez += v[i].first;
l = prv[l];
continue;
}
if (ind == 0 || ind == n - 1) continue;
rez += min(a[prv[ind]], a[nxt[ind]]);
prv[nxt[ind]] = prv[ind];
nxt[prv[ind]] = nxt[ind];
}
cout << rez;
}
|
#include <bits/stdc++.h>
using namespace std;
int MAXN = 500005;
vector<int> v(MAXN);
vector<int> prv(MAXN);
vector<int> nxt(MAXN);
vector<int> add(500005);
queue<int> q;
void check(int idx) {
if (add[idx]) return;
if (v[prv[idx]] >= v[idx] and v[idx] <= v[nxt[idx]]) {
add[idx] = 1;
q.push(idx);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
nxt[0] = 1;
prv[n + 1] = n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
prv[i] = i - 1;
nxt[i] = i + 1;
}
for (int i = 1; i <= n; i++) check(i);
long long ans = 0;
while (!q.empty()) {
int idx = q.front();
q.pop();
nxt[prv[idx]] = nxt[idx];
prv[nxt[idx]] = prv[idx];
ans += min(v[prv[idx]], v[nxt[idx]]);
check(prv[idx]);
check(nxt[idx]);
}
int idx = nxt[0];
while (idx != n + 1) {
ans += min(v[prv[idx]], v[nxt[idx]]);
idx = nxt[idx];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 5e5 + 42;
int n, arr[nmax];
int l[nmax], r[nmax];
stack<pair<int, int> > help, emp;
pair<int, int> work[nmax];
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first < b.first;
return a.second < b.second;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%i", &arr[i]);
for (int i = 1; i <= n; i++) {
while (help.size() && arr[i] >= help.top().first) help.pop();
if (help.size() == 0)
l[i] = -1;
else
l[i] = help.top().second;
help.push({arr[i], i});
}
help = emp;
for (int i = n; i >= 1; i--) {
while (help.size() && arr[i] >= help.top().first) help.pop();
if (help.size() == 0)
r[i] = n + 1;
else
r[i] = help.top().second;
help.push({arr[i], i});
}
for (int i = 1; i <= n; i++) work[i] = {arr[i], i};
sort(work + 1, work + n + 1, cmp);
long long ans = 0;
int prev = 0;
for (int i = 1; i + 2 <= n; i++) {
int j = i;
while (work[i].first == work[j].first) j++;
j--;
ans = ans + 1LL * (work[i].first - prev) * (n - 1 - i);
prev = work[i].first;
for (int k = i; k <= j; k++)
if (l[work[k].second] != -1 && r[work[k].second] != n + 1) {
if (k == i || l[work[k].second] != l[work[k - 1].second]) {
ans =
ans + min(arr[l[work[k].second]], arr[r[work[k].second]]) - prev;
}
}
i = j;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int in[10000009];
int lef[1000009], ri[1000009];
int fixx[1000009], val[1000009];
vector<pair<int, int> > data;
int main() {
scanf("%d", &n);
if (n == 1) {
scanf("%d", &n);
cout << 0 << endl;
return 0;
}
for (int i = 0; i < (int)n; i++) {
scanf("%d", &in[i]);
;
fixx[i] = 0;
val[i] = 0;
data.push_back(make_pair(in[i], i));
}
for (int i = 0; i < (int)n; i++) {
if (i == 0) {
lef[i] = -1;
ri[i] = i + 1;
} else if (i == n - 1) {
ri[i] = -1;
lef[i] = i - 1;
} else {
lef[i] = i - 1;
ri[i] = i + 1;
}
}
sort(data.begin(), data.end());
long long sum = 0;
for (int i = 0; i < (int)n; i++) {
int x = data[i].first;
int pos = data[i].second;
if (pos == 0 || pos == n - 1) {
fixx[pos] = 1;
val[pos] = 0;
continue;
}
if (fixx[ri[pos]] == 1 || fixx[lef[pos]] == 1) {
fixx[pos] = 1;
val[pos] = min(in[ri[pos]], in[lef[pos]]);
continue;
}
sum += min(in[ri[pos]], in[lef[pos]]);
ri[lef[pos]] = ri[pos];
lef[ri[pos]] = lef[pos];
}
for (int i = 0; i < (int)n; i++) {
if (fixx[i] == 1) {
sum += val[i];
}
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
template <typename T>
inline void read(T &a) {
T w = 1;
a = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = -1;
for (; isdigit(ch); ch = getchar()) a = (a << 3) + (a << 1) + (ch ^ 48);
a *= w;
}
long long a[MAX], b[MAX];
stack<long long> pos;
signed main() {
long long n;
read(n);
long long ans = 0, tot = 0;
for (register long long i = 1; i <= n; ++i) {
read(a[i]);
while (pos.size() >= 2) {
long long x = pos.top();
pos.pop();
long long y = pos.top();
if (y >= x && x <= a[i]) {
ans += min(y, a[i]);
} else {
pos.push(x);
break;
}
}
pos.push(a[i]);
}
while (!pos.empty()) {
b[++tot] = pos.top();
pos.pop();
}
sort(b + 1, b + tot + 1);
for (register long long i = 1; i <= tot - 2; ++i) {
ans += b[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxk = 105;
vector<pair<int, long double> > f, tmp;
long double g[maxn], t[maxn];
long double ans;
int n, k;
int main() {
scanf("%d%d", &n, &k);
f.push_back(make_pair(1, 1.0));
for (int i = 0; i < n; ++i) {
tmp.clear();
for (int k = 0; k < (int)f.size(); ++k) {
int j = f[k].first;
long double p = f[k].second;
if (p < 1e-15) continue;
g[i + 1] += p * (j * 1.0 / (j + 1)) * ((j + 1) / 2.0);
tmp.push_back(make_pair(j, p * (j * 1.0 / (j + 1))));
g[i + 1] += p * (1.0 / (j + 1)) * j;
tmp.push_back(make_pair(j + 1, p * (1.0 / (j + 1))));
}
pair<int, long double> last = tmp[0];
f.clear();
for (int k = 1; k < (int)tmp.size(); ++k)
if (tmp[k].first == last.first)
last.second += tmp[k].second;
else {
f.push_back(last);
last = tmp[k];
}
f.push_back(last);
}
for (int i = 1; i <= n; ++i) g[i] += g[i - 1];
if (k > 1) {
t[0] = log(1);
for (int i = 1; i <= n; ++i) t[0] = t[0] + log(k - 1) - log(k);
for (int i = 1; i <= n; ++i)
t[i] = t[i - 1] + log(n - i + 1) - log(i) - log(k - 1);
for (int i = 1; i <= n; ++i) t[i] = exp(t[i]);
} else {
t[n] = 1;
}
for (int i = 0; i <= n; ++i) ans += g[i] * t[i];
ans *= k;
printf("%.100lf\n", (double)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void enable_comma() {}
string tostring(char c) {
string s = "";
s += c;
return s;
}
string tostring(string s) { return "\"" + s + "\""; }
string tostring(const char *c) { return tostring((string)c); }
string tostring(long long x) {
if (x < 0) return "-" + tostring(-x);
if (x > 9)
return tostring(x / 10) + tostring(char('0' + x % 10));
else
return tostring(char('0' + x));
}
string tostring(int x) { return tostring((long long)x); }
string tostring(unsigned long long x) {
if (x > 9)
return tostring((long long)(x / 10)) + tostring(char('0' + x % 10));
else
return tostring(char('0' + x));
}
string tostring(unsigned x) { return tostring((long long)x); }
string tostring(double x) {
static char res[114];
sprintf(res, "%lf", x);
string s = tostring(res);
return s.substr(1, (int)s.size() - 2);
}
string tostring(long double x) { return tostring((double)x); }
template <class A, class B>
string tostring(pair<A, B> p) {
return "(" + tostring(p.first) + "," + tostring(p.second) + ")";
}
template <class T>
string tostring(T v) {
string res = "";
for (auto p : v) res += (res.size() ? "," : "{") + tostring(p);
return res.size() ? res + "}" : "{}";
}
template <class A>
string tostring(A *a, int L, int R) {
return tostring(vector<A>(a + L, a + R + 1));
};
template <class A>
string tostring(A a, int L, int R) {
return tostring(a.data(), L, R);
}
string tostrings() { return ""; }
template <typename Head, typename... Tail>
string tostrings(Head H, Tail... T) {
return tostring(H) + " " + tostrings(T...);
}
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
template <class T>
void ckmax(T &x, const T y) {
if (x < y) x = y;
}
template <class T>
void ckmin(T &x, const T y) {
if (x > y) x = y;
}
const int N = 100005, M = 1005;
int n, m = M - 5, k;
long double p[M], pp[M];
void solve() {
n = read(), k = read();
p[1] = 1;
long double ans = 0;
for (int i = (1); i <= (n); i++) {
memset(pp, 0, sizeof(pp));
for (int j = (1); j <= (m); j++) {
ans += p[j] * ((1 + j + 1) * (j + 1) / 2 - 1) / (j + 1) / k;
pp[j] += p[j] * j / (j + 1);
pp[j + 1] += p[j] / (j + 1);
}
for (int j = (1); j <= (m); j++) {
p[j] = (p[j] * (k - 1) + pp[j]) / k;
}
}
ans *= k;
printf("%.10lf\n", (double)ans);
}
int main() {
int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
int const MAGIC = 700;
ld f[2][MAGIC];
ld *cur = f[0], *nxt = f[1];
int main() {
int N, K;
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; ++i) {
for (int j = 1; j < MAGIC; ++j) {
nxt[j] = ((j * cur[j] + cur[j + 1] + j) / (j + 1) + j / 2.) / K +
(1 - 1. / K) * cur[j];
}
swap(cur, nxt);
}
printf("%.20lf\n", (double)cur[1] * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
const int MaxLv = 900;
vector<vector<long double> > dp(2, vector<long double>(MaxLv + 1, 0));
for (int(j) = (int)(1); (j) <= (int)(MaxLv); ++(j)) dp[n & 1][j] = 0;
for (int i = n - 1; i >= 0; --i)
for (int(j) = (int)(1); (j) <= (int)(MaxLv); ++(j)) {
long double r = 0;
long double selectedProb = 1.L / k;
r += (1 - selectedProb) * (dp[i + 1 & 1][j] + 0);
long double levelupProb = 1.L / (j + 1);
if (j + 1 <= MaxLv) r += (dp[i + 1 & 1][j + 1] + j * k) / (k * (j + 1));
r += (1 - levelupProb) * (dp[i + 1 & 1][j] + (j + 1) * k / 2.L) / k;
dp[i & 1][j] = r;
}
long double ans = dp[0 & 1][1];
printf("%.15f\n", (double)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
double dp[2][605];
int main() {
scanf("%d %d", &N, &K);
for (int i = N - 1; i >= 0; i--) {
int cur = i & 1;
int nex = cur ^ 1;
for (int j = 1; j <= 600; j++) {
double a = (j + dp[nex][j + 1]) / (j + 1.0);
double b = (j * (1 + j) / 2.0 + j * dp[nex][j]) / (j + 1.0);
dp[cur][j] = (a + b) / K + dp[nex][j] * (1 - 1.0 / K);
}
}
printf("%.10lf\n", K * dp[0][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][600 + 10];
int main(void) {
int N, K, i, j;
double ans = 0.0;
cin >> N >> K;
dp[0][1] = 1.0;
for ((i) = 0; (i) < (int)(N); (i)++) {
int cur = i % 2, next = (i + 1) % 2;
for ((j) = 0; (j) < (int)(600); (j)++)
ans += dp[cur][j] * (j / 2.0 + j / (j + 1.0));
for ((j) = 0; (j) < (int)(600); (j)++)
dp[next][j] = dp[cur][j] * (1.0 - 1.0 / (j + 1.0) / K);
for ((j) = 0; (j) < (int)(600); (j)++)
dp[next][j + 1] += dp[cur][j] / (j + 1.0) / K;
for ((j) = 0; (j) < (int)(600); (j)++)
if (dp[next][j] < 1.0E-100) dp[next][j] = 0.0;
}
printf("%.12f\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 525;
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;
const int N = 100100;
double ans, f[2][N];
int now, n, k;
int main() {
scanf("%d%d", &n, &k);
now = 0;
for (int i = n - 1; i >= 0; i--) {
now ^= 1;
for (int j = 1; j <= 600; j++)
f[now][j] =
f[now ^ 1][j] * (j * 1.0 / (j + 1.0) / k + (k - 1) * 1.0 / k) +
(j * 1.0 / 2 + j * 1.0 / (j + 1)) / k +
1.0 / (j + 1) * f[now ^ 1][j + 1] / k;
}
printf("%.12lf\n", k * f[now][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m = 700;
double f[100010];
void Work() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
f[j] = ((double)j / (j + 1) * f[j] + (double)j / 2 +
(f[j + 1] + j) / (j + 1) + f[j] * (k - 1)) /
k;
printf("%.10lf\n", f[1] * k);
}
void Init() { scanf("%d%d", &n, &k); }
int main() {
Init();
Work();
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. / (j + 1)) +
f[i & 1 ^ 1][j + 1] / (j + 1) + j * (j + 3.) / 2 / (j + 1)) /
k;
printf("%.10f\n", f[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
long long int n, k;
cin >> n >> k;
double log_acc = 1.0;
double log_phi = log(1.0 / (k - 1.0));
double res = 0.0;
double es[100001];
for (int i = 0; i <= n; ++i) es[i] = 0;
for (long long int m = 0; m <= n; ++m) {
if (0 == m) log_acc = n * log(1.0 - 1.0 / k);
double ee = es[1];
res += exp(log_acc) * ee;
log_acc += log_phi + log(n - m) - log(1.0 + m);
if (k == 1 && n == m) res = ee;
for (int l = 0; l <= 700; ++l) {
double p = 1.0 / (l + 1.0);
es[l] = (1.0 - p) * es[l] + l / 2.0 + p * (l + es[l + 1]);
}
}
printf("%.14f\n", res * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
register 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 = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
const int Size = 1005;
const int INF = 0x3f3f3f3f;
double dp[2][Size];
int main() {
int n = read();
int k = read();
int maxl = min(n, 700);
double p = (double)(k - 1) / k;
for (register int i = 1; i <= n; i++) {
register int now = i & 1, pre = now ^ 1;
for (register int j = 1; j <= maxl; j++) {
dp[now][j] = p * dp[pre][j] +
(1 - p) * ((dp[pre][j + 1] + j) / (j + 1) +
(dp[pre][j] + (j + 1) / 2.0) * j / (j + 1));
}
}
printf("%.10lf", dp[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long int mod(long long int a, long long int b,
long long int x = 1000000007) {
long long int res = 1;
a = a % x;
while (b > 0) {
if (b & 1) {
res = (res * a) % x;
}
b = b >> 1;
a = (a * a) % x;
}
return res;
}
inline long long int gcd(long long int a, long long int b) {
long long int r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
inline long long int left(long long int i) { return (i << 1); }
inline long long int right(long long int i) { return ((i << 1) + 1); }
const int maxn = 1e5 + 5;
const int maxx = 1e6 + 5;
const int logn = 316;
double ans[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
long long int m = min(650ll, n);
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
ans[j] =
1.0 / k / (j + 1) * (j * ans[j] + ans[j + 1] + j * (j + 3.0) / 2.0) +
1.0 * (k - 1) / k * ans[j];
}
}
cout << fixed << setprecision(12);
cout << ans[1] * k << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][800];
int n, k;
int main() {
scanf("%d%d", &n, &k);
dp[0][1] = 0;
for (int i = 1; i <= n; ++i) {
int cur = i & 1 ^ 1;
int nxt = cur ^ 1;
for (int t = 1; t + 1 < 800; ++t) {
dp[nxt][t] = dp[cur][t + 1] + t * dp[cur][t] + (t * t + 0.0 + 3 * t) / 2;
dp[nxt][t] /= k * (t + 1);
dp[nxt][t] += (k - 1.0) / k * dp[cur][t];
}
}
printf("%.12lf\n", dp[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double f[2333], p[2333], ans, ess;
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 2333; i >= 0; i--) f[i] = 0, p[i] = 1.0 / i;
f[1] = 1.0;
for (int i = 1; i <= n; i++) {
for (int j = 2000; j >= 0; j--) {
if (fabs(f[j]) <= 1e-23) {
f[j] = 0;
continue;
}
ans += f[j] * j * (0.5 + p[j + 1]);
ess = f[j] * p[j + 1] * p[k];
f[j + 1] += ess;
f[j] -= ess;
}
}
printf("%.12lf\n", (double)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXT = 610;
double f[2][MAXT];
inline int Min(int a, int b) { return a < b ? a : b; }
int main() {
int N;
double K;
scanf("%d %lf", &N, &K);
double p1 = 1.0 / K, p2;
for (int i = N - 1, lim, c = i & 1; i >= 0; --i, c ^= 1) {
lim = Min(600, i + 1);
for (int t = 1; t <= lim; ++t) {
p2 = 1.0 / (double)(t + 1);
f[c][t] =
p1 *
(p2 * (f[c ^ 1][t + 1] + f[c ^ 1][t] * t + t * (t + 1) / 2 + t)) +
(1.0 - p1) * (f[c ^ 1][t]);
}
}
printf("%.10lf", f[0][1] * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:128000000")
const int maxl = 750;
int n, k;
double f[maxl];
double prec[maxl];
double nprec[maxl];
double me[maxl];
int main() {
cin >> n >> k;
double nk = 1.0 / (double)k;
for (int i = 1; i < maxl; ++i) {
me[i] = (double)(i + 1) / 2.0;
prec[i] = (1.0 / (double)(i + 1));
nprec[i] = (1.0 - prec[i]);
prec[i] *= nk;
nprec[i] *= nk;
}
double res = 0.0;
memset(f, 0, sizeof f);
f[1] = 1.0;
for (int i = 0; i < n; ++i) {
double cf, dif;
for (int j = min(maxl - 2, i + 1); j; --j) {
cf = f[j];
dif = prec[j] * cf;
f[j + 1] += dif;
res += nprec[j] * cf * me[j];
res += dif * (double)j;
f[j] = cf - dif;
}
}
cout.precision(15);
cout << fixed << res * (double)k << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
srand(time(0));
cout << fixed << setprecision(9);
cerr << fixed << setprecision(9);
static long double dp[1 << 20];
static long double inv[1 << 20];
int n, k;
cin >> n >> k;
for (int i = 1; i <= 1e6; ++i) inv[i] = (long double)(1.0) / i;
long double ans = 0;
dp[1] = 1;
for (int rep = 1; rep <= n; ++rep) {
for (int j = min(rep, 1000); j; --j) {
const long double prob = inv[k] * dp[j] * inv[j + 1];
ans += dp[j] * j * (0.5 + inv[j + 1]);
dp[j] -= prob;
dp[j + 1] += prob;
}
}
cout << ans << '\n';
cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-8;
const long double PI = acos(-1.);
const long long MOD = 1000000007;
long double dp[2][1555];
long double inv[1555];
int main() {
int i, j, k, T;
for (i = 1; i <= 1501; i++) inv[i] = ((long double)1) / i;
int n = 100000, m = 1;
while (~scanf("%d%d", &n, &m)) {
memset(dp, 0, sizeof dp);
long double ans = 0;
dp[0][1] = 1;
for (i = 0; i < n; i++) {
int x = i % 2, y = (i + 1) % 2;
int MX = 600;
for (j = 1; j <= MX; j++) ans += dp[x][j] * j * (inv[j + 1] + inv[2]);
for (j = 1; j <= MX; j++)
dp[y][j] = dp[x][j] * (1. - inv[j + 1] * inv[m]);
for (j = 1; j <= MX; j++) dp[y][j + 1] += dp[x][j] * inv[j + 1] * inv[m];
}
printf("%.16f\n", (double)ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 500;
const int maxk = 700;
long double dp[maxk];
int main() {
int n, k;
cin >> n >> k;
long double ans = 0;
dp[1] = 1;
for (int i = 0; i < n; i++) {
long double dj;
long double dk = k;
for (int j = maxk - 1; j >= 1; j--) {
dj = j;
ans += dp[j] * dj * (dj + 3) / (2 * (dj + 1));
dp[j] = (dp[j] * ((dk - 1) + dj / (dj + 1)) + dp[j - 1] / dj) / dk;
}
}
cout << fixed << setprecision(12) << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double f[2][810];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i * i <= n; ++i) f[0][i] = 0;
int st = min(max(800.0, sqrt(n)), 1.0 * n);
int c = 0;
for (int i = 1; i <= n; ++i) {
c ^= 1;
for (int j = 1; j <= st; ++j) {
f[c][j] = 1.0 * (k - 1) / k * f[c ^ 1][j] +
1.0 * j / k / (j + 1) * f[c ^ 1][j] +
1.0 / k / (j + 1) * (f[c ^ 1][j + 1] + (1.0 + j) * j / 2.0 + j);
if (f[c][j] <= 1e-100) f[c][j] = 0;
}
}
printf("%.10lf", f[c][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
int n, k;
long double _ldp[708], _dp[708], *ldp = _ldp, *dp = _dp;
int main() {
scanf("%d%d", &n, &k);
memset(dp, 0, sizeof(_dp));
memset(ldp, 0, sizeof(_dp));
for (int T = (1); T <= (n); ++T) {
for (int L = (1); L <= (700); ++L)
dp[L] = ((L * (ldp[L] + (L + 1) / 2.0) + ldp[L + 1] + L) / (L + 1) +
ldp[L] * (k - 1)) /
k;
std::swap(dp, ldp);
}
printf("%.20lf\n", (double)(ldp[1] * k));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double DP[705], Pre[705];
int n, k;
double ans = 0;
int main() {
cin >> n >> k;
int sq = 700;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sq; j++)
DP[j] = 1.0 / k / (j + 1) * (Pre[j] * j + Pre[j + 1] + j * (j + 3) / 2) +
1.0 * (k - 1) / k * Pre[j];
for (int j = 1; j <= sq; j++) Pre[j] = DP[j];
}
printf("%0.12f", DP[1] * k);
}
|
#include <bits/stdc++.h>
int n, k;
long double _ldp[708], _dp[708], *ldp = _ldp, *dp = _dp, E[100086];
int main() {
scanf("%d%d", &n, &k);
E[0] = 0;
memset(dp, 0, sizeof(_dp));
memset(ldp, 0, sizeof(_dp));
for (int T = (1); T <= (n); ++T) {
for (int L = (1); L <= (700); ++L)
dp[L] = ((L * (ldp[L] + (L + 1) / 2.0) + ldp[L + 1] + L) / (L + 1) +
ldp[L] * (k - 1)) /
k;
E[T] = dp[1];
std::swap(dp, ldp);
}
printf("%.20lf\n", (double)(E[n] * k));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double D[703][2];
int n, k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
int p = (i % 2);
int r = !p;
for (int j = 1; j <= 700; ++j)
D[j][p] =
1.0 / (k * (j + 1)) * (j * D[j][r] + D[j + 1][r] + j * (j + 3) / 2) +
D[j][r] * (k - 1) / k;
}
cout << fixed << setprecision(11) << D[1][n % 2] * k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int maxk = 800;
long double a[maxk];
long double b[maxk];
int main(int argc, char *argv[]) {
int n, k;
cin >> n >> k;
a[1] = k;
long double ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j < maxk; j++) {
b[j] = a[j] * (1.0 - 1.0 / (k * (j + 1))) + a[j - 1] / (k * j);
}
long double sum = 0;
for (int j = 1; j < maxk; j++) {
ans += (a[j] / k) * ((long double)j * (j + 1) / 2 / (j + 1) +
(long double)j / (j + 1));
a[j] = b[j];
if (a[j] < 1e-50) a[j] = 0;
}
}
cerr << a[50] << endl;
cout.precision(11);
cout << fixed << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxj = 1000;
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>
inline int rd() {
char c = getchar();
while (!isdigit(c)) c = getchar();
int x = c - '0';
while (isdigit(c = getchar())) x = x * 10 + c - '0';
return x;
}
long double f[2][1001];
int n, k;
void input() { n = rd(), k = rd(); }
void solve() {
int bound = std::min(n, 800);
int cur = 1, pre = 0;
for (int i = 1, _ = n; i <= _; i++) {
cur ^= 1, pre ^= 1;
for (int j = 1, _ = bound; j <= _; j++)
f[cur][j] =
(k - 1) * f[pre][j] / k +
(j * f[pre][j] + f[pre][j + 1] + j * (j + 3) / 2) / (k * (j + 1));
}
printf("%.12lf\n", (double)f[cur][1] * k);
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1000000 + 5;
int N, K;
double dp[2][1005];
void compute_dp() {
bool h = true;
for (int n = 1; n <= N; ++n, h ^= 1) {
memset(dp[h], 0, sizeof dp[h]);
for (int t = min(1000, N - n + 1); t; --t)
dp[h][t] = (dp[h ^ 1][t + 1] + t * dp[h ^ 1][t] + t * (t + 3.0) / 2.0) /
(K * (t + 1.0)) +
((K - 1.0) * dp[h ^ 1][t]) / K;
}
}
int main() {
cin >> N >> K;
compute_dp();
cout << fixed << setprecision(10) << K * dp[N & 1][1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
int n, k;
double dp[1024], ndp[1024];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
for (int t = 1; t < 1000; ++t)
ndp[t] = dp[t] * (k - 1) / k +
(t * dp[t] + dp[t + 1] + t * (t + 3) / 2) / k / (t + 1);
for (int t = 1; t < 1000; ++t) dp[t] = ndp[t];
}
printf("%.15f\n", k * dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100000;
const int MAXZ = 1000;
int nwin, ntype;
double E[2][MAXN + 1];
void run() {
scanf("%d%d", &nwin, &ntype);
int at = 0;
E[at][0] = 0;
for (int i = (1); i <= (nwin); ++i)
E[at][i] = 1.0 * (MAXZ * (MAXZ + 1) / 2 + MAXZ) / ntype / (MAXZ + 1) +
E[at][i - 1];
for (int z = MAXZ - 1; z >= 1; --z) {
at = 1 - at;
E[at][0] = 0;
for (int i = (1); i <= (nwin); ++i)
E[at][i] = 1.0 * (z * (z + 1) / 2 + z + E[1 - at][i - 1] - E[at][i - 1]) /
ntype / (z + 1) +
E[at][i - 1];
}
printf("%.9lf\n", ntype * E[at][nwin]);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double f[100005];
int main() {
int n, k, ub;
scanf("%d%d", &n, &k);
ub = min(n, 80000000 / n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= ub; j++)
f[j] = (k - 1) * 1.0 / k * f[j] +
1.0 / k / (j + 1) * (j * f[j] + j * 0.5 * (j + 1) + f[j + 1] + j);
printf("%.12lf\n", f[1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][605];
int Max = 600;
int main() {
int n, k;
while (cin >> n >> k) {
memset(dp, sizeof(dp), 0);
dp[0][1] = 1;
int cur = 0;
int next = 1;
double ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < Max; ++j)
ans += dp[cur][j] * (j / 2.0 + j / (j + 1.0));
for (int j = 1; j < Max; ++j)
dp[next][j] = dp[cur][j] * (1 - (1.0 / (j + 1) / k));
for (int j = 2; j < Max; ++j) dp[next][j] += dp[cur][j - 1] / j / k;
for (int j = 0; j < Max; ++j)
if (dp[next][j] < 1e-100) dp[next][j] = 0;
cur = next;
next = next ^ 1;
}
printf("%.9lf\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5, MAXT = 710;
int N, K;
double d[2][MAXT];
int main() {
scanf("%d%d", &N, &K);
for (int i = 0; i < MAXT; i++) {
d[0][i] = 0;
}
int c = 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < MAXT - 1; j++) {
d[c][j] = 1.0 / (K * (j + 1)) *
(j * d[c ^ 1][j] + d[c ^ 1][j + 1] + j * (j + 3) / 2.0) +
(K - 1.0) / K * d[c ^ 1][j];
}
c ^= 1;
}
printf("%.10lf\n", d[c ^ 1][1] * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double f[2][1010];
int main() {
scanf("%d%d", &n, &k);
int now = 1;
int t = min(n, 1000);
for (int i = 1; i <= n; i++, now ^= 1) {
for (int j = t; j; j--) {
f[now][j] = ((f[now ^ 1][j + 1] + j) / (j + 1.0) +
j * (f[now ^ 1][j] + (j + 1.0) / 2.0) / (j + 1.0)) /
(k * 1.0) +
(k - 1) * f[now ^ 1][j] / (k * 1.0);
}
}
printf("%.10lf", f[now ^ 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, sum[1010];
long double f[1010][2], g[1010][2], ans, p[1010], P;
int main() {
scanf("%d%d", &n, &m);
g[1][0] = 1.;
double P = 1. / (long double)m;
for (int i = 1; i <= 810; i++)
p[i] = 1. / (long double)i, sum[i] = (1 + i) * i / 2;
for (int i = 1; i <= n; i++) {
x ^= 1;
for (int j = 1; j <= min(800, i + 1); j++) {
f[j][x] = f[j][x ^ 1] * (m - 1) * P;
g[j][x] = g[j][x ^ 1] * (m - 1) * P;
g[j][x] += (g[j - 1][x ^ 1] * p[j] + g[j][x ^ 1] * j * p[j + 1]) * P;
f[j][x] += ((f[j - 1][x ^ 1] + (j - 1) * g[j - 1][x ^ 1]) * p[j] +
(j * f[j][x ^ 1] + sum[j] * g[j][x ^ 1]) * p[j + 1]) *
P;
}
}
for (int i = 1; i <= min(800, n + 1); i++) ans += f[i][x] * m;
printf("%.12lf\n", (double)ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
register 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 = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
const int Size = 1005;
const int INF = 0x3f3f3f3f;
double dp[2][Size];
int main() {
int n = read();
int k = read();
int maxl = min(n, 700);
double p = (double)(k - 1) / k;
for (register int i = 1; i <= n; i++) {
register int now = i & 1, pre = now ^ 1;
for (register int j = 1; j <= maxl; j++) {
dp[now][j] = p * dp[pre][j] +
(1 - p) * ((dp[pre][j + 1] + j) / (j + 1) +
(dp[pre][j] + (j + 1) / 2.0) * j / (j + 1));
}
}
printf("%.10lf", dp[n & 1][1] * k - (9e-10));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, A;
double f[2][710];
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
int main() {
read(n);
read(K);
A = 0;
for (int i = 1; i <= n; i++) {
A ^= 1;
for (int j = 1; j <= min(n, 600); j++)
f[A][j] = f[A ^ 1][j] * j / K / (j + 1) + f[A ^ 1][j] * (K - 1) / K +
f[A ^ 1][j + 1] / K / (j + 1) +
(double)j * (j + 3) / 2 / (j + 1);
}
printf("%.9lf\n", f[A][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int n, k;
double E[2][600];
int main() {
scanf("%d%d", &n, &k);
for (int i = n - 1; i >= 0; i--)
for (int j = 1; j < 600; j++)
E[i % 2][j] =
E[(i + 1) % 2][j] * (j * 1.0 / (j + 1) / k + (k - 1) * 1.0 / k) +
(j * 1.0 / 2 + j * 1.0 / (j + 1)) / k +
1.0 / (j + 1) * E[(i + 1) % 2][j + 1] / k;
printf("%.9lf\n", k * E[0][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double k;
double f[2][1005];
int main() {
cin >> n >> k;
for (int i = 1, sta = 1; i <= n; ++i, sta ^= 1)
for (int j = 1; j <= 1000; ++j) {
f[sta][j] =
(1 / k) * (((f[sta ^ 1][j] + (long double)(j + 1) / 2) *
((long double)j / (j + 1))) +
(f[sta ^ 1][j + 1] + j) * ((long double)1 / (j + 1))) +
((k - 1) / k) * f[sta ^ 1][j];
}
printf("%.10lf\n", f[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-10);
double E[2][600];
double res[600];
int main() {
memset(E, 0, sizeof(E));
int n, k;
scanf("%d %d", &n, &k);
int now = 1;
for (int j = 1; j < 600; j++) res[j] = (j * 1. / 2 + j * 1. / (j + 1)) / k;
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) +
res[j] + 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;
int n;
double k;
double dp[2][700 + 5];
int main() {
scanf("%d %lf", &n, &k);
int now = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 700; j++) {
dp[now][j] = dp[now ^ 1][j] * (k - 1.0) / double(k) +
((dp[now ^ 1][j + 1] + j) / (j + 1.0) +
(dp[now ^ 1][j] + (j + 1) / 2.0) * j / (j + 1.0)) /
double(k);
}
now ^= 1;
}
printf("%.10lf\n", k * dp[now ^ 1][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
long n, k;
double prob[10][1000 + 100];
double ans;
double ev[10][1000 + 100];
double pup, prem;
double rev[100000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
double gz = 1.0 / k;
for (int i = 1; i <= 1000 + 1000; i++) rev[i] = 1.0 / i;
prob[0][1] = 1;
ev[0][1] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 1000; j++) prob[1 - i % 2][j] = ev[1 - i % 2][j] = 0;
long ths, nxt;
ths = i % 2;
nxt = 1 - ths;
for (int j = 1; j <= 1000; j++) {
if (prob[ths][j] < 1e-50) continue;
ev[ths][j] /= prob[ths][j];
pup = gz * rev[j + 1];
prob[nxt][j + 1] += prob[ths][j] * pup;
ev[nxt][j + 1] += (ev[ths][j] + j) * prob[ths][j] * pup;
prem = gz * (1.0 - rev[j + 1]);
prob[nxt][j] += prob[ths][j] * prem;
ev[nxt][j] += (ev[ths][j] + (j + 1) * 0.5) * prob[ths][j] * prem;
prob[nxt][j] += prob[ths][j] * (1.0 - gz);
ev[nxt][j] += ev[ths][j] * (1.0 - gz) * prob[ths][j];
}
}
for (int i = 1; i <= 1000; i++) ans += ev[n % 2][i] * k;
cout.precision(12);
cout << fixed << ans << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[700 + 5], b[700 + 5];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = n - 1; i >= 0; i--) {
memset(b, 0, sizeof(b));
for (int j = 1; j <= 700; j++)
b[j] = a[j] * (m - 1) / m + (a[j] * j / (j + 1) + 1.0 * j / 2 +
a[j + 1] / (j + 1) + 1.0 * j / (j + 1)) /
m;
memcpy(a, b, sizeof(b));
}
printf("%.10lf\n", a[1] * m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double f[2][605], k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 600; j++)
f[i & 1][j] = (1.0 / k) *
((j * f[i & 1 ^ 1][j] + f[i & 1 ^ 1][j + 1] + j) / (j + 1) +
(k - 1) * f[i & 1 ^ 1][j] + j / 2.0);
printf("%.9f\n", k * f[n & 1][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 605;
const double eps = 1e-50;
double dp[2][N];
int main() {
dp[0][1] = 1.0;
double ans = 0.0, k;
int n;
scanf("%d%lf", &n, &k);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < N; ++j)
ans += dp[(i - 1) & 1][j] * (j / 2.0 + j / (j + 1.0));
for (int j = N - 1; j >= 0; --j) {
dp[i & 1][j] = dp[(i - 1) & 1][j] * (1.0 - 1.0 / (j + 1) / k);
dp[i & 1][j + 1] += dp[(i - 1) & 1][j] / k / (j + 1.0);
if (dp[i & 1][j] < eps) dp[i & 1][j] = 0.0;
}
}
printf("%.10lf", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double f[2][850];
int main() {
scanf("%d%d", &n, &k);
int t = min(n, 800);
int now = 1;
for (int i = 1; i <= n; i++, now ^= 1)
for (int j = t; j; j--)
f[now][j] = ((f[now ^ 1][j + 1] + j) / (j + 1.0) +
j * (f[now ^ 1][j] + (j + 1.0) / 2.0) / (j + 1.0)) /
(k * 1.0) +
(k - 1) * f[now ^ 1][j] / (k * 1.0);
printf("%.10lf", k * f[now ^ 1][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
double f[1002][2];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int can = 1;
for (int j = 1; j <= n; j++) {
can = 1 - can;
for (int i = 1; i <= 1000; i++) {
f[i][can] =
((1.0 * i + f[i][1 - can] * i + (f[i + 1][1 - can])) / (i + 1) +
0.5 * i) /
k +
f[i][1 - can] * (k - 1) / k;
}
}
printf("%.12lf\n", f[1][can] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100000 + 10;
int n, k;
double F[2][800];
void solve() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int p = i % 2, c = p ^ 1;
memset(F[p], 0, sizeof(F[p]));
for (int j = 1; j <= 800; j++) {
F[p][j] =
1.0 / (double)k *
((double)j / (double)(j + 1) * (F[c][j] + (double)(j + 1) / 2.0) +
1.0 / (double)(j + 1) * (F[c][j + 1] + (double)j)) +
(double)(k - 1) / k * F[c][j];
}
}
double ans = F[n % 2][1] * (double)k;
printf("%.9f\n", ans);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAGIC = 2000;
long double f[MAGIC + 10], inv[MAGIC + 10];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int j = 1; j < MAGIC; j++) {
f[j] = 0.0;
inv[j] = 1.0 / j;
}
f[1] = 1.0;
long double q = 1.0 / k;
long double ans = 0.0;
for (int it = 0; it < n; it++) {
for (int j = MAGIC - 1; j >= 1; j--) {
if (f[j] < 1e-100) {
f[j] = 0.0;
continue;
}
ans += f[j] * j * (0.5 + inv[j + 1]);
long double u = f[j] * q * inv[j + 1];
f[j + 1] += u;
f[j] -= u;
}
}
printf("%.17lf\n", (double)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return 8 * sizeof(int) - __builtin_clz(first);
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class TaskD {
public:
void solve(istream& cin, ostream& cout) {
int N, K;
cin >> N >> K;
int s = 1000;
vector<double> D(N + 1, 0), E = D;
double KK = 1.0 / K;
E[0] = 1;
double ans = 0;
for (int l = 1; l < s; ++l) {
double z = ((K - 1) + l / double(l + 1));
double second = 1.0 / l;
for (int t = 0; t <= min(N, l - 2); ++t) E[t] = 0;
for (int t = 1; t <= N; ++t) {
if (t <= l - 2) {
continue;
}
E[t] = KK * (E[t - 1] * z + D[t - 1] * second);
if (E[t] < 1e-300) E[t] = 0;
}
double tt = 0;
for (int t = 0; t < N; ++t) tt += E[t];
ans += tt * l * (0.5 + 1.0 / (l + 1));
swap(E, D);
E[0] = 0;
}
cout << fixed << setprecision(10) << ans << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
TaskD solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
const int inf = 1 << 29;
const int mod = 1000000007;
const double eps = 1e-8;
const int li = 700;
int n, m;
double ch;
double dp[2][li + 2];
int main() {
scanf("%d%d", &n, &m);
ch = 1.0 / m;
int pt = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= li; j++) {
double f = j / (j + 1.0);
dp[pt][j] = (f * ch + 1 - ch) * dp[pt ^ 1][j] +
ch * (1 - f) * dp[pt ^ 1][j + 1] + f * ch + j / 2.0 / m;
}
pt ^= 1;
}
printf("%.10f\n", m * dp[pt ^ 1][1]);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.