#pragma GCC optimize(2)

#include<bits/stdc++.h>
#define forup(i,s,e) for(int i=(s),E123123123=(e);i<=E123123123;++i)
#define fordown(i,s,e) for(int i=(s),E123123123=(e);i>=E123123123;--i)
#define mem(a,b) memset(a,b,sizeof(a))
#ifdef DEBUG
#define msg(args...) fprintf(stderr,args)
#else
#define msg(...) void();
#endif
using namespace std;
using i64=long long;
using i128=__int128;
using pii=pair<int,i64>;
#define fi first
#define se second
#define mkp make_pair
#define gc getchar()
int read(){
    int x=0,f=1;char c;
    while(!isdigit(c=gc)) if(c=='-') f=-1;
    while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc;}
    return x*f;
}
#undef gc
const int N=2e5+5,B=650,T=310;
i64 inf=1e18;
int n,m,a[N];
i64 sum[N];
int L[T],R[T],blg[N];
deque<pii> conv[T];
i128 cross(pii a,pii b){
    return a.fi*b.se-a.se*b.fi;
}
pii operator -(const pii a,const pii b){
    return mkp(a.fi-b.fi,a.se-b.se);
}
bool slp(pii a,pii b,pii c){
    return cross(b-a,c-b)<=0;
}
bool slp(pii a,pii b,i64 k){
    return (b.se-a.se)<=(i128)(b.fi-a.fi)*k;
}
i64 dp[N];
int mex[N],tag[T];
i64 mxv[T][N];
void work(int pl,int pr,int ql,int qr,int b){
    if(ql>qr) return;
    if(pl==pr){
        forup(i,ql,qr){
            mxv[b][i]=-sum[pl]*i+dp[pl];
        }
        return;
    }
    int mid=(ql+qr)>>1,p=0;
    i64 val=-inf;
    forup(i,pl,pr){
        if(-sum[i]*mid+dp[i]>val){
            p=i;
            val=-sum[i]*mid+dp[i];
        }
    }
    mxv[b][mid]=val;
    work(pl,p,mid+1,qr,b);work(p,pr,ql,mid-1,b);
}
void getconv(int j){
    if(~tag[j]){
        forup(k,L[j],R[j]){
            mex[k]=tag[j];
        }
        tag[j]=-1;
    }
    deque<pii> &q=conv[j];
    q.clear();
    vector<pii> vv;
    fordown(k,R[j],L[j]){
        pii nw;
        nw.fi=mex[k];nw.se=mex[k]*sum[k]-dp[k];
        vv.push_back(nw);
    }
    sort(vv.begin(),vv.end(),[&](pii a,pii b){if(a.fi!=b.fi)return a.fi<b.fi;return a.se<b.se;});
    for(auto i:vv){
        if(q.size()&&i.fi==q.back().fi) continue;
        while(q.size()>2&&slp(q[q.size()-2],q[q.size()-1],i)) q.pop_back();
        q.push_back(i);
    }
}
int tt[N],m0,lst[N],pp[N];
vector<pair<pii,int> > modi[N];
map<pii,int> odt;
using mit=map<pii,int>::iterator;
mit split(int x){
    mit it=odt.lower_bound(mkp(x,0));
    if(it->fi.fi==x) return it;
    --it;
    int l=it->fi.fi,r=it->fi.se,c=it->se;
    odt.erase(it);
    odt.insert(mkp(mkp(l,x-1),c));
    return odt.insert(mkp(mkp(x,r),c)).fi;
}
signed main(){
    n=read();m=read();
    forup(i,1,n){
        a[i]=read();
        sum[i]=sum[i-1]+a[i];
        pp[i]=lst[a[i]];
        lst[a[i]]=i;
    }
    int t=n/B;
    forup(i,1,t){
        L[i]=R[i-1]+1;R[i]=i*B;
        forup(j,L[i],R[i]) blg[j]=i;
    }
    if(R[t]!=n){
        ++t;
        L[t]=R[t-1]+1;R[t]=n;
        forup(j,L[t],R[t]) blg[j]=t;
    }
    forup(i,1,t) tag[i]=-1;
    fordown(i,n,0){
        mex[i]=mex[i+1];
        while(tt[mex[i]]) ++mex[i];
        ++tt[a[i]];
    }
    forup(i,0,n) tt[i]=0;
    int lpos=0;
    forup(i,1,n){
        if(mex[i]!=mex[i-1]){
            odt.insert(mkp(mkp(lpos,i-1),mex[i-1]));
            lpos=i;
        }
    }
    // forup(i,0,n){
    //     msg("%d ",mex[i]);
    // }msg("|\n");
    odt.insert(mkp(mkp(lpos,n),mex[n]));
    fordown(i,n,1){
        mit st=split(pp[i]);
        int r=pp[i]-1;
        for(mit it=st;it!=odt.end()&&it->se>=a[i];odt.erase(prev(++it))){
            modi[i].push_back(*it);
            r=it->fi.se;
        }
        if(r>=pp[i])odt.insert(mkp(mkp(pp[i],r),a[i]));
        mex[i]=0;
    }
    mex[0]=0;
    forup(i,1,n){
        ++tt[a[i]];
        while(tt[m0]) ++m0;
        dp[i]=0;
        if(i<=m){
            dp[i]=max(dp[i],m0*sum[i]);
        }
        vector<int> sv;
        for(auto j:modi[i]){
            int l=j.fi.fi,r=j.fi.se,c=j.se;
            if(r==0) continue;
            if(l==0) l=1;
            if(blg[r]==blg[l]){
                if(~tag[blg[l]]){
                    int p=blg[l];
                    forup(k,L[p],R[p]) mex[k]=tag[p];
                    tag[p]=-1;
                }
                forup(k,l,r){
                    mex[k]=c;
                }
                sv.push_back(blg[l]);
            }else{
                if(~tag[blg[l]]){
                    int p=blg[l];
                    forup(k,L[p],R[p]) mex[k]=tag[p];
                    tag[p]=-1;
                }
                if(~tag[blg[r]]){
                    int p=blg[r];
                    forup(k,L[p],R[p]) mex[k]=tag[p];
                    tag[p]=-1;
                }
                forup(k,l,R[blg[l]]) mex[k]=c;
                forup(k,L[blg[r]],r) mex[k]=c;
                sv.push_back(blg[l]);sv.push_back(blg[r]);
                forup(j,blg[l]+1,blg[r]-1) tag[j]=c;
            }
        }
        // forup(j,1,n){
        //     int mm=mex[j];
        //     if(~tag[blg[j]]) mm=tag[blg[j]];
        //     msg("%d ",mm);
        // }msg("|");
        fordown(j,i-1,max(L[blg[i]],i-m)){
            int mm=mex[j];
            if(~tag[blg[j]]) mm=tag[blg[j]];
            dp[i]=max(dp[i],dp[j]+mm*(sum[i]-sum[j]));
        }
        sort(sv.begin(),sv.end());
        sv.erase(unique(sv.begin(),sv.end()),sv.end());
        for(auto j:sv){
            getconv(j);
        }
        if(i-m>=1&&blg[i]!=blg[i-m]){
            fordown(j,blg[i]-1,blg[i-m]+1){
                if(~tag[j]){
                    dp[i]=max(dp[i],tag[j]*sum[i]+mxv[j][tag[j]]);
                    // msg("[%d]A %d %d %d %lld|%lld\n",i,L[j],R[j],tag[j],mxv[j][tag[j]],tag[j]*sum[i]+mxv[j][tag[j]]);
                }else{
                    while(conv[j].size()>=2&&slp(conv[j][0],conv[j][1],sum[i])) conv[j].pop_front();
                    dp[i]=max(dp[i],conv[j].front().fi*sum[i]-conv[j].front().se);
                    // if(i==10){
                    //     for(auto k:conv[j]){
                    //         msg("(%d,%d,%lld)",k.fi,k.se,k.fi*sum[i]-k.se);
                    //     }
                    // }
                    // msg("[%d]B %d %d %d %lld|%lld(%d)\n",i,L[j],R[j],conv[j].front().fi,-conv[j].front().se,conv[j].front().fi*sum[i]-conv[j].front().se,(int)conv[j].size());
                }
            }
            fordown(j,R[blg[i-m]],i-m){
                int mm=mex[j];
                if(~tag[blg[j]]) mm=tag[blg[j]];
                dp[i]=max(dp[i],dp[j]+mm*(sum[i]-sum[j]));
            }
        }
        if(i==R[blg[i]]){
            work(L[blg[i]],R[blg[i]],0,n,blg[i]);
            getconv(blg[i]);
        }
        // msg("{%d %lld}\n",i,dp[i]);
    }
    // msg("|\n");
    printf("%lld\n",dp[n]);
}
/*
13 7
6 9 0 12 6 1 9 0 3 4 6 9 12 

*/