NOIP模拟day2 2020.10.30

今天这题啊，难度肯定达到了，这真的是NOIP吗？不过质量还是高啊。
T1

首先，题目看似第一要求边数目，第二才管权值。但我们不能就这样掉坑里了，去先找多少条边。注意到在一个连通块中，当边数最多时一定是$n-1$，而每次说边数最多是相对每一次操作而言，没有说纵向对比，所以这个条件基本可以不管。这样下来一个明显的暴力做法就有了，每次操作分别找最大生成树，再把边删了继续找，这显然是会TLE的。

那么我们就考虑优化，考虑用$k$个并查集来维护每时刻删了的边连通性，而对于权值大的边来说越往前放越佳，假设放$t$时刻，能不能放就在于在并查集中边所连$2$点是否连通，若连通则代表不能加在t时刻，则t时刻及以后都不能放，因为删了的边不会回来，满足单调性。所以我们对于每条边可以二分找到最早能放的时刻，更新$ans$和并查集。

$code：$

#include<bits/stdc++.h>
using namespace std;
const int N=1010,M=3e5+10,K=1e4+10;
int n,m,k,fa[K][N],ans[M],l,r;
struct bian{int op;int ed;int val;int id;}eg[M];
bool comp(bian a,bian b){return a.val>b.val;}
int Get(int id,int u)
{
	if(fa[id][u]==u) return u;
	fa[id][u]=Get(id,fa[id][u]);
	return fa[id][u];
}
int Read()
{
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch)){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
	return f*x;
}
bool check(int i,int j)
{
	int f1=Get(i,eg[j].op),f2=Get(i,eg[j].ed);
	if(f1==f2) return false;
	else return true;
}
int main()
{
	n=Read(),m=Read(),k=Read();
	for(int i=1;i<=m;i++) {eg[i].op=Read(),eg[i].ed=Read(),eg[i].val=Read();eg[i].id=i;}
	sort(eg+1,eg+1+m,comp);
	for(int i=1;i<=k;i++) for(int j=1;j<=n;j++) fa[i][j]=j;
	for(int i=1;i<=m;i++)
	{
		l=1,r=k;
		while(l<r){
			int mid=(l+r)>>1;
			if(check(mid,i)) r=mid;
			else l=mid+1;
		}
		if(l==r&&!check(r,i)) l++;
		else fa[l][Get(l,eg[i].op)]=Get(l,eg[i].ed);
		ans[eg[i].id]=l%(k+1);
	}
	for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
	return 0;
}

T2

这是唯一一道氵点的题把，我考试时却没咋想就走了…;

其实这道题有个东西想到了就好做了，那就是如果想要每一列都变黑至少要有一行先为全黑，那之后就可以每次花$1$代价把一列染黑。

那么我们下手点便是找让一行全黑的代价，我们发现若第$i$行有白块，必须第i列有黑块，以代价$1$修改$1$个白块，假若第$i$列没有黑家伙，那必须多花一代价改一下。最后求出每行变全黑需要的值，因为只需一行，取$min$加上$ans$l

$code:$

#include<bits/stdc++.h>
using namespace std;
int ans,n,saber,vis[510][2],whe[510],Min=1000;//whe某列有无黑 vis某行多少白,列是否全黑 
char s;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++) 
	for(int j=1;j<=n;j++)
	{
		cin>>s;
		if(s=='#') saber=whe[j]=1;
		else vis[j][1]=1,vis[i][0]++;
	}
	if(!saber){
		cout<<-1;
		return 0;
	}
	for(int i=1;i<=n;i++)
	{
		if(vis[i][1]) ans++;
		if(!vis[i][0]) Min=0;
        Min=min(Min,vis[i][0]+(!whe[i]));
	}
	cout<<ans+Min;
}

T3

一道蛮妙的题，毕竟神犇fsy都做了2h，首先我们若不考虑它的乘积要在$n^m$之下的话，总方案数就是因数个数的$2m$次方。而我们发现对于一个乘积为$x$的方案，把所有$a_i$转化为$\frac{n^{2m}}{a_i}$,那么乘积变为$\frac{n^{2m}}{x}$，这启示我们乘积小于$n^m$方案数和大于的一样多。所以$ans$便可以表达为总方案数加上乘积为$n^m$方案数再$÷2$。

首先要求因数个数吧，据大佬crf所说，这是小学奥数，即我们在求质因数时就可以求因数个数，分别乘上因数个数$+1$就行了。

于是我们现在主要目的就是找乘积为$n^m$的方案数，说实话，我这种蒟蒻真不会，听各路大佬讲解终于懂了点。前面所说的求质因数这里便是会用上，我们现在已经知道了各个质因数的个数$num$，那么我们要求只放该因数且放了$num\ast m$个该因数的方案数$f$，其中在每个位置不能放超$num$个。这个方案数求出来有啥用呢，其实每个质因数所对应$f$之积就是乘积为$n^m$方案数总数，可以想想为什么。

所以$f$怎么求呢，我们可以设$f[i][j]$表示在第$i$位已经放了$j$个质因数的方案数，要的就是$f[2m][num\ast m]$,转移方程也很简单，$f[i][j]={\sum }_{k=0}^{min(num,j)}f[i-1][k]$

$tips:$
最后除以$2$时不直接除，要乘$2$的逆元再取模，而$2$关于一个质数$mod$的逆元便是$mod+1$。
$f$数组记得初始化啊！！！！
$code：$

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=998244353;
int n,m,ans1=1,ans2=1,fxk=1,cnt,ys[40],num[40],f[210][3300];
int dp(int num)
{
	memset(f,0,sizeof(f));
	int sum=0;
	for(int i=0;i<=num;i++) f[1][i]=1;
	for(int i=2;i<=2*m;i++)
	for(int j=0;j<=num*m;j++)
	{
		sum=0;	
		for(int k=0;k<=min(j,num);k++) sum=(sum+f[i-1][j-k])%mod;
        f[i][j]=sum;
	}
	return f[2*m][num*m];
}
signed main()
{
	scanf("%lld%lld",&n,&m);
    int x=2;
	if(n==1)
	{
		cout<<1;
		return 0;
	}
	while(n!=1)
	{
		if(n%x==0)
		{		
		    int tot=0;
			while(n%x==0)
			{
				tot++;
				n/=x;
			}
			ans1=(ans1*dp(tot))%mod;
			fxk=(fxk*(tot+1))%mod;
		}
		x++;
	}     

//	cout<<fxk<<endl;
	for(int i=1;i<=2*m;i++) ans2=(ans2*fxk)%mod;
    if(n!=1) ans1=ans1*dp(1)%mod,ans2=2*ans2%mod;
//	cout<<ans1<<endl;
//1ll*(ans1+ksm(ans2,2*m))%mod*(mod+1)/2%mod);
	printf("%lld",(ans1+ans2)%mod*(mod+1)/2%mod);
}

T4
一道对于本蒟蒻来说毋庸置疑的神仙题…

好，开$T4$的坑吧，毕竟是道综合性蛮强的数据结构题。

读题后我们发现，第$k$次操作后的节点个数其实就是$k$次操作所经过的链上点的并。而这里有个经典做法（懒得打了，直接上图）

而每次我们多加入一条链时，答案的更新其实就是这样：

黄色的链为已加入的，红色是新加入的，因为要按dfs序，所以$ans$更新就要按红色左边那条来（怎么判断后文有介绍） ，(这是不正确的，还可能是右边的，因为可能从右边开搜，被坑了。。。。。)找到两者的LCP（最长公共前缀）便可以了。
那么问题来了：
$1$：数很大，不能直接两两比较在，怎么解决？
$2$：加入的链位置不一定是按顺序加入，可能从哪里冒进来，怎么记录之前的值？
$3$：你加入了一条链，又该如何找到对应的拿来更新$ans$的另一条链？
.
.
.
.
.
.
.
.
.
.
.
.
其实当你把这些问题解决之后，这道题基本就没了（当然你要不写挂）那这里说说神仙$crf$的方法吧，第一个问题我们用哈希来解决，第二个问题用主席树维护，第三个我们借助$set$容器，每次插入时没必要用lower_bound啥的，直接取新加入的位置上一个或下一个就是了。
那，$T4$没了耶。
$神仙crf的code$：

#include<bits/stdc++.h>
#define re register
#define fi first
#define se second
#define mpr make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef set<int>::iterator iter;
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(!isdigit(ch)&&ch!='-') ch=getchar();
	ch=='-'?f=-1:x=ch-'0';
	while(isdigit(ch=getchar())) x=x*10+ch-'0';
	return x*f;
}
const int N=2e5+5,bs1=233,bs2=10007,mod1=19260817,mod2=1e9+7;
int n,Q,a[N],rt[N],pw1[N],pw2[N];
ll ans=1;
namespace sgt
{
	int idcnt,lc[N*30],rc[N*30];
	pii h[N*30];
	inline void pushup(int x,int l,int mid,int r)
	{
		h[x].fi=(1ll*h[lc[x]].fi*pw1[r-mid]%mod1+h[rc[x]].fi)%mod1;
		h[x].se=(1ll*h[lc[x]].se*pw2[r-mid]%mod2+h[rc[x]].se)%mod2;
	}
	void insert(int &x,int pre,int l,int r,int ps)
	{
		x=++idcnt;
		h[x]=h[pre],lc[x]=lc[pre],rc[x]=rc[pre];
		if(l==r) {h[x].fi^=1,h[x].se^=1;return;}
		int mid=(l+r)>>1;
		if(ps<=mid) insert(lc[x],lc[pre],l,mid,ps);
		else insert(rc[x],rc[pre],mid+1,r,ps);
		pushup(x,l,mid,r);
	}
	int q_lcp(int x,int y,int l,int r)
	{
		if(l==r) return 0;
		int mid=(l+r)>>1;
		if(h[lc[x]]!=h[lc[y]]) return q_lcp(lc[x],lc[y],l,mid);
		else return mid-l+1+q_lcp(rc[x],rc[y],mid+1,r);
	}
	int q_cmp(int x,int y,int l,int r)
	{
		//cout<<h[x].fi<<" "<<h[y].fi<<"  "<<l<<" "<<r<<endl;
		if(l==r) return h[y].fi;
		int mid=(l+r)>>1;
		if(h[lc[x]]!=h[lc[y]]) return q_cmp(lc[x],lc[y],l,mid);
		else return q_cmp(rc[x],rc[y],mid+1,r);
	}
}
struct cmp{bool operator()(int x,int y) {return sgt::q_cmp(x,y,1,n);}};
set<int,cmp>st;
signed main()
{
	//freopen("d.in","r",stdin);
	//freopen("d.out","w",stdout);
	n=read(),Q=read();
	pw1[0]=pw2[0]=1;
	for(re int i=1;i<=n;++i) pw1[i]=1ll*pw1[i-1]*bs1%mod1,pw2[i]=1ll*pw2[i-1]*bs2%mod2;
	for(re int i=1;i<=Q;++i)
	{
		int k=n-read(),last=rt[i-1];
		ans+=n;
		for(re int j=k;j>=1;--j)
		{
			a[j]^=1;
			sgt::insert(rt[i],last,1,n,j);
			last=rt[i];
			if(a[j]) break;
		}
		if(st.find(rt[i])!=st.end()) continue; 
		iter p=st.insert(rt[i]).fi;
		iter l=p,r=p;
		--l,++r;
		//cout<<*l<<" "<<*p<<" "<<*r<<endl;
		if(p==st.end()) continue;
		if(p!=st.begin()) ans-=sgt::q_lcp(rt[i],*l,1,n);
		if(p!=--st.end()) ans-=sgt::q_lcp(rt[i],*r,1,n);
		if(p!=st.begin()&&p!=--st.end()) ans+=sgt::q_lcp(*l,*r,1,n);
		printf("%lld\n",ans);
	}
	return 0;
}

写的最久一次博客…