省选模拟赛Round3Day1 进攻！字符串 序列

于 2020-06-13 21:53:11 发布
阅读量279 收藏
点赞数
分类专栏： 总结 文章标签： c++ 算法 图论 字符串 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C20180602_csq/article/details/106736457
版权

 

当我看到题时，心态就已经崩了。。。

 

 

题解

这题其实就是求网格图上的“希望”（有交K连通块计数）

（这里我们把一个面看成一个点，面面之间有公共边则在两个面之间连边）

根据希望那道题的容斥方法（边点容斥）

这种容斥的本质其实就是欧拉图论定理V-E+F=2

欧拉图论定理的适用范围是平面图，而网格图恰好就是平面图

我们先来计算每个点包含它的矩形的数目，再计算出每条边包含它的矩形的数目，再算每个环包含它的矩形的数目

那么最终的答案就等于Σ（点方案数^K）-Σ（边方案数^K）+Σ（环方案数^K）

这样我们就完成了第一步

 

我们现在来考虑如何计算包含一个点的方案

先算出这个点分别作为左上、左下、右上、右下的矩形个数（利用单调队列可以做到总体复杂度O(n^2)）

一个矩形会使点它所覆盖的点的方案数加1

于是我们考虑一种巧妙的差分

 

在计算出当前点的四种矩形个数后

一个1、4处的矩形会使当前点右下方所有点的方案数都加1

一个2、3处的矩形会使当前点右下方所有点的方案数都减1

为什么？

其实我们本应该对1、2、3、4处每一个合法的矩形进行差分

但是由于时间复杂度的限制，我们不能直接这样做

而我们又考虑到：一个矩形，它本身就会被自己的四个顶点分别算到一次

所以我们可以分4次来对它进行差分

至于边、环的方案也可以用类似的方法来做

这样我们就解决了这道题

 

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 2005
#define LL long long
const int mod=998244353;
char s[N][N];
int h1[N][N],h2[N][N];
int stk[N],top;
LL f[4][N][N];
int ksm(int x,int y)
{
	int ret=1;
	while(y){
		if(y&1)ret=1ll*ret*x%mod;
		y>>=1;x=1ll*x*x%mod;
	}
	return ret;
}
int main()
{
	freopen("attack.in","r",stdin);
	freopen("attack.out","w",stdout);
	int n,m,K,i,j,k;
	scanf("%d%d%d",&n,&m,&K);
	for(i=1;i<=n;i++)scanf("%s",s[i]+1);
	for(i=1;i<=n;i++)for(j=1;j<=m;j++)if(s[i][j]=='1')h1[i][j]=h1[i-1][j]+1;else h1[i][j]=0;
	for(i=n;i>=1;i--)for(j=1;j<=m;j++)if(s[i][j]=='1')h2[i][j]=h2[i+1][j]+1;else h2[i][j]=0;
	for(i=1;i<=n;i++){
		int sum=0;stk[top=1]=0;
		for(j=1;j<=m;j++){
			while(top&&h1[i][stk[top]]>=h1[i][j]){
				sum-=h1[i][stk[top]]*(stk[top]-stk[top-1]);
				top--;
			}
			stk[++top]=j;
			sum+=h1[i][j]*(stk[top]-stk[top-1]);
			f[0][i+1][j+1]+=sum;f[1][i+1][j+1]+=sum;f[2][i+1][j+1]+=sum;f[3][i+1][j+1]+=sum;
		}
	}
	for(i=1;i<=n;i++){
		int sum=0;stk[top=1]=m+1;
		for(j=m;j>=1;j--){
			while(top&&h1[i][stk[top]]>=h1[i][j]){
				sum-=h1[i][stk[top]]*(stk[top-1]-stk[top]);
				top--;
			}
			stk[++top]=j;
			sum+=h1[i][stk[top]]*(stk[top-1]-stk[top]);
			f[0][i+1][j]-=sum;f[1][i+1][j]-=sum;f[2][i+1][j+1]-=sum;f[3][i+1][j+1]-=sum;
		}
	}
	for(i=1;i<=n;i++){
		int sum=0;stk[top=1]=0;
		for(j=1;j<=m;j++){
			while(top&&h2[i][stk[top]]>=h2[i][j]){
				sum-=h2[i][stk[top]]*(stk[top]-stk[top-1]);
				top--;
			}
			stk[++top]=j;
			sum+=h2[i][stk[top]]*(stk[top]-stk[top-1]);
			f[0][i][j+1]-=sum;f[1][i+1][j+1]-=sum;f[2][i][j+1]-=sum;f[3][i+1][j+1]-=sum;
		}
	}
	for(i=1;i<=n;i++){
		int sum=0;stk[top=1]=m+1;
		for(j=m;j>=1;j--){
			while(top&&h2[i][stk[top]]>=h2[i][j]){
				sum-=h2[i][stk[top]]*(stk[top-1]-stk[top]);
				top--;
			}
			stk[++top]=j;
			sum+=h2[i][stk[top]]*(stk[top-1]-stk[top]);
			f[0][i][j]+=sum;f[1][i+1][j]+=sum;f[2][i][j+1]+=sum;f[3][i+1][j+1]+=sum;
		}
	}
	for(k=0;k<4;k++)for(i=1;i<=n;i++)for(j=1;j<=m;j++)
		f[k][i][j]=f[k][i][j]+f[k][i-1][j]+f[k][i][j-1]-f[k][i-1][j-1];
	int ans=0;
	for(i=1;i<=n;i++)for(j=1;j<=m;j++){
		for(k=0;k<4;k++)f[k][i][j]%=mod;
		ans=(1ll*ans+1ll*ksm(f[0][i][j],K)+1ll*mod-1ll*ksm(f[1][i][j],K)+1ll*mod-1ll*ksm(f[2][i][j],K)+1ll*ksm(f[3][i][j],K))%mod;
	}
	printf("%d\n",ans);
}

 

 

 

 

 

 

题解

Trie树预处理+不均匀莫队+删除型回滚+双向链表

这题

本来在考试的时候想到了莫队，但是觉得莫队会被卡爆（比如一个字符串特别长，还被不断地删除加入）

所以就写了可持久化Trie树暴力（竟然只有20分。。。）

没想到可以在分块的时候对字符串的长度加权，做一个不均匀的分块

于是这道题就简单很多了

在普通的Trie树上可以随便统计一个深度满足条件的数的个数

然后利用set来插入删除g[len]，维护两个连续点的差的平方和，再用总的方案数减去这个值就是合法区间的个数

然而O(nsqrt(n)logn)会TLE

我们考虑一种删除很快的数据结构：双向链表

这样，利用类似与回滚莫队的思路，我们先把所有的点都加入莫队，右端点倒序进行莫队

利用双向链表来维护两点差的平方和，这样就只用删除和回退了

双向链表还有一个好处就是：删除的时候不把当前点的指针清零，回退的时候直接按顺序加入就可以了

 

代码：（其实这份代码有个bug：不能直接用权值之和来判断是否存在该前缀，因为权值可能为0！！）

（但是数据太水了，所以过了hhhh）

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{
	char c;int num=0,flg=1;
	while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;
	while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}
	return num*flg;
}
#define N 600005
#define LL long long
int n,A,B,C;
int V[N];
char s[N];int le;
int ch[N][26];LL sum[N];
int tot,rt,mxl;
int all,pos[N],len[N],val[N],st[N],ed[N];
void insert(int &i,int d,int k)
{
	if(!i)i=++tot;
	pos[all+d+1]=i;len[i]=d;val[all+d+1]=k;
	if(d>=le)return;
	insert(ch[i][s[d]-'a'],d+1,k);
}
int bel[N],D;
struct node{
	int l,r,id;
	bool operator < (const node &t)const{
		return bel[l]<bel[t.l]||(bel[l]==bel[t.l]&&r>t.r);
	}
}q[N];
int g[N];
LL F(int x){return 1ll*x*(x-1)/2;}
LL gcd(LL x,LL y){return !y?x:gcd(y,x%y);}
int lp[N],rp[N],cnt[N];
bool check(int x){return (sum[x]&&1ll*B*sum[x]+1ll*A*len[x]>=1ll*C);}
LL ans,lans[N];
void add(int x)
{
	int p=pos[x],tmp=check(p);
	sum[p]+=val[x];
	if(!tmp&&check(p)&&(!cnt[g[len[p]]]++)){
		p=g[len[p]];
		lp[rp[p]]=p;
		rp[lp[p]]=p;
		ans+=F(rp[p]-p)+F(p-lp[p])-F(rp[p]-lp[p]);
	}
}
void del(int x)
{
	int p=pos[x],tmp=check(p);
	sum[p]-=val[x];
	if(tmp&&!check(p)&&(!(--cnt[g[len[p]]]))){
		p=g[len[p]];
		lp[rp[p]]=lp[p];
		rp[lp[p]]=rp[p];
		ans+=F(rp[p]-lp[p])-F(rp[p]-p)-F(p-lp[p]);
	}
}
int main()
{
	freopen("string.in","r",stdin);
	freopen("string.out","w",stdout);
	int Q,l,r,L,R,i,j;
	n=gi();A=gi();B=gi();C=gi();
	for(i=1;i<=n;i++)V[i]=gi();
	for(i=1;i<=n;i++){
		scanf("%s",s);le=strlen(s);
		mxl=max(mxl,le);
		insert(rt,0,V[i]);
		st[i]=all+1;all+=le+1;ed[i]=all;
	}
	for(i=1;i<=mxl;i++)g[i]=gi();
	Q=gi();
	D=int(sqrt(1.0*all+0.5));
	for(i=1;i<=all;i++)bel[i]=(i-1)/D+1;
	for(i=1;i<=Q;i++){q[i].l=st[gi()];q[i].r=ed[gi()];q[i].id=i;}
	sort(q+1,q+Q+1);
	
	int las=0;ans=0;
	for(i=1;i<=all;i++)sum[pos[i]]+=val[i];
	for(i=1;i<=tot;i++)if(check(i))cnt[g[len[i]]]++;
	for(i=1;i<=mxl;i++)
		if(cnt[i]){rp[lp[i]=las]=i;ans+=F(i-las);las=i;}
	rp[las]=mxl+1;ans+=F(mxl+1-las);
	
	//printf("initial:");for(int k=1;k<=mxl;k++)printf("%d ",cnt[k]);printf("\n");
		
	l=1;r=all;
	for(i=1,j=1;i<=bel[all]&&j<=Q;i++){
		L=(i-1)*D+1;R=min(all,i*D);
		for(;j<=Q&&bel[q[j].l]==i;j++){
			
			//printf("start:");for(int k=1;k<=mxl;k++)printf("%d ",cnt[k]);printf("\n");
				
			while(r>q[j].r)del(r--);
			while(l<q[j].l)del(l++);
			
			
			//printf("now:");for(int k=1;k<=mxl;k++)printf("%d ",cnt[k]);printf("\n");
				
			lans[q[j].id]=ans;
			//printf("answer:%d\n",ans);
			while(l>L)add(--l);
				
			//printf("end:");for(int k=1;k<=mxl;k++)printf("%d ",cnt[k]);printf("\n");
			//printf("\n");
		}
		while(r<all)add(++r);
		while(l<R+1)del(l++);
	}
	for(i=1;i<=Q;i++){
		LL tmp=F(mxl+1);lans[i]=tmp-lans[i];
		LL gc=gcd(lans[i],tmp);
		printf("%lld/%lld\n",lans[i]/gc,tmp/gc);
	}
}

 

 

 

 

 

 

题解

整体二分+网络流（这个问题本质上其实是保序回归L1问题）

考虑权值范围为[0,1]的情况

如图就是一种建图方法（蓝边边权为INF，绿边边权为1）

可以发现这样建图的话，如果一个被限制为最小值的点x的权值为1，且它管辖的区间范围种有权值为0的点

那么他就会贡献1的流量，也就是说，使它满足条件就会花费1的代价

这种建图方式本质其实就是最大权闭合图的建图方式

注意，这里要使用线段树优化建边，并且由于min、max限制的连边方式普通，还需要开两棵线段树分别进行优化

然后根据保序回归的那篇论文，把所有的点整体二分一下最终的权值，然后看是否满流就可以了？？？

表示看不懂论文

但是写代码还是会的。。。hhh

 

代码：（啊啊啊cnt一定要赋成1啊啊啊啊，调到凌晨1点，难受，第二天才发现错。。。）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
inline int gi()
{
	char c;int num=0,flg=1;
	while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;
	while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}
	return num*flg;
}
#define N 50005
#define M 1000005
const int INF=0x3f3f3f3f;
int n,m,val[N],ans;
struct qnode{
	int l,r,t;
	qnode(){}
	qnode(int x,int y,int z){l=x;r=y;t=z;}
};
vector<qnode> Q[N];
int fir[N],cur[N],nxt[M],to[M],cap[M],cnt;
void adde(int a,int b,int c)
{
	//printf("adde:%d %d %d\n",a,b,c);
	to[++cnt]=b;nxt[cnt]=fir[a];fir[a]=cnt;cap[cnt]=c;
	to[++cnt]=a;nxt[cnt]=fir[b];fir[b]=cnt;cap[cnt]=0;
}
#define lc i<<1
#define rc i<<1|1
struct node{
	int l,r,x;
}a[2][N];
int id[N],tot;
void build(int i,int l,int r)
{
	a[0][i].l=l;a[0][i].r=r;
	if(l==r){a[0][i].x=a[1][i].x=id[l];return;}
	int mid=(l+r)>>1;
	a[0][i].x=++tot;a[1][i].x=++tot;
	build(lc,l,mid),build(rc,mid+1,r);
	adde(a[0][i].x,a[0][lc].x,INF);
	adde(a[0][i].x,a[0][rc].x,INF);
	adde(a[1][lc].x,a[1][i].x,INF);
	adde(a[1][rc].x,a[1][i].x,INF);
}
void insert(int i,int l,int r,int p,int t)
{
	if(a[0][i].l>r||a[0][i].r<l)return;
	if(l<=a[0][i].l&&a[0][i].r<=r){
		if(t)adde(a[1][i].x,p,INF);
		else adde(p,a[0][i].x,INF);
		return;
	}
	insert(lc,l,r,p,t);insert(rc,l,r,p,t);
}

int q[N],he,ta;
int S,T,dis[N];
bool bfs()
{
	memset(dis,-1,(tot+1)<<2);
	dis[q[he=ta=1]=T]=0;
	while(he<=ta){
		int u=q[he++];
		for(int v,p=fir[u];p;p=nxt[p]){
			if(cap[p^1]&&dis[v=to[p]]==-1){
				dis[v]=dis[u]+1;
				q[++ta]=v;
			}
		}
	}
	return dis[S]!=-1;
}
int sap(int u,int aug)
{
	if(u==T) return aug;
	int ret=0,tmp;
	for(int v,&p=cur[u];p;p=nxt[p])
		if(cap[p]&&dis[u]==dis[v=to[p]]+1){
			tmp=sap(v,min(cap[p],aug));
			cap[p]-=tmp;aug-=tmp;
			cap[p^1]+=tmp;ret+=tmp;
			if(aug==0)return ret;
		}
	return ret;
}
void solve(int l,int r,vector<int> &A)
{
	if(A.empty()) return;
	if(l==r){
		for(int i=0;i<(int)A.size();i++)
			ans+=(val[A[i]]<l?l-val[A[i]]:val[A[i]]-l);
		return;
	}
	if(A.size()==1){
		ans+=max(val[A[0]]-r,0)+max(l-val[A[0]],0);
		return;
	}
	int mid=(l+r)>>1,i,j;
	S=tot=1;T=++tot;
	for(i=0;i<(int)A.size();i++)
		id[i]=++tot;
	build(1,0,A.size()-1);
	for(i=0;i<(int)A.size();i++){
		for(j=0;j<(int)Q[A[i]].size();j++){
			qnode tmp=Q[A[i]][j];
			int x=lower_bound(A.begin(),A.end(),tmp.l)-A.begin();
			int y=upper_bound(A.begin(),A.end(),tmp.r)-A.begin()-1;
			if(x<=y) insert(1,x,y,id[i],tmp.t);
		}
	}
	for(i=0;i<(int)A.size();i++){
		if(val[A[i]]<=mid)adde(id[i],T,1);
		else adde(S,id[i],1);
	}
	while(bfs())
		memcpy(cur,fir,(tot+1)<<2),sap(S,INF);
	//bfs();
	vector<int> L,R;
	for(i=0;i<(int)A.size();i++){
		if(dis[id[i]]!=-1)L.push_back(A[i]);
		else R.push_back(A[i]);
	}
	memset(fir,0,(tot+1)<<2);cnt=1;
	solve(l,mid,L),solve(mid+1,r,R);
}
vector<int> ini;
int main()
{
	freopen("sequence.in","r",stdin);
	freopen("sequence.out","w",stdout);
	cnt=1;
	int i,x,mi=INF,mx=-INF,l,r,op;
	n=gi();m=gi();
	for(i=1;i<=n;i++){
		val[i]=gi();ini.push_back(i);
		mi=min(mi,val[i]);mx=max(mx,val[i]);
	}
	while(m--){
		op=gi();l=gi();r=gi();x=gi();
		Q[x].push_back(qnode(l,r,op));
	}
	solve(mi,mx,ini);
	printf("%d\n",ans);
}

 

 

 

 

 

 

 

 

 

 

cqbzcsq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值