text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = (1 << 20) + 5;
int const MAXM = 1e6 + 6;
int a[MAXN];
long long sum[MAXN][2];
int n, m;
void DFS(int l, int r, int dep) {
if (dep == 0) {
sum[0][1] = sum[0][0] = 0;
return;
}
int mid = (l + r) >> 1;
DFS(l, mid, dep - 1);
DFS(mid + 1, r, dep - 1);
for (int i = l; i <= mid; i++) {
sum[dep][0] += lower_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1);
}
for (int i = mid + 1; i <= r; i++)
sum[dep][1] += lower_bound(a + l, a + mid + 1, a[i]) - (a + l);
sort(a + l, a + r + 1);
return;
}
int main() {
scanf("%d", &n);
int all = (1 << n);
for (int i = 1; i <= all; i++) scanf("%d", &a[i]);
DFS(1, all, n);
scanf("%d", &m);
int q;
for (int i = 0; i < m; i++) {
scanf("%d", &q);
for (int j = q; j >= 0; j--) swap(sum[j][0], sum[j][1]);
long long ans = 0;
for (int j = n; j >= 0; j--) ans += (long long)sum[j][0];
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 20 + 5, MaxL = (1 << 20) + 5;
int n, arr[MaxL], A[MaxL], len, q;
long long sum[MaxN], same[MaxN];
void init() {
scanf("%d", &n);
len = 1 << n;
for (int i = 1; i <= len; ++i) scanf("%d", &arr[i]);
}
void calc(int d, int st, int en) {
if (d == 0) return;
int mid = (st + en) >> 1;
calc(d - 1, st, mid);
calc(d - 1, mid + 1, en);
int p = st, q = mid + 1, mn, l1, l2;
while (p <= mid && q <= en) {
if (arr[p] < arr[q])
mn = arr[p];
else
mn = arr[q];
l1 = l2 = 0;
while (p <= mid && arr[p] == mn) ++p, ++l1;
while (q <= en && arr[q] == mn) ++q, ++l2;
same[d] += (long long)l1 * (long long)l2;
}
p = st;
q = mid + 1;
for (int i = st; i <= en; ++i)
if (p <= mid && (q > en || arr[p] <= arr[q]))
A[i] = arr[p++];
else {
A[i] = arr[q++];
sum[d] += (long long)(mid - p + 1);
}
for (int i = st; i <= en; ++i) arr[i] = A[i];
}
void build() { calc(n, 1, len); }
void solve() {
scanf("%d", &q);
int v;
long long ans;
while (q--) {
scanf("%d", &v);
for (int i = v, p = 1 << (v - 1); i > 0; --i, p >>= 1)
sum[i] = ((long long)p * (long long)p) * ((long long)(1 << (n - i))) -
sum[i] - same[i];
ans = 0;
for (int i = 1; i <= n; ++i) ans += sum[i];
printf("%I64d\n", ans);
}
}
int main() {
init();
build();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1024 * 1024 * 2;
const int MOD = 1000000007;
int n;
long long a[N];
long long sum[25][2];
void build(int l, int r, int dep) {
if (dep == 0) {
sum[dep][0] = sum[dep][1] = 0;
return;
}
int m = (l + r) >> 1;
build(l, m, dep - 1);
build(m + 1, r, dep - 1);
for (int i = l; i <= m; i++) {
sum[dep][1] += a + r + 1 - upper_bound(a + m + 1, a + r + 1, a[i]);
sum[dep][0] += lower_bound(a + m + 1, a + r + 1, a[i]) - (a + m + 1);
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &n);
int cnt = (1 << n);
for (int i = 1; i <= cnt; i++) {
scanf("%I64d", a + i);
}
build(1, cnt, n);
int q;
scanf("%d", &q);
while (q--) {
int k;
scanf("%d", &k);
for (int i = k; i >= 0; i--) {
swap(sum[i][0], sum[i][1]);
}
long long ans = 0;
for (int i = n; i >= 0; i--) {
ans += sum[i][0];
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
long long kk0[20], kk1[20];
int aa[1 << 20];
void solve(int l, int r, int h) {
static int bb[1 << 20];
int m, i, j, k;
if (h >= 0) {
m = (l + r) / 2;
solve(l, m, h - 1);
solve(m, r, h - 1);
for (i = l, j = m; i < m; i++) {
while (j < r && aa[i] > aa[j]) j++;
kk0[h] += j - m;
}
for (i = l, j = m; j < r; j++) {
while (i < m && aa[i] < aa[j]) i++;
kk1[h] += i - l;
}
for (i = l, j = m, k = 0; i < m || j < r;)
if (i < m && (j == r || aa[i] < aa[j]))
bb[k++] = aa[i++];
else
bb[k++] = aa[j++];
for (i = l; i < r; i++) aa[i] = bb[i - l];
}
}
int main() {
long long cnt;
int n, m, i, b;
scanf("%d", &n);
for (i = 0; i < 1 << n; i++) scanf("%d", &aa[i]);
solve(0, 1 << n, n - 1);
scanf("%d", &m);
b = 0;
while (m-- > 0) {
scanf("%d", &i);
b ^= (1 << i) - 1;
cnt = 0;
for (i = 0; i < n; i++) cnt += (b & 1 << i) == 0 ? kk0[i] : kk1[i];
printf("%lld\n", cnt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int h, n, m, inv[25][2] = {0}, q;
vector<int> a;
vector<int> b;
vector<int> c;
vector<int> tp;
void srt1(int l, int r, int ht) {
int i = l, j = ((l + r) / 2) + 1, mid = (l + r) / 2, ct = 0,
sz = (r - l + 1) / 2;
while (i <= mid && j <= r) {
if (b[i] <= b[j]) {
tp[ct] = b[i];
ct++;
i++;
} else {
tp[ct] = b[j];
ct++;
j++;
inv[ht][0] += mid - i + 1;
}
}
while (i <= mid) {
tp[ct] = b[i];
ct++;
i++;
}
while (j <= r) {
tp[ct] = b[j];
ct++;
j++;
inv[ht][0] += mid - i + 1;
}
for (i = l; i <= r; i++) {
b[i] = tp[i - l];
}
}
void srt2(int l, int r, int ht) {
int i = l, j = ((l + r) / 2) + 1, mid = (l + r) / 2, ct = 0,
sz = (r - l + 1) / 2;
while (i <= mid && j <= r) {
if (c[i] >= c[j]) {
tp[ct] = c[i];
ct++;
i++;
} else {
tp[ct] = c[j];
ct++;
j++;
inv[ht][1] += mid - i + 1;
}
}
while (i <= mid) {
tp[ct] = c[i];
ct++;
i++;
}
while (j <= r) {
tp[ct] = c[j];
ct++;
j++;
inv[ht][1] += mid - i + 1;
}
for (i = l; i <= r; i++) {
c[i] = tp[i - l];
}
}
void ms(int l, int r, int ht) {
if (l == r) {
return;
}
ms(l, (l + r) / 2, ht - 1);
ms(((l + r) / 2) + 1, r, ht - 1);
srt1(l, r, ht);
srt2(l, r, ht);
}
int main(int argc, const char* argv[]) {
cin >> h;
n = 1 << h;
a.resize(n);
b.resize(n);
c.resize(n);
tp.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
c[i] = a[i];
}
ms(0, n - 1, h);
cin >> m;
for (int i = 0; i < m; i++) {
long long int ans = 0;
scanf(" %I64d", &q);
for (int j = q; j >= 0; j--) {
swap(inv[j][0], inv[j][1]);
}
for (int j = 0; j <= h; j++) {
ans += inv[j][0];
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int v[1 << N], n, q;
long long dp[1 << N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= (1 << n); ++i) scanf("%d", &v[i]);
dp[0] = dp[1] = 0;
for (int i = 1; i <= n; ++i) {
long long sum = 0, sumtp = 0;
for (int j = 1; j <= (1 << n); j += (1 << i)) {
int a = j, b = j + (1 << (i - 1)), c = j + (1 << i) - 1;
for (int ta = b - 1, tb = c; tb >= b;) {
if (ta >= a && v[ta] > v[tb])
ta--;
else
sumtp += (b - 1) - ta, tb--;
}
sort(v + a, v + c + 1);
int p = c + 1;
for (int k = c - 1; k >= a; --k) {
if (v[k] < v[k + 1]) p = k + 1;
sum += c - p + 1;
}
}
for (int j = 0; j < (1 << (i)); ++j) {
dp[j | (1 << i)] = sum - sumtp - dp[j];
dp[j] += sumtp;
}
}
scanf("%d", &q);
int cnt = 0;
while (q--) {
int x;
scanf("%d", &x);
cnt ^= (1 << x);
printf("%I64d\n", dp[cnt]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int size;
cin >> size;
vector<int> numbers(1 << size);
for (int _n((1 << size)), i(0); i < _n; i++) cin >> numbers[i];
vector<long long> more(size, 0), less(size, 0);
vector<int> state(size, 0);
vector<int> next(1 << size);
for (int i = 0; i < size; i++) {
for (int j = 0; j < (1 << size); j += 1 << (i + 1)) {
int middle = j + (1 << i);
int end = middle + (1 << i);
int at1 = j;
int at2 = middle;
int at = j;
while (at1 < middle && at2 < end) {
if (numbers[at1] <= numbers[at2]) {
next[at++] = numbers[at1++];
more[i] += at2 - middle;
} else {
next[at++] = numbers[at2++];
}
}
while (at1 < middle) {
next[at++] = numbers[at1++];
more[i] += 1 << i;
}
while (at2 < end) {
next[at++] = numbers[at2++];
}
at1 = j;
at2 = middle;
at = j;
while (at1 < middle && at2 < end) {
if (numbers[at1] < numbers[at2]) {
next[at++] = numbers[at1++];
} else {
next[at++] = numbers[at2++];
less[i] += at1 - j;
}
}
while (at1 < middle) {
next[at++] = numbers[at1++];
}
while (at2 < end) {
next[at++] = numbers[at2++];
less[i] += 1 << i;
}
}
next.swap(numbers);
}
long long answer = accumulate(more.begin(), more.end(), 0ll);
int queryCount;
cin >> queryCount;
for (int i = 0; i < queryCount; i++) {
int query;
cin >> query;
for (int j = 0; j < query; j++) {
if (state[j]) {
answer += more[j];
answer -= less[j];
} else {
answer += less[j];
answer -= more[j];
}
state[j] ^= true;
}
cout << answer << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[(1 << 20) + 4], n;
long long store[21][2], INV = 0;
long long query(int l, int r, int no) {
return (A + r + 1 - upper_bound(A + l, A + r + 1, no));
}
void gen(int de, int l, int r) {
if (!de) return;
gen(de - 1, l, (l + r) / 2);
gen(de - 1, (l + r) / 2 + 1, r);
int a = l, b = (l + r) / 2, c = r;
for (int i = a; i <= b; i++) {
long long nos = query(b + 1, c, A[i]);
store[de][1] += nos;
}
for (int i = b + 1; i <= c; i++) {
long long nos = query(a, b, A[i]);
store[de][0] += nos;
}
sort(A + l, A + r + 1);
}
int main() {
cin >> n;
for (int i = 1; i <= (1 << n); i++) cin >> A[i];
gen(n, 1, (1 << n));
for (int de = n; de > 0; de--) INV += store[de][0];
int m;
cin >> m;
while (m--) {
int de;
cin >> de;
while (de != 0) {
INV -= store[de][0];
INV += store[de][1];
swap(store[de][0], store[de][1]);
de--;
}
printf("%lld\n", INV);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20) + 10;
int a[maxn], b[maxn], c[maxn];
long long inv[2][25];
int n, d, m;
long long ans;
void f(int *a, int l, int r, int dep, int mark) {
if (r - l == 0) return;
int mid = (r + l) / 2;
f(a, l, mid, dep + 1, mark);
f(a, mid + 1, r, dep + 1, mark);
int x = l, y = mid + 1, i = l;
while (i <= r) {
if (y > r || (x <= mid && a[x] <= a[y]))
c[i++] = a[x++];
else {
c[i++] = a[y++];
inv[mark][dep] += (mid - x + 1);
}
}
for (int j = l; j <= r; j++) a[j] = c[j];
return;
}
int main() {
scanf("%d", &d);
n = (1 << d);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long k = 1;
for (int j = n; j > 0; j--) b[j] = a[k++];
f(a, 1, n, 0, 0);
f(b, 1, n, 0, 1);
scanf("%d", &m);
while (m--) {
ans = 0;
int x;
scanf("%d", &x);
for (int i = d - x; i <= d; i++) swap(inv[0][i], inv[1][i]);
for (int i = 0; i <= d; i++) ans += inv[0][i];
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long A[1048576];
long long B[30];
long long C[30];
long P[30];
void f(long n, long o) {
if (n > 1) {
f(n - 1, o);
f(n - 1, o + P[n - 1]);
}
sort(A + o, A + o + P[n - 1]);
sort(A + o + P[n - 1], A + o + P[n]);
long i = o;
long j = o + P[n - 1];
while (i != o + P[n - 1] && j != o + P[n]) {
if (A[i] < A[j]) {
B[n] += o + P[n] - j;
i += 1;
} else {
j += 1;
}
}
i = o;
j = o + P[n - 1];
while (i != o + P[n - 1] && j != o + P[n]) {
if (A[i] <= A[j]) {
i += 1;
} else {
C[n] += o + P[n - 1] - i;
j += 1;
}
}
}
int main(int, char**) {
ios_base::sync_with_stdio(false);
P[0] = 1;
for (long i = (1); i <= (29); ++i) P[i] = 2 * P[i - 1];
long n;
cin >> n;
for (long i = 0; i < (P[n]); ++i) cin >> A[i];
for (long i = 0; i < (29); ++i) B[i] = 0;
for (long i = 0; i < (29); ++i) C[i] = 0;
f(n, 0);
bitset<30> BS;
long m;
cin >> m;
for (long i = 0; i < (m); ++i) {
long q;
cin >> q;
while (q != 0) {
BS[q] = not BS[q];
q -= 1;
}
long long r = 0;
for (long j = 0; j < (n + 1); ++j) {
r += BS[j] ? B[j] : C[j];
}
cout << r << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005, MOD = 7 + 1e9;
const int Max_N = 1 << 21;
int x[Max_N];
long long bigger[32], smaller[32];
void Divide(int L, int R, int dep) {
if (L == R) return;
int M = (L + R) >> 1;
Divide(L, M, dep + 1);
Divide(M + 1, R, dep + 1);
for (int i = M + 1; i <= R; i++) {
bigger[dep] +=
(long long)((x + M + 1) - upper_bound(x + L, x + M + 1, x[i]));
smaller[dep] += (long long)(lower_bound(x + L, x + M + 1, x[i]) - (x + L));
}
sort(x + L, x + R + 1);
}
int main() {
int n, i, m, q;
long long ans;
while (cin >> n) {
for (i = 1; i <= (1 << n); i++) scanf("%d", &x[i]);
memset(bigger, 0, sizeof(bigger));
memset(smaller, 0, sizeof(smaller));
Divide(1, 1 << n, 1);
ans = 0;
for (i = 1; i <= n; i++) ans += bigger[i];
cin >> m;
while (m--) {
scanf("%d", &q);
for (i = n - q + 1; i <= n; i++) {
ans -= bigger[i];
ans += smaller[i];
swap(bigger[i], smaller[i]);
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 5;
int a[N];
int n;
vector<vector<long long> > t(4 * N, vector<long long>(2, 0));
vector<vector<long long> > sum(21, vector<long long>(2, 0));
vector<int> ty(21, 0);
long long res;
void build(int root, int l, int r) {
if (r - l == 1) {
t[root][0] = t[root][1] = 0;
return;
}
long long mid = (l + r) / 2;
build(2 * root, l, mid);
build(2 * root + 1, mid, r);
vector<int> tm(r - l);
long long i = l;
long long j1 = mid, j2 = mid;
int cnt = 0;
long long res[2] = {0, 0};
while (i != mid) {
while (!(j1 == r or a[j1] >= a[i])) {
tm[cnt++] = a[j1++];
}
while (!(j2 == r or a[j2] > a[i])) {
j2++;
}
res[0] += j1 - mid;
res[1] += r - j2;
tm[cnt++] = a[i++];
}
while (j1 != r) {
tm[cnt++] = a[j1++];
}
t[root][0] = res[0];
t[root][1] = res[1];
for (int i = 0; i < cnt; ++i) {
a[i + l] = tm[i];
}
}
void suma(int num) {
int h = n;
for (int nn = 1; nn <= num; nn *= 2) {
for (int i = nn; i < 2 * nn; i++) {
sum[h][0] += t[i][0];
sum[h][1] += t[i][1];
}
res += sum[h--][0];
}
}
void update(int h) {
for (int i = 0; i <= h; i++) {
res -= sum[i][ty[i]];
ty[i] = 1 - ty[i];
res += sum[i][ty[i]];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
int num = 1 << n;
for (int i = 0; i < num; ++i) {
cin >> a[i];
}
build(1, 0, num);
suma(num);
int q;
cin >> q;
int h;
while (q--) {
cin >> h;
update(h);
cout << res << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const int mod = 1000000007;
const long long Lbig = 2e18;
inline long long getnum() {
register long long r = 0;
register bool ng = 0;
register char c;
c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') ng = 1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = getchar();
if (ng) r = -r;
return r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline void putsp() { putchar(' '); }
inline void putendl() { putchar('\n'); }
inline char mygetchar() {
register char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
int n, nxt[500111], pre[500111], a[500111];
bool f[500111];
void del(int x) {
f[x] = 1;
nxt[pre[x]] = nxt[x];
pre[nxt[x]] = pre[x];
}
long long check(int x) {
if (!f[x] && x != 1 && x != n && a[pre[x]] >= a[x] && a[x] <= a[nxt[x]]) {
del(x);
return min(a[nxt[x]], a[pre[x]]) + check(pre[x]) + check(nxt[x]);
}
return 0;
}
int main() {
n = getnum();
for (int i = 1; i <= n; i++) a[i] = getnum(), nxt[i] = i + 1, pre[i] = i - 1;
long long ans = 0;
for (int i = 2; i < n; i++) {
if (!f[i]) ans += check(i);
}
int p = 1;
while (p >= 1 && p <= n) ans += min(a[pre[p]], a[nxt[p]]), p = nxt[p];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, L[500010], R[500010], a[500010];
pair<int, int> b[500010];
void erase(int x) {
int u = L[x], v = R[x];
L[v] = u, R[u] = v;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = make_pair(a[i], i);
sort(b + 1, b + n + 1);
for (int i = 0; i <= n; i++) R[i] = i + 1, L[i + 1] = i;
long long ans = 0;
for (int i = 1; i < n - 1; i++) {
int x = b[i].second;
if (L[x] == 0 || R[x] == n + 1)
ans += a[x];
else
ans += min(a[L[x]], a[R[x]]);
erase(x);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long s = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return s;
}
long long a[500005], n, cnt;
long long ans;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[++cnt] = read();
while (cnt > 2 && a[cnt - 2] >= a[cnt - 1] && a[cnt] >= a[cnt - 1]) {
ans += min(a[cnt - 2], a[cnt]);
a[cnt - 1] = a[cnt];
a[cnt] = 0;
cnt--;
}
}
sort(a + 1, a + cnt + 1);
for (int i = 1; i <= cnt - 2; i++) ans += a[i];
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
if (n == 1) {
cout << 0 << '\n';
return 0;
}
stack<int> st;
long long ans = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
int a, b;
while (1) {
if (st.size())
a = st.top(), st.pop();
else
break;
if (st.size())
b = st.top();
else {
st.push(a);
break;
}
if (a <= b && a <= x) {
ans += min(b, x);
} else {
st.push(a);
break;
}
}
st.push(x);
}
int mx = -1, scmx = -1;
while (st.size()) {
int x = st.top();
st.pop();
ans += x;
scmx = max(scmx, x);
if (scmx > mx) swap(scmx, mx);
}
cout << ans - mx - scmx << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500002];
int b[500002];
int ssl[500002];
int ssp[500002];
int z[500002];
int n;
long long int p = 0;
long long int s = 0;
void qs(int a[], int b[], int l, int r) {
int i = l, j = r, tmp, p = a[(l + r) / 2];
while (i <= j) {
while (a[i] < p) i++;
while (a[j] > p) j--;
if (i <= j) {
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
tmp = b[i];
b[i] = b[j];
b[j] = tmp;
i++;
j--;
}
}
if (l < j) qs(a, b, l, j);
if (i < r) qs(a, b, i, r);
}
void del(int i) {
s = s + min(z[ssl[i]], z[ssp[i]]) - p;
ssl[ssp[i]] = ssl[i];
ssp[ssl[i]] = ssp[i];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%i", &a[i]);
ssl[i] = i - 1;
ssp[i] = i + 1;
b[i] = i;
z[i] = a[i];
}
qs(a, b, 1, n);
z[0] = 0;
z[n + 1] = 0;
int i = 1;
int l = 1, r = n;
for (int j = 1; j <= n - 2; j++) {
if ((b[i] != l) && (b[i] != r)) {
del(b[i]);
}
if (b[i] == l) {
s = s + (n - 1 - j) * (z[l] - p);
p = z[l];
l = ssp[l];
}
if (b[i] == r) {
s = s + (n - 1 - j) * (z[r] - p);
p = z[r];
r = ssl[r];
}
i++;
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
int arr[MAXN];
int n, x, t;
long long ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (t <= 1)
arr[++t] = x;
else {
while (t > 1 && arr[t] <= arr[t - 1] && arr[t] <= x) {
ans += min(arr[t - 1], x);
t--;
}
arr[++t] = x;
}
}
sort(arr + 1, arr + t + 1, greater<int>());
for (int i = 3; i <= t; i++) ans += arr[i];
return cout << ans << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int n, a[maxn], q[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long ans = 0;
q[1] = a[1];
int p = 1;
for (int i = 2; i <= n; i++) {
while (q[p] <= a[i] && q[p] <= q[p - 1] && p > 1) {
ans = ans + min(q[p - 1], a[i]);
p--;
}
q[++p] = a[i];
}
sort(q, q + p + 1);
for (int i = 1; i < p - 1; i++) ans = ans + q[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
int n, a[MAXN] = {}, pr[MAXN], ne[MAXN];
bool add[MAXN] = {};
long long res = 0;
queue<int> q;
void check(int i) {
if (add[i]) return;
if (a[pr[i]] >= a[i] && a[i] <= a[ne[i]]) {
add[i] = 1;
q.push(i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pr[i] = i - 1;
ne[i] = i + 1;
}
ne[0] = 1;
pr[n + 1] = n;
for (int i = 1; i <= n; i++) check(i);
while (q.size()) {
int c = q.front();
q.pop();
ne[pr[c]] = ne[c];
pr[ne[c]] = pr[c];
res += min(a[pr[c]], a[ne[c]]);
check(pr[c]);
check(ne[c]);
}
int c = ne[0];
while (c != n + 1) {
res += min(a[pr[c]], a[ne[c]]);
c = ne[c];
}
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 500100;
const int MXPW = 30;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const int mod = 1000000007;
int a[MXN];
int main() {
int n;
scanf("%d", &n);
long long mx = 0, mx2 = 0;
long long s = 0, mns = 0;
for (int i = (0); i < (n); i++) {
scanf("%d", &a[i]);
if (i) mns += min(a[i], a[i - 1]);
s += a[i];
if (a[i] > mx)
mx2 = mx, mx = a[i];
else if (a[i] > mx2)
mx2 = a[i];
}
cout << 2 * s - 2 * mx - mx2 - mns;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const N = 5e5 + 5;
long long n, ans;
long long a[N];
long long l[N];
long long r[N];
set<pair<long long, long long>> s;
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 0; i <= n + 1; i++) {
l[i] = i - 1;
r[i] = i + 1;
}
for (long long i = 1; i <= n; i++) {
s.insert({a[i], i});
}
long long tmp = 0;
while (s.size() > 2) {
long long cnt = (*s.begin()).first - tmp;
long long i = (*s.begin()).second;
s.erase(s.begin());
if (l[i] == 0) {
tmp += cnt;
ans += cnt * (s.size() - 1);
} else {
if (r[i] == n + 1) {
tmp += cnt;
ans += cnt * (s.size() - 1);
} else {
ans += min(a[l[i]] - tmp, a[r[i]] - tmp);
}
}
l[r[i]] = l[i];
r[l[i]] = r[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[500009];
int main() {
long long ans = 0;
int n, i, j, t = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &j);
while (t > 1 && s[t] <= s[t - 1] && s[t] <= j) ans += min(s[--t], j);
s[++t] = j;
}
for (i = 1; i <= t; ++i) ans += s[i];
for (i = 1; i <= t; ++i)
if (s[i] >= s[i - 1] && s[i] >= s[i + 1])
return printf("%lld", ans - s[i] - max(s[i - 1], s[i + 1])), 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Pos;
long long a[500005], Out;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%I64d", &x);
while (Pos > 1 && a[Pos - 1] >= a[Pos] && a[Pos] <= x) {
Out += min(x, a[Pos - 1]);
Pos--;
}
a[++Pos] = x;
}
sort(a + 1, a + 1 + Pos);
for (int i = 1; i <= Pos - 2; i++) Out += a[i];
printf("%I64d", Out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500005], L[500005], R[500005];
struct Node {
int id, vlu;
Node() { id = 0, vlu = INT_MAX; }
Node(int _i, int _v) : id(_i), vlu(_v) {}
};
Node _merge(Node p, Node q) { return p.vlu < q.vlu ? p : q; }
Node tree[500005 * 4];
void build(int node, int lo, int hi) {
if (lo == hi) {
tree[node] = Node(lo, a[lo]);
return;
}
int mid = lo + (hi - lo) / 2, lft = node << 1, rgt = lft | 1;
build(lft, lo, mid);
build(rgt, mid + 1, hi);
tree[node] = _merge(tree[lft], tree[rgt]);
}
void update(int node, int lo, int hi, int pos) {
if (lo == hi) {
tree[node].vlu = INT_MAX;
return;
}
int mid = lo + (hi - lo) / 2, lft = node << 1, rgt = lft | 1;
if (pos <= mid)
update(lft, lo, mid, pos);
else
update(rgt, mid + 1, hi, pos);
tree[node] = _merge(tree[lft], tree[rgt]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i), L[i] = i - 1, R[i] = i + 1;
build(1, 1, n);
long long res = 0;
int lft = 1, rgt = n;
for (int i = 1; i <= n - 2; i++) {
int id = tree[1].id;
if (id == rgt) {
res += tree[1].vlu, rgt = L[rgt];
} else if (id == lft) {
res += tree[1].vlu, lft = R[lft];
} else {
res += min(a[L[id]], a[R[id]]);
R[L[id]] = R[id];
L[R[id]] = L[id];
}
update(1, 1, n, id);
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> A[500005];
int B[500005], pre[500005], nxt[500005];
int main(int argc, char const *argv[]) {
int n;
scanf("%d", &n);
for (int(i) = (int)(1); (i) <= (int)(n); ++(i))
scanf("%d", &A[i].first), A[i].second = i, B[i] = A[i].first,
pre[i] = i - 1, nxt[i] = i + 1;
sort(A + 1, A + n + 1);
long long res = 0;
for (int(i) = (int)(1); (i) <= (int)(n - 2); ++(i)) {
int pos = A[i].second;
if (!pre[pos] || nxt[pos] == n + 1)
res += A[i].first;
else
res += min(B[pre[pos]], B[nxt[pos]]);
nxt[pre[pos]] = nxt[pos], pre[nxt[pos]] = pre[pos];
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500005], n, id[500005], prv[500005], nxt[500005];
long long ans;
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
id[i] = i;
prv[i] = i - 1;
nxt[i] = i + 1;
}
sort(id + 1, id + n + 1, cmp);
for (i = 1; i <= n - 2; i++) {
if (prv[id[i]] == 0 || nxt[id[i]] == n + 1)
ans += a[id[i]];
else
ans += min(a[prv[id[i]]], a[nxt[id[i]]]);
nxt[prv[id[i]]] = nxt[id[i]];
prv[nxt[id[i]]] = prv[id[i]];
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
int v[510009], pr[510009], ne[510009];
bool vis[510009];
queue<int> q;
void tap(int x) {
if (vis[x]) return;
if (v[pr[x]] >= v[x] && v[x] <= v[ne[x]]) vis[x] = 1, q.push(x);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
pr[i] = i - 1;
ne[i] = i + 1;
}
ne[0] = 1, pr[n + 1] = n;
for (int i = 1; i <= n; i++) tap(i);
while (q.size()) {
int k = q.front();
q.pop();
ne[pr[k]] = ne[k];
pr[ne[k]] = pr[k];
ans += min(v[pr[k]], v[ne[k]]);
tap(pr[k]);
tap(ne[k]);
}
int k = ne[0];
while (k != n + 1) {
ans += min(v[pr[k]], v[ne[k]]), k = ne[k];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[555555], n;
int main() {
cin >> n;
int sz = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[sz++];
while (sz >= 3 && a[sz - 1] >= a[sz - 2] && a[sz - 2] <= a[sz - 3]) {
ans += min(a[sz - 1], a[sz - 3]);
a[sz - 2] = a[sz - 1];
sz--;
}
}
sort(a, a + sz);
for (int i = 0; i < sz - 2; i++) ans += a[i];
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.0000001;
const double PI = acos(-1);
const long long INFLL = 0x7FFFFFFFFFFFFFFF;
const int INF = 0x7FFFFFFF;
template <typename T>
inline void next(T &num) {
char c;
num = 0;
do {
c = getchar_unlocked();
} while (c != EOF && c == ' ' && c == '\n' && c == '\t');
int sign = (c == '-' ? -1 : 1);
if (c != '-') num += (c - '0');
while ((c = getchar_unlocked()) != EOF && c != '\n' && c != '\t' &&
c != ' ') {
num *= 10;
num += (c - '0');
}
num *= sign;
}
inline string getstr() {
string str;
char k;
while ((k = getchar_unlocked()) == ' ' || k == '\n') {
k = getchar_unlocked();
if (k == ' ' || k == '\n')
continue;
else
break;
}
str.push_back(k);
while ((k = getchar_unlocked()) != EOF && k != '\n' && k != '\t' &&
k != '\v' && k != '\0' && k != ' ')
str.push_back(k);
return str;
}
int pr[500005], nx[500005], a[500005];
pair<int, int> x[500005];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = int(1), _b = int(n); i <= _b; i++) {
cin >> a[i];
x[i] = make_pair(a[i], i);
pr[i] = i - 1;
nx[i] = i + 1;
}
sort(x + 1, x + n + 1);
int l = 1, r = n;
long long ans = 0;
for (int i = int(1), _b = int(n - 2); i <= _b; i++) {
int cur = x[i].second;
if (cur == l) {
l = nx[l];
ans += x[i].first;
continue;
}
if (cur == r) {
r = pr[r];
ans += x[i].first;
continue;
}
ans += min(a[nx[cur]], a[pr[cur]]);
pr[nx[cur]] = pr[cur];
nx[pr[cur]] = nx[cur];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[600000];
int main() {
int n;
scanf("%d", &n);
long long tmp;
int pos = 0;
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &tmp);
while (pos > 1 && a[pos] <= tmp && a[pos] <= a[pos - 1]) {
sum += min(a[pos - 1], tmp);
pos--;
}
a[++pos] = tmp;
}
sort(a + 1, a + 1 + pos);
for (int i = 1; i <= pos - 2; i++) sum += a[i];
printf("%I64d", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int N = 500010;
int a[N], l[N], r[N];
pair<int, int> p[N];
int main() {
int n;
long long ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[i].first = a[i];
p[i].second = i;
l[i] = i - 1;
r[i] = i + 1;
}
sort(p + 1, p + n + 1);
int pl = 1, pr = n;
for (int i = 1; i <= n - 2; i++) {
int pos = p[i].second;
if (pos == pl) {
ans += a[pos];
pl = r[pl];
} else if (pos == pr) {
ans += a[pos];
pr = l[pr];
} else {
ans += (long long)min(a[l[pos]], a[r[pos]]);
l[r[pos]] = l[pos], r[l[pos]] = r[pos];
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tr[3 * 500000 + 2], mx[3 * 500000 + 2];
long long a[500000 + 2], b[500000 + 2];
long long nxt[500000 + 2], pre[500000 + 2];
void build(long long pos, long long st, long long ed) {
if (st == ed) {
tr[pos] = st;
mx[pos] = a[st];
return;
}
long long mid = st + ((ed - st) >> 1);
build(2 * pos, st, mid);
build(2 * pos + 1, mid + 1, ed);
if (mx[2 * pos] >= mx[2 * pos + 1])
tr[pos] = tr[2 * pos + 1];
else
tr[pos] = tr[2 * pos];
mx[pos] = min(mx[2 * pos], mx[2 * pos + 1]);
}
void update(long long pos, long long st, long long ed, long long x,
long long val) {
if (st == ed && st == x) {
mx[pos] = val;
return;
}
long long mid = st + ((ed - st) >> 1);
if (x <= mid)
update(2 * pos, st, mid, x, val);
else
update(2 * pos + 1, mid + 1, ed, x, val);
if (mx[2 * pos] >= mx[2 * pos + 1])
tr[pos] = tr[2 * pos + 1];
else
tr[pos] = tr[2 * pos];
mx[pos] = min(mx[2 * pos], mx[2 * pos + 1]);
}
int main() {
long long i, j, k, p, q, m, n, sm = 0;
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pre[i] = i - 1;
nxt[i] = i + 1;
}
a[0] = a[n + 1] = 100000000LL;
build(1, 1, n);
long long st = 1, ed = n;
for (long long l = 1; l <= n - 2; l++) {
k = tr[1];
if (k == st || k == ed) {
sm += a[k];
if (k == st)
st = nxt[k];
else
ed = pre[k];
} else {
sm += min(a[pre[k]], a[nxt[k]]);
}
update(1, 1, n, k, 100000000LL);
p = pre[k], q = nxt[k];
nxt[p] = q;
pre[q] = p;
}
printf("%lld\n", sm);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500100];
int pr[500100];
int ne[500100];
pair<int, int> p[500100];
int cmp_pii(const pair<int, int>& x, const pair<int, int>& y) {
if (x.first == y.first) return x.second < y.second;
return x.first < y.first;
}
int main() {
int n;
scanf("%d", &n);
for (int i = int(0); i < int(n); i++) {
pr[i] = i - 1;
ne[i] = i + 1;
scanf("%d", &a[i]);
p[i] = pair<int, int>(a[i], i);
}
sort(p, p + n, cmp_pii);
int lo = 0, hi = n - 1;
long long ans = 0;
for (int i = int(0); i < int(n - 2); i++) {
int j = p[i].second;
if (j == lo) {
ans += a[j];
lo = ne[lo];
continue;
}
if (j == hi) {
ans += a[j];
hi = pr[hi];
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];
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using std::min;
int stk[500001], top, n;
long long ans = 0;
int main() {
scanf("%d", &n);
for (int i = 1, tem; i <= n; i++) {
scanf("%d", &tem);
while (top > 1 && stk[top] <= min(stk[top - 1], tem))
ans += min(stk[top - 1], tem), --top;
stk[++top] = tem;
}
for (int i = 2; i < top; i++) ans += min(stk[i - 1], stk[i + 1]);
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[500005];
int lt[500005];
int rt[500005];
vector<long long> b;
int main() {
int i, n, j;
long long ans = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
if (i == 0) {
lt[i] = -1;
rt[i] = i + 1;
} else {
lt[i] = i - 1;
rt[i] = i + 1;
}
if (i > 1) {
j = i;
while (j > 0 && lt[j] != -1 && lt[lt[j]] != -1 && a[lt[j]] <= a[j] &&
a[lt[j]] <= a[lt[lt[j]]]) {
ans += min(a[j], a[lt[lt[j]]]);
rt[lt[lt[j]]] = rt[lt[j]];
lt[j] = lt[lt[j]];
}
}
}
for (i = 0; i < n; i = rt[i]) {
b.push_back(a[i]);
}
sort(b.begin(), b.end());
for (i = 0; i < int(b.size()) - 2; i++) ans += b[i];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500001;
int n, a[N], pre[N], aft[N];
set<pair<int, int>> s;
long long ans;
int main() {
std::ios::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
s.insert(make_pair(a[i], i));
pre[i] = i - 1;
aft[i] = i + 1;
}
aft[n - 1] = -1;
ans = 0;
int sz = s.size();
for (set<pair<int, int>>::iterator it = s.begin(); it != s.end(); it++) {
if (sz <= 2) break;
if (pre[it->second] != -1 && aft[it->second] != -1) {
ans += (long long)min(a[pre[it->second]], a[aft[it->second]]);
pre[aft[it->second]] = pre[it->second];
aft[pre[it->second]] = aft[it->second];
} else {
ans += it->first;
if (pre[it->second] != -1) aft[pre[it->second]] = aft[it->second];
if (aft[it->second] != -1) pre[aft[it->second]] = pre[it->second];
}
sz--;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 5e5 + 5;
int a[N], st[N], top, n;
long long ans;
int main() {
read(n);
for (register int i = 1; i <= n; i++) read(a[i]);
for (register int i = 1; i <= n; i++) {
while (top >= 2 && st[top - 1] >= st[top] && st[top] <= a[i]) {
ans += min(st[top - 1], a[i]);
--top;
}
st[++top] = a[i];
}
sort(st + 1, st + top + 1);
for (register int i = 1; i < top - 1; i++) ans += st[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
int n;
int a[500005];
int pr[500005];
int ne[500005];
int add[500005];
queue<int> q;
void chk(int x) {
if (add[x]) return;
if (a[x] <= a[pr[x]] and a[x] <= a[ne[x]]) {
add[x] = 1;
q.push(x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n + 1; ++i) {
cin >> a[i];
pr[i] = i - 1;
ne[i] = i + 1;
}
ne[0] = 1;
pr[n + 1] = n;
for (int i = 1; i < n + 1; ++i) chk(i);
long long ans = 0;
while (!q.empty()) {
int i = q.front();
q.pop();
ans += min(a[pr[i]], a[ne[i]]);
ne[pr[i]] = ne[i];
pr[ne[i]] = pr[i];
chk(pr[i]);
chk(ne[i]);
}
int c = ne[0];
while (c != n + 1) {
ans += min(a[pr[c]], a[ne[c]]);
c = ne[c];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(time(0));
const long long mod = 1e9 + 7;
const int mn = 5e5 + 10;
int a[mn];
long long ans = 0;
int pl[mn], pr[mn];
int fl(int x) { return x == pl[x] ? x : (pl[x] = fl(pl[x])); }
int fr(int x) { return x == pr[x] ? x : (pr[x] = fr(pr[x])); }
int o[mn];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
iota(pl, pl + mn, 0);
iota(pr, pr + mn, 0);
iota(o, o + mn, 0);
sort(o, o + n, [](int x, int y) { return a[x] < a[y]; });
int lo = 0, hi = n - 1;
for (int i = 0; i < n - 2; i++) {
if (o[i] == lo)
ans += a[lo], lo = fr(lo + 1);
else if (o[i] == hi)
ans += a[hi], hi = fl(hi - 1);
else {
ans += min(a[fr(o[i] + 1)], a[fl(o[i] - 1)]);
pr[o[i]] = fr(o[i] + 1);
pl[o[i]] = fl(o[i] - 1);
}
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 5e5;
int stiva[NMAX + 2];
int top = 0;
int N;
long long ans = 0;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> N;
for (int i = 1; i <= N; ++i) {
int x;
cin >> x;
while (top > 1 && stiva[top - 1] >= stiva[top] && stiva[top] <= x) {
ans += min(stiva[top - 1], x);
--top;
}
stiva[++top] = x;
}
sort(stiva + 1, stiva + top + 1);
for (int i = 1; i <= top - 2; ++i) ans += stiva[i];
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[1000000];
int main() {
ios::sync_with_stdio(false);
int N;
scanf("%d", &N);
if (N <= 2) {
cout << 0 << '\n';
return 0;
}
long long sum = 0;
int m1 = 0, m2 = 0;
for (int i = 0; i < (int)(N); ++i) {
scanf("%d", &b[i]);
sum += b[i];
if (b[i] > m1)
m2 = m1, m1 = b[i];
else if (b[i] > m2)
m2 = b[i];
}
long long ans = 2 * sum - 2 * m1 - m2;
for (int i = 0; i < (int)(N - 1); ++i) {
ans -= min(b[i], b[i + 1]);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500005], id[500005], lef[500005], rig[500005];
long long ans;
int cmp(int i, int j) { return a[i] < a[j]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
id[i] = i;
lef[i] = i - 1;
rig[i] = i + 1;
}
rig[0] = 1;
lef[n + 1] = n;
sort(id + 1, id + n + 1, cmp);
ans = 0;
for (int i = 1; i <= n; i++) {
ans += max(0, min(a[lef[id[i]]] - a[id[i]], a[rig[id[i]]] - a[id[i]]));
rig[lef[id[i]]] = rig[id[i]];
lef[rig[id[i]]] = lef[id[i]];
if (i < n - 1) {
ans += a[id[i]];
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
scanf("%d", &head);
RI(tail...);
}
long long lasai(int n, int a[]) {
static int vis[500010], vid, per[500010];
long long ans = 0;
for (int i = 0; i < int(n - 2); i++) per[i] = i + 2;
do {
vid++;
long long now = 0;
for (int ii = 0; ii < int(n - 2); ii++) {
int i = per[ii];
vis[i] = vid;
int l = i, r = i;
while (vis[l] == vid) l--;
while (vis[r] == vid) r++;
now += min(a[l], a[r]);
}
ans = max(ans, now);
} while (next_permutation(per, per + n - 2));
return ans;
}
int n, a[500010], pre[500010], nxt[500010];
bool vis[500010];
int main() {
RI(n);
for (int i = (1); i <= int(n); i++) RI(a[i]);
for (int i = (0); i <= int(n); i++) nxt[i] = i + 1;
for (int i = (1); i <= int(n + 1); i++) pre[i] = i - 1;
priority_queue<pair<int, int> > pq;
auto val = [&](int i) {
return a[pre[i]] >= a[i] && a[i] <= a[nxt[i]] ? 1000000000
: min(a[pre[i]], a[nxt[i]]);
};
auto push = [&](int i) { pq.push(make_pair(val(i), i)); };
for (int i = (2); i <= int(n - 1); i++) push(i);
long long ans = 0;
while (!pq.empty()) {
int i = pq.top().second;
int v = pq.top().first;
pq.pop();
if (vis[i] || val(i) != v) continue;
vis[i] = 1;
ans += min(a[pre[i]], a[nxt[i]]);
nxt[pre[i]] = nxt[i];
pre[nxt[i]] = pre[i];
if (pre[i] > 1) push(pre[i]);
if (nxt[i] < n) push(nxt[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int L[5 * 100010];
int R[5 * 100010], arr[5 * 100010], idx[5 * 100010];
int n;
bool comp(int a, int b) { return (bool)(arr[a] < arr[b]); }
int main() {
while (scanf("%d", &n) == 1) {
(memset(L, 0, sizeof(L)));
(memset(R, 0, sizeof(R)));
(memset(idx, 0, sizeof(idx)));
for (int i = 1; i <= n; i++) {
R[i - 1] = i;
L[i] = i - 1;
int a;
scanf("%d", &a);
arr[i] = a;
idx[i] = i;
}
R[n] = n + 1, L[n + 1] = n;
sort(idx + 1, idx + n + 1, comp);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int indx = idx[i];
if (!L[indx] or R[indx] > n)
ans += arr[indx];
else
ans += min(arr[L[indx]], arr[R[indx]]);
L[R[indx]] = L[indx];
R[L[indx]] = R[indx];
}
printf("%I64d\n", ans - arr[idx[n - 1]] - arr[idx[n]]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const long long MAXN = 1e6 + 10;
const long long INF = 8e18;
const long long MOD = 1e9 + 7;
pair<long long, long long> A[MAXN];
long long n;
set<pair<long long, long long> > st;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i].first;
A[i].second = i;
st.insert({i, A[i].first});
}
sort(A, A + n);
long long ans = 0, val = 0;
long long rem = n;
for (int i = 0; i < n - 2; i++) {
auto it = st.find({A[i].second, A[i].first});
auto ite = st.end();
ite--;
if (it == st.begin() || it == ite) {
ans += (A[i].first - val) * (rem - 2);
val += (A[i].first - val);
st.erase(it);
rem--;
} else {
auto nxt = it, prv = it;
nxt++;
prv--;
ans += min(nxt->second, prv->second) - val;
st.erase(it);
rem--;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using std::min;
using std::sort;
const int maxn = 500000 + 10;
int stack[maxn], p = -1;
int main() {
int n, x;
scanf("%d", &n);
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
while (p >= 1 && stack[p - 1] >= stack[p] && stack[p] <= x) {
ans += min(stack[p - 1], x);
p--;
}
stack[++p] = x;
}
sort(stack, stack + p + 1);
for (int i = 0; i < p - 1; i++) ans += stack[i];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int id, s;
} a[500010];
int l[500010], r[500010], b[500010], n, i, L, R;
long long ans;
bool cmp(const node& a, const node& b) { return a.s < b.s; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i].s);
a[i].id = i;
l[i] = i - 1;
r[i] = i + 1;
b[i] = a[i].s;
}
sort(a + 1, a + n + 1, cmp);
L = 1;
R = n;
for (i = 1; i <= n - 2; i++)
if (a[i].id == L)
ans += a[i].s, L = r[a[i].id];
else if (a[i].id == R)
ans += a[i].s, R = l[a[i].id];
else {
ans += min(b[l[a[i].id]], b[r[a[i].id]]);
r[l[a[i].id]] = r[a[i].id];
l[r[a[i].id]] = l[a[i].id];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(5e5) + 10, mod = int(1e9) + 7;
int n, a[N];
long long second;
int mx, mx2;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] >= mx) {
mx2 = mx;
mx = a[i];
} else if (mx2 < a[i])
mx2 = a[i];
second += 2 * a[i];
second -= min(a[i], a[i - 1]);
}
second = second - 2 * mx - mx2;
printf("%lld", second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
int a[501010], nxt[501010], pre[501010];
pair<int, int> p[501010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
p[i] = pair<int, int>(a[i], i);
nxt[i] = i + 1, pre[i] = i - 1;
}
sort(p + 1, p + n + 1);
long long ans = 0;
int st = 1, ed = n;
for (int i = 1; i < n - 1; i++) {
int v = p[i].second;
if (v == st) {
ans += p[i].first;
st = nxt[st];
} else if (v == ed) {
ans += p[i].first;
ed = pre[ed];
} else {
ans += min(a[pre[v]], a[nxt[v]]);
pre[nxt[v]] = pre[v];
nxt[pre[v]] = nxt[v];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char BUFFER[100000 + 5];
bool readn(int &n) { return scanf("%d", &n) == 1; }
bool readl(long long &n) { return scanf("%I64d", &n) == 1; }
bool readd(double &n) { return scanf("%lf", &n) == 1; }
bool reads(string &s) {
s = "";
int n = scanf("%s", BUFFER);
if (n == 1) s = BUFFER;
return n == 1;
}
bool readln(string &s) {
char *valid = gets(BUFFER);
if (valid) s = BUFFER;
return ((bool)valid);
}
const int maxn = 1e6 + 10;
set<pair<int, int> > st;
vector<int> A[maxn];
int main() {
int i, j, k, n, m;
st.clear();
for (i = 0; i < maxn; ++i) A[i].clear();
long long ans = 0;
cin >> n;
set<pair<int, int> >::iterator p1, p2, p;
for (i = 0; i < n; ++i) {
readn(m);
st.insert(make_pair(i, m));
A[m].push_back(i);
}
for (i = 0; i < maxn; ++i) {
if (((int)st.size()) < 3) break;
for (j = 0; j < ((int)A[i].size()); ++j) {
if (((int)st.size()) < 3) break;
k = A[i][j];
p1 = p2 = p = st.find(make_pair(k, i));
if (p == st.begin() || p == (--st.end())) {
ans += p->second;
st.erase(p);
continue;
}
p1--;
p2++;
ans += min(p1->second, p2->second);
st.erase(p);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int a[N];
int main() {
int n;
long long ans = 0;
scanf("%d", &n);
int cnt = -1;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[++cnt]);
while (cnt > 1 && a[cnt - 1] <= a[cnt - 2] && a[cnt - 1] <= a[cnt]) {
ans += min(a[cnt - 2], a[cnt]);
a[cnt - 1] = a[cnt];
--cnt;
}
}
for (int i = 1; i < cnt; ++i) ans += min(a[i - 1], a[i + 1]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
const long long maxn = 5e5 + 10;
const long long inf = 1e18;
long long STACK[maxn], t, a[maxn];
int32_t main() {
long long n = in();
for (long long i = 0; i < n; i++) a[i] = in();
long long ans = 0;
for (long long i = 0; i < n; i++) {
while (t >= 2 && STACK[t - 2] >= STACK[t - 1] && a[i] >= STACK[t - 1])
ans += min(STACK[t - 2], a[i]), t--;
STACK[t++] = a[i];
}
sort(STACK, STACK + t);
for (long long i = 0; i < t - 2; i++) ans += STACK[i];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500300;
const int mod = 998244353;
const long long inf = 1e18;
int n, a[N];
set<pair<int, int> > s;
set<int> alive;
int p[N];
inline int get(int x) {
if (p[x] == x) return x;
return p[x] = get(p[x]);
}
long long ans = 0;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i], alive.insert(i);
for (int i = 0; i < n; ++i) s.insert({a[i], i});
for (int i = 0; i < n - 2; ++i) {
int pos = s.begin()->second;
s.erase(s.begin());
if (*alive.begin() == pos) {
ans += a[pos];
} else if (*alive.rbegin() == pos) {
ans += a[pos];
} else {
int ri = *alive.upper_bound(pos);
int le = *(--alive.lower_bound(pos));
ans += min(a[ri], a[le]);
}
alive.erase(pos);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[N], l[N], r[N];
int st[N], top = 0, stone = 0;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
top = 0;
stone = 0;
for (int i = 0; i < n; i++) {
while (top > stone && st[top - 1] < a[i]) --top;
if (top) l[i] = st[top - 1];
if (!top || a[i] > st[top - 1]) ++stone;
st[top++] = a[i];
}
top = 0;
stone = 0;
for (int i = n - 1; i >= 0; i--) {
while (top > stone && st[top - 1] <= a[i]) --top;
if (top) r[i] = st[top - 1];
if (!top || a[i] > st[top - 1]) ++stone;
st[top++] = a[i];
}
long long ans = 0;
for (int i = 1; i < n - 1; i++) {
ans += min(l[i], r[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
int n, a[MAXN];
long long ans = 0;
int s[MAXN], cnt = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int top = 1;
for (int i = 1; i <= n; i++) {
int x = a[i];
while (top > 2 && s[top - 2] >= s[top - 1] && s[top - 1] <= x) {
ans += min(s[top - 2], x);
top -= 1;
}
s[top++] = x;
}
top -= 1;
sort(1 + s, 1 + s + top);
for (int i = 1; i <= top - 2; i++) {
ans += s[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, top, stack1[500001];
long long ans;
int main() {
int x;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
while (top > 1 && stack1[top - 1] >= stack1[top] && stack1[top] <= x) {
ans += min(stack1[top - 1], x);
top--;
}
stack1[++top] = x;
}
sort(stack1, stack1 + top + 1);
for (int i = 1; i <= top - 2; i++) ans += stack1[i];
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 5e5 + 5;
int t[N], n;
pair<int, int> t2[N];
long long ans;
set<int> ava;
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 1; i <= n; i++) t2[i] = {t[i], i};
for (int i = 1; i <= n; i++) ava.insert(i);
sort(t2 + 1, t2 + n + 1);
for (int i = 1; i <= n - 2; i++) {
ans += (t2[i].first - t2[i - 1].first) * (n - i - 1);
auto gosc = ava.find(t2[i].second);
if (gosc != ava.begin() && next(gosc) != ava.end())
ans += min(t[*prev(gosc)], t[*next(gosc)]) - t2[i].first;
ava.erase(t2[i].second);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500010], nb;
pair<int, int> link[500010], b[500010];
long long res;
bool removed[500010];
void remove(int i) {
link[link[i].first].second = link[i].second;
link[link[i].second].first = link[i].first;
removed[i] = true;
}
bool hole(int i) {
return a[link[i].first] >= a[i] && a[i] <= a[link[i].second];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
link[1].second = 2;
link[n].first = n - 1;
for (int i = 2; i <= n - 1; i++) {
link[i] = make_pair(i - 1, i + 1);
}
for (int i = 2; i <= n - 1; i++) {
if (!removed[i] && hole(i)) {
int x = i;
while (x != -1) {
res += min(a[link[x].first], a[link[x].second]);
remove(x);
if (link[x].first > 1 && hole(link[x].first))
x = link[x].first;
else if (link[x].second < n && hole(link[x].second))
x = link[x].second;
else
x = -1;
}
}
}
int x = link[1].second;
while (x < n) {
res += min(a[link[x].first], a[link[x].second]);
x = link[x].second;
}
printf("%I64d", res);
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[500009];
int tree[500009], n = 500004, b[500009];
void update(int idx, int val) {
while (idx <= n) {
tree[idx] += val;
idx += (idx & -idx);
}
}
int sum(int idx) {
int val = 0;
while (idx > 0) {
val += tree[idx];
idx -= (idx & -idx);
}
return val;
}
int query(int val) {
int low = 0;
int high = n;
int mid = (low + high) / 2;
while (low < high) {
int mid = (low + high) / 2;
if (sum(mid) >= val)
high = mid;
else
low = mid + 1;
}
return low;
}
int main() {
int N;
scanf("%d", &N);
if (N <= 2) {
printf("0\n");
return 0;
}
for (int i = int(1); i <= int(N); i++) {
scanf("%d", &a[i].first);
a[i].second = i;
b[i] = a[i].first;
}
sort(a + 1, a + N + 1);
reverse(a + 1, a + N + 1);
update(a[1].second, 1);
update(a[1].second, 1);
update(a[2].second, 1);
update(a[2].second, 1);
long long int ans = 0;
for (int i = int(3); i <= int(N); i++) {
int idx = a[i].second;
update(a[i].second, 1);
if (query(sum(idx) - 1) != 0 && query(sum(idx) + 1) != n) {
ans += min(b[query(sum(idx) - 1)], b[query(sum(idx) + 1)]);
} else if (query(sum(idx) + 2) != n) {
ans += min(a[i].first, b[query(sum(idx) + 2)]);
} else if (query(sum(idx) - 2) != 0) {
ans += min(a[i].first, b[query(sum(idx) - 2)]);
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[500010];
stack<int> st;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
while (st.size() > 1 && a[i] >= st.top()) {
int x = st.top();
st.pop();
if (x <= st.top()) {
ans += (0LL + min(st.top(), a[i]));
} else {
st.push(x);
break;
}
}
st.push(a[i]);
}
vector<int> z;
while (st.size() != 0) {
z.push_back(st.top());
st.pop();
}
sort(z.begin(), z.end());
for (int i = 0; i < (int)z.size() - 2; i++) ans += z[i];
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int b[500000 + 5];
int main() {
while (cin >> n) {
long long ans = 0;
int r = -1;
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
while (r > 0 && b[r] <= b[r - 1] && b[r] <= tmp) {
ans += min(b[r - 1], tmp);
r--;
}
b[++r] = tmp;
}
sort(b, b + r + 1);
for (int i = 0; i <= r - 2; i++) ans += b[i];
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, tree_size;
long long answer;
int m[524290], t[524290], leftpr[524290], rightpr[524290], tree[1048580],
key[1048580];
void build() {
tree_size = pow(2, 1.0 * ceil(log2(n)));
for (int i = 2 * tree_size - 1; i > 0; --i) {
if (i >= tree_size) {
key[i] = i - tree_size + 1;
if (i - tree_size < n)
tree[i] = m[i - tree_size + 1];
else
tree[i] = 1000000000;
} else {
tree[i] = min(tree[2 * i], tree[2 * i + 1]);
if (tree[i] == tree[2 * i])
key[i] = key[2 * i];
else
key[i] = key[2 * i + 1];
}
}
}
int find_minn(int l, int r) {
l += tree_size - 1;
r += tree_size - 1;
int minn = 1000000000;
int n_minn;
while (l <= r) {
if (l % 2 && tree[l] < minn) {
minn = tree[l];
n_minn = l;
}
if (!(r % 2) && tree[r] < minn) {
minn = tree[r];
n_minn = r;
}
l = (l + 1) / 2, r = (r - 1) / 2;
}
return key[n_minn];
}
void form(int v, int k) {
v += tree_size - 1;
tree[v] = k;
while (v /= 2) {
tree[v] = min(tree[2 * v], tree[2 * v + 1]);
if (tree[v] == tree[v * 2])
key[v] = key[2 * v];
else
key[v] = key[2 * v + 1];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &m[i]);
leftpr[i] = i - 1;
rightpr[i] = i + 1;
}
if (n < 3)
cout << 0;
else {
build();
int size_m = n;
int del_obj;
while (size_m > 2) {
del_obj = find_minn(1, n);
if (rightpr[del_obj] == n + 1 || leftpr[del_obj] == 0)
answer += m[del_obj];
else
answer += min(m[rightpr[del_obj]], m[leftpr[del_obj]]);
rightpr[leftpr[del_obj]] = rightpr[del_obj];
leftpr[rightpr[del_obj]] = leftpr[del_obj];
form(del_obj, 1000000000);
size_m--;
}
cout << answer;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500010], b[500010];
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
long long ans = 0;
if (n > 2) {
int id = 0;
b[id++] = a[0];
b[id++] = a[1];
for (int i = 2; i < n; i++) {
while (b[id - 1] <= b[id - 2] && b[id - 1] <= a[i]) {
ans += min(b[id - 2], a[i]);
id--;
}
b[id++] = a[i];
}
sort(b, b + id);
for (int i = 0; i < id - 2; i++) ans += b[i];
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int s[500005];
int n, top;
long long ans;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int 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 + top + 1);
for (int i = 1; i <= top - 2; i++) ans += s[i];
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 999999999;
const int mod = 1000000007;
inline int Getint() {
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
int ret = 0;
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret;
}
pair<int, int> p[500010];
int a[500010], l[500010], r[500010];
int n;
int main() {
n = Getint();
for (int i = 1; i <= n; i++) {
a[i] = Getint();
p[i] = make_pair(a[i], i);
l[i] = i - 1, r[i] = i + 1;
}
sort(p + 1, p + n + 1);
int left = 1, right = n;
long long ans = 0;
for (int i = 1; i < n - 1; i++) {
int j = p[i].second;
if (j == left) {
ans += p[i].first;
left = r[left];
continue;
}
if (j == right) {
ans += p[i].first;
right = l[right];
continue;
}
int x = a[l[j]], y = a[r[j]];
if (x < y)
ans += x;
else
ans += y;
l[r[j]] = l[j], r[l[j]] = r[j];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long st[1000], top, n, ans, x;
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &x);
while (top > 1 && st[top - 1] >= st[top] && x >= st[top]) {
ans += min(st[top - 1], x);
top--;
}
st[++top] = x;
}
sort(st + 1, st + 1 + top);
for (int i = 1; i <= top - 2; i++) ans += st[i];
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500500];
int main() {
int n, i, p = 0, x;
long long ans = 0;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%d", &x);
while (p >= 2 && a[p - 2] >= a[p - 1] && x >= a[p - 1]) {
if (a[p - 2] < x)
ans += a[p - 2];
else
ans += x;
--p;
}
a[p++] = x;
}
sort(a, a + p);
for (i = p - 3; i >= 0; --i) ans += a[i];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 510000;
int a[N], que[N];
int rear;
int main() {
int n;
scanf("%d", &n);
long long ret = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
while (rear >= 2 && que[rear - 1] <= que[rear - 2] &&
que[rear - 1] <= a[i]) {
ret += min(que[rear - 2], a[i]);
rear--;
}
que[rear++] = a[i];
}
sort(que, que + rear);
for (int i = 0; i < rear - 2; i++) {
ret += que[i];
}
cout << ret << endl;
}
|
#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;
return 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m = 0, x;
int a[500010];
int main() {
long long ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[m++]);
while (m >= 3) {
if (a[m - 2] <= a[m - 1] && a[m - 2] <= a[m - 3]) {
ans += min(a[m - 1], a[m - 3]);
a[m - 2] = a[m - 1];
--m;
} else
break;
}
}
sort(a, a + m);
for (int i = 0; i < m - 2; ++i) ans += a[i];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, he, en;
int L[500010], R[500010], a[500010], id[500010];
long long an;
inline bool cc1(const int &A, const int &B) { return a[A] < a[B]; }
inline void del(int x) {
L[R[x]] = L[x];
R[L[x]] = R[x];
if (x == he)
he = R[x];
else if (x == en)
en = L[x];
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
L[i] = i - 1;
R[i] = i + 1;
id[i] = i;
}
he = 1, en = n;
sort(id + 1, id + n + 1, cc1);
for (i = 1; i <= n; i++)
if (he != en && R[he] != en) {
int A = id[i];
if (A == he)
an += a[he];
else if (A == en)
an += a[en];
else
an += min(a[L[A]], a[R[A]]);
del(A);
}
printf("%I64d\n", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int vl;
int l, r;
node *left, *right;
} typedef node;
long long int seq[600000];
node *root;
int query(node *cur, int l, int r) {
if (r < cur->l || l > cur->r) return -1;
if (cur->l >= l && cur->r <= r) return cur->vl;
int vl = query(cur->left, l, r);
if (vl == -1) return query(cur->right, l, r);
int vr = query(cur->right, l, r);
if (vr != -1 && seq[vr] > seq[vl]) return vr;
return vl;
}
long long int calc(int l, int r) {
if (r - l <= 1) return 0;
int p = query(root, l + 1, r - 1);
return calc(l, p) + calc(p, r) +
min(seq[query(root, l, p - 1)], seq[query(root, p + 1, r)]);
}
void build(node *cur, int l, int r) {
cur->l = l;
cur->r = r;
if (l == r) {
cur->vl = l;
return;
}
int m = (l + r) / 2;
cur->left = new node();
cur->right = new node();
build(cur->left, l, m);
build(cur->right, m + 1, r);
cur->vl = cur->left->vl;
if (seq[cur->right->vl] > seq[cur->left->vl]) cur->vl = cur->right->vl;
}
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%I64d", &seq[i]);
root = new node();
build(root, 0, n - 1);
printf("%I64d\n", calc(0, n - 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 500005;
int a[maxN];
int n;
int main() {
int m = 0;
long long ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
a[++m] = x;
while (m >= 3 && a[m - 1] <= a[m - 2] && a[m - 1] <= a[m]) {
ans += min(a[m - 2], a[m]);
a[m - 1] = a[m];
--m;
}
}
a[m + 1] = 0;
for (int i = 1; i <= m; ++i) ans += min(a[i - 1], a[i + 1]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
int box[MAXN];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
long long ret = 0;
int top = -1;
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
while (top >= 1 && box[top - 1] >= box[top] && x > box[top]) {
ret += min(box[top - 1], x);
--top;
}
box[++top] = x;
}
sort(box, box + top + 1);
for (int i = 0; i <= top - 2; ++i) {
ret += box[i];
}
printf("%I64d\n", ret);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class L>
bool smax(T &x, L y) {
return x < y ? (x = y, 1) : 0;
}
template <class T, class L>
bool smin(T &x, L y) {
return y < x ? (x = y, 1) : 0;
}
const int maxn = 5e5 + 17;
list<int> a;
list<int>::iterator per[maxn];
int n;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0, x; i < n; i++) cin >> x, a.push_back(x), per[i] = --a.end();
sort(per, per + n,
[](list<int>::iterator &i, list<int>::iterator &j) { return *i < *j; });
long long ans = 0, dam = 0;
for_each(per, per + max(0, n - 2), [&](list<int>::iterator &i) {
if (i == a.begin() || i == --a.end()) {
ans += (a.size() - 2) * (*i - dam);
dam = *i;
} else {
auto prv = i, nxt = i;
prv--, nxt++;
ans += min(*prv, *nxt) - dam;
}
a.erase(i);
});
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int in[N];
pair<int, int> p[N];
int nxt[N], prv[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", in + i);
p[i] = {in[i], i};
nxt[i] = i + 1;
prv[i] = i - 1;
}
sort(p, p + n);
long long res = 0;
int low = 0, high = n - 1;
for (int i = 0; i < n - 2; ++i) {
int j = p[i].second;
if (j == low) {
res += p[i].first;
low = nxt[low];
continue;
}
if (j == high) {
res += p[i].first;
high = prv[high];
continue;
}
int x = in[prv[j]];
int y = in[nxt[j]];
res += min(x, y);
nxt[prv[j]] = nxt[j];
prv[nxt[j]] = prv[j];
}
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 500500;
int a[MN];
struct D {
int l, r;
int d;
void setmin() {
if (MN <= r) return;
d = min(a[l], a[r]);
}
};
D d[MN];
int main() {
int n;
cin >> n;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
q;
for (int i = 0; i < n; i++) {
cin >> a[i];
d[i].l = i - 1;
d[i].r = i + 1;
q.push(pair<int, int>(a[i], i));
}
for (int i = 1; i < n - 1; i++) {
d[i].setmin();
}
long long r = 0;
while (q.size() > 2) {
pair<int, int> p = q.top();
q.pop();
D dd = d[p.second];
if (dd.l < 0 || n <= dd.r) {
r += a[p.second];
if (dd.l < 0) {
d[dd.r].l = -1;
} else {
d[dd.l].r = n;
}
} else {
r += dd.d;
d[dd.l].r = dd.r;
d[dd.l].setmin();
d[dd.r].l = dd.l;
d[dd.r].setmin();
}
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500100;
struct Set {
priority_queue<pair<int, int> > q1, q2;
void push(pair<int, int> x) { q1.push(x); }
void pop() { q1.pop(); }
void del(pair<int, int> x) { q2.push(x); }
bool empty() { return q1.empty(); }
void fix() {
while (!q1.empty() && !q2.empty() && q1.top() == q2.top()) {
q1.pop();
q2.pop();
}
}
pair<int, int> top() {
fix();
return q1.top();
}
} q;
int n;
int from[maxn], to[maxn];
int v[maxn];
bool flag[maxn] = {0};
int getans(int x) { return min(v[from[x]], v[to[x]]); }
void del(int x) {
flag[x] = 1;
int a = from[x], b = to[x];
if (a > 0) q.del(make_pair(getans(a), a));
if (b <= n) q.del(make_pair(getans(b), b));
to[a] = b;
from[b] = a;
if (a > 0) q.push(make_pair(getans(a), a));
if (b <= n) q.push(make_pair(getans(b), b));
}
void del1(int x) {
flag[x] = 1;
from[to[x]] = from[x];
to[from[x]] = to[x];
}
queue<int> h;
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) from[i] = i - 1, to[i] = i + 1;
for (int i = 1; i <= n; i++) cin >> v[i];
long long ans = 0;
for (int i = 2; i < n; i++)
if (v[i] <= getans(i)) h.push(i);
while (!h.empty()) {
int now = h.front();
h.pop();
if (flag[now]) continue;
flag[now] = 1;
ans += getans(now);
del1(now);
int a = from[now];
if (a > 0 && getans(a) >= v[a]) h.push(a);
int b = to[now];
if (b <= n && getans(b) >= v[b]) h.push(b);
}
for (int i = 1; i <= n; i++)
if (!flag[i]) q.push(make_pair(getans(i), i));
while (!q.empty()) {
pair<int, int> a = q.top();
q.pop();
ans += a.first;
del(a.second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
using std::sort;
using std::swap;
template <typename T>
void read(T &x) {
int flag = 1;
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -flag;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= flag;
}
const int _ = 5e5 + 10;
int s[_], t, x, n;
long long ret;
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(x);
while (t >= 2 && s[t] <= s[t - 1] && s[t] < x) ret += min(s[t - 1], x), --t;
s[++t] = x;
}
sort(s + 1, s + t + 1);
for (int i = 1; i <= t - 2; ++i) ret += s[i];
printf("%lld\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[1000000], ant[1000000], nxt[1000000];
int n;
int ja[1000000];
bool cmp(int a, int b) { return v[a] < v[b]; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> v[i];
long long ans = 0;
for (int i = 0; i < n - 1; i++) nxt[i] = i + 1;
for (int i = 1; i < n; i++) ant[i] = i - 1;
vector<int> u;
for (int i = 1; i < n - 1; i++) u.push_back(i);
sort((u).begin(), (u).end(), cmp);
for (int i = 0; i < u.size(); i++) {
int x = u[i];
if (v[ant[x]] >= v[x] && v[nxt[x]] >= v[x]) {
int a = ant[x], b = nxt[x];
ant[b] = a, nxt[a] = b;
ja[u[i]] = 1;
ans += min(v[a], v[b]);
}
}
reverse((u).begin(), (u).end());
vector<int> val;
for (int i = 0; i < u.size(); i++) {
int x = u[i];
if (ja[u[i]]) continue;
val.push_back(v[u[i]]);
}
val.push_back(v[0]), val.push_back(v[n - 1]);
sort((val).begin(), (val).end());
for (int i = 0; i < val.size() - 2; i++) ans += val[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (int)n; ++i) cin >> a[i];
vector<int> left(n), right(n);
for (int i = 0; i < (int)n; ++i) left[i] = i - 1;
for (int i = 0; i < (int)n; ++i) right[i] = i + 1;
right[n - 1] = -1;
long long rval = 0;
vector<pair<int, int> > V;
for (int i = 0; i < (int)n; ++i) V.push_back(make_pair(a[i], i));
sort(V.begin(), V.end());
int W = 0;
int size = n;
for (int pos = 0; pos < (int)V.size() - 2; ++pos) {
pair<int, int> p = V[pos];
int diff = p.first - W;
int x = p.second;
rval += (size - 2) * diff;
size--;
W = a[x];
rval += max(0, min(((left[x]) != -1 ? a[(left[x])] : 0),
((right[x]) != -1 ? a[(right[x])] : 0)) -
W);
int l = left[x];
int r = right[x];
if (r != -1) left[r] = l;
if (l != -1) right[l] = r;
}
cout << rval << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[500010];
int left_ind[500010], right_ind[500010];
int main() {
int numbers;
cin >> numbers;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
ref;
for (int i{1}; i <= numbers; ++i) {
cin >> arr[i];
ref.push(pair<long long, int>(arr[i], i));
left_ind[i] = i - 1;
right_ind[i] = i + 1;
}
long long output = 0;
int left = 1, right = numbers;
while (ref.size() > 2) {
pair<long long, int> it = ref.top();
ref.pop();
if (it.second == left || it.second == right) {
output += it.first;
if (it.second == left)
left = right_ind[left];
else
right = left_ind[right];
} else
output += min(arr[left_ind[it.second]], arr[right_ind[it.second]]);
right_ind[left_ind[it.second]] = right_ind[it.second];
left_ind[right_ind[it.second]] = left_ind[it.second];
}
cout << output;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const N = 5e5 + 20;
long long n, a[N], x, ans, l[N], r[N];
set<pair<long long, long long> > s;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 0; i <= n + 1; i++) l[i] = i - 1, r[i] = i + 1;
for (long long i = 1; i <= n; i++) s.insert({a[i], i});
while (s.size() > 2) {
long long k = (*s.begin()).first - x, i = (*s.begin()).second;
s.erase(s.begin());
if (l[i] == 0) {
x += k;
ans += k * (s.size() - 1);
} else if (r[i] == n + 1) {
x += k;
ans += k * (s.size() - 1);
} else
ans += min(a[l[i]] - x, a[r[i]] - x);
l[r[i]] = l[i], r[l[i]] = r[i];
}
return cout << ans, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long LLMAX = 9223372036854775807LL;
const int MOD = 1000000007;
const int maxn = 500001;
int n;
int a[maxn];
pair<int, int> p[maxn];
int pr[maxn], ne[maxn];
int main() {
scanf("%d", &(n));
for (int(i) = 0; (i) < (int)(n); ++(i)) scanf("%d", &(a[i]));
for (int i = 0; i < n; ++i) {
p[i] = make_pair((a[i]), (i));
pr[i] = i - 1;
ne[i] = i + 1;
}
sort(p, p + n);
long long ans = 0, l = 0, r = n - 1;
for (int i = 0; i < n - 2; ++i) {
int j = p[i].second;
if (j == l) {
ans += p[i].first;
l = ne[j];
} else if (j == r) {
ans += p[i].first;
r = pr[r];
} else {
ans += min(a[pr[j]], a[ne[j]]);
pr[ne[j]] = pr[j];
ne[pr[j]] = ne[j];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
int St[MAXN], top;
int main() {
int n;
scanf("%d", &n);
long long ans = 0;
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
while (top >= 2 && St[top - 2] >= St[top - 1] && St[top - 1] <= t) {
ans += min(St[top - 2], t);
top--;
}
St[top++] = t;
}
sort(St, St + top);
for (int i = 0; i < top - 2; i++) {
ans += St[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int a[N];
int prev[N];
int next[N];
vector<pair<long long int, long long int> > v;
for (int i = 0; i < N; i++) {
cin >> a[i];
prev[i] = i - 1;
next[i] = i + 1;
v.push_back({a[i], i});
}
sort(v.begin(), v.end());
long long int ans = 0;
int l = 0;
int r = N - 1;
pair<long long int, long long int> x;
for (int i = 0; i < (int)v.size() - 2; i++) {
x = v[i];
if (x.second == l) {
ans += x.first;
prev[next[l]] = -1;
l = next[l];
} else if (x.second == r) {
ans += x.first;
next[prev[r]] = N;
r = prev[r];
} else {
ans += min(a[next[x.second]], a[prev[x.second]]);
next[prev[x.second]] = next[x.second];
prev[next[x.second]] = prev[x.second];
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 500005;
int n, s[maxN], sta[maxN];
void Readln() {
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
}
void Solve() {
if (n <= 2) {
printf("0\n");
return;
}
int tot = 2;
sta[1] = s[1];
sta[2] = s[2];
long long ans = 0;
for (int i = 3; i <= n; i++) {
while (tot > 1 && sta[tot] <= sta[tot - 1] && sta[tot] <= s[i]) {
ans += min(sta[tot - 1], s[i]);
tot--;
}
tot++;
sta[tot] = s[i];
}
sort(sta + 1, sta + 1 + tot);
for (int i = 1; i <= tot - 2; i++) ans += sta[i];
printf("%I64d\n", ans);
}
int main() {
Readln();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int n, a[500000];
int main() {
cin >> n;
for (int i = 0; i < (int)n; i++) cin >> a[i];
long long ans = 0;
set<int> alive;
set<pair<int, int> > vals;
for (int i = 0; i < (int)n; i++)
alive.insert(i), vals.insert(make_pair(a[i], i));
for (int iter = 0; iter < (int)n - 2; iter++) {
int x, z;
int y = vals.begin()->second;
set<int>::iterator it = alive.lower_bound(y);
if (it == alive.begin()) {
ans += a[y];
alive.erase(y);
vals.erase(make_pair(a[y], y));
continue;
}
++it;
if (it == alive.end()) {
ans += a[y];
alive.erase(y);
vals.erase(make_pair(a[y], y));
continue;
}
z = *it;
--it;
--it;
x = *it;
ans += min(a[x], a[z]);
alive.erase(y);
vals.erase(make_pair(a[y], y));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
const int N = 1 << 19;
int a[N], L[N], R[N], ord[N];
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
L[i] = i - 1;
R[i] = i + 1;
ord[i - 1] = i;
}
sort(ord, ord + n, [&](int i, int j) { return a[i] < a[j]; });
ll ans = 0;
for (int j = 0, l = 1, r = n; j + 2 < n; ++j) {
int i = ord[j];
if (i == l) {
ans += a[i];
l = R[l];
continue;
}
if (i == r) {
ans += a[i];
r = L[r];
continue;
}
ans += min(a[L[i]], a[R[i]]);
R[L[i]] = R[i];
L[R[i]] = L[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, s, d[500002][3], f, g, h, j, k, l, i, n, m;
long long inf = 100000000000000000ll;
pair<long long, int> p[500003], p1;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
d[i][0] = a;
d[i][1] = i - 1;
d[i][2] = i + 1;
p[i] = {a, i};
}
sort(p + 1, p + n + 1);
i = 0;
long long y = 0;
int L = 1, R = n;
while (n - i - 2 > 0) {
p1 = p[i + 1];
if (p1.second == L || p1.second == R) {
k += (p1.first - y) * (n - i - 2);
y = p1.first;
if (p1.second == L)
L = d[p1.second][2];
else
R = d[p1.second][1];
} else {
k = k + min(d[d[p1.second][1]][0], d[d[p1.second][2]][0]) - y;
d[d[p1.second][1]][2] = d[p1.second][2];
d[d[p1.second][2]][1] = d[p1.second][1];
}
i++;
}
cout << k;
}
|
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ", ";
err(++it, args...);
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
if (n <= 2) do {
cout << 0 << endl;
return;
} while (0);
;
long long res = 0;
stack<int> sl, sr;
sl.push(a[0]);
for (int i = n - 1; i > 0; --i) sr.push(a[i]);
while (sr.size() > 1) {
int c = sr.top();
sr.pop();
if (sl.top() >= c && c <= sr.top()) {
res += min(sl.top(), sr.top());
if (sl.size() > 1) {
sr.push(sl.top());
sl.pop();
}
continue;
}
sl.push(c);
}
a = vector<int>();
a.emplace_back(sr.top());
while (!sl.empty()) {
a.emplace_back(sl.top());
sl.pop();
}
reverse(begin(a), end(a));
n = a.size();
int max_r = 0;
for (int i = 1; i < n - 1; ++i) max_r = max(max_r, min(a[i - 1], a[i + 1]));
sl = stack<int>();
sl.push(a[0]);
sr = stack<int>();
sr.push(a[n - 1]);
for (int i = 1; i < n - 1; ++i) {
if (min(a[i - 1], a[i + 1]) == max_r) {
for (int j = n - 2; j >= i; --j) sr.push(a[j]);
break;
}
sl.push(a[i]);
}
while (sl.size() > 1 && sr.size() > 1) {
int l = sl.top();
sl.pop();
int r = sr.top();
sr.pop();
int al = min(sl.top(), r);
int ar = min(l, sr.top());
if (al > ar) {
res += al;
sr.push(r);
} else {
res += ar;
sl.push(l);
}
}
while (sl.size() > 1) {
int cl = sl.top();
sl.pop();
res += min(sl.top(), sr.top());
}
while (sr.size() > 1) {
int cr = sr.top();
sr.pop();
res += min(sl.top(), sr.top());
}
do {
cout << res << endl;
return;
} while (0);
;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
enum { N = 500002 };
enum { C = 1000001 };
set<pair<pair<int, int>, pair<int, int> > > s;
int n, a[N];
long long cnt = 0, sum = 0;
pair<pair<int, int>, pair<int, int> > elem, neigh;
void count() {
while (s.size() > 2) {
elem = *s.begin();
s.erase(s.begin());
if (elem.second.first == -1 || elem.second.second == n) {
cnt += (s.size() - 1) * (elem.first.first - sum);
sum = elem.first.first;
} else
cnt += min(a[elem.second.first], a[elem.second.second]) - sum;
if (elem.second.first != -1) {
neigh = make_pair(make_pair(a[elem.second.first], elem.second.first),
make_pair(-1, elem.first.second));
neigh = *s.lower_bound(neigh);
s.erase(neigh);
neigh.second.second = elem.second.second;
s.insert(neigh);
}
if (elem.second.second != n) {
neigh = make_pair(make_pair(a[elem.second.second], elem.second.second),
make_pair(elem.first.second, 0));
neigh = *s.lower_bound(neigh);
s.erase(neigh);
neigh.second.first = elem.second.first;
s.insert(neigh);
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(make_pair(make_pair(a[i], i), make_pair(i - 1, i + 1)));
}
count();
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
const double eps = 1e-9;
int ts, kk = 1;
int n, b[500005];
pair<int, int> a[500005];
int lt[500005], rt[500005];
int main() {
int t, i, j, k;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
b[i] = k;
a[i] = pair<int, int>(k, i);
lt[i] = i - 1;
rt[i] = i + 1;
}
sort(a, a + n);
int x, y;
long long int rs = 0;
int lo, hi;
lo = 0;
hi = n - 1;
for (i = 0; i < n - 2; i++) {
k = a[i].second;
if (k == lo) {
rs += a[i].first;
lo = rt[k];
continue;
}
if (k == hi) {
rs += a[i].first;
hi = lt[k];
continue;
}
x = lt[k];
y = rt[k];
rs += min(b[x], b[y]);
rt[x] = y;
lt[y] = x;
}
cout << rs << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5 * 10e5 + 5;
int a[N];
int n;
int cnt;
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
while (n--) {
cin >> a[cnt];
while (cnt >= 2 && a[cnt - 1] <= a[cnt] && a[cnt - 1] <= a[cnt - 2]) {
ans += min(a[cnt], a[cnt - 2]);
cnt--;
a[cnt] = a[cnt + 1];
}
cnt++;
}
sort(a, a + cnt);
for (int i = 0; i < cnt - 2; ++i) {
ans += a[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[500050];
int st[500050];
int main() {
int top = 0;
long long sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
st[top++] = a[i];
while (top > 2 && st[top - 2] <= st[top - 1] &&
st[top - 2] <= st[top - 3]) {
sum += std::min(st[top - 1], st[top - 3]);
st[top - 2] = st[top - 1];
top--;
}
}
sort(st, st + top);
for (int i = 0; i < top - 2; ++i) sum += st[i];
printf("%I64d\n", sum);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5 * 1e5 + 100;
long long n, a[N], suc[N], pre[N], ans;
struct node {
long long num, id;
} sh[N];
bool cmp(node a, node b) { return a.num < b.num; }
stack<long long> s;
inline long long read() {
long long f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline void del(long long x) {
suc[pre[x]] = suc[x];
pre[suc[x]] = pre[x];
}
inline long long cal(long long x) { return min(a[pre[x]], a[suc[x]]); }
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
if (n <= 2) {
printf("0\n");
return 0;
}
for (long long i = 1; i <= n; i++) sh[i] = (node){a[i], i};
sort(sh + 1, sh + 1 + n, cmp);
for (long long i = 1; i <= n; i++) pre[i] = i - 1, suc[i] = i + 1;
long long h = 1, t = n;
for (long long i = 1; i <= n; i++) {
if (suc[suc[h]] == t) {
ans += cal(suc[h]);
del(suc[h]);
while (!s.empty()) ans += cal(s.top()), del(s.top()), s.pop();
break;
}
if (sh[i].id == h) {
h = suc[h];
s.push(h);
continue;
}
if (sh[i].id == t) {
t = pre[t];
s.push(t);
continue;
}
ans += cal(sh[i].id);
del(sh[i].id);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 501000;
struct ArrayItem {
long long val, num;
long long prev, next;
} A[MAXN];
long long N;
long long Sum = 0;
bool operator<(ArrayItem A, ArrayItem B) { return A.val > B.val; }
priority_queue<ArrayItem> Q;
void Delete(ArrayItem t) {
long long i = t.num;
A[A[i].prev].next = A[i].next;
A[A[i].next].prev = A[i].prev;
if (A[i].prev == 0 || A[i].next == N + 1)
Sum += A[i].val;
else
Sum += min(A[A[i].prev].val, A[A[i].next].val);
}
int main() {
cin >> N;
for (long long i = 1; i <= N; i++) {
cin >> A[i].val;
A[i].num = i;
A[i].prev = i - 1;
A[i].next = i + 1;
Q.push(A[i]);
}
long long n = N;
while (n-- > 2) {
Delete(Q.top());
Q.pop();
}
cout << Sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double PI = acos(-1);
int n, a[N], que[N], top;
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
que[++top] = a[1];
for (int i = 2; i <= n; i++) {
while (top > 1 && que[top] <= que[top - 1] && que[top] <= a[i]) {
ans += min(que[top - 1], a[i]);
top--;
}
que[++top] = a[i];
}
sort(que + 1, que + 1 + top);
for (int i = 1; i <= top - 2; i++) ans += que[i];
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
struct Arrete {
int v, c;
};
struct Point {
int x, y;
double distance(Point other) const {
return sqrt((x - other.x) * (x - other.x) + (y - other.y) * (y - other.y));
}
};
const int NB_D = 4;
const int DY[] = {-1, 1, 0, 0};
const int DX[] = {0, 0, -1, 1};
int main(void) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int N;
std::cin >> N;
std::vector<int> arr(N);
std::vector<std::pair<int, int> > sorted(N);
std::vector<int> next(N);
std::vector<int> prev(N);
for (int i(0); i < N; ++i) {
prev[i] = i - 1;
next[i] = i + 1;
std::cin >> arr[i];
sorted[i] = {arr[i], i};
}
std::sort((sorted).begin(), (sorted).end());
long long ans(0);
int left(0), right(N - 1);
sorted.pop_back();
if (!sorted.empty()) sorted.pop_back();
for (auto &v : sorted) {
if (v.second == left) {
ans += v.first;
left = next[left];
continue;
}
if (v.second == right) {
ans += v.first;
right = prev[right];
continue;
}
ans += std::min(arr[prev[v.second]], arr[next[v.second]]);
prev[next[v.second]] = prev[v.second];
next[prev[v.second]] = next[v.second];
}
std::cout << ans << '\n';
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.