text
stringlengths 49
983k
|
|---|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define pa pair<int,int>
const int Maxn=200010;
const LL inf=(1LL<<60);
int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
return x*f;
}
int n;LL d,a[Maxn];
struct Node{LL v;int x;Node(LL _v=0,int _x=0){v=_v;x=_x;}};
bool operator<(Node a,Node b){return a.v<b.v;}
struct Seg{int l,r,lc,rc,pos;Node p[5];}tr[Maxn<<1];
int tot;
void up(int x)
{
int lc=tr[x].lc,rc=tr[x].rc;
for(int i=0;i<5;i++)
if(tr[lc].p[i]<tr[rc].p[i])
{
tr[x].p[i]=tr[lc].p[i];
if(i==4)tr[x].pos=tr[lc].pos;
}
else
{
tr[x].p[i]=tr[rc].p[i];
if(i==4)tr[x].pos=tr[rc].pos;
}
if(tr[lc].p[2].v!=inf&&tr[rc].p[1].v!=inf)
{
LL t=tr[lc].p[2].v+tr[rc].p[1].v;
if(t<tr[x].p[4].v)tr[x].p[4]=Node(t,tr[lc].p[2].x),tr[x].pos=tr[rc].p[1].x;
}
if(tr[lc].p[0].v!=inf&&tr[rc].p[3].v!=inf)
{
LL t=tr[lc].p[0].v+tr[rc].p[3].v;
if(t<tr[x].p[4].v)tr[x].p[4]=Node(t,tr[rc].p[3].x),tr[x].pos=tr[lc].p[0].x;
}
}
void build(int l,int r)
{
int x=++tot;
tr[x].l=l;tr[x].r=r;
for(int i=0;i<5;i++)tr[x].p[i]=Node(inf,0);
if(l==r)
{
if(l!=1)
{
tr[x].p[0]=Node(a[l]-(LL)l*d,l);
tr[x].p[1]=Node(a[l]+(LL)l*d,l);
tr[x].p[2]=tr[x].p[3]=tr[x].p[4]=Node(inf,0);
}
else
{
tr[x].p[0]=tr[x].p[1]=tr[x].p[4]=Node(inf,0);
tr[x].p[2]=Node(a[l]-(LL)l*d,l);
tr[x].p[3]=Node(a[l]+(LL)l*d,l);
}
return;
}
int mid=l+r>>1;
tr[x].lc=tot+1,build(l,mid);
tr[x].rc=tot+1,build(mid+1,r);
up(x);
}
void modify(int x,int p)
{
for(int i=0;i<5;i++)tr[x].p[i]=Node(inf,0);
if(tr[x].l==tr[x].r)
{
int l=tr[x].l;
tr[x].p[0]=tr[x].p[1]=tr[x].p[4]=Node(inf,0);
tr[x].p[2]=Node(a[l]-(LL)l*d,l);
tr[x].p[3]=Node(a[l]+(LL)l*d,l);
return;
}
int mid=tr[x].l+tr[x].r>>1,lc=tr[x].lc,rc=tr[x].rc;
if(p<=mid)modify(lc,p);
else modify(rc,p);
up(x);
}
int main()
{
n=read(),d=read();
for(int i=1;i<=n;i++)a[i]=read();
build(1,n);
int m=n-1;LL ans=0;
while(m--)ans+=tr[1].p[4].v,modify(1,tr[1].pos);
printf("%lld",ans);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+10;
ll A[maxn],dp[2][maxn];
int main()
{
int n;scanf("%d",&n);
ll d;scanf("%lld",&d);
ll ret=0;
for(int i=0;i<n;i++)
{
scanf("%lld",&A[i]);
ret+=A[i];
}
ret+=d*(n-1);
dp[0][0]=A[0];
for(int i=1;i<n;i++)
dp[0][i]=min(A[i],dp[0][i-1]+d);
dp[1][n-1]=A[n-1];
for(int i=n-2;i>=0;i--)
dp[1][i]=min(A[i],dp[1][i+1]+d);
for(int i=1;i<n-1;i++)
ret+=min(dp[0][i],dp[1][i]);
printf("%lld\n",ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define _for(i,j,N) for(int i = (j);i < (N);i++)
#define _rep(i,j,N) for(int i = (j);i <= (N);i++)
#define ALL(x) x.begin(),x.end()
#define pb push_back
#define LL long long
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& v) {
_for(i,0,(int)(v.size()-1)) os << v[i] << " ";
os << v[v.size()-1];
return os;
}
template<typename T>
ostream& operator<<(ostream& os,const set<T>& v){
for(typename set<T>::iterator it = v.begin();it != v.end();it++)
os << *it <<" ";
return os;
}
const int maxn = 2e5+5;
LL N,D;
LL A[maxn];
LL R[maxn];
LL fee(int l,int r){
return (r - l)*D + A[l] + A[r];
}
int main()
{
cin >> N >> D;
_rep(i,1,N){
cin >> A[i];
}
R[N] = N;
for(int i = N-1; i>= 0;i--){
LL bef = R[i+1];
if( (bef - i)*D + A[bef] > A[i]){
R[i] = i;
}
else R[i] = bef;
}
LL ans = 0;
int l = 1;
int ll = 1;
int r = 2;
while(l < N){
r = R[r];
ans += fee(ll,r);
_for(i,l+1,r){
ans += min(fee(ll,i),fee(i,r));
}
l = r;
if((l - ll)*D + A[ll] >= A[l]){
ll = r;
}
r++;
}
cout << ans << endl;
return 0;
}
|
#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;
template<typename T>
struct Kruskal{
struct edge{
int from,to;
T cost;
int used;
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> r,p;
vector<edge> es;
Kruskal(){}
Kruskal(int n):n(n),r(n,1),p(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){ es.emplace_back(u,v,c); }
T build(){
sort(es.begin(),es.end());
T res=0;
for(auto &e:es){
if(!same(e.from,e.to)){
res+=e.cost;
unite(e.from,e.to);
e.used=1;
}
}
return res;
}
};
vector<pair<P,ll>> 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({{idx,i},dist(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({{idx,i},dist(idx,i)}); }
dfs(l,m);
dfs(m,r);
}
int main(){
cin >> n >> d;
rep(i,n){ cin>>a[i]; }
dfs(0,n);
Kruskal<ll> ks(n);
for(auto e:edges){
int u=e.F.F,v=e.F.S; ll c=e.S;
ks.add_edge(v,u,c);
}
ll ans=ks.build();
cout << ans << endl;
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(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>n>>d;
int i,j;
for(i=0;i<n;++i) cin>>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]);
cout<<res<<endl;
return 0;
}
|
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
#pragma comment(linker, "/STACK:1024000000,1024000000")
#pragma GCC optimize("Os")
#pragma GCC optimize("Og")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,sse,sse2,sse3,ssse3,sse4")
#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;
}
|
/* cerberus97 - Hanit Banga */
#include <iostream>
#include <iomanip>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
using namespace std;
#define pb push_back
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL)
typedef long long ll;
typedef long double ld;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
const int N = 2e5 + 10;
struct edge {
int u, v; ll w;
bool operator<(const edge &o) const {
return w < o.w;
}
};
int a[N], sz[N], par[N];
vector<edge> edges;
bool merge(int u, int v);
int get_root(int u);
int main() {
fast_cin();
int n; ll d;
cin >> n >> d;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sz[i] = 1;
par[i] = i;
}
priority_queue<pll, vector<pll>, greater<pll>> q;
for (int i = 1; i <= n; ++i) {
while (!q.empty()) {
int j = q.top().second;
if (a[j] > a[i]) {
q.pop();
continue;
} else {
edges.pb({i, j, a[i] + a[j] + d * (i - j)});
break;
}
}
q.push({a[i] - d * i, i});
}
while (!q.empty()) {
q.pop();
}
for (int i = n; i >= 1; --i) {
while (!q.empty()) {
int j = q.top().second;
if (a[j] > a[i]) {
q.pop();
continue;
} else {
edges.pb({i, j, a[i] + a[j] + d * (j - i)});
break;
}
}
q.push({a[i] + d * i, i});
}
sort(edges.begin(), edges.end());
ll ans = 0;
for (auto &e : edges) {
if (merge(e.u, e.v)) {
ans += e.w;
}
}
cout << ans;
}
bool merge(int u, int v) {
u = get_root(u);
v = get_root(v);
if (u == v) {
return false;
}
if (sz[u] < sz[v]) {
swap(u, v);
}
sz[u] += sz[v];
par[v] = u;
return true;
}
int get_root(int u) {
if (par[u] != u) {
par[u] = get_root(par[u]);
}
return par[u];
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef long double llf;
typedef pair<lint, int> pi;
const int MAXN = 200005;
struct disj{
int pa[MAXN];
void init(int n){
iota(pa, pa + n + 1, 0);
}
int find(int x){
return pa[x] = (pa[x] == x ? x : find(pa[x]));
}
bool uni(int p, int q){
p = find(p);
q = find(q);
if(p == q) return 0;
pa[q] = p; return 1;
}
}disj;
struct edg{
int s, e;
lint x;
bool operator<(const edg &ee)const{
return x < ee.x;
}
};
int n, a[MAXN], proc[MAXN];
int sz[MAXN], msz[MAXN];
vector<edg> ans;
vector<pi> gph[MAXN];
vector<int> cdfn;
void dfs(int x, int p){
cdfn.push_back(x);
sz[x] = 1;
msz[x] = 0;
for(auto &i : gph[x]){
if(!proc[i.second] && i.second != p){
dfs(i.second, x);
sz[x] += sz[i.second];
msz[x] = max(msz[x], sz[i.second]);
}
}
}
int get_center(int x){
cdfn.clear();
dfs(x, -1);
pi ans(1e9, x);
for(auto &i : cdfn){
int w = max(msz[i], sz[x] - sz[i]);
ans = min(ans, pi(w, i));
}
return ans.second;
}
vector<pi> dfn;
lint dis[MAXN];
void dfs2(int x, int p){
dfn.push_back(pi(a[x] + dis[x], x));
for(auto &i : gph[x]){
if(proc[i.second] || i.second == p) continue;
dis[i.second] = dis[x] + i.first;
dfs2(i.second, x);
}
}
int main(){
scanf("%d",&n);
int d; scanf("%d",&d);
for(int i=1; i<=n; i++) scanf("%d",&a[i]);
for(int i=1; i<n; i++){
int s = i, e = i + 1, x = d;
gph[s].push_back(pi(x, e));
gph[e].push_back(pi(x, s));
}
queue<int> que;
que.push(1);
while(!que.empty()){
int x = que.front();
que.pop();
x = get_center(x);
dfn.clear();
dis[x] = 0;
dfs2(x, -1);
sort(dfn.begin(), dfn.end());
for(int i=1; i<dfn.size(); i++){
ans.push_back({dfn[0].second, dfn[i].second,
dfn[0].first + dfn[i].first});
}
proc[x] = 1;
for(auto &i : gph[x]){
if(!proc[i.second]){
que.push(i.second);
}
}
}
sort(ans.begin(), ans.end());
disj.init(n);
lint dap = 0;
for(auto &i : ans){
if(disj.uni(i.s, i.e)) dap += i.x;
}
cout << dap << endl;
}
|
#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(int i=1;i<=n;i++)
{
cin>>a[i];
ret+=a[i];
}
ret+=(n-1)*d;
r[1]=a[1];
for(int i=2;i<=n;i++)
r[i]=min(a[i],r[i-1]+d);
l[n]=a[n];
for(int i=n-1;i>=1;i--)
l[i]=min(a[i],l[i+1]+d);
for(int i=2;i<n;i++)
ret+=min(l[i],r[i]);
cout<<ret<<endl;
return 0;
}
|
#include<vector>
#include<cmath>
#include<map>
#include<cstdlib>
#include<iostream>
#include<sstream>
#include<fstream>
#include<string>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<stack>
#include<bitset>
#include<functional>
#include<ctime>
#include<queue>
#include<deque>
#include<complex>
#include<cassert>
using namespace std;
#define pb push_back
#define pf push_front
typedef long long lint;
typedef complex<double> P;
#define mp make_pair
#define fi first
#define se second
typedef pair<int,int> pint;
typedef pair<int,lint> pl;
typedef pair<lint,pint> tint;
#define All(s) s.begin(),s.end()
#define rAll(s) s.rbegin(),s.rend()
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
//問題文および制約はちゃんと確認しよう！
//サイズは10^5じゃなくて2×10^5とかかもしれないし、重要な制約・条件を見落としているかも
//とりあえずサンプルを読んでから解法を考えよう？
struct unionf{
vector <int> data;
unionf(int size):data(size,-1){}
bool unions(int x,int y){
x=root(x);y=root(y);
if(x!=y){
if(data[y]<data[x]){int d=x;x=y;y=d;}
data[x]+=data[y];data[y]=x;
}
return x!=y;
}
bool finds(int x,int y){
return root(x)==root(y);
}
int root(int x){
return data[x]<0?x:data[x]=root(data[x]);
}
int find(int x){
return -data[x];
}
};
lint d[400100];int from[400100];
vector<pl> gr[400100];
priority_queue<tint> q;
vector<tint> ed;
int main()
{
int n,a;lint D;cin>>n>>D;
rep(i,n){
cin>>a;gr[i].pb(mp(i+n,a));gr[i+n].pb(mp(i,a));
}
rep(i,n-1){
gr[i].pb(mp(i+1,D));gr[i+1].pb(mp(i,D));
}
memset(from,-1,sizeof(from));
rep(i,n) q.push(mp(0,mp(i+n,i+n)));
while(!q.empty()){
tint p=q.top();q.pop();
lint di=-p.fi;int x=p.se.fi,y=p.se.se;
//cout<<di<<' '<<x<<' '<<y<<endl;
if(from[x]>=0){
if(y!=from[x]) ed.pb(mp(d[x]+di,mp(y-n,from[x]-n)));
}
else{
from[x]=y;d[x]=di;
rep(i,gr[x].size()){
q.push(mp(-di-gr[x][i].se,mp(gr[x][i].fi,y)));
}
}
}
unionf uni(n+10);
lint out=0;
rep(i,ed.size()){
lint c=ed[i].fi;int x=ed[i].se.fi,y=ed[i].se.se;
//cout<<c<<' '<<x<<' '<<y<<endl;
if(uni.finds(x,y)) continue;
out+=c;uni.unions(x,y);
}
cout<<out<<endl;
}
|
// includes {{{
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<tuple>
#include<cmath>
#include<random>
#include<cassert>
// #include<deque>
// #include<multiset>
// #include<bitset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = long long;
int n;
ll d;
const int N = 2e5;
int a[N];
ll le[N], ri[N];
ll le2[N], ri2[N];
// smin, smax {{{
// clang-format off
template < class T, class U > inline void smin(T &a, const U &b) { a = a < (T) b ? a : b; }
template < class T, class U > inline void smax(T &a, const U &b) { a = a < (T) b ? b : a; }
// clang-format on
// }}}
// 連結性の証明 :
// 左へ伸ばすものについては，
// 左から伸ばしたものをつなげて，
// 右へ伸ばす頂点を新しく引きずる
// 最小性の証明 :
// それぞれの頂点は選択をしなければいけない
// その選択を制限の範囲で自由にできる
// ごめんちょっとよくわからない
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> d;
for(int i = 0; i < n; i++) {
cin >> a[i];
le[i] = ri[i] = a[i];
le[i] += -i * d;
ri[i] += i * d;
le2[i] = le[i];
ri2[i] = ri[i];
}
for(int i = 1; i < n; i++) smin(le[i], le[i-1]);
for(int i = n - 2; i >= 0; i--) smin(ri[i], ri[i+1]);
ll ans = 0;
for(int i = 0; i < n; i++) {
if(i == 0) {
ans += le2[i];
} else if (i == n - 1) {
ans += ri2[i];
} else {
ans += min(ri2[i] + le[i], le2[i] + ri[i]);
}
}
cout << ans << endl;
return 0;
}
|
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cctype>
#include<vector>
#define rep(i,x,y) for(int i=x; i<=y; ++i)
#define repd(i,x,y) for(int i=x; i>=y; --i)
#define mid (l+r>>1)
#define lch (rt<<1)
#define rch (rt<<1|1)
#define pb push_back
using namespace std;
const int N=200005;
typedef long long LL;
int n;
LL a[N],f[N],g[N],D,ans;
int getint()
{
char ch;
while(!isdigit(ch=getchar()));
int x=ch-48;
while(isdigit(ch=getchar())) x=x*10+ch-48;
return x;
}
signed main()
{
n=getint(),D=getint();
rep(i,1,n) a[i]=getint(),ans+=a[i];
ans+=D*(n-1);
f[1]=a[1];
rep(i,2,n) f[i]=min(a[i],f[i-1]+D);
g[n]=a[n];
repd(i,n-1,1) g[i]=min(a[i],g[i+1]+D);
rep(i,2,n-1) ans+=min(f[i],g[i]);
printf("%lld\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int N = 200003;
long long d,f[N],g[N],a[N],ans=0;
int n;
int main(){
scanf("%d%lld",&n,&d);
for(int i=1;i<=n;i++) {
scanf("%lld",&a[i]);
ans+=a[i];
}
f[1]=a[1];g[n]=a[n];
for(int i=2;i<=n;i++) f[i]=min(f[i-1]+d,a[i]);
for(int i=n-1;i>=1;i--) g[i]=min(g[i+1]+d,a[i]);
for(int i=2;i<n;i++) ans+=min(f[i],g[i]);
printf("%lld",ans+(n-1)*d);
}
|
#include<cstdio>
#include<algorithm>
using int64=long long;
using uchar=unsigned char;
constexpr int maxn(200000);
constexpr int64 inf(1e17);
template<class _Tp>
inline bool bchkMin(_Tp&x,const _Tp&y)
{return(x>y)&&(x=y,1);}
namespace IOManager{
constexpr int FILESZ(131072);
char buf[FILESZ];
const char*ibuf=buf,*tbuf=buf;
struct IOManager{
inline char gc()
{return(ibuf==tbuf)&&(tbuf=(ibuf=buf)+fread(buf,1,FILESZ,stdin),ibuf==tbuf)?EOF:*ibuf++;}
template<class _Tp>
inline operator _Tp(){
_Tp s=0u;char c=gc();
for(;c<48;c=gc());
for(;c>47;c=gc())
s=(_Tp)(s*10u+c-48u);
return s;
}
};
}IOManager::IOManager io;
int sz[maxn+1];
int64 szl[maxn+1],szr[maxn+1];
struct Edge{
int s,t;int64 w;
inline void init(const int&is,const int&it,const int64&iw)
{s=is;t=it;w=iw;}
inline bool operator<(const Edge&rhs)
const{return w<rhs.w;}
}e[maxn*30],*cur=e;
void calc(const int&l,const int&r){
if(l==r)
return;
const int m=(l+r)>>1;
int lmp,rmp;
int64 lmv=inf,rmv=inf;
for(int i=l;i<=m;++i)
if(bchkMin(lmv,szl[i]))
lmp=i;
for(int i=m+1;i<=r;++i)
if(bchkMin(rmv,szr[i]))
rmp=i;
for(int i=l;i<=m;++i)
(++cur)->init(i,rmp,szl[i]+rmv);
for(int i=m+1;i<=r;++i)
(++cur)->init(lmp,i,lmv+szr[i]);
calc(l,m);calc(m+1,r);
}
int ufs[maxn+1];
inline int anc(const int&v)
{return v==ufs[v]?v:ufs[v]=anc(ufs[v]);}
int main(){
const int n=io,D=io;
int64 t=0;
for(int i=1;i<=n;++i,t+=D)
ufs[i]=i,
sz[i]=io,
szl[i]=sz[i]-t,
szr[i]=sz[i]+t;
calc(1,n);
std::sort(e+1,cur+1);
int64 ans=0;
for(Edge*i=e+1;i<=cur;++i)
if(anc(i->s)!=anc(i->t))
ans+=i->w,ufs[ufs[i->s]]=ufs[i->t];
printf("%lld",ans);
return 0;
}
|
#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);
const int src = min_element(a.begin(), a.end()) - a.begin();
ll ans = 0;
for (int i = src - 1; i >= 0; --i) {
ans += a[i] + b[i + 1] + D;
}
for (int i = src + 1; i < n; ++i) {
ans += a[i] + b[i - 1] + D;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using E = pair<ll, P>;
const ll INF = 1LL << 60;
int n;
ll D;
ll a[200005];
vector< E > edges;
void solve(int L, int R) {
if (R - L <= 1) return;
int mid = (R + L) / 2;
ll lval = INF;
int lidx = -1;
for (int i = L; i < mid; i++) {
ll tmp = a[i] - D * i;
if (lval > tmp) {
lidx = i;
lval = tmp;
}
}
ll rval = INF;
int ridx = -1;
for (int i = mid; i < R; i++) {
ll tmp = a[i] + D * i;
if (rval > tmp) {
ridx = i;
rval = tmp;
}
}
for (int i = L; i < mid; i++) {
edges.emplace_back(a[i] + a[ridx] + D * (ridx - i), P(i, ridx));
}
for (int i = mid; i < R; i++) {
edges.emplace_back(a[i] + a[lidx] + D * (i - lidx), P(lidx, i));
}
solve(L, mid);
solve(mid, R);
}
struct UnionFind {
//各要素が属する集合の代表(根)を管理する
//もし、要素xが根であればdata[x]は負の値を取り、-data[x]はxが属する集合の大きさに等しい
vector<int> data;
UnionFind(int sz) : data(sz, -1) {}
bool unite(int x, int y) {
x = find(x);
y = find(y);
bool is_union = (x != y);
if (is_union) {
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return is_union;
}
int find(int x) {
if (data[x] < 0) { //要素xが根である
return x;
} else {
data[x] = find(data[x]); //data[x]がxの属する集合の根でない場合、根になるよう更新される
return data[x];
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return -data[find(x)];
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> D;
for (int i = 0; i < n; i++) cin >> a[i];
solve(0, n);
sort(edges.begin(), edges.end());
UnionFind uf(n);
ll ans = 0;
for (E& e : edges) {
ll cost = e.first;
int u = e.second.first, v = e.second.second;
if (!uf.same(u, v)) {
uf.unite(u, v);
ans += cost;
}
}
cout << ans << endl;
return 0;
}
|
#include<cstdio>
int dpL[200005],dpR[200005],n,D,a[200005];
long long ans;
int Min(int x,int y){return x>y?y:x;}
int main()
{
scanf("%d%d",&n,&D);
for(int i=0;i<n;i++)
scanf("%d",a+i),ans+=a[i]+D;
ans-=D;
dpR[0]=a[0];
for(int i=1;i<n;i++)
dpR[i]=Min(dpR[i-1]+D,a[i]);
dpL[n-1]=a[n-1];
for(int i=n-2;i>=0;i--)
dpL[i]=Min(dpL[i+1]+D,a[i]);
for(int i=1;i<n-1;i++)
ans+=Min(dpL[i],dpR[i]);
printf("%lld\n",ans);
return 0;
}
|
// Code By H~S~C
#ifdef ONLINE_JUDGE
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
#pragma comment(linker, "/STACK:1024000000,1024000000")
#pragma GCC optimize("Os")
#pragma GCC optimize("Og")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,sse,sse2,sse3,ssse3,sse4")
#endif
#include <initializer_list>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <iostream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <cstdio>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <set>
#define pb push_back
#define rep(i,n) for (int i=0;i<(n);++i)
#define rep1(i,n) for (int i=1;i<=(n);++i)
#define Rep(i,a,b) for (int i=(a);i<=(b);++i)
#define All(a) a.begin(),a.end()
#define SZ(a) ((int)a.size())
#define sqr(s) ((s)*(s))
#define MP make_pair
#define fillset(a,val) memset(a,val,sizeof(a))
#define X first
#define Y second
#define endl '\n'
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair <int,int> pii;
const int inf=0x3f3f3f3f;
const ll lnf=0x3f3f3f3f3f3f3f3f;
const double EPS=1e-9,PI=acos(-1.0);
const int mod1=1000000007,mod2=998244353;
//....................密..........封..........线..........下..........禁..........止..........hack...............................................
const int Maxn=200005;
ll n,d,a[Maxn],dpl[Maxn],dpr[Maxn],ans;
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(nullptr);cout.tie(nullptr);
cin>>n>>d;rep(i,n) cin>>a[i],ans+=a[i];
ans+=(n-1)*d;dpl[0]=a[0];dpr[n-1]=a[n-1];
rep1(i,n-1) 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);
rep1(i,n-2) ans+=min(dpl[i],dpr[i]);
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 200010
#define INFLL 0x3f3f3f3f3f3f3f3f
int n, m;
ll d, a[N];
struct Edge
{
int u, v; ll w;
Edge() {}
Edge(int u, int v, ll w) : u(u), v(v), w(w) {}
bool operator < (const Edge &other) const { return w < other.w; }
}edge[N * 30];
void add(int l, int r)
{
if (l == r) return;
int mid = (l + r) >> 1;
ll Min = INFLL; int pos = -1;
for (int i = l; i <= mid; ++i)
{
ll f = a[i] - d * i;
if (f < Min)
{
Min = f;
pos = i;
}
}
for (int i = mid + 1; i <= r; ++i)
edge[++m] = Edge(pos, i, a[pos] + a[i] + d * (i - pos));
Min = INFLL; pos = -1;
for (int i = mid + 1; i <= r; ++i)
{
ll f = a[i] + d * i;
if (f < Min)
{
Min = f;
pos = i;
}
}
for (int i = l; i <= mid; ++i)
edge[++m] = Edge(pos, i, a[pos] + a[i] + d * (pos - i));
add(l, mid);
add(mid + 1, r);
}
int pre[N];
int find(int x) { return pre[x] == 0 ? x : pre[x] = find(pre[x]); }
ll Kruskal()
{
memset(pre, 0, sizeof pre);
sort(edge + 1, edge + 1 + m);
int cnt = 1;
ll res = 0;
for (int i = 1; i <= m; ++i)
{
int u = edge[i].u, v = edge[i].v; ll w = edge[i].w;
int fu = find(u), fv = find(v);
if (fu == fv) continue;
pre[fu] = fv;
res += w;
++cnt;
if (cnt == n) return res;
}
return res;
}
int main()
{
while (scanf("%d%lld", &n, &d) != EOF)
{
m = 0;
for (int i = 1; i <= n; ++i) scanf("%lld", a + i);
add(1, n);
printf("%lld\n", Kruskal());
}
return 0;
}
|
#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>>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()
{
ios_base::sync_with_stdio(false);
cin>>n>>d;
init();
for(int i=0;i<n;i++)
{
cin>>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++)
{
typeof(vec[i]) 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;
#define ls val[k << 1]
#define rs val[k << 1 | 1]
#define mid ((s + t) >> 1)
#define lson k << 1, s, mid
#define rson k << 1 | 1, mid + 1, t
typedef long long ll;
typedef pair <ll, int> node;
typedef pair <int, int> pii;
typedef pair <ll, pii> edge;
const int maxn = 2e5 + 10;
int n, par[maxn]; ll k, a[maxn];
node dat[maxn]; vector <edge> e;
struct sgt {
node val[maxn << 2];
void build(int k, int s, int t) {
if (s == t) {
val[k] = node(1ll << 60, s); return;
}
build(lson), build(rson), val[k] = min(ls, rs);
}
void upd(int k, int s, int t, node x) {
if (s == t) {
val[k] = x; return;
}
if (x.second <= mid) {
upd(lson, x);
} else {
upd(rson, x);
}
val[k] = min(ls, rs);
}
node query(int k, int s, int t, int l, int r) {
if (l <= s && t <= r) {
return val[k];
}
node res = node(1ll << 60, 0);
if (l <= mid) res = query(lson, l, r);
if (r > mid) res = min(res, query(rson, l, r));
return res;
}
} t1, t2;
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);
}
int main() {
scanf("%d %lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i), dat[i] = node(a[i], i), par[i] = i;
}
sort(dat + 1, dat + n + 1);
t1.build(1, 1, n), t2.build(1, 1, n);
for (int i = 1; i <= n; i++) {
int x = dat[i].second; node p;
p = x < n ? t1.query(1, 1, n, x + 1, n) : node(1ll << 60, 0);
if (p.first < 1ll << 60) {
e.push_back(edge(p.first + a[x] - k * x, pii(x, p.second)));
}
t1.upd(1, 1, n, node(a[x] + k * x, x));
p = x > 1 ? t2.query(1, 1, n, 1, x - 1) : node(1ll << 60, 0);
if (p.first < 1ll << 60) {
e.push_back(edge(p.first + a[x] - k * (n - x), pii(x, p.second)));
}
t2.upd(1, 1, n, node(a[x] + k * (n - x), x));
}
sort(e.begin(), e.end());
ll ans = 0;
for (edge p : e) {
int u = p.second.first, v = p.second.second;
if (find(u) != find(v)) {
unite(u, v), ans += p.first;
}
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
int a[200010],d,n,ans;
int dpl[200010],dpr[200010];
signed main(){
cin>>n>>d;
for(int i=1 ;i<=n;i++)cin>>a[i],ans+=a[i];
ans+=(n-1)*d;
dpr[1]=a[1];
for(int i=2;i<=n;i++)dpr[i]=min(a[i],dpr[i-1]+d);
dpl[n]=a[n];
for(int i=n-1;i>=1;i--)dpl[i]=min(a[i],dpl[i+1]+d);
for(int i=2;i<n;i++)ans+=min(dpl[i],dpr[i]);
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int N = 200003;
int n;
long long ans, d, a[N], f[N], g[N];
int main(){
scanf("%d%lld", &n, &d);
for(int i = 1;i <= n;i ++){
scanf("%lld", a + i);
ans += a[i];
}
f[1] = a[1];
for(int i = 2;i <= n;i ++) f[i] = min(f[i - 1] + d, a[i]);
g[n] = a[n];
for(int i = n - 1;i;i --) g[i] = min(g[i + 1] + d, a[i]);
for(int i = 2;i < n;i ++) ans += min(f[i], g[i]);
printf("%lld\n", ans + (n - 1) * d);
}
|
#include <iostream>
#include<vector>
using namespace std;
typedef long long ll;
int main() {
int n;cin>>n;
ll d;cin>>d;
vector<ll> a(n);
for(int i=0;i<n;i++){
cin>>a[i];
}
vector<ll> r(n);
r[n-1]=n-1;
for(int i=n-2;i>=0;i--){
if(a[r[i+1]]+(r[i+1]-i)*d>a[i]){
r[i]=i;
}else{
r[i]=r[i+1];
}
}
int ri=0;
ll ra=a[0];
ll ans=0;
while(ri!=n-1){
ans+=ra+a[r[ri+1]]+(r[ri+1]-ri)*d;
for(int i=ri+1;i<r[ri+1];i++){
if((i-ri)*d+ra<(r[ri+1]-i)*d+a[r[ri+1]]){
ans+=a[i]+ra+(i-ri)*d;
}else{
ans+=a[i]+(r[ri+1]-i)*d+a[r[ri+1]];
}
}
ra+=(r[ri+1]-ri)*d;
if(ra>a[r[ri+1]]){
ra=a[r[ri+1]];
}
ri=r[ri+1];
}
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define maxn 240000
typedef long long LL;
const LL mod = 1000000007;
LL A[maxn], D;
LL mi[2][maxn * 4];
void build(int p, int o, int l, int r){
if(l == r){
mi[p][o] = p ? D * l + A[l] : - D * l + A[l];
return;
}
int m = (l + r) >> 1;
build(p, o * 2, l, m);
build(p, o * 2 + 1, m + 1, r);
mi[p][o] = min(mi[p][o * 2], mi[p][o * 2 + 1]);
}
LL ask(int p, int o, int l, int r, int L, int R){
if(l >= L && r <= R) return mi[p][o];
int m = (l + r) >> 1;
LL ret = 1E18;
if(L <= m) ret = min(ret, ask(p, o * 2, l, m, L, R));
if(R > m) ret = min(ret, ask(p, o * 2 + 1, m + 1, r, L, R));
return ret;
}
void update(int p, int o, int l, int r, int i){
if(l == r) mi[p][o] = 1E18;
else{
int m = (l + r) >> 1;
if(i <= m) update(p, o * 2, l, m, i);
else update(p, o * 2 + 1, m + 1, r, i);
mi[p][o] = min(mi[p][o * 2], mi[p][o * 2 + 1]);
}
}
vector<pair<LL, int> > v;
int main(){
int N;
cin >> N >> D;
LL ans = D * (N - 1);
for(int i = 1; i <= N; i += 1){
cin >> A[i];
ans += A[i] << 1;
}
ans -= A[1] + A[N];
for(int i = 2; i < N; i += 1) v.push_back(make_pair(A[i], i));
sort(v.begin(), v.end());
build(0, 1, 1, N);
build(1, 1, 1, N);
for(auto p : v){
int i = p.second;
LL L = ask(0, 1, 1, N, 1, i - 1) + D * i - A[i];
LL R = ask(1, 1, 1, N, i + 1, N) - D * i - A[i];
if(L >= 0 && R >= 0) continue;
ans += min(L, R);
update(0, 1, 1, N, i);
update(1, 1, 1, N, i);
}
cout << ans;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+105;
const ll MAXN=9e18+105;
struct node{
ll u,v,w;
node(ll u,ll v,ll w):u(u),v(v),w(w){}
bool operator <(const node&A)const{return w<A.w;}
};
ll n,d,ans,cnt;
ll A[N],lv[N],fa[N],deep[N];
vector<node>edge;
int find(int x){
if(fa[x]==x)return x;
else return fa[x]=find(fa[x]);
}
void combine(int x,int y){
x=find(x),y=find(y);
if(lv[x]<lv[y])fa[x]=y;
else if(lv[x]==lv[y])fa[y]=x,lv[x]++;
else fa[y]=x;
}
void divide(int L,int R){
if(L==R)return;
ll mid=(L+R)/2,pL,pR,mL=MAXN,mR=MAXN;
for(int i=L;i<=mid;i++)if(A[i]-d*i<mL)mL=A[i]-d*i,pL=i;
for(int i=mid+1;i<=R;i++)if(A[i]+d*i<mR)mR=A[i]+d*i,pR=i;
for(int i=L;i<=mid;i++)edge.push_back(node(i,pR,mR+A[i]-d*i));
for(int i=mid+1;i<=R;i++)edge.push_back(node(pL,i,mL+A[i]+d*i));
divide(L,mid),divide(mid+1,R);
}
void kruskal(){
for(int i=1;i<=n;i++)fa[i]=i;
for(int i=0;i<edge.size();i++){
int u=edge[i].u,v=edge[i].v;
if(find(u)!=find(v)){
ans+=edge[i].w;
combine(u,v);
cnt++;
}
if(cnt==n-1)break;
}
return;
}
int main(){
scanf("%d%d",&n,&d);
for(int i=1;i<=n;i++)scanf("%d",&A[i]);
divide(1,n);
sort(edge.begin(),edge.end());
kruskal();
cout<<ans<<endl;
return 0;
}
|
#include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
#define SIZE 210000
class unionfind
{
public:
int par[SIZE];
int ran[SIZE];
int ren[SIZE];
void init()
{
for (int i = 0; i<SIZE; i++)
{
par[i] = i;
ran[i] = 0;
ren[i] = 1;
}
}
int find(int a)
{
if (a == par[a])return a;
else return par[a] = find(par[a]);
}
void unite(int a, int b)
{
a = find(a);
b = find(b);
if (a == b)return;
if (ran[a]>ran[b])
{
par[b] = a;
ren[a] += ren[b];
}
else
{
par[a] = b;
ren[b] += ren[a];
}
if (ran[a] == ran[b])ran[b]++;
}
};
unionfind uf;
typedef long long ll;
typedef pair<ll, ll>pii;
typedef pair<ll, pii>pi3;
ll dat[202020];
vector<pi3>pat;
#define INF 1000000000000000000LL
void dfs(int beg, int end, ll dis)
{
if (beg == end)return;
int med = (beg + end) / 2;
ll mini1 = INF, mini2 = INF;
int r1 = -1, r2 = -1;
for (int i = beg; i <= med; i++)if (mini1 > dis*(med - i) + dat[i])mini1 = dis*(med - i) + dat[i], r1 = i;
for (int i = med + 1; i <= end; i++)if (mini2 > dis*(i - med) + dat[i])mini2 = dis*(i - med) + dat[i], r2 = i;
for (int i = beg; i <= med; i++)pat.push_back(make_pair(dis*(r2 - i) + dat[i] + dat[r2], make_pair(i, r2)));
for (int i = med + 1; i <= end; i++)pat.push_back(make_pair(dis*(i - r1) + dat[i] + dat[r1], make_pair(i, r1)));
dfs(beg, med, dis), dfs(med + 1, end, dis);
}
int main()
{
int num;
ll dis;
scanf("%d%lld", &num, &dis);
for (int i = 0; i < num; i++)scanf("%lld", &dat[i]);
dfs(0, num - 1, dis);
sort(pat.begin(), pat.end());
uf.init();
ll s = 0;
for (int i = 0; i < pat.size(); i++)
{
int u = pat[i].second.first, v = pat[i].second.second;
if (uf.find(u) != uf.find(v))
{
uf.unite(u, v);
s += pat[i].first;
}
}
printf("%lld\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) begin(v),end(v)
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll<<30;
constexpr ll longINF = 1ll<<60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
struct UnionFind {
vector<int> par, rank;
UnionFind(int n) {
par.resize(n);
rank.resize(n);
REP(i, n) {
par[i] = i;
rank[i] = 0;
}
}
int operator[] (int x) {
return find(x);
}
int find(int x) {
if (x == par[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]) swap(x, y);
par[y] = x;
if (rank[x] == rank[y]) rank[x]++;
}
bool same(int x, int y) {
return find(x) == find(y);
}
};
using pll = pair<ll, ll>;
using ll3 = tuple<ll, ll, ll>;
int N, D;
vector<int> A;
void dfs(int l, int r, vector<ll3> &edge) {
if (r - l <= 1) return;
int m = (l + r) / 2;
pll mn(longINF, -1);
FOR(i, m, r) chmin(mn, pll(A[i] + (ll)i * D, i));
FOR(i, l, m) edge.emplace_back(A[i] - (ll)i * D + mn.fi, i, mn.se);
mn = pll(longINF, -1);
FOR(i, l, m) chmin(mn, pll(A[i] - (ll)i * D, i));
FOR(i, m, r) edge.emplace_back(A[i] + (ll)i * D + mn.fi, i, mn.se);
dfs(l, m, edge);
dfs(m, r, edge);
}
int main() {
cin >> N >> D;
A.resize(N);
REP(i, N) scanf("%d", &A[i]);
vector<ll3> edge;
dfs(0, N, edge);
sort(ALL(edge));
UnionFind uf(N);
ll ans = 0;
for (ll3 &cur : edge) {
ll cost, x, y;
tie(cost, x, y) = cur;
if (uf.same(x, y)) continue;
uf.unite(x, y);
ans += cost;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SZ(x) ((int)x.size())
#define FOR(i,a,b) for (int i=a;i<=b;++i)
#define FORD(i,a,b) for (int i=a;i>=b;--i)
using namespace std;
typedef long long LL;
typedef pair<LL,int> pa;
typedef vector<int> vec;
void getint(int &v){
char ch,fu=0;
for(ch='*'; (ch<'0'||ch>'9')&&ch!='-'; ch=getchar());
if(ch=='-') fu=1, ch=getchar();
for(v=0; ch>='0'&&ch<='9'; ch=getchar()) v=v*10+ch-'0';
if(fu) v=-v;
}
const LL INF=1e18;
int n,D,a[500010];
bool u[500010];
LL ans;
struct node{
pa v[2][2]; //[in MST now];[use + -]
pa t;
node(){
v[0][0]=v[0][1]=v[1][0]=v[1][1]=mp(INF,0);
t=mp(INF,0);
}
}T[800010];
void pushup(int rt){
T[rt].t=min(T[rt<<1].t,T[rt<<1|1].t);
T[rt].t=min(T[rt].t,mp(T[rt<<1].v[0][0].fi+T[rt<<1|1].v[1][1].fi,T[rt<<1].v[0][0].se));
T[rt].t=min(T[rt].t,mp(T[rt<<1].v[1][0].fi+T[rt<<1|1].v[0][1].fi,T[rt<<1|1].v[0][1].se));
T[rt].v[0][0]=min(T[rt<<1].v[0][0],T[rt<<1|1].v[0][0]);
T[rt].v[0][1]=min(T[rt<<1].v[0][1],T[rt<<1|1].v[0][1]);
T[rt].v[1][0]=min(T[rt<<1].v[1][0],T[rt<<1|1].v[1][0]);
T[rt].v[1][1]=min(T[rt<<1].v[1][1],T[rt<<1|1].v[1][1]);
}
void build(int l,int r,int rt){
if (l==r){
T[rt].v[u[l]][0]=mp(a[l]-1ll*l*D,l);
T[rt].v[u[l]][1]=mp(a[l]+1ll*l*D,l);
T[rt].v[u[l]^1][0]=mp(INF,0);
T[rt].v[u[l]^1][1]=mp(INF,0);
return;
}
int m=l+r>>1;
build(l,m,rt<<1);
build(m+1,r,rt<<1|1);
pushup(rt);
}
void upd(int l,int r,int rt,int x){
if (l==r){
T[rt].v[u[l]][0]=mp(a[l]-1ll*l*D,l);
T[rt].v[u[l]][1]=mp(a[l]+1ll*l*D,l);
T[rt].v[u[l]^1][0]=mp(INF,0);
T[rt].v[u[l]^1][1]=mp(INF,0);
return;
}
int m=l+r>>1;
if (x<=m) upd(l,m,rt<<1,x);
else upd(m+1,r,rt<<1|1,x);
pushup(rt);
}
void prim(){
build(1,n,1);
u[1]=1;
upd(1,n,1,1);
FOR(rp,2,n){
pa tmp=T[1].t;
ans+=tmp.fi;
u[tmp.se]=1;
upd(1,n,1,tmp.se);
}
}
int main(){
cin>>n>>D;
FOR(i,1,n) getint(a[i]);
prim();
printf("%lld\n",ans);
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
const int N=2e5+5;
typedef long long ll;
struct Edge {
int u,v;ll c;
bool operator < (const Edge &b) const {
return c<b.c;
}
};
std::vector<Edge> g;
int par[N],n;ll a[N],D;
void init() {
for(int i=1;i<=n;i++) par[i]=i;
}
int fd(int x) {
return par[x]==x?x:par[x]=fd(par[x]);
}
void solve(int l,int r) {
if(l>=r) return;
int mid=(l+r)>>1;
int L=l,R=mid+1;
for(int i=l+1;i<=mid;i++) {
if(a[i]-D*i<a[L]-L*D) L=i;
}
for(int i=mid+2;i<=r;i++) {
if(a[i]+D*i<a[R]+R*D) R=i;
}
for(int i=l;i<=r;i++) {
if(i<=mid) g.push_back((Edge){i,R,a[i]+a[R]+(R-i)*D});
else g.push_back((Edge){L,i,a[L]+a[i]+(i-L)*D});
}
solve(l,mid);
solve(mid+1,r);
}
ll kruskal() {
init();
std::sort(g.begin(),g.end());
ll ans=0;
for(Edge &w:g) {
int u=fd(w.u),v=fd(w.v);
if(u!=v) par[u]=v,ans+=w.c;
}
return ans;
}
int main() {
scanf("%d%lld",&n,&D);
for(int i=1;i<=n;i++) scanf("%d",a+i);
solve(1,n);printf("%lld\n",kruskal());
return 0;
}
|
#include <cstdio>
#include <unordered_map>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
const int N = 2e5 + 10;
int A[N];
int n, d;
long long ans;
int fa[N];
struct node
{
int x, y;
long long v;
node(int X = 0, int Y = 0, long long V = 0)
{
x = X;
y = Y;
v = V;
}
};
vector<node>edge;
bool operator<(const node &a, const node &b)
{
return a.v < b.v;
}
long long G(int x)
{
return A[x] + (long long)x * d;
}
long long F(int x)
{
return A[x] - (long long)x * d;
}
void work(int l, int r)
{
if (l == r)
{
return;
}
if (l + 1 == r)
{
edge.push_back(node(l, r, F(l) + G(r)));
return;
}
int F_min = l, G_min = r;
int mid = (l + r) / 2;
for (int i = l ; i<= mid ; i ++)
if (F(F_min) > F(i))
F_min = i;
for (int i = mid + 1 ; i<= r ; i ++)
if (G(G_min) > G(i))
G_min = i;
for (int i = l ; i <= mid; i ++)
edge.push_back(node(i, G_min, F(i) + G(G_min)));
for (int i = mid + 1 ; i <= r; i ++)
edge.push_back(node(F_min, i, F(F_min) + G(i)));
work(l, mid);
work(mid + 1, r);
}
int getfa(int x)
{
return x == fa[x] ? x : fa[x] = getfa(fa[x]);
}
int main()
{
scanf("%d %d", &n, &d);
for (int i = 1; i <= n ; i ++)
scanf("%d", &A[i]), fa[i] = i;
work(1, n);
sort(edge.begin(), edge.end());
for (auto u:edge)
if (getfa(u.x) != getfa(u.y))
{
ans += u.v;
fa[getfa(u.x)] = getfa(u.y);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<typename T>
void out(T x) { cout << x << endl; exit(0); }
#define watch(x) cout << (#x) << " is " << (x) << endl
using ll = long long;
const ll mod = 1e9+7;
const int maxn = 1e6 + 5;
struct dsu0 {
vector<int> par, siz;
int n;
int cc;
int largest;
void init(int n) {
assert(n>0);
this->n=n;
cc=n;
par.resize(n+10);siz.resize(n+10);
for (int i=0; i<n; i++) par[i]=i,siz[i]=1;
largest=1;
}
int parent(int x) {
assert(x>=0 && x<n);
return par[x]==x?x:par[x]=parent(par[x]);
}
bool join(int x, int y) {
x=parent(x);y=parent(y);
if (x==y) return false;
cc--;
if (siz[x]<siz[y]) swap(x,y);
siz[x]+=siz[y];par[y]=x;
largest=max(largest,siz[x]);
return true;
}
};
ll n, d;
ll a[maxn];
vector<array<ll,3>> edges;
void solve(int l, int r) {
if (l==r) return;
if (l+1==r) {
edges.push_back({d + a[l] + a[r], l, r});
return;
}
int mid=(l+r)/2;
int l0=l,r0=r;
auto f = [&](ll i) {
return a[i]-d*i;
};
auto g = [&](ll i) {
return a[i]+d*i;
};
for (int i=l; i<=mid; i++) {
if (f(i) < f(l0)) {
l0=i;
}
}
for (int i=mid+1; i<=r; i++) {
if (g(i) < g(r0)) {
r0 = i;
}
}
//cout<<l<<" "<<r<<": "<<l0<<" "<<r0<<endl;
for (int j=mid+1; j<=r; j++) {
edges.push_back({f(l0)+g(j),l0,j});
}
for (int i=l; i<=mid; i++) {
edges.push_back({f(i)+g(r0),i,r0});
}
solve(l,mid);
solve(mid+1,r);
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin>>n>>d;
for (int i=0; i<n; i++) {
cin>>a[i];
}
solve(0,n-1);
sort(edges.begin(), edges.end());
dsu0 dsu;
dsu.init(n);
ll res = 0;
for (auto ed: edges) {
ll wei = ed[0];
int u = ed[1];
int v = ed[2];
//cout<<wei<<": "<<u<<","<<v<<endl;
if (dsu.join(u,v)) {
res += wei;
}
}
assert(dsu.cc==1);
cout<<res<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define ln '\n'
#define all(dat) dat.begin(), dat.end()
#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, fm, to) for (int i = fm; 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;
const int nsz = 2e5;
const num inf = 0x3f3f3f3f3f3f3f3f;
int n, l[nsz + 5], r[nsz + 5];
num d, a[nsz + 5], ans;
num inline w1(int id) {
return a[id] - d * id;
}
num inline w2(int id) {
return a[id] + d * id;
}
num inline w(int u, int v) {
return a[u] + a[v] + d * abs(u - v);
}
int main() {
scanf("%d%lld", &n, &d);
cont (i, n) {
scanf("%lld", &a[i]);
}
a[0] = inf, a[n + 1] = inf;
cont (i, n) {
l[i] = w1(l[i - 1]) < w1(i) ? l[i - 1] : i;
}
for (int i = n; i >= 1; --i) {
r[i] = w2(r[i + 1]) < w2(i) ? r[i + 1] : i;
}
int pre = 0;
cont (i, n) {
if (l[i] == i && r[i] == i) {
if (pre) ans += w(pre, i);
pre = i;
} else {
ans += min(l[i] != i ? w(l[i], i) : inf, r[i] != i ? w(i, r[i]) : inf);
}
}
cout << ans << ln;
}
|
#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
{
return val<x.val;
}
};
int search(int x)
{
if(fa[x]==-1)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()
{
memset(fa,-1,sizeof(fa));
scanf("%d%lld",&n,&m);
for(int i=1;i<=n;i++)
scanf("%lld",a+i);
solve(1,n);
sort(v.begin(),v.end());
n--;
for(int i=0;;i++)
{
int x=search(v[i].L),y=search(v[i].R);
if(x==y)continue;
ans+=v[i].val;n--;
if(!n)
{
printf("%lld\n",ans);
return 0;
}
fa[x]=y;
}
}
|
#include<vector>
#include<iostream>
#include<map>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<deque>
#pragma GCC optimize(2)
#pragma G++ optimize(2)
#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<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
using namespace std;
#define REP(i,m,n) for(int i=(int)m ; i < (int) n ; ++i )
#define rep(i,n) REP(i,0,n)
typedef long long ll;
typedef pair<int,int> pint;
typedef pair<ll,int> pli;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
struct UnionFind{
vector<int> par;
UnionFind(int n):par(n,-1){}
int find(int x){
if(par[x]<0)return x;
return par[x]=find(par[x]);
}
bool unite(int x,int y){
x=find(x);
y=find(y);
if(x==y)return false;
if(par[x]>par[y]){
par[y]+=par[x];
par[x]=y;
}
else{
par[x]+=par[y];
par[y]=x;
}
return true;
}
bool same(int x,int y){
return find(x)==find(y);
}
};
vector<pair<ll,pint>> edges;
ll a[202020],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(){
int n;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){
if(uf.unite(e.second.first,e.second.second))ans+=e.first;
}
cout<<ans<<endl;
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <set>
#include <map>
#include <functional>
#include <cmath>
#include <cassert>
#include <string>
#define SIZE 200005
#define INF 10000000000000000LL
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
typedef pair <ll,P> PP;
struct UF
{
int par[SIZE],rank[SIZE];
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;
ll A[SIZE];
ll D;
vector <PP> edge;
void solve(int l,int r)
{
if(l==r) return;
int m=(l+r)/2;
ll mn=INF;
int pl=-1;
for(int i=l;i<=m;i++)
{
ll vl=A[i]-D*(ll) i;
if(mn>vl)
{
mn=vl;
pl=i;
}
}
mn=INF;
int pr=-1;
for(int i=m+1;i<=r;i++)
{
ll vl=A[i]+D*(ll) i;
if(mn>vl)
{
mn=vl;
pr=i;
}
}
for(int i=l;i<=m;i++)
{
ll vl=A[i]-D*(ll) i;
ll vr=A[pr]+D*(ll) pr;
edge.push_back(PP(vl+vr,P(i,pr)));
}
for(int i=m+1;i<=r;i++)
{
ll vl=A[pl]-D*(ll) pl;
ll vr=A[i]+D*(ll) i;
edge.push_back(PP(vl+vr,P(pl,i)));
}
solve(l,m);
solve(m+1,r);
}
int main()
{
int n;
scanf("%d %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);
ll ret=0;
for(int i=0;i<edge.size();i++)
{
P p=edge[i].second;
if(!uf.same(p.first,p.second))
{
uf.unite(p.first,p.second);
ret+=edge[i].first;
}
}
printf("%lld\n",ret);
return 0;
}
|
#pragma GCC optimize ("O3")
#pragma GCC target ("avx")
#include<cstdio>
#include<algorithm>
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 chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int cm = 1 << 17;
char cn[cm], * ci = cn + cm, ct;
inline char getcha() {
if (ci - cn == cm) { fread_unlocked(cn, 1, cm, stdin); ci = cn; }
return *ci++;
}
inline int getint() {
int A = 0;
if (ci - cn + 16 > cm) while ((ct = getcha()) >= '0') A = A * 10 + ct - '0';
else while ((ct = *ci++) >= '0') A = A * 10 + ct - '0';
return A;
}
int main() {
//cin.tie(0);
//ios::sync_with_stdio(false);
int N = getint();
int D = getint();
ll kotae = (N - 1) * (ll)D;
int A[200001];
int C[200001];
C[0] = 1e9;
rep1(i, N) {
A[i] = getint();
kotae += A[i];
C[i] = min(C[i - 1] + D, A[i]);
}
int mae = 1e9;
for (int i = N - 1; i > 1; i--) {
mae = min(mae + D, A[i + 1]);
kotae += min(A[i], min(mae, C[i - 1]) + D);
}
printf("%lld", kotae);
Would you please 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
//getintとかいうのそんなに速いのかなテスト
int getint()
{
char ch;
while (!isdigit(ch = getchar()));
int x = ch - 48;
while (isdigit(ch = getchar())) x = x * 10 + ch - 48;
return x;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N = getint();
ll D = getint();
ll kotae = (N - 1) * D;
int A[200001];
ll C[200001];
C[0] = 1e18;
rep1(i, N) {
A[i] = getint();
kotae += A[i];
C[i] = min(C[i - 1] + D, (ll)A[i]);
}
ll mae = 1e18;
for (int i = N - 1; i > 1; i--) {
mae = min(mae + D, (ll)A[i + 1]);
ll kari = min(mae, C[i - 1]) + D;
kotae += min((ll)A[i], kari);
}
co(kotae);
Would you please return 0;
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
int res,n,d,a[200010],dpl[200010],dpr[200010];
signed main()
{
ios::sync_with_stdio(false);
cin>>n>>d;
for(int i=1;i<=n;i++){cin>>a[i];res+=a[i];}
res+=(n-1)*d;
dpl[1]=a[1];
for(int i=2;i<=n;i++) dpl[i]=min(a[i],dpl[i-1]+d);
dpr[n]=a[n];
for(int i=n-1;i>=1;i--) dpr[i]=min(a[i],dpr[i+1]+d);
for(int i=2;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;
const int MAX_N=200005;
LL A[MAX_N],dp1[MAX_N],dp2[MAX_N];
LL ans,D;
int n;
int main()
{
cin>>n>>D;
ans+=(n-1)*D;
for(int i=0;i<n;i++)
{
cin>>A[i];
ans+=A[i];
}
dp1[0]=A[0];
dp2[n-1]=A[n-1];
for(int i=1;i<n;i++)dp1[i]=min(dp1[i-1]+D,A[i]);
for(int i=n-2;i>=0;i--)dp2[i]=min(dp2[i+1]+D,A[i]);
for(int i=1;i<n-1;i++)ans+=min(dp1[i],dp2[i]);
if(n==1)ans=0;
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
#define INF 1000000000000000007
using namespace std;
int n,d,p[200010],a[200010];
vector<pair<int,pair<int,int> > > edges;
int find_set(int x)
{
if(p[x]==x) return x;
else return p[x]=find_set(p[x]);
}
bool unite(int x,int y)
{
int rootx=find_set(x),rooty=find_set(y);
if(rootx==rooty) return false;
else{
p[rooty]=rootx;
return true;
}
}
void solve(int l,int r)
{
if(l>=r) return;
int m=(l+r)/2;
int minv1=INF,pos1=-1;
for(int i=l;i<=m;i++){
int val=a[i]-d*i;
if(val<minv1){
minv1=val;
pos1=i;
}
}
int minv2=INF,pos2=-1;
for(int i=m+1;i<=r;i++){
int val=a[i]+d*i;
if(val<minv2){
minv2=val;
pos2=i;
}
}
for(int i=l;i<=m;i++){
edges.push_back(make_pair(minv2+a[i]-d*i,make_pair(i,pos2)));
}
for(int i=m+1;i<=r;i++){
edges.push_back(make_pair(minv1+a[i]+d*i,make_pair(pos1,i)));
}
solve(l,m);
solve(m+1,r);
}
signed main()
{
ios::sync_with_stdio(false);
cin>>n>>d;
for(int i=1;i<=n;i++){
cin>>a[i];
p[i]=i;
}
solve(1,n);
int cnt=0,ans=0;
sort(edges.begin(),edges.end());
for(int i=0;i<edges.size()&&cnt<n-1;i++){
if(unite(edges[i].second.first,edges[i].second.second)){
ans+=edges[i].first;
cnt++;
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n,m,i,j,l[200005],r[200005],mil[200005][19],mir[200005][19],x,y,aa[200005],d,lg[200005],ans;
long long fndl(long long x){if (l[x]==x) return x;return l[x]=fndl(l[x]);}
long long fndr(long long x){if (r[x]==x) return x;return r[x]=fndr(r[x]);}
struct f
{
long long x,id;
}a[200005];
bool cmp(f x,f y){return x.x<y.x;}
void merge(long long x,long long y)
{
if (x>y) swap(x,y);
l[fndl(y)]=fndl(x);
r[fndr(x)]=fndr(y);
}
long long ql(long long x,long long y)
{
if (x>y) return 1ll<<60;
long long k=lg[y-x+1];
return min(mil[x][k],mil[y-(1<<k)+1][k]);
}
long long qr(long long x,long long y)
{
if (x>y) return 1ll<<60;
long long k=lg[y-x+1];
return min(mir[x][k],mir[y-(1<<k)+1][k]);
}
bool isb(long long x,long long y)
{
long long f=min(ql(1,fndl(x)-1)+qr(fndl(x),fndr(x)),qr(fndr(x)+1,n)+ql(fndl(x),fndr(x)));
if (f<y) return 0;
if (f==y) return 1;
if (f>y) exit(-1);
}
void solve(long long x)
{
long long i,j;
for (i=fndl(x)-1;i>=1;i=fndl(i)-1)
{
long long d=ql(fndl(i),fndr(i))+qr(fndl(x),fndr(x));
if (isb(i,d))
{
merge(i,x);
ans+=d;
}
else break;
}
for (i=fndr(x)+1;i<=n;i=fndr(i)+1)
{
long long d=qr(fndl(i),fndr(i))+ql(fndl(x),fndr(x));
if (isb(i,d))
{
merge(i,x);
ans+=d;
}
else break;
}
}
int main()
{
scanf("%lld%lld",&n,&m);
lg[1]=0;
for (i=2;i<=n;i++) lg[i]=lg[i/2]+1;
for (i=1;i<=n;i++)
{
scanf("%lld",&aa[i]);
a[i].x=aa[i];
a[i].id=i;
mil[i][0]=aa[i]-i*m;
mir[i][0]=aa[i]+i*m;
}
for (j=1;(1<<j)<=n;j++)
{
for (i=1;i+(1<<j)-1<=n;i++)
{
mil[i][j]=min(mil[i][j-1],mil[i+(1<<(j-1))][j-1]);
mir[i][j]=min(mir[i][j-1],mir[i+(1<<(j-1))][j-1]);
}
}
sort(a+1,a+n+1,cmp);
for (i=1;i<=n;i++) l[i]=r[i]=i;
for (i=1;i<=n;i++) solve(i);
cout<<ans<<endl;
return 0;
}
|
/*
读题不规范，爆零两行泪。
数据不清空，爆零两行泪。
多测不读完，爆零两行泪。
边界不特判，爆零两行泪。
贪心不证明，爆零两行泪。
D P 顺序错，爆零两行泪。
大小少等号，爆零两行泪。
变量不统一，爆零两行泪。
越界不判断，爆零两行泪。
调试不注释，爆零两行泪。
溢出不 l l，爆零两行泪。
*/
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define mp make_pair
#define X first
#define Y second
#define pb push_back
const int inf=0x3f3f3f3f3f3f3f3f;
int lowbit(int x){return x&-x;}
const int N=200000;
int n,d;
int a[N+1];
pair<int,int> p[N+1];
struct bitree{
pair<int,int> mn[N+1];
void init(){
for(int i=1;i<=n;i++)mn[i]=mp(inf,0);
}
void chkmn(int x,pair<int,int> v){
while(x<=n)mn[x]=min(mn[x],v),x+=lowbit(x);
}
int Mn(int x){
pair<int,int> res(inf,0);
while(x)res=min(res,mn[x]),x-=lowbit(x);
return res.Y;
}
}bit,bit_r;
vector<pair<int,int> > eg;
struct ufset{
int fa[N+1];
void init(){memset(fa,0,sizeof(fa));}
int root(int x){return fa[x]?fa[x]=root(fa[x]):x;}
bool mrg(int x,int y){
x=root(x);y=root(y);
if(x==y)return false;
return fa[x]=y,true;
}
}ufs;
int cst(pair<int,int> x){
if(x.X>x.Y)swap(x.X,x.Y);
return a[x.X]+a[x.Y]+(x.Y-x.X)*d;
}
bool cmp(pair<int,int> x,pair<int,int> y){
return cst(x)<cst(y);
}
int kruskal(){
sort(eg.begin(),eg.end(),cmp);
int ans=0;
// for(int i=0;i<eg.size();i++)printf("%lld %lld\n",eg[i].X,eg[i].Y);
for(int i=0;i<eg.size();i++)ans+=ufs.mrg(eg[i].X,eg[i].Y)*cst(eg[i]);
return ans;
}
signed main(){
cin>>n>>d;
for(int i=1;i<=n;i++)scanf("%lld",a+i),p[i]=mp(a[i],i);
sort(p+1,p+n+1);
bit.init();bit_r.init();
for(int i=1;i<=n;i++){
int mn1=bit.Mn(p[i].Y-1),mn2=bit_r.Mn(n-p[i].Y);
if(mn1)eg.pb(mp(p[i].Y,mn1));
if(mn2)eg.pb(mp(p[i].Y,mn2));
bit.chkmn(p[i].Y,mp(p[i].X-p[i].Y*d,p[i].Y));bit_r.chkmn(n-p[i].Y+1,mp(p[i].X+p[i].Y*d,p[i].Y));
}
cout<<kruskal();
return 0;
}
/*1
3 1000
1 100 1
*/
|
#include<bits/stdc++.h>
using namespace std;
long long n,a[200001],f[200001],g[200001],d;
long long ans;
int main()
{
scanf("%lld%lld",&n,&d);
for(int i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
ans+=a[i];
}
f[1]=a[1];
for(int i=2;i<=n;i++)f[i]=min(f[i-1]+d,a[i]);
g[n]=a[n];
for(int i=n-1;i>=1;i--)g[i]=min(g[i+1]+d,a[i]);
for(int i=2;i<=n-1;i++)ans+=min(f[i],g[i]);
printf("%lld",ans+(n-1)*d);
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
const int INF=1001001001001001001ll;
struct UnionFindTree{
vector<int>par,sz;
UnionFindTree(int n){
par.resize(n);
sz.resize(n);
for(int i=0;i<n;i++){
par[i]=i;
sz[i]=1;
}
}
int find(int x){
return x==par[x]?x: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])swap(x,y);
sz[x]+=sz[y];
par[y]=x;
}
bool areSame(int x,int y){
return find(x)==find(y);
}
int size(int x){
return sz[find(x)];
}
};
int N,D;
int A[222222];
signed main(){
cin>>N>>D;
rep(i,N)cin>>A[i];
UnionFindTree uf(N);
int ans=0;
while(true){
if(uf.size(0)==N)break;
vector<tuple<int,int,int>>uku,ushi;
pint p(INF,-1);
int cur=0;
while(cur<N){
int nex=cur;
int mi1=INF,mi2=INF;
while(nex<N&&uf.areSame(cur,nex)){
chmin(mi1,nex*D+A[nex]);
chmin(mi2,-nex*D+A[nex]);
nex++;
}
uku.pb(make_tuple(p.fi+mi1,p.se,cur));
if(p.fi>mi2)p={mi2,cur};
cur=nex;
}
p={INF,-1};
cur=N-1;
while(cur>=0){
int nex=cur;
int mi1=INF,mi2=INF;
while(nex>=0&&uf.areSame(cur,nex)){
chmin(mi1,-nex*D+A[nex]);
chmin(mi2,nex*D+A[nex]);
nex--;
}
ushi.pb(make_tuple(p.fi+mi1,p.se,cur));
if(p.fi>mi2)p={mi2,cur};
cur=nex;
}
reverse(all(ushi));
rep(i,uku.size()){
tuple<int,int,int>t=min(uku[i],ushi[i]);
int c,x,y;tie(c,x,y)=t;
if(uf.areSame(x,y))continue;
ans+=c;
uf.unite(x,y);
}
}
cout<<ans<<endl;
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]){
if(mp[p]!=INFL)se.erase(P(mp[p],p));
mp[p]=cost;
se.insert(P(cost,p));
}
}
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;
}
|
#include <bits/stdc++.h>
#define ln '\n'
#define all(dat) dat.begin(), dat.end()
#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, fm, to) for (int i = fm; 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;
const int nsz = 2e5;
int n, d, a[nsz + 5];
num w1[nsz + 5], w2[nsz + 5];
vector< pair<num, pair<int, int> > > e;
struct union_find {
int sz, pr[nsz + 5];
int inline operator [] (int id) { return qry(id); }
void inline init(int sz = n) {
this->sz = sz;
cont (u, n) pr[u] = u;
}
int qry(int u) {
return pr[u] == u ? u : pr[u] = qry(pr[u]);
}
bool inline link(int u, int v) {
int pu = qry(u), pv = qry(v);
if (pu == pv) return 0;
pr[pv] = pu;
return 1;
}
};
union_find uf;
num inline w(int u, int v) {
if (u < v) swap(u, v);
return w1[u] + w2[v];
}
void graph_init(int el = 1, int er = n) {
if (el == er) return;
int md = (el + er) >> 1, ml = 1, mr = md + 1;
circ (u, el, md) {
w2[u] < w2[ml] && (ml = u);
}
circ (u, md + 1, er) {
w1[u] < w1[mr] && (mr = u);
}
circ (u, el, md) {
e.push_back({w(u, mr), {u, mr}});
}
circ (u, md + 1, er) {
e.push_back({w(u, ml), {u, ml}});
}
graph_init(el, md);
graph_init(md + 1, er);
}
num inline kruskal(vector< pair<num, pair<int, int> > > &e = ::e) {
int cnt = 0;
num res = 0;
uf.init();
sort(all(e));
loop (i, e.size()) {
int u = e[i].second.first, v = e[i].second.second;
num w = e[i].first;
if (uf.link(u, v)) {
res += w;
if (++cnt == n - 1) break;
}
}
return res;
}
int main() {
scanf("%d%d", &n, &d);
cont (i, n) {
scanf("%d", &a[i]);
w1[i] = (num) a[i] + (num) d * i;
w2[i] = (num) a[i] - (num) d * i;
}
graph_init();
printf("%lld\n", kruskal());
}
|
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<queue>
#include<stack>
using namespace std;
#define MOD 1000000007
#define INF (1<<29)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
Int n, d;
Int a[216000];
Int sums[216000];
Int difs[216000];
Int res;
int main(){
cin >> n >> d;
for(int i = 0;i < n;i++){
cin >> a[i];
sums[i] = a[i] + i * d;
difs[i] = a[i] - i * d;
res += 2 * a[i];
}
res += (n-1)*d;
res -= a[0] + a[n-1];
for(int i = 1;i < n;i++)difs[i] = min(difs[i], difs[i-1]);
for(int i = n-2;i >= 0;i--)sums[i] = min(sums[i], sums[i+1]);
for(int i = 1;i < n-1;i++){
// cout << difs[i] << " " << sums[i] << endl;
Int ltmp = -a[i] + i*d + difs[i];
Int rtmp = -a[i] - i*d + sums[i];
// cout << ltmp << " " << rtmp << endl;
res += min(ltmp, rtmp);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<long,long> P;
typedef pair<long,P> PP;
vector<PP> edge;
long long N,D;
vector<long long> A;
const long INF=(1L<<50);
class UF{
vector<int> par,rank;
public:
UF(int size){
par.resize(size);rank.resize(size);
for (int i = 0; i < size; 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);
}
};
void solve(long l,long r){
if(l==r)return;
long m=(l+r)/2;
long mn=INF;
int pl=-1;
for(long i = l; i <= m; i++)
{
long vl=A[i]-D*i;
if(mn>vl){
mn=vl;
pl=i;
}
}
long pr=-1;
mn=INF;
for(long i=m+1;i<=r;i++){
long vr=A[i]+D*i;
if(mn>vr){
mn=vr;
pr=i;
}
}
for(long i = l; i <= m; i++)
{
edge.push_back(PP(A[i]+A[pr]+D*(pr-i),P(i,pr)));
}
for(long i = m+1; i < r+1; i++)
{
edge.push_back(PP(A[i]+A[pl]+D*(i-pl),P(pl,i)));
}
solve(l,m);
solve(m+1,r);
return;
}
int main(){
scanf("%lld",&N);
scanf("%lld",&D);
A.resize(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&A[i]);
}
solve(0,N-1);
sort(edge.begin(),edge.end());
UF uf(N);
long ret=0;
for(auto tmp:edge){
P p=tmp.second;
if(!uf.same(p.first,p.second)){
uf.unite(p.first,p.second);
ret+=tmp.first;
}
}
cout<<ret<<endl;
return 0;
}
|
#define DEB
#include<bits/stdc++.h>
#define REP(i,m) for(int i=0;i<(m);++i)
#define REPN(i,m,in) for(int i=(in);i<(m);++i)
#define ALL(t) (t).begin(),(t).end()
#define CLR(a) memset((a),0,sizeof(a))
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
using namespace std;
#ifdef DEB
#define dump(x) cerr << #x << " = " << (x) << endl
#define prl cerr<<"called:"<< __LINE__<<endl
#define dumpR(x) cerr<<"\x1b[31m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpY(x) cerr<<"\x1b[33m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpG(x) cerr<<"\x1b[32m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
template<class T> void debug(T a,T b){ for(;a!=b;++a) cerr<<*a<<' ';cerr<<endl;}
#else
#define dump(x) ;
#define dumpR(x) ;
#define dumpY(x) ;
#define dumpG(x) ;
#define prl ;
template<class T> void debug(T a,T b){ ;}
#endif
template<class T> void chmin(T& a,const T& b) { if(a>b) a=b; }
template<class T> void chmax(T& a,const T& b) { if(a<b) a=b; }
typedef long long int lint;
typedef pair<int,int> pi;
namespace std{
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.fr<<','<<a.sc<<')';
return out;
}
}
const lint INF=1e18;
int n;
lint D;
lint ar[200005];
lint br[200005],cr[200005];
bool mark1[200005],mark2[200005];
bool done[200005];
lint pfxbr[200005],sfxcr[200005];
int main(){
cin>>n>>D;
REP(i,n){
cin>>ar[i];
br[i]=ar[i]-i*D;
cr[i]=ar[i]+i*D;
}
pfxbr[0]=INF;
REP(i,n){
if(br[i]<pfxbr[i]){
mark1[i]=1;
pfxbr[i+1]=br[i];
}else{
pfxbr[i+1]=pfxbr[i];
}
}
sfxcr[n]=INF;
for(int i=n-1;i>=0;--i){
if(cr[i]<sfxcr[i+1]){
mark2[i]=1;
sfxcr[i]=cr[i];
}else{
sfxcr[i]=sfxcr[i+1];
}
}
int prev=-1;
lint res=0;
REP(i,n){
if(mark1[i] && mark2[i]){
if(~prev){
res+=D*(i-prev)+ar[i]+ar[prev];
}
prev=i;
}else{
lint tmp1=pfxbr[i]+ar[i]+i*D;
lint tmp2=sfxcr[i]+ar[i]-i*D;
res+=min(tmp1,tmp2);
}
}
cout<<res<<endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
using ll=long long;
struct edge{
ll w,v,u;
};
bool edge_cmp(edge &v, edge &u){
return v.w<u.w;
}
vector<int> al(200010);
ll n,d;
vector<edge> edges;
void rec(ll left, ll right){
if(right-left<=1){
return;
}
ll mid = (left+right)/2;
ll leftmin = left;
for(int i=left;i<mid;i++){
ll t = al[i] - d*i;
ll t2 = al[leftmin] - d*leftmin;
if(t<t2){
leftmin = i;
}
}
ll rightmin = mid;
for(int i=mid;i<right;i++){
ll t = al[i] + d*i;
ll t2 = al[rightmin] + d*rightmin;
if(t<t2){
rightmin = i;
}
}
for(int i=left;i<mid;i++){
edge e = {al[rightmin]+al[i]+(rightmin-i)*d, i, rightmin};
edges.push_back(e);
}
for(int i=mid;i<right;i++){
edge e = {al[leftmin]+al[i]+(i-leftmin)*d, leftmin, i};
edges.push_back(e);
}
rec(left, mid);
rec(mid, right);
}
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
void init(int n) { par.assign(n, -1); }
int find(int x) {
if (par[x] < 0) return x;
else return par[x] = find(par[x]);
}
bool same(int x, int y) {
return find(x) == find(y);
}
bool unite(int x, int y) {
x = find(x); y = find(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[find(x)];
}
};
int main(){
cin>>n>>d;
for(int i=0;i<n;i++){
cin>>al[i];
}
rec(0, n);
UnionFind uf(n);
sort(edges.begin(), edges.end(), edge_cmp);
ll res = 0;
for(auto e:edges){
if(uf.same(e.v, e.u)){
continue;
}
res += e.w;
uf.unite(e.u,e.v);
}
cout<<res<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ref(i,x,y)for(int i=x;i<=y;++i)
#define mp make_pair
#define fi first
#define se second
typedef long long LL;
typedef pair<LL,int> PII;
const int N=200010;
const LL inf=1e18;
int n,D,s[N];
struct node{
int x,y;
PII p; LL s;
PII s1[2],s2[2];
}a[N*5];
void pushup(int t){
int l=t<<1,r=l|1;PII pp;LL ss;
ref(d,0,1)a[t].s1[d]=min(a[l].s1[d],a[r].s1[d]);
ref(d,0,1)a[t].s2[d]=min(a[l].s2[d],a[r].s2[d]);
if(a[l].s<a[r].s) a[t].p=a[l].p,a[t].s=a[l].s;
else a[t].p=a[r].p,a[t].s=a[r].s;
pp=mp(a[l].s2[0].se,a[r].s1[1].se);
ss=a[l].s2[0].fi+a[r].s1[1].fi;
if(ss<a[t].s)a[t].p=pp,a[t].s=ss;
pp=mp(a[r].s1[0].se,a[l].s2[1].se);
ss=a[l].s2[1].fi+a[r].s1[0].fi;
if(ss<a[t].s)a[t].p=pp,a[t].s=ss;
}
void build(int x,int y,int t){
a[t].x=x;a[t].y=y;
if(x==y){
a[t].p=mp(0,0); a[t].s=inf;
a[t].s1[0]=mp(s[x]+(LL)D*x,x);a[t].s1[1]=mp(inf,0);
a[t].s2[0]=mp(s[x]-(LL)D*x,x);a[t].s2[1]=mp(inf,0);
return;
}
int m=(x+y)>>1;
build(x,m,t<<1);
build(m+1,y,t<<1|1);
pushup(t);
}
void update(int x,int y,int t,int p){
if(x==y){
swap(a[t].s1[0],a[t].s1[1]);
swap(a[t].s2[0],a[t].s2[1]);
return;
}
int m=(x+y)>>1;
if(p<=m)update(x,m,t<<1,p);
else update(m+1,y,t<<1|1,p);
pushup(t);
}
int main(){
cin>>n>>D;
ref(i,1,n)cin>>s[i];
build(1,n,1);
update(1,n,1,1);
LL ans=0;
ref(i,1,n-1){
PII p=a[1].p;LL s=a[1].s;
update(1,n,1,p.fi);ans+=s;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> ii;
typedef pair<ll,ll> pll;
#define F first
#define S second
#define RE register
#define random(x) (rand()%x)
#define LOG(a,b) (log(a)/log(b))
#define N 200005
#define mod 998244353
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3fll
int n;
ll d,a[N],ans=0,dpl[N],dpr[N];
int main(){
scanf("%d%lld",&n,&d);
for(int i=1;i<=n;++i){
scanf("%lld",a+i);
ans+=a[i];
}
ans+=d*(n-1);
dpl[1]=a[1];
for(int i=2;i<=n;++i) dpl[i]=min(dpl[i-1]+d,a[i]);
dpr[n]=a[n];
for(int i=n-1;i;--i) dpr[i]=min(dpr[i+1]+d,a[i]);
for(int i=2;i<n;++i) ans+=min(dpl[i],dpr[i]);
printf("%lld\n",ans);
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
template <typename Tp> inline void getint(Tp &num){
register int ch, neg = 0;
while(!isdigit(ch = getchar())) if(ch == '-') neg = 1;
num = ch & 15;
while(isdigit(ch = getchar())) num = num * 10 + (ch & 15);
if(neg) num = -num;
}
int N, cnt, fa[200005]; ll D, A[200005], L[200005], R[200005], ans;
struct edge {int u, v; ll w;} ed[4000005];
inline bool operator < (const edge &ed1, const edge &ed2) {return ed1.w < ed2.w;}
int getf(const int &u) {return fa[u] == u ? u : fa[u] = getf(fa[u]);}
inline int findmin(const ll *a, int l, const int &r){
register int res = l;
while(++l <= r) if(a[l] < a[res]) res = l;
return res;
}
void build(const int &l, const int &r){
if(l == r) return; const int mid = l + r >> 1;
const int Lmin = findmin(L, l, mid), Rmin = findmin(R, mid + 1, r);
for(register int i = l; i <= mid; i++) ed[++cnt] = (edge){i, Rmin, L[i] + R[Rmin]};
for(register int i = mid + 1; i <= r; i++) ed[++cnt] = (edge){Lmin, i, L[Lmin] + R[i]};
build(l, mid), build(mid + 1, r);
}
int main(){
getint(N), getint(D);
for(register int i = 1; i <= N; i++) getint(A[i]), fa[i] = i;
for(register int i = 1; i <= N; i++) L[i] = A[i] - i * D, R[i] = A[i] + i * D;
build(1, N), sort(ed + 1, ed + cnt + 1);
for(register int i = 1, bl = N; i <= cnt && bl > 1; i++){
const int fu = getf(ed[i].u), fv = getf(ed[i].v);
if(fu != fv) bl--, fa[fv] = fu, ans += ed[i].w;
}
return printf("%lld\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)
const int MAX_N=2e5;
const ll INF=1e18;
int N;
int N2;
ll D;
typedef pair<ll,int> P;
ll orgA[MAX_N];
P A[MAX_N];
P seg[2][MAX_N<<2];
P query(int typ,int l,int r,int k,int a,int b){
if (r<=a || b<=l){
return P(INF,-1);
}
if (l<=a && b<=r){
return seg[typ][k];
}
P lseg=query(typ,l,r,k*2+1,a,(a+b)/2),rseg=query(typ,l,r,k*2+2,(a+b)/2,b);
return min(lseg,rseg);
}
void change(int typ,int inx,ll val){
seg[typ][N2-1+inx]=P(val,inx);
inx+=N2-1;
while(1){
if (inx==0){
return;
}
inx=(inx-1)/2;
seg[typ][inx]=min(seg[typ][inx*2+1],seg[typ][inx*2+2]);
}
}
struct edge{
int s,t;
ll cst;
edge(int s=-1,int t=-1,ll c=INF):s(s),t(t),cst(c){}
bool operator < (const edge &e)const{
return cst<e.cst;
}
};
vector<edge> G;
ll calcst(int x,int y){
return orgA[x]+orgA[y]+abs(x-y)*D;
}
int ufpar[MAX_N];
int uffnd(int v){
if (ufpar[v]==v){
return v;
}
return ufpar[v]=uffnd(ufpar[v]);
}
bool iscon(int s,int t){
s=uffnd(s);
t=uffnd(t);
return s==t;
}
void ufunite(int s,int t){
s=uffnd(s);
t=uffnd(t);
ufpar[s]=t;
}
int main(){
cin>>N>>D;
REP(i,N){
ll a;
cin>>a;
orgA[i]=a;
A[i]=P(a,i);
}
N2=1;
while(N2<N) N2<<=1;
REP(i,2){
REP(j,N2*2-1){
seg[i][j]=P(INF,-1);
}
}
sort(A,A+N);
REP(i,N){
P l,r;
l=r=P(INF,-1);
edge el,er;
el=er=edge(-1,-1,INF);
if (A[i].second>0){
l=query(0,0,A[i].second,0,0,N2);
}
if (A[i].second<N-1){
r=query(1,A[i].second+1,N,0,0,N2);
}
if (l.second!=-1){
G.push_back(edge(A[i].second,l.second,calcst(A[i].second,l.second)));
el=edge(A[i].second,l.second,calcst(A[i].second,l.second));
}
if (r.second!=-1){
G.push_back(edge(A[i].second,r.second,calcst(A[i].second,r.second)));
er=edge(A[i].second,r.second,calcst(A[i].second,r.second));
}
change(0,A[i].second,A[i].first-A[i].second*D);
change(1,A[i].second,A[i].first+A[i].second*D);
}
sort(G.begin(),G.end());
ll ans=0;
REP(i,N){
ufpar[i]=i;
}
for(auto e:G){
if (!iscon(e.s,e.t)){
ufunite(e.s,e.t);
ans+=e.cst;
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pii;
#define fi first
#define se second
#define mp make_pair
#define fastIO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
const int N = (int)2e5 + 9;
int par[N];
int fin(int x){
if(x == par[x]) return x;
return par[x]=fin(par[x]);
}
int unite(int a, int b){
a = fin(a);
b = fin(b);
if(a == b) return 0;
par[a]=b;
return 1;
}
struct Edge{
int ai;
int bi;
ll wei;
bool operator< (const Edge &T) const {
return wei < T.wei;
}
};
vector<Edge> check;
ll a[N];
ll d;
void solve(int l, int r){
if(l == r) return;
int mid = (l + r) / 2;
int i1 = l;
int i2 = mid + 1;
for(int j = l + 1; j <= mid ; j ++ ){
if(a[j] - j * 1ll * d < a[i1] - i1 * 1ll * d){
i1 = j;
}
}
for(int j = mid + 2; j <= r; j ++ ){
if(a[j] + j * 1ll * d < a[i2] + i2 * 1ll * d){
i2 = j;
}
}
for(int i = l ; i <= mid ; i ++ ){
check.push_back({i,i2,a[i]+a[i2]+(i2-i)*1ll*d});
}
for(int i = mid + 1; i <= r; i ++ ){
check.push_back({i,i1,a[i]+a[i1]+(i-i1)*1ll*d});
}
solve(l,mid);
solve(mid+1,r);
}
int main(){
fastIO;
int n;
cin >> n >> d;
for(int i = 1; i <= n; i ++ ){
cin >> a[i];
par[i]=i;
}
solve(1,n);
sort(check.begin(), check.end());
ll ans = 0;
for(auto p : check){
ans += p.wei * 1ll * unite(p.ai, p.bi);
}
cout << ans << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,pii> ppi;
const int maxn=200003;
vector<ppi> e;
int n,d,a[maxn];
inline ll calcf(int i){
return a[i]-1ll*d*i;
}
inline ll calcg(int i){
return a[i]+1ll*d*i;
}
void add(int l,int r){
e.push_back(make_pair(calcf(l)+calcg(r),make_pair(l,r)));
}
void solve(int l,int r){
if(l==r) return ;
int mid=(l+r)/2;
solve(l,mid);
solve(mid+1,r);
ll mn=1e18;
int pl,pr;
for(int i=l;i<=mid;++i){
if(calcf(i)<mn){
mn=calcf(i);
pl=i;
}
}
mn=1e18;
for(int i=mid+1;i<=r;++i){
if(calcg(i)<mn){
mn=calcg(i);
pr=i;
}
}
for(int i=l;i<=mid;++i)
add(i,pr);
for(int i=mid+1;i<=r;++i)
add(pl,i);
}
int fa[maxn];
int fnd(int x){
return fa[x]==x?x:fa[x]=fnd(fa[x]);
}
int main(){
scanf("%d%d",&n,&d);
for(int i=1;i<=n;++i)
scanf("%d",&a[i]),fa[i]=i;
solve(1,n);
sort(e.begin(),e.end());
// for(int i=0;i<e.size();++i){
// printf("[%d (%d %d)]\n",e[i].first,e[i].second.first,e[i].second.second);
// }
ll res=0;
for(int i=0;i<e.size();++i){
int x=e[i].second.first;
int y=e[i].second.second;
int fx=fnd(x),fy=fnd(y);
if(fx!=fy){
fa[fx]=fy;
res+=e[i].first;
}
}
printf("%lld\n",res);
return 0;
}
|
#include <cstdio>
#include <set>
#include <vector>
using namespace std;
inline int abs(int x) { return (x >= 0) ? x : - x; }
int main()
{
int n;
long d;
scanf("%d%ld", &n, &d);
vector<long> a(n);
for (int i = 0; i < n; i++)
scanf("%ld", &a[i]);
vector<long> b(n);
for (int i = 0; i < n; i++)
b[i] = a[i] + i * d;
set<pair<long, int>> pairs;
for (int i = 1; i < n; i++)
pairs.insert(make_pair(b[i], i));
long cost = 0;
int j = 0;
int k = 0;
while (!pairs.empty()) {
const int i = pairs.begin()->second;
cost += abs(i - j) * d + a[i] + a[j];
pairs.erase(pairs.begin());
for (k++; k < i; k++) {
cost += min(abs(i - k) * d + a[i] + a[k], abs(j - k) * d + a[j] + a[k]);
pairs.erase(make_pair(b[k], k));
}
if (a[i] < a[j] + abs(i - j) * d)
j = i;
}
printf("%ld\n", cost);
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 <int,int>
#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,a[200010],ans=0,dpl[200010],dpr[200010];
int main()
{
cin>>n>>d;
rep(i,n) scanf("%I64d",&a[i]),ans+=a[i];
if(n==1)
{
puts("0");
rt0;
}
ans+=(n-1)*d;
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++) ans+=min(dpl[i],dpr[i]);//cout<<min(dpl[i],dpr[i])<<' ';
//cout<<endl;
cout<<ans<<endl;
rt0;
}
|
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
ll qmin(ll a, ll b){
return (a < b) ? a : b;
}
ll n, d;
ll a[200200];
vector< pair< ll, pair<ll, ll> > > edge;
void solve(int l, int r){
if(l >= r) return ;
int mid = (l+r) >> 1;
solve(l, mid);
solve(mid+1, r);
int mnpos1 = l;
for(int i = l; i <= mid; i++){
if(a[i] + (mid - i) * d < a[mnpos1] + (mid - mnpos1) * d) mnpos1 = i;
}
ll mnpos2 = mid+1;
for(int i = mid+1; i <= r; i++){
if(a[i] + (i - mid) * d < a[mnpos2] + (mnpos2 - mid) * d) mnpos2 = i;
}
for(int i = l; i <= mid; i++) edge.push_back(make_pair(a[mnpos2] + a[i] + (mnpos2 - i) * d, make_pair(i, mnpos2)));
for(int i = mid+1; i <= r; i++) edge.push_back(make_pair(a[i] + a[mnpos1] + (i - mnpos1) * d, make_pair(i, mnpos1)));
}
int par[200200];
int get_par(int now){
return par[now] = ((par[now] == now) ? now : get_par(par[now]));
}
void unite(int a, int b){
par[get_par(a)] = get_par(b);
}
ll ans = 0;
int main(){
scanf("%lld%lld", &n, &d);
rep(i, n) par[i] = i;
rep(i, n) scanf("%lld", &a[i]);
solve(0, n-1);
sort(edge.begin(), edge.end());
rep(i, edge.size()){
if(get_par(edge[i].second.first) != get_par(edge[i].second.second)){
ans += edge[i].first;
unite(edge[i].second.first, edge[i].second.second);
}
}
cout << ans << endl;
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[200005*18];
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());
}
|
#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);
printf("%lld\n",ans);
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=200010;
int n,a[N],d;
ll ans=0;
int main(){
scanf("%d%d",&n,&d);
ans=1ll*(n-1)*d;
for(int i=1;i<=n;++i)scanf("%d",&a[i]),ans+=a[i];
for(int i=2;i<=n;++i)a[i]=min(a[i-1]+d,a[i]);
for(int i=n-1;i;--i)a[i]=min(a[i+1]+d,a[i]);
for(int i=2;i<n;++i)ans+=a[i];
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i,a,b) for(int i=(a);i<=(b);i++)
#define ROF(i,a,b) for(int i=(a);i>=(b);i--)
int n,d;
ll f[200020],g[200020],ans,a[200020];
int main(){
scanf("%d%d",&n,&d);
FOR(i,1,n) scanf("%lld",a+i);
f[1]=a[1];
FOR(i,2,n) f[i]=min(f[i-1]+d,a[i]);
g[n]=a[n];
ROF(i,n-1,1) g[i]=min(g[i+1]+d,a[i]);
FOR(i,2,n-1) ans+=min(f[i],g[i])+a[i];
ans+=1ll*d*(n-1)+a[1]+a[n];
printf("%lld\n",ans);
}
|
#include <bits/stdc++.h>
using namespace std;
#define LL long long
const int maxN = 2e5 + 10;
struct Node
{
int from, to;
LL value;
Node(int X = 0, int Y = 0, LL Z = 0) { from = X; to = Y; value = Z; }
}edge[maxN * 25 + 1];
int n, D, cnt;
int a[maxN + 1], pa[maxN + 1];
inline int read()
{
int num = 0, f = 1;
char ch = getchar();
while( !isdigit( ch ) ) { if(ch == '-') f = -1; ch = getchar(); }
while( isdigit( ch ) ) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
inline void solve(int l, int r)
{
if(l == r) return;
int mid = (l + r) >> 1;
solve(l, mid); solve(mid + 1, r);
int ml = 0, mr = 0;
LL fl = 1e18, fr = 1e18;
for(int i = l; i <= mid; i++)
if(a[i] - 1ll * D * i < fl) fl = a[i] - 1ll * D * i, ml = i;
for(int i = mid + 1; i <= r; i++)
if(a[i] + 1ll * D * i < fr) fr = a[i] + 1ll * D * i, mr = i;
for(int i = l; i <= mid; i++) edge[++ cnt] = Node(i, mr, 1ll * (mr - i) * D + a[i] + a[mr]);
for(int i = mid + 1; i <= r; i++) edge[++ cnt] = Node(ml, i, 1ll * (i - ml) * D + a[ml] + a[i]);
}
inline bool comp(Node a, Node b) { return a.value < b.value; }
inline int find(int x) { return pa[x] == x ? x : pa[x] = find(pa[x]); }
int main()
{
n = read(), D = read();
for(int i = 1; i <= n; i++) a[i] = read();
solve(1, n);
sort(edge + 1, edge + cnt + 1, comp);
for(int i = 1; i <= n; i++) pa[i] = i;
LL ans = 0;
for(int i = 1; i <= cnt; i++)
{
int x = find(edge[i].from), y = find(edge[i].to);
if(x == y) continue;
ans += edge[i].value;
pa[x] = y;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f3f3f3f3f
const int maxn=2e5+10;
ll A[maxn];
ll D;
struct Edge
{
int u,v;
ll cst;
Edge(){}
Edge(int u,int v,ll cst):u(u),v(v),cst(cst){}
bool operator < (const Edge &t)const
{
return cst<t.cst;
}
};
vector<Edge> edge;
void solve(int l,int r)
{
if(l==r)return;
int mid=(l+r)>>1;
int v1=0;
ll mn=inf;
for(int i=l;i<=mid;i++)
{
ll vl=A[i]-D*1ll*i;
if(vl<mn)
{
mn=vl;
v1=i;
}
}
int v2=0;
mn=inf;
for(int i=mid+1;i<=r;i++)
{
ll vl=A[i]+D*1ll*i;
if(vl<mn)
{
mn=vl;
v2=i;
}
}
for(int i=l;i<=mid;i++)
{
// cout<<(A[v2]+A[i]+D*(v2-i))<<" "<<v2<<" "<<i<<endl;
edge.push_back(Edge(v2,i,A[v2]+A[i]+D*1ll*(v2-i)));
}
for(int i=mid+1;i<=r;i++)
{
// cout<<(A[v1]+A[i]+D*(i-v1))<<" "<<i<<" "<<v1<<endl;
edge.push_back(Edge(v1,i,A[v1]+A[i]+D*1ll*(i-v1)));
}
// system("pause");
solve(l,mid);
solve(mid+1,r);
}
int fa[maxn];
inline int getfa(int x)
{
return fa[x]==x?x:fa[x]=getfa(fa[x]);
}
int main()
{
int n;
scanf("%d%lld",&n,&D);
for(int i=0;i<n;i++)scanf("%lld",&A[i]);
solve(0,n-1);
sort(edge.begin(),edge.end());
for(int i=0;i<n;i++)fa[i]=i;
ll ans=0;
for(int i=0;i<edge.size();i++)
{
int u=edge[i].u,v=edge[i].v;
if(getfa(u)==getfa(v))continue;
// cout<<u<<" "<<v<<endl;
fa[getfa(u)]=getfa(v);
ans+=edge[i].cst;
}
printf("%lld\n",ans);
return 0;
}
|
/*----------------by syr----------------*/
/*
----- ----- -----
| | |---| _/
| | | \_ /
----- | \ -----
|---\ \ / |\ /|
| | \_/ | \/ |
| | / \ | |
|---/ / \ | |
*/
#include<bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i,x,y) for(int i=(x);i<(y);++i)
#define REP(i,x,y) for(int i=(x);i<=(y);++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef pair<int,int> pii;
const int INF=1e9+7;
const int maxn=2e5+5;
struct Edge{
ll w;
int u;
int v;
Edge(ll w,int u,int v):w(w),u(u),v(v){}
inline bool operator <(const Edge &b)const{return w<b.w;}
};
class Dsu{
private:
int sz;
int fa[maxn];
public:
inline void init(int n){
sz=n;
FOR(i,0,sz) fa[i]=i;
return;
}
inline int find(int x){return (x==fa[x])?(x):(fa[x]=find(fa[x]));}
inline void combine(int x,int y){
x=find(x);y=find(y);
fa[x]=y;
return;
}
}dsu;
int n;
int a[maxn];
ll d,ans;
vector<Edge> vec;
inline void solve(int l,int r){
if(l==r) return;
int md=(l+r)>>1;
solve(l,md);
solve(md+1,r);
int va=r,vs=l;
REP(i,l+1,md) if(a[i]-d*i<=a[vs]-d*vs) vs=i;
FOR(i,md+1,r) if(a[i]+d*i<=a[va]+d*va) va=i;
REP(i,l,md) vec.PB(Edge((va-i)*d+a[va]+a[i],va,i));
REP(i,md+1,r) vec.PB(Edge((i-vs)*d+a[vs]+a[i],vs,i));
return;
}
int main(){
scanf("%d%lld",&n,&d);
FOR(i,0,n) scanf("%d",a+i);
solve(0,n-1);
sort(vec.begin(),vec.end());
dsu.init(n);
FOR(i,0,vec.size()){
int u=vec[i].u,v=vec[i].v;
if(dsu.find(u)==dsu.find(v)) continue;
//printf("u=%d v=%d\n",u,v);
ans+=vec[i].w;
dsu.combine(u,v);
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200005;
int n, d;
int a[N];
ll ans, opt;
vector<pair<ll,int>> vals;
int main() {
scanf("%d %d", &n, &d);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
for (int i = 2; i <= n; ++i) {
ll x = (ll) a[i] + (ll) i * d;
while (vals.size() && vals.back().first >= x) {
vals.pop_back();
}
vals.push_back(make_pair(x, i));
}
int now = 2;
opt = a[1] - d;
for (auto p : vals) {
int nxt = p.second;
ans += p.first + opt;
for (int i = now; i < nxt; ++i) {
ans += a[i] + min(p.first - (ll) i * d, opt + (ll) i * d);
opt = min(opt, a[i] - (ll) i * d);
}
opt = min(opt, a[nxt] - (ll) nxt * d);
now = nxt + 1;
}
printf("%lld\n", ans);
}
|
#include<bits/stdc++.h>
using namespace std;
#define FOR(i, x, y) for(int i = (x); i < (y); ++i)
#define REP(i, x, y) for(int i = (x); i <= (y); ++i)
#define MP make_pair
#define PB push_back
#define PH push
#define fst first
#define snd second
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const int maxn = 2e5 + 5;
int n, d;
int a[maxn];
ll ans;
int main(){
scanf("%d%d", &n, &d);
FOR(i, 0, n){
scanf("%d", a + i);
ans += a[i];
}
FOR(i, 1, n)
a[i] = min(a[i], a[i - 1] + d);
for(int i = n - 2; i >= 0; --i)
a[i] = min(a[i], a[i + 1] + d);
FOR(i, 1, n - 1)
ans += a[i];
ans += 1ll * d * (n - 1);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}
class UnionFind{
private:
::std::vector<int_fast32_t> par;
size_t n;
public:
UnionFind(){}
UnionFind(size_t n):n(n){
par.resize(n, -1);
}
uint_fast32_t find(uint_fast32_t x){
return par[x] < 0 ? x : par[x] = find(par[x]);
}
size_t size(uint_fast32_t x){
return -par[find(x)];
}
bool unite(uint_fast32_t x, uint_fast32_t y){
x = find(x);
y = find(y);
if(x == y) return false;
if(size(x) < size(y)) std::swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
bool same(uint_fast32_t x, uint_fast32_t y){
return find(x) == find(y);
}
};
int64 N, D;
vector<int64> A, ed;
vector<PII> e;
UnionFind uf;
void dfs(int64 l, int64 r){
if(r-l == 1) return;
int64 lmin = INF_LL, lidx = -1;
int64 rmin = INF_LL, ridx = -1;
int32 m = (l+r)/2;
FOR(i, l, m){ if (lmin > A[i]-i*D) { lmin = A[i]-i*D; lidx = i; } }
FOR(i, m, r){ if (rmin > A[i]+i*D) { rmin = A[i]+i*D; ridx = i; } }
FOR(i, l, m){ e.emplace_back(i, ridx); ed.emplace_back(rmin+(A[i]-i*D));}
FOR(i, m, r){ e.emplace_back(lidx, i); ed.emplace_back(lmin+(A[i]+i*D));}
dfs(l, m); dfs(m, r);
}
int main(void){
cin >> N >> D;
A.resize(N);
uf = UnionFind(N);
REP(i, N) cin >> A[i];
dfs(0, N);
vector<int64> ord(ed.size()); iota(all(ord), 0);
sort(all(ord), [&](int64 l, int64 r){
return ed[l] < ed[r];
});
int64 res = 0;
REP(i, e.size()){
int64 idx = ord[i];
if(uf.unite(e[idx].fs, e[idx].sc)) res += ed[idx];
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
int n; ll k, ans, a[maxn], lef[maxn], rig[maxn];
int main() {
scanf("%d %lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i), ans += a[i];
}
ans += (n - 1) * k;
lef[1] = a[1];
for (int i = 2; i <= n; i++) {
lef[i] = min(a[i], lef[i - 1] + k);
}
rig[n] = a[n];
for (int i = n - 1; i; i--) {
rig[i] = min(a[i], rig[i + 1] + k);
}
for (int i = 2; i < n; i++) {
ans += min(lef[i], rig[i]);
}
printf("%lld", ans);
return 0;
}
|
#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 = 200005;
int n, d;
int a[maxn];
vector <pair <ll, pair <int, int> > > edges;
struct union_find {
int fa[maxn], siz[maxn];
union_find() {
for (int i = 0; i < maxn; ++ i)
fa[i] = i, siz[i] = 1;
}
int find(int x) {
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void merge(int x, int y) {
x = find(x); y = find(y);
if (x == y) return ;
if (siz[x] < siz[y]) swap(x, y);
fa[y] = x;
siz[x] += siz[y];
}
} dsu;
void solve(int l, int r) {
if (l + 1 == r) return ;
int m = (l + r) >> 1;
vector <pair <ll, int> > lft, rgt;
for (int i = l; i < m; ++ i)
lft.pb(mp(a[i] + 1LL * (m - i) * d, i));
for (int i = m; i < r; ++ i)
rgt.pb(mp(a[i] + 1LL * (i - m) * d, i));
sort(lft.begin(), lft.end());
sort(rgt.begin(), rgt.end());
for (int i = 0; i < lft.size(); ++ i)
edges.pb(mp(lft[i].first + rgt[0].first, mp(lft[i].second, rgt[0].second)));
for (int i = 0; i < rgt.size(); ++ i)
edges.pb(mp(lft[0].first + rgt[i].first, mp(lft[0].second, rgt[i].second)));
solve(l, m); solve(m, r);
}
int main() {
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++ i) scanf("%d", &a[i]);
solve(0, n);
sort(edges.begin(), edges.end());
ll ans = 0;
for (int i = 0; i < edges.size(); ++ i) {
ll d = edges[i].first;
int u = edges[i].second.first;
int v = edges[i].second.second;
if (dsu.find(u) != dsu.find(v)) {
ans += d;
dsu.merge(u, v);
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <iostream>
#include <string>
#include <array>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#include <algorithm>
#include <cmath>
#include <iomanip>
#define FOR(i, a, b) for(decltype(b) i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
using namespace std;
#ifdef INPUT
#include <sstream>
stringstream input(R"(
3 1
1 100 1
)");
#define cin input
#endif
int main()
{
int n, d;
cin >> n >> d;
vector<int> a(n);
for (auto& i : a)
cin >> i;
vector<ll> ld(n), rd(n);
vector<int> lp(n), rp(n);
multimap<ll, int> q;
REP (i, n)
{
ld[i] = a[i] - (ll)i * d;
lp[i] = i;
rd[n - i - 1] = a[n - i - 1] - (ll)i * d;
rp[n - i - 1] = n - i - 1;
if (i)
{
if (ld[i] > ld[i - 1])
{
ld[i] = ld[i - 1];
lp[i] = lp[i - 1];
}
if (rd[n - i - 1] > rd[n - i])
{
rd[n - i - 1] = rd[n - i];
rp[n - i - 1] = rp[n - i];
}
}
}
ll r = (ll)d * (n - 1);
REP (i, n)
{
ll ldd = ld[i] - (a[i] - (ll)i * d);
ll rdd = rd[i] - (a[i] - (ll)(n - i - 1) * d);
if (i && i != n - 1)
q.insert(make_pair(min(ldd, rdd), i));
r += a[i] * 2;
}
r -= a[0];
r -= a[n - 1];
for (auto p : q)
{
r += p.first;
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
#ifdef NON_SUBMIT
#define TEST(n) (n)
#else
#define TEST(n) ((void)0)
#endif
using namespace std;
int N, D;
vector<int> A, color;
vector<tuple<long long,int,int>> E;
int find_(int a)
{
if(a==color[a]) return a;
return color[a]=find_(color[a]);
}
void union_(int a, int b)
{
a=find_(a);
b=find_(b);
color[a]=color[b]=min(a,b);
}
void solve(int s, int e)
{
int m=(s+e)>>1, l=s, r=e;
if(s>=e) return;
for(int i=s;i<=e;i++) {
if(i<=m && A[i]-1LL*i*D<A[l]-1LL*l*D) l=i;
else if(i>m && A[i]+1LL*i*D<A[r]+1LL*r*D) r=i;
}
for(int i=s;i<=e;i++) {
if(i<=m) E.emplace_back(A[i]+A[r]+1LL*(r-i)*D,i,r);
else E.emplace_back(A[l]+A[i]+1LL*(i-l)*D,l,i);
}
solve(s,m);
solve(m+1,e);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
TEST(freopen("input.txt", "r", stdin));
TEST(freopen("output.txt", "w", stdout));
TEST(freopen("debug.txt", "w", stderr));
int u, v;
long long w, ans=0;
cin>>N>>D;
A.resize(N); color.resize(N);
for(int i=0;i<N;i++) cin>>A[color[i]=i];
solve(0,N-1);
sort(E.begin(),E.end());
for(auto e: E) {
tie(w,u,v)=e;
if(find_(u)!=find_(v)) {
union_(u,v);
ans+=w;
}
}
cout<<ans<<'\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define _for(i,j,N) for(int i = (j);i < (N);i++)
#define _rep(i,j,N) for(int i = (j);i <= (N);i++)
#define ALL(x) x.begin(),x.end()
#define pb push_back
#define LL long long
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& v) {
_for(i,0,(int)(v.size()-1)) os << v[i] << " ";
os << v[v.size()-1];
return os;
}
template<typename T>
ostream& operator<<(ostream& os,const set<T>& v){
for(typename set<T>::iterator it = v.begin();it != v.end();it++)
os << *it <<" ";
return os;
}
const int maxn = 2e5+5;
LL N,D;
LL A[maxn];
LL R[maxn];
LL L[maxn];
LL fee(int l,int r){
return (r - l)*D + A[l] + A[r];
}
int main()
{
cin >> N >> D;
_rep(i,1,N){
cin >> A[i];
}
R[N] = N;
for(int i = N-1; i>= 0;i--){
LL bef = R[i+1];
if( (bef - i)*D + A[bef] > A[i]){
R[i] = i;
}
else R[i] = bef;
}
L[1] = 1;
for(int i = 2;i<=N;i++){
LL bef = L[i-1];
if((i-bef)*D + A[bef] > A[i]){
L[i] = i;
}
else L[i] = bef;
}
LL ans = 0;
int p = 1;
int l = 1;
int r = 2;
while(p < N){
r = R[r];
ans += fee(l,r);
_for(i,p+1,r){
ans += min(fee(l,i),fee(i,r));
}
p = r;
l = L[r];
r++;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define fr(i,n) for(int i=0;i<n;i++)
ll par[200010],ranki[200010];
void init(int n){
fr(i,n){
par[i]=i;
ranki[i]=0;
}
}
int find(int x){
if(par[x]==x) return x;
else return par[x]=find(par[x]);
}
void unit(int x,int y){
x=find(x);
y=find(y);
if(x==y) return;
if(ranki[x]<ranki[y]) par[x]=y;
else par[y]=x;
if(ranki[x]==ranki[y]) ranki[x]++;
}
bool same(int x,int y){
return find(x)==find(y);
}
struct road{
ll dm,cd,ct;
bool operator<(const road& right) const{
return ct<right.ct;
}
};
vector<road> roads;
int main(){
ll n,d,a[200010],ans=0,cnt=0;
cin>>n>>d;
fr(i,n) cin>>a[i];
priority_queue<P,vector<P>,greater<P>> q;
fr(i,n){
while(!q.empty()){
ll j=q.top().second;
if(a[j]>a[i]){
q.pop();
continue;
}
else{
roads.push_back((road){i,j,a[i]+a[j]+d*(i-j)});
break;
}
}
q.push(make_pair(a[i]-d*i,i));
}
while(!q.empty()) q.pop();
for(int i=n-1;i>=0;i--){
while(!q.empty()){
ll j=q.top().second;
if(a[j]>a[i]){
q.pop();
continue;
}
else{
roads.push_back((road){i,j,a[i]+a[j]+d*(j-i)});
break;
}
}
q.push(make_pair(a[i]+d*i,i));
}
init(n);
// for(auto it=roads.begin();it!=roads.end();it++) cout<<(*it).dm<<" "<<(*it).cd<<" "<<(*it).ct<<endl;
sort(roads.begin(),roads.end());
for(auto it=roads.begin();cnt<n-1;it++){
road r=*it;
if(same(r.dm,r.cd)) continue;
unit(r.dm,r.cd);
ans+=r.ct;
cnt++;
}
cout<<ans<<endl;
}
|
#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;
int A[200001];
ll C[200001];
C[0] = 1e18;
ll motomoto = (N - 1) * D;
rep1(i, N) {
cin >> A[i];
motomoto += A[i];
C[i] = min(C[i - 1], A[i] - i * D);
}
ll saishou = 1e18;
ll setuyaku = 0;
for (int i = N - 1; i > 1; i--) {
saishou = min(saishou, A[i + 1] + (i + 1) * D);
motomoto += A[i];
ll kari = min(saishou - i * D, C[i - 1] + i * D);
if (A[i] > kari) setuyaku += A[i] - kari;
}
co(motomoto - setuyaku);
Would you please return 0;
}
|
/* --- author: dxm --- */
#include<bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
#define INF 1e9
#define Inf 1e18
#define rep(i,n) for(int (i)=0;(i)<n;i++)
#define REP(i,n) for(int (i)=1;(i)<=n;i++)
#define mp make_pair
#define pb push_back
#define fst first
#define snd second
typedef long long ll;
typedef double db;
typedef long double ldb;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<long long,long long> pll;
void qread(int &x){
int neg=1;x=0;
char c=getchar();
while(c<'0'||c>'9'){if(c=='-')neg=-1;c=getchar();}
while(c>='0'&&c<='9')x=10*x+c-'0',c=getchar();
x*=neg;
}
const int maxn=200005;
int n,d,tot;
int a[maxn];
ll ans;
class Edge{
public:
int u,v;
ll w;
Edge(int _u=0,int _v=0,ll _w=0):u(_u),v(_v),w(_w){}
bool operator < (const Edge &o)const{
return w<o.w;
}
}e[maxn*20];
namespace Dsu{
int f[maxn];
void init(){
REP(i,n)f[i]=i;
}
int find(int x){
return f[x]==x?x:f[x]=find(f[x]);
}
}
void solve(int l,int r){
if(l==r)return;
int mid=l+r>>1;
pair<ll,int>mn=mp(Inf,0);
for(int i=l;i<=mid;i++)mn=min(mn,mp(-1LL*i*d+a[i],i));
for(int i=mid+1;i<=r;i++)e[++tot]=Edge(mn.snd,i,mn.fst+1LL*i*d+a[i]);
mn=mp(Inf,0);
for(int i=mid+1;i<=r;i++)mn=min(mn,mp(1LL*i*d+a[i],i));
for(int i=l;i<=mid;i++)e[++tot]=Edge(i,mn.snd,-1LL*i*d+a[i]+mn.fst);
solve(l,mid);solve(mid+1,r);
}
int main(){
#ifdef FILE
freopen("FILE.in","r",stdin);
freopen("FILE.out","w",stdout);
#endif
scanf("%d%d",&n,&d);
REP(i,n)scanf("%d",&a[i]);
solve(1,n);
sort(e+1,e+1+tot);
Dsu::init();
REP(i,tot){
int u=Dsu::find(e[i].u),v=Dsu::find(e[i].v);
if(u==v)continue;
ans+=e[i].w;
Dsu::f[u]=v;
}
printf("%lld\n",ans);
#ifdef TIME
printf("Running Time = %d ms\n",int(clock()*1000.0/CLOCKS_PER_SEC));
#endif
return 0;
}
/*
Input:
-----------------
Output:
*/
|
#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 getchar getchar_unlocked
#define putchar putchar_unlocked
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
int getint() {
char C;
while (!isdigit(C = getchar()));
int A = C - '0';
while (isdigit(C = getchar())) A = A * 10 + C - '0';
return A;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N = getint();
ll D = getint();
ll kotae = (N - 1) * D;
int A[200001];
ll C[200001];
C[0] = 1e18;
rep1(i, N) {
A[i] = getint();
kotae += A[i];
C[i] = min(C[i - 1] + D, (ll)A[i]);
}
ll mae = 1e18;
for (int i = N - 1; i > 1; i--) {
mae = min(mae + D, (ll)A[i + 1]);
ll kari = min(mae, C[i - 1]) + D;
kotae += min((ll)A[i], kari);
}
co(kotae);
Would you please return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int N=200005;
struct UnionFind
{
int parent[N],rnk[N];
UnionFind(int n)
{
for(int i=0;i<=n;i++)
{
parent[i]=i;
rnk[i]=1;
}
}
int root(int x)
{
if(parent[x]!=x)
parent[x]=root(parent[x]);
return parent[x];
}
void connect(int x,int y)
{
int rx=root(x),ry=root(y);
if(rx==ry)
return;
if(rx>ry)
{
parent[ry]=rx;
rnk[rx]+=rnk[ry];
}
if(rx<=ry)
{
parent[rx]=ry;
rnk[ry]+=rnk[rx];
}
}
};
long long a[N],d;
vector<pair<long long,pair<int,int>>>edge;
void solve(int l,int r)
{
if(l==r)
return;
int m=(l+r)/2;
long long mn=LLONG_MAX;
int pl=-1;
for(int i=l;i<=m;i++)
{
long long vl=a[i]-d*i;
if(mn>vl)
{
mn=vl;
pl=i;
}
}
mn=LLONG_MAX;
int pr=-1;
for(int i=m+1;i<=r;i++)
{
long long vl=a[i]+d*i;
if(mn>vl)
{
mn=vl;
pr=i;
}
}
for(int i=l;i<=m;i++)
{
long long vl=a[i]-d*i;
long long vr=a[pr]+d*pr;
edge.push_back(make_pair(vl+vr,make_pair(i,pr)));
}
for(int i=m+1;i<=r;i++)
{
long long vl=a[pl]-d*pl;
long long vr=a[i]+d*i;
edge.push_back(make_pair(vl+vr,make_pair(pl,i)));
}
solve(l,m);
solve(m+1,r);
}
int main()
{
int n;
scanf("%d%lld",&n,&d);
for(int i=1;i<=n;i++)
scanf("%lld",&a[i]);
solve(1,n);
sort(edge.begin(),edge.end());
UnionFind uf(n);
long long ret=0;
for(int i=0;i<edge.size();i++)
{
pair<int,int> p=edge[i].second;
if(uf.root(p.first)!=uf.root(p.second))
{
uf.connect(p.first,p.second);
ret+=edge[i].first;
}
}
printf("%lld\n",ret);
return 0;
}
|
#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 main()
{
int N;
lint D;
cin >> N >> D;
vector<lint> A(N);
REP(i, N) cin >> A[i];
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<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ll long long
using namespace std;
inline int read(){
int x=0,f=1;char ch;
do{ch=getchar();if(ch=='-')f=-1;}while(ch<'0'||ch>'9');
do{x=x*10+ch-'0';ch=getchar();}while(ch>='0'&&ch<='9');
return x*f;
}
const int N=200010;
const ll INF=0x3f3f3f3f3f3f3f3f;
ll da[2][N],db[2][N],a[N];
int n;ll d;
inline int cmin(ll*num,int x,int y){
if (num[x]<=num[y]) return x;
else return y;
}
struct Data{
int mna[2],mnb[2];
pair<ll,int> ans;
}T[N<<2];
inline void pushup(int o){
for (int i=0;i<2;++i){
T[o].mna[i]=cmin(da[i],T[o<<1].mna[i],T[o<<1|1].mna[i]);
T[o].mnb[i]=cmin(db[i],T[o<<1].mnb[i],T[o<<1|1].mnb[i]);
}
T[o].ans=min(T[o<<1].ans,T[o<<1|1].ans);
ll tans=da[1][T[o<<1].mna[1]]+db[0][T[o<<1|1].mnb[0]];
T[o].ans=min(T[o].ans,make_pair(tans,T[o<<1].mna[1]));
tans=db[1][T[o<<1].mnb[1]]+da[0][T[o<<1|1].mna[0]];
T[o].ans=min(T[o].ans,make_pair(tans,T[o<<1|1].mna[0]));
}
inline void build(int o,int l,int r){
if (l==r){
T[o].ans=make_pair(INF,l);
T[o].mna[0]=T[o].mna[1]=T[o].mnb[0]=T[o].mnb[1]=l;
return;
}
int mid=(l+r)>>1;
build(o<<1,l,mid),build(o<<1|1,mid+1,r);
pushup(o);
}
inline void qset(int o,int l,int r,int x){
if (l==r){
da[0][l]=da[1][l]=INF;
db[0][l]=1ll*l*d+a[l],db[1][l]=-1ll*l*d+a[l];
return;
}
int mid=(l+r)>>1;
if (x<=mid) qset(o<<1,l,mid,x);
else qset(o<<1|1,mid+1,r,x);
pushup(o);
}
int main(){
n=read(),d=read();
for (int i=1;i<=n;++i) a[i]=read();
for (int i=1;i<=n;++i){
da[0][i]=1ll*i*d+a[i],da[1][i]=-1ll*i*d+a[i];
db[0][i]=db[1][i]=INF;
}
build(1,1,n);
ll ans=0;
qset(1,1,n,1);
for (int i=1;i<n;++i){
ans+=T[1].ans.first;
int wh=T[1].ans.second;
qset(1,1,n,wh);
}
printf("%lld\n",ans);
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
const int cm = 1 << 17;
char cn[cm], *ci = cn + cm, ct;
inline char getcha() {
if (ci - cn == cm) { fread_unlocked(cn, 1, cm, stdin); ci = cn; }
return *ci++;
}
inline int getint() {
int A = 0;
if (ci - cn + 16 > cm) while ((ct = getcha()) >= '0') A = A * 10 + ct - '0';
else while ((ct = *ci++) >= '0') A = A * 10 + ct - '0';
return A;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N = getint();
ll D = getint();
ll kotae = (N - 1) * D;
int A[200001];
ll C[200001];
C[0] = 1e18;
rep1(i, N) {
A[i] = getint();
kotae += A[i];
C[i] = min(C[i - 1] + D, (ll)A[i]);
}
ll mae = 1e18;
for (int i = N - 1; i > 1; i--) {
mae = min(mae + D, (ll)A[i + 1]);
ll kari = min(mae, C[i - 1]) + D;
kotae += min((ll)A[i], kari);
}
co(kotae);
Would you please 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;
vector<P>loop(bool b){
unordered_map<int,ll>mp;//連結成分ごとの最小値
set<P>se;//コスト、連結成分
vector<P>res;
rep(i,n){
int id=(b?n-i-1:i);
if(se.empty()){
res.push_back(P(INFL,-1));
}
else{
auto it=se.begin();
while(it!=se.end()&&it->second==uf.find(id))it++;
if(it!=se.end()){
res.push_back(P(d*i+it->first+a[i],it->second));
}
else{
res.push_back(P(INFL,-1));
}
}
ll cost=-i*d+a[i];
if(!mp.count(uf.find(id))||cost<mp[uf.find(id)]){
if(mp.count(uf.find(id)))se.erase(P(mp[uf.find(id)],uf.find(id)));
mp[uf.find(id)]=cost;
se.insert(P(cost,uf.find(id)));
}
}
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]);
swap(res2[i],res2[n-i-1]);
}
unordered_map<int,P>mp;
rep(i,n){
if(!mp.count(uf.find(i))||mp[uf.find(i)]>res[i]){
mp[uf.find(i)]=res[i];
}
if(!mp.count(uf.find(i))||mp[uf.find(i)]>res2[i]){
mp[uf.find(i)]=res2[i];
}
}
for(auto p:mp){
if(p.second.first==INFL)continue;
if(!uf.same(p.first,p.second.second)){
uf.unite(p.first,p.second.second);
ans+=p.second.first;
}
}
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n,m,i,j,l[200005],r[200005],mil[200005][19],mir[200005][19],x,y,aa[200005],d,lg[200005],ans;
long long fndl(long long x){if (l[x]==x) return x;return l[x]=fndl(l[x]);}
long long fndr(long long x){if (r[x]==x) return x;return r[x]=fndr(r[x]);}
struct f
{
long long x,id;
}a[200005];
bool cmp(f x,f y){return x.x<y.x;}
void merge(long long x,long long y)
{
if (x>y) swap(x,y);
l[fndl(y)]=fndl(x);
r[fndr(x)]=fndr(y);
}
long long ql(long long x,long long y)
{
if (x>y) return 1ll<<60;
long long k=lg[y-x+1];
return min(mil[x][k],mil[y-(1<<k)+1][k]);
}
long long qr(long long x,long long y)
{
if (x>y) return 1ll<<60;
long long k=lg[y-x+1];
return min(mir[x][k],mir[y-(1<<k)+1][k]);
}
bool isb(long long x,long long y)
{
long long f=min(ql(1,fndl(x)-1)+qr(fndl(x),fndr(x)),qr(fndr(x)+1,n)+ql(fndl(x),fndr(x)));
if (f<y) return 0;
if (f==y) return 1;
if (f>y) exit(-1);
}
void solve(long long x)
{
long long i,j;
for (i=fndl(x)-1;i>=1;i=fndl(i)-1)
{
long long d=ql(fndl(i),fndr(i))+qr(fndl(x),fndr(x));
if (isb(i,d))
{
merge(i,x);
ans+=d;
}
else break;
}
for (i=fndr(x)+1;i<=n;i=fndr(i)+1)
{
long long d=qr(fndl(i),fndr(i))+ql(fndl(x),fndr(x));
if (isb(i,d))
{
merge(i,x);
ans+=d;
}
else break;
}
}
int main()
{
scanf("%lld%lld",&n,&m);
lg[1]=0;
for (i=2;i<=n;i++) lg[i]=lg[i/2]+1;
for (i=1;i<=n;i++)
{
scanf("%lld",&aa[i]);
a[i].x=aa[i];
a[i].id=i;
mil[i][0]=aa[i]-i*m;
mir[i][0]=aa[i]+i*m;
}
for (j=1;(1<<j)<=n;j++)
{
for (i=1;i+(1<<j)-1<=n;i++)
{
mil[i][j]=min(mil[i][j-1],mil[i+(1<<(j-1))][j-1]);
mir[i][j]=min(mir[i][j-1],mir[i+(1<<(j-1))][j-1]);
}
}
sort(a+1,a+n+1,cmp);
for (i=1;i<=n;i++) l[i]=r[i]=i;
for (i=1;i<=n;i++) solve(a[i].id);
cout<<ans<<endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <queue>
#include <sstream>
#include <stack>
#include <time.h>
#include <vector>
#include <complex>
#include <map>
#include <set>
#include <iomanip>
#include <math.h>
#include <stdlib.h>
#include <list>
#include <utility>
#include <memory>
#include <cstring>
#include <fstream>
#include <numeric>
#include <assert.h>
#include <bits/stdc++.h>
using namespace std;
#define SIZE 200005
#define INF 10000000000000000LL
typedef long long ll;
typedef pair<int,int> P;
typedef pair<ll,P> PP;
struct UF{
int par[SIZE],rank[SIZE];
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;
ll A[SIZE];
ll D;
vector <PP> edge;
void solve(int l,int r){
if (l==r) return;
int m=(l+r)/2;
ll mn=INF;
int pl=-1;
for (int i=l;i<=m;i++){
ll vl=A[i]-D*(ll)i;
if (mn>vl){
mn=vl;
pl=i;
}
}
mn=INF;
int pr=-1;
for (int i=m+1;i<=r;i++){
ll vl=A[i]+D*(ll)i;
if (mn>vl){
mn=vl;
pr=i;
}
}
for (int i=l;i<=m;i++){
ll vl=A[i]-D*(ll)i;
ll vr=A[pr]+D*(ll)pr;
edge.push_back(PP(vl+vr,P(i,pr)));
}
for (int i=m+1;i<=r;i++){
ll vl=A[pl]-D*(ll)pl;
ll vr=A[i]+D*(ll)i;
edge.push_back(PP(vl+vr,P(pl,i)));
}
solve(l,m);
solve(m+1,r);
}
int main(){
int n;
scanf ("%d%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);
ll ret=0;
for (int i=0;i<edge.size();i++){
P p=edge[i].second;
if (!uf.same(p.first,p.second)){
uf.unite(p.first,p.second);
ret+=edge[i].first;
}
}
printf("%lld",ret);
return 0;
}
|
#include<cstdio>
#include<algorithm>
#define Rint register int
using namespace std;
typedef long long LL;
const int N = 200003;
int n;
LL ans, d, a[N], f[N], g[N];
int main(){
scanf("%d%lld", &n, &d);
for(Rint i = 1;i <= n;i ++){
scanf("%lld", a + i);
ans += a[i];
}
f[1] = a[1];
for(Rint i = 2;i <= n;i ++) f[i] = min(f[i - 1] + d, a[i]);
g[n] = a[n];
for(Rint i = n - 1;i;i --) g[i] = min(g[i + 1] + d, a[i]);
for(Rint i = 2;i < n;i ++) ans += min(f[i], g[i]);
printf("%lld\n", ans + (n - 1) * d);
}
|
#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;
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>
using namespace std;
#define int long long
int n,val[200100],m,fa[200100],res;
struct node{
int x,y,z;
node(int u=0,int v=0,int w=0){x=u,y=v,z=w;}
friend bool operator<(const node&u,const node&v){return u.z<v.z;}
};
vector<node>v;
inline void read(int &x){
x=0;
char c=getchar();
while(c>'9'||c<'0')c=getchar();
while(c>='0'&&c<='9')x=(x<<3)+(x<<1)+(c^48),c=getchar();
}
inline void print(int x){
if(x<=9)putchar('0'+x);
else print(x/10),putchar('0'+x%10);
}
void solve(int l,int r){
if(l==r)return;
int mid=(l+r)>>1;
int ml=l,mr=r,mn;
mn=0x3f3f3f3f3f3f3f3f;
for(int i=l;i<=mid;i++)if(val[i]-i*m<mn)mn=val[i]-i*m,ml=i;
mn=0x3f3f3f3f3f3f3f3f;
for(int i=r;i>mid;i--)if(val[i]+i*m<mn)mn=val[i]+i*m,mr=i;
for(int i=l;i<=mid;i++)v.push_back(node(i,mr,val[i]+val[mr]+(mr-i)*m));
for(int i=r;i>mid;i--)v.push_back(node(ml,i,val[ml]+val[i]+(i-ml)*m));
solve(l,mid),solve(mid+1,r);
}
int find(int x){
return fa[x]==x?x:fa[x]=find(fa[x]);
}
bool merge(int x,int y){
x=find(x),y=find(y);
if(x==y)return false;
fa[x]=y;
return true;
}
signed main(){
read(n),read(m);
for(int i=1;i<=n;i++)read(val[i]),fa[i]=i;
solve(1,n),sort(v.begin(),v.end());
for(auto i:v){
if(n==1)break;
if(merge(i.x,i.y))n--,res+=i.z;
}
print(res);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long int gcd(long long int x,long long int y){
while((x%=y)&&(y%=x));
return x^y;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin>>T;
while(T--){
long long int A,B,C,D;
cin>>A>>B>>C>>D;
if(A<B||D<B){
cout<<"No\n";
continue;
}
long long int g = gcd(B,D);
A = A - (C-B+1);
long long int d = (A%g+g)%g;
A = C-B+1+d;
if(A<0)
cout<<"No\n";
else
cout<<"Yes\n";
}
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
return b ? gcd(b, a%b) : a;
}
int main() {
int T;
cin >> T;
for (int i = 0; i < T; i++) {
ll A, B, C, D;
cin >> A >> B >> C >> D;
if (B > A || B > D) {
cout << "No" << endl;
}
else if (B <= C) {
cout << "Yes" << endl;
}
else {
ll g = gcd(B, D);
if (B - g + A%g > C) cout << "No" << endl;
else cout << "Yes" << endl;
}
}
}
|
#include <iostream>
#include <algorithm>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int Q; long long A, B, C, D;
int main() {
cin >> Q;
while (Q--) {
cin >> A >> B >> C >> D;
long long G = gcd(B, D);
long long mn = A - (A - C - 1) / G * G - B;
cout << (A < B || B > D || mn < 0 ? "No" : "Yes") << '\n';
}
return 0;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
template<typename T>
T gcd(T a,T b)
{
if(a<b) swap(a,b);
T r = a % b;
while(r!=0)
{
a = b;
b = r;
r = a % b;
}
return b;
}
int main()
{
int T;
cin >> T;
unsigned long int A,B,C,D;
for(int i=0;i<T;i++)
{
scanf("%ld%ld%ld%ld",&A,&B,&C,&D);
if(A<B || D<B || C<A%B || C<B-gcd(B,D)) puts("No");
else puts("Yes");
}
return 0;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
template<typename T>
T gcd(T x,T y){return y?gcd(y,x%y):x;}
int main()
{
int T; scanf("%d",&T);
unsigned long int A,B,C,D;
for(;0<T;T--)
{
scanf("%ld%ld%ld%ld",&A,&B,&C,&D);
if(A<B||D<B||C<A%B||C<B-gcd(B,D)) puts("No");
else puts("Yes");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int t;
ll a,b,c,d;
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
int main(){
cin>>t;
while(t--){
cin>>a>>b>>c>>d;
if(a<b || b>d){
printf("No\n");continue;
}
if(((a%b+((b-1-a%b)/gcd(b,d))*gcd(b,d))>c)) printf("No\n");
else printf("Yes\n");
}
return 0;
}
|
#include <iostream>
#define llint long long
using namespace std;
llint T;
llint gcd(llint a, llint b)
{
if(b == 0) return a;
return gcd(b, a%b);
}
int main(void)
{
cin >> T;
llint a, b, c, d;
llint g, i, mx;
for(int t = 0; t < T; t++){
cin >> a >> b >> c >> d;
if(a < b) goto ng;
if(d < b) goto ng;
g = gcd(b, d);
i = a % b;
mx = ((b-1)-i)/g*g + i;
if(mx > c) goto ng;
else goto ok;
ok:
cout << "Yes" << endl;
continue;
ng:
cout << "No" << endl;
continue;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
return b ? gcd(b, a % b) : a;
}
bool solve() {
ll A, B, C, D; cin >> A >> B >> C >> D;
if (A < B) return false;
if (B > D) return false;
if (B <= C+1) return true;
ll G = gcd(B, D);
ll AM = A % G;
ll ma = B - G + AM;
return ma <= C;
}
int main() {
int Q; cin >> Q;
while (Q--) {
if (solve()) cout << "Yes" << endl;
else cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if(b == 0) return a;
else return gcd(b, a%b);
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if(a < b) puts("No");
else if(d < b) puts("No");
else {
long long v = c - b + 1;
long long x = a;
x %= gcd(b, d);
x -= gcd(b, d);
if(v <= x && x < 0) puts("No");
else puts("Yes");
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
long long t,a,b,c,d;
long long gcd(long long x,long long y){return !y?x:gcd(y,x%y);}
int main()
{
cin>>t;
while(t--)
{
cin>>a>>b>>c>>d;
if(a<b||d<b){puts("No");continue;}
if(c>=b-1){puts("Yes");continue;}
long long g=gcd(d,b);
if(b-c-1>=g){puts("No");continue;}
puts(((c-a+1)%g+g)%g>((b-a-1)%g+g)%g||(c-a+1)%g==0?"No":"Yes");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.