2024年6月杂题乱写

6.5

P3214 [HNOI2011] 卡农

设 $f_i$ 表示选了 $m$ 个集合的答案，简单观察发现，只要确定了 $m-1$ 个集合，最后一个集合就是确定的，不是偶数次数的出现，偶数次数的不出现，选 $m$ 个集合有 $C_{2^n-1}^{m-1}$ 种方案，考虑下面两种不合法的情况。

• 这 $m-1$ 个集合已经合法，最后一个集合为空集。
• 最后要选的集合在前面 $m-1$ 个集合出现过。

答案就是总数减去这两种情况，第一种情况显然为 $f_{i-1}$，第二种情况其实就是有 $i-2$ 个集合已经合法了，数量为 $f_{i-2}$，但是因为最后的一个集合（相同的两个）不确定，所以第二种情况实际上有 $f_{i-2}\cdot [2^n-1-(i-2)]$，直接减去就可以，这时因为我们每一种都算了 $m$ 遍，所以答案要除以 $m$。

$$f_i=\frac{C_{2^n-1}^{i-1}-f_{i-1}-f_{i-2}\cdot (2^n-i+1)}{i}$$

直接递推即可。

点击查看代码

#include<bits/stdc++.h>
#define int long long
inline int read(){
	char ch=getchar();int x=0,f=1;
	for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
	for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);
	return x*f;
}
const int N=1e6+10,mod=1e8+7;
inline int mo(int x){return x<0?(x%mod+mod)%mod:(x>=mod?x%mod:x);}
inline int qpow(int a,int b){
	int res=1;
	for(;b;b>>=1,a=mo(a*a))if(b&1)res=mo(res*a);
	return res;
}
int n,m,sum,inv[N],C,f[N];
signed main(){
	// freopen("in.in","r",stdin),freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0),std::cout.tie(0);
	n=read(),m=read();sum=mo(qpow(2,n)-1);
	if(m>sum){std::cout<<0<<'\n';exit(0);}
	inv[1]=1,f[1]=f[2]=0;f[0]=1;
	for(int i=2;i<=m;++i)inv[i]=mo((mod-mod/i)*inv[mod%i]);
	C=mo(mo(sum*(sum-1))*inv[2]);
	for(int i=3;i<=m;++i){
		f[i]=mo(mo((C-f[i-1]-mo(f[i-2]*mo(sum-i+2))))*inv[i]);
		C=mo(mo(C*(sum-i+1))*inv[i]);
	}
	std::cout<<f[m]<<'\n';
}

6.9

困困困，头疼疼疼疼疼，给大家来场 ABC 速通。

• A 直接扫
• B 直接扫
• C 递归周围，然后中间填白色
• D 设 $len$ 为数字 $n$ 十进制下的长度，$V_n=n\cdot \sum _{i=0}^{n-1}{10}^{i\cdot len}$，后面直接等比数列求和 $ans=n\cdot \frac{{10}^{n\cdot len}-1}{{10}^{len}-1}$。
• E 就是求有向图每个点能到达的点（包括自己）的和，反向建边后直接缩点拓扑排序跑 DP 即可。
• F 一眼线段树，赛时傻逼没推下式子锅了，$(a+x)\cdot (b+y)=ab+xb+ya+xy$，记两个 tag 即可。
• G 高级东西，不会。

6.15 ABC358 速通

D 直接二分找，然后删。
E 就是求多重集排列数，直接设 $f_{i,j}$ 表示考虑前 $i$ 个字母，长度为 $j$ 时的方案数，枚举新加入多少个元素，有 $f_{i,j}=\sum _{k=max(0,j-c_i)}^j{f}_{i-1,j}\cdot C_j^k$，最后 $ans=\sum _{i=1}^n{f}_{26,i}$
F 随便找，然后比较傻逼，没意思。
G 直接设状态 $f_{t,i,j}$ 表示 $t$ 时刻在 $(i,j)$ 的最大价值，转移就直接从 $5$ 个位置转移，发现 $k$ 很大，但是当 $k\ge nm$ 时就没啥意义了，因为此时的最优解一定不会再从其他点转移了，所以考虑 $k\le nm$ 时的答案，最后加上剩下的次数乘上价值找最大就行。

6.17

感觉这种博客还是要写下去，

CF1808D Petya, Petya, Petr, and Palindromes

比较水的题。首先直接不太好想，正难则反，考虑将所有不需要改变的点对处理出来，拿总数一减就是答案。
发现合法数就是两个位置的数相同，所以就变成了，对于每一个数，查询指定区间内与它相等的数的个数。
因为需要满足回文的对称性，所以偶数位置只会和偶数位置匹配，奇数位置只会和奇数位置匹配，此时其实可以直接无脑上数据结构了，时间复杂度 $\mathcal{O}(n\log n)$。
不考虑数据结构，这里有两种处理方法。

• 开个桶记录一下每个数的出现次数，类似莫队的思想，两个指针记录一下桶的范围，每次查到 $a_i$ 时，求出与 $a_i$ 的对应位置范围，然后移动指针，如果位置 $j$ 与 $i$ 奇偶性相同，就产生 $1$ 的贡献，奇数偶数各查一次。
• 开桶记录每个数出现的奇数位置和偶数位置，对于每个数，双指针不断向右扩展，直到不合法时记录一下两个指针之间的数的个数，也是奇数偶数都查一次。

这两种做法的时间复杂度都是 $\mathcal{O}(n)$，做法一因为区间单调，所以保证了复杂度，做法二显然是线性，这里给出做法一的代码。

#include<bits/stdc++.h>
#define int long long
typedef long long ll;
typedef unsigned long long ull;
inline int read(){char ch=getchar();int x=0,f=1;for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);return x*f;}
const int N=2e5+10;
int a[N],n,k,q[N],mid,l1,r1,ans;
inline void work(int pd){
	l1=1,r1=0;
	memset(q,0,sizeof(q));
	for(int i=mid+2+pd;i<=n;i+=2){
		int L=std::max(1ll,i-k+1),R=std::min(n,i+mid-1);
		int l=(L+L+k-1)-i,r=(R+(R-k+1))-i;
		while(r1<r){if((r1&1)!=(i&1))q[a[++r1]]++;else ++r1;}
		while(r1>r){if((r1&1)==(i&1))q[a[r1--]]--;else --r1;}
		while(l1<l){if((l1&1)==(i&1))q[a[l1++]]--;else ++l1;}
		while(l1>l){if((l1&1)!=(i&1))q[a[--l1]]++;else --l1;}
		ans+=q[a[i]];
	}
}
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
	n=read();k=read();
	for(int i=1;i<=n;++i)a[i]=read();
	mid=k/2;int pd=mid&1;
	work(pd),work(pd^1);
	std::cout<<(n-k+1)*(k/2)-ans<<'\n';
}

CF1526D Kill Anton

感觉是比较神的构造，直接构造答案，比较困难，思考 $b$ 串到 $a$ 的最大代价，因为交换相邻的元素，可以想到逆序对，给序列 $a$ 依次标号，这样由 $b$ 到 $a$ 的交换次数就是 $b$ 的逆序对数量。题目就转化为了求逆序对数量最多的 $b$ 串，但是同种字母之间是没有区别的，所以在最优策略下，同种字母直接是不会进行交换的，不属于逆序对，所以不能简单的将 $a$ 串翻转。
有引理：一定存在所有同类字母相邻的最优答案。
感性理解：因为字母之间只会不同类交换，所以考虑把不同类的字母尽量放前面，同类在一起。
证明：

• 在最优策略下，同类字母不会发生交换，所以对于任意排列，同类字母之间的标号都是递增的。
• 对于同类字母 $a_i$ 与 $a_j$ 之间的所有相邻异类字母 $a_k$ 到 $a_q$ 来说，如果 $a_k$ 这种字母中 $w$ 个字母与前面的 $a_i$ 这种字母共构成了 $v_1$ 个逆序对，$s$ 个与后面的 $a_i$ 这种字母共构成了 $v_2$ 个逆序对，有 $v_1\le (k-i)\times w,v_2\le (j-q)\times s$。如果将所有的 $a_k$ 交换到前面，此时新增了 $[(k-i)\times s-v_1]$ 个逆序对，如果将他们交换到后面，此时新增了 $[(j-q)\times w-v_2]$ 个逆序对。
• 当 $(k-i)\times s-v_1\le 0$，即 $(k-i)\times s\le (k-i)\times w$ 时，有 $s\le w$，则 $v_2\le (j-q)\times s\le (j-q)\times w$，即 $(j-q)\times w-v_2\ge 0$。同理，如果 $(j-q)\times w-v_2\le 0$，则 $(k-i)\times s-v_1\ge 0$。
• 所以对于任何一种情况，我们总能使得同类字母相邻且逆序对数量单调不减，即一定存在所有同类字母相邻的最优答案。

由于不确定字母之间的顺序，我们可以直接枚举排列，然后每次用树状数组查询逆序对数量（当然也可以 $\mathcal{O}(n)$ 直接计算交换次数），取最大即可，时间复杂度 $\mathcal{O}(24n\log n)$。

#include<bits/stdc++.h>
#define int long long
typedef long long ll;
typedef unsigned long long ull;
inline int read(){char ch=getchar();int x=0,f=1;for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);return x*f;}
const int N=1e5+10;
int n,a[N],ans[N],_ans,t[N];
char s[N];
bool vis[N];
std::vector<int> v[5];
inline void add(int x){
	for(;x<=n;x+=x&-x)t[x]+=1;
}
inline int query(int x){
	int res=0;
	for(int i=n;i;i-=i&-i)res+=t[i];
	for(int i=x;i;i-=i&-i)res-=t[i];
	return res;
}
inline void solve(){
	for(int i=1;i<=n;++i)t[i]=0;
	int res=0;
	for(int i=1;i<=4;++i){
		for(int x:v[a[i]]){
			res+=query(x);
			add(x);
		}
	}
	if(_ans<=res){
		for(int i=1;i<=4;++i)ans[i]=a[i];
		_ans=res;
	}
}
inline void dfs(int len,int x){
	if(len)a[len]=x;
	if(len==4){
		solve();
		return;
	}
	for(int i=1;i<=4;++i){
		if(!vis[i]){
			vis[i]=1;
			dfs(len+1,i);
			vis[i]=0;
		}
	}
}
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
	int t;std::cin>>t;
	while(t--){
		_ans=0;
		for(int i=1;i<=4;++i)v[i].clear();
		std::cin>>s+1;
		n=strlen(s+1);
		for(int i=1;i<=n;++i){
			if(s[i]=='A')v[1].push_back(i);
			if(s[i]=='N')v[2].push_back(i);
			if(s[i]=='T')v[3].push_back(i);
			if(s[i]=='O')v[4].push_back(i);
		}
		dfs(0,0);
		for(int i=1;i<=4;++i){
			for(int j=1;j<=v[ans[i]].size();++j){
				if(ans[i]==1)std::cout<<'A';
				if(ans[i]==2)std::cout<<'N';
				if(ans[i]==3)std::cout<<'T';
				if(ans[i]==4)std::cout<<'O';
			}
		}
		std::cout<<'\n';
	}
}

6.19

CF1978D Elections

感觉 C 比 D 难，为啥这场能掉分，为啥 C 对不出脑电波，感觉赛时死磕很不好。
有一点比较显然，如果一个人不能直接获胜的话，那么他前面的人都应该被撤下，这样才会改变这个人的票数，才有可能使他获胜。
接下来有两种情况：

• 撤完前面的人后，他的票数大于等于剩下的人的最多票数的话，那么此时直接获胜。
• 撤完前面的人后，他的票数小于剩下的人的最多票数的话，此时再把票数最多的人撤下，这样他就成了票数最多的人，获胜。

直接做前缀和和后缀最大值就行，时间复杂度 $\mathcal{O}(n)$，注意开 long long。

#include<bits/stdc++.h>
#define int long long 
typedef long long ll;
typedef unsigned long long ull;
inline int read(){char ch=getchar();int x=0,f=1;for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);return x*f;}
const int N=2e5+10;
int a[N],sum[N],max[N];
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
	int T=read();
	while(T--){
		int n=read(),c=read();
		for(int i=1;i<=n;++i)a[i]=read();a[1]+=c;
		for(int i=1;i<=n;++i)sum[i]=sum[i-1]+a[i];
		max[n+1]=0;
		for(int i=n;i;--i)max[i]=std::max(a[i],max[i+1]);
		int st=0;
		for(int i=1;i<=n;++i){
			if(a[i]==max[1]&&st<max[1]){std::cout<<0<<' ';}
			else{
				int ans=i-1;
				if(sum[i]<max[i+1]){ans++;}
				std::cout<<ans<<' ';
			}
			st=std::max(st,a[i]);
		}
		std::cout<<'\n';
	}	
}

6.20

CF1736D Equal Binary Subsequences

感觉是对脑电波题，能对上黄，对不上紫。
首先对于 $1$ 和 $0$ 的个数是奇数的话一定不合法，特判掉即可。
经过一些数据的模拟，我们好像并不能找出完全不合法的情况，这时可以大胆猜测如果数量不是奇数的话一定有解。
考虑什么样的序列一定是合法的，不难发现，两位两位的进行分组，每组都一样的序列一定是合法的，如 1111001100 或 0000111100，对于答案 $p$，直接选奇数位就可以。
事实上，对于任意一个可能合法的序列，都能构造出一种方案，使得他与上面序列同构。
具体来说，我们扫描每一组，如果这两个数不一样，选出一个和上一个选择不一样的那一位（如果上次没选过就随便选），扫描完毕后，将选出的子序列右移一位。此时每组的两个数都相同，合法。
考虑为什么第一组的数也一定相同：因为 $1$ 和 $0$ 的个数为偶数，所以选出来的数一定有偶数个 $0$ 和 $1$，并且他们是交错的，所以右移之后一定能使每一组的数都相同。

#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
inline int read(){char ch=getchar();int x=0,f=1;for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);return x*f;}
const int N=2e5+10;
char s[N];
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
	int T;std::cin>>T;
	while(T--){
		int n;std::cin>>n;n*=2;
		std::cin>>s+1;
		std::vector<int> v;
		int _1=0,_0=0;
		for(int i=1;i<=n;++i)_1+=s[i]=='1',_0+=s[i]=='0';
		for(int i=1;i<=n;i+=2){
			int x=i,y=i+1;
			if(s[x]!=s[y]){
				if(v.size()){
					if(s[x]!=s[v[v.size()-1]])v.push_back(x);
					else v.push_back(y);
				}
				else v.push_back(x);
			}
		}
		if(_1&1){std::cout<<-1<<'\n';continue;}
		std::cout<<v.size()<<' ';
		for(int x:v)std::cout<<x<<' ';
		std::cout<<'\n';
		for(int i=1;i<=n;i+=2)std::cout<<i<<' ';std::cout<<'\n';
	}
}

这题真的从头到尾都想假了，如果想的总有hack，及时换思路。

6.21

P9510 『STA - R3』高维立方体

更多关于斐波那契数列的知识
设 $f_i$ 表示斐波那契数列的第 $i$ 项。

引理一：$\sum _{i=1}^n{f}_i^2=f_n{f}_{n+1}$
证明：显然 $\sum _{i=1}^n{f}_i^2=f_n{f}_{n+1}$ 对于 $n=3$ 成立，假设该引理对于 $n=k$ 成立，对于 $n=k+1$，有

$$\begin{array}{rl}\sum _{i=1}^{k+1}{f}_i^2& =\sum _{i=1}^k{f}_i^2+f_{k+1}^2\\ & =f_k{f}_{k+1}+f_{k+1}^2\\ & =f_{k+1}{f}_{k+2}\end{array}$$

即 $\sum _{i=1}^n{f}_i^2=f_n{f}_{n+1}$，证毕。

简单整理下所求式子，得 $\sum _{i=1}^n(f_i{f}_{i-1}{f}_{i-2}+f_i^3)+f_n{f}_{n+1}$
对于 $\sum _{i=1}^n{f}_i{f}_{i-1}{f}_{i-2}$，有

$$\begin{array}{rl}\sum _{i=1}^n{f}_i{f}_{i-1}{f}_{i-2}& =\sum _{i=1}^n{f}_i{f}_{i-1}(f_i-f_{i-1})\\ & =\sum _{i=1}^n{f}_i^2{f}_{i-1}-f_i{f}_{i-1}^2\\ & =f_n^2{f}_{n-1}-f_n{f}_{n-1}^2+f_{n-1}^2{f}_{n-2}-f_{n-1}{f}_{n-2}^2+\cdots +f_1^2{f}_0-f_1{f}_0^2\\ & =f_n^2{f}_{n-1}-(f_{n-1}+f_{n-2})f_{n-1}^2+f_{n-1}^2{f}_{n-2}-(f_{n-2}+f_{n-3})f_{n-2}^2+\cdots +0-0\\ & =f_n^2{f}_{n-1}-f_{n-1}^3-f_{n-2}^3-\cdots -0\\ & =f_n^2{f}_{n-1}-\sum _{i=1}^{n-1}{f}_i^3\end{array}$$

故答案可以整理为

$$\begin{array}{rl}\sum _{i=1}^n(f_i{f}_{i-1}{f}_{i-2}+f_i^3)+f_n{f}_{n+1}& =f_n^2{f}_{n-1}-\sum _{i=1}^{n-1}{f}_i^3+\sum _{i=1}^n{f}_i^3+f_n{f}_{n+1}\\ & =f_n^2{f}_{n-1}+f_n^3+f_n{f}_{n+1}\\ & =f_n^2{f}_{n+1}+f_n{f}_{n+1}\end{array}$$

直接矩阵快速幂即可。
另外，这题也可以数形结合，用立方体的体积表示乘积，发现所有的 $f_i{f}_{i-1}{f}_{i-2}$ 和 $f_i^3$ 可以互补成一个长宽高为 $f_{n+1},f_n,f_n$ 的立方体，同样可以得出答案。

#include<bits/stdc++.h>
#define int long long
#define ll long long
#define int long long
int mod;
using namespace std;
inline int read(){
    int x=0,f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<1)+(x<<3)+(ch^48);
    return x*f;
}
inline int mo(int x){return x>=1e9?x%mod:x;}
struct mt{
    ll a[2][2];
    mt(){memset(a,0,sizeof a);}
    mt operator*(const mt&b)const{
        mt res;
        for(int i=0;i<=1;++i)
        	for(int k=0;k<=1;++k){
        		int zc=a[i][k];
            	for(int j=0;j<=1;++j)
                	res.a[i][j]=mo(res.a[i][j]+zc*b.a[k][j]);
        	}
        return res;
    }
}ans,base;
inline int qpow(int b){
	b--;
    ans.a[0][0]=0,ans.a[0][1]=1;
    base.a[0][1]=base.a[1][0]=base.a[1][1]=1;
    base.a[0][0]=0;
    while(b){
        if(b&1)ans=ans*base;
        base=base*base;b>>=1;
    }
    return ans.a[0][1];
}
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	int T=read();
	while(T--){
		int n=read();mod=read();
		int a=qpow(n),b=ans.a[0][0]+a;
		std::cout<<(a*a%mod*b%mod+b*a%mod)%mod<<'\n';
	}
}

6.23

AT_abc359_d [ABC359D] Avoid K Palindrome

看到 $k\le 10$，考虑状压，字母 A 代表 $0$，字母 B 代表 $1$，? 都可以代表，设 $f_{i,s}$ 表示到达第 $i$ 个位置，最后 $k$ 个字母的状态为 $s$ 时的方案数。
显然有转移方程 $f_{i,s}=f_{i-1,(s>>1)+(1<<(k-1))}+f_{i-1,s>>1}$，继承了前 $k-1$ 位的状态，check 一下状态 $s$ 是否合法即可。

#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
inline int read(){char ch=getchar();int x=0,f=1;for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);return x*f;}
const int N=2e3+50,mod=998244353;
char st[N];
int n,k,f[N][N];
bool vis[N];
inline int mo(int x){return x<0?(x%mod+mod)%mod:(x>=mod?x%mod:x);}
inline bool check(int l,int r,int s){
	int x=s;
	for(int i=r;i>=l;--i){
		int zc=s&1;s>>=1;
		if(st[i]=='?')continue;
		if(st[i]-'A'!=zc)return false;
	}
	return (!vis[x]);
}
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
	std::cin>>n>>k>>(st+1);
	if(k==1){std::cout<<0<<'\n';exit(0);}
	vis[0]=1;
	for(int i=0;i<(1<<k)-1;++i){
		int a[11],b[11];
		for(int i=1;i<=k;++i)a[i]=b[i]=0;
		int len=0,x=i;
		while(x)len++,a[len]=b[len]=(x&1),x>>=1;
		len=k;
		std::reverse(b+1,b+len+1);
		int tot=0;
		for(int j=1;j<=len;++j)tot+=a[j]==b[j];
		if(tot==len)vis[i]=1;
		f[k][i]=check(1,k,i);
	}
	int ans=0;
	for(int i=k+1;i<=n;++i)
		for(int s=0;s<(1<<k)-1;++s)
			if(check(i-k+1,i,s)){
				int x=s>>1;
				f[i][s]=mo(f[i][s]+f[i-1][x+(1<<k-1)]+f[i-1][x]);
			}
	for(int s=0;s<(1<<k)-1;++s)ans=mo(ans+f[n][s]);
	std::cout<<ans<<'\n';
}

AT_abc359_e [ABC359E] Water Tank

如果一个水桶即将有水，那么之前的所有低于他的桶一定都装满了水，否则水不会过来。
所以需要维护一个高度单调递减的栈就行，就是单调栈板子题，时间复杂度 $\mathcal{O}(n)$。

#include<bits/stdc++.h>
#define int long long
typedef long long ll;
typedef unsigned long long ull;
inline int read(){char ch=getchar();int x=0,f=1;for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);return x*f;}
const int N=2e5+10;
int n,h[N],f[N],head,tail,q[N];
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
	n=read();int ans=0;
	h[0]=2e18;
	for(int i=1;i<=n;++i){
		h[i]=read();
		int pos=0;
		while(head<=tail&&h[i]>h[q[tail]]){--tail;}
		pos=q[tail],q[++tail]=i;
		f[i]=f[pos]+(i-pos)*h[i];
		std::cout<<f[i]+1<<' ';
	}
}

AT_abc359_f [ABC359F] Tree Degree Optimization

对于任何一个度数合法的方案，它所对应的树一定是存在的，所以只需要考虑度数的分配即可。
为了保证连通，每个点至少有一个度，答案先记上这一点。然后剩下 $n-2$ 个度要分配，考虑动态维护给每个点再加上一个度的贡献，贪心每次分配给贡献最小的即可。

#include<bits/stdc++.h>
#define int long long
typedef long long ll;
typedef unsigned long long ull;
inline int read(){char ch=getchar();int x=0,f=1;for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);return x*f;}
const int N=2e5+10;
int n,a[N];
struct QQ
{
	int val,cnt,id;
	friend bool operator <(QQ a,QQ b){return a.val>b.val;} 
};
std::priority_queue<QQ> q;
signed main(){
	// freopen("in.in","r",stdin);freopen("out.out","w",stdout);
	std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
	n=read();int ans=0;
	for(int i=1;i<=n;++i){
		int x=read();
		ans+=x;
		q.push({x*3,1,x});
	}
	for(int i=1;i<=n-2;++i){
		auto it=q.top();q.pop();
		ans+=it.val;
		int x=it.cnt+1;
		q.push({it.id*(x*2+1),x,it.id});
	}
	std::cout<<ans<<'\n';
}