2019牛客暑期多校训练营（第九场）

现场AC:     B.D

RANK:316

今天打的很差，还是太菜了！

补题情况：

- 队友过的

Ο 自己过的或赛后补题

题号

A

B

C

D

E

F

G

H

I

J

K

L

状态

.

-

.

Ο

Ο

.

.

.

.

.

.

.

D:

二表法：

一个很神奇的做法，没有百度我估计要写dfs+剪枝了

首先把n分成2半

a，b两个数组

然后把a数组任意组合得到大小为(2^(na))的数组A

b数组一样得到B。

结果肯定是在A数组中选一个数和在B数组中选一个数相加刚好等于s。

记录下A数组选的数，和B数组选的数，再对应二进制压缩前的状态即可。

 

在A数组和B数组选数有个线性的做法：

把A降序即从大到小，

把B升序即从小到大。

先让  i=1，j=1

先看A1+B1是否等于S

如果等于，就break

如果大于S，则说明A1+B1大了，肯定把A1+B1变小，由于A降序，所以让i++即可.

否则让j++。

题目保证有一个解  输出即可。

#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
const int M= (1<<18)+77;
const ll T = 9e18;
ll ans=0;
ll s[40];
ll a[40],b[40];
int na,nb;
struct node
{
	ll x,id;
}A[M],B[M];
bool cmp2(node a,node b)
{
	return a.x>b.x;
}
bool cmp1(node a,node b)
{
	return a.x<b.x;
}
int pr[50];
int main()
{
	ll n;
	scanf("%lld%lld",&n,&ans);
	for(int i=1;i<=n;i++)
	{
		scanf("%lld",&s[i]);
	}
	for(int i=1;i<=n;i++)
	{
		if(i%2==1)
			a[++na]=s[i];
		else
			b[++nb]=s[i];
	}
	ll lena=1<<na;
	for(int i=1;i<=lena;i++)
	{
		ll res=0;
		for(int j=1;j<=na;j++)
		{
			if((1<<(j-1))&i)
				res+=a[j];
		}
		A[i].x=res;
		A[i].id=i;
	}
	ll lenb=1<<nb;
	for(int i=1;i<=lenb;i++)
	{
		ll res=0;
		for(int j=1;j<=nb;j++)
		{
			if((1<<(j-1))&i)
				res+=b[j];
		}
		B[i].x=res;
		B[i].id=i;
	}
	sort(A+1,A+1+lena,cmp1);
	sort(B+1,B+1+lenb,cmp2);
	int i=1,j=1;
	while(1)
	{
		if(A[i].x+B[j].x==ans)
		{
			break;
		}
		else if(A[i].x+B[j].x<ans)
		{
			i+=1;
		}
		else
			j+=1;
		if(i>lena||j>lenb)
		break;
	}
	for(int k=1;k<=na;k++)
	{
		if((1<<(k-1))&A[i].id)
			pr[k*2-1]=1;
	}
	for(int k=1;k<=nb;k++)
	{
		if((1<<(k-1))&B[j].id)
			pr[k*2]=1;
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d",pr[i]);
	}
	puts("");
   	return 0;
}

E：

比赛是把自己绕进去了，大体思路对了，过程优化的时候越写越麻烦。

最后结束一看题解瞬间明白，3分钟敲完AC。

思路：首先没人认识的时候肯定是ans=C[n][4];

如果2个人认识，会少什么？

少的部分肯定是：这2人所在集合，各选一个，再在剩余所有人中选2个。//其他情况一定不会少

问题就在于怎么快速求出在剩余所有人中选2个。

假如我们求出了当前状态下：在所有人中选2个的方案数sum。

那么在剩余人中取2个的方案数肯定等于：

sum减去：选一个x集合的人和剩余人和选一个y集合的人和剩余人加上选一个x集合和一个y集合。

这些都能直接算出来，所以结果就能表示出来了。

然后我们发现，这个剩余人中选2个的方案数再加上----在新的xy集合中选一个及在剩余人中选一个的方案数，就是等于当前状态下所有人选2个的方案数。

所以直接并查集递推即可

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int M= 1e5+7;
ll fa[M];
ll sz[M];
ll num,pi,n,pr,numr;
ll ns[M];
ll rs[M];
bool flag;
ll C[100000+8][4];
void dabiao()
{
    C[0][0]=1;
     
    for(int i=1;i<=1e5+5;i++)
    {
        C[i][1]=i;
        for(int j=2;j<=4;j++)
            C[i][j]=C[i-1][j-1]+C[i-1][j];
    }
}
int  get(int x)
{
    if(fa[x]==x)return x;
    return fa[x]=get(fa[x]);
}
int main()
{
    dabiao();
    ll m;
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n;i++)
    fa[i]=i,sz[i]=1;
    num = n;
    ll ans=C[n][4];
    printf("%lld\n",ans);
    pi=0;
    ll sum=C[n][2];
    for(int i=1;i<=m;i++)
    {
        int x,y;
        flag=false;
        scanf("%d%d",&x,&y);
        int gx=get(x),gy=get(y);
        if(gx==gy||ans<=0)
        {
        	printf("%lld\n",ans);
        	continue;
		}
		num--;
    	fa[gx]=gy;
    	int nz=(n-sz[gx]-sz[gy]);
    	sum-=sz[gx]*nz;
		sum-=sz[gy]*nz;
		sum-=sz[gx]*sz[gy];
		ans-=sum*(sz[gx]*sz[gy]);
		sz[gy]+=sz[gx];
    	sum+=sz[gy]*nz;
    	
    	printf("%lld\n",ans);
    }
    return 0;
}

H：

主席树空间大小等于： 4*N+n*logN。  n是数字个数，N是数字大小上限。

logN<=17      4*N=2*n

所以开19是最合适的。

 

然后我们说一下这一题的思路：

题目让求l-r区间内，砍y刀后全部砍完，没刀砍的长度和一样，问你第x刀砍在哪？

首先 我们直到砍x刀  总共砍去了 ： kan==sum /y  *x;

sum是区间内竹子总高度，我们只需要找高度：h满足高度大于等于h部分的长度和恰好等于kan即可。

我们可以二分h，但是暴力做时间复杂度不够，想到可以用线段树快速维护。

 

但是线段树只能快速维护整数点，所以我们先求出整数h，使得高度大于h的部分的长度大于等于kan，

中间会差一个小于1的小数部分 ：  h1；

这里我们再求出高度在  h---h+h1区间的竹子个数num，和高度大于h的部分的总长度sup

就可算出h1==  (sup-kan)/num;

sup和num可用 可持久化权值线段树---即主席树  快速维护

总体复杂度nlog n^2;

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int M= 2e5+7;
const int N = 1e5;
int rt[M],ls[M*19],rs[M*19],sum[M*19];
ll val[M*19];
int cnt;
#define m (l+r)/2
void up(int pre,int &o,int l,int r,int x)
{
	o=++cnt;
	sum[o]=sum[pre]+1;
	val[o]=val[pre]+x;
	ls[o]=ls[pre];
	rs[o]=rs[pre];
	if(l==r)return ;
	if(x<=m)up(ls[pre],ls[o],l,m,x);
	else up(rs[pre],rs[o],m+1,r,x);
}
ll qu(int pre,int o,int l,int r,int x)//区间高度大于x的部分，竹子的长度和 
{
	if(x<=l)
	{
		return val[o]-val[pre]-(ll)(sum[o]-sum[pre])*x;
	}
	ll res=0;
//	if(x>m)
	res+=qu(rs[pre],rs[o],m+1,r,x);
	if(x<=m)res+=qu(ls[pre],ls[o],l,m,x);
	return res;
}
int qu2(int pre,int o,int l,int r,int x)//区间高度  大于  x的竹子个数 
{
	if(x<=l)
	{
		return sum[o]-sum[pre];
	}
	int res=0;
//	if(x>m)
	res+=qu2(rs[pre],rs[o],m+1,r,x);
	if(x<=m)res+=qu2(ls[pre],ls[o],l,m,x);
	return res;
} 
int main()
{
	int n,q,z;
	scanf("%d%d",&n,&q);
	cnt=0;//初始化 
	for(int i=1;i<=n;i++)
	scanf("%d",&z),up(rt[i-1],rt[i],1,N,z);
	int l,r;
	double x,y;
//	puts("ok");
	for(int i=1;i<=q;i++)
	{
		scanf("%d%d%lf%lf",&l,&r,&x,&y);
		ll s=val[rt[r]]-val[rt[l-1]];
		db kan=s*1.0*x/y;
		int L=0,R=N,pos=0;
	//	cout<<"kan:"<<kan<<"  s:"<<s<<endl;
		while(L<=R)
		{
			int mid=(L+R)/2;
			ll sup=qu(rt[l-1],rt[r],1,N,mid);
		//	cout<<"l:"<<l<<"   r:"<<r<<"  mid"<<mid<<"   sup:"<<sup<<endl;
			
			if(sup*1.0>=kan)
			{
				pos=mid;
				L=mid+1;
			}
			else
			R=mid-1;
		}
		int num=qu2(rt[l-1],rt[r],1,N,pos+1);//区间竹子高度大于等于pos+1的个数 
		ll sup=qu(rt[l-1],rt[r],1,N,pos);//区间竹子高度大于等于pos部分的长度和
		db h=pos*1.0+(sup-kan)*1.0/num;
	//	cout<<"pos:"<<pos<<" num:"<<num<<"  sup:"<<sup<<" h:"<<h<<endl;
		printf("%.15f\n",h);
	}
   	return 0;
}