bzoj4572

最新推荐文章于 2020-01-20 19:28:47 发布
最新推荐文章于 2020-01-20 19:28:47 发布
阅读量947 收藏
点赞数
分类专栏： 省选 bzoj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jzhang1/article/details/51276734
版权
一个鬼畜的做法...(估计没人看,看了也没人写..)（最终优化形态请看最后一个代码）

首先状压Dp应该都知道吧(然而yjq直接容斥强势艹过...),那么我们来优化状态,首先考虑不可能匹配成功的状态,把它们缩到一个状态,我们发现,哇!一下子少了好多状态!大概从几百万变成了5w-15w左右,但是Dp是状态数^2的,这样子肯定不行...然后一个鬼畜的优化就来了,我把与第一行匹配开始点相同的状态缩成一个状态(比如两个状态i和j,如果它
们和模板串都是从{1,5,6}开始可以匹配,那么其实它们可以当做一个状态,但是注意又可以匹配模板第一行,又可以匹配模板第二行的状态,那么它们和两行匹配的位置都必须相同.),然后发现有一维的状态变成了100+的数量,然后省选就90了,然后bzoj就卡着时限过了....估计用AC自动机进行中途的匹配过程可以快10倍左右吧(然而我这代码已经7k了,再多一点就....)...(还有一个脑洞不知道行不行,因为当时考试没足够时间,现在又与模板第一行匹配的状态k个,与第二行匹配的状态c个,之前考场上的做法只缩了k,但是c好像也可以缩一缩?要是c也能缩那估计就可以虐标算了.)

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <ctime>
#define Mod 1000000007
using namespace std;
struct node {int op;int val;int num;int k;int pos[20];int id;int pox[20];
};node Dp[600010];
struct edge{int next;int to;
};edge bian[10000010];
int first[600010],size = 0,cnt = 0,m,c,A[3][20],s[100];
int top = 0,v[100],pos[600010],queue[600010],tot = 0,n;
int p,Ans,f[110][10010][2],P[20],Q[20];
bool exist[600010],visit[600010];
void inser(int x,int y) {
	size ++;
	bian[size].to = y;
	bian[size].next = first[x];
	first[x] = size;
}
void check1(int x) {
	cnt = 0;
	for(int i = 0;i <= m - c;i ++)
	{
		bool F = true;
		for(int j = 1;j <= c;j ++)
			if(A[1][j] != s[i + j - 1])
				{F = false;break;}
		if(F == true) v[ ++cnt] = i;
	}
	if(cnt == 0) return ;
	exist[x] = true;
	top ++;
	Dp[top].k = 0;
	Dp[top].num = 1;
	Dp[top].val = x;
	Dp[top].op = cnt;
	for(int i = 1;i <= Dp[top].op;i ++)
		Dp[top].pos[i] = v[i];
	if(visit[x] == true) 
	{
		cnt = 0;
		for(int i = 0;i <= m -c;i ++)
		{
			bool F = true;
			for(int j = 1;j <= c;j ++)
				if(A[2][j] != s[i + j - 1])
					{F = false;break;}
			if(F) v[ ++cnt] = i;
		}
		Dp[top].id = cnt;
		for(int i = 1;i <= Dp[top].id;i ++)
			Dp[top].pox[i] = v[i];
	}
	else Dp[top].id = 0;
}
void check2(int x) {
	for(int i = 0;i <= m - c;i ++) 
	{
		bool F = true;
		for(int j = 1;j <= c;j ++)
			if(A[2][j] != s[i + j - 1])
				{F = false;break;}
		if(F == true) {visit[x] = true;queue[ ++tot] = x;return ;}
	}
}
bool check(int x,int y) {
	//cerr<<"HH"<<endl;
	for(int i = 0;i <= m - 1;i ++)
		P[i] = x % 3,x /= 3;
	for(int i = 0;i <= m - 1;i ++)
		Q[i] = y % 3,y /= 3;
	for(int i = 0;i <= m - c;i ++)
	{
		bool F = true;
		for(int j = 1;j <= c;j ++)
			if(A[1][j] != P[i + j - 1] || A[2][j] != Q[i + j - 1])
				 {F = false;break;}
		if(F) return true;
	}
	return false;
}
bool comp(const node &x,const node &y) {
	if(x.op != y.op) return x.op < y.op;
	if(x.id != y.id) return x.id < y.id;
	for(int i = 1;i <= x.op;i ++)
		if(x.pos[i] != y.pos[i])
			return x.pos[i] < y.pos[i];
	for(int i = 1;i <= x.id;i ++)
		if(x.pox[i] != y.pox[i])
			return x.pox[i] < y.pox[i];
	return x.val < y.val;
}
bool same(node A,node B) {
	if(A.op != B.op) return false;
	if(A.id != B.id) return false;
	for(int i = 1;i <= A.op;i ++)
		if(A.pos[i] != B.pos[i])
			return false;
	for(int i = 1;i <= A.id;i ++)
		if(A.pox[i] != B.pox[i])
			return false;
	return true;
}
bool what(const int &x,const int &y) {
	return pos[x] < pos[y];
}
int main() {
	freopen("alphago.in","r",stdin);
	freopen("alphago.out","w",stdout);
	scanf("%d%d%d%d",&n,&m,&c,&p);
	while(p --) 
	{
		Ans = 0;size = 0;top = 0;tot = 0;
		memset(exist,false,sizeof(exist));
		memset(visit,false,sizeof(visit));
		memset(first,0,sizeof(first));
		memset(queue,0,sizeof(queue));
		memset(pos,0,sizeof(pos));
		memset(Dp,0,sizeof(Dp));
		for(int i = 1;i <= 2;i ++)
		for(int j = 1;j <= c;j ++) 
		{
			char c = 'd';
			while(c != 'B' && c != 'W' && c != 'X')	
				c = getchar();
			if(c == 'B') A[i][j] = 1;
			if(c == 'W') A[i][j] = 2;
			if(c == 'X') A[i][j] = 0;
		}
		int N = 1;
		for(int i = 1;i <= m;i ++)
			N = N * 3;
		for(int i = 0;i <= N - 1;i ++) 
		{
			int M = i;
			for(int j = 0;j <= m - 1;j ++) 
			{
				s[j] = M % 3;
				M /= 3;
			}
			check2(i);
			check1(i);
		}
		int O = N - top;
		sort(Dp + 1,Dp + top + 1,comp);
		int Z = top;top = 0;
		for(int i = 1;i <= Z;i ++)
			if(i == 1 || !same(Dp[i],Dp[i - 1]))
				Dp[ ++top] = Dp[i],pos[Dp[i].val] = top;
			else Dp[top].num ++,pos[Dp[i].val] = top;
		sort(queue + 1,queue + tot + 1,what);
		//cerr<<clock()<<endl;
		for(int i = 1;i <= top;i ++)
		{
		for(int j = 1;j <= tot;j ++)
			if(check(Dp[i].val,queue[j]))
				if(!exist[queue[j]]) Dp[i].k ++;
				else if(j == 1 || pos[queue[j]] != pos[queue[j - 1]]) inser(i,pos[queue[j]]);
		}memset(f,0,sizeof(f));
		for(int i = 1;i <= top;i ++)
			f[1][i][0] = Dp[i].num;
		f[1][top + 1][0] = O;
		cerr<<size<<endl;
		//cerr<<clock()<<endl;
		for(int i = 1;i <= n - 1;i ++)
		{
			for(int j = 1;j <= top;j ++) 
			{
				int Add = (1ll * f[i][j][0] * Dp[j].k) % Mod;
				f[i + 1][top + 1][1] += Add;
				if(f[i + 1][top + 1][1] > Mod) f[i + 1][top + 1][1] -= Mod;
				Add = (1ll * f[i][j][0] * (1ll * O - 1ll * Dp[j].k)) % Mod;
				f[i + 1][top + 1][0] += Add;
				if(f[i + 1][top + 1][0] > Mod) f[i + 1][top + 1][0] -= Mod;
				Add = (1ll * f[i][j][1] * O) % Mod;
				f[i + 1][top + 1][1] += Add;
				if(f[i + 1][top + 1][1] > Mod) f[i + 1][top + 1][1] -= Mod;
				for(int u = first[j];u;u = bian[u].next)
				{
					Add = (1ll * f[i][j][0] * Dp[bian[u].to].num) % Mod;
					f[i + 1][bian[u].to][1] += Add;
					if(f[i + 1][bian[u].to][1] > Mod) f[i + 1][bian[u].to][1] -= Mod;
				/*	Add = (1ll * f[i][j][1] * Dp[bian[u].to].num) % Mod;
					f[i + 1][bian[u].to][1] += Add;
					if(f[i + 1][bian[u].to][1] > Mod) f[i + 1][bian[u].to][1] -= Mod;*/
					f[i + 1][bian[u].to][0] -= Add;
					if(f[i + 1][bian[u].to][1] < 0) f[i + 1][bian[u].to][0] += Mod;
				}
				for(int k = 1;k <= top;k ++) 
				{
					Add = (1ll * f[i][j][0] * Dp[k].num) % Mod;
					f[i + 1][k][0] += Add;
					if(f[i + 1][k][0] > Mod) f[i + 1][k][0] -= Mod;
					Add = (1ll * f[i][j][1] * Dp[k].num) % Mod;
					f[i + 1][k][1] += Add;
					if(f[i + 1][k][1] > Mod) f[i + 1][k][1] -= Mod;
				}
			}
			for(int k = 1;k <= top;k ++) 
			{
				int Add;
				Add = (1ll * f[i][top + 1][0] * Dp[k].num) % Mod;
				f[i + 1][k][0] += Add;
				if(f[i + 1][k][0] > Mod) f[i + 1][k][0] -= Mod;
				Add = (1ll * f[i][top + 1][1] * Dp[k].num) % Mod;
				f[i + 1][k][1] += Add;
				if(f[i + 1][k][1] > Mod) f[i + 1][k][1] -= Mod;
			}
			int Add;
			Add = (1ll * f[i][top + 1][0] * O) % Mod;
			f[i + 1][top + 1][0] += Add;
			if(f[i + 1][top + 1][0] > Mod) f[i + 1][top + 1][0] -= Mod;
			Add = (1ll * f[i][top + 1][1] * O) % Mod;
			f[i + 1][top + 1][1] += Add;
			if(f[i + 1][top + 1][1] > Mod) f[i + 1][top + 1][1] -= Mod;
		}
		//cerr<<clock()<<endl;
		for(int i = 1;i <= top + 1;i ++)
			Ans = (Ans + f[n][i][1]) % Mod;
		printf("%d\n",Ans);
	}
	return 0;
}

然而又瞬间秒写了另外一个优化,就是对于第二层状态判一下相同的状态剪掉...(这还只是不完全剪枝，果然又快了一倍多....)

bool yiyang(const int &x,const int &y) {
	if(pos[x] == 0 || pos[y] == 0) return false;
	return pos[x] == pos[y];
}
sort(queue + 1,queue + tot + 1,what);
tot = unique(queue + 1,queue + tot + 1,yiyang) - queue - 1;


在处理完Dp之后其实就加了这么一句小小的话....

jzhang1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
bzoj4572: [Scoi2016]围棋
limboman的博客
12-07 677
这道题我只会子集和变换优化的sb暴力（什么轮廓线插头都忘光了…） 考虑到合法状态的稀疏性（其实是你自己不会证明吧……），就可以放心暴力啦；#include<bits/stdc++.h> #define rep(i,k,n) for(int i=k;i<=n;i++) using namespace std; const int mod=1e9+7; const int N=5e4+7; const
【BZOJ】4572: [Scoi2016]围棋-轮廓线DP
远行客
09-15 260
传送门：bzoj4572 题解 算可以匹配的比较麻烦，转化成求不能匹配的，取个补集即可。 c≤6,M≤12c≤6,M≤12c\leq 6,M\leq 12，数据范围明示轮廓线DP，设f[k][sta][i][j](0≤k≤n,0≤sta≤2M,0≤i,j&amp;amp;amp;lt;c)f[k][sta][i][j](0≤k≤n,0≤sta≤2M,0≤i,j&amp;amp;amp;lt;c)f[k][sta][i][j](0\...
2019.03.27【SCOI2016】【洛谷P3290】【BZOJ4572】【LOJ2017】围棋（KMP）（轮廓线DP）
zxyoi_dreamer的博客（不定期诈尸）
03-27 157
洛谷传送门 BZOJ传送门 LOJ传送门 解析： 由于空间存的下并没有用哈希表优化状态转移，不然还能快一点，主要是哈希表的存参后的解码会稍微麻烦一些。 至少匹配一次，这个至少并不好处理，发现总的方案数始终是3nm3^{nm}3nm，所以我们考虑计算一次都没有匹配的方案数。 对于上一行的状态，我们只关心它有没有匹配完第一行，直接用一个二进制数压一下就行了。 在第一行匹配上的情况下如果当前行匹配上了...
bzoj4572: [Scoi2016]围棋（轮廓线dp）
苟为蒟蒻又何妨
03-25 147
传送门 题解可以参见zjjzjjzjj神仙的，写的很清楚。 代码： #include<bits/stdc++.h> #define ri register int using namespace std; typedef long long ll; const int mod=1e9+7; inline int add(const int&a,const int&b){...
(转)惨烈：1个Bug，45分钟损失4亿多美元
Julia & Rust & Python
09-30 3574
惨烈：1个Bug，45分钟损失4亿多美元2016-09-29 程序员的那些事 http://mp.weixin.qq.com/s?__biz=MjM5OTA1MDUyMA==&mid=2655436975&idx=1&sn=c42751b73b287ca907b897702f509ae8&chksm=bd730cd88a0485ce5483db1832741d224b7b830d6b72af4bc
bzoj problem
08-21
八中OJ所有题目
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
bzoj1878数据
01-30
bzoj1878数据（莫队）详细题解：http://blog.csdn.net/boyxiejunboy/article/details/50611972
BZOJ第三部分
11-04
BZOJ原题-BZOJP3001-P4000的题目，下载后可以离线做题。
Bottles Arrangement - HUD 4572 不明觉厉
提比的强行AC
06-15 1195
Bottles Arrangement Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 377    Accepted Submission(s): 291 Problem Description 　　Hunan
插入排序
热门推荐
ambition_star的博客
01-20 2万+
‘’’ 插入排序 ‘’’ arr=[23,45,3,6,56,1,15,4] for i in range( len( arr ) ): preIndex = i - 1# -1 # current = arr[i]# 23 #存储for循环遍历的索引数字 while preIndex >= 0 and arr[preIndex] > curren...
SCOI 2016 bzoj 4567~4572 题解
lcrtest的博客
04-28 2321
bzoj 4567 [Scoi2016]背单词 首先，我们发现如果有S(a)是S(b)的后缀，那么S(a)一定先加入 那么倒着建字典树，每次dfs自己所有的儿子，看哪棵子儿子结束节点最多，按照这个顺序贪心 儿子结束节点：遍历当前节点子树能够到达并且不经过其他结束节点的节点 什么意思呢，假设说我们有一个aabb 有一个abb，那么我计算abb的时候可以忽略aabb的贡献，这两个串对于 b 只
SCOI2016酱油记
jzhang1的专栏
04-11 1691
Day-2&Day-1     急急忙忙学了好多几何和字符串的算法.. Day0     随便刷了几道水题，半平面交，到了宾馆开始血浪... Day1     T1：瞄一眼发现是贪心，于是写了个AC自动机缩点..（还好学了AC自动机..直接trie树扒点估计不会..）     T2：看了之后发现完全不会..暴力都写不出来，当时就慌了，考完之后lcr说是线性基..%%%完美爆零。  
bzoj4593
jzhang1的专栏
05-28 1050
感谢王队长对本题的点拨...     我们先直接以1为根，考虑到一个点的代价貌似只和根与儿子节点有关。所以想到状态f[],h[],分别表示父亲还没炸，炸掉i子树 的花费和父亲先被炸掉的花费，可以观察到h[i] TYPE A :     因为c[i] TYPE B :     现在c[i] c[v]并且f[v] - h[v] = c[v]时用h[v]更优，但是这样就完了吗？当然不是，
JSOI2015 day1
jzhang1的专栏
01-09 1000
JSOI2015 day1 t1: 题目大意 设全集为1个拥有n个数的集合,现在把全集的子集填入k行的三角形中,其中三角形第i行有i列(有点像杨辉三角). 要求对于i行j列填入的子集f[i][j],必须使得f[i][j]为f[i-1][j]的子集,同时也要是f[i][j+1]的子集.(当f[i][j]==f[i-1][j]这种情况发生时也认作合法). 给出n和k,求方案数mod(1e9+7
CQOI2016
jzhang1的专栏
04-12 773
T1:     大意：一个850个点，8500条边的图，问所有点对之间的最小割有多少种不同的权值。     分治最小割。(然而做这道题之前完全不知道是什么..%YY出来的lcr)。     一开始所有点在一个集合中，随便找两个点求一次最小割，然后会把点集分成两半，继续直到所有点都变成一个点为止 (反正我们这儿唯一A的人就是这么说的...但是奇慢无比，应该是姿势不太对...)。     至
SCOI2015 day1
jzhang1的专栏
02-02 610
SC省选day1（scoi2015）        T1：大意：给出一个n*m的矩阵，从中选出n个数（m>=n），保证每一行每一列都只有一个数被选中，使得选出的数中第k大的最小。(n,m        我们先把问题转化成求第n-k+1小的数最小，那么我们先二分答案，然后对于第i行，第j列的数，如果它小于当前val，从i到j连一条边，否则不管，如果最后的最大流大于等于n-k+1,就说明当前方案可
bzoj2908数据下载
最新发布
10-14
BZOJ 2908 题目是一个数据下载任务。这个任务要求下载指定的数据文件，并统计文件中小于等于给定整数的数字个数。 为了完成这个任务，首先需要选择一个合适的网址来下载文件。我们可以使用一个网络爬虫库，如Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值