牛客CSP-S提高组赛前集训营3 赛后总结

货物收集

二分答案.复杂度\(O(n\log n)\).

货物分组

用费用提前计算的思想,考虑用一个新的箱子来装货物会发生什么.

显然费用会加上后面的所有货物的总重.

\(60\)分的\(O(n^2)\)DP代码:

#include<bits/stdc++.h>
#define LL long long
const int SIZE=100005,INF=0x3F3F3F3F;
int n;
LL W,A[SIZE],sum[SIZE];
LL DP[SIZE];

using std::max;
using std::min;

struct Seg_Tree
{
	#define LC(x) (x<<1)
	#define RC(x) (x<<1|1)
	#define Mid ((L+R)>>1)
	LL Max[SIZE*4],Min[SIZE*4];
	void push_up(int x)
	{
		Max[x]=max(Max[LC(x)],Max[RC(x)]);
		Min[x]=min(Min[LC(x)],Min[RC(x)]);
	}
	void Build(int x,int L,int R)
	{
		if(L==R){Max[x]=Min[x]=A[L];return;}
		Build(LC(x),L,Mid);
		Build(RC(x),Mid+1,R);
		push_up(x);
	}
	LL Query_Max(int x,int L,int R,int X,int Y)
	{
		if(L>Y||R<X)return -INF;
		if(L>=X&&R<=Y)return Max[x];
		return max(Query_Max(LC(x),L,Mid,X,Y),Query_Max(RC(x),Mid+1,R,X,Y));
	}
	LL Query_Min(int x,int L,int R,int X,int Y)
	{
		if(L>Y||R<X)return INF;
		if(L>=X&&R<=Y)return Min[x];
		return min(Query_Min(LC(x),L,Mid,X,Y),Query_Min(RC(x),Mid+1,R,X,Y));
	}
}T;

int main()
{
	scanf("%d%lld",&n,&W);
	for(int i=1;i<=n;i++)
	{
		scanf("%lld",&A[i]);
		sum[i]=sum[i-1]+A[i];
	}
	T.Build(1,1,n);
	memset(DP,0x3F,sizeof(DP));
	DP[0]=0;
	for(int i=1;i<=n;i++)
		for(int k=i-1;k>=0&&sum[i]-sum[k]<=W;k--)
				DP[i]=min(DP[i],DP[k]+sum[n]-sum[k]+T.Query_Max(1,1,n,k+1,i)-T.Query_Min(1,1,n,k+1,i));
	printf("%lld",DP[n]);
	return 0;
}

地形计算

无向图三元环/四元环的套路题吧.由于我太菜了,还去现学了三/四元环.

[笔记] 三元环 && 四元环计数 - LuitaryiJack的博客园

三/四元环的统计主要思想是Meet in the Middle,也就是把一个环拆成两个部分.从一个点开始标记环的一半,然后再尝试匹配另外一半.如果在尝试匹配的过程中遇到了一个标记过的点,那么这两半就可以拼成一个环.

(此处应有BGMThe Middle)

这么来看,时间复杂度是\(O(n^2)\)的,但是如果按照某种顺序来找环的话,时间复杂度可以降到\(O(m \sqrt{m})\).

我们可以按以下规则给所有点排名:

1. 度数小的节点排在度数大的节点的前面.
2. 度数相同的节点,编号小的排在前面.

然后,给每一条无向边定向.

• 如果寻找三元环,从排名大的连向排名小的.
• 如果寻找四元环,从排名小的连向排名大的.

最后则统计答案,按照上面的规则定向后,每一个环只会被统计一次.

• 如果寻找三元环,则对于每一个\(u\),标记它的出点\(v\).然后枚举出点\(v\),再枚举\(v\)的出点\(w\),如果\(w\)被标记,则\((u,v,w)\)形成三元环.

• 如果寻找四元环,则对于每一个点\(u\),枚举原图中\(u\)的出点\(v\),再枚举重定向图中\(v\)的出点\(w\).标记\(w\).然后再次枚举原图中\(u\)的出点\(v\),枚举重定向图中\(v\)的出点\(w\),如果\(w\)被标记,则形成(可能不止一个)四元环.交换"原图"与"重定向图"的枚举顺序也是可以的.不过,为了保证每个四元环只被计数一次,上述操作必须要求Rank[w]>Rank[u].

本题只是将四元环计数改成了四元环求和,算法本质没有变化,只是在"标记"的时候把个数改成权值和即可.

#include<bits/stdc++.h>
using namespace std;
const int SIZE=100005,Mod=1e9+7;
#define LL long long
#define pb push_back
LL A[SIZE];

int n,m,Deg[SIZE],ID[SIZE],Rnk[SIZE],Cnt[SIZE];
LL Ans,C[SIZE];
vector<int>G1[SIZE],G2[SIZE];

bool cmp(int A,int B)
{
	return Deg[A]==Deg[B]?A<B:Deg[A]<Deg[B];
}

int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
		scanf("%lld",&A[i]);
	int u,v;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&u,&v);
		G1[u].pb(v);
		G1[v].pb(u);
	}
	for(int i=1;i<=n;i++)
	{
		ID[i]=i;
		Deg[i]=G1[i].size();
	}
	sort(ID+1,ID+1+n,cmp);
	for(int i=1;i<=n;i++)
		Rnk[ID[i]]=i;
	for(int u=1;u<=n;u++)
		for(int v:G1[u])
			if(Rnk[v]>Rnk[u])
				G2[u].pb(v);
	for(int u=1;u<=n;u++)
	{
		for(int v:G1[u])
			for(int w:G2[v])
				if(Rnk[w]>Rnk[u])
				{
					Ans=(Ans+C[w]+1LL*Cnt[w]*A[v])%Mod;
					C[w]=(C[w]+A[u]+A[w]+A[v])%Mod;
					++Cnt[w];
				}
		for(int v:G1[u])
			for(int w:G2[v])
				if(Rnk[w]>Rnk[u])
				{
					C[w]=0;
					Cnt[w]=0;
				}
	}
	printf("%lld",Ans);
	return 0;
}