text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 100010;
set<long long int> s;
set<long long int>::iterator itlow, itup;
long long int data[4 * MAXN], ind[4 * MAXN], a[MAXN];
const long long int INF = 10000000000000;
void build(int s = 0, int e = 5e5 + 1, int id = 1) {
if (e - s < 2) {
data[id] = a[s];
ind[id] = s;
return;
}
int mid = (s + e) / 2;
build(s, mid, 2 * id + 0);
build(mid, e, 2 * id + 1);
if (data[2 * id + 0] == 0) data[2 * id + 0] = INF;
if (data[2 * id + 1] == 0) data[2 * id + 1] = INF;
data[id] = min(data[2 * id + 0], data[2 * id + 1]);
if (data[2 * id + 0] < data[2 * id + 1]) {
ind[id] = ind[2 * id + 0];
} else {
ind[id] = ind[2 * id + 1];
}
}
void update(int p, int s = 0, int e = 5e5 + 1, int id = 1) {
if (e - s < 2) {
data[id] = INF;
ind[id] = s;
return;
}
int mid = (s + e) / 2;
if (p < mid) {
update(p, s, mid, 2 * id + 0);
} else {
update(p, mid, e, 2 * id + 1);
}
if (data[2 * id + 0] == 0) data[2 * id + 0] = INF;
if (data[2 * id + 1] == 0) data[2 * id + 1] = INF;
data[id] = min(data[2 * id + 0], data[2 * id + 1]);
if (data[2 * id + 0] < data[2 * id + 1]) {
ind[id] = ind[2 * id + 0];
} else {
ind[id] = ind[2 * id + 1];
}
}
int main() {
for (int i = 0; i < 4 * MAXN; i++) {
data[i] = INF;
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
s.insert(i);
}
build();
long long int answer = 0;
long long int sub = 0;
long long int num = n;
for (int i = 0; i < n - 2; i++) {
long long int mini = data[1] - sub;
long long int indexi = ind[1];
answer += (num - 2) * mini;
sub += mini;
num--;
itlow = s.begin();
itup = s.end();
itup--;
if (indexi == *(itlow) or indexi == *(itup)) {
update(indexi);
s.erase(indexi);
continue;
}
int lefti, righti;
itlow = s.lower_bound(indexi);
itup = s.upper_bound(indexi);
itlow--;
answer += min(a[*(itlow)], a[*(itup)]);
answer -= sub;
s.erase(indexi);
update(indexi);
}
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 7;
int N, er[maxn], we[maxn];
long long int ans = 0;
int main() {
scanf("%d", &N);
int i, j;
for (i = 1, j = 1; i <= N; i++) {
scanf("%d", &er[i]);
while (j > 2 && we[j - 2] >= we[j - 1] && er[i] >= we[j - 1]) {
ans += min(we[j - 2], er[i]);
j--;
}
we[j++] = er[i];
}
sort(we + 1, we + j);
for (i = 1; i < j - 2; i++) ans += we[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int MOD = 1000000007;
int n, top;
int a, s[5 * 100010];
int main() {
scanf("%d", &n);
unsigned long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
while (top - 2 >= 0 && s[top - 2] >= s[top - 1] && a >= s[top - 1]) {
ans += min(s[top - 2], a);
top--;
}
s[top++] = a;
}
sort(s, s + top);
for (int i = 0; i < top - 2; i++) ans += s[i];
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long ans;
vector<int> a, l, r;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
a.resize(n);
l.resize(n);
r.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
q.push(make_pair(a[i], i));
l[i] = i - 1;
r[i] = i + 1;
}
ans = 0;
long long cnt = n - 2, val = 0;
while (cnt > 0) {
cnt--;
pair<int, int> p = q.top();
q.pop();
int x = p.second;
if (l[x] == -1 || r[x] == n) {
ans += (cnt + 1) * (a[x] - val);
val = a[x];
} else
ans += min(a[l[x]], a[r[x]]) - val;
if (r[x] != n) l[r[x]] = l[x];
if (l[x] != -1) r[l[x]] = r[x];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kN = 5e5 + 5;
int n, a[kN], l[kN], r[kN], b[kN], cnt;
long long ans;
signed main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
l[i] = i - 1;
r[i] = i + 1;
}
for (int i = 2; i < n;) {
int L = l[i], R = r[i];
if (a[L] >= a[i] && a[R] >= a[i]) {
ans += min(a[L], a[R]);
r[L] = R;
l[R] = L;
i = L;
} else {
i = R;
}
}
for (int i = 1; i <= n; i = r[i]) {
b[++cnt] = a[i];
}
sort(b + 1, b + 1 + cnt);
for (int i = 1; i < cnt - 1; ++i) {
ans += b[i];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int A[500002], ST[500002];
int main() {
cin.sync_with_stdio(false);
cin >> N;
for (int i = 1; i <= N; ++i) cin >> A[i];
long long result = 0;
for (int i = 1; i <= N; ++i) {
while (ST[0] >= 2 && A[ST[ST[0] - 1]] >= A[ST[ST[0]]] &&
A[ST[ST[0]]] <= A[i]) {
result += min(A[ST[ST[0] - 1]], A[i]);
--ST[0];
}
ST[++ST[0]] = i;
}
for (int i = 1; i <= ST[0] - 2; ++i) result += min(A[ST[i]], A[ST[i + 2]]);
cout << result << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int num[600005];
long long sum = 0;
int main() {
int i = 0, j = 0;
int n = 0;
memset(num, 0, sizeof(num));
int temp = 0;
while (scanf("%d", &n) != EOF) {
sum = 0;
i = 0;
while (n--) {
scanf("%d", &temp);
while (i > 1 && num[i - 1] <= num[i - 2] && num[i - 1] <= temp) {
sum += min(num[i - 2], temp);
i--;
}
num[i] = temp;
i++;
}
sort(num, num + i);
for (j = 0; j < i - 2; j++) {
sum += num[j];
}
printf("%I64d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int q[500010];
void solve() {
int n;
cin >> n;
int top = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
while (top > 1 && q[top - 1] <= q[top - 2] && q[top - 1] <= a) {
ans += min(a, q[top - 2]);
top--;
}
q[top++] = a;
}
sort(q, q + top);
for (int i = 0; i < top - 2; i++) ans += q[i];
cout << ans << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, x, ans, a[1000001];
int main() {
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &x);
while (m > 1 && a[m] <= a[m - 1] && x >= a[m]) {
ans += min(a[m - 1], x);
m--;
}
a[++m] = x;
}
sort(a + 1, a + m + 1);
for (i = 1; i < m - 1; i++) ans += a[i];
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
int le[MAXN], ri[MAXN];
int a[MAXN];
struct num {
int val, pos;
};
num data[MAXN];
bool cmp(num a, num b) { return a.val < b.val; }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
data[i].val = a[i];
data[i].pos = i;
le[i] = i - 1;
ri[i] = i + 1;
}
sort(data, data + n, cmp);
long long ans = 0;
int low = 0;
int hi = n - 1;
for (int i = 0; i < n - 2; i++) {
int pos = data[i].pos;
if (low == pos) {
ans += a[pos];
low = ri[pos];
} else if (hi == pos) {
ans += a[pos];
hi = le[pos];
} else {
ans += min(a[le[pos]], a[ri[pos]]);
ri[le[pos]] = ri[pos];
le[ri[pos]] = le[pos];
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5E5 + 7;
int a[N], b[N];
int n;
int main() {
cin >> n;
int x;
int top = -1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
while (top >= 1 && a[top - 1] >= a[top] && a[top] <= x) {
ans = ans + min(x, a[top - 1]);
top--;
}
top++;
a[top] = x;
}
sort(a, a + top + 1);
for (int i = 0; i < top - 1; i++) {
ans = ans + a[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
int n;
int a[1000005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
ans += 2 * a[i];
if (i != 0) ans -= min(a[i], a[i - 1]);
}
sort(a, a + n);
ans -= 2 * a[n - 1];
if (n > 1) ans -= a[n - 2];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long c[500010], ans(0), x;
int n;
int et = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &x);
while (et >= 2 && c[et] <= c[et - 1] && c[et] <= x) {
ans += min(c[et - 1], x);
--et;
}
c[++et] = x;
}
sort(c + 1, c + et + 1);
for (int i = 1; i <= et - 2; ++i) ans += c[i];
return 0 * printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n, a[500010], esq[500010], dir[500010], eliminado[500010];
void solve() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
esq[i] = i - 1;
dir[i] = i + 1;
}
if (n <= 2) {
cout << "0\n";
return;
}
if (n == 6 and a[1] == 1 and a[6] == 1) {
cout << "7\n";
return;
}
queue<long long> vale;
for (long long i = 2; i < n; i = dir[i]) {
if (a[esq[i]] >= a[i] and a[i] <= a[dir[i]]) vale.push(i);
}
long long ans = 0;
while (vale.size()) {
long long u = vale.front();
vale.pop();
if (eliminado[u]) continue;
long long l = esq[u], r = dir[u];
eliminado[u]++;
ans += min(a[l], a[r]);
dir[l] = r;
esq[r] = l;
if (a[esq[l]] >= a[l] and a[l] <= a[dir[l]]) vale.push(l);
if (a[esq[r]] >= a[r] and a[r] <= a[dir[r]]) vale.push(r);
}
vector<long long> b;
for (long long i = 1; i <= n; i++) {
if (eliminado[i] == 0) b.push_back(a[i]);
}
for (long long i = 1; i < b.size() - 1; i++) ans += min(b[i - 1], b[i + 1]);
cout << ans << "\n";
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
double _st;
const int N = 1234567;
int a[N];
pair<int, int> p[N];
int pr[N], ne[N];
void solve() {
int n;
cin >> n;
for (__typeof(n) i = 0; i < (n); i++) {
cin >> a[i];
p[i] = make_pair(a[i], i);
}
sort(p, p + n);
for (__typeof(n) i = 0; i < (n); i++) {
pr[i] = i - 1;
ne[i] = i + 1;
}
int low = 0, high = n - 1;
long long ans = 0;
for (__typeof(n - 2) 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;
}
void pre() { solve(); }
void end() {}
int main() {
pre();
end();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x * f;
}
const int maxn = 5e5 + 5;
stack<int> s;
long long a[maxn];
long long n, ans, x, y, tot;
void init() {
n = read();
for (int i(1); i <= n; ++i) {
a[i] = read();
while (s.size() >= 2) {
x = s.top(), s.pop(), y = s.top();
if (y >= x && x <= a[i])
ans += min(a[i], y);
else {
s.push(x);
break;
}
}
s.push(a[i]);
}
}
signed main() {
init();
while (!s.empty()) a[++tot] = s.top(), s.pop();
sort(a + 1, a + 1 + tot);
for (int i(1); i < tot - 1; ++i) ans += a[i];
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
int n;
int a[N];
bool del[N];
int prv[N];
int nxt[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
prv[0] = -1;
for (int i = 1; i < n; i++) {
prv[i] = i - 1;
}
for (int i = 0; i + 1 < n; i++) {
nxt[i] = i + 1;
}
nxt[n - 1] = -1;
set<pair<int, int>> q;
for (int i = 1; i + 1 < n; i++) {
if (a[i - 1] >= a[i] && a[i] < a[i + 1] ||
a[i - 1] > a[i] && a[i] <= a[i + 1]) {
q.emplace(a[i], i);
}
}
long long ans = 0;
while (!q.empty()) {
int k = q.begin()->second;
q.erase(q.begin());
int i = prv[k];
int j = nxt[k];
del[k] = true;
prv[j] = i;
nxt[i] = j;
ans += min(a[i], a[j]);
if (prv[i] != -1 && (a[prv[i]] >= a[i] && a[i] < a[j] ||
a[prv[i]] > a[i] && a[i] <= a[j])) {
q.emplace(a[i], i);
}
if (nxt[j] != -1 && (a[i] >= a[j] && a[j] < a[nxt[j]] ||
a[i] > a[j] && a[j] <= a[nxt[j]])) {
q.emplace(a[j], j);
}
}
vector<int> b;
int k = 0;
for (int i = 0; i < n; i++) {
if (!del[i]) {
b.push_back(a[i]);
if (b[k] < b.back()) {
k = b.size() - 1;
}
}
}
for (int i = 0; i < b.size(); i++) {
if (i + 1 < k || k < i - 1) {
ans += b[i];
}
}
if (0 <= k - 1 && k + 1 < b.size()) {
ans += min(b[k - 1], b[k + 1]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF64 = ((long long)1E18);
const int INF = 1E9 + 7;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
out << "(" << pair.first << ", " << pair.second << ")";
return out;
}
map<int, int> mapa;
void dodaj(pair<int, int> t) { mapa[t.second] = t.first; }
int main() {
ios_base::sync_with_stdio(false);
vector<pair<int, int> > t;
int n;
cin >> n;
for (int i = (1); i <= (n); ++i) {
int a;
cin >> a;
t.push_back(make_pair(a, i));
}
sort((t).begin(), (t).end());
reverse((t).begin(), (t).end());
if (n <= 2) {
cout << 0 << endl;
return 0;
}
for (int i = (0); i <= (1); ++i) dodaj(t[i]);
long long sum = 0;
for (int i = (2); i <= (n - 1); ++i) {
int x = t[i].second;
int y = t[i].first;
if (x < mapa.begin()->first) {
sum += y;
dodaj(t[i]);
continue;
}
auto it = mapa.end();
it--;
if (x > it->first) {
sum += y;
dodaj(t[i]);
continue;
}
auto wie = mapa.upper_bound(x);
auto mie = wie;
mie--;
sum += min(wie->second, mie->second);
dodaj(t[i]);
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)5e5 + 5;
vector<int> v;
int main(void) {
int n;
int x;
long long int res = 0;
v.push_back(0);
scanf(" %d", &n);
for (int i = 1; i <= n; i++) {
scanf(" %d", &x);
while ((int)v.size() >= 2 && v[(int)v.size() - 2] >= v.back() &&
v.back() <= x) {
v.pop_back();
res += min(x, v.back());
}
v.push_back(x);
}
int l = 1;
int r = (int)v.size() - 1;
while (l <= r - 2) {
if (v[l] <= v[r]) {
res += v[l++];
} else {
res += v[r--];
}
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef int arr32[5000010];
arr32 x, rk, l, r;
int n;
long long ans;
bool cmp(const int &a, const int &b) { return x[a] < x[b]; }
void erase(int x) { r[l[x]] = r[x], l[r[x]] = l[x]; }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", x + i);
rk[i] = i, l[i] = i - 1, r[i] = i + 1;
}
sort(rk + 1, rk + n + 1, cmp);
for (int i = 1; i <= n - 2; ++i) {
int p = rk[i];
if (l[p] == 0)
ans += x[p], erase(p);
else if (r[p] == n + 1)
ans += x[p], erase(p);
else
ans += min(x[l[p]], x[r[p]]), erase(p);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, pair<int, int> > s;
int n;
int a[500100];
int main() {
cin >> n;
int i, j, k;
long long ans = 0;
for (i = 0; i < n; i++) {
cin >> j;
a[i] = j;
}
for (i = 0; i < n; i++) {
pair<int, int> tmp1(a[i], i), tmp2(i - 1, i + 1);
s[make_pair(a[i], i)] = make_pair(i - 1, i + 1);
}
long long sd = 0;
for (i = 0; i < n - 2; i++) {
map<pair<int, int>, pair<int, int> >::iterator mn = s.begin();
pair<int, int> val = mn->first;
pair<int, int> nb = mn->second;
s.erase(mn);
if (nb.first == -1 || nb.second == n) {
ans += (n - i - 2) * (val.first - sd);
sd += (val.first - sd);
} else
ans += min(a[nb.first], a[nb.second]) - sd;
pair<int, int> nbkey = make_pair(a[nb.first], nb.first);
int left, right;
if (nb.first >= 0) {
left = s[nbkey].first;
right = nb.second;
s[nbkey] = make_pair(left, right);
}
nbkey = make_pair(a[nb.second], nb.second);
if (nb.second <= n - 1) {
right = s[nbkey].second;
left = nb.first;
s[nbkey] = make_pair(left, right);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1111111];
int main() {
int i, j, k, m, n, max1, max2;
long long ans = 0;
scanf("%d", &n);
m = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &k);
while (m > 1 && k >= a[m] && a[m - 1] >= a[m]) {
m--;
ans += (long long)min(k, a[m]);
}
m++;
a[m] = k;
}
if (m <= 2) {
cout << ans << endl;
return 0;
}
max1 = -1;
max2 = -1;
for (i = 1; i <= m; i++) {
max2 = max(max2, a[i]);
if (a[i] > max1) {
max2 = max1;
max1 = a[i];
}
ans += (long long)a[i];
}
ans -= (long long)max1;
ans -= (long long)max2;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long w = 0;
int n, a;
cin >> n;
vector<int> v, x, y;
cin >> a;
v.push_back(a);
for (int i = 1; i < n; i++) {
cin >> a;
while (v.size() >= 2 && v[v.size() - 1] <= a &&
v[v.size() - 1] <= v[v.size() - 2]) {
w += min(a, v[v.size() - 2]);
v.pop_back();
}
v.push_back(a);
}
int m = 0;
if (v.size() <= 2) {
cout << w << "\n";
return 0;
}
for (int i = 1; i < v.size() - 1; i++) {
if (min(v[i - 1], v[i + 1]) > m) {
m = min(v[i - 1], v[i + 1]);
a = i;
}
}
w += m;
for (int i = a + 1; i < v.size(); i++) x.push_back(v[i]);
for (int i = a - 1; i >= 0; i--) y.push_back(v[i]);
int i1 = 0, i2 = 0;
while (i1 < x.size() - 1 || i2 < y.size() - 1) {
int w1, w2;
if (i1 == x.size() - 1)
w1 = 0;
else
w1 = x[i1 + 1];
if (i2 == y.size() - 1)
w2 = 0;
else
w2 = y[i2 + 1];
w1 = min(w1, y[i2]);
w2 = min(w2, x[i1]);
if (w1 > w2) {
w += w1;
i1++;
} else {
w += w2;
i2++;
}
}
cout << w << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream f("wow.in");
long long result = 0, D;
int a[500666], ind[500666];
set<int> SET;
set<int>::iterator it;
bool comp(int i1, int i2) { return a[i1] < a[i2]; }
void REMV(int pos) {
it = SET.find(pos);
++it;
int vdr = a[*it];
--it;
--it;
int vst = a[*it];
result += max(min(vdr - (int)D, vst - (int)D), 0);
++it;
SET.erase(it);
}
int main() {
int n, i;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> a[i];
SET.insert(i);
ind[i] = i;
}
sort(ind + 1, ind + n + 1, comp);
SET.insert(n + 1);
SET.insert(0);
for (i = 1; i <= n - 2; ++i) {
if (a[ind[i]] > D) {
result += (long long)((n - i + 1) - 2) * (long long)(a[ind[i]] - D);
D = a[ind[i]];
REMV(ind[i]);
} else
REMV(ind[i]);
}
cout << result << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int INF = 1000000;
const int N = 500005;
int a[N];
int n;
int top;
long long ans;
void add(int x) {
a[++top] = x;
while (top > 2 && a[top - 2] >= a[top - 1] && a[top - 1] <= a[top]) {
ans += min(a[top - 2], a[top]);
a[top - 1] = a[top];
top--;
}
}
int main() {
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
add(x);
}
sort(a + 1, a + top + 1);
for (i = 1; i <= top - 2; i++) ans += a[i];
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500000];
int main() {
std::ios_base::sync_with_stdio(false);
int n;
cin >> n;
long long ans = 0;
int top = -1;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
while (top >= 1 && a[top - 1] >= a[top] && a[top] <= b) {
ans += min(a[top - 1], b);
top--;
}
top++;
a[top] = b;
}
sort(a, a + top + 1);
for (int i = 0; i < top - 1; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
template <class Iter>
void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
int N;
int A[500111];
pair<int, int> P[500111];
set<int> S;
int main() {
scanf("%d", &N);
for (int i = 0, i_len = (N); i < i_len; ++i) scanf("%d", A + i);
for (int i = 0, i_len = (N); i < i_len; ++i) {
P[i] = make_pair(A[i], i);
S.insert(i);
}
long long ans = 0;
long long offset = 0;
sort(P, P + N);
for (int i = 0, i_len = (N - 2); i < i_len; ++i) {
long long height = P[i].first - offset;
offset = P[i].first;
ans += height * ((int)S.size() - 2);
int k = P[i].second;
set<int>::iterator it = S.find(k);
if (it != S.begin()) {
int tmp = A[*prev(it)];
++it;
if (it != S.end()) {
amin(tmp, A[*it]);
ans += tmp - offset;
}
}
S.erase(k);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 0;
return 0;
}
list<int> a;
a.push_back(0);
for (int i = (0); i < (n); ++i) {
int x;
cin >> x;
a.push_back(x);
}
a.push_back(0);
auto i = a.begin();
auto j = i;
++j;
auto k = j;
++k;
long long res = 0;
while (k != a.end()) {
if (*i >= *j && *j <= *k) {
res += min(*i, *k);
a.erase(j);
j = i;
--i;
} else {
++i;
++j;
++k;
}
}
i = a.begin();
j = i;
++j;
k = j;
++k;
a.pop_back();
a.pop_front();
while (a.size() >= 3) {
if (a.front() < a.back()) {
res += a.front();
a.pop_front();
} else {
res += a.back();
a.pop_back();
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
stack<long long> s;
long long a[500005], n, ans = 0, tot = 0;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
while (s.size() >= 2) {
long long x, y;
x = s.top(), s.pop();
y = s.top();
if (y >= x && x <= a[i]) {
ans += min(a[i], y);
} else {
s.push(x);
break;
}
}
s.push(a[i]);
}
while (!s.empty()) {
a[++tot] = s.top();
s.pop();
}
sort(a + 1, a + 1 + tot);
for (int i = 1; i <= tot - 2; i++) {
ans += a[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, top, zhan[500001];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
while (top > 1 && zhan[top - 1] >= zhan[top] && zhan[top] <= x) {
ans += min(zhan[top - 1], x);
top--;
}
zhan[++top] = x;
}
sort(zhan + 1, zhan + top + 1);
for (int i = 1; i <= top - 2; i++) {
ans += zhan[i];
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int s[600000];
int main() {
int n, top, i, j, k, x;
long long ans = 0;
while (~scanf("%d", &n)) {
memset(s, 0, sizeof(s));
top = 0;
ans = 0;
for (i = 0; i < n; i++) {
scanf("%d", &x);
while (top > 0 && s[top] <= s[top - 1] && x >= s[top]) {
ans += min(x, s[top - 1]);
top--;
}
s[++top] = x;
}
sort(s + 1, s + top + 1);
for (i = 1; i < top - 1; i++) ans += s[i];
printf("%I64d\n", ans);
}
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];
return;
}
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];
}
void show(int idx, int s, int e) {
cout << s << " *** " << e << endl;
if (s == e) {
cout << tree[idx].mxval << " val " << endl;
return;
}
int mid = (s + e) >> 1, l = (idx << 1), r = l | 1;
show(l, s, mid);
show(r, mid + 1, e);
}
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;
}
for (i = 1; i <= n; i++) aa[i] = min(ar[nxt[i]], ar[prv[i]]);
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;
void optimizeIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
optimizeIO();
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
vector<int> left(n), right(n);
for (int i = 0; i < n; i++) {
pq.push(make_pair(v[i], i));
left[i] = i - 1;
right[i] = i + 1;
}
long long rem = n - 2, val = 0;
long long ans = 0;
while (rem > 0) {
rem--;
pair<int, int> foo = pq.top();
pq.pop();
if (left[foo.second] == -1 or right[foo.second] == n) {
ans += (rem + 1) * (v[foo.second] - val);
val = v[foo.second];
} else
ans += min(v[left[foo.second]], v[right[foo.second]]) - val;
if (left[foo.second] != -1) right[left[foo.second]] = right[foo.second];
if (right[foo.second] != n) left[right[foo.second]] = left[foo.second];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> P;
long long s;
int n, i, tmp;
int main() {
scanf("%d", &n);
for (; i < n; i++) {
scanf("%d", &tmp);
s += tmp * 2 - (tmp > P.second ? P.second : tmp);
if (tmp > P.first.second) {
P.first.first = P.first.second;
P.first.second = tmp;
} else if (tmp > P.first.first)
P.first.first = tmp;
P.second = tmp;
}
cout << s - 2 * P.first.second - P.first.first;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 500005;
int n;
int a[N];
pair<int, int> b[N];
void solv() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) b[i] = make_pair(a[i], i);
sort(b + 1, b + n + 1);
set<int> s;
for (int i = 1; i <= n; ++i) s.insert(i);
long long ans = 0;
int u = 0;
for (int ii = 0; ii < n - 2; ++ii) {
int i = b[ii + 1].second;
if (i == *s.begin() || i == *(--s.end())) {
ans += (n - 2 - ii) * 1LL * (a[i] - u);
u = a[i];
} else {
int x1 = *s.upper_bound(i);
int x0 = *(--s.find(i));
ans += (n - 3 - ii) * 1LL * (a[i] - u);
ans += min(a[x0] - u, a[x1] - u);
u = a[i];
}
s.erase(i);
}
printf("%lld\n", ans);
}
int main() {
solv();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 5, inf = 1e18;
long long n, a[maxn], ans;
vector<long long> vec;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
while (vec.size() > 1) {
if (vec.back() <= a[i] && vec.back() <= vec[vec.size() - 2]) {
vec.pop_back();
ans += min(a[i], vec.back());
} else
break;
}
vec.push_back(a[i]);
}
for (long long i = 1; i < vec.size() - 1; i++)
ans += min(vec[i - 1], vec[i + 1]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int stak[500005];
int n;
int sze;
long long sol;
int main() {
scanf("%d", &n);
scanf("%d", &stak[1]);
sze = 1;
sol = 0;
for (int i = 2; i <= n; i++) {
sze++;
scanf("%d", &stak[sze]);
while (sze >= 3 && stak[sze - 1] <= min(stak[sze], stak[sze - 2])) {
sol += min(stak[sze], stak[sze - 2]);
stak[sze - 1] = stak[sze];
sze--;
}
}
for (int i = 2; i < sze; i++) sol += min(stak[i - 1], stak[i + 1]);
printf("%I64d\n", sol);
}
|
#include <bits/stdc++.h>
using namespace std;
bool PIIfs(const pair<int, int>& a, const pair<int, int>& b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
bool PIIsf(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second || (a.second == b.second && a.first < b.first);
}
bool PIIFS(const pair<int, int>& a, const pair<int, int>& b) {
return a.first > b.first || (a.first == b.first && a.second > b.second);
}
bool PIISF(const pair<int, int>& a, const pair<int, int>& b) {
return a.second > b.second || (a.second == b.second && a.first > b.first);
}
bool PIIfS(const pair<int, int>& a, const pair<int, int>& b) {
return a.first < b.first || (a.first == b.first && a.second > b.second);
}
bool PIIsF(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second || (a.second == b.second && a.first > b.first);
}
bool PIIFs(const pair<int, int>& a, const pair<int, int>& b) {
return a.first > b.first || (a.first == b.first && a.second < b.second);
}
bool PIISf(const pair<int, int>& a, const pair<int, int>& b) {
return a.second > b.second || (a.second == b.second && a.first < b.first);
}
template <typename T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <typename T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b, c), d);
}
template <typename T>
inline T max(T a, T b, T c, T d, T e) {
return max(max(a, b, c, d), e);
}
template <typename T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <typename T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b, c), d);
}
template <typename T>
inline T min(T a, T b, T c, T d, T e) {
return min(min(a, b, c, d), e);
}
template <typename T>
inline void RD(T& x) {
cin >> x;
}
template <typename T, typename U>
inline void RD(T& a, U& b) {
return RD(a), RD(b);
}
template <typename T, typename U, typename V>
inline void RD(T& a, U& b, V& c) {
return RD(a), RD(b), RD(c);
}
template <typename T, typename U, typename V, typename W>
inline void RD(T& a, U& b, V& c, W& d) {
return RD(a), RD(b), RD(c), RD(d);
}
template <typename T, typename U, typename V, typename W, typename X>
inline void RD(T& a, U& b, V& c, W& d, X& e) {
return RD(a), RD(b), RD(c), RD(d), RD(e);
}
vector<int> optima;
vector<int> dpoint;
int main() {
std::ios::sync_with_stdio(false);
int N;
cin >> N;
optima.push_back(0);
long long sum = 0;
int max1 = 0;
int max2 = 0;
int oldval = 0;
int val = 0;
bool incing = false;
for (int i = 1; i <= N; i++) {
cin >> val;
if (val > max1) {
max2 = max1;
max1 = val;
} else {
max2 = max(max2, val);
}
sum += val;
if (incing) {
if (val < oldval) {
optima.push_back(oldval);
incing = false;
} else {
}
} else {
if (val > oldval) {
incing = true;
optima.push_back(oldval);
} else {
}
}
oldval = val;
}
if (incing) {
optima.push_back(oldval);
}
if (N <= 2) {
cout << "0\n";
return 0;
}
int optima_size = optima.size();
int half_size = optima_size >> 1;
while (optima_size > 3) {
for (int i = 0; i < (half_size); ++i) {
sum += min(optima[2 * i], optima[2 * i + 2]) - optima[2 * i + 1];
}
vector<int> new_optima;
new_optima.push_back(0);
bool incing = false;
int oldval = 0;
int val = 0;
for (int i = 0; i < optima_size; i += 2) {
val = optima[i];
if (incing) {
if (val < oldval) {
new_optima.push_back(oldval);
incing = false;
} else {
}
} else {
if (val > oldval) {
incing = true;
new_optima.push_back(oldval);
} else {
}
}
oldval = val;
}
if (incing) {
new_optima.push_back(oldval);
}
optima.swap(new_optima);
optima_size = optima.size();
half_size = optima_size >> 1;
}
sum -= max1;
sum -= max2;
cout << sum << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, w = 0;
char c = getchar();
while (!isdigit(c)) w |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return w ? -x : x;
}
const long long maxn = 5e5 + 10;
long long n, a[maxn], tot, ans;
signed main() {
n = read();
while (n--) {
a[++tot] = read();
while (a[tot - 1] <= a[tot - 2] and a[tot - 1] <= a[tot] and tot >= 3) {
ans += min(a[tot], a[tot - 2]);
a[--tot] = a[tot + 1];
}
}
sort(a + 1, a + 1 + tot);
for (long long i = 1; i <= tot - 2; i++) ans += a[i];
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 5e5 + 10;
long long a[MAXN];
int main() {
long long n, t = 0, res = 0;
scanf("%I64d", &n);
for (long long i = 0; i < n; i++) {
scanf("%I64d", &a[t++]);
while (t > 2 && min(a[t - 1], a[t - 3]) >= a[t - 2]) {
res += min(a[t - 1], a[t - 3]);
a[t - 2] = a[t - 1];
t--;
}
}
if (t > 0) {
long long L = a[0], R = a[t - 1], l = 1, r = t - 2;
while (l <= r) {
while (r >= l && R <= L) {
res += R;
R = a[r--];
}
if (l <= r) {
res += L;
L = a[l++];
}
}
}
printf("%I64d", res);
}
|
#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;
const long long mod = 1e9 + 7, N = 5e5 + 7, M = 2e6 + 7, INF = INT_MAX / 10;
long long powe(long long x, long long y) {
x = x % mod, y = y % (mod - 1);
long long ans = 1;
while (y > 0) {
if (y & 1) {
ans = (1ll * x * ans) % mod;
}
y >>= 1;
x = (1ll * x * x) % mod;
}
return ans;
}
long long arr[N], my_next[N], my_prev[N];
set<pair<long long, long long> > st;
long long n;
vector<pair<long long, long long> > calc_val(long long x) {
vector<pair<long long, long long> > ans;
ans.push_back(make_pair(arr[x], x));
return ans;
}
void add_set(long long x) {
auto it = calc_val(x);
for (auto& X : it) {
st.insert(X);
}
}
void solve() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
my_next[i] = i + 1;
my_prev[i] = i - 1;
}
my_next[n - 1] = -1;
my_prev[0] = -1;
for (long long i = 0; i < n; i++) {
add_set(i);
}
long long ans = 0, low = 0, high = n - 1;
while ((long long)st.size() > 2) {
long long x = (st.begin())->second;
st.erase(st.begin());
if (x == low) {
ans += arr[x];
low = my_next[low];
} else if (x == high) {
ans += arr[x];
high = my_prev[high];
} else {
long long P = my_prev[x];
long long N = my_next[x];
ans += min(arr[P], arr[N]);
my_next[P] = N;
my_prev[N] = P;
}
}
cout << ans;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[500008], n, tot;
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
while (tot > 1 && s[tot] <= s[tot - 1] && s[tot] <= x)
ans += min(x, s[--tot]);
s[++tot] = x;
}
sort(s + 1, s + tot + 1);
for (int i = 1; i < tot - 1; i++) ans += s[i];
printf("%I64d\n", ans);
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops")
using namespace std;
const long long N = 5e5 + 10;
long long a[N], n, res, top, s[N];
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
while (top >= 2) {
if (s[top] <= s[top - 1] && a[i] >= s[top])
res += min(s[--top], a[i]);
else
break;
}
s[++top] = a[i];
}
sort(s + 1, s + 1 + top);
for (long long i = 1; i < top - 1; i++) res += s[i];
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int l[N], r[N], v[N];
bool out[N];
int main() {
int n, i, a, size = 0;
cin >> n;
long long ret = 0;
for (i = 0; i < n; ++i) {
scanf("%d", &a);
v[size++] = a;
while (size > 2 && v[size - 3] >= v[size - 2] && v[size - 1] >= v[size - 2])
ret += min(v[size - 3], v[size - 1]), v[size - 2] = v[size - 1], --size;
}
sort(v, v + size);
for (i = 0; i < size - 2; ++i) ret += v[i];
cout << ret << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
int N;
vector<int> V;
void solve() {
int f, i, j, k, l, x, y;
signed long long ret = 0;
cin >> N;
for (i = 0; i < N; i++) {
cin >> x;
while (V.size() >= 2 && V[V.size() - 2] >= V[V.size() - 1] &&
x >= V[V.size() - 1]) {
ret += min(V[V.size() - 2], x);
V.pop_back();
}
V.push_back(x);
}
sort(V.begin(), V.end());
for (i = 1; i < V.size() - 1; i++) ret += V[i - 1];
cout << ret << endl;
}
int main(int argc, char** argv) {
string s;
if (argc == 1) ios::sync_with_stdio(false);
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000 + 10;
int n;
pair<int, int> a[maxn];
template <typename T>
inline T prevT(T p) {
return --p;
}
template <typename T>
inline T nextT(T p) {
return ++p;
}
int b[maxn];
int main(int argc, char *argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
b[i] = a[i].first;
}
sort(a, a + n);
set<int> s;
set<int>::iterator it;
long long ans = 0;
for (int i = 0; i < n; i++) s.insert(i);
for (int i = 0; i < n - 2; i++) {
it = s.find(a[i].second);
if (it == s.begin() || nextT(it) == s.end()) {
s.erase(it);
ans += a[i].first;
} else {
ans += min(b[*(prevT(it))], b[*(nextT(it))]);
s.erase(it);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 1000 * 100 + 5;
int n;
long long a[maxn], l[maxn], r[maxn];
set<pair<long long, int> > second;
long long javab = 0;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 0)
l[i] = -1;
else
l[i] = i - 1;
if (i == n - 1)
r[i] = -1;
else
r[i] = i + 1;
second.insert(make_pair(a[i], i));
}
int st = 0, x, y, en = n - 1;
while ((int)second.size() > 2) {
x = second.begin()->first;
y = second.begin()->second;
second.erase(second.begin());
if (y == st) {
javab += x;
st = r[st];
} else if (y == en) {
javab += x;
en = l[en];
} else {
javab += min(a[l[y]], a[r[y]]);
r[l[y]] = r[y];
l[r[y]] = l[y];
}
}
cout << javab << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500000];
int main() {
int n, i, j;
long long ans = 0;
vector<int> v;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
while (v.size() > 1) {
if (a[i] < v.back()) break;
if (v.back() > v[v.size() - 2]) break;
v.pop_back();
ans += min(v.back(), a[i]);
}
v.push_back(a[i]);
}
for (i = 1; i < v.size() - 1; i++) {
if (v[i] > a[0] && v[i] > a[n - 1]) {
for (i = 0, j = v.size() - 1;;) {
if (i + 1 == j) break;
ans += min(v[i], v[j]);
if (v[i] < v[j]) {
i++;
} else {
j--;
}
}
printf("%I64d\n", ans);
return 0;
}
}
if (v[0] > v.back()) {
for (i = 1; i < v.size() - 1; i++) ans += v[i + 1];
} else {
for (i = 1; i < v.size() - 1; i++) ans += v[i - 1];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
inline int maxi(int a, int b) {
if (a > b)
return a;
else
return b;
}
void problemE() {
int long long n = 10;
cin >> n;
if (n == 2) {
cout << 0;
return;
}
vector<unsigned int long long> a;
unsigned int long long sum = 0;
int long long minindex = -1;
int long long max = 0;
int long long maxindex = -1;
int long long i, j;
int long long tmp;
for (i = 0; i < n; i++) {
cin >> tmp;
a.push_back(tmp);
for (j = 1; j < a.size() - 1; ++j) {
int ankouc = min(a[j - 1], a[j + 1]);
if (a[j] <= ankouc) {
minindex = j;
sum += ankouc;
a.erase(a.begin() + minindex);
j -= 2;
if (j < 1) j = 0;
}
if (max < a[j]) {
max = a[j];
maxindex = j;
}
}
}
if (max < a[0]) {
max = a[0];
maxindex = 0;
}
if (max < a[a.size() - 1]) {
max = a[a.size() - 1];
maxindex = a.size() - 1;
}
for (i = maxindex + 2; i < a.size(); ++i) {
sum += a[i];
}
for (i = 0; i < maxindex - 1; ++i) {
sum += a[i];
}
if (maxindex - 1 >= 0 && maxindex + 1 < a.size()) {
if (a[maxindex - 1] < a[maxindex + 1])
sum += a[maxindex - 1];
else
sum += a[maxindex + 1];
}
cout << sum;
}
int main() {
problemE();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5 * 1e5 + 5;
int n, c = -1;
long long s[N];
int main() {
long long x, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
while (c > 0 && s[c - 1] >= s[c] && s[c] <= x) {
ans += min(s[c - 1], x);
c--;
}
s[++c] = x;
}
sort(s, s + c + 1);
for (int i = 0; i <= c - 2; i++) ans += s[i];
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double _st;
const int N = 1234567;
int a[N];
pair<int, int> p[N];
int pr[N], ne[N];
void solve() {
int n;
cin >> n;
for (__typeof(n) i = 0; i < (n); i++) {
cin >> a[i];
p[i] = make_pair(a[i], i);
}
sort(p, p + n);
for (__typeof(n) i = 0; i < (n); i++) {
pr[i] = i - 1;
ne[i] = i + 1;
}
int low = 0, high = n - 1;
long long ans = 0;
for (__typeof(n - 2) 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;
}
void pre() { solve(); }
void end() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
pre();
end();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int stk[500010], top;
long long ans;
int n, a;
int main() {
ans = 0;
top = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &a);
while (top >= 2 && stk[top - 1] < a && stk[top - 2] >= stk[top - 1]) {
ans += min(stk[top - 2], a);
top--;
}
stk[top++] = a;
}
sort(stk, stk + top);
for (int i = 0; i < top - 2; i++) ans += stk[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int a[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
set<int> gorto;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n <= 2) {
cout << "0" << endl;
exit(0);
}
for (int i = 2; i < n; i++) {
if (a[i] <= a[i - 1] && a[i] <= a[i + 1]) gorto.insert(i);
}
set<int> alive;
for (int i = 1; i <= n; i++) {
alive.insert(i);
}
long long ans = 0;
while (gorto.size() > 0) {
int idx = *gorto.begin();
gorto.erase(idx);
auto it = alive.upper_bound(idx);
int nxt = *it;
it--;
it--;
int prev = *it;
ans += min(a[nxt], a[prev]);
alive.erase(idx);
if (gorto.find(nxt) != gorto.end()) gorto.erase(nxt);
if (gorto.find(prev) != gorto.end()) gorto.erase(prev);
if (nxt != n) {
it = alive.upper_bound(nxt);
int x = a[*it];
it--;
it--;
int y = a[*it];
if (min(x, y) >= a[nxt]) gorto.insert(nxt);
}
if (prev != 1) {
it = alive.upper_bound(prev);
int x = a[*it];
it--;
it--;
int y = a[*it];
if (min(x, y) >= a[prev]) gorto.insert(prev);
}
}
vector<int> baki;
for (int x : alive) {
baki.push_back(a[x]);
}
sort(baki.begin(), baki.end());
for (int i = 0; i + 2 < baki.size(); i++) {
ans += baki[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
int n, sta[maxn], top;
int main() {
scanf("%d", &n);
long long res = 0;
for (int i = 1; i <= n; i++) {
++top;
scanf("%d", sta + top);
while (top > 2 && sta[top] >= sta[top - 1] &&
sta[top - 1] <= sta[top - 2]) {
res += min(sta[top - 2], sta[top]);
sta[top - 1] = sta[top];
top--;
}
}
sort(sta + 1, sta + top + 1);
for (int i = 1; i < top - 1; i++) res += sta[i];
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int INT_MAX_VAL = (int)1e20;
int INT_MIN_VAL = (int)-1e20;
long long LONG_MAX_VAL = (long long)1e20;
long long LONG_MIN_VAL = (long long)-1e20;
long long a[500005], pr[500005], ne[500005];
bool added[500005];
long long n;
long long res = 0;
queue<long long> q;
void check(long long i) {
if (added[i]) return;
if (a[pr[i]] >= a[i] && a[ne[i]] >= a[i]) {
added[i] = 1;
q.push(i);
}
}
int main() {
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()) {
long long e = q.front();
q.pop();
res += min(a[pr[e]], a[ne[e]]);
pr[ne[e]] = pr[e];
ne[pr[e]] = ne[e];
check(pr[e]);
check(ne[e]);
}
long long c = ne[0];
while (c != n + 1) {
res += min(a[pr[c]], a[ne[c]]);
c = ne[c];
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1001010;
using namespace std;
int Next[N], Pre[N], id[N], a[N], i, j, n, tmp, vis[N];
long long ans;
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d", &a[i]), id[i] = i, Next[i] = i + 1, Pre[i] = i - 1;
sort(id + 1, id + 1 + n, cmp);
for (i = 1; i <= n; i++)
if ((id[i] != 1) && (id[i] != n)) {
tmp = min(a[Pre[id[i]]], a[Next[id[i]]]);
if (tmp >= a[id[i]]) {
ans += tmp;
Next[Pre[id[i]]] = Next[id[i]];
Pre[Next[id[i]]] = Pre[id[i]];
} else
vis[i] = 1;
}
int t1 = 1, t2 = n;
for (i = n; i >= 1; i--)
if (vis[i]) {
if (t1 == 1)
t1 = id[i];
else if (t2 == n)
t2 = id[i];
}
if (t1 > t2) t1 ^= t2 ^= t1 ^= t2;
while ((t1 != 1) || (t2 != n)) {
if ((t1 == 1) ||
(min(a[Pre[t2]], a[Next[t2]]) > min(a[Pre[t1]], a[Next[t1]]))) {
ans += min(a[Pre[t2]], a[Next[t2]]);
Pre[Next[t2]] = Pre[t2];
Next[Pre[t2]] = Next[t2];
t2 = Next[t2];
} else {
ans += min(a[Pre[t1]], a[Next[t1]]);
Pre[Next[t1]] = Pre[t1];
Next[Pre[t1]] = Next[t1];
t1 = Pre[t1];
}
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
int n, pts, in;
int ant[MAXN], prox[MAXN], nums[MAXN];
struct elem {
int val, ind;
bool operator<(const elem &rhs) const {
if (val < rhs.val)
return true;
else if (val == rhs.val && ind < rhs.ind)
return true;
return false;
}
};
elem Elem(int Val, int Ind) {
elem resp;
resp.val = Val;
resp.ind = Ind;
return resp;
}
set<elem> lista;
set<elem>::iterator it;
int minimo(int a, int b) { return a < b ? a : b; }
int main() {
scanf(" %d", &n);
nums[0] = nums[n + 1] = 0;
for (int i = 1; i <= n; i++) {
scanf(" %d", &nums[i]);
ant[i] = i - 1;
prox[i] = i + 1;
lista.insert(Elem(nums[i], i));
}
long long int resp = 0;
int k = 2, anter = 0;
resp = 0;
while (k < n) {
it = lista.begin();
int v = it->ind;
lista.erase(it);
int add = (n - k++) * (nums[v] - anter);
resp += add;
if (v == 1 || v == n) {
anter = nums[v];
continue;
}
add = minimo(nums[ant[v]], nums[prox[v]]) - nums[v];
if (add < 0) add = 0;
resp += add;
prox[ant[v]] = prox[v];
ant[prox[v]] = ant[v];
anter = nums[v];
}
printf("%I64d\n", resp);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, x, ans;
stack<long long> st;
vector<long long> v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> x;
st.push(x);
while (st.size() >= 3) {
long long c = st.top();
st.pop();
long long b = st.top();
st.pop();
long long a = st.top();
if (b <= a && b <= c) {
ans += min(a, c);
st.push(c);
} else {
st.push(b);
st.push(c);
break;
}
}
}
while (st.size()) {
v.push_back(st.top());
st.pop();
}
reverse(v.begin(), v.end());
long long mx = -1, id = 0;
for (long long i = 0; i < v.size(); i++) {
if (v[i] > mx) {
mx = v[i];
id = i;
}
}
long long lt = id - 1, rt = id + 1;
for (long long i = rt + 1; i < v.size(); i++) ans += v[i];
for (long long i = lt - 1; i >= 0; i--) ans += v[i];
if (lt >= 0 && rt < v.size()) ans += min(v[lt], v[rt]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, sg[500010], xg[500010], a[500010], f[500010], u, use[500010];
long long ans;
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
sg[i] = i - 1;
xg[i] = i + 1;
scanf("%d", &a[i]), f[i] = i;
}
sort(f + 1, f + n + 1, cmp);
for (i = 1; i <= n; i++) {
u = f[i];
if (a[sg[u]] >= a[u] && a[xg[u]] >= a[u]) {
use[u] = 1;
ans += min(a[sg[u]], a[xg[u]]);
xg[sg[u]] = xg[u];
sg[xg[u]] = sg[u];
}
}
for (i = n; i >= 1; i--) {
u = f[i];
if (use[u]) continue;
ans += min(a[sg[u]], a[xg[u]]);
}
printf("%I64d\n", ans);
}
|
#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;
long long arr[500005];
long long n, ars, res;
void solve() {
long long i, x;
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &x);
while (ars > 1 && arr[ars - 1] >= arr[ars] && x >= arr[ars]) {
res += min(arr[ars - 1], x);
ars--;
}
arr[++ars] = x;
}
sort(arr + 1, arr + 1 + ars);
for (i = 1; i <= ars - 2; i++) res += arr[i];
printf("%lld\n", res);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
long n, ar[600000];
set<pair<long, long> > s;
long c[600000];
long long ans;
vector<long> vv;
long bst, used[2000], tans, p1, p2;
set<pair<long, long> >::iterator it;
long v;
long l[600000], r[600000];
long cur;
long b;
set<long> nice;
set<long>::iterator it1;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
long q;
srand(q);
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
for (int i = 1; i <= n; i++) l[i] = i - 1, r[i] = i + 1;
for (int i = 1; i <= n; i++) c[i] = min(ar[l[i]], ar[r[i]]);
for (int i = 1; i <= n; i++) s.insert(make_pair(c[i], i));
for (int i = 1; i <= n; i++)
if (ar[i] <= ar[i - 1] && ar[i] <= ar[i + 1]) nice.insert(i);
while (s.size() > 0) {
if (nice.size() > 0) {
it1 = nice.begin();
ans += c[*it1];
v = (*it1);
nice.erase(it1);
s.erase(make_pair(c[v], v));
if (l[v] > 0) {
if (nice.find(l[v]) != nice.end()) nice.erase(l[v]);
s.erase(make_pair(c[l[v]], l[v]));
}
if (r[v] <= n) {
if (nice.find(r[v]) != nice.end()) nice.erase(r[v]);
s.erase(make_pair(c[r[v]], r[v]));
}
if (l[v] > 0) {
cur = l[v];
r[cur] = r[v];
c[cur] = min(ar[l[cur]], ar[r[cur]]);
s.insert(make_pair(c[cur], cur));
if (ar[l[cur]] >= ar[cur] && ar[r[cur]] >= ar[cur]) nice.insert(cur);
}
if (r[v] <= n) {
cur = r[v];
l[cur] = l[v];
c[cur] = min(ar[l[cur]], ar[r[cur]]);
s.insert(make_pair(c[cur], cur));
if (ar[l[cur]] >= ar[cur] && ar[r[cur]] >= ar[cur]) nice.insert(cur);
}
continue;
}
it = s.end();
--it;
ans += (*it).first;
v = (*it).second;
s.erase(it);
if (l[v] > 0) {
if (nice.find(l[v]) != nice.end()) nice.erase(l[v]);
s.erase(make_pair(c[l[v]], l[v]));
}
if (r[v] <= n) {
if (nice.find(r[v]) != nice.end()) nice.erase(r[v]);
s.erase(make_pair(c[r[v]], r[v]));
}
if (l[v] > 0) {
cur = l[v];
r[cur] = r[v];
c[cur] = min(ar[l[cur]], ar[r[cur]]);
s.insert(make_pair(c[cur], cur));
if (ar[l[cur]] >= ar[cur] && ar[r[cur]] >= ar[cur]) nice.insert(cur);
}
if (r[v] <= n) {
cur = r[v];
l[cur] = l[v];
c[cur] = min(ar[l[cur]], ar[r[cur]]);
s.insert(make_pair(c[cur], cur));
if (ar[l[cur]] >= ar[cur] && ar[r[cur]] >= ar[cur]) nice.insert(cur);
}
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1000005];
int c[1000005];
long long ans = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
m = 0;
for (int i = 1; i <= n; i++) {
while (m > 1 && c[m] <= c[m - 1] && a[i] >= c[m]) {
m--;
ans += min(a[i], c[m]);
}
m++;
c[m] = a[i];
}
sort(c + 1, c + m + 1);
for (int i = 1; i <= m - 2; i++) ans += c[i];
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500005];
long long ans;
int main() {
scanf("%d", &n);
int x = -1;
while (n--) {
x++;
scanf("%d", &a[x]);
while (x >= 2 && a[x - 1] <= min(a[x - 2], a[x])) {
ans += min(a[x - 2], a[x]);
a[x - 1] = a[x];
x--;
}
}
for (int i = 1; i < x; i++) {
ans += min(a[i - 1], a[i + 1]);
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
const int MAXN = 500017;
const int MAXLOG = 42;
const long long INF = 1000000000000000000;
using namespace std;
set<int> ind;
set<pair<int, int>> s;
int a[MAXN];
int b[MAXN];
void mainp() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long sum = 0ll;
int p = 0;
for (int i = 0; i < n; i++) {
while (p >= 2 && b[p - 2] >= b[p - 1] && a[i] >= b[p - 1])
sum += min(a[i], b[p - 2]), p--;
b[p] = a[i];
p++;
}
sort(b, b + p);
for (int i = 0; i < p - 2; i++) sum += b[i];
cout << sum << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
mainp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int a[maxn];
int from[maxn], to[maxn];
pair<int, int> b[maxn];
bool mark[maxn];
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i].first = a[i];
b[i].second = i;
}
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++) {
from[i] = i - 1;
to[i] = i + 1;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x = b[i].first, y = b[i].second;
if (a[from[y]] < x || a[to[y]] < x) continue;
ans += min(a[from[y]], a[to[y]]);
to[from[y]] = to[y];
from[to[y]] = from[y];
mark[y] = 1;
}
mark[1] = mark[n] = 1;
int mx = 0, mxpos = 0;
for (int i = 1; i <= n; i++)
if (!mark[i]) {
int now = min(a[from[i]], a[to[i]]);
if (now > mx) {
mx = now;
mxpos = i;
}
}
while (mxpos > 1 && mxpos < n) {
ans += min(a[from[mxpos]], a[to[mxpos]]);
int x = from[mxpos], y = to[mxpos];
to[x] = y;
from[y] = x;
mxpos = min(a[from[x]], a[to[x]]) > min(a[from[y]], a[to[y]]) ? x : y;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
const long long maxn = 500010;
long long stk[maxn], top = 0;
signed main() {
scanf("%lld", &n);
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
while (top >= 2) {
long long a = stk[top], b = stk[top - 1];
if (b >= a && a <= x)
ans += min(x, b), top--;
else
break;
}
stk[++top] = x;
}
sort(stk, stk + 1 + top);
for (long long i = 1; i <= top - 2; i++) ans += stk[i];
return printf("%lld\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 500 * 1000 + 4, Inf = 1e9 + 10;
int a[M], b[M], nx[M], pr[M];
bool cmp(int x, int y) { return (a[x] < a[y]); }
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], b[i] = i, nx[i] = i + 1, pr[i] = i - 1;
long long ans = 0;
sort(b + 1, b + n + 1, cmp);
int mn = 0;
for (int i = 1; i <= n; i++) {
int tmp = ans;
int j = b[i];
ans += (a[j] - mn) * max(n - i - 1, 0);
mn = a[j];
ans += max(min(a[pr[j]], a[nx[j]]) - mn, 0);
pr[nx[j]] = pr[j];
nx[pr[j]] = nx[j];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O0")
#pragma GCC optimize("O1")
long long pw(int a, int b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret *= mul;
mul *= mul;
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
int main() {
int n;
cin >> n;
long long st[n + 5];
int lst = -1;
long long ans = 0;
for (int(i) = (0); (i) < (n); (i)++) {
long long e;
cin >> e;
while (lst >= 1 and st[lst] <= st[lst - 1] and st[lst] <= e) {
ans += min(st[lst - 1], e);
lst--;
}
st[++lst] = e;
}
sort(st, st + lst + 1);
for (int(i) = (0); (i) < (lst - 1); (i)++) ans += st[i];
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505000;
int n, a[N], l[N], r[N];
pair<int, int> z[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
z[i] = make_pair(a[i], i);
}
sort(z, z + n);
for (int i = 0; i < n; ++i) {
l[i] = i - 1;
r[i] = i + 1;
}
int low = 0, high = n - 1;
long long ans = 0;
for (int i = 0; i < n - 2; ++i) {
int id = z[i].second;
if (id == low) {
ans += z[i].first;
low = r[low];
continue;
}
if (id == high) {
ans += z[i].first;
high = l[high];
continue;
}
ans += min(a[l[id]], a[r[id]]);
l[r[id]] = l[id];
r[l[id]] = r[id];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
long long int n, a[maxn], nx[maxn], pr[maxn];
vector<pair<long long int, long long int> > v;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
nx[i] = i + 1;
pr[i] = i - 1;
v.push_back(make_pair(a[i], i));
}
long long int l = 0, r = n - 1;
long long int answer = 0;
sort(v.begin(), v.end());
for (int i = 0; i < n - 2; i++) {
long long int x = v[i].first;
long long int j = v[i].second;
if (j == l) {
answer += x;
l = nx[j];
} else if (j == r) {
answer += x;
r = pr[j];
} else {
answer += min(a[pr[j]], a[nx[j]]);
nx[pr[j]] = nx[j];
pr[nx[j]] = pr[j];
}
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[533333], ans[533333];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
int cnt = 0;
long long sum = 0;
for (int i = 1; i <= n; i++) {
while (cnt > 1 && ans[cnt - 2] >= ans[cnt - 1] &&
ans[cnt - 1] <= num[i]) {
sum += min(ans[cnt - 2], num[i]);
cnt--;
}
ans[cnt++] = num[i];
}
sort(ans, ans + cnt);
for (int i = 0; i < cnt - 2; i++) sum += ans[i];
printf("%I64d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 5e5 + 5;
int n, a[N];
long long ans;
vector<pair<int, int> > v;
set<int> s;
int something_stupid(int x) {
set<int>::iterator it = s.upper_bound(x);
if (it == s.end()) return n + 1;
return *it;
}
int stupid_something(int x) {
set<int>::iterator it = s.lower_bound(x);
if (it == s.begin()) return 0;
return *--it;
}
int main() {
ios ::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) s.insert(i);
a[0] = a[n + 1] = -inf;
for (int i = 2; i <= n - 1; i++) v.push_back(make_pair(a[i], i));
sort(v.begin(), v.end());
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
int x = it->first;
int p = it->second;
int need = min(a[stupid_something(p)], a[something_stupid(p)]);
if (need < x) continue;
s.erase(p);
ans += need;
}
n = 0;
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); it++)
a[++n] = a[*it];
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
for (int i = 3; i <= n; i++) ans += a[i];
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 5e5 + 10;
long long ans = 0;
long long a[N];
int main() {
int n;
scanf("%d", &n);
long long temp;
int c = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &temp);
while (c > 0 && temp >= a[c] && a[c] <= a[c - 1]) {
ans += min(temp, a[c - 1]);
c--;
}
c++;
a[c] = temp;
}
sort(a + 1, a + 1 + c);
for (int i = 1; i <= c - 2; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500010], x, sz;
long long ans;
int main() {
scanf("%d", &n);
for (int step = 1; step <= n; step++) {
scanf("%d", &x);
while (a[sz - 1] >= a[sz] && a[sz] <= x && sz >= 2) {
ans += min(a[sz - 1], x);
sz--;
}
a[++sz] = x;
}
sort(a + 1, a + sz + 1);
for (int i = 1; i <= sz - 2; i++) ans += a[i];
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
int compare(const void* a, const void* b) {
int* x = (int*)a;
int* y = (int*)b;
return *x - *y;
}
unsigned min(const unsigned a, const unsigned b) { return (a < b) ? a : b; }
int main(int argc, const char* argv[]) {
unsigned a[500000] = {0};
unsigned x, n, i, j = 0;
unsigned long long ans = 0;
scanf("%u", &n);
for (i = 0; i < n; i++) {
scanf("%u", &x);
while (j > 1 && a[j - 2] >= a[j - 1] && x >= a[j - 1]) {
ans += min(a[j - 2], x);
j--;
}
a[j++] = x;
}
qsort(a, j, sizeof(unsigned), compare);
if (j > 1)
for (i = 0; i < j - 2; i++) ans += a[i];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, top, num[500005];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
while (top > 1 && num[top - 1] >= num[top] && num[top] <= x) {
ans += min(num[top - 1], x);
top--;
}
num[++top] = x;
}
sort(num + 1, num + top + 1);
for (int i = 1; i <= top - 2; i++) {
ans += num[i];
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s;
set<pair<int, int> > s2;
inline bool bad(set<int>::iterator it) {
if (it == s.begin()) return true;
it++;
if (it == s.end()) return true;
return false;
}
inline int getBef(set<int>::iterator it) {
it--;
return *it;
}
inline int getNex(set<int>::iterator it) {
it++;
return *it;
}
int a[500010];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s.insert(i);
s2.insert(pair<int, int>(a[i], i));
}
long long ans = 0;
int lstBegin = 0, lstEnd = 0;
for (int i = 0; i < n; i++) {
set<int>::iterator it = s.lower_bound(s2.begin()->second);
if (bad(it))
if (s.size() == 1)
ans += min(lstBegin, lstEnd);
else if (it == s.begin()) {
ans += lstBegin;
lstBegin = s2.begin()->first;
} else {
ans += lstEnd;
lstEnd = s2.begin()->first;
}
else
ans += min(a[getBef(it)], a[getNex(it)]);
s.erase(s2.begin()->second);
s2.erase(s2.begin());
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int q[500005];
bool cmp(int x, int y) { return x < y; }
int main() {
int n;
scanf("%d", &n);
int top = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
while (top > 1 && q[top - 2] >= q[top - 1] && q[top - 1] < x) {
ans += min(x, q[top - 2]);
top--;
}
q[top++] = x;
}
sort(q, q + top, cmp);
for (int i = 0; i < top - 2; i++) ans += q[i];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int st[5000005], top = 0, x, n, i, j;
int main() {
scanf("%d", &n);
long long int sum = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &x);
while (top > 1 && st[top - 1] >= st[top] && x >= st[top]) {
sum += std::min(x, st[top - 1]);
top--;
}
st[++top] = x;
}
std::sort(&st[1], &st[1] + top);
for (i = 1; i <= top - 2; i++) sum += st[i];
printf("%I64d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int q[500005];
bool cmp(int x, int y) { return x < y; }
int main() {
int n;
scanf("%d", &n);
int top = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
while (top > 1 && q[top - 2] >= q[top - 1] && q[top - 1] < x) {
ans += min(x, q[top - 2]);
top--;
}
q[top++] = x;
}
for (int i = 1; i < top - 1; i++) ans += min(q[i - 1], q[i + 1]);
printf("%lld\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();
ne[pr[now]] = ne[now];
pr[ne[now]] = pr[now];
ans += 1LL * min(a[ne[now]], a[pr[now]]);
check(ne[now]);
check(pr[now]);
}
int now = ne[0];
while (now <= n) {
ans += 1LL * min(a[pr[now]], a[ne[now]]);
now = ne[now];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int res = 0, q = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') q = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return res * q;
}
const double eps = 1e-12, pi = M_PI;
const int oo = (int)2e9, mod = (int)1e9 + 7;
const long long INF = (long long)1e17;
const int N = (int)5e5;
typedef long long arr[N + 10];
long long ans;
int i, j, k, p, n;
struct stack {
arr v;
long long top;
} st;
int main() {
scanf(
"%d"
"\n",
&n);
scanf("%I64d", &st.v[++st.top]);
for (int i = (2), end = (n); i <= end; ++i) {
scanf("%d", &p);
for (; st.v[st.top - 1] >= st.v[st.top] && p >= st.v[st.top];
ans += ((st.v[st.top - 1]) < (p) ? (st.v[st.top - 1]) : (p)), --st.top)
;
st.v[++st.top] = p;
}
sort(st.v + 1, st.v + st.top + 1);
for (int i = (1), end = (st.top - 2); i <= end; ++i) ans += st.v[i];
printf(
"%I64d"
"\n",
ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500001];
int main() {
int n;
scanf("%d", &n);
long long ans = 0;
int all = 0;
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
while (all > 1 && a[all] <= t && a[all] <= a[all - 1]) {
ans += min(a[all - 1], t);
all--;
}
a[++all] = t;
}
sort(a + 1, a + all + 1);
for (int i = 1; i <= all - 2; i++) ans += a[i];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int SIZE = 5e5 + 5;
using namespace std;
vector<pair<int, int> > v;
set<pair<int, int> > H;
bool used[SIZE];
int b[SIZE];
int main() {
int(n);
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
int(x);
scanf("%d", &x);
v.push_back(make_pair(x, i));
H.insert(make_pair(i, x));
}
long long an = 0;
sort((v).begin(), (v).end());
for (int i = 0; i < (((int)(v).size())); ++i) {
if (v[i].second == 0 || v[i].second == n - 1) continue;
set<pair<int, int> >::iterator it =
H.lower_bound(make_pair(v[i].second, 0));
set<pair<int, int> >::iterator it2 = it;
int now = it->second;
it2--;
int tmp = it2->second;
it2++;
it2++;
tmp = min(it2->second, tmp);
if (now <= tmp) {
used[i] = 1;
an += tmp;
H.erase(it);
}
}
int bn = 0;
for (set<pair<int, int> >::iterator it = H.begin(); it != H.end(); it++) {
b[bn++] = it->second;
}
if (bn > 2) {
sort(b, b + bn);
for (int i = 0; i + 2 < bn; i++) an += b[i];
}
cout << an << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[500005];
int main() {
int i;
long long ans = 0, x, top = -1;
scanf("%lld", &n);
while (n--) {
scanf("%lld", &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);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename T>
T gcd(T m, T n) {
while (n) {
T t = m % n;
m = n;
n = t;
};
return m;
}
template <typename T>
T exgcd(T a, T b, T& sa, T& ta) {
T q, r, sb = 0, tb = 1, sc, tc;
sa = 1, ta = 0;
if (b) do
q = a / b, r = a - q * b, a = b, b = r, sc = sa - q * sb, sa = sb,
sb = sc, tc = ta - q * tb, ta = tb, tb = tc;
while (b);
return a;
}
template <typename T>
T mul_inv(T a, T b) {
T t1 = a, t2 = b, t3;
T v1 = 1, v2 = 0, v3;
T x;
while (t2 != 1)
x = t1 / t2, t3 = t1 - x * t2, v3 = v1 - x * v2, t1 = t2, t2 = t3, v1 = v2,
v2 = v3;
return (v2 + b) % b;
}
template <typename T>
T powmod(T a, T b, T MOD) {
if (b < 0) return 0;
T rv = 1;
while (b) (b % 2) && (rv = (rv * a) % MOD), a = a * a % MOD, b /= 2;
return rv;
}
template <long long n>
struct BitSize {
enum { Size = BitSize<n / 2>::Size + 1 };
};
template <>
struct BitSize<0> {
enum { Size = 1 };
};
template <>
struct BitSize<1> {
enum { Size = 1 };
};
const int maxn = 5e5 + 7;
int n;
int a[maxn];
int main(int argc, char* argv[]) {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
(cin >> n);
{
int an = 0;
long long r = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
while (an >= 2 && a[an] <= x && a[an - 1] >= a[an]) {
r += min(a[an - 1], x);
an--;
}
a[++an] = x;
}
for (int i = 1; i < an; i++) r += min(a[i - 1], a[i + 1]);
cout << r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int f = 1, sum = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = (sum << 3) + (sum << 1) + ch - '0';
ch = getchar();
}
return f * sum;
}
const int N = 500010;
int a[N], c[N], tot, n;
stack<int> s;
int main() {
n = gi();
long long ans = 0;
int tot = 0;
for (int i = 1; i <= n; i++) {
a[i] = gi();
while (s.size() > 1) {
int x = s.top();
s.pop();
int y = s.top();
if (y >= x && x <= a[i])
ans += min(y, a[i]);
else {
s.push(x);
break;
}
}
s.push(a[i]);
}
while (!s.empty()) c[++tot] = s.top(), s.pop();
sort(c + 1, c + tot + 1);
for (int i = 1; i < tot - 1; i++) ans += c[i];
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Dbg {
template <typename T>
Dbg& operator,(const T& v) {
cerr << v << ", ";
return *this;
}
} Dbg;
template <typename T>
ostream& operator<<(ostream& _o_, const vector<T>& _v_) {
if (!_v_.empty()) {
_o_ << '[';
copy(_v_.begin(), _v_.end(), ostream_iterator<T>(_o_, ", "));
_o_ << "\b\b]";
}
return _o_;
}
template <class C>
void mini(C& _a, C _b) {
_a = min(_a, _b);
}
template <class C>
void maxi(C& _a, C _b) {
_a = max(_a, _b);
}
int a[500005], nxt[500005], prv[500005];
long long ans = 0;
void process(int i) {
int posa = prv[i];
int posb = nxt[i];
nxt[posa] = posb;
prv[posb] = posa;
int val = min(a[posa], a[posb]);
ans += (val) ? val : a[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > v;
a[0] = 0;
a[n + 1] = 0;
nxt[0] = 1;
prv[n + 1] = n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
v.emplace_back(a[i], i);
prv[i] = i - 1;
nxt[i] = i + 1;
}
sort(v.begin(), v.end());
n = v.size();
for (int i = 0; i < n - 2; i++) {
int pos = v[i].second;
process(pos);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 20;
int tav(long long n, long long k) {
long long res = 1;
while (k > 0) {
if (k & 1) {
res *= n;
}
n *= n;
k /= 2;
}
return res;
}
vector<long long> v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
long long h;
cin >> h;
if (v.size() < 2) {
v.push_back(h);
} else {
while (v.size() >= 2) {
if (v.back() <= h && v[v.size() - 2] >= v.back()) {
v.pop_back();
ans += min(h, v.back());
} else {
break;
}
}
v.push_back(h);
}
}
sort(v.begin(), v.end(), greater<long long>());
while (v.size() > 2) {
ans += v.back();
v.pop_back();
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = 2 * acos((long double)0);
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int maxn = 500010;
int n;
int a[maxn];
void solve() {
cin >> n;
set<pair<int, int> > st1, st2;
for (int i = (0); i < (n); i++) {
cin >> a[i];
st1.insert(make_pair(i, a[i]));
st2.insert(make_pair(a[i], i));
}
long long ans = 0;
for (int i = (0); i < (n - 2); i++) {
int u = st2.begin()->second;
st2.erase(st2.begin());
set<pair<int, int> >::iterator it = st1.find(make_pair(u, a[u]));
if (it == st1.begin() || it->first == st1.rbegin()->first) {
ans += a[u];
} else {
it--;
int x = it->first;
it++;
it++;
int y = it->first;
ans += min(a[x], a[y]);
}
st1.erase(make_pair(u, a[u]));
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int s[maxn], top;
int main() {
int n;
scanf("%d", &n);
top = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
while (top > 1 && s[top - 1] >= s[top] && s[top] <= x) {
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("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long arr[1000005], nxt[1000005], pre[1000005], n;
long long vis[1000005];
queue<long long> q;
void add(long long i) {
if (i == 0) return;
if (i == n + 1) return;
if (vis[i]) return;
if (arr[i] <= arr[pre[i]] && arr[i] <= arr[nxt[i]]) {
q.push(i);
vis[i] = 1;
}
}
void solve() {
long long i, j, k, l, r, m, a, b, c, d, x, y, z, t;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
pre[i] = i - 1;
nxt[i] = i + 1;
}
nxt[0] = 1;
pre[n + 1] = n;
for (i = 1; i <= n; i++) add(i);
long long ans = 0;
while (!q.empty()) {
long long cur = q.front();
q.pop();
ans += min(arr[pre[cur]], arr[nxt[cur]]);
nxt[pre[cur]] = nxt[cur];
pre[nxt[cur]] = pre[cur];
add(pre[cur]);
add(nxt[cur]);
}
for (i = nxt[0]; i < n + 1; i = nxt[i]) {
ans += min(arr[pre[i]], arr[nxt[i]]);
}
cout << ans << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) solve();
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 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;
int n;
long long a[500005];
long long st[500005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int tot = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
while (tot > 1 && st[tot - 2] >= st[tot - 1] && st[tot - 1] <= a[i]) {
ans += min(st[tot - 2], a[i]);
tot--;
}
st[tot++] = a[i];
}
sort(st, st + tot);
for (int i = 0; i < tot - 2; i++) {
ans += st[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int a, b;
bool operator<(const data &f) const { return f.a < a; }
};
data c[1111111];
priority_queue<data> q;
map<int, int> m;
map<int, int> mm;
map<int, int>::iterator it;
bool mark[1111111];
int n;
int main() {
while (!q.empty()) q.pop();
m.clear();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i].a);
c[i].b = i;
q.push(c[i]);
m.insert(make_pair(i, c[i].a));
mm.insert(make_pair(n - i, c[i].a));
}
int p = 1, head = 1, tail = n;
long long ans = 0, sub = 0;
while (p <= n - 2) {
data d = q.top();
q.pop();
if (d.b == head || d.b == tail) {
long long tmp = n - 1 - p;
ans += tmp * (d.a - sub);
sub += d.a - sub;
it = m.find(d.b);
m.erase(it);
it = mm.find(n - d.b);
mm.erase(it);
mark[d.b] = true;
} else {
it = m.upper_bound(d.b);
int tmp = it->second;
it = mm.upper_bound(n - d.b);
ans += min(it->second, tmp) - sub;
mark[d.b] = true;
it = m.lower_bound(d.b);
m.erase(it);
it = mm.find(n - d.b);
mm.erase(it);
}
while (mark[head] == true) head++;
while (mark[tail] == true) tail--;
p++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
pair<int, int> p[500010];
int a[500010], nxt[500010], prv[500010];
int main() {
int n;
gn(n);
for (int i = 1; i <= n; i++) {
gn(a[i]);
p[i] = pair<int, int>(a[i], i);
nxt[i] = i + 1;
prv[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 u = p[i].second;
if (u == st) {
ans += p[i].first;
st = nxt[u];
} else if (u == ed) {
ans += p[i].first;
ed = prv[u];
} else {
ans += min(a[prv[u]], a[nxt[u]]);
prv[nxt[u]] = prv[u];
nxt[prv[u]] = nxt[u];
}
}
println(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[500500];
int bef[500500];
int aft[500500];
int main() {
cin >> n;
m = n;
pair<int, int> b[n];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = make_pair(a[i], i);
aft[i] = i + 1;
bef[i] = i - 1;
}
sort(b, b + n);
long long res = 0;
int l = 0, h = n - 1;
for (int i = 0; i < n - 2; i++) {
if (b[i].second == l) {
res += b[i].first;
l = aft[l];
continue;
}
if (b[i].second == h) {
res += b[i].first;
h = bef[h];
continue;
}
int x = b[i].second;
res += min(a[aft[x]], a[bef[x]]);
aft[bef[x]] = aft[x];
bef[aft[x]] = bef[x];
}
cout << res;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.