【USACO3.1.5】联系 位运算/KMP/AC自动机

最新推荐文章于 2021-08-30 23:15:23 发布
最新推荐文章于 2021-08-30 23:15:23 发布
阅读量526 收藏
点赞数
分类专栏： 位运算 AC自动机 kmp USACO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_23081367/article/details/43928171
版权
USACO 同时被 3 个专栏收录
71 篇文章 0 订阅
订阅专栏
kmp
11 篇文章 0 订阅
订阅专栏
AC自动机
7 篇文章 0 订阅
订阅专栏

吐槽：这题的输出真恶心恶心恶心恶心恶心*10000……


TLE方法：

暴力KMP，把所有的100 101 111之类的方案，全部和原串匹配一次…… 然后排序输出。

Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.008 secs, 9424 KB]
   Test 2: TEST OK [0.003 secs, 9424 KB]
   Test 3: TEST OK [0.032 secs, 9424 KB]
   Test 4: TEST OK [0.065 secs, 9424 KB]

  > Run 5: Execution error: Your program (`contact') used more than
        the allotted runtime of 1 seconds (it ended or was stopped at
        1.674 seconds) when presented with test case 5. It used 9420 KB of
        memory. 
/*
TASK:contact
LANG:C++
*/

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

bool text[200020];
int L, R, n, tlen=0, slen, next[50];
bool son[50];

void init()
{
	scanf("%d%d%d\n", &L, &R, &n);
	char ch;
	while (1)
	{
		ch = getchar();
		if (ch == '\n')	continue;
		if (ch == EOF)	break;
		text[tlen++] = ch - '0';
	}
}

void cal(int k, int w) //k这个数字，转化为w位数字
{
	slen = w - 1;
	memset(son,0,sizeof(son));
	while (k)
	{
		son[slen--] = k % 2;	
		k /= 2;
	}
	slen = w;
}

int kmp(bool *son, bool *text, int slen, int tlen)
{
	int i = 0, j = -1;
	int ans = 0;
	next[0] = -1;
	while (i != slen)
	{
		if (j == -1 || son[i] == son[j])	next[++i] = ++ j;	
		else j = next[j];
	}
	i = 0, j = 0;
	while (i != tlen)
	{
		if (j == -1 || text[i] == son[j])	++i, ++ j;	
		else j = next[j];
		if (j == slen)
		{
			++ ans;
			j = next[j];
		}
	}
	return ans;
}

struct pack
{
	int key;
	int k, w;
}a[500000];
int tail=0;

bool operator < (pack A, pack B)
{
	if (A.key != B.key)	return A.key > B.key; //首先是重复次数多的
	if (A.w != B.w) return A.w < B.w;
	if (A.k != B.k)	return A.k < B.k;
}

void doit()
{
	for (int i = L; i <= R; ++ i)//穷举位数
	{
		for (int j = 0; j <= (1 << i) - 1; ++ j)//穷举十进制数字，然后换成二进制
		{
			cal(j, i);//	
			a[tail].key = kmp(son, text, slen, tlen);
			if (a[tail].key == 0)	continue;
			a[tail].k = j;
			a[tail].w = i;
			++tail;
		}
	}
	sort(a, a + tail);
	int tmp = -1,t=0, now=0; //最后一次出现的循环次数的数值， 输出了多少个不同的循环，  当前节点
	int output_num;
	while (now != tail)
	{
		if (a[now].key != tmp)//新的重复次数	
		{
			if (t == n)	break;
			if (tmp != -1)	printf("\n");
			printf("%d", tmp = a[now].key);
			putchar('\n');
			++ t;	
			output_num = 0;
		}else{
			if (output_num != 6)	putchar(' ');
			else 
			{
				putchar('\n');
				output_num = 0;
			}
		}
		cal(a[now].k, a[now].w);
		for (int i = 0; i != a[now].w; ++ i)	putchar(son[i]+'0');
		++ output_num;
		++now;
	}
	putchar('\n');
}

int main()
{
	freopen("contact.in","r",stdin);
	freopen("contact.out","w",stdout);
	init();
	doit();
	return 0;
}





AC方法1：

位运算。 把原串看成是一个二进制串。 把后面1位，2位，3位…… 都截取下来，换成十进制K，然后给b[k][i] (十进制是K，二进制是i位)，保存进b数组，然后给b数组排序输出即可。


要点1：    0 00 000是不一样的串， 所以可以要记录一个数字到底是几位。

要点2：    为了省事，在给sort附加CMP信息的时候，可以在3个关键字上做手脚，达到排序后直接输出即可，不需要再做任何调整。 （第一关键字正序，第二第三关键字倒序）


速度很优秀

Executing...
   Test 1: TEST OK [0.003 secs, 9816 KB]
   Test 2: TEST OK [0.000 secs, 9816 KB]
   Test 3: TEST OK [0.003 secs, 9816 KB]
   Test 4: TEST OK [0.003 secs, 9816 KB]
   Test 5: TEST OK [0.005 secs, 9816 KB]
   Test 6: TEST OK [0.019 secs, 9816 KB]
   Test 7: TEST OK [0.014 secs, 9816 KB]

All tests OK.
/*
TASK:contact
LANG:C++
*/

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

int L, R, n, slen, tlen=0;
int son[13];

inline void cal(int k, int w) //k这个数字，转化为w位数字
{
	slen = w - 1;
	memset(son,0,sizeof(son));
	while (k)
	{
		son[slen--] = k % 2;	
		k /= 2;
	}
	slen = w;
}

struct pack
{
	int key;  //出现的次数
	int k, w; //模拟的是k，位数是w
}a[140000];
int tail=0;

int b[9000][15]={0};

inline bool operator < (pack A, pack B)
{
	if (A.key != B.key)	return A.key > B.key; //首先是重复次数多的
	if (A.w != B.w) return A.w < B.w;
	if (A.k != B.k)	return A.k < B.k;
}

void doit()
{
	for (int i = L; i <= R; ++ i)
	{
		for (int j = 0; j <= (1 << i) - 1; ++ j)	
		{
			if (b[j][i] == 0)	continue;
			a[tail].key = b[j][i];
			a[tail].w = i;
			a[tail++].k = j;
		}
	
	}
	sort(a, a + tail);
	int tmp = -1,t=0, now=0; //最后一次出现的循环次数的数值， 输出了多少个不同的循环，  当前节点
	int output_num;
	while (now != tail)
	{
		if (a[now].key != tmp)//新的重复次数	
		{
			if (t == n)	break;
			if (tmp != -1)	printf("\n");
			printf("%d", tmp = a[now].key);
			putchar('\n');
			++ t;	
			output_num = 0;
		}else{
			if (output_num != 6)	putchar(' ');
			else 
			{
				putchar('\n');
				output_num = 0;
			}
		}
		cal(a[now].k, a[now].w);
		for (int i = 0; i != a[now].w; ++ i)	putchar(son[i]+'0');
		++ output_num;
		++now;
	}
	putchar('\n');
}
inline void check(int tot, int wei) //tot这个数字，来检测所有wei位(二进制下)的数字
{
	int s = (1 << wei);
	int t = tot & ((1 << wei) - 1); // tot的xxx
	b[t][wei] ++;
}

int main()
{
	freopen("contact.in","r",stdin);
	freopen("contact.out","w",stdout);
	scanf("%d%d%d\n", &L, &R, &n);
	char ch;
	int tot = 0;
	while (1)
	{
		ch = getchar();
		if (ch == '\n')	continue;
		if (ch == EOF)	break;
		++tlen;
		tot <<= 1;	
		tot += ch=='0'?0:1; //新的数字插入
		for (int i = L; i <= min(R, tlen); ++ i)	check(tot, i);	//tot长度为i
	}
	doit();
	return 0;
}

方法3： AC自动机


因为AC自动机拥有多串匹配功能，所以嘛~ 把长度范围内的二进制串都放进trie里，然后直接把后来的串放在AC自动机里跑一下就行了~ 速度也非常快。2个程序在速度差不多……   方法4，我实在想不到了……别人程序比我慢，我猜是getchar的区别导致的


Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.008 secs, 5676 KB]
   Test 2: TEST OK [0.008 secs, 5676 KB]
   Test 3: TEST OK [0.011 secs, 5932 KB]
   Test 4: TEST OK [0.008 secs, 5676 KB]
   Test 5: TEST OK [0.024 secs, 5932 KB]
   Test 6: TEST OK [0.032 secs, 5676 KB]
   Test 7: TEST OK [0.032 secs, 5932 KB]

All tests OK.
/*
TASK:contact
LANG:C++
*/
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <cstring>
using namespace std;

int L, R, n, slen, tlen=0;
int son[13];

inline void cal(int k, int w) //k这个数字，转化为w位数字
{
	slen = w - 1;
	memset(son,0,sizeof(son));
	while (k)
	{
		son[slen--] = k % 2;	
		k /= 2;
	}
	slen = w;
}

struct pack
{
	int key;  //出现的次数
	int k, w; //模拟的是k，位数是w
}a[140000];
int tail=0;

int b[9000][15]={0};

inline bool operator < (pack A, pack B)
{
	if (A.key != B.key)	return A.key > B.key; //首先是重复次数多的
	if (A.w != B.w) return A.w < B.w;
	if (A.k != B.k)	return A.k < B.k;
}

void doit()
{
	for (int i = L; i <= R; ++ i) //排序
	{
		for (int j = 0; j <= (1 << i) - 1; ++ j)	
		{
			if (b[j][i] == 0)	continue;
			a[tail].key = b[j][i];
			a[tail].w = i;
			a[tail++].k = j;
		}
	
	}
	sort(a, a + tail);
	int tmp = -1,t=0, now=0; 
	int output_num;
	while (now != tail)  //恶心输出
	{
		if (a[now].key != tmp)
		{
			if (t == n)	break;
			if (tmp != -1)	printf("\n");
			printf("%d", tmp = a[now].key);
			putchar('\n');
			++ t;	
			output_num = 0;
		}else{
			if (output_num != 6)	putchar(' ');
			else 
			{
				putchar('\n');
				output_num = 0;
			}
		}
		cal(a[now].k, a[now].w);
		for (int i = 0; i != a[now].w; ++ i)	putchar(son[i]+'0');
		++ output_num;
		++now;
	}
	putchar('\n');
}

struct node
{
	int flag;
	int k, w;
	node *fail;
	node *c[2];
	node()
	{
		flag = k = w = 0;
		fail = NULL;
		c[0] = c[1] = NULL;
	}
};


struct AC_DFA
{
	int size;
	queue<node*>q;
	node *root;

	AC_DFA()
	{
		root = new node;	
	}

	inline void ins(int *word, int len, int k)
	{
		node *now = root;
		for (int i = 0; i != len; ++ i)
		{
			if (!now -> c[word[i]])	
				now -> c[word[i]] = new node;
			now = now -> c[word[i]];
		}
		now -> flag = 1; //这里有单词
		now -> k = k; //
		now -> w = len;
	}

	void setfail()
	{
		q.push(root);
		root -> fail = NULL;
		while (!q.empty())
		{
			node *now = q.front();		
			q.pop();
			for (int i = 0; i != 2; ++ i)
			{
				if (now -> c[i])	
				{
					node *p = now -> fail;	
					while (p && !p -> c[i])	p = p -> fail;
					now -> c[i] -> fail = p ? p -> c[i] : root;
					q.push(now -> c[i]);
				}else now -> c[i] = now == root ? root : now -> fail -> c[i];
			}
		}
	
	}
}ac;

void init()
{
	scanf("%d%d%d\n", &L, &R, &n);
	for (int i = L; i <= R; ++ i)
	{
		for (int j = 0; j  != (1 << i) ; ++ j)
		{
			cal(j, i);	
			ac.ins(son, i, j);
		}
	}
	ac.setfail();
}

int main()
{
	freopen("contact.in","r",stdin);
	freopen("contact.out","w",stdout);
	init();
	char ch;
	node *now = ac.root, *tmp;
	while (1)
	{
		ch = getchar();
		if (ch == '\n')	continue;
		if (ch == EOF)	break;
		now = now -> c[ch - '0'];
		tmp = now;
		while (tmp && tmp -> flag)
		{
			b[tmp -> k][tmp -> w] ++;
			tmp = tmp -> fail;	
		}
	}
	doit();
	return 0;
}


CMTM4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
USACO2.2【统计,dp,模拟,位运算】
QuantAsk
10-07 259
正题 T1:序言页码 PrefaceNumberingPreface NumberingPrefaceNumbering 评测记录:https://www.luogu.org/recordnew/lists?uid=52918&amp;pid=P1465 题目大意 求1∼n1\sim n1∼n的罗马数字每个字母出现的次数。 解题思路 先写一个表，表示这个位上出现哪个数字表示10n10n10n...
USACO Checker Challenge 位运算
06-19 457
直接DFS会超时，第一种改进是利用对称性减枝，http://blog.sina.com.cn/s/blog_4e4c6ca501000cvj.html 第二种改进是使用位运算，见matrix67大牛：  http://www.matrix67.com/blog/archives/122 第一版代码，单纯DFS，没有利用对称剪枝，test8 超时； /* ID: wangxin
usaco 1.5 checker 位运算实现
12-27
dfs结合位运算，很简单得实现8皇后问题，时间空间都很神奇。
[USACO 1.5.4]checker（水题重做——位运算（lowbit的应用））
weixin_30539625的博客
01-26 274
描述 检查一个如下的6 x 6的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线(包括两条主对角线的所有平行线)上至多有一个棋子。 0 1 2 3 4 5 6 ------------------------- 1 | | O | | | | | ------------------------- 2...
USACO 1.4 The Clocks
ACMer不要报考高校代码为13627的移通学院！
01-22 428
虽然很多方法都一个意思……但是我因为算错2^27，认为爆int就没用位运算……然后傻呼呼的居然在压十进制位在做BFS…… 在USACO上TLE，但是其他OJ一般卡时内能过…… 9个数字分解为0123，然后用一个9位数保存…… 大量时间浪费在拆解数字上…… /* TASK:clocks LANG:C++ */ #include #include #include #include
usaco_problem_files___1.1.1-1.5.4.zip_USACO/contact_online judgi
09-22
《USACO问题集：1.1.1-1.5.4版本解析》 USACO，全称为United States of America Computing Olympiad，是美国计算机奥林匹克竞赛，旨在培养高中生的编程技能和算法理解能力。这个名为"usaco_problem_files___1.1.1-...
USACO官网93题fps格式 OJ题库
最新发布
10-30
USACO 官网第一到 五章 练习题中文语言官方数据 fps格式支持导入所有OJ 1 [1.1] 你的飞碟在这儿 Your Ride Is Here 2 [1.1] 贪婪的送礼者Greedy Gift Givers 3 [1.1] 黑色星期五Friday the Thirteenth 4 [1.1] 坏掉...
lamps.zip_数值算法/人工智能_Visual_C++_
08-11
LAMPS题目源自于USACO（美国计算机奥林匹克），它是一个旨在提升高中生编程能力的比赛。通过这个实例，我们可以学习到如何运用数值算法和人工智能的基础思想来解决实际问题。 首先，我们要了解LAMPS问题的核心。...
USACO 历年全部测试数据
10-08
含2001~2017全部比赛赛题测试数据 2001~2007 数据√ 题面× 标程题解× 2008~2010 数据√ 题面√ 标程题解× 2011~2017 数据√ 题面√ 标程题解√ 其中除2008~2010外其他年份均按照年度、月度、金银铜白金组别整理...
usaco刷题，关于 位运算
az_77的博客
05-28 274
刷usaco题解，一道我写了一百行代码的题题解只用了十几行。。。直接惊呆。。 第一次知道位运算还有这种方法。 可以快速的比较是不是有一个数是不是属于某个几个，只限于一位数。 /* ID: w.x.f.g1 PROG: crypt1 LANG: C++ */ #include #include using namespace std; #define jud(t) for(int x
【USACO3.2.2】01串 位运算/二分答案
ACMer不要报考高校代码为13627的移通学院！
02-26 671
挺有意思的一个题目。 说白了，就是给定一个数字K， 我能否计算出从0~K 这K+1个数字中（全部用二进制表示），  有几个数字是有1个1，有几个数字是2个1，有几个数字有3个1， 有几个数字有4个1……   这样的问题可以看成是， 有T个空格，我有K个1要插入这T个空格中。  这样的话，这个问题就转化为组合数学问题了。 举个例子： 对于一个二进制数字
P1461 海明码 Hamming Codes
weixin_30342827的博客
04-05 141
题目描述 给出 N，B 和 D，要求找出 N 个由0或1组成的编码（1 <= N <= 64），每个编码有 B 位（1 <= B <= 8），使得两两编码之间至少有 D 个单位的“Hamming距离”（1 <= D <= 7）。“Hamming距离”是指对于两个编码，他们二进制表示法中的不同二进制位的数目。看下面的两个编码 0x554 和 0x234...
洛谷 P3041 [USACO12JAN]Video Game G（AC自动机+DP）
C_Dreamy的博客
02-22 209
题目不难想到要应用 DP，建好 AC自动机之后 dp[i][j] 表示到第i 个字符标号为j 的节点时最大的连击数是多少 dp 方程也不难想 由于本人实力欠缺，dp 数组的初始化为什么要设为 -1 没想明白，先给自己挖个坑 QAQ const int N=300+5; int n,m; int i,j,k; char s[N]; int t[N][3],tot=0; int vis[N],f[N]; int dp[(int)1e3+5...
[BZOJ3942][Usaco2015 Feb]Censoring（kmp）
薇小薇
11-01 442
对kmp要有更深层次的理解呢
【USACO】AC自动机
weixin_30273763的博客
05-16 73
Description 对，这就是裸的AC自动机。要求：在规定时间内统计出模版字符串在文本中出现的次数。 Input 第一行：模版字符串的个数N。第2->N+1行：N个字符串。(每个模版字符串的长度<=50)第N+2行：一行很长的字符串。长的很。(使用AC自动机能在1s内计算出） ...
bzoj3075: [Usaco2013]Necklace（kmp+dp）
苟为蒟蒻又何妨
03-01 295
传送门 题意简述：给出S,TS,TS,T两个字串，∣S∣≤10000,∣T∣≤1000|S|\le10000,|T|\le1000∣S∣≤10000,∣T∣≤1000，问至少从SSS中删去几个字符能够使得TTT不是修改后的SSS的字串。 思路： 考虑正难则反转化问题。 只需要求所有使得TTT不为SSS字串的SSS的字符数最大值。 于是设计状态fi,jf_{i,j}fi,j​表示SSS中前iii个...
[USACO15FEB]Censoring S【KMP+单调栈】
既然弱小，就只顾变强就是了
07-03 235
题目链接 我们要让S串去删除T串，且不断的删除存在过的T串，所以就是可以用一个单调栈维护一个存在的串，然后因为可能存在删除，所以我们要记录每一位的最大匹配个数。 #include <iostream> #include <cstdio> #include <cmath> #include <string> #include <cstring> #include <algorithm> #include <limits&g.
USACOTraining 3.1.5 Contact 联系 题解
初学者
08-13 4007
奶牛们开始对用电波望远镜扫描牧场外的宇宙感兴趣.最近,他们注意到了一种非常奇怪的脉冲调 制微波被从星系的中央发射出来.他们希望知道电波是否是被某些地外生命发射出来的,还是仅仅 是普通的的星星的心跳.      帮助奶牛们用一个能够分析他们在文件中记下的记录的工具来找到真相.他们在寻找长度在A到B 之间（含）在每天的数据文件中重复得最多的比特序列 (1 得最多的比特序列.一个输入限制告
P4824 [USACO15FEB]Censoring S（kmp删子串）
weixin_43442908的博客
08-30 138
P4824 [USACO15FEB]Censoring S（kmp删子串） 传送门 题意： 给你S，T字符串，删除S串，重复这个过程，直到不能删为止，删除后字符串会拼接起来 思路： 用栈维护，当删除成功时，出栈至拼接的位置，然后看其next数组位置，继续kmp匹配。 方案打印即为栈内元素。 代码： #include <iostream> #include <cstring> #include <stack> using namespace std; const int N
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值