2020牛客多校训练营（第七、八场）

第七场

H.Dividing

标签：整除分块

发现符合要求的(n,k)无非两种，要么n是k的倍数，要么n-1是k的倍数（n=1也算）

于是就把问题转化成求解${\sum }_{k=1}^n\lfloor \frac{N}{k}\rfloor +{\sum }_{k=2}^n(\lfloor \frac{N-1}{k}\rfloor +1)$

可以直接整除分块 $O(\sqrt{n})$求解

#include
using namespace std;
typedef long long ll;

const int N=1e5+5,MOD=1e9+7;

ll T,n,k,m;

ll sum,up,down,last;

int main()
{
	cin>>n>>k;
	if (k<=sqrt(n))
	{
		for (int i=1;i<=k;i++)
		{
			sum=(sum+n/i)%MOD;
			sum=(sum+(n-1)/i+1)%MOD;
		}
		sum=((sum-n)%MOD+MOD)%MOD;
	}
	else
	{
		up=sqrt(n);
		for (int i=1;i<=up;i++)
			sum=(sum+n/i)%MOD;
		down=n/k;
		last=k;
		for (int i=down;i<=up;i++)
		{
			sum=(sum+1ll*i*(last-n/(i+1)))%MOD;
			last=n/(i+1);
		}
		if (1ll*up*(up+1)>n) sum-=up;

		n--;
		up=sqrt(n);
		for (int i=1;i<=up;i++)
			sum=(sum+n/i)%MOD;
		down=n/k;
		last=k;
		for (int i=down;i<=up;i++)
		{
			sum=(sum+1ll*i*(last-n/(i+1)))%MOD;
			last=n/(i+1);
		}
		if (1ll*up*(up+1)>n) sum-=up;
		sum=((sum-n)%MOD+MOD)%MOD;
		sum=(sum+k-1)%MOD;
	}
	printf("%lld\n",sum);
	return 0;
}

B.Mask-Allocation

标签：思维，构造，gcd

题意真的很难看懂

构造方法类似于在n*m的矩阵里填正方形

比如这个7*4的，需要7组4个就横着看，需要4组7个就把每个正方形旋转90度之后竖着看。直觉上感觉这种构造方法比较优，但是正确性证不来。

写法就是类似于求gcd。

#include
using namespace std;
typedef long long ll;

const int N=1e5+5,INF=0x3f3f3f3f;

int T,n,m;

vector<int>ans;

int main()
{
	cin>>T;
	while(T--)
	{
		scanf("%d%d",&n,&m);
		if (n<m) swap(n,m);
		ans.clear();
		while(n%m!=0)
		{
			for (int i=1;i<=n/m*m;i++) ans.push_back(m);
			int t=m;
			m=n%m;
			n=t;
		}
		for (int i=1;i<=n;i++) ans.push_back(m);
		printf("%d\n",ans.size());
		for (auto x:ans) printf("%d ",x);
		printf("\n");
	}
	return 0;
}

C.A-National-Pandemic

标签：树链剖分

树剖的就是一种能实现在$O(lo{g}^{2}n)$的复杂度内修改和查询树上两点路径和的结构。
入门推荐
模板题
其复杂度一方面由线段树logn区间修改查询，另一方面由“任意结点到根最多经过logn条轻边”来保证。

怎么通过查询路径和解决这道题呢？

首先对于操作一，我们希望把这个操作从任意结点转移到根结点上，可以先对x到根每条边权值+2（在查询时作为补充），再修改全局变量global+=w-dep[x]，把操作转化为对根节点的操作。

对于操作二，先查询（操作三）点值，然后对于大于0的部分，单独搞一个变量fix把大于0的部分抵消掉。

对于操作三查询直接给出计算方法
ans=qQuery(x,1)+global-tot*(dep[x])+fix[x];
也就是"x到根节点的路径和"+“全局变量”-“操作一的次数”*“x的深度”+“操作二的抵消部分”

#include
using namespace std;
typedef long long ll;

const int N=5e4+5;

ll q[N];

int n,m,r,p,fix[N],tot,T,global;

struct segTree{
	ll t[N<<4];
	ll lztag[N<<4];
	void init()
	{
		memset(t,0,sizeof(t));
		memset(lztag,0,sizeof(lztag));
	}
	void pushdown(int o,int l,int r)
	{
		if (lztag[o])
		{
			int mid=(l+r)>>1;
			t[o*2]+=lztag[o]*(mid-l+1);
			t[o*2+1]+=lztag[o]*(r-mid);
			lztag[o*2]+=lztag[o];
			lztag[o*2+1]+=lztag[o];
			lztag[o]=0;
		}
	}
	void pushup(int o,int l,int r)
	{
		t[o]=t[o*2]+t[o*2+1];
	}
	void build(int o,int l,int r)
	{
		if (l==r)
		{
			//t[o]=ord[l]%p;
			return;
		}
		int mid=(l+r)>>1;
		build(o*2,l,mid);
		build(o*2+1,mid+1,r);
		pushup(o,l,r);
	}
	void modify(int o,int l,int r,int tl,int tr,int v)
	{
		if (tl<=l && r<=tr)
		{
			t[o]+=1ll*v*(r-l+1);
			lztag[o]+=v;
			return;
		}
		int mid=(l+r)>>1;
		pushdown(o,l,r);
		if (tl<=mid) modify(o*2,l,mid,tl,tr,v);
		if (tr>mid) modify(o*2+1,mid+1,r,tl,tr,v);
		pushup(o,l,r);
	}
	ll query(int o,int l,int r,int tl,int tr)
	{
		if (tl<=l && tr>=r) return t[o];
		int mid=(l+r)>>1;
		pushdown(o,l,r);
		if (tr<=mid) return query(o*2,l,mid,tl,tr);
		if (tl>mid) return query(o*2+1,mid+1,r,tl,tr);
		return query(o*2,l,mid,tl,tr)+query(o*2+1,mid+1,r,tl,tr);
	}
}ST;

int sz[N],dep[N],son[N],fa[N],top[N],num[N],cnt;

vector<int>G[N];

void init()
{
	memset(sz,0,sizeof(sz));
	memset(fix,0,sizeof(fix));
	tot=0;
	cnt=0;
	fa[1]=-1;
	dep[1]=1;
	top[1]=1;
	global=0;
}

void dfs1(int x)
{
	int mxson=-1;
	son[x]=-1;
	for (auto to:G[x])
	{
		if (to==fa[x]) continue;
		dep[to]=dep[x]+1;
		fa[to]=x;
		dfs1(to);
		if (sz[to]>mxson) mxson=sz[to], son[x]=to;
		sz[x]+=sz[to];
	}
	sz[x]++;
}
void dfs2(int x,int tp)
{
	num[x]=++cnt;
	top[x]=tp;
	if (~son[x]) dfs2(son[x],tp);
	for (auto to:G[x])
	{
		if (to==fa[x] || to==son[x]) continue;
		dfs2(to,to);
	}
}
void qModify(int x,int y,int z)
{
	while(top[x]!=top[y])
	{
		if (dep[top[x]]<dep[top[y]]) swap(x,y);
		ST.modify(1,1,n,num[top[x]],num[x],z);
		x=fa[top[x]];
	}
	if (dep[x]>dep[y]) swap(x,y);
	ST.modify(1,1,n,num[x],num[y],z);
}
void subrootModify(int x,int z)
{
	ST.modify(1,1,n,num[x],num[x]+sz[x]-1,z);
}

ll qQuery(int x,int y)
{
	ll res=0;
	while(top[x]!=top[y])
	{
		if (dep[top[x]]<dep[top[y]]) swap(x,y);
		res+=ST.query(1,1,n,num[top[x]],num[x]);
		x=fa[top[x]];
	}
	if (dep[x]>dep[y]) swap(x,y);
	res+=ST.query(1,1,n,num[x],num[y]);
	return res;
}

ll subrootQuery(int x)
{
	return ST.query(1,1,n,num[x],num[x]+sz[x]-1);
}

void solve()
{
	cin>>n>>m;
	for (int i=1;i<=n;i++) G[i].clear();
	for (int i=1;i<=n-1;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		G[u].push_back(v);
		G[v].push_back(u);
	}
	init();
	dfs1(1);
	dfs2(1,1);
	ST.init();
	for (int i=1;i<=m;i++)
	{
		int opt,x,w;
		scanf("%d",&opt);
		if (opt==1)
		{
			scanf("%d%d",&x,&w);
			qModify(x,1,2);
			global+=w-dep[x];
			tot++;
		}
		if (opt==2)
		{
			scanf("%d",&x);
			int ask=qQuery(x,1)+global-tot*(dep[x])+fix[x];
			if (ask>0) fix[x]-=ask;
		}
		if (opt==3)
		{
			scanf("%d",&x);
			int ask=qQuery(x,1)+global-tot*(dep[x])+fix[x];
			printf("%d\n",ask);
		}
	}
}

int main()
{
	cin>>T;
	while(T--) solve();
	return 0;
}

第八场

K.Kabaleo-Lite

难点在于题意读不清楚和爆long long，以及怎么用unsigned long long处理负数。

一开始一直搞不清是优先“人数”还是优先“利润”，后来看了回答才搞清楚是优先人数，然而已经WA飞了。。

然后这道题最大值会到$1e19$，只能用unsigned long long存，问题是怎么处理负数情况呢。可以开两个ull，遇到正数记在第一个变量里，遇到负数，把它取反之后记录在第二个变量里，然后判断这两个变量的大小来决定答案是否有负号。

#include
using namespace std;
typedef long long ll;

const int N=1e5+5;
const ll INF=0x3f3f3f3f3f3f3f3f;
int T,n;

ll A[N],B[N];
struct status{
	ll a,b;
};
vector<status>Q;
void solve(int caseNum)
{
	scanf("%d",&n);
	A[0]=0;
	for (int i=1;i<=n;i++)
	{
		scanf("%llu",&A[i]);
		A[i]+=A[i-1];
	}
	B[0]=INF;
	for (int i=1;i<=n;i++)
	{
		scanf("%llu",&B[i]);
		B[i]=min(B[i-1],B[i]);
	}
	Q.clear();
	for (int i=n;i>=1;i--)
	{
		while(!Q.empty() && Q.back().a<=A[i]) Q.pop_back();
		Q.push_back({A[i],B[i]});
	}
	ll sum=0;
	unsigned long long ans1=0,ans2=0;
	unsigned long long aa=0;
	for (auto now:Q)
	{
		if (now.a>=0)
			ans1+=1ll*now.a*(now.b-sum);
		else
			ans2+=1ll*(-now.a)*(now.b-sum);
		sum=now.b;
	}
	bool sig=0;
	unsigned long long ans;
	if (ans1>=ans2) ans=ans1-ans2;
	else
	{
		sig=1;
		ans=ans2-ans1;
	}
	printf("Case #%d: %lld ",caseNum,sum);
	if (sig) printf("-");
	printf("%llu\n",ans);
}
int main()
{
	cin>>T;
	for (int i=1;i<=T;i++) solve(i);
	return 0;
}

G.Game-SET

不知道怎么评价的一题。结论是只需要考虑前21个就可以了，那直接暴力肯定没问题。想不通为啥，也懒得证了。

然而直接写$O(T\ast n^3)$的暴力，找到解就return也一样能过。。

也不深究了，倒是对这种字符串的读入和处理方法可以学一下。

#include
using namespace std;
 
const int N=300;
 
int A[N][4];
 
int T,n;
 
char s[100],o[100],p[100],q[100],r[100];
 
void Read(int x)
{
    scanf("%s",s);
    int len=strlen(s);
    for (int i=0;i<len;i++) if (s[i]=='[' || s[i]==']') s[i]=' ';
    sscanf(s,"%s%s%s%s",o,p,q,r);
    switch(o[1]){
        case 'n':A[x][0]=1; break;
        case 'w':A[x][0]=2; break;
        case 'h':A[x][0]=3; break;
        default:A[x][0]=0; break;
    }
    switch(p[0]){
        case 'd':A[x][1]=1; break;
        case 's':A[x][1]=2; break;
        case 'o':A[x][1]=3; break;
        default:A[x][1]=0; break;
    }
    switch(q[1]){
        case 'o':A[x][2]=1; break;
        case 't':A[x][2]=2; break;
        case 'p':A[x][2]=3; break;
        default:A[x][2]=0; break;
    }
    switch(r[0]){
        case 'r':A[x][3]=1; break;
        case 'g':A[x][3]=2; break;
        case 'p':A[x][3]=3; break;
        default:A[x][3]=0; break;
    }
}
 
bool judge(int a,int b,int c)
{
    for (int i=0;i<=3;i++)
    {
        if (A[a][i]==0 || A[b][i]==0 || A[c][i]==0) continue;
        int sum=A[a][i]+A[b][i]+A[c][i];
        if (sum!=6 && sum!=3 && sum!=9) return 0;
    }
    return 1;
}
void solve(int cs)
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++) Read(i);
    for (int i=1;i<=min(21,n);i++)
        for (int j=i+1;j<=min(21,n);j++)
            for (int k=j+1;k<=min(21,n);k++)
            {
                if (judge(i,j,k))
                {
                    printf("Case #%d: %d %d %d\n",cs,i,j,k);
                    return;
                }
            }
    printf("Case #%d: -1\n",cs);
}
int main()
{
    cin>>T;
    for (int cs=1;cs<=T;cs++) solve(cs);
    return 0;
}