洛谷8月月赛I Div.2题解

Solution

A

高精度加法板子，注意$10^k$不需要使用普通的高精度乘方，可以直接求出。

B

较容易发现规律:

①当$a=0,b=0$时，显然输出$0$；
②当$a=0$时，我们只需要将$a$乘上一个巨大的值，将$b$除以一个巨大的值即可，代价为$q$；
③$b=0$同理；

④当$a\ne b$且$a,b\ne 0$时，我们需要这么操作:
(1)使用一次操作①($x=min(a,b)$)或操作②($x=\infty$)，使$a$与$b$中有一个数为$0$；
(2)此时情况即为前已讨论过的②或③。
可以发现，此时代价为$min(p,q)+q$，其中$min(p,q)$是将$a,b$中一个数改为$0$的代价。

⑤当$a=b$且$a,b\ne 0$时，我们可以：
(1)使用一次操作①($x=a$)，即可满足要求，代价为$p$；
(2)操作方法与④相同，代价为$min(p,q)+q$。
故此时代价为$min(p,min(p,q)+q)$。

综上所述，我们可以在$O(1)$时间复杂度内求出答案。

C

考虑，对于某一位有$x$个$0$，$y$个$1$，若$k$的该位上填$0$，则对答案的贡献为$y\times v_i$，否则贡献为$x\times v_i$，其中$v_i$表示第$i$位的位权。

于是，我们贪心地从高位扫到低位，尝试让该位等于$1$。如果可以填$1$就填$1$，否则填$0$。

但是，关注到，如果我们这么贪心地填，可能出现到后来无论怎么填，该值都会超过$m$的现象。于是，我们维护一个后缀和，表示从该位向后，所能得到的最小值。

for (int i=maxlen-1;i>=1;i--)  pre[i]=min(cnt[i][0],cnt[i][1])*v[i]+pre[i+1];

其中，$pr{e}_i$表示了后缀和 (suf) ，$cn{t}_i$表示第$i$个二进制位上0/1出现的次数，$v_i$表示第$i$位的位权。

求出了$pre$后我们能干什么？可以发现，我们对于每一位，心里都有数了。即，如果该位填了$1$，但是该位的贡献加上后面的最小值(即$pr{e}_{i+1}$)超过了$m$，那么该位就绝对不能填$1$。这样做的好处在于，不会出现后面无论如何都无法使${\sum }_{i=1}^{n}kxor{a}_i\le m$，即在贪心后后悔的现象。

时间复杂度$O(nlo{g}_{2}t+mlo{g}_{2}t)$，其中$t$表示$a$序列中的最大值。

D

考虑树形$dp$。

状态设计: $d{p}_{i,0}$表示，当$i$的父边大于$i$的权值时，以$i$为根的子树中各边的士兵数量之和的最大值；$d{p}_{i,1}$表示的唯一区别是，$i$的父边不大于$i$的权值。

考虑神仙状态转移。

设$a$节点的点权为$x$，$a$节点的孩子$son$点权为$y$。

①已选定$a->son$边的权值比$a$的点权大。
(1)若$x>y$，则$son$的最大贡献为$d{p}_{son,0}+m$，注意此时我们在$a->son$的边上放了$m$个士兵，可以使答案最大化且不与条件互斥。
(2)若$x\le y$，则$son$的最大贡献为$max(d{p}_{son,0}+m,d{p}_{son,1}+y)$；其中$d{p}_{son,0}+m$与$(1)$相同，$d{p}_{son,1}+y$的决策中，$a->son$的边权为$y$。

②已选定$a->son$边的权值不大于$a$的点权。
(1)若$x\le y$，则$son$的最大贡献为$d{p}_{son.1}+x$；
(2)若$x>y$，则$son$的最大贡献为$max(d{p}_{son,0}+x,d{p}_{son,1}+y)$。

于是，我们求出了，每个孩子节点对$a$的两种贡献(①②)。假设第一种贡献组成的序列为$A$，第二种贡献组成的序列为$B$，这两个序列的长度都是$pos$。我们假设要让$a$节点的$k$条子边的权值比$a$的权值大，相当于在$A$序列中选$k$个数，在$B$序列中选$pos-k$个数，并使我们选的数之和尽可能得大。

现在思考如何快速求得这个问题。

我们先假设选了$A$序列中的所有数，现在我们要把一些选的数改成$B$序列的数。可以发现，对于一次改动，对答案的贡献为$B_i-A_i$，现在我们要进行最多$pos-k$次改动，使得贡献与$A$序列中各数之和尽可能得大。

于是，我们只需要建立一个数组$C$，其中$C_i=B_i-A_i$，并在$C_i$中选择最多$pos-k$个数使得和尽可能得大，这个和就是贡献之和的最大值。显然，我们直接将$C$从大到小排序，选前$pos-k$个数即可；如果目前看到的这个数已经不大于$0$了，就直接跳出循环，否则累加。

于是，我们可以在$lo{g}_{2}n$的时间复杂度内进行状态转移。

总时间复杂度$O(nlo{g}_{2}n)$。

---

几个卡点:

①回溯时容易对当前的$A,B,C$数组产生变动，我们要先向下递归，然后再转移：

for (int i=head[now];i;i=e[i].next)
	{
		if (e[i].to!=fath)  dfs(e[i].to,now);
	}
for (int i=head[now];i;i=e[i].next)
{
	转移……
}

②边界条件: 叶节点$l$的状态，即$d{p}_{l,0}=-inf$，$d{p}_{l,1}=0$；之所以$d{p}_{l,0}=-inf$，是因为若$l$的父边比$l$的点权还要大，那么$l$节点的城主就会造反。

③若当前节点$rt$的点权为$m$，则$d{p}_{rt,0}$的值是$-inf$，这是因为不可能出现$rt$的点权小于$rt$的父边的情况。

Code

A

#include <bits/stdc++.h>
#define int long long
using namespace std;

int n,x,last=10000;
int a[10005];

signed main()
{
	cin>>n>>x;
	if (n==0)  cout<<x+1<<endl;
	else if (n==1)  cout<<10+x<<endl;
	else
	{
		a[last-n]=1;
		for (rg int i=last-n+1;i<=last;++i)  a[i]=0;
		
		a[last]+=x;
		for (int i=last;i>=1;i--)
		{
			a[i-1]+=(a[i]/10);
			a[i]=a[i]%10;
		}
		int flag=0;
		for (int i=1;i<=last;i++)
		{
			if (a[i])  flag=1;
			if (flag==1)  cout<<a[i];
		}
		cout<<endl;
	}
	return 0;
}

B

#include <bits/stdc++.h>
#define int long long
using namespace std;

int a,b,c,d;

signed main()
{
	cin>>a>>b>>c>>d;
	if (a==0&&b==0)  cout<<0<<endl;
	else if (a==0||b==0)  cout<<d<<endl;
	else if (a==b)  cout<<min(c,min(c,d)+d)<<endl;
	else cout<<min(c,d)+d<<endl;
	
	return 0;
}

C

#include <bits/stdc++.h>
#define int unsigned long long
#define rg register
using namespace std;
const int maxlen=51;

int n,q,m,x,pos=0,tot=0;
bool a[100005][65],ans[65];
int v[65],cnt[65][5],pre[65];

inline int read()
{
	int s=0,w=1;
	char ch=getchar();
	
	while (ch<'0'||ch>'9')
	{
		if (ch=='-')  w=-w;
		ch=getchar();
	}
	while (ch>='0'&&ch<='9')
	{
		s=(s<<1)+(s<<3)+(ch^'0');
		ch=getchar();
	}
	return s*w;
}

signed main()
{
	cin>>n;
	for (rg int i=1;i<=n;++i)
	{
		pos=maxlen+1;
		x=read();
		
		while (x)
		{
			a[i][--pos]=x%2;
			x/=2;
		}
	}
	v[maxlen]=1;
	for (rg int i=maxlen-1;i>=1;--i)  v[i]=v[i+1]*2;
	for (rg int i=1;i<=maxlen;++i)
	{
		for (rg int j=1;j<=n;++j)  cnt[i][0]+=a[j][i];
		cnt[i][1]=n-cnt[i][0];
	}
	pre[maxlen]=min(cnt[maxlen][0],cnt[maxlen][1]);
	for (rg int i=maxlen-1;i>=1;--i)  pre[i]=min(cnt[i][0],cnt[i][1])*v[i]+pre[i+1];
	
	cin>>q;
	while (q--)
	{
		m=read();
		int flag=1;
		for (rg int i=1;i<=maxlen;++i)
		{
			if (m>=v[i]*cnt[i][1]+pre[i+1])  ans[i]=1,m-=v[i]*cnt[i][1];
			else if (m>=v[i]*cnt[i][0]+pre[i+1])  ans[i]=0,m-=v[i]*cnt[i][0];
			else
			{
				flag=0;
				break;
			}
		}
		if (flag==0)
		{
			cout<<-1<<endl;
			continue;
		}
		tot=0;
		for (rg int i=maxlen;i>=1;--i)
		{
			tot+=v[i]*ans[i];
			pos*=2;
		}
		printf("%lld\n",tot);
	}
	return 0;
}

D

#include <bits/stdc++.h>
#define int long long
#define inf 2000000007
using namespace std;

int n,m,cnt=0;
int a[500005],head[500005],dp[500005][2],small[500005],big[500005];

struct edge
{
	int next;
	int to;
}e[1000005];

bool cmp(int x,int y)
{
	return x>y;
}

inline int up(int x,int y)
{
	if (x%y==0)  return x/y;
	else return (x/y)+1;
}

inline void add_edge(int u,int v)
{
	cnt++;
	e[cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}

inline void dfs(int now,int fath)
{
	int flag=1,pos=0,pos2=0,tot0=0,tot1=0,now0,now1;
	for (int i=head[now];i;i=e[i].next)
	{
		if (e[i].to!=fath)  dfs(e[i].to,now);
	}
	for (int i=head[now];i;i=e[i].next)
	{
		if (e[i].to!=fath)
		{
			flag=0;
			
			if (a[now]<=a[e[i].to])  small[++pos]=dp[e[i].to][1]+a[now];
			else small[++pos]=max(dp[e[i].to][0]+a[now],dp[e[i].to][1]+a[e[i].to]);
			
			if (a[now]!=m)
			{
				if (a[now]>a[e[i].to])  big[++pos2]=dp[e[i].to][0]+m;
				else big[++pos2]=max(dp[e[i].to][0]+m,dp[e[i].to][1]+a[e[i].to]);
			}
			else big[++pos2]=-inf;
			
			tot0+=small[pos];
			tot1+=small[pos];
		}
	}
	if (flag==1)
	{
		dp[now][0]=-inf,dp[now][1]=0;
		return;
	}
	if (now!=1)  now1=pos/2;
	else now1=up(pos,2ll)-1;
	now0=max(now1-1,0ll);
	for (int i=1;i<=pos;i++)  big[i]=big[i]-small[i];
	sort(big+1,big+pos+1,cmp);
	
	for (int i=1;i<=pos;i++)
	{
		if (big[i]<=0)  break;
		if (now0)  tot0+=big[i],now0--;
		if (now1)  tot1+=big[i],now1--;
	}
	dp[now][0]=tot0,dp[now][1]=tot1;
	if (pos==1)  dp[now][0]=-inf;
}

signed main()
{
	cin>>n>>m;
	for (int i=1;i<=n;i++)  cin>>a[i];
	for (int i=1;i<n;i++)
	{
		int u,v;
		cin>>u>>v;
		add_edge(u,v);
		add_edge(v,u);
	}
	dfs(1,0);
	cout<<dp[1][1]<<endl;
	
	return 0;
}

总结

又是一场赛后诸葛亮的比赛，$D$由于时间原因代码没调完，导致$323$滚粗……

唉，还是太菜了QAQ