text
stringlengths 49
983k
|
|---|
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,dp[100001],a[100001],b;
int main() {
cin >> n >> m;
for(int i=1; i<=m; i++) {
cin >> b;
a[b]=1;
}
dp[0]=1;
for(int i=1; i<=n; i++) {
if(a[i-1]==0) {
dp[i]+=dp[i-1];
}
if(a[i-2]==0) {
dp[i]+=dp[i-2];
}
dp[i]%=1000000007;
}
cout << dp[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, A, B = 1e9+7;
cin >> N >> M;
vector<int> vec(N + 1, -1);
vec.at(0) = 1;
vec.at(1) = 1;
for (int i = 0; i < M; i++) {
scanf("%d", &A);
vec.at(A) = 0;
}
for (int i = 2; i < N + 1; i++) {
if (vec.at(i) != 0) vec.at(i) = (vec.at(i - 2) + vec.at(i - 1)) % B;
}
cout << vec.at(N) << endl;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll mod=1e9+7;
int main(){
ll n,m,a1,r1;
cin>>n>>m;
vector<ll> dp(n+5,0);
vector<ll> no(n+5,0);
for(a1=0;a1<m;++a1){
cin>>r1;
no[r1]=1;
}
dp[0]=1;
for(a1=1;a1<=n;++a1){
if(no[a1]) continue;
int x=0;
if(a1-2>=0) x=dp[a1-2];
dp[a1]=(dp[a1-1]+x)%mod;
}
cout<<dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> x(n + 1, 1);
int a;
for(int i = 0; i < m; i++){
cin >> a;
x.at(a) = 0;
}
x.at(1) *= x.at(0);
for(int i = 2; i <= n; i++){
x.at(i) *= x.at(i - 1) + x.at(i - 2);
x.at(i) %= (int) 1e9 + 7;
}
cout << x.at(n) << "\n";
}
|
#include<bits/stdc++.h>
using namespace std;
int n,m,t,a[100005];
bool able[100005];
int main(){
cin>>n>>m;
for(int i=1;i<=m;i++){
cin>>t;
able[t+1]=1;
}
n++;
a[1]=1;
for(int i=2;i<=n;i++){
if(able[i]){
continue;
}
a[i]=((long long)(a[i-1])+a[i-2])%1000000007;
}
cout<<a[n];
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
struct node
{
int u,v;
ll w;
bool operator<(const node &o)const{return w<o.w;}
}e[6000005];
int n,cot=0,a[200005],fail[200005];
ll d;
void add(int l,int r)
{
if(l>=r) return;
int m=l+r>>1;
ll mi=1e18,pos;
for(int i=l;i<=m;i++)
{
ll f=a[i]-d*i;
if(f<mi) mi=f,pos=i;
}
for(int i=m+1;i<=r;i++)
e[cot].u=pos,e[cot].v=i,e[cot++].w=a[i]+a[pos]+d*(i-pos);
mi=1e18;
for(int i=m+1;i<=r;i++)
{
ll f=a[i]+d*i;
if(f<mi) mi=f,pos=i;
}
for(int i=l;i<=m;i++)
e[cot].u=i,e[cot].v=pos,e[cot++].w=a[i]+a[pos]+d*(pos-i);
add(l,m);add(m+1,r);
}
int get_fa(int x)
{
return fail[x]==x?x:fail[x]=get_fa(fail[x]);
}
ll kruskal()
{
sort(e,e+cot);
for(int i=1;i<=200000;i++) fail[i]=i;
ll ans=0;
for(int i=0;i<cot;i++)
{
int fu=get_fa(e[i].u),fv=get_fa(e[i].v);
if(fu==fv) continue;
fail[fu]=fv;
ans+=e[i].w;
}
return ans;
}
int main()
{
scanf("%d%lld",&n,&d);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
add(1,n);
printf("%lld\n",kruskal());
}
|
//Code by 27.
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<math.h>
#include<vector>
#include<queue>
#include<map>
#include<stack>
#include<fstream>
#include<stdlib.h>
#include<set>
#include<climits>
#include<cmath>
#include<memory.h>
#include<sstream>
#include<time.h>
#include<iomanip>
using namespace std;
const unsigned long long BIGEST=1000000000000000000+1000000000000000000;
const long long BIGER=1000000000000000000;
const int BIG=1000000000;
const int MOD=1000000007;
const long long LMOD=1000000007;
long long n,d;
long long a[300005];
long long dp[2][300005];
int main()
{
long long res=0;
scanf("%lld%lld",&n,&d);
for(long long i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
res+=a[i];
}
res+=d*(n-1);
dp[0][1]=a[1];
for(long long i=2;i<=n;i++)
{
dp[0][i]=min(dp[0][i-1]+d,a[i]);
}
dp[1][n]=a[n];
for(long long i=n-1;i>=1;i--)
{
dp[1][i]=min(dp[1][i+1]+d,a[i]);
}
for(long long i=2;i<n;i++)
{
res+=min(dp[0][i],dp[1][i]);
//cout<<dp[0][i]<<" "<<dp[1][i]<<endl;
}
cout<<res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, pii> node;
const int maxn = 2e5 + 10;
int n, par[maxn]; ll k, a[maxn], f[maxn];
vector <node> e;
int find(int x) {
return par[x] == x ? x : par[x] = find(par[x]);
}
void unite(int x, int y) {
par[find(x)] = find(y);
}
void solve(int l, int r) {
if (l == r) return;
ll val = 1ll << 60;
int mid = l + r >> 1, pl = 0, pr = 0;
for (int i = l; i <= mid; i++) {
f[i] = a[i] - k * i;
if (val > f[i]) val = f[i], pl = i;
}
val = 1ll << 60;
for (int i = mid + 1; i <= r; i++) {
f[i] = a[i] + k * i;
if (val > f[i]) val = f[i], pr = i;
}
for (int i = l; i <= mid; i++) {
e.push_back(node(f[i] + f[pr], pii(i, pr)));
}
for (int i = mid + 1; i <= r; i++) {
e.push_back(node(f[pl] + f[i], pii(i, pl)));
}
solve(l, mid), solve(mid + 1, r);
}
int main() {
scanf("%d %lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i), par[i] = i;
}
solve(1, n), sort(e.begin(), e.end());
ll ans = 0;
for (node p : e) {
int u = p.second.first, v = p.second.second;
if (find(u) != find(v)) {
ans += p.first, unite(u, v);
}
}
printf("%lld", ans);
return 0;
}
|
#include <iostream>
#include <queue>
#include <utility>
#define ll long long
using namespace std;
ll A[200010];
priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> pq;
bool cd[200010];
int main() {
int N;
ll D;
cin >> N >> D;
for(int i=0; i<N; ++i){
cin >> A[i];
pq.push(make_pair(A[i], i));
}
int cnt=0;
ll ans=0;
while(cnt<N-1){
int now=pq.top().second;
if(now>0){
if(!cd[now]){
cd[now]=1;
ans += A[now]+A[now-1]+D;
if(A[now]+D<A[now-1]){
A[now-1]=A[now]+D;
pq.push(make_pair(A[now-1], now-1));
}
++cnt;
}
}
if(now<N-1){
if(!cd[now+1]){
cd[now+1]=1;
ans += A[now]+A[now+1]+D;
if(A[now]+D<A[now+1]){
A[now+1]=A[now]+D;
pq.push(make_pair(A[now+1], now+1));
}
++cnt;
}
}
pq.pop();
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
template<typename T>
struct Kruskal{
struct edge{
Int from,to;
T cost;
Int used;
edge(){}
edge(Int from,Int to,T cost):
from(from),to(to),cost(cost),used(0){}
bool operator<(const edge& e) const{
return cost<e.cost;
}
};
Int n;
vector<Int> p,r;
vector<edge> edges;
Kruskal(){}
Kruskal(Int n):n(n){}
void init(Int n){
r.assign(n,1);
p.resize(n);
iota(p.begin(),p.end(),0);
}
Int find(Int x){
return (x==p[x]?x:p[x]=find(p[x]));
}
bool same(Int x,Int y){
return find(x)==find(y);
}
void unite(Int x,Int y){
x=find(x);y=find(y);
if(x==y) return;
if(r[x]<r[y]) swap(x,y);
r[x]+=r[y];
p[y]=x;
}
void add_edge(Int u,Int v,T c){
edges.emplace_back(u,v,c);
}
T build(){
sort(edges.begin(),edges.end());
init(n);
T res=0;
for(auto &e:edges){
if(!same(e.from,e.to)){
res+=e.cost;
unite(e.from,e.to);
e.used=1;
}
}
return res;
}
};
//INSERT ABOVE HERE
signed main(){
Int n,d;
cin>>n>>d;
vector<Int> a(n);
for(Int i=0;i<n;i++) cin>>a[i];
Kruskal<Int> ks(n);
using P = pair<Int, Int>;
using PP = pair<P, P>;
auto add_edge=
[&](Int x,Int y){
Int c=abs(x-y)*d+a[x]+a[y];
ks.add_edge(x,y,c);
};
function<PP(Int, Int)> dfs=
[&](Int l,Int r)->PP{
if(l+1==r) return PP(P(a[l]-l*d,l),P(a[l]+l*d,l));
Int m=(l+r)>>1;
PP x=dfs(l,m),y=dfs(m,r);
for(Int i=l;i<m;i++)
add_edge(i,y.second.second);
for(Int i=m;i<r;i++)
add_edge(x.first.second,i);
return PP(min(x.first,y.first),min(x.second,y.second));
};
dfs(0,n);
cout<<ks.build()<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<LL,LL> PII;
const int MAXN = 400100;
vector<PII> graph[MAXN];
void add_edge(int v, int u, int c) {
graph[v].push_back(PII(u,c));
graph[u].push_back(PII(v,c));
}
int main() {
int N, D;
cin >> N >> D;
for(int i=0; i<N; i++) {
LL p;
cin >> p;
add_edge(i, i+N, p);
}
for(int i=0; i<N-1; i++) {
int v,u,c;
//cin >> v >> u >> c;
//v--;u--;
add_edge(i, i+1, D);
}
priority_queue<pair<LL,PII> , vector<pair<LL,PII> >, greater<pair<LL,PII> > > pq;
vector<int> used(2*N, 0), dist(2*N, 0);
int cnt = 1;
LL ans = 0;
for(int i=0; i<N; i++) {
pq.push(make_pair(0, PII(i+N, -1)));
}
while(!pq.empty()) {
auto cur = pq.top(); pq.pop();
LL v = cur.second.first;
if(used[v]) {
LL u = cur.second.second;
if(used[v] > used[u])
ans += dist[v] + cur.first;
continue;
}
used[v] = cnt;
cnt++;
dist[v] = cur.first;
for(auto uc: graph[v]) {
LL u = uc.first;
LL c = uc.second;
pq.push(make_pair(dist[v] + c, PII(u, v)));
}
}
cout << ans << endl;
return 0;
}
|
/***********************
* Author: xuziyuan *
***********************/
#include <bits/stdc++.h>
#define rt0 return 0
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define replet(c) for(char c='a';c<='z';c++)
#define LL long long
#define pii pair <LL,LL>
#define pb push_back
#define fi first
#define se second
#define mpr make_pair
#define sqr(a) ((a)*(a))
using namespace std;
const LL MOD=1e9+7;
LL n,d,ans=0;
LL a[200010],par[200010];
vector <pair <LL,pii> > v;
LL FIND(LL pos)//dsu
{
if(par[pos]!=pos) par[pos]=FIND(par[pos]);
return par[pos];
}
void UNION(LL pos1,LL pos2)
{
par[FIND(pos1)]=FIND(pos2);
}
void solve(LL lb,LL ub)//分治
{
if(lb==ub) return;//只剩一个
LL mid=(lb+ub)/2,mn=1e18,lbest,rbest;
for(LL i=lb;i<=mid;i++)
{
if(a[i]-d*i<mn)//左边是编号较小的一组,所以是减
{
mn=a[i]-d*i;
lbest=i;
}
}
mn=1e18;
for(LL i=mid+1;i<=ub;i++)
{
if(a[i]+d*i<mn)//右边是编号较大的一组,所以是加
{
mn=a[i]+d*i;
rbest=i;
}
}
for(LL i=lb;i<=mid;i++)
{
LL val1=a[i]-d*i,val2=a[rbest]+d*rbest;
v.pb({val1+val2,{i,rbest}});
}
for(LL i=mid+1;i<=ub;i++)
{
LL val1=a[i]+d*i,val2=a[lbest]-d*lbest;
v.pb({val1+val2,{lbest,i}});
}
solve(lb,mid);
solve(mid+1,ub);
}
int main()
{
rep(i,200005) par[i]=i;
cin>>n>>d;
rep(i,n) scanf("%I64d",&a[i]);
solve(0,n-1);
sort(v.begin(),v.end());
rep(i,v.size())
{
if(FIND(v[i].se.fi)==FIND(v[i].se.se)) continue;
UNION(v[i].se.fi,v[i].se.se);
ans+=v[i].fi;
}
cout<<ans<<endl;
rt0;
}
/*
在连通两个区域时,只连接两边的最好的点是不行的
比如:
如果只连接两边的最好的点:
(1,val:200)-(2,val:10)
/
(3,val:100)-(4,val:200)
这时,总消费是623;
如程序中的,连接一边的所有点和另一边的最好的点
(1,val:200)-(2,val:10)
/ |
(3,val:100) (4,val:200)
这时,总消费是534
因为,一开始被分在某一边的某个点不一定连自己这边的某个点是最优的,
可能连另一边的最好的点更佳
*/
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
const int mx=200010;
const ll mod=1e9+7;
struct UnionFind {
vector<int> par,sizes; // par[i]:iの親の番号(ex)par[3]=2 : 3の親が2
UnionFind(int n) : par(n),sizes(n,1) { //最初は全てが根であるとして初期化
for(int i=0; i<n; i++){ par[i]=i; }
}
int root(int x) { //xが属する木の根を再帰で得る:root(x)={xの木の根}
if(par[x]==x){ return x; }
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); //xの根をrx
int ry = root(y); //yの根をry
if(rx == ry){ return; } //xとyの根が同じ(=同じ木にある)時はそのまま
if(sizes[rx]<sizes[ry]){ swap(rx, ry); } //xの木をおおきくする
par[ry] = rx;
sizes[rx] += sizes[ry]; //sizes[ry]はもう使わない
}
bool check(int x, int y) { // x,yが属する木が同じならtrueを返す
return root(x) == root(y);
}
int size(int x){ //xが含まれる木の大きさを返す
return sizes[root(x)];
}
};
vector<pair<ll,P>> edges;
vector<ll> a(mx);
ll n,d;
ll dist(int x,int y){ return d*abs(x-y)+a[x]+a[y]; }
void dfs(int l, int r){
if(l+1>=r){ return; }
ll mini=longinf, idx=-1;
int m=(l+r)/2;
for(int i=l; i<m; i++){ if(dist(i,m)<mini)mini=dist(i,m),idx=i; }
for(int i=m; i<r; i++){ edges.push_back({dist(idx,i),{idx,i}}); }
mini=longinf; idx=-1;
for(int i=m; i<r; i++){ if(dist(i,l)<mini)mini=dist(i,l),idx=i; }
for(int i=l; i<m; i++){ edges.push_back({dist(idx,i),{idx,i}}); }
dfs(l,m);
dfs(m,r);
}
int main(){
cin >> n >> d;
rep(i,n){ cin>>a[i]; }
dfs(0,n);
sort(edges.begin(),edges.end());
UnionFind uf(n);
ll ans=0;
for(auto e:edges){
int u=e.S.F,v=e.S.S; ll c=e.F;
if(!uf.check(u,v)){ uf.unite(u,v); ans+=c;}
}
cout << ans << endl;
return 0;
}
|
#ifndef BZ
#pragma GCC optimize "-O3"
#endif
#include <bits/stdc++.h>
#define FASTIO
#define ALL(v) (v).begin(), (v).end()
#define rep(i, l, r) for (int i = (l); i < (r); ++i)
#ifdef FASTIO
#define scanf abacaba
#define printf abacaba
#endif
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
using namespace std;
/*
ll pw(ll a, ll b) {
ll ans = 1; while (b) {
while (!(b & 1)) b >>= 1, a = (a * a) % MOD;
ans = (ans * a) % MOD, --b;
} return ans;
}
*/
const int MAXN = 210000;
ll d;
int n;
ll a[MAXN];
int main() {
#ifdef FASTIO
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#endif
cin >> n >> d;
for (int i = 0; i < n; ++i)
cin >> a[i];
vector<pair<ll, int>> vv;
for (int i = 1; i < n; ++i) {
ll x = a[i] + d * i;
while (!vv.empty() && vv.back().first >= x)
vv.pop_back();
vv.emplace_back(x, i);
}
int now = 1;
ll bst = a[0];
ll ans = 0;
for (int i = 0; i < vv.size(); ++i) {
int nw = vv[i].second;
ans += vv[i].first + bst;
for (int j = now; j < nw; ++j) {
ans += a[j] + min(vv[i].first - j * d, bst + j * d);
bst = min(bst, a[j] - j * d);
}
bst = min(bst, a[nw] - nw * d);
now = nw + 1;
}
cout << ans << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,m,val[200100],res;
signed main(){
scanf("%lld%lld",&n,&m);
for(int i=1;i<=n;i++)scanf("%lld",&val[i]);
res+=accumulate(val+1,val+n+1,0ll);
for(int i=2;i<=n;i++)val[i]=min(val[i],val[i-1]+m);
for(int i=n-1;i;i--)val[i]=min(val[i],val[i+1]+m);
printf("%lld\n",res+accumulate(val+1,val+n+1,0ll)-val[1]-val[n]+(n-1)*m);
return 0;
}
|
#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long double ld;
typedef long long ll;
const int max_n = 300011, max_m = 500011, inf = 1000111222;
const ll inff = 1000111222333444;
struct dsu {
int p[max_n], sz[max_n];
dsu() {
for (int i = 0; i < max_n; ++i) {
p[i] = i;
sz[i] = 1;
}
}
int find_set(int x) {
if (p[x] == x) return x;
return p[x] = find_set(p[x]);
}
void union_set(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x != y) {
if (sz[x] < sz[y]) swap(x, y);
p[y] = x;
sz[x] += sz[y];
}
}
};
int n, a[max_n], d;
vector<pair<ll, pair<int, int> > > edges;
dsu dd;
ll dist(int i, int q) {
return 1LL * abs(i - q) * d + a[i] + a[q];
}
void dev(int l, int r) {
if (l + 1 == r) {
return;
}
int mid = (l + r) / 2;
pair<ll, int> cv1, cv2;
cv1 = cv2 = {inff, 0};
for (int i = l; i < mid; ++i) {
cv1 = min(cv1, {a[i] - 1LL * d * i, i});
}
for (int i = mid; i < r; ++i) {
cv2 = min(cv2, {a[i] + 1LL * d * i, i});
}
for (int i = l; i < mid; ++i) edges.push_back({dist(i, cv2.S), {i, cv2.S}});
for (int i = mid; i < r; ++i) edges.push_back({dist(i, cv1.S), {i, cv1.S}});
dev(l, mid);
dev(mid, r);
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
cin >> n >> d;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
dev(0, n);
sort(edges.begin(), edges.end());
ll ans = 0;
for (int i = 0; i < edges.size(); ++i) {
if (dd.find_set(edges[i].S.F) != dd.find_set(edges[i].S.S)) {
dd.union_set(edges[i].S.F, edges[i].S.S);
ans += edges[i].F;
}
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
ll BIT1[200010];
ll BIT2[200010];
void add1(int A, ll B) {
while (A > 0) {
BIT1[A] = min(BIT1[A], B);
A -= A & -A;
}
}
ll query1(int A) {
ll kotae = 1e18;
while (A <= 200000) {
kotae = min(kotae, BIT1[A]);
A += A & -A;
}
return kotae;
}
void add2(int A, ll B) {
while (A <= 200000) {
BIT2[A] = min(BIT2[A], B);
A += A & -A;
}
}
ll query2(int A) {
ll kotae = 1e18;
while (A > 0) {
kotae = min(kotae, BIT2[A]);
A -= A & -A;
}
return kotae;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, D;
cin >> N >> D;
int A[200001];
rep1(i, N) cin >> A[i];
rep1(i, 200000) BIT1[i] = 1e18;
rep1(i, 200000) BIT2[i] = 1e18;
rep1(i, N) {
add1(i, A[i] + i * D);
}
rep1(i, N) {
add2(i, A[i] - i * D);
}
ll setuyaku = 0;
for (int i = 2; i < N; i++) {
ll kari1 = query1(i + 1) - i * D;
ll kari2 = query2(i - 1) + i * D;
if (A[i] > min(kari1, kari2)) {
setuyaku += A[i] - min(kari1, kari2);
}
}
ll motomoto = 0;
rep1(i, N - 1) motomoto += A[i];
rep1(i, N - 1) motomoto += A[i + 1];
motomoto += (N - 1) * D;
co(motomoto - setuyaku);
Would you please return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using pll = pair<ll, ll>;
int main(){
ll n, d;
cin >> n >> d;
vector<ll> a(n);
for(auto& i : a) cin >> i;
auto cost = [&](ll x, ll y){
return a[x] + a[y] + abs(x - y) * d;
};
vector<ll> l(n), r(n);
l[0] = 0;
for(ll i = 1; i < n; i++) l[i] = min(l[i - 1], i, [&](ll x, ll y){ return cost(i, x) < cost(i, y); });
r[n - 1] = n - 1;
for(ll i = n - 1; i--; ) r[i] = min(r[i + 1], i, [&](ll x, ll y){ return cost(i, x) < cost(i, y); });
ll ans = 0;
pll last;
for(ll i = 0; i < n - 1; i++) if(last != pll{l[i], r[i + 1]}){
last = {l[i], r[i + 1]};
ans += cost(l[i], r[i + 1]);
}
for(ll i = 1; i < n - 1; i++) if(l[i] != i && r[i] != i) ans += min(cost(i, l[i - 1]), cost(i, r[i + 1]));
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+7;
int n,fa[N];
ll ans,d,a[N],l[N],r[N];
int main()
{
cin>>n>>d;
ans=(n-1)*d;
for(int i=1;i<=n;i++)scanf("%lld",&a[i]),ans+=a[i],l[i]=r[i]=1e18;
l[1]=a[1];
for(int i=2;i<=n;i++)l[i]=min(l[i-1],a[i]-(i-1)*d);
r[n]=a[n]+(n-1)*d;
for(int i=n-1;i;i--)r[i]=min(r[i+1],a[i]+(i-1)*d);
for(int i=2;i<n;i++)ans+=min((i-1)*d+l[i],r[i]-(i-1)*d);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << (x) << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){
return o<<"("<<p.fs<<","<<p.sc<<")";
}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){
o<<"{";
for(const T& v:vc) o<<v<<",";
o<<"}";
return o;
}
using ll = long long;
template<class T> using V = vector<T>;
template<class T> using VV = vector<vector<T>>;
int N;
ll D;
ll A[200010];
using P = pair<int,int>;
using PP = pair<ll,P>;
struct UnionFind{
vector<int> par;
UnionFind(int N){
par.assign(N,0);
rep(i,N) par[i]=i;
}
int find(int x){
if(par[x]==x) return x;
return par[x]=find(par[x]);
}
bool same(int x,int y){
return find(x)==find(y);
}
void unite(int x,int y){
x=find(x),y=find(y);
if(x==y) return;
par[y]=x;
}
};
vector<PP> es;
ll inf = 1e18;
void solve(int l,int r){
if(r-l==1) return;
int m = (l+r)/2;
solve(l,m);
solve(m,r);
{
ll bestl = inf;
int agl = -1;
for(int i=l;i<m;i++){
ll cost = -i*D+A[i];
if(bestl>cost){
bestl = cost;
agl = i;
}
}
int agr = -1;
ll bestr = inf;
for(int i=m;i<r;i++){
ll cost = i*D+A[i];
if(bestr>cost){
bestr = cost;
agr = i;
}
}
for(int i=l;i<m;i++){
es.pb(PP(-i*D+A[i]+bestr,P(i,agr)));
}
for(int i=m;i<r;i++){
es.pb(PP(i*D+A[i]+bestl,P(i,agl)));
}
}
}
int main(){
cin>>N>>D;
rep(i,N) cin>>A[i];
solve(0,N);
sort(all(es));
UnionFind UF(N);
ll ans = 0;
for(PP e:es){
ll c = e.fs;
int x = e.sc.fs, y = e.sc.sc;
if(!UF.same(x,y)){
UF.unite(x,y);
ans += c;
}
}
cout<<ans<<endl;
}
|
#include<vector>
#include<iostream>
#include<map>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<deque>
#define ll long long
using namespace std;
#define BUF_SIZE 1048576
char _buf[BUF_SIZE],*_is=_buf,*_it=_buf;
inline char rdc(){
if (_is==_it) _it=(_is=_buf)+fread(_buf,1,BUF_SIZE,stdin);
return *_is++;
}
inline void rdi(int &x){
int f=0;
register char ch=rdc();
while ((ch<'0' or ch>'9') and (ch^'-')) ch=rdc();
if (ch=='-') f=1,ch=rdc();
while (ch>='0' and ch<='9') x=(x<<3)+(x<<1)+(ch^'0'),ch=rdc();
if(f) x=-x;
}
inline void rdi(ll &x){
ll f=0;
register char ch=rdc();
while ((ch<'0' or ch>'9') and (ch^'-')) ch=rdc();
if (ch=='-') f=1,ch=rdc();
while (ch>='0' and ch<='9') x=(x<<3)+(x<<1)+(ch^'0'),ch=rdc();
if(f) x=-x;
}
inline void write(int x){
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void _write(int x){
write(x);
putchar(' ');
}
inline void print(int x){
write(x);
putchar('\n');
}
inline void write(ll x){
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void _write(ll x){
write(x);
putchar(' ');
}
inline void print(ll x){
write(x);
putchar('\n');
}
#define int ll
int res,n,d;
int a[200005];
int dpl[200005],dpr[200005];
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
rdi(n),rdi(d);
int i,j;
for(i=0;i<n;++i) rdi(a[i]),res+=a[i];
res+=(n-1)*d;
dpr[0]=a[0];
for(i=1;i<n;++i) dpr[i]=min(a[i],dpr[i-1]+d);
dpl[n-1]=a[n-1];
for(i=n-2;~i;--i) dpl[i]=min(a[i],dpl[i+1]+d);
for(i=1;i<n-1;++i) res+=min(dpl[i],dpr[i]);
print(res);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <random>
#include <cassert>
#include <cstring>
#include <chrono>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
struct TEdge {
int a, b;
ll w;
TEdge() {}
TEdge(int a, int b, ll w): a(a), b(b), w(w) {}
};
vector<TEdge> edges;
void AddEdges(int l, int r, const vector<ll>& a, ll d) {
if (l + 1 == r) {
edges.push_back(TEdge(l, r, a[l] + a[r] + d));
return;
}
if (l == r) return;
int m = (l + r) / 2;
int bestLeft = l;
for (int i = l; i < m; ++i) if (a[i] - d * i < a[bestLeft] - d * bestLeft) bestLeft = i;
int bestRight = r;
for (int i = m; i <= r; ++i) if (a[i] + d * i < a[bestRight] + d * bestRight) bestRight = i;
for (int i = l; i < m; ++i) edges.push_back(TEdge(i, bestRight, a[i] - d * i + a[bestRight] + d * bestRight));
for (int i = m; i <= r; ++i) edges.push_back(TEdge(bestLeft, i, a[bestLeft] - d * bestLeft + a[i] + d * i));
AddEdges(l, m - 1, a, d);
AddEdges(m , r, a ,d);
}
int parent[300 * 1000];
int GetRoot(int v) {
if (parent[v] == v) return v;
int w = GetRoot(parent[v]);
parent[v] = w;
return w;
}
void Unite(int v1, int v2) {
v1 = GetRoot(v1);
v2 = GetRoot(v2);
if (v1 == v2) return;
if (rand() % 2) swap(v1, v2);
parent[v2] = v1;
}
int main()
{
int n;
ll d;
cin >> n >> d;
vector<ll> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
AddEdges(0, n - 1, a, d);
sort(edges.begin(), edges.end(), [](TEdge e1, TEdge e2) { return e1.w < e2.w; });
for (int i = 0; i < n; ++i) parent[i] = i;
ll result = 0;
for (auto e : edges) {
//cerr << e.a << " " << e.b << " " << e.w << endl;
if (GetRoot(e.a) == GetRoot(e.b)) continue;
result += e.w;
Unite(e.a, e.b);
}
cout << result << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,d,ret,a[200005],dpl[200005],dpr[200005];
signed main()
{
cin>>n>>d;
for(int i=0;i<n;i++)
{
cin>>a[i];
ret+=a[i];
}
ret+=(n-1)*d;
dpr[0]=a[0];
for(int i=1;i<n;i++)
dpr[i]=min(a[i],dpr[i-1]+d);
dpl[n-1]=a[n-1];
for(int i=n-2;i>=0;i--)
dpl[i]=min(a[i],dpl[i+1]+d);
for(int i=1;i<n-1;i++)
ret+=min(dpl[i],dpr[i]);
cout<<ret<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define ll long long
#define pi pair<int,int>
#define pl pair<ll,ll>
#define pd pair<double,double>
#define ld long double
#define pld pair<ld,ld>
#define lg length()
#define sz size()
#define vi vector<int>
#define vl vector<ll>
#define vp vector<pi>
#define vpl vector<pl>
#define pb push_back
#define INF 1000000005
#define LINF 1000000000000000005
int n,p[200005],r[200005];
ll d,a[200005],f[200005],g[200005],ans;
vector <pair<ll,pi>> s;
int Par(int nod){
if(p[p[nod]]==p[nod]) return p[nod];
else return p[nod]=Par(p[nod]);
}
void Unite(int x, int y){
x=Par(x); y=Par(y);
if(x==y) return;
if(r[x]>r[y]) swap(x,y);
if(r[x]==r[y]) r[y]++;
p[x]=y;
}
void DC(int l, int r){
if(l==r) return;
int mid=(l+r)/2;
DC(l,mid);
DC(mid+1,r);
int x=0,y=0;
for(int i=l;i<=mid;i++){
if(f[i]<f[x]) x=i;
}
for(int i=mid+1;i<=r;i++){
if(g[i]<g[y]) y=i;
}
for(int i=l;i<=mid;i++){
s.pb({f[i]+g[y],{i,y}});
}
for(int i=mid+1;i<=r;i++){
s.pb({f[x]+g[i],{x,i}});
}
}
int32_t main(){
ios_base :: sync_with_stdio(0); cin.tie(); cout.tie();
#ifdef LOCAL_DEFINE
ifstream cin("input.in");
#endif
cin >> n >> d;
for(int i=1;i<=n;i++){
cin >> a[i];
p[i]=i;
f[i]=-d*i+a[i];
g[i]=d*i+a[i];
}
f[0]=g[0]=LINF;
DC(1,n);
sort(s.begin(),s.end());
for(pair<ll,pi> i : s){
if(Par(i.y.x)==Par(i.y.y)) continue;
Unite(i.y.x,i.y.y);
ans+=i.x;
}
cout << ans;
#ifdef LOCAL_DEFINE
cerr << "\nTime elapsed: " << 1.0*clock()/CLOCKS_PER_SEC << " \n";
#endif
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef pair<ll,ll> pi;
typedef vector<pi> vpi;
typedef long double ld;
#define pb emplace_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define ALL(x) x.begin(), x.end()
#define SZ(x) (ll)x.size()
#define f first
#define s second
#define MAXN 200100
pi t;
ll A[MAXN];
ll nearest[MAXN];
ll N,K;
ll done[MAXN];
vi V;
ll val(ll x, ll y){
return A[x] + A[y] + K*abs(y-x);
}
int main(){
cin>>N>>K;
for (ll i=1;i<=N;++i)cin>>A[i];
t = mp(1e18,-1);
for (ll i=N;i>=1;--i){
nearest[i] = t.s;
if (K*i + A[i] < t.f){
t = mp(K*i+A[i], i);
}
}
ll cur = 1;
V.pb(1);
while (nearest[cur] != -1){
done[cur] = 1;
cur = nearest[cur];
V.pb(cur);
}
done[cur] = 1;
ll ans = 0;
ll bestp = A[1] - K;
for (ll i=1;i<SZ(V);++i){
ans += bestp + V[i]*K + A[V[i]];
// cout<<V[i]<<' '<<ans<<'\n';
bestp = min(bestp, A[V[i]]-K*V[i]);
}
bestp = A[1] - K;
for (ll i=0;i<SZ(V) - 1;++i){
for (ll j=V[i]+1;j<V[i+1];++j){
ans += min(bestp + j*K + A[j], val(V[i+1], j));
bestp = min(bestp, A[j] - K*j);
}
bestp = min(bestp, A[V[i+1]]-K*V[i+1]);
}
cout<<ans;
}
|
#include<bits/stdc++.h>
using namespace std;
#define FOR(a, b, c) for(int a = b; a <= c; ++a)
#define fi first
#define se second
#define pb push_back
#define int long long
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
const int N = 2e5 + 10;
const int oo = 1e18;
int n, D, ans = 0;
int A[N], val[N], pr[N];
vector<iii> edge;
int nfind(int u) { return (pr[u] == u) ? u : (pr[u] = nfind(pr[u])); }
void addeg(int u, int v) {
if(nfind(u) == nfind(v)) return;
ans += D * abs(u - v) + A[u] + A[v];
pr[nfind(u)] = nfind(v);
}
void solve(int lef, int rig) {
if(lef >= rig) return;
int mid = (lef + rig) / 2;
ii minl = {oo, 0}, minr = {oo, 0};
FOR(i, lef, mid) {
val[i] = A[i] - i * D;
minl = min(minl, {val[i], i});
}
FOR(i, mid + 1, rig) {
val[i] = A[i] + i * D;
minr = min(minr, {val[i], i});
}
FOR(i, lef, mid) edge.pb({val[i] + minr.fi, {i, minr.se}});
FOR(i, mid + 1, rig) edge.pb({val[i] + minl.fi, {i, minl.se}});
solve(lef, mid); solve(mid + 1, rig);
}
signed main() {
// freopen("test.inp", "r", stdin);
// freopen("test.out", "w", stdout);
ios_base::sync_with_stdio(false); cout.tie(0);
cin >> n >> D;
FOR(i, 1, n) pr[i] = i;
FOR(i, 1, n) cin >> A[i];
solve(1, n);
sort(edge.begin(), edge.end());
for(auto i: edge) addeg(i.se.fi, i.se.se);
return cout << ans, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef unsigned long long ull;
#define fst first
#define sed second
#define pb push_back
#define mp make_pair
#define rt register int
#define all(it) it.begin(), it.end()
#define rep(it, f, e) for (rt it = f; it <= e; ++it)
#define per(it, f, e) for (rt it = f; it >= e; --it)
const int MAXN = 2e5 + 10;
int A[MAXN];
ll dpl[MAXN], dpr[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n, d;
cin >> n >> d;
ll ans = (n - 1ll) * d;
rep (i, 1, n) {
cin >> A[i];
ans += A[i];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
dpl[1] = A[1];
rep (i, 2, n) {
dpl[i] = min((ll)A[i], dpl[i - 1] + d);
}
dpr[n] = A[n];
per (i, n - 1, 1) {
dpr[i] = min((ll)A[i], dpr[i + 1] + d);
}
rep (i, 2, n - 1) {
ans += min(dpl[i], dpr[i]);
}
cout << ans <<endl;
return 0;
}
|
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
using lint = long long int;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); }; } fast_ios_;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template<typename T> void Min(T &m, const T q) { if (m > q) m = q; }
int N;
lint D;
vector<lint> A;
int main()
{
cin >> N >> D;
A.resize(N);
for (auto &v : A) cin >> v;
lint res = accumulate(A.begin(), A.end(), 0LL);
REP(i, N - 1) Min(A[i + 1], A[i] + D);
IREP(i, N - 1) Min(A[i], A[i + 1] + D);
cout << res + accumulate(A.begin(), A.end(), 0LL) - A[0] - A[N - 1] + (N - 1) * D << endl;
}
|
#include <bits/stdc++.h>
#define ll long long
#define mp make_pair
#define pb push_back
#define INF 0x3f3f3f3f
using namespace std;
ll l[200001],dpr[200001],dpl[200001];
void solve()
{
int n;
cin>>n;
ll d;
cin>>d;
ll ret=0;
for (int i=0;i<n;i++) cin>>l[i],ret+=l[i];
ret+=(n-1)*d;
dpr[0]=l[0];
for (int i=1;i<n;i++) dpr[i]=min(l[i],dpr[i-1]+d);
dpl[n-1]=l[n-1];
for (int i=n-2;i>=0;i--) dpl[i]=min(l[i],dpl[i+1]+d);
for (int i=1;i<n-1;i++) ret+=min(dpl[i],dpr[i]);
cout<<ret;
}
int main()
{
solve();
return 0;
}
|
#include <iostream>
#include <utility>
#include <queue>
#include <stdlib.h>
#define llint long long
#define inf 1e18
using namespace std;
typedef pair<llint, llint> P;
llint n, d;
llint a[200005];
priority_queue< P, vector<P>, greater<P> > Q;
llint l[200005], r[200005];
int main(void)
{
cin >> n >> d;
for(int i = 1; i <= n; i++) cin >> a[i];
a[0] = a[n+1] = inf;
for(int i = 1; i <= n; i++){
l[i] = i-1, r[i] = i+1;
}
llint ans = 0;
for(int i = 1; i <= n; i++) Q.push(make_pair(a[i], i));
while(Q.size()){
llint p = Q.top().second;
Q.pop();
if(l[p] > 0 && l[p] <= n){
ans += d + a[p] + a[l[p]];
a[l[p]] = min(a[p]+d, a[l[p]]);
r[l[p]] = 0;
Q.push(make_pair(a[l[p]], l[p]));
a[p] = min(a[p], a[l[p]]+d);
l[p] = 0;
Q.push(make_pair(a[p], p));
}
else if(r[p] > 0 && r[p] <= n){
ans += d + a[p] + a[r[p]];
a[r[p]] = min(a[p]+d, a[r[p]]);
l[r[p]] = 0;
Q.push(make_pair(a[r[p]], r[p]));
a[p] = min(a[p], a[r[p]]+d);
r[p] = 0;
Q.push(make_pair(a[p], p));
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef pair <int, int> pii;
typedef pair <long long, pii> plii;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n;
long long d;
long long a[200010];
int fa[200010];
vector <plii> e;
int find(int x){
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
long long fl(int x){
return x == -1 ? INF : a[x] - x * d;
}
long long fr(int x){
return x == -1 ? INF : a[x] + x * d;
}
void add_edge(int l, int r){
if (l == r) return ;
int mid = (l + r) >> 1;
int pos = -1;
for (int i = l; i <= mid; i++){
if (fl(i) < fl(pos)) pos = i;
}
for (int i = mid + 1; i <= r; i++){
e.push_back(mp(a[i] + a[pos] + (i - pos) * d, mp(i, pos)));
}
pos = -1;
for (int i = mid + 1; i <= r; i++){
if (fr(i) < fr(pos)) pos = i;
}
for (int i = l; i <= mid; i++){
e.push_back(mp(a[i] + a[pos] + (pos - i) * d, mp(i, pos)));
}
add_edge(l, mid), add_edge(mid + 1, r);
}
int main(){
scanf("%d%lld", &n, &d);
for (int i = 0; i < n; i++){
scanf("%d", &a[i]);
}
add_edge(0, n - 1);
sort(e.begin(), e.end());
for (int i = 0; i < n; i++){
fa[i] = i;
}
long long ans = 0;
int tot = n - 1;
for (int i = 0; i < e.size(); i++){
int u = e[i].se.fi, v = e[i].se.se;
long long dist = e[i].fi;
if (find(u) == find(v)) continue;
fa[find(u)] = find(v);
ans += dist, tot--;
if (!tot) break;
}
printf("%lld\n", ans);
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
int main(){
ll N,D;
ll A[200005];
cin>>N>>D;
ll ret = D*(N-1);
for(int i = 0;i < N;i++){
cin>>A[i];
ret += A[i];
}
for(int i = 1;i < N;i++){
A[i]=min(A[i-1]+D,A[i]);
}
for(int i = N-2;i >=0;i--){
A[i]=min(A[i+1]+D,A[i]);
}
for(int i = 1;i < N-1;i++){
ret += A[i];
}
cout<<ret<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pi;
typedef pair<ll,pi> pii;
typedef vector<int> vi;
#define f first
#define s second
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define forn(i, n) for(register int i=0; i<n; i++)
#define Forn(i, n) for(register int i=1; i<=n; i++)
#define foreach(it, a) for(__typeof((a).begin()) it=(a).begin(); it!=(a).end(); it++)
#define Foreach(it, a) for(__typeof((a).rbegin()) it=(a).rbegin(); it!=(a).rend(); it++)
#define INF 1999999999999999999LL
inline int in()
{
char c=getchar();
int neg=1, x=0;
while(!isdigit(c)) (c=='-')?neg=-1, c=getchar():c=getchar();
while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48), c=getchar();
return neg*x;
}
const int MAX=2e5+5;
int N;
ll A[MAX], D, ret;
vector<pii> e;
namespace DSU
{
int par[MAX];
inline void init()
{
Forn(i, MAX-1)
par[i]=i;
}
inline int find(int x)
{
return x==par[x]?x:par[x]=find(par[x]);
}
inline int unite(int x, int y)
{
x=find(x), y=find(y);
if(x==y)
return 0;
par[x]=y;
return 1;
}
}
inline void solve(int l, int r)
{
if(l==r)
return;
int m=l+r>>1, pl=-1, pr=-1;
ll mnl=INF, mnr=INF;
for(int i=l; i<=m; i++)
{
ll vl=A[i]-1LL*D*i;
if(mnl>vl)
mnl=vl, pl=i;
}
for(int i=m+1; i<=r; i++)
{
ll vr=A[i]+1LL*D*i;
if(mnr>vr)
mnr=vr, pr=i;
}
for(int i=l; i<=m; i++)
{
ll vl=A[i]-1LL*D*i;
e.pb(mp(vl+mnr, mp(i, pr)));
}
for(int i=m+1; i<=r; i++)
{
ll vr=A[i]+1LL*D*i;
e.pb(mp(mnl+vr, mp(pl, i)));
}
solve(l, m);
solve(m+1, r);
}
int main()
{
DSU::init();
N=in(), D=in();
Forn(i, N)
A[i]=in();
solve(1, N);
sort(all(e));/*
foreach(it, e)
cout<<it->f<<" "<<it->s.f<<" "<<it->s.s<<endl;*/
foreach(it, e)
ret+=DSU::unite(it->s.f, it->s.s)*it->f;
printf("%lld\n", ret);
return 0;
}
|
#include <stdio.h>
inline char gc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
#define gc getchar
inline long long read(){
long long now=0;int f=0;register char c=gc();
for(;c<48||c>57;c=='-'&&(f=1),c=gc());for(;c>47&&c<58;now=(now<<3)+(now<<1)+c-'0',c=gc());
return f?-now:now;
}
#define Maxn 200005
long long n,d,a[Maxn],dpl[Maxn],dpr[Maxn],ans;
long long Min(long long x, long long y) { return (((y - x) >> (64 - 1)) & (x ^ y)) ^ x; }
signed main()
{
n=read(),d=read();
for (int i=0;i<n;++i) a[i]=read(),ans+=a[i];
ans+=(n-1)*d;dpl[0]=a[0];dpr[n-1]=a[n-1];
for (int i=1;i<n;++i) dpl[i]=Min(a[i],dpl[i-1]+d);
for (int i=n-2;~i;--i) dpr[i]=Min(a[i],dpr[i+1]+d);
for (int i=1;i<n-1;++i) ans+=Min(dpl[i],dpr[i]);
printf("%lld\n",ans);
return 0;
}
|
#include<vector>
#include<iostream>
#include<map>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<deque>
#define ll long long
using namespace std;
#define BUF_SIZE 1048576
char _buf[BUF_SIZE],*_is=_buf,*_it=_buf;
inline char rdc(){
if (_is==_it) _it=(_is=_buf)+fread(_buf,1,BUF_SIZE,stdin);
return *_is++;
}
inline void rdi(int &x){
int f=0;
register char ch=rdc();
while ((ch<'0' or ch>'9') and (ch^'-')) ch=rdc();
if (ch=='-') f=1,ch=rdc();
while (ch>='0' and ch<='9') x=(x<<3)+(x<<1)+(ch^'0'),ch=rdc();
if(f) x=-x;
}
inline void rdi(ll &x){
ll f=0;
register char ch=rdc();
while ((ch<'0' or ch>'9') and (ch^'-')) ch=rdc();
if (ch=='-') f=1,ch=rdc();
while (ch>='0' and ch<='9') x=(x<<3)+(x<<1)+(ch^'0'),ch=rdc();
if(f) x=-x;
}
inline void write(int x){
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void _write(int x){
write(x);
putchar(' ');
}
inline void print(int x){
write(x);
putchar('\n');
}
inline void write(ll x){
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void _write(ll x){
write(x);
putchar(' ');
}
inline void print(ll x){
write(x);
putchar('\n');
}
#define int ll
int res,n,d;
int a[200005];
int dpl[200005],dpr[200005];
signed main(){
rdi(n),rdi(d);
int i,j;
for(i=0;i<n;++i) rdi(a[i]),res+=a[i];
res+=(n-1)*d;
dpr[0]=a[0];
for(i=1;i<n;++i) dpr[i]=min(a[i],dpr[i-1]+d);
dpl[n-1]=a[n-1];
for(i=n-2;~i;--i) dpl[i]=min(a[i],dpl[i+1]+d);
for(i=1;i<n-1;++i) res+=min(dpl[i],dpr[i]);
print(res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N;
ll D;
ll A[202020];
ll L[202020],R[202020];
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N>>D;
ll ret=0;
FOR(i,N) {
cin>>A[i];
ret+=A[i];
L[i]=max((i?L[i-1]:-1LL<<60),i*D-A[i]);
}
ret+=(N-1)*D;
for(i=N-1;i>=0;i--) {
R[i]=min((i<N-1?R[i+1]:1LL<<60),i*D+A[i]);
if(i>0 && i<N-1) ret+=min(i*D-L[i],R[i]-(i*D));
}
cout<<ret<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9+7;
//const ll MOD = 998244353;
const int inf = (1<<30)-1;
const ll INF = (1LL<<60)-1;
const ld EPS = 1e-10;
template<typename T> bool chmax(T &x, const T &y) {return (x < y)? (x = y, true) : false;};
template<typename T> bool chmin(T &x, const T &y) {return (x > y)? (x = y, true) : false;};
struct edge{int to; ll cost;};
const int MAX_V = 4e5;
vector<edge> es[MAX_V];
vector<int> col(MAX_V, -1);
vector<ll> d(MAX_V, INF);
void add_edge(int from, int to, ll cost){
es[from].eb((edge){to, cost});
es[to].eb((edge){from, cost});
}
void dijkstra(int n){
priority_queue<pli, vector<pli>, greater<pli> > que;
rep(i, n){
d[i] = 0, col[i] = i;
que.push(pli(d[i], i));
}
while(!que.empty()){
pli p = que.top();
que.pop();
int v = p.second;
if(p.first > d[v]) continue;
for(auto &e: es[v]){
if(chmin(d[e.to], d[v]+e.cost)){
col[e.to] = col[v];
que.push(pli(d[e.to], e.to));
}
}
}
}
int main(){
int N; ll D;
cin >> N >> D;
ll A[N];
rep(i, N){
cin >> A[i];
add_edge(i, N+i, A[i]);
}
rep(i, N-1) add_edge(N+i, N+i+1, D);
dijkstra(N);
ll ans = 0;
rep(i, 2*N){
for(auto &e: es[i]){
int u = col[i], v = col[e.to];
if(u < v){
ans += A[u]+A[v]+D*abs(u-v);
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define int long long
#define P(x) {if (debug) cout << x << endl;}
#define H(x) P(#x << ": " << (x))
#define FR(i,a,b) for (int i=(a); i<(b); i++)
#define F(i,n) FR(i,0,n)
#define DR(i,a,b) for (int i=(b); i-->(a);)
#define D(i,n) DR(i,0,n)
#define S(s) (int)(s).size()
#define ALL(v) v.begin(), v.end()
#define MI(a,v) a = min(a,v)
#define MA(a,v) a = max(a,v)
#define V vector
#define pb push_back
#define mt make_tuple
using namespace std;
template<class T> ostream &operator<<(ostream &os, V<T> v) {
F(i,S(v)) os<<(i?" ":"")<<v[i];
return os;
}
const bool debug = 0;
const int INF = 1e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n,d; cin>>n>>d;
V<int> a(n);
F(i,n) {
cin>>a[i];
}
V<int> prefMin(n+1), sufMin(n+1);
prefMin[0] = INF;
F(i,n) {
prefMin[i+1] = min(a[i], prefMin[i]+d);
}
sufMin[n] = INF;
D(i,n) {
sufMin[i] = min(a[i], sufMin[i+1]+d);
}
int cost = max(n-1, 0LL)*d;
H(cost)
F(i,n) {
cost += a[i];
}
H(cost)
FR(i,1,n-1) {
int here = min(prefMin[i+1], sufMin[i]);
if (here < a[i]) {
P(i)
H(here)
H(prefMin[i+1])
H(sufMin[i])
}
assert(here <= a[i]);
cost += here;
}
cout<<cost<<"\n";
}
|
#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
using namespace std;
long long n,d,a[200005],r[200005],l[200005];
int main()
{
cin>>n>>d;
long long ret=0;
for(int i=0;i<n;i++)
{
cin>>a[i];
ret+=a[i];
}
ret+=(n-1)*d;
//cout<<ret<<endl;
r[0]=a[0];
for(int i=1;i<n;i++)
r[i]=min(a[i],r[i-1]+d);
l[n-1]=a[n-1];
for(int i=n-2;i>=0;i--)
l[i]=min(a[i],l[i+1]+d);
for(int i=1;i<n-1;i++)
ret+=min(l[i],r[i]);
cout<<ret;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef pair<ll, P> Pi;
int par[200002];
int rk[200002];
void init(int n){
for(int i=0; i<n; i++){
par[i]=i; rk[i]=0;
}
}
int find(int x){
if(par[x]==x){
return x;
}else{
return par[x]=find(par[x]);
}
}
void unite(int x, int y){
x=find(x);
y=find(y);
if(x==y) return;
if(rk[x]<rk[y]){
par[x]=y;
}else{
par[y]=x;
if(rk[x]==rk[y]) rk[x]++;
}
}
bool same(int x, int y){
return find(x)==find(y);
}
int n;
ll d;
ll a[200001];
vector<Pi> e;
void solve(int l, int r){
if(l==r) return;
int m=(l+r)/2;
int i1=l; ll mn=a[l]-(ll)l*d;
for(int i=l+1; i<=m; i++){
if(mn>a[i]-(ll)i*d) mn=a[i]-(ll)i*d, i1=i;
}
for(int i=m+1; i<=r; i++) e.push_back(Pi(a[i]+a[i1]+(ll)(i-i1)*d, P(i1, i)));
i1=m+1, mn=a[m+1]+(ll)(m+1)*d;
for(int i=m+2; i<=r; i++){
if(mn>a[i]+(ll)i*d) mn=a[i]+(ll)i*d, i1=i;
}
for(int i=l; i<=m; i++) e.push_back(Pi(a[i]+a[i1]+(ll)(i1-i)*d, P(i1, i)));
solve(l, m);
solve(m+1, r);
}
int main()
{
cin>>n>>d;
for(int i=0; i<n; i++){
cin>>a[i];
}
if(n==1){
cout<<0<<endl;
return 0;
}
solve(0, n-1);
ll ans=0;
sort(e.begin(), e.end());
init(n);
for(int i=0; i<e.size(); i++){
int x=e[i].second.first, y=e[i].second.second;
if(!same(x, y)){
unite(x, y);
ans+=e[i].first;
}
}
cout<<ans<<endl;
return 0;
}
|
// Code by Denverjin.
#include <bits/stdc++.h>
using namespace std;
using ld = double;
using ll = long long;
using ull = unsigned long long;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int SZ = 1 << 13;
char buff[SZ], *pos = buff + SZ - 1;
#define getchar() (++ pos == buff + SZ ? fread(pos = buff, 1, SZ, stdin), *pos : *pos)
inline ll read() {
ll x = 0; int f = 1, c = getchar();
for (;!isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x<<3) + (x<<1) + (c^48);
return x * f;
}
const int N = 1 << 20;
int n, D;
ll dpL[N], dpR[N];
ll a[N];
int main() {
n = read(), D = read();
for (int i = 0; i < n; ++ i) a[i] = read();
dpL[0] = a[0];
for (int i = 1; i < n; ++ i) dpL[i] = min(a[i], dpL[i - 1] + D);
dpR[n - 1] = a[n - 1];
for (int i = n - 2; ~i; -- i) dpR[i] = min(a[i], dpR[i + 1] + D);
ll res = 1LL * D * (n - 1);
for (int i = 0; i < n; ++ i) res += a[i];
for (int i = 1; i < n - 1; ++ i) res += min(dpL[i], dpR[i]);
printf("%lld\n", res);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int n;
long long D;
long long a[200005];
pair<long long,int> co1[200005],co2[200005];
struct Node{
int v,u;
long long cost;
Node(int xv=0,int xu=0,long long xcost=0){
v=xv;u=xu;cost=xcost;
}
bool operator <(const Node &a) const{
return cost<a.cost;
}
};
vector<Node> edge;
void solve(int l,int r){
if(l>=r) return;
int mid=l+r>>1;
// cout<<l<<" "<<r<<endl;
solve(l,mid);solve(mid+1,r);
sort(co1+l,co1+mid+1);sort(co2+mid+1,co2+r+1);
for(int i=l;i<=mid;i++){
edge.push_back(Node(co1[i].second,co2[mid+1].second,co1[i].first+co2[mid+1].first));
}
for(int i=mid+1;i<=r;i++){
edge.push_back(Node(co1[l].second,co2[i].second,co1[l].first+co2[i].first));
}
}
int pa[200005];
int find(int x){
return (pa[x]==x)?x:pa[x]=find(pa[x]);
}
void merge(int x,int y){
x=find(x);y=find(y);
pa[x]=y;
}
int main(){
scanf("%d %lld",&n,&D);
for(int i=0;i<n;i++){
scanf("%lld",&a[i]);
co1[i]=make_pair(a[i]-(i+1)*D,i);
co2[i]=make_pair(a[i]+(i+1)*D,i);
}
solve(0,n-1);
sort(edge.begin(),edge.end());
// cout<<"lala"<<endl;
for(int i=0;i<=n;i++) pa[i]=i;
long long res=0;
for(int i=0;i<edge.size();i++){
int v=edge[i].v,u=edge[i].u;
long long co=edge[i].cost;
// cout<<u<<" "<<v<<" "<<co<<endl;
if(find(v)!=find(u)){
merge(v,u);
res+=co;
}
}
cout<<res;
}
|
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
using namespace std;
const int maxn = 200100;
ll a[maxn], n, d;
ll f[maxn], g[maxn];
int getf(int l, int r) {
ll minvalue = LLONG_MAX;
int ind = 0;
for(int i=l;i<=r;i++) {
if(f[i] < minvalue) {
minvalue = f[i];
ind = i;
}
}
return ind;
}
int getg(int l, int r) {
ll minvalue = LLONG_MAX;
int ind = 0;
for(int i=l;i<=r;i++) {
if(g[i] < minvalue) {
minvalue = g[i];
ind = i;
}
}
return ind;
}
vector<pair<ll, pair<int,int> > > edges;
void solve(int l, int r) {
if(l >= r) return;
else {
int mid = (l + r) / 2;
int fi = getf(l, mid);
int si = getg(mid+1, r);
for(int i=l;i<=mid;i++) {
edges.pb(mp(f[i] + g[si], mp(i, si)));
}
for(int i=mid+1;i<=r;i++) {
edges.pb(mp(f[fi] + g[i], mp(fi, i)));
}
solve(l, mid);
solve(mid+1, r);
}
}
int uparent[maxn];
int usize[maxn];
int ufind(int x) {
while(uparent[x] != x) {
x = uparent[x];
}
return x;
}
void unite(int x, int y) {
x = ufind(x);
y = ufind(y);
if(x == y) return;
if(usize[x] > usize[y]) {
uparent[y] = x;
usize[x] += usize[y];
}
else {
uparent[x] = y;
usize[y] += usize[x];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin>>n>>d;
for(ll i=1LL;i<=n;i++) {
cin>>a[i];
f[i] = a[i] - 1LL * i * d;
g[i] = a[i] + 1LL * i * d;
uparent[i] = i;
usize[i] = 1;
}
solve(1, n);
sort(edges.begin(), edges.end());
ll result = 0LL;
int br = 0;
for(auto i:edges) {
int x = i.second.first;
int y = i.second.second;
if(x == y) continue;
if(ufind(x) != ufind(y)) {
unite(x, y);
result += i.first;
br++;
}
}
cout<<result<<"\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ran 200020
#define i64 long long int
int n;
vector<pair<i64,pair<int,int> > > w;
i64 a[ran], d, u[ran], v[ran];
void add_edge(int x,int y){
w.push_back(make_pair(labs(x-y)*d+a[x]+a[y], make_pair(x,y)));
}
void dfs(int s,int e){
if(s == e)return;
int m = (s + e)/2;
dfs(s, m);
dfs(m+1, e);
int A = s, B = e;
for(int i=s; i<=m; i++)if(u[i] < u[A])A = i;
for(int i=m+1; i<=e; i++)if(v[i] < v[B])B = i;
for(int i=s; i<=m; i++)add_edge(B, i);
for(int i=m+1; i<=e; i++)add_edge(A, i);
}
int ace[ran];
int ancestor(int x){return x-ace[x]?ace[x]=ancestor(ace[x]):x;}
int main(){
ios::sync_with_stdio(false);
cin >> n >> d;
for(int i=0; i<n; i++){
cin >> a[i];
u[i] = a[i] - i * d;
v[i] = a[i] + i * d;
ace[i] = i;
}
dfs(0,n-1);
sort(w.begin(),w.end());
i64 res = 0;
for(auto p : w){
int x = p.second.first, y = p.second.second;
x = ancestor(x);
y = ancestor(y);
if(x == y)continue;
ace[x] = y;
res += p.first;
}
cout << res << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <utility>
#include <deque>
#include <stack>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<ll> vl;
typedef queue<int> qi;
typedef queue<ll> ql;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
#define rep(i,n) for (int i=0;i<n;i++)
#define mp make_pair
#define pb push_back
#define pf push_front
#define F first
#define S second
#define INF 200000009
class DSU{
public:
int fa[200005];
inline void init(){
for (int i=0;i<200005;++i) fa[i]=i;
}
inline int f(int x){
return fa[x]==x? x:fa[x]=f(fa[x]);
}
inline void u(int x,int y){
x=f(x);y=f(y);
if (x==y) return;
fa[x]=y;
}
inline bool same(int x,int y){
return (f(x)==f(y));
}
}dsu;
typedef pair<ll,pii> Edge;
vector<Edge> edges;
ll a[200005];ll d;
int n;
inline void solve(int l,int r){
if (l==r) return;
if (l==r-1){
edges.pb(mp(a[l]+a[r]+d,mp(l,r)));
return;
}
int m=(l+r)>>1;
solve(l,m);solve(m+1,r);
int bestl,bestr;
ll mincostl=1e18;
for (int i=l;i<=m;++i){
if (a[i]-d*i<mincostl){
mincostl=a[i]-d*i;bestl=i;
}
}
ll mincostr=1e18;
for (int i=m+1;i<=r;++i){
if (a[i]+d*i<mincostr){
mincostr=a[i]+d*i;bestr=i;
}
}
for (int i=l;i<=m;++i){
edges.pb(mp(mincostr+a[i]-d*i,mp(i,bestr)));
}
for (int i=m+1;i<=r;++i){
edges.pb(mp(mincostl+a[i]+d*i,mp(bestl,i)));
}
return;
}
int main(){
ios::sync_with_stdio(false);
cin>>n>>d;
for (int i=1;i<=n;++i) cin>>a[i];
if (n==1){
cout<<0<<endl;return 0;
}
solve(1,n);
sort(edges.begin(),edges.end());// smaller to bigger
reverse(edges.begin(),edges.end());// bigger to smaller
dsu.init();
ll ans=0;
while(!edges.empty()){
Edge E=edges.back();edges.pop_back();
ll u=E.S.F,v=E.S.S,cost=E.F;
if (dsu.same(u,v)) continue;
dsu.u(u,v);
ans+=cost;
}
cout<<ans;
return 0;
}
|
#include <iostream>
#include <queue>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
int main()
{
int n;
ll d;
cin >> n >> d;
ll a[200005];
priority_queue<P, vector<P>, greater<P>> que;
for(int i = 0; i < n; i++){
cin >> a[i];
que.push(P(a[i], i));
}
bool used[200005]{0};
ll ans = 0;
while(que.size()){
P p = que.top();
que.pop();
int u = p.second;
if(u > 0 && !used[u]){
ans += d + a[u] + a[u - 1];
if(d + a[u] < a[u - 1]){
a[u - 1] = d + a[u];
que.push(P(a[u - 1], u - 1));
}
used[u] = true;
}
if(u < n - 1 && !used[u + 1]){
ans += d + a[u] + a[u + 1];
if(d + a[u] < a[u + 1]){
a[u + 1] = d + a[u];
que.push(P(a[u + 1], u + 1));
}
used[u + 1] = true;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define INF (1LL<<55)
#define INF2 (1LL<<55)
using namespace std;
typedef long long ll;
typedef pair<ll,int> P;
struct edge{
int u,v;
ll c;
edge(){}
edge(int uu,int vv,ll cc){
u=uu;
v=vv;
c=cc;
}
bool operator<(const edge &e)const{
return c<e.c;
}
};
struct uftree{
int par[200005];
int rank[200005];
uftree(){
}
void init(int n){
for(int i=0;i<n;i++){
par[i]=i;
rank[i]=0;
}
}
int find(int x){
if(par[x]==x)return x;
return par[x]=find(par[x]);
}
void unite(int x,int y){
x=find(x);
y=find(y);
if(x==y)return;
if(rank[x]<rank[y]){
par[x]=y;
}else{
if(rank[x]==rank[y])rank[x]++;
par[y]=x;
}
}
bool same(int x,int y){
return find(x)==find(y);
}
};
int n;
ll d;
ll a[200005];
uftree uf;
vector<edge> e;
void dfs(int l,int r){
if(l>=r)return;
int mid=(l+r)/2;
int lv=mid,rv=mid;
for(int i=l;i<=mid;i++){
if((a[mid]+a[lv]+d*(mid-lv))>(a[mid]+a[i])+d*(mid-i)){
lv=i;
}
}
for(int i=mid;i<r;i++){
if((a[mid]+a[rv]+d*(rv-mid))>(a[mid]+a[i])+d*(i-mid)){
rv=i;
}
}
for(int i=l;i<=mid;i++){
e.push_back(edge(i,rv,a[i]+a[rv]+d*(rv-i)));
}
for(int i=mid;i<r;i++){
e.push_back(edge(i,lv,a[i]+a[lv]+d*(i-lv)));
}
if(l+1==r)return;
dfs(l,mid);
dfs(mid,r);
}
int main(void){
scanf("%d%lld",&n,&d);
for(int i=0;i<n;i++){
scanf("%lld",&a[i]);
}
if(n==1){
printf("0\n");
return 0;
}
dfs(0,n);
ll ans=0;
uf.init(n);
sort(e.begin(),e.end());
for(int i=0;i<e.size();i++){
if(!uf.same(e[i].u,e[i].v)){
//printf("%d %d %lld\n",e[i].u,e[i].v,e[i].c);
uf.unite(e[i].u,e[i].v);
ans+=e[i].c;
}
}
printf("%lld\n",ans);
return 0;
}
|
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 200005
#define ll long long
#define ld double
#define mod 998244353
using namespace std;
int n, d;
int a[maxn];
struct eg
{
int u, v;
ll c;
bool operator < (const eg &t)const
{
return c < t.c;
}
}as[maxn * 20];
int ncnt = 0;
int fa[maxn];
int gfa(int a)
{
if(fa[a] == a) return a;
return fa[a] = gfa(fa[a]);
}
ll b[maxn];
void work(int l, int r)
{
if(l == r) return;
int mid = (l + r) >> 1;
int lmin = l, rmin = mid + 1;
for(int i = l; i <= mid; i++)
{
b[i] = a[i] - 1ll * i * d;
if(b[i] < b[lmin]) lmin = i;
}
for(int i = mid + 1; i <= r; i++)
{
b[i] = a[i] + 1ll * i * d;
if(b[i] < b[rmin]) rmin = i;
}
for(int i = l; i <= mid; i++)
as[ncnt].u = i, as[ncnt].v = rmin,
as[ncnt++].c = b[rmin] + b[i];
for(int i = mid + 1; i <= r; i++)
as[ncnt].u = i, as[ncnt].v = lmin,
as[ncnt++].c = b[lmin] + b[i];
work(l, mid),
work(mid + 1, r);
}
int main()
{
scanf("%d%d", &n, &d);
for(int i = 1; i <= n; i++)
scanf("%d", &a[i]);
work(1, n);
sort(as, as + ncnt);
for(int i = 1; i <= n; i++)
fa[i] = i;
ll ans = 0;
for(int i = 0; i < ncnt; i++)
{
int ufa = gfa(as[i].u), vfa = gfa(as[i].v);
if(ufa != vfa)
ans += as[i].c, fa[ufa] = vfa;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define null ""
#define all(dat) dat.begin(), dat.end()
#define over(msg) cout << msg << endl, exit(0);
#define loop(i, to) for (int i = 0; i < to; ++i)
#define cont(i, to) for (int i = 1; i <= to; ++i)
#define circ(i, fr, to) for (int i = fr; i <= to; ++i)
#define foreach(i, dat) for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
typedef long long num;
using namespace std;
struct edge {
int u, v;
num val;
edge() {}
edge(int u, int v, num val) {
this->u = u;
this->v = v;
this->val = val;
}
};
int n, pr[200005];
num ans, d, w[200005];
vector<edge> dat;
bool inline cmp(edge a, edge b) {
return a.val < b.val;
}
int find_pr(int a) {
return pr[a] == a ? a : pr[a] = find_pr(pr[a]);
}
void solve(int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1, pl = 0, pr = 0;
num ml = 5e18, mr = 5e18;
circ (i, l, mid) {
num cur = w[i] - d * i;
if (cur < ml) {
pl = i;
ml = cur;
}
}
circ (i, mid + 1, r) {
num cur = w[i] + d * i;
if (cur < mr) {
pr = i;
mr = cur;
}
}
circ (i, mid + 1, r) {
dat.push_back(edge(pl, i, ml + w[i] + d * i));
}
circ (i, l, mid) {
dat.push_back(edge(i, pr, mr + w[i] - d * i));
}
solve(l, mid);
solve(mid + 1, r);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> d;
cont (i, n) {
cin >> w[i];
}
solve(1, n);
sort(all(dat), cmp);
cont (i, n) {
pr[i] = i;
}
loop (i, dat.size()) {
int u = dat[i].u, v = dat[i].v, pu = find_pr(u), pv = find_pr(v);
num val = dat[i].val;
if (pu == pv) continue;
pr[pv] = pu;
ans += val;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int>pli;
typedef pair<ll,pair<int,int>>plii;
const pli M(1ll<<60,0);
const int N=2e5+5;
struct node{
int lb,rb,md;
pli m[4];plii al;
}t[N<<2];
int n,D,a[N],i;ll ans;
bool b[N];
inline void set1(int i,int l){
t[i].m[0]=pli(a[l]-1ll*l*D,l);
t[i].m[1]=pli(a[l]+1ll*l*D,l);
t[i].m[2]=t[i].m[3]=M;t[i].al=make_pair(1ll<<60,make_pair(0,0));
}
inline void set2(int i,int l){
t[i].m[2]=pli(a[l]-1ll*l*D,l);
t[i].m[3]=pli(a[l]+1ll*l*D,l);
t[i].m[0]=t[i].m[1]=M;t[i].al=make_pair(1ll<<60,make_pair(0,0));
}
inline plii F(pli a,pli b){return make_pair(a.first+b.first,make_pair(a.second,b.second));}
inline void maintain(int i){
for(int j=0;j<4;++j)t[i].m[j]=min(t[i<<1].m[j],t[i<<1|1].m[j]);
t[i].al=min(min(t[i<<1].al,t[i<<1|1].al),min(F(t[i<<1].m[0],t[i<<1|1].m[3]),
F(t[i<<1].m[2],t[i<<1|1].m[1])));
}
void build(int i,int l,int r){
t[i].lb=l;t[i].rb=r;t[i].md=l+r>>1;
if(l==r)return l==1?set1(i,l):set2(i,l);
build(i<<1,l,t[i].md);build(i<<1|1,t[i].md+1,r);
maintain(i);
}
void mdy(int i,int l){
if(t[i].lb==t[i].rb)return set1(i,l);
mdy(i<<1|(t[i].md<l),l);maintain(i);
}
int main(){
scanf("%d%d",&n,&D);for(i=1;i<=n;++i)scanf("%d",a+i);build(1,1,n);
b[1]=1;
for(i=1;i<n;++i){
int x=t[1].al.second.first,y=t[1].al.second.second;
ans+=t[1].al.first;if(b[x])b[y]=1,mdy(1,y);else b[x]=1,mdy(1,x);
}
printf("%lld\n",ans);
return 0;
}
|
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pli;
#define fir first
#define sec second
#define Mp make_pair
const int MAXN = 2e5 + 5;
int a[MAXN];
ll lval[MAXN],rval[MAXN];
struct Edge
{
int u,v;
ll w;
};
inline bool cmp(const Edge &p,const Edge &q){ return p.w<q.w;}
vector<Edge> e;
int fa[MAXN];
inline void init(int n){ for(int i=1; i<=n; ++i) fa[i]=i;}
int find(int u){ return fa[u]==u? u: fa[u]=find(fa[u]);}
void connect(int u,int v){ fa[find(u)]=find(v);}
void gao(int l,int r)
{
if(l==r) return;
int mid = (l+r)>>1;
ll lmn = lval[l];
int lpos = l;
for(int i=l; i<=mid; ++i)
if(lmn > lval[i])
lmn = lval[i], lpos = i;
ll rmn = rval[r];
int rpos = r;
for(int i=mid+1; i<=r; ++i)
if(rmn > rval[i])
rmn = rval[i], rpos = i;
for(int i=l; i<=mid; ++i)
e.push_back((Edge){ i, rpos, lval[i] + rmn});
for(int i=mid+1; i<=r; ++i)
e.push_back((Edge){ lpos, i, lmn + rval[i]});
gao(l,mid); gao(mid+1,r);
}
int main(void)
{
int n;
ll d;
scanf("%d%lld",&n,&d);
for(int i=1; i<=n; ++i) scanf("%d",&a[i]);
for(int i=1; i<=n; ++i)
lval[i] = a[i] - d*i,
rval[i] = a[i] + d*i;
gao(1,n);
sort(e.begin(),e.end(),cmp);
ll ans=0;
init(n);
for(int i=0; i<(int)e.size(); ++i)
{
int u=e[i].u, v=e[i].v;
ll w=e[i].w;
if(find(u) == find(v)) continue;
ans += w;
connect(u,v);
}
printf("%lld",ans);
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
const int maxn = 2e5 + 5;
int lab[maxn], N;
int a[maxn], D;
vector<pair<ll, ii>> edge;
void init(int n)
{
for(int i = 1; i <= n; ++i)
lab[i] = -1;
}
int finds(int u)
{
if(lab[u] < 0) return u;
return lab[u] = finds(lab[u]);
}
bool merges(int u, int v)
{
u = finds(u); v = finds(v);
if(u == v) return false;
if(lab[v] < lab[u]) swap(u, v);
lab[u] += lab[v];
lab[v] = u;
return true;
}
void solve(int l, int r)
{
if(l >= r) return;
int mid = (l + r) / 2;
solve(l, mid); solve(mid + 1, r);
int minl = l, minr = mid + 1;
for(int i = l; i <= mid; ++i)
if(1ll * D * (mid - i) + a[i] < 1ll * D * (mid - minl) + a[minl])
minl = i;
for(int i = mid + 1; i <= r; ++i)
if(1ll * D * (i - mid) + a[i] < 1ll * D * (minr - mid) + a[minr])
minr = i;
for(int i = l; i <= mid; ++i)
edge.eb(1ll * D * (minr - i) + a[i] + a[minr], mp(i, minr));
for(int i = mid + 1; i <= r; ++i)
edge.eb(1ll * D * (i - minl) + a[i] + a[minl], mp(i, minl));
}
signed main(void)
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifdef LOCAL
freopen("A.INP", "r", stdin);
freopen("A.OUT", "w", stdout);
#endif // LOCAL
cin >> N >> D;
for(int i = 1; i <= N; ++i)
cin >> a[i];
solve(1, N);
init(N);
sort(edge.begin(), edge.end());
ll res = 0;
for(auto & all : edge){
if(merges(all.se.fi, all.se.se)){
res += all.fi;
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF (INT64_MAX)
#define MOD (1000000000+7)
#define MAX 200000
int N;
long long D;
long long A[MAX + 1];
typedef pair<int, int> P;
typedef pair<long long, P> Edge;
vector<Edge> edges;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) {
return -par[root(x)];
}
};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
void rec(int left, int right)
{
if (right - left <= 1) return;
int mid = (left + right) / 2;
long long leftmin = 1LL<<60;
int leftminp = -1;
for (int i = left; i < mid; ++i) if (chmin(leftmin, A[i]-D*i)) leftminp = i;
long long rightmin = 1LL<<60;
int rightminp = -1;
for (int i = mid; i < right; ++i) if (chmin(rightmin, A[i]+D*i)) rightminp = i;
for (int i = left; i < mid; ++i)
edges.push_back(make_pair(A[rightminp] + A[i] + D * (rightminp - i), make_pair(i, rightminp)));
for (int i = mid; i < right; ++i)
edges.push_back(make_pair(A[leftminp] + A[i] + D * (i - leftminp), make_pair(leftminp, i)));
rec(left, mid);
rec(mid, right);
}
int main() {
cin >> N >> D;
for( int i = 0; i < N; i++ ) {
cin >> A[i];
}
rec( 0, N );
sort( edges.begin(), edges.end() );
UnionFind uf( N );
long long ans = 0;
for( int i = 0; i < edges.size(); i++ ) {
Edge e = edges[i];
if( !uf.issame( e.second.first, e.second.second ) ) {
uf.merge( e.second.first, e.second.second );
ans += e.first;
}
}
cout << ans << endl;
return 0;
}
|
//By MagicSpark
/*
Problem:
Main Idea:
Status:
*/
#include<bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
#define int long long
using namespace std;
//using namespace __gnu_pbds;
const int inf=0x3f3f3f3f;
const long long inf2=0x3f3f3f3f3f3f3f3f;
const double eps=1e-6;
const int mod=1000000007;
typedef long long ll;
namespace fastio{
char in[100000];
int itr=0,llen=0;
char get(){
if(itr==llen)llen=fread(in,1,100000,stdin),itr=0;
if(llen==0)return EOF;
return in[itr++];
}
char out[100000];
int itr2=0;
void put(char c){
out[itr2++]=c;
if(itr2==100000){
fwrite(out,1,100000,stdout);
itr2=0;
}
}
int clear(){
fwrite(out,1,itr2,stdout);
itr2=0;
return 0;
}
int getint(){
int r=0; bool ng=0; char c; c=get();
while (c!='-'&&(c<'0'||c>'9')) c=get();
if (c=='-') ng=1, c=get();
while (c>='0'&&c<='9') r=r*10+c-'0', c=get();
return ng?-r:r;
}
string getstr(){
string ret="";
char ch=get();
while(ch==' '||ch=='\n')ch=get();
while(ch!=' '&&ch!='\n')ret.push_back(ch),ch=get();
return ret;
}
void putstr(string s){
for(int i=0;i<s.size();i++)put(s[i]);
}
void putint(int x){
if(x<0){
put('-');
x=-x;
}
if(x==0){
put('0');
return;
}
char c[20];int pos=0;
while(x){
c[pos++]='0'+x%10;
x/=10;
}
for(int i=pos-1;i>=0;i--)put(c[i]);
}
void getarr(int arrname[],int size){
for(int i=0;i<size;i++)arrname[i]=getint();
}
}
using namespace fastio;
#define fastio
int n,d;
int a[200005];
int dpl[200005],dpr[200005];
ll ans=0;
signed main(){
n=getint();d=getint();
if(n==1)return puts("0")&0;
for(int i=0;i<n;i++)a[i]=getint(),ans+=a[i];
ans+=(n-1)*d;
dpl[0]=a[0];
for(int i=1;i<n;i++)dpl[i]=min(dpl[i-1]+d,a[i]);
dpr[n-1]=a[n-1];
for(int i=n-2;i>=0;i--)dpr[i]=min(dpr[i+1]+d,a[i]);
for(int i=1;i<n-1;i++)ans+=min(dpl[i],dpr[i]);
cout<<ans<<endl;
return 0;
}
|
#include<cstdio>
//used segment tree to maintain point set
//0 for ai-d*i, 1 for ai+d*i
//a for visited, b for not
struct SegmentT{
int l,r;
int al,ar;
int bl,br;
int bestL, bestR;
SegmentT(){
l = r = 0;
al = ar = bl = br = bestL = bestR = -1;
}
};
SegmentT t[800005];
long long D;
long long a[200005];
int vis[200005];
const long long inf = 1e18+7;
long long getSingle(long long p,long long tag){
if(p==-1) return inf;
else return a[p]+tag*D*p;
}
long long getPair(long long l,long long r){
if(l==-1 || r==-1) return inf;
else return a[l]+a[r]+D*(r-l);
}
SegmentT merge(SegmentT a, SegmentT b){
SegmentT res;
res.l = a.l, res.r = b.r;
if(getSingle(a.al,-1)<getSingle(b.al,-1)) res.al = a.al;
else res.al = b.al;
if(getSingle(a.ar,1)<getSingle(b.ar,1)) res.ar = a.ar;
else res.ar = b.ar;
if(getSingle(a.bl,-1)<getSingle(b.bl,-1)) res.bl = a.bl;
else res.bl = b.bl;
if(getSingle(a.br,1)<getSingle(b.br,1)) res.br = a.br;
else res.br = b.br;
if(getPair(a.bestL,a.bestR)<getPair(b.bestL,b.bestR)) res.bestL = a.bestL, res.bestR = a.bestR;
else res.bestL = b.bestL, res.bestR = b.bestR;
if(getPair(a.al,b.br)<getPair(res.bestL,res.bestR)) res.bestL = a.al, res.bestR = b.br;
if(getPair(a.bl,b.ar)<getPair(res.bestL,res.bestR)) res.bestL = a.bl, res.bestR = b.ar;
return res;
}
void build(int p,int l,int r){
t[p].l = l, t[p].r = r;
if(l==r){
if(l==1) t[p].al = t[p].ar = l;
else t[p].bl = t[p].br = l;
}
else{
int m = (l+r)/2;
build(2*p,l,m);
build(2*p+1,m+1,r);
t[p] = merge(t[2*p],t[2*p+1]);
}
}
void change(int p,int x){
if(t[p].l==t[p].r){
t[p].bl = t[p].br = -1;
t[p].al = t[p].ar = t[p].l;
}
else{
int m = (t[p].l+t[p].r)/2;
if(x<=m) change(2*p,x);
else change(2*p+1,x);
t[p] = merge(t[2*p],t[2*p+1]);
}
}
int main(){
int n;
scanf("%d%lld",&n,&D);
for(int i = 1; i <= n; i++) scanf("%lld",&a[i]);
build(1,1,n);
vis[1] = 1;
long long ans = 0;
for(int i = 1; i <= n-1; i++){
int l = t[1].bestL, r = t[1].bestR;
long long add = getPair(l,r);
//printf("l = %d, r = %d: %lld\n",l,r,add);
ans += add;
if(!vis[l]) change(1,l), vis[l] = 1;
else change(1,r), vis[r] = 1;
}
printf("%lld\n",ans);
return 0;
}
|
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const long double EPS=1e-9;
const long double PI=acos(-1.0);
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
long double ABS(long double a){return max(a,-a);}
int p[210000];
int UF[210000];
int FIND(int a){
if(UF[a]<0)return a;
return UF[a]=FIND(UF[a]);
}
void UNION(int a,int b){
a=FIND(a);b=FIND(b);if(a==b)return;UF[a]+=UF[b];UF[b]=a;
}
pair<int,int> t[210000];
vector<pair<long long,pair<int,int> > >v;
pair<long long,int> segtree[2][524288];
pair<long long,int> query(int a,int b,int c,int d,int e,int f){
if(d<a||b<c)return make_pair(inf,-1);
if(c<=a&&b<=d)return segtree[f][e];
return min(query(a,(a+b)/2,c,d,e*2,f),query((a+b)/2+1,b,c,d,e*2+1,f));
}
void update(int a,long long b,int c){
int at=a;
a+=262144;
while(a){
segtree[c][a]=min(segtree[c][a],make_pair(b,at));
a/=2;
}
}
int main(){
int a,b;scanf("%d%d",&a,&b);
for(int i=0;i<a;i++)scanf("%d",p+i);
for(int i=0;i<a;i++){
t[i]=make_pair(p[i],i);
}
for(int i=0;i<524288;i++)for(int j=0;j<2;j++)segtree[j][i]=make_pair(inf,-1);
std::sort(t,t+a);
for(int i=0;i<a;i++){
int I=t[i].second;
pair<long long,int> L=query(0,262143,0,I,1,1);
pair<long long,int> R=query(0,262143,I,a-1,1,0);
if(L.second!=-1){
v.push_back(make_pair((long long)(I-L.second)*b+p[I]+p[L.second],make_pair(I,L.second)));
}
if(R.second!=-1){
v.push_back(make_pair((long long)(R.second-I)*b+p[I]+p[R.second],make_pair(I,R.second)));
}
update(I,p[I]+(long long)b*I,0);
update(I,p[I]+(long long)b*(a-I),1);
}
std::sort(v.begin(),v.end());
long long ret=0;
for(int i=0;i<a;i++)UF[i]=-1;
for(int i=0;i<v.size();i++){
if(FIND(v[i].second.first)!=FIND(v[i].second.second)){
UNION(v[i].second.first,v[i].second.second);
ret+=v[i].first;
}
}
printf("%lld\n",ret);
}
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define ULL unsigned long long
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define pll pair<LL,LL>
#define x first
#define y second
#define pi acos(-1)
#define sqr(x) ((x)*(x))
#define pdd pair<double,double>
#define MEMS(x) memset(x,-1,sizeof(x))
#define MEM(x) memset(x,0,sizeof(x))
#define less Less
#define EPS 1e-4
#define arg ARG
#define cpdd const pdd
#define rank Rank
#define KK 500
#define N 100005
LL a[200005];
vector<pair<LL,pii> > v;
void dc(int l,int r,LL d){
if(l==r)return;
int mid=(l+r)/2;
LL lmin=1e18,li;
LL rmin=1e18,ri;
for(int i=l;i<=mid;i++){
LL val=a[i]+(mid-i)*d;
if(val<lmin){
lmin=val;
li=i;
}
}
for(int i = mid+1;i<=r;i++){
LL val=a[i]+(i-mid)*d;
if(val<rmin){
rmin=val;
ri=i;
}
v.pb(mp(val+lmin,mp(i,li)));
}
for(int i = l;i<=mid;i++){
v.pb(mp(a[i]+(mid-i)*d+rmin,mp(i,ri)));
}
dc(l,mid,d);
dc(mid+1,r,d);
}
int f[200005];
int Find(int x){
if(f[x]==x)return x;
return f[x]=Find(f[x]);
}
int main(){
int n,d;
scanf("%d %d",&n,&d);
for(int i = 1;i<=n;i++){
scanf("%lld",&a[i]);
}
dc(1,n,d);
for(int i = 1;i<=n;i++)
f[i]=i;
sort(v.begin(),v.end());
LL ans=0;
for(auto it:v){
int a=it.y.x,b=it.y.y;
int fa=Find(a),fb=Find(b);
if(fa!=fb){
f[fa]=fb;
ans+=it.x;
}
}
printf("%lld\n",ans);
}
/*
0
1 1
2 3
3 5 1 0 0
4*/
|
#include<bits/stdc++.h>
using namespace std;
#define maxn 400020
#define rep(i,l,r) for(register int i = l ; i <= r ; i++)
#define repd(i,r,l) for(register int i = r ; i >= l ; i--)
#define rvc(i,S) for(register int i = 0 ; i < (int)S.size() ; i++)
#define rvcd(i,S) for(register int i = ((int)S.size()) - 1 ; i >= 0 ; i--)
#define fore(i,x)for (register int i = head[x] ; i ; i = e[i].next)
#define pb push_back
#define prev prev_
#define stack stack_
#define mp make_pair
#define fi first
#define se second
#define inf 1e18
#define lowbit(x) (x&(-x))
typedef long long ll;
typedef pair<ll,int> pr;
struct node{
int x,y; ll w;
bool operator < (node a)const{
return w < a.w;
}
}dt[maxn];
int fa[maxn],n,a[maxn],rec[maxn],D,tot;
ll b[maxn],c[maxn],ans;
pr mn[maxn];
inline pr query(int id){
pr res (inf,0);
for (int i = id ; i ; i -= lowbit(i)){
if ( mn[i].fi < res.fi ) res = mn[i];
}
return res;
}
inline void modify(int id,pr cur){
for (int i = id ; i <= n ; i += lowbit(i)){
if ( mn[i].fi > cur.fi ) mn[i] = cur;
}
}
void init(){
sort(rec + 1,rec + n + 1);
rep(i,1,n) a[i] = lower_bound(rec + 1,rec + n + 1,a[i]) - rec;
rep(i,1,n) mn[i] = mp(inf,0);
rep(i,1,n){
pr cur = query(a[i] - 1);
if ( cur.se ) dt[++tot] = (node){i,cur.se,(ll)D * i + rec[a[i]] + cur.fi};
modify(a[i],mp((ll)-D * i + rec[a[i]],i));
}
rep(i,1,n) mn[i] = mp(inf,0);
repd(i,n,1){
pr cur = query(a[i]);
if ( cur.se ) dt[++tot] = (node){i,cur.se,(ll)-D * i + rec[a[i]] + cur.fi};
modify(a[i],mp((ll)D * i + rec[a[i]],i));
}
}
int getfa(int x){ return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
int main(){
scanf("%d %d",&n,&D);
rep(i,1,n) scanf("%d",&a[i]) , rec[i] = a[i] , b[i] = (ll)a[i] + (ll)D * i , c[i] = (ll)a[i] - (ll)D * i;
init();
sort(dt + 1,dt + tot + 1);
for (int i = 1 ; i <= n ; i++) fa[i] = i;
rep(i,1,tot){
int x = dt[i].x , y = dt[i].y;
int p = getfa(x) , q = getfa(y);
if ( p != q ){
ans += dt[i].w;
fa[p] =q;
}
}
cout<<ans<<endl;
}
|
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pli;
#define fir first
#define sec second
#define Mp make_pair
const int MAXN = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
template<typename T>
void chk_min(T &a,T b){ if(a>b) a=b;}
ll a[MAXN];
int main(void)
{
int n;
ll d;
scanf("%d%lld",&n,&d);
for(int i=1; i<=n; ++i) scanf("%lld",&a[i]);
ll ans=0;
for(int i=1; i<=n; ++i) ans += a[i];
for(int i=2; i<=n; ++i) chk_min(a[i], a[i-1]+d);
for(int i=n-1; i>=1; --i) chk_min(a[i], a[i+1]+d);
for(int i=1; i<=n; ++i) ans += a[i];
printf("%lld",ans + d*(n-1) - a[1] - a[n]);
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define N 200010
char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<'0'||c>'9')) c=getchar();return c;}
int gcd(int n,int m){return m==0?n:gcd(m,n%m);}
int read()
{
int 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;
}
int n,d,a[N],fa[N],t;
ll ans;
struct data
{
int x,y;ll z;
bool operator <(const data&a) const
{
return z<a.z;
}
}e[N<<5];
int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
ll calcl(int i)
{
return a[i]-1ll*i*d;
}
ll calcr(int i)
{
return a[i]+1ll*i*d;
}
void solve(int l,int r)
{
if (l==r) return;
int mid=l+r>>1;
solve(l,mid);
solve(mid+1,r);
int L=l;
for (int i=l;i<=mid;i++) if (calcl(i)<calcl(L)) L=i;
int R=r;
for (int i=mid+1;i<=r;i++) if (calcr(i)<calcr(R)) R=i;
for (int i=l;i<=mid;i++) e[++t]=(data){i,R,calcl(i)+calcr(R)};
for (int i=mid+1;i<=r;i++) e[++t]=(data){L,i,calcl(L)+calcr(i)};
}
signed main()
{
n=read(),d=read();
for (int i=1;i<=n;i++) a[i]=read();
solve(1,n);
for (int i=1;i<=n;i++) fa[i]=i;
sort(e+1,e+t+1);
for (int i=1;i<=t;i++)
if (find(e[i].x)!=find(e[i].y))
{
fa[find(e[i].x)]=find(e[i].y);
ans+=e[i].z;
}
cout<<ans;
return 0;
//NOTICE LONG LONG!!!!!
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
ll n, D;
cin >> n >> D;
vector<ll> a(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
vector<ll> b = a;
for (int i = 1; i < n; ++i)
b[i] = min(b[i], b[i - 1] + D);
for (int i = n - 2; i >= 0; --i)
b[i] = min(b[i], b[i + 1] + D);
ll ans = accumulate(a.begin(), a.end(), 0LL) + (n - 1LL) * D;
if (n >= 3)
ans += accumulate(b.begin() + 1, b.end() - 1, 0LL);
cout << ans;
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
struct edge
{
ll x,y,w;
}e[400005];
struct node
{
ll dsu,w;
}a[200005];
ll n,i,d,u,ans=0,v,cnt=0,tr[2][200005],vp[200005],fx,fy;
const ll inf=1e18;
ll lowbit(ll p){return p&-p;}
bool cmp(node a,node b){return a.w<b.w;}
bool cmp2(edge a,edge b){return a.w<b.w;}
bool cmp3(node a,node b){return a.dsu<b.dsu;}
int getf(int p){return a[p].dsu==p?p:a[p].dsu=getf(a[p].dsu);}
ll vl(ll u,ll v){return d*(v-u)+vp[u]+vp[v];}
ll pvl(ll t,ll u){return u==0?inf:(t==0?(-u*d+vp[u]):(d*u+vp[u]));}
ll ask(ll t,ll p)
{
ll ans=0,tp,tmp=inf;
while(p)
{
if((tp=pvl(t,tr[t][p]))<tmp)
{
ans=tr[t][p];
tmp=tp;
}
p-=lowbit(p);
}
return ans;
}
void ins(ll t,ll p,ll v)
{
ll tmp,tp;
tp=pvl(t,v);
while(p<=n)
{
tmp=pvl(t,tr[t][p]);
if(tp<tmp)tr[t][p]=v;
p+=lowbit(p);
}
}
int main()
{
scanf("%lld%lld",&n,&d);
for(i=1;i<=n;i++)scanf("%lld",&a[i].w),a[i].dsu=i,vp[i]=a[i].w;
sort(a+1,a+n+1,cmp);
for(i=1;i<=n;i++)
{
u=ask(0,a[i].dsu);
v=ask(1,n+1-a[i].dsu);
if(u)e[++cnt]=(edge){u,a[i].dsu,vl(u,a[i].dsu)};
if(v)e[++cnt]=(edge){a[i].dsu,v,vl(a[i].dsu,v)};
ins(0,a[i].dsu,a[i].dsu);
ins(1,n+1-a[i].dsu,a[i].dsu);
}
sort(e+1,e+cnt+1,cmp2);
sort(a+1,a+n+1,cmp3);
for(i=1;i<=cnt;i++)
{
fx=getf(e[i].x);fy=getf(e[i].y);
if(fx!=fy)
{
ans+=e[i].w;
a[fx].dsu=fy;
}
}
printf("%lld\n",ans);
return 0;
}
|
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <set>
#define MAXN 200005
#define INF 0x3f3f3f3f
#define rint register int
#define LL long long
#define LD long double
using namespace std;
int n, d, a[MAXN], b[MAXN];
LL ans;
int main()
{
scanf("%d%d", &n, &d);
for(rint i=1; i<=n; ++i)
{
scanf("%d", &a[i]);
b[i]=a[i];
ans+=a[i];
}
for(rint i=2; i<=n; ++i) b[i]=min(b[i], b[i-1]+d);
for(rint i=n-1; i>=1; --i) b[i]=min(b[i], b[i+1]+d);
ans+=1LL*(n-1)*d;
for(rint i=2; i<n; ++i) ans+=b[i];
printf("%lld\n", ans);
return 0;
}
|
//#pragma GCC optimize(2)
// Happy TLE and WA every day!
// by: zxb the vegetable chicken
#include<bits/stdc++.h>
#define mp make_pair
#define rep(i,n) for(int i = 0; i < n; i++)
#define foreach(i,c) for(VAR(i, (c).begin()); i != (c).end(); ++i)
#define BINF 0x7fffffff
#define INF 0x3f3f3f3f
#define LINF 4557430888798830399
#define pb push_back
#define F first
#define S second
#define Time clock()/CLOCKS_PER_SEC
#define read ZXBs_fast_input
#define write ZXBs_fast_output
#define int long long
//#define usingFiles
using namespace std;
typedef unsigned int ui;
typedef pair<int, int> pii;
typedef long long ll;
inline bool read(int& x){
x = 0;
int c;
int sign = 1;
while( (c = getchar()) < '0' || c > '9' ) if(c == '-') sign = -1;
x = c ^ '0';
while( (c = getchar()) >= '0' && c <= '9' ) x = (x<<3) + (x<<1) + (c ^ '0');
x *= sign;
return 1;
}
inline bool write(int x){
if(x >= 10) write(x / 10);
putchar(x % 10 + '0');
return 1;
}
const int rp = 666666;
const bool debug = 1;
const bool I_good_vegetable_a = 1;
int n, d;
int a[200200];
int dpL[200200];
int dpR[200200];
signed main(){
ios::sync_with_stdio(false);
#ifdef usingFiles
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
cin >> n >> d;
rep(i, n) cin >> a[i];
int res = d * (n - 1);
rep(i, n) res += a[i];
dpL[0] = a[0];
for(int i = 1; i < n; i++){
dpL[i] = min(a[i], dpL[i - 1] + d);
}
dpR[n - 1] = a[n - 1];
for(int i = n - 2; i >= 0; i--){
dpR[i] = min(a[i], dpR[i + 1] + d);
}
for(int i = 1; i < n - 1; i++){
res += min(dpL[i], dpR[i]);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll,ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll n,d,ans,a[200005],ml[200005],mr[200005];
int main(void){
cin>>n>>d;
ans=d*(n-1);
for(int i=0;i<n;i++){
cin>>a[i];
ans+=a[i];
}
for(int i=0;i<n;i++)mr[i]=INF,ml[i]=INF;
ml[0]=a[0];
for(ll i=1;i<n;i++){
ml[i]=min(ml[i-1],a[i]-i*d);
}
mr[n-1]=a[n-1]+d*(n-1);
for(ll i=n-2;i>=0;i--){
mr[i]=min(mr[i+1],a[i]+i*d);
}
for(ll i=1;i+1<n;i++){
ans+=min(i*d+ml[i],mr[i]-i*d);
}
cout<<ans<<endl;
}
|
#include <iostream>
using namespace std;
using ll=long long;
ll n,d,a[200000],b[200000],m=1LL<<60,loc,ans;
int main(void){
cin>>n>>d;
for(int i=0;i<n;i++){
cin>>a[i];
if(m>a[i]){m=a[i];loc=i;}
if(i)b[i]=min(a[i],b[i-1]+d);
if(i==0)b[i]=a[i];
}
for(int i=n-1;i;i--){
b[i-1]=min(b[i-1],b[i]+d);
}
for(int i=loc-1;i>=0;i--){
ans+=a[i]+b[i+1]+d;
}
for(int i=loc+1;i<n;i++){
ans+=a[i]+b[i-1]+d;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
#define pb emplace_back
#define ll long long
#define fi first
#define se second
#define mp make_pair
#define int int64_t
using namespace std;
typedef pair<int, int> pii;
const int N = int(2e5 + 7);
const int inf = int(1e18);
struct TEdge {
int u, v, w;
TEdge() {}
TEdge(int u, int v, int w): u(u), v(v), w(w) {}
bool operator < (const TEdge& o) const& {
return w < o.w;
}
};
int n, d, x, res, lab[N], f[N], g[N];
vector<TEdge> e;
int Find(int x) {return lab[x] < 0? x: lab[x] = Find(lab[x]);}
void Union(int r, int s) {
if(lab[r] > lab[s]) swap(r, s);
lab[r] += lab[s], lab[s] = r;
}
void Divide(int l, int r) {
if(l == r) return;
int mid = (l + r) >> 1, wf = inf, vf, wg = inf, vg;
for(int i = l; i <= mid; ++i)
if(wf > f[i]) wf = f[i], vf = i;
for(int i = mid + 1; i <= r; ++i) {
if(wg > g[i]) wg = g[i], vg = i;
e.pb(vf, i, wf + g[i]);
}
for(int i = l; i <= mid; ++i) e.pb(vg, i, wg + f[i]);
Divide(l, mid), Divide(mid + 1, r);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
#define Task "test"
if(fopen(Task".inp", "r")) {
freopen(Task".inp", "r", stdin);
freopen(Task".out", "w", stdout);
}
cin >> n >> d;
for(int i = 1; i <= n; ++i) {
cin >> x;
f[i] = x - d * i;
g[i] = x + d * i;
}
Divide(1, n);
sort(e.begin(), e.end());
memset(&lab, -1, sizeof lab);
for(TEdge& ed: e) {
int r = Find(ed.u), s = Find(ed.v);
if(r != s) res += ed.w, Union(r, s);
}
cout << res;
}
|
//accept
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#define mp make_pair
typedef long long ll;
using namespace std;
const int inf=1025352128;
int n,d;
int a[200005];
int f[200005];
int rk[200005];
vector <pair<ll,pair<int,int> > >vec;
int find(int x)
{
if(f[x]==x)
{
return x;
}
else
{
rk[x]=1;
return f[x]=find(f[x]);
}
}
void merge(int x,int y)
{
x=find(x);
y=find(y);
if(rk[x]==rk[y])
{
if(rand()&1)
{
rk[x]++;
f[y]=x;
}
else
{
rk[y]++;
f[x]=y;
}
return;
}
if(rk[x]>rk[y])
{
f[y]=x;
return;
}
if(rk[y]>rk[x])
{
f[x]=y;
return;
}
}
void init()
{
for(int i=0;i<n;i++)
{
f[i]=i;
rk[i]=1;
}
}
inline ll cost(int i,int j)
{
return 1LL*a[i]+1LL*a[j]+1LL*(j-i)*d;
}
void add(int l,int r)
{
if(r-l<=1) return;
int m=l+r>>1;
ll minx=inf,tl,tr;
for(int i=l;i<m;i++)
{
if(1LL*a[i]-1LL*i*d<minx)
{
minx=1LL*a[i]-1LL*i*d;
tl=i;
}
}
minx=1LL*inf*inf;
for(int i=m;i<r;i++)
{
if(1LL*a[i]+1LL*i*d<minx)
{
minx=1LL*a[i]+1LL*i*d;
tr=i;
}
}
for(int i=l;i<m;i++)
{
vec.push_back(mp(cost(i,tr),mp(i,tr)));
}
for(int i=m;i<r;i++)
{
vec.push_back(mp(cost(tl,i),mp(tl,i)));
}
add(l,m);
add(m,r);
}
int main()
{
scanf("%d%d",&n,&d);
init();
for(int i=0;i<n;i++)
{
scanf("%d",a+i);
}
add(0,n);
sort(vec.begin(),vec.end());
vec.erase(unique(vec.begin(),vec.end()),vec.end());
ll res=0;
int s=1;
for(int i=0;i<vec.size();i++)
{
pair<ll,pair<int,int> > x=vec[i];
if(find(x.second.first)==find(x.second.second)) continue;
merge(x.second.first,x.second.second);
s++;
res+=x.first;
if(s==n) break;
}
cout<<res<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long n,d,a[222222],ps,ans;
struct node
{
long long mn,pos;
pair<long long,long long> x,y;//ai+id,ai-id
pair<long long,long long> xx,yy;
}tree[888888];
long long Min(long long a,long long b,long long c,long long d)
{
return min(a,min(b,min(c,d)));
}
void pushup(long long node)
{
tree[node].x=min(tree[node<<1].x,tree[(node<<1)|1].x);
tree[node].y=min(tree[node<<1].y,tree[(node<<1)|1].y);
tree[node].xx=min(tree[node<<1].xx,tree[(node<<1)|1].xx);
tree[node].yy=min(tree[node<<1].yy,tree[(node<<1)|1].yy);
tree[node].mn=Min(tree[node<<1].mn,tree[(node<<1)|1].mn,tree[node<<1].y.first+tree[(node<<1)|1].xx.first,tree[(node<<1)|1].x.first+tree[node<<1].yy.first);
if (tree[node].mn==tree[node<<1].mn) tree[node].pos=tree[node<<1].pos;
else if (tree[node].mn==tree[(node<<1)|1].mn) tree[node].pos=tree[(node<<1)|1].pos;
else if (tree[node].mn==tree[node<<1].y.first+tree[(node<<1)|1].xx.first) tree[node].pos=tree[(node<<1)|1].xx.second;
else tree[node].pos=tree[node<<1].yy.second;
}
void build(long long l,long long r,long long node)
{
if (l==r)
{
tree[node].mn=1e18;
if (l==1)
{
tree[node].x=make_pair(a[l]+l*d,l);
tree[node].y=make_pair(a[l]-l*d,l);
tree[node].xx=make_pair(1e18,1e18);
tree[node].yy=make_pair(1e18,1e18);
}
else
{
tree[node].xx=make_pair(a[l]+l*d,l);
tree[node].yy=make_pair(a[l]-l*d,l);
tree[node].x=make_pair(1e18,1e18);
tree[node].y=make_pair(1e18,1e18);
}
return;
}
long long mid=(l+r)>>1;
build(l,mid,node<<1);
build(mid+1,r,(node<<1)|1);
pushup(node);
}
void upd(long long x,long long l,long long r,long long node)
{
if (l==r)
{
swap(tree[node].x,tree[node].xx);
swap(tree[node].y,tree[node].yy);
return;
}
long long mid=(l+r)>>1;
if (x>mid) upd(x,mid+1,r,(node<<1)|1);
else upd(x,l,mid,node<<1);
pushup(node);
}
int main()
{
scanf("%lld%lld",&n,&d);
for (long long i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
}
build(1,n,1);
for (long long i=1;i<n;i++)
{
ans+=tree[1].mn;
ps=tree[1].pos;
upd(ps,1,n,1);
}
printf("%lld\n",ans);
return 0;
}
|
// ※※※ 解答不能 ※※※
// LHiC氏.
// https://atcoder.jp/contests/keyence2019/submissions/4005363
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define a first
#define b second
const int MAXN = 210000;
LL d;
int n;
LL a[MAXN];
int main(){
scanf("%d %lld", &n, &d);
rep(i, n) scanf("%lld", &a[i]);
vector<pair<LL, int>> vv;
repx(i, 1, n){
LL x = a[i] + d * i;
while(!vv.empty() && vv.back().a >= x) vv.pop_back();
vv.emplace_back(x, i);
}
int now = 1;
LL bst = a[0];
LL ans = 0;
rep(i, vv.size()){
int nw = vv[i].b;
ans += vv[i].a + bst;
repx(j, now, nw){
ans += a[j] + min(vv[i].a - j * d, bst + j * d);
bst = min(bst, a[j] - j * d);
}
bst = min(bst, a[nw] - nw * d);
now = nw + 1;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define int LL
using namespace std;
typedef long long LL;
const int MAX_N=200005;
struct edge
{
int u,v,cost;
edge(){}
edge(int _u,int _v,int _cost)
{
u=_u;
v=_v;
cost=_cost;
}
bool operator < (const edge &A) const
{
return cost<A.cost;
}
};
const LL INF=0x3f3f3f3f3f3f3f3f;
LL A[MAX_N];
LL ans,n,D;
int fa[MAX_N];
LL Ai_Di[MAX_N],Aj_Dj[MAX_N];
vector <edge> g;
void init()
{
for(int i=0;i<n;i++)fa[i]=i;
}
int find(int x)
{
return x==fa[x]?x:fa[x]=find(fa[x]);
}
void unite(int u,int v)
{
fa[find(u)]=find(v);
}
bool same(int u,int v)
{
return find(u)==find(v);
}
void solve(int l,int r)
{
if(l==r)return;
int mid=(l+r)/2;
int pl=-1;
LL vl=INF;
for(int i=l;i<=mid;i++)
{
if(Ai_Di[i]<vl)
{
vl=Ai_Di[i];
pl=i;
}
}
int pr=-1;
LL vr=INF;
for(int i=mid+1;i<=r;i++)
{
if(Aj_Dj[i]<vr)
{
vr=Aj_Dj[i];
pr=i;
}
}
for(int i=l;i<=mid;i++)
{
g.push_back(edge(i,pr,vr+Ai_Di[i]));
}
for(int i=mid+1;i<=r;i++)
{
g.push_back(edge(i,pl,vl+Aj_Dj[i]));
}
solve(l,mid);
solve(mid+1,r);
}
signed main()
{
cin>>n>>D;
init();
for(int i=0;i<n;i++)cin>>A[i];
for(int i=0;i<n;i++)Ai_Di[i]=A[i]-D*i;
for(int i=0;i<n;i++)Aj_Dj[i]=A[i]+D*i;
solve(0,n-1);
sort(g.begin(),g.end());
for(int i=0;i<g.size();i++)
{
int u=g[i].u;
int v=g[i].v;
int cost=g[i].cost;
if(!same(u,v))
{
unite(u,v);
ans+=cost;
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
using ll = long long;
using i_i = tuple<int, int>;
struct edge { int u, v; ll w; };
struct union_find {
vector<int> v;
union_find(int n) : v(n, -1) {}
int find(int x) { return v[x] < 0 ? x : v[x] = find(v[x]); }
void unite(int x, int y) {
x = find(x); y = find(y);
if (x == y) return;
if (-v[x] < -v[y]) swap(x, y);
v[x] += v[y]; v[y] = x;
}
bool root(int x) { return v[x] < 0; }
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -v[find(x)]; }
};
bool kr_cmp(const edge& l, const edge& r) { return l.w < r.w; }
ll kruskal(int N, vector<edge> E) {
sort(E.begin(), E.end(), kr_cmp);
union_find uf(N);
ll sum = 0;
for (edge e: E)
if (!uf.same(e.u, e.v)) {
uf.unite(e.u, e.v);
sum += e.w;
}
return sum;
}
int N;
ll D;
vector<edge> E;
ll a[200010];
void f(int l, int r) {
if (r - l == 1) return;
int m = (l + r) / 2;
f(l, m);
f(m, r);
int i0, j0;
{
ll mi = LLONG_MAX;
for (int i = l; i < m; i++) {
ll x = a[i] - D * i;
if (x < mi) {
mi = x;
i0 = i;
}
}
}
{
ll mi = LLONG_MAX;
for (int j = m; j < r; j++) {
ll x = a[j] + D * j;
if (x < mi) {
mi = x;
j0 = j;
}
}
}
for (int i = l; i < m; i++)
E.pb({i, j0, a[i] + a[j0] + D * (j0 - i)});
for (int j = m; j < r; j++)
E.pb({i0, j, a[i0] + a[j] + D * (j - i0)});
}
int main() {
cin >> N >> D;
rep(i, N) scanf("%lld", &a[i]);
f(0, N);
cout << kruskal(N, E) << endl;
}
|
// Code by Denverjin.
#include <bits/stdc++.h>
using namespace std;
using ld = double;
using ll = long long;
using ull = unsigned long long;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int SZ = 1 << 13;
char buff[SZ], *pos = buff + SZ - 1;
#define getchar() (++ pos == buff + SZ ? fread(pos = buff, 1, SZ, stdin), *pos : *pos)
inline ll read() {
ll x = 0; int f = 1, c = getchar();
for (;!isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x<<3) + (x<<1) + (c^48);
return x * f;
}
const int N = 1 << 24;
int n, D;
int a[N];
ll e[N][3];
int m;
int id[N];
void solve(int l, int r) {
if (l + 1 >= r) return;
int md = (l + r) >> 1;
int mL = l; for (int i = l; i < md; ++ i) if (-1LL * i * D + a[i] < -1LL * mL * D + a[mL]) mL = i;
int mR = md; for (int i = md; i < r; ++ i) if (1LL * i * D + a[i] < 1LL * mR * D + a[mR]) mR = i;
for (int i = md; i < r; ++ i) e[m][0] = mL, e[m][1] = i, e[m][2] = 1LL * (i - mL) * D + a[i] + a[mL], id[m] = m ++;
for (int i = l; i < md; ++ i) e[m][0] = i, e[m][1] = mR, e[m][2] = 1LL * (mR - i) * D + a[i] + a[mR], id[m] = m ++;
solve(l, md);
solve(md, r);
}
int par[N];
void init() { for (int i = 0; i < N; ++ i) par[i] = i; }
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void merge(int x, int y) { x = find(x), y = find(y); par[x] = y; }
bool same(int x, int y) { return find(x) == find(y); }
int main() {
init();
n = read(), D = read();
for (int i = 0; i < n; ++ i) a[i] = read();
solve(0, n);
sort(id, id + m, [&](int a, int b) {
return e[a][2] < e[b][2];
});
ll ans = 0;
for (int ii = 0; ii < m; ++ ii) {
int i = id[ii];
if (!same(e[i][0], e[i][1])) {
merge(e[i][0], e[i][1]);
ans += e[i][2];
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <iostream>
#include <limits>
#include <numeric>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
struct Ed {
int u, v;
ll w;
Ed() {}
Ed(int u, int v, ll w) : u(u), v(v), w(w) {}
bool operator<(const Ed &rhs) const {
return w < rhs.w;
}
bool operator>(const Ed &rhs) const {
return rhs < *this;
}
};
const int N = 200010;
const ll INF = 1LL << 60;
int n, d;
int a[N], f[N];
pair<ll, int> p[N], q[N];
Ed mst[N];
Ed tmp[N * 2];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void divideConquer(int l, int r) {
if (l == r)
return;
int mid = (l + r) >> 1;
divideConquer(l, mid);
divideConquer(mid + 1, r);
merge(mst + l, mst + mid, mst + mid + 1, mst + r, tmp + 1);
pair<ll, int> x = p[l], y = q[mid + 1];
int a = r - l - 1, b = a;
for (int i = l; i <= mid; ++i)
tmp[++b] = Ed(p[i].second, y.second, p[i].first + y.first);
for (int i = mid + 1; i <= r; ++i)
tmp[++b] = Ed(x.second, q[i].second, x.first + q[i].first);
inplace_merge(tmp + a + 1, tmp + a + mid - l + 2, tmp + b + 1);
inplace_merge(tmp + 1, tmp + a + 1, tmp + b + 1);
for (int i = l; i <= r; ++i)
f[i] = i;
int cnt = l;
for (int i = 1; i <= b; ++i) {
int u = find(tmp[i].u), v = find(tmp[i].v);
if (u != v) {
mst[cnt++] = tmp[i];
f[u] = v;
}
}
inplace_merge(p + l, p + mid + 1, p + r + 1);
inplace_merge(q + l, q + mid + 1, q + r + 1);
}
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i)
p[i] = make_pair(a[i] - i * (ll)d, i);
for (int j = 1; j <= n; ++j)
q[j] = make_pair(a[j] + j * (ll)d, j);
divideConquer(1, n);
ll ans = 0;
for (int i = 1; i < n; ++i)
ans += mst[i].w;
printf("%lld\n", ans);
return 0;
}
|
//https://atcoder.jp/contests/keyence2019/tasks/keyence2019_e
#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef unsigned long long ull;
#define fst first
#define sed second
#define pb push_back
#define mp make_pair
#define rt register int
#define all(it) it.begin(), it.end()
#define rep(it, f, e) for (rt it = f; it <= e; ++it)
#define per(it, f, e) for (rt it = f; it >= e; --it)
const int MAXN = 2e5 + 10;
struct Dsu {
int par[MAXN];
Dsu() {
rep (i, 1, MAXN - 1) {
par[i] = i;
}
}
inline int find(int x) {
return x == par[x] ? x : par[x] = find(par[x]);
}
inline void mry(int a, int b) {
par[find(a)] = find(b);
}
inline bool tog(int a, int b) {
return find(a) == find(b);
}
} dsu;
ll A[MAXN], n, d;
vector<pair<ll,pii> > edge;
inline void solve(int l, int r) {
if (l == r) return;
int m = (l + r) >> 1;
ll ml = 1e18, li = 0;
rep (i, l, m) {
if (ml > A[i] - i * d) {
ml = A[i] - i * d;
li = i;
}
}
ll mr = 1e18, ri = 0;
rep (i, m + 1, r) {
if (mr > A[i] + i * d) {
mr = A[i] + i * d;
ri = i;
}
}
rep (i, l, m) {
edge.pb(mp(A[i] - i * d + mr,mp(i, ri)));
}
rep (i, m + 1, r) {
edge.pb(mp(A[i] + i * d + ml,mp(i, li)));
}
solve(l, m);
solve(m + 1, r);
}
int main() {
cin >> n >> d;
rep (i, 1, n) {
cin >> A[i];
}
solve(1, n);
sort(all(edge));
ll ans = 0;
for (auto e : edge) {
// cerr << e.sed.fst << ' ' << e.sed.sed <<endl;
if (!dsu.tog(e.sed.fst, e.sed.sed)) {
ans += e.fst;
dsu.mry(e.sed.fst, e.sed.sed);
}
}
cout << ans << endl;
return 0;
}
|
/*
ID: htc9811
LANG: C++
TASK:
*/
#include<stdio.h>
#include<string>
#include<math.h>
#include<stdlib.h>
#include<set>
#include<bitset>
#include<map>
#include<vector>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<deque>
#include<stack>
#include<cmath>
#include<ctime>
#include<complex>
#include<list>
#include<limits.h>
using namespace std;
const int N=2e5+5;
int n,cur;
long long a[N];
long long d,ans;
struct Seg{
long long length;
int x,y;
Seg(){};
Seg(long long length,int x,int y):length(length),x(x),y(y){};
};
struct UF{
int p[N],rnk[N];
void init(int n){
memset(p,0,sizeof(p));
memset(rnk,0,sizeof(rnk));
for(int i=0;i<n;i++) p[i]=i;
for(int i=0;i<n;i++) rnk[i]=0;
}
int fp(int x){
return x==p[x]?x:p[x]=fp(p[x]);
}
void un(int x,int y){
if(rnk[x]>rnk[y]) p[y]=x;
if(rnk[x]<rnk[y]) p[x]=y;
if(rnk[x]==rnk[y]) p[x]=y,rnk[y]++;
}
};
inline bool comp(Seg &x,Seg &y){
return x.length<y.length;
}
vector<Seg> seg;
UF uf;
void solve(int left,int right){
if(left==right) return;
int middle=(left+right)>>1;
int pl=left;
long long vl=a[left]-d*left;
for(int i=left+1;i<=middle;i++){
long long cv=a[i]-d*i;
if(cv<vl){
vl=cv;
pl=i;
}
}
int pr=middle+1;
long long vr=a[middle+1]+d*(middle+1);
for(int i=middle+2;i<=right;i++){
long long cv=a[i]+d*i;
if(cv<vr){
vr=cv;
pr=i;
}
}
for(int i=left;i<=middle;i++) seg.push_back(Seg(a[i]-d*i+vr,i,pr));
for(int i=middle+1;i<=right;i++) seg.push_back(Seg(a[i]+d*i+vl,pl,i));
solve(left,middle);
solve(middle+1,right);
}
int main(){
// freopen("cc3.in","r",stdin);
// freopen("cc1.out","w",stdout);
scanf("%d%lld",&n,&d);
uf.init(n);
for(int i=0;i<n;i++) scanf("%lld",a+i);
solve(0,n-1);
sort(seg.begin(),seg.end(),comp);
for(int i=1;i<n;i++){
while(true){
int nx=seg[cur].x;
int ny=seg[cur].y;
long long len=seg[cur].length;
nx=uf.fp(nx);
ny=uf.fp(ny);
cur++;
if(nx!=ny){
uf.un(nx,ny);
// printf("%lld\n",len);
ans+=len;
break;
}
}
}
printf("%lld\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
typedef long long ll;
int n,tot,d,a[N],f[N];
struct node
{
int u,v;
node(int u=0,int v=0,ll w=0):u(u),v(v),w(w){}
ll w;
bool operator<(const node&o)const
{
return w<o.w;
}
}e[N*20];
void solve(int l,int r)
{
if(l==r) return;
int m=l+r>>1;
ll p1=l,p2=m+1,s=1e18;
for(ll i=l;i<=m;i++)
if(-i*d+a[i]<s)
s=-i*d+a[i],p1=i;
s=1e18;
for(ll i=m+1;i<=r;i++)
if(i*d+a[i]<s)
s=i*d+a[i],p2=i;
for(ll i=l;i<=m;i++)
{
tot++;
e[tot]=node(i,p2,-i*d+a[i]+p2*d+a[p2]);
}
for(ll i=m+1;i<=r;i++)
{
tot++;
e[tot]=node(p1,i,-p1*d+a[p1]+i*d+a[i]);
}
solve(l,m);solve(m+1,r);
}
int getf(int x){return f[x]==x?x:f[x]=getf(f[x]);}
int main()
{
scanf("%d%d",&n,&d);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
solve(1,n);
sort(e+1,e+1+tot);
for(int i=1;i<=n;i++) f[i]=i;
ll ans=0;
for(int i=1;i<=tot;i++)
{
int fu=getf(e[i].u),fv=getf(e[i].v);
if(fu==fv) continue;
ans+=e[i].w;
f[fu]=fv;
}
printf("%lld\n",ans);
}
|
#include<bits/stdc++.h>
#define maxn 505050
using namespace std;
typedef long long ll;
struct edge{
ll x,y,z;
}e[maxn*4];
ll ans,pre[maxn],fa[maxn],n,a[maxn],b[maxn],c[maxn],d,p,q;
int l[maxn],r[maxn];
int ffind(int x){
if (pre[x]==x) return x;
pre[x]=ffind(pre[x]); return pre[x];
}
void union_(int u,int v){
pre[v]=u;
b[u]=min(b[u],b[v]);
c[u]=min(c[u],c[v]);
}
bool cmp(edge x,edge y){
return x.z<y.z;
}
ll cost(int u,int v){
return 1ll*abs(u-v)*d+a[u]+a[v];
}
ll f[maxn],g[maxn];
int main(){
cin >> n >> d; int cnt=0;
for (int i=1;i<=n;i++) cin >> a[i];
for (int i=1;i<=n;i++) fa[i]=pre[i]=i,b[i]=a[i]-d*i,c[i]=a[i]+d*i;
int tot=n;
while (tot>1){
int p=1; ll res=b[fa[1]];
for (int i=2;i<=tot;i++){
ll tmp=c[fa[i]];
f[i]=tmp+res,g[i]=p;
if (b[fa[i]]<res) res=b[fa[i]],p=i;
}
int q=n; res=c[fa[tot]];
for (int i=tot-1;i;i--){
ll tmp=b[fa[i]];
if (i==1||tmp+res<f[i]) f[i]=tmp+res,g[i]=q;
if (c[fa[i]]<res) res=c[fa[i]],q=i;
}
for (int i=1;i<=tot;i++){
int u=ffind(fa[i]),v=ffind(fa[g[i]]);
if (u!=v) union_(u,v),ans+=f[i];
}
tot=0;
for (int i=1;i<=n;i++){
fa[++tot]=ffind(i);
while (i<n&&ffind(i+1)==fa[tot]) i++;
}
}
cout << ans << endl;
}
|
//Link : https://atcoder.jp/contests/keyence2019/tasks/keyence2019_e
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 200000
#define inf 2000000000000000000
int A[N];
pair<ll,int> seg1[N*4],seg2[N*4];
int n;
ll d;
void init(int pos,int l,int r) {
if(l==r) {
seg1[pos] = make_pair((ll)l*d + A[l],l);
seg2[pos] = make_pair(-(ll)l*d + A[l],l);
return;
}
int mid = (l+r)/2;
init(pos*2,l,mid);
init(pos*2+1,mid+1,r);
seg1[pos] = min(seg1[pos*2],seg1[pos*2+1]);
seg2[pos] = min(seg2[pos*2],seg2[pos*2+1]);
}
pair<ll,int> query(pair<ll,int> *seg,int pos,int l,int r,int ql,int qr) {
if(r<ql || qr<l) {
return make_pair(inf,0);
}
if(ql<=l && r<=qr) {
return seg[pos];
}
int mid = (l+r)/2;
return min(query(seg,pos*2,l,mid,ql,qr),query(seg,pos*2+1,mid+1,r,ql,qr));
}
ll solveSeg(int l,int r,ll leftValue,ll rightValue) {
if(l>r) {
return 0;
}
ll ret = 0;
int index = -1;ll value = inf;
pair<ll,int> q = query(seg1,1,0,n-1,l,r);
index = q.second;
value = q.first + leftValue;
q = query(seg2,1,0,n-1,l,r);
int tindex = q.second;
if(q.first + rightValue < value) {
value = q.first + rightValue;
index = q.second;
}
ll u = min(rightValue, A[index] + d*index);
ll v = min(leftValue, A[index] - d*index);
ret += solveSeg(l,index-1,leftValue,u)
+ solveSeg(index+1,r,v,rightValue) + value;
return ret;
}
void solve() {
scanf("%d %lld",&n,&d);
int minIndex = -1,minValue = 2e9;
for(int i=0;i<n;++i) {
scanf("%d",&A[i]);
if(A[i]<minValue) {
minValue = A[i];
minIndex = i;
}
}
init(1,0,n-1);
printf("%lld\n",solveSeg(0,minIndex-1,inf,minIndex*d + A[minIndex])
+ solveSeg(minIndex+1,n-1,-minIndex*d + A[minIndex],inf)
);
}
int main() {
//freopen("input.txt","r",stdin);
solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pi;
typedef pair<ll,pi> pii;
typedef vector<int> vi;
#define f first
#define s second
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define forn(i, n) for(register int i=0; i<n; i++)
#define Forn(i, n) for(register int i=1; i<=n; i++)
#define foreach(it, a) for(__typeof((a).begin()) it=(a).begin(); it!=(a).end(); it++)
#define Foreach(it, a) for(__typeof((a).rbegin()) it=(a).rbegin(); it!=(a).rend(); it++)
#define INF 1999999999999999999LL
inline int in()
{
char c=getchar();
int neg=1, x=0;
while(!isdigit(c)) (c=='-')?neg=-1, c=getchar():c=getchar();
while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48), c=getchar();
return neg*x;
}
const int MAX=2e5+5;
int N;
ll dpl[MAX], dpr[MAX], A[MAX], D, ret;
int main()
{
N=in(), D=in();
forn(i, N)
A[i]=in(), ret+=A[i];
ret+=(N-1)*D;
dpr[0]=A[0];
Forn(i, N-1)
dpr[i]=min(dpr[i-1]+D, A[i]);
dpl[N-1]=A[N-1];
for(int i=N-2; i>-1; i--)
dpl[i]=min(dpl[i+1]+D, A[i]);
Forn(i, N-2)
ret+=min(dpl[i], dpr[i]);
printf("%lld\n", ret);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
//世界の皆は頭ええな
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, D;
cin >> N >> D;
ll kotae = (N - 1) * D;
ll A[200001], C[200001];
C[0] = 1e18;
rep1(i, N) {
cin >> A[i];
kotae += A[i];
C[i] = min(C[i - 1] + D, A[i]);
}
ll mae = 1e18;
for (int i = N - 1; i > 1; i--) {
mae = min(mae + D, A[i + 1]);
ll kari = min(mae, C[i - 1]) + D;
kotae += min(A[i], kari);
}
co(kotae);
Would you please return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
const int N=200050;
const int M=2*N;
const ll inf=9e18;
struct SegmentTree
{
ll mn[M];
void init(){ for(int i=0;i<M;i++) mn[i]=inf;}
SegmentTree(){ init();}
void Set(int i, ll f){ i+=N;for(;i;i>>=1) mn[i]=min(mn[i],f);}
ll Get(int l, int r)
{
ll ans=inf;
for(l+=N,r+=N;l<=r;l>>=1,r>>=1)
{
if(l%2==1) ans=min(ans,mn[l++]);
if(r%2==0) ans=min(ans,mn[r--]);
}
return ans;
}
} L,R;
int a[N];
ll dp[N],tmp[N];
ll Solve(int n, int D)
{
set<int> st;
vector<pair<int,int> > work;
for(int i=1;i<=n;i++) work.pb(mp(a[i],i));
sort(work.begin(),work.end());
ll ans=0;
for(int j=0;j<n;j++)
{
int i=work[j].second;
if(j!=0)
{
bool lf=0,rf=0;
ll l=L.Get(1,i-1);
if(l!=inf) lf=1;
l+=a[i]+(ll)i*D;
ll r=R.Get(i+1,n);
if(r!=inf) rf=1;
r+=a[i]-(ll)i*D;
ll add=min(l,r);
if(lf && rf) add=min(add,(ll)a[i]*2);
//printf("%i %lld l:%lld %lld r:%lld\n",i,add,l,L.Get(1,i-1),r);
ans+=add;
}
L.Set(i,a[i]-(ll)i*D);
R.Set(i,a[i]+(ll)i*D);
//printf("Ins:%lld %lld\n",a[i]-(ll)i*D,a[i]+(ll)i*D);
}
return ans;
}
int main()
{
int n,i,D;
scanf("%i %i",&n,&D);
for(i=1;i<=n;i++) scanf("%i",&a[i]);
if(n==1) return 0*printf("0\n");
printf("%lld\n",Solve(n,D));
/*ll ans=0;
for(i=2;i<n;i++) ans+=a[i]*2;
ans+=a[1]+a[n];
ll sum;
ans+=(ll)D*(n-1);
sum=ans;
int id=1;
for(i=2;i<=n;i++) if(a[i]<a[id]) id=i;
dp[id]=0;
ll mn=a[id]-(ll)id*D;
for(i=id+1;i<=n;i++)
{
dp[i]=mn+a[i]+(ll)i*D+dp[i-1];
mn=min(mn,a[i]-(ll)i*D);
}
tmp[id]=0;
mn=a[id]+(ll)id*D;
for(i=id-1;i>=1;i--)
{
tmp[i]=mn+a[i]-(ll)i*D+tmp[i+1];
mn=min(mn,a[i]+(ll)i*D);
}
//for(i=1;i<=n;i++) ans=min(ans,dp[i]+tmp[i]);
//for(i=1;i<=n;i++) printf("i:%i dp:%lld tmp:%lld\n",i,dp[i],tmp[i]);
ans=min(ans,dp[n]+tmp[1]);
printf("%lld\n",ans);*/
/*for(i=1;i<=n;i++)
{
tmp[i]=a[i]-(ll)i*D;
if(i>1) tmp[i]=min(tmp[i],tmp[i-1]);
}
ll ret=0;
mn=a[n]+(ll)n*D;
for(i=n-1;i>=1;i--)
{
ret+=tmp[i]+mn;
mn=min(mn,a[i]+(ll)i*D);
}
printf("%lld\n",ret);*/
return 0;
}
|
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 2e5 + 5;
const int LogN = 23;
const long long inf = 1e17;
int A[N], n;
long long D;
struct Edge {
int u, v;
long long w;
} e[N * LogN];
int etot = 0;
void buildGraph(int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1;
buildGraph(l, mid);
buildGraph(mid + 1, r);
int x, y;
long long f = inf, g = inf;
for (int i = l; i <= mid; i++)
if (f > A[i] - i * D)
f = A[i] - i * D, x = i;
for (int i = mid + 1; i <= r; i++)
if (g > A[i] + i * D)
g = A[i] + i * D, y = i;
for (int i = mid + 1; i <= r; i++)
e[++etot] = Edge{x, i, f + A[i] + i * D};
for (int i = l; i <= mid; i++)
e[++etot] = Edge{y, i, g + A[i] - i * D};
return;
}
int fa[N];
int find(int x) {
return x == fa[x] ? x : fa[x] = find(fa[x]);
}
void init_ufs(int n) {
for (int i = 1; i <= n; i++)
fa[i] = i;
}
bool merge(int u, int v) {
int fu = find(u), fv = find(v);
if (fu == fv) return false;
return fa[fu] = fv, true;
}
long long Kruskal_MST() {
sort(e + 1, e + 1 + etot, [](Edge& a, Edge& b) {
return a.w < b.w;
});
init_ufs(n);
long long ans = 0ll;
for (int i = 1, c = 0; c < n - 1; i++)
if (merge(e[i].u, e[i].v))
ans += e[i].w, ++c;
return ans;
}
signed main() {
scanf("%d%lld", &n, &D);
for (int i = 1; i <= n; i++)
scanf("%d", A + i);
buildGraph(1, n);
printf("%lld\n", Kruskal_MST());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int , int> P2;
typedef pair<pair<int , int> , int> P3;
typedef pair<pair<int , int> , pair<int , int> > P4;
#define PB(a) push_back(a)
#define MP(a , b) make_pair((a) , (b))
#define M3P(a , b , c) make_pair(make_pair((a) , (b)) , (c))
#define M4P(a , b , c , d) make_pair(make_pair((a) , (b)) , make_pair((c) , (d)))
#define repp(i,a,b) for(int i = (int)(a) ; i < (int)(b) ; ++i)
#define repm(i,a,b) for(int i = (int)(a) ; i > (int)(b) ; --i)
int main(){
int N; LL D; cin >> N >> D;
vector<LL> A(N),r(N);
repp(i,0,N){
cin >> A[i];
r[i] = i;
}
sort(r.begin(),r.end(),[&](const int &u, const int &v){return A[u]+u*D < A[v]+v*D;});
int p = 0;
LL m = A[0];
LL ans = 0;
repp(i,0,N) if(r[i] > p){
LL z = A[r[i]]-r[i]*D;
++p;
while(p < r[i]){
if(m+A[p]+p*D < A[r[i]]+r[i]*D+A[p]-p*D){
ans += m+A[p]+p*D;
m = min(m,A[p]-p*D);
} else {
ans += A[r[i]]+r[i]*D+A[p]-p*D;
z = min(z,A[p]-p*D);
}
++p;
}
ans += m+A[r[i]]+r[i]*D;
m = min(m,z);
}
cout << ans << endl;
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <math.h>
#include <assert.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <iostream>
#include <functional>
#include <unordered_set>
#include <bitset>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define Fi first
#define Se second
#define pb(x) push_back(x)
#define szz(x) (int)x.size()
#define rep(i,n) for(int i=0;i<n;i++)
#define all(x) x.begin(),x.end()
typedef tuple<int, int, int> t3;
int N, D, A[200020];
ll mn_l[200020];
vector <pair<ll, pii> > E;
int p[200020]; int Find(int x) { return p[x] == x ? x : p[x] = Find(p[x]); }
int main() {
scanf("%d%d", &N, &D);
for(int i=1;i<=N;i++) {
scanf("%d", A + i);
}
mn_l[N + 1] = 1e18;
for(int i=N;i;i--) {
mn_l[i] = min(mn_l[i+1], A[i] + (ll) i * D);
}
vector <int> v;
ll mn = 1e18;
for(int i=1;i<=N;i++) {
if(mn > A[i] - (ll)i*D) {
mn = A[i] - (ll) i*D;
v.pb(i);
}
else {
int p = v.back();
ll len = min(mn_l[i+1] + A[i] - (ll)i*D, A[i] + A[p] + (ll)D*(i-p));
E.pb(make_pair(len, pii(i, v.back())));
}
}
for(int i=0;i<szz(v)-1;i++) {
int a = v[i], b = v[i+1];
E.pb(make_pair(mn_l[b] + A[a] - (ll)a*D, pii(a, b)));
}
sort(all(E));
for(int i=1;i<=N;i++) p[i] = i;
ll ans = 0;
for(auto e : E) {
int x = Find(e.Se.Fi), y = Find(e.Se.Se);
if(x != y) p[y] = x, ans += e.Fi;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<ll,int>P;
class UnionFind {
vector<int>par, sz;
public:
UnionFind() {}
UnionFind(int n) {
par = sz = vector<int>(n);
for (int i = 0; i < n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (par[x] == x)return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x); y = find(y);
if (x == y)return;
if (sz[x] > sz[y]) {
par[y] = x;
sz[x] += sz[y];
}
else {
par[x] = y;
sz[y] += sz[x];
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return sz[find(x)];
}
};
int n;ll d;
ll a[300000];
UnionFind uf;
ll mp[300000];
vector<P>loop(bool b){
vector<P>res(n);
rep(i,n)res[i]=P(INFL,-1),mp[i]=INFL;
set<P>se;//コスト、連結成分
rep(i,n){
int id=(b?n-i-1:i);
int p=uf.find(id);
if(!se.empty()){
auto it=se.begin();
while(it!=se.end()&&it->second==p)it++;
if(it!=se.end()){
res[p]=min(res[p],P(d*i+it->first+a[i],it->second));
}
}
ll cost=-i*d+a[i];
if(cost<mp[p]){
se.erase(P(mp[p],p));
mp[p]=cost;
se.insert(P(cost,p));
}
while(se.size()>2)se.erase(--se.end());
}
return res;
}
int main(){
cin>>n>>d;
rep(i,n)scanf("%lld",&a[i]);
uf=UnionFind(n);
ll ans=0;
while(uf.size(0)!=n){
auto res=loop(0);
rep(i,n/2)swap(a[i],a[n-i-1]);
auto res2=loop(1);
rep(i,n/2)swap(a[i],a[n-i-1]);
rep(i,n){
res[i]=min(res[i],res2[i]);
if(res[i].second==-1)continue;
if(!uf.same(i,res[i].second)){
uf.unite(i,res[i].second);
ans+=res[i].first;
}
}
}
cout<<ans<<endl;
}
|
#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
const int N=200005;
long long a[N],l[N],r[N];
int main()
{
ios::sync_with_stdio(false);
int n;
long long d,ret=0;
cin>>n>>d;
for(register int i=1;i<=n;i++)
{
cin>>a[i];
ret+=a[i];
}
ret+=(n-1)*d;
r[1]=a[1];
for(register int i=2;i<=n;i++)
r[i]=min(a[i],r[i-1]+d);
l[n]=a[n];
for(register int i=n-1;i>=1;i--)
l[i]=min(a[i],l[i+1]+d);
for(register int i=2;i<n;i++)
ret+=min(l[i],r[i]);
cout<<ret<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using i64 = long long;
int main() {
constexpr i64 inf = std::numeric_limits<i64>::max() / 2;
int n;
i64 d;
std::cin >> n >> d;
std::vector<i64> a(n), b, c;
for (int i = 0; i < n; i++) {
std::cin >> a[i];
b.push_back(a[i] + i * d);
c.push_back(a[i] - i * d);
}
for (int i = 1; i < n; i++) {
b[n - 1 - i] = std::min(b[n - i - 1], b[n - i]);
c[i] = std::min(c[i], c[i - 1]);
}
std::vector<int> r;
i64 ret = 0;
for (int i = 0; i < n; i++) {
i64 cost = inf;
if (i && c[i - 1] <= a[i] - i * d) {
cost = std::min(cost, c[i - 1] + a[i] + i * d);
}
if (i + 1 < n && b[i + 1] <= a[i] + i * d) {
cost = std::min(cost, b[i + 1] + a[i] - i * d);
}
if (cost < inf) ret += cost;
else r.push_back(i);
}
for (int i = 1; i < r.size(); i++) {
auto v = r[i - 1], w = r[i];
ret += a[v] + a[w] + (w - v) * d;
}
std::cout << ret << std::endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define ll long long
#define pq priority_queue
#define mp make_pair
#define pii pair<int,int>
#define mod 998244353
int lowbit(int x) {return x&(-x);}
int n,d;
int a[200010];
vector <pair<ll,pii> > e;
struct UF{
int p[200010],rank[200010];
void init() {
for (int i=0;i<200010;i++) p[i]=i;
for (int i=0;i<200010;i++) rank[i]=0;
}
int getf(int x){
if (p[x]==x) return x;
return getf(p[x]);
}
bool same(int x,int y) {
return getf(x)==getf(y);
}
void unite(int x,int y) {
int xx=getf(x);
int yy=getf(y);
if (xx!=yy) {
if (rank[xx]<rank[yy]) p[xx]=yy;
else {
p[yy]=xx;
if (rank[xx]==rank[yy]) rank[xx]++;
}
}
}
}uf;
void solve(int l,int r) {
if (l==r) return;
int mid=l+r>>1;
ll mn=1e18;
int pl,pr;
for (int i=l;i<=mid;i++) {
ll cur=(ll)a[i]-(ll)d*(ll)i;
if (cur<mn) {
mn=cur;
pl=i;
}
}
mn=1e18;
for (int j=mid+1;j<=r;j++) {
ll cur=a[j]+(ll)d*(ll)j;
if (cur<mn) {
mn=cur;
pr=j;
}
}
for (int i=mid+1;i<=r;i++) {
ll vl=(ll)a[pl]-(ll)d*(ll)pl;
ll vr=(ll)a[i]+(ll)d*(ll)i;
e.pb(mp(vl+vr,mp(pl,i)));
}
for (int i=l;i<=mid;i++) {
ll vl=(ll)a[i]-(ll)d*(ll)i;
ll vr=(ll)a[pr]+(ll)d*(ll)pr;
e.pb(mp(vl+vr,mp(i,pr)));
}
solve(l,mid);
solve(mid+1,r);
}
int main(){
scanf("%d%d",&n,&d);
for (int i=0;i<n;i++) scanf("%d",&a[i]);
solve(0,n-1);
sort(e.begin(),e.end());
uf.init();
ll ans=0ll;
for (int i=0;i<e.size();i++) {
int u=e[i].se.fi,v=e[i].se.se;
if (!uf.same(u,v)) {
uf.unite(u,v);
ans+=e[i].fi;
// cout<<e[i].fi<<" "<<u<<" "<<v<<endl;
}
}
cout<<ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<vector<ll>> matrix;
ll l[200005];
ll dpR[200005];
ll dpL[200005];
void solve() {
int n;
cin >> n;
ll d;
cin >> d;
ll ret = 0;
for(int i = 0; i < n; i++) {
cin >> l[i];
ret += l[i];
}
ret += (n-1)*d;
dpR[0] = l[0];
for(int i = 1; i < n; i++) {
dpR[i] = min(l[i], dpR[i-1] + d);
}
dpL[n-1] = l[n-1];
for(int i = n-2; i >= 0; i--) {
dpL[i] = min(l[i], dpL[i+1] + d);
}
for(int i = 1; i < n-1; i++) {
ret += min(dpL[i], dpR[i]);
}
cout << ret << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
solve();
}
|
//by xxj
#include<bits/stdc++.h>
using namespace std;
#define mp make_pair
#define ll long long
#define pii pair<int,int>
#define lowbit(x) x&-x
const int inf=1e9+7;
const double eps=1e-10;
const ll linf=1e18+7;
const ll hh=523;
//const int mod=;
ll a[200007];
int fa[200007];
int n;
ll d;
vector<pair<ll,pii> > edge;
int ff(int x){
if (fa[x]==x){
return x;
}
return fa[x]=ff(fa[x]);
}
void solve(int l,int r){
if (l==r){
return;
}
int mid=(l+r)>>1;
ll mnl=linf,mnr=linf;
int pl,pr;
ll t;
for (int i=mid;i>=l;i--){
t=a[i]-1ll*i*d;
if (t<mnl){
mnl=t;
pl=i;
}
}
for (int i=mid+1;i<=r;i++){
t=a[i]+1ll*i*d;
if (t<mnr){
mnr=t;
pr=i;
}
}
for (int i=mid;i>=l;i--){
t=a[i]-1ll*i*d;
edge.push_back(mp(t+mnr,mp(pr,i)));
}
for (int i=mid+1;i<=r;i++){
t=a[i]+1ll*i*d;
edge.push_back(mp(t+mnl,mp(pl,i)));
}
solve(l,mid);
solve(mid+1,r);
}
int main(){
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
scanf("%d%lld",&n,&d);
for (int i=0;i<n;i++){
scanf("%lld",a+i);
fa[i]=i;
}
solve(0,n-1);
sort(edge.begin(),edge.end());
int f1,f2;
ll ans=0;
for (int i=0;i<edge.size();i++){
pii p=edge[i].second;
f1=ff(p.first);
f2=ff(p.second);
if (f1!=f2){
ans+=edge[i].first;
fa[f1]=f2;
}
}
printf("%lld\n",ans);
return 0;
}
/*
input:
*/
|
#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
using namespace std;
long long n,d,a[200005];
typedef pair <int,int> P;
typedef pair <long long,P> PP;
struct UF
{
int par[200005],rank[200005];
void init(int n)
{
for(int i=0;i<n;i++)
{
par[i]=i;
rank[i]=0;
}
}
int find(int x)
{
if(par[x]==x)
return x;
return par[x]=find(par[x]);
}
void unite(int x,int y)
{
x=find(x);
y=find(y);
if(x==y)
return;
if(rank[x]<rank[y])
par[x]=y;
else
{
par[y]=x;
if(rank[x]==rank[y])
rank[x]++;
}
}
bool same(int x,int y)
{
return find(x)==find(y);
}
}uf;
vector <PP> edge;
void solve(int l,int r)
{
if(l==r)
return;
//cout<<l<<' '<<r<<endl;
int m=(l+r)/2;
long long mn=2e18;
int pl=-1;
for(int i=l;i<=m;i++)
{
long long vl=a[i]-d*(long long)i;
if(mn>vl)
{
mn=vl;
pl=i;
}
}
mn=2e18;
int pr=-1;
for(int i=m+1;i<=r;i++)
{
long long vl=a[i]+d*(long long)i;
if(mn>vl)
{
mn=vl;
pr=i;
}
}
for(int i=l;i<=m;i++)
{
long long vl=a[i]-d*(long long)i;
long long vr=a[pr]+d*(long long)pr;
edge.push_back(PP(vl+vr,P(i,pr)));
}
for(int i=m+1;i<=r;i++)
{
long long vl=a[pl]-d*(long long)pl;
long long vr=a[i]+d*(long long)i;
edge.push_back(PP(vl+vr,P(pl,i)));
}
solve(l,m);
solve(m+1,r);
}
int main()
{
scanf("%lld%lld",&n,&d);
for(int i=0;i<n;i++)
scanf("%lld",&a[i]);
solve(0,n-1);
sort(edge.begin(),edge.end());
uf.init(n+2);
long long ret=0;
for(int i=0;i<edge.size();i++)
{
P p=edge[i].second;
//cout<<p.first<<' '<<p.second<<endl;
if(!uf.same(p.first,p.second))
{
//cout<<p.first<<' '<<p.second<<endl;
uf.unite(p.first,p.second);
ret+=edge[i].first;
}
}
cout<<ret;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a) for(int i=0;i<(a);i++)
const ll MOD=1000000007;
int N;
ll D,A[202020];
vector<pair<ll,pair<int,int>>> G;
const int MAX_V=202020;
int par[MAX_V]; // 親
int rnk[MAX_V]; // rank, 木の深さ
void init(){
for(int i=0;i<MAX_V;i++){
par[i]=i;
rnk[i]=0;
}
}
int find(int x){
if (par[x] == x){
return x;
}else{
return par[x] = find(par[x]);
}
}
void unite(int x, int y){
x = find(x);
y = find(y);
if (x == y) return;
if (rnk[x] < rnk[y]){
par[x] = y;
}else{
par[y] = x;
if (rnk[x] == rnk[y]) rnk[x]++;
}
}
bool same(int x, int y){
return find(x) == find(y);
}
void solve(int l, int r){
if(r-l<=1) return;
int mid=(l+r)/2;
int miL=l;
for(int i=l+1;i<mid;i++) if(A[i]-D*i<A[miL]-miL*D) miL=i;
int miR=mid;
for(int i=mid+1;i<r;i++) if(A[i]+D*i<A[miR]+miR*D) miR=i;
for(int i=mid;i<r;i++) G.push_back({A[i]+A[miL]+D*(i-miL),{i,miL}});
for(int i=l;i<mid;i++) G.push_back({A[i]+A[miR]+D*(miR-i),{i,miR}});
solve(l,mid);
solve(mid,r);
}
int main(){
cin>>N>>D;
rep(i,N) cin>>A[i];
solve(0,N);
sort(G.begin(),G.end());
init();
ll ans=0;
for(auto& p:G){
if(!same(p.second.first,p.second.second)){
ans+=p.first;
unite(p.second.first,p.second.second);
}
}
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long l[200003],n,d,dpl[200003],dpr[200003],ans;
int main(){
cin>>n>>d;
ans+=(n-1)*d;
for(int i=0;i<n;i++)
cin>>l[i],
ans+=l[i];
dpr[0]=l[0];dpl[n-1]=l[n-1];
for(int i=1;i<n;i++)
dpr[i]=min(l[i],dpr[i-1]+d);
for(int i=n-2;i>=0;i--)
dpl[i]=min(l[i],dpl[i+1]+d);
for(int i=1;i<n-1;i++)
ans+=min(dpl[i],dpr[i]);
cout<<ans;
}
|
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
using lint = long long int;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template<typename T> void Min(T &m, const T q) { if (m > q) m = q; }
int N;
lint D;
vector<lint> A, B;
int main()
{
cin >> N >> D;
A.resize(N);
lint as = 0;
REP(i, N)
{
cin >> A[i];
as += A[i];
}
B = A;
REP(i, N - 1) Min(B[i + 1], B[i] + D);
IREP(i, N - 1) Min(B[i], B[i + 1] + D);
cout << as + accumulate(B.begin() + 1, B.begin() + N - 1, 0LL) + (N - 1) * D << endl;
}
|
/*
please pass my code
use a kruskal's idea
every edge should be between adjacent connected components
(no idea why this is the case, it just seems to work)
*/
#include <stdio.h>
#include <set>
#include <utility>
long long minn(long long a,long long b){return a<=b?a:b;}
int n;
long long d;
int a[200005];
// segment is [i,ptr2[i])
int ptr1[200005];
int ptr2[200005];
long long c1[200005];
long long c2[200005];
std::set<std::pair<int,int>> kruskal;
bool done[200005];
long long ans=0;
int main()
{
#ifdef NOT_DMOJ
freopen("data.txt","r",stdin);
#endif // NOT_DMOJ
scanf("%d%lld",&n,&d);
for (int i=1; i<=n; i++) {
scanf("%d",a+i);
ptr1[i]=i-1;
ptr2[i]=i+1;
c1[i]=c2[i]=a[i];
}
for (int i=2; i<=n; i++) {
//kruskal.insert({c2[i-1]+c1[i],i});
kruskal.insert({c2[i-1],i});
kruskal.insert({c1[i],i});
}
done[1]=1;
done[n+1]=1;
while (!kruskal.empty()) {
// pop lowest edge from set
int i2=kruskal.begin()->second;
kruskal.erase(kruskal.begin());
if (done[i2]) continue;
done[i2]=1;
int i3=ptr2[i2];
int i1=ptr1[i2];
int i0=ptr1[i1];
ans+=c2[i1]+d+c1[i2];
//printf("%d ans+=%d\n",i2,c2[i1]+d+c1[i2]);
// ptr stuff
ptr2[i0]=i1;
ptr2[i1]=i3;
ptr1[i3]=i1;
ptr1[i1]=i0;
// merge i1 with i2
if (c1[i1]>c1[i2]+(i2-i1)*d) {
c1[i1]=c1[i2]+(i2-i1)*d;
kruskal.insert({c2[i0],i1});
kruskal.insert({c1[i1],i1});
}
c2[i1]=minn(c2[i2],c2[i1]+(i3-i2)*d);
kruskal.insert({c2[i1],i3});
kruskal.insert({c1[i3],i3});
//printf("new ends %lld %lld\n",c1[i1],c2[i1]);
}
printf("%lld\n",ans);
}
|
#include<bits/stdc++.h>
using namespace std;
#define N 300000
#define LL long long
LL n,m,p,ans,a[N],fa[N];
struct edge{
LL x,y,c;
edge(LL x=0,LL y=0,LL c=0):x(x),y(y),c(c){}
bool operator < (const edge &p) const{return c<p.c;}
}b[N<<5];
LL gfa(LL x){
return x==fa[x]?x:fa[x]=gfa(fa[x]);
}
void solve(LL l,LL r){
if (l>=r) return;
LL mid=(l+r)>>1;
LL t=0;
for (LL i=l;i<=mid;++i)
if (t==0||a[i]+(mid-i)*p<a[t]+(mid-t)*p) t=i;
for (LL i=mid+1;i<=r;++i) b[++m]=edge(t,i,a[t]+a[i]+(i-t)*p);
t=0;
for (LL i=mid+1;i<=r;++i)
if (t==0||a[i]+(i-mid-1)*p<a[t]+(t-mid-1)*p) t=i;
for (LL i=l;i<=mid;++i) b[++m]=edge(t,i,a[t]+a[i]+(t-i)*p);
solve(l,mid); solve(mid+1,r);
}
int main(){
scanf("%lld%lld",&n,&p);
for (LL i=1;i<=n;++i) scanf("%lld",a+i);
solve(1,n);
sort(b+1,b+m+1);
for (int i=1;i<=n;++i) fa[i]=i;
for (LL i=1;i<=m;++i){
LL x=b[i].x,y=b[i].y; x=gfa(x); y=gfa(y);
if (x!=y){ans+=b[i].c; fa[x]=y;}
}
printf("%lld\n",ans);
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define ll long long
#define rep(i, a, b) for(int i = a; i <= b; i++)
void read(int &x) {
x = 0; int flag = 1; char ch = ' ';
while(ch < '0' || ch > '9') { if(ch == '-') flag = -1; ch = getchar(); }
while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= flag;
}
void read(ll &x) {
x = 0; int flag = 1; char ch = ' ';
while(ch < '0' || ch > '9') { if(ch == '-') flag = -1; ch = getchar(); }
while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= flag;
}
using namespace std;
const int maxn = 200010;
struct Edge {
int u, v;
ll w;
Edge(){}
Edge(int a, int b, ll c) { u = a, v = b, w = c; }
bool operator < (const Edge & a) const {
return w < a.w;
}
};
vector <Edge> edge;
int n, f[maxn];
ll d, a[maxn];
int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
void solve(int l, int r) {
if(l == r) return;
int mid = (l + r) >> 1, px = 0, py = 0;
ll x = 1e9, y = 1e9;
x *= maxn; y *= maxn;
rep(i, l, mid)
if(a[i] - i * d <= x) {
x = a[i] - i * d;
px = i;
}
rep(i, mid + 1, r)
if(a[i] + i * d <= y) {
y = a[i] + i * d;
py = i;
}
rep(i, l, mid)
edge.push_back(Edge(i, py, (py - i) * d + a[i] + a[py]));
rep(i, mid + 1, r)
edge.push_back(Edge(px, i, (i - px) * d + a[px] + a[i]));
solve(l, mid);
solve(mid + 1, r);
}
int main()
{
read(n), read(d);
rep(i, 1, n) read(a[i]);
solve(1, n);
sort(edge.begin(), edge.end());
ll ans = 0;
rep(i, 1, n) f[i] = i;
rep(i, 0, edge.size() - 1) {
int u = edge[i].u, v = edge[i].v;
int root1 = find(u), root2 = find(v);
if(root1 != root2) {
f[root1] = root2;
ans += edge[i].w;
}
}
printf("%lld\n", ans);
return 0;
}
|
#pragma GCC optimize(2)
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
const int maxn = 2e5 + 5;
int n, d, a[maxn];
ll dp[maxn];
int main() {
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++ i)
scanf("%d", &a[i]);
for (int i = 0; i < n; ++ i) dp[i] = a[i];
for (int i = 0; i + 1 < n; ++ i)
dp[i + 1] = min(dp[i + 1], dp[i] + d);
for (int i = n - 1; i; -- i)
dp[i - 1] = min(dp[i - 1], dp[i] + d);
ll ans = 0;
for (int i = 0; i < n; ++ i) ans += a[i];
for (int i = 1; i < n - 1; ++ i) ans += dp[i];
printf("%lld\n", ans + 1LL * d * (n - 1));
return 0;
}
|
#include<bits/stdc++.h>
#define N 200005
#define ll long long
#define pb push_back
using namespace std;
int fa[N],n;
ll ans,a[N],m;
struct node
{
int L,R;
ll val;
node(ll x,int y,int z){val=x,L=y,R=z;}
bool operator < (const node &x) const
{
if(val!=x.val)return val<x.val;
if(L!=x.L)return L<x.L;
return R<x.R;
}
};
int search(int x)
{
if(fa[x]==x)return x;
return fa[x]=search(fa[x]);
}
vector<node> v;
void solve(int l,int r)
{
if(l==r)return;
int mid=(l+r)>>1,min_l,min_r;
ll mn=-1;
for(int i=l;i<=mid;i++)
{
ll value=a[i]-m*(ll)i;
if(mn==-1||mn>value)
min_l=i,mn=value;
}
mn=-1;
for(int i=mid+1;i<=r;i++)
{
ll value=a[i]+m*(ll)i;
if(mn==-1||mn>value)
min_r=i,mn=value;
ll tmp=a[i]+a[min_l]+m*(ll)(i-min_l);
v.pb(node(tmp,min_l,i));
}
for(int i=l;i<=mid;i++)
{
ll tmp=a[i]+a[min_r]+m*(ll)(min_r-i);
v.pb(node(tmp,i,min_r));
}
solve(l,mid);
solve(mid+1,r);
}
int main()
{
for(int i=0;i<N;i++)
fa[i]=i;
scanf("%d%lld",&n,&m);
for(int i=0;i<n;i++)
scanf("%lld",a+i);
solve(0,n-1);
sort(v.begin(),v.end());
for(int i=0;i<v.size();i++)
{
int x=search(v[i].L),y=search(v[i].R);
if(x==y)continue;
ans+=v[i].val;
fa[x]=y;
}
printf("%lld\n",ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.