學了一個挺帥的 MerMaid
所以用一下
MerMaid 就是你們接下來會看到的好看小標題
但是實際上它是用來畫流程圖的……
考慮每次複製以後一定會貼上若干次（大於零，否則沒有意義），因此將複製貼上捆綁起來考慮，設複製後連續貼上了 \(m\) 次，則代價為 \(x+my\)，貢獻為讓編輯器內文字個數變為 \(m+1\) 倍
假設我們做了 \(k\) 次上述操作，第 \(i\) 次操作的貼上次數為 \(m_i\)，則
- 總貢獻為 \(\prod\limits^k_i(m_i+1)\)
- 總代價為 \(\sum\limits^k_i(x+m_iy)\)
根據題意，我們需要 \(\prod\limits^k_i(m_i+1)\gt n\)，在此基礎上總代價最小
轉化一下總代價的式子
當 \(k\) 不變時，\(kx\) 項不變，等價於求 \(\sum^k_im_i\) 的最小值
引理：最優答案中不存在 \(i,j\)，使得 \(m_i-m_j\gt 1\)
證明：設 \(m_i-m_j\gt 1\)，因為 \((m_i-1)(m_j+1)=m_im_j+m_i-m_j-1=m_i(m_j+1)\gt m_im_j\)，故其一定不是最優解
因此設最終答案中最小的數為 \(t\)，則最大的可能值一定為 \(t+1\)，如果我們欽定有 \(p\) 個 \(t\)，則題目中條件等價於 \(t^p\times (t+1)^{k-p}\gt n\)，可以列舉所有可能的 \(p\)，透過二分答案找到最小的 \(t\) 的可能值來計算貢獻
在外層列舉 \(k\) 即可，\(k\le log_2n\)，因此複雜度為列舉 \(k\) 套列舉 \(p\) 套二分答案套快速冪，\(\log^4n\)
記得開 int128
#include<bits/stdc++.h>
#define int __int128
using namespace std;
long long n,x,y;
int power(int a,int t){
int base=a,ans=1;
while(t){
if(t&1){
ans=ans*base;
}
base=base*base;
t>>=1;
}
return ans;
}
signed main(){
int res=0x7fffffffffffffff;
cin>>n>>x>>y;
for(int k=1;k<=n and clock()<=0.85*CLOCKS_PER_SEC;++k){
for(int i=0;i<=k;++i){
int l=2,r=ceil(pow(n,(double)1/k)*2),ans=-1;
while(l<=r){
int mid=(l+r)/2;
if(power(mid,i)*power(mid+1,k-i)>n){
ans=mid;
r=mid-1;
}
else l=mid+1;
}
if(ans==-1) continue;
res=min(res,(__int128)k*x+((__int128)(ans-1)*i+(__int128)ans*(k-i))*(__int128)y);
}
}
cout<<(long long)res;
}
暴力思路：可以處理出值域上每個值在原數列上的最大不出現長度 \(l_i\)（形式化地，\(l_i\) 為滿足存在 \(j\)，使得 \(\forall k\in[j,j+l_i-1],a_k\neq i\) 的最大值），然後對這個最大長度做字首 \(\max\)，這樣就可以二分答案了，修改 \(n\) 查詢 \(\log n\)
最佳化思路：對值域建線段樹，每個點 \(i\) 記錄 \(l_i\)，這樣查詢字首 \(\max\) 相當於查區間最值，不用重構 \(\max\) 陣列，然而並沒有什麼最佳化，修改 \(n\) 查詢 \(\log^2n\)
再次最佳化思路：由於單點修改隻影響相鄰的兩個區間的長度，因此考慮只改變這兩個區間的值
可以想到對每個值維護一個 set，記錄每個值的位置，方便查詢其前驅，後繼，然後算出距離後進行刪除，那麼我們就還需要一種資料結構來支援快速刪除，插入，查詢最大值
賽時卡這了，沒想到解法竟然是無腦上兩顆優先佇列
對值域上每個值開兩個優先佇列，一個表示現有的值，一個表示刪除的值
- 加入操作：直接放進現有值的優先佇列
- 刪除操作：直接放進刪除的值的優先佇列
- 查詢最大值操作：由於刪除佇列內的值一定是加入操作內的值的子集，因此如果當前現有值佇列的對首已經被刪除，則它也一定是刪除值佇列的對首，因此只需要判斷兩個佇列的對首是否相等即可
修改 \(\log n\) 查詢 \(\log^2n\)
#include<bits/stdc++.h>
using namespace std;
int n,q;
int a[500001];
int lstpos[500001];
namespace stree{
struct tree{
int maxn;
}t[500001*4];
#define tol (id*2)
#define tor (id*2+1)
#define mid(l,r) mid=((l)+(r))/2
void change(int id,int l,int r,int pos,int val){
if(l==r){
t[id].maxn=val;
return;
}
int mid(l,r);
if(pos<=mid) change(tol,l,mid,pos,val);
else change(tor,mid+1,r,pos,val);
t[id].maxn=max(t[tol].maxn,t[tor].maxn);
}
int ask(int id,int l,int r,int L,int R){
if(L<=l and r<=R){
return t[id].maxn;
}
int mid(l,r);
if(R<=mid) return ask(tol,l,mid,L,R);
else if(L>=mid+1) return ask(tor,mid+1,r,L,R);
return max(ask(tol,l,mid,L,mid),ask(tor,mid+1,r,mid+1,R));
}
}
set<int>pos[500001];
struct getmax_t{
priority_queue<int> add_t,del_t;
inline void add(int x){
add_t.push(x);
}
inline void del(int x){
del_t.push(x);
}
inline int max(){
while(del_t.empty()==false and del_t.top()==add_t.top()){
del_t.pop();
add_t.pop();
}
return add_t.top();
}
};
getmax_t maxn[500001];
inline void add(int _pos){
pos[a[_pos]].insert(_pos);
auto iter1=pos[a[_pos]].lower_bound(_pos);iter1--;
auto iter2=pos[a[_pos]].upper_bound(_pos);
maxn[a[_pos]].add(_pos-*iter1-1);
maxn[a[_pos]].add(*iter2-_pos-1);
stree::change(1,1,n+1,a[_pos]+1,maxn[a[_pos]].max());
}
inline void del(int _pos){
auto iter1=pos[a[_pos]].lower_bound(_pos);iter1--;
auto iter2=pos[a[_pos]].upper_bound(_pos);
maxn[a[_pos]].del(_pos-*iter1-1);
maxn[a[_pos]].del(*iter2-_pos-1);
pos[a[_pos]].erase(_pos);
}
int main(){
ios::sync_with_stdio(false);
cin>>n>>q;
for(int i=1;i<=n;++i){
cin>>a[i];
maxn[a[i]].add(i-lstpos[a[i]]-1);
pos[a[i]].insert(i);
lstpos[a[i]]=i;
}
for(int i=0;i<=n;++i){
pos[i].insert(0);
pos[i].insert(n+1);
maxn[i].add(n-lstpos[i]);
stree::change(1,1,n+1,i+1,maxn[i].max());
}
while(q--){
int opt,x;
cin>>opt>>x;
if(opt==1){
del(x);del(x+1);
swap(a[x],a[x+1]);
add(x);add(x+1);
}
else{
int l=0,r=n,ans=n+1;
while(l<=r){
int mid=(l+r)/2;
if(stree::ask(1,1,n+1,1,mid+1)>=x){
ans=mid;
r=mid-1;
}
else l=mid+1;
}
cout<<ans<<'\n';
}
}
}
這道題用一種比較好玩的方式考了並行排序
部分分解法是常數較大的奇偶排序（多執行緒冒泡（？））
#include<bits/stdc++.h>
using namespace std;
int n;
int main(){
cin>>n;
cout<<((n+1)/2)*2<<endl;
for(int i=1;i<=((n+1)/2);i++){
for(int j=1;j+1<=n;j+=2){
cout<<"CMPSWP R"<<j<<" R"<<j+1<<' ';
}
cout<<'\n';
for(int j=2;j+1<=n;j+=2){
cout<<"CMPSWP R"<<j<<" R"<<j+1<<' ';
}
cout<<'\n';
}
}
正解用的是比較優秀的雙調排序
關於雙調排序的學習推薦 這篇文章
這是什麼
