【HDU5745 2016 Multi-University Training Contest 2L】【bitset做法or暴力】La Vie en rose 目标串多少子串可以被原始串做相邻交换得到

最新推荐文章于 2020-08-28 17:17:38 发布
最新推荐文章于 2020-08-28 17:17:38 发布
阅读量805 收藏
点赞数
分类专栏： 题库-HDU 暴力 STL-bitset 文章标签： 题库-HDU 暴力 STL-bitset
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snowy_smile/article/details/52052919
版权
题库-HDU 同时被 3 个专栏收录
144 篇文章 0 订阅
订阅专栏
暴力
55 篇文章 0 订阅
订阅专栏
STL-bitset
5 篇文章 0 订阅
订阅专栏

La Vie en rose

Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 1938    Accepted Submission(s): 655

Problem Description
Professor Zhang would like to solve the multiple pattern matching problem, but he only has only one pattern string   p=p1p2...pm . So, he wants to generate as many as possible pattern strings from   p  using the following method:

1. select some indices   i1,i2,...,ik  such that   1≤i1<i2<...<ik<|p|  and   |ij−ij+1|>1  for all   1≤j<k .
2. swap   pij  and   pij+1  for all   1≤j≤k .

Now, for a given a string   s=s1s2...sn , Professor Zhang wants to find all occurrences of all the generated patterns in   s .
 

Input
There are multiple test cases. The first line of input contains an integer   T , indicating the number of test cases. For each test case:

The first line contains two integers   n  and   m   (1≤n≤105,1≤m≤min{5000,n})  -- the length of   s  and   p .

The second line contains the string   s  and the third line contains the string   p . Both the strings consist of only lowercase English letters.
 

Output
For each test case, output a binary string of length   n . The   i -th character is "1" if and only if the substring   sisi+1...si+m−1  is one of the generated patterns.
 

Sample Input 
  
  

   
   3
4 1
abac
a
4 2
aaaa
aa
9 3
abcbacacb
abc
 

Sample Output 
  
  

   
   1010
1110
100100100
 

Author
zimpha
 

Source
2016 Multi-University Training Contest 2


【HDU5745 2016 Multi-University Training Contest 2L】【暴力做法】La Vie en rose 目标串多少子串可以被原始串做相邻交换得到 

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre() { freopen("c://test//input.in", "r", stdin); freopen("c://test//output.out", "w", stdout); }
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1, class T2>inline void gmax(T1 &a, T2 b) { if (b>a)a = b; }
template <class T1, class T2>inline void gmin(T1 &a, T2 b) { if (b<a)a = b; }
const int N = 1e5+10, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int casenum, casei;
int n, m;
char a[N], b[N], ans[N];
bool check(int st)
{
	for (int j = 0; j < m; ++j)
	{
		if (a[st + j] != b[j])
		{
			if (a[st + j + 1] == b[j] && a[st + j] == b[j + 1])++j;
			else return 0;
		}
	}
	return 1;
}
int main()
{
	scanf("%d", &casenum);
	for (casei = 1; casei <= casenum; ++casei)
	{
		scanf("%d%d", &n, &m);
		scanf("%s%s", a + 1, b);
		for (int i = 1; i <= n; ++i)ans[i] = '0';
		ans[n + 1] = 0;
		for (int i = 1; i + m - 1 <= n; ++i)
		{
			if (check(i))ans[i] = '1';
		}
		puts(ans + 1);
	}
	return 0;
}
/*
【trick&&吐槽】
这题竟然暴力就够AC了，惊了个呆！

【题意】
给你一个长度为n（1e5）的目标字符串。
我们有一个长度为m（min(5000,n))的基础串，
对于这个目标字符串，显然有n-m+1个长度为m的子串
问你，在这些子串中，有哪些子串，是可以通过对基础串一些相邻位置的交换，得到的。

即，我们可以选出若干个基础串的若干个位置p[]，使得p[i+1]>p[i]+1，
然后我们swap(p[i],p[i]+1)，就可以实现变形后的基础串与目标字符串的匹配

【类型】
暴力 or bitset

【分析】
正解是bitset——

【时间复杂度&&优化】
O(nm/32)

*/

【HDU5745 2016 Multi-University Training Contest 2L】【bitset做法】La Vie en rose 目标串多少子串可以被原始串做相邻交换得到

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre() { freopen("c://test//input.in", "r", stdin); freopen("c://test//output.out", "w", stdout); }
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1, class T2>inline void gmax(T1 &a, T2 b) { if (b>a)a = b; }
template <class T1, class T2>inline void gmin(T1 &a, T2 b) { if (b<a)a = b; }
const int N = 1e5 + 10, M = 5000, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int casenum, casei;
int n, m;
char a[N], b[N], ans[N];
bitset<M>D[26];//D[i]表示字符i在b中出现的位置
bitset<M>L[26];//L[i]表示字符i在b中出现的位置（所有位置都右移一位）
bitset<M>R[26];//R[i]表示字符i在b中出现的位置（所有位置都左移一位）
bitset<M>dp[3];
bitset<M>bef,beh;
int main()
{
	scanf("%d", &casenum);
	for (casei = 1; casei <= casenum; ++casei)
	{
		scanf("%d%d", &n, &m);
		scanf("%s%s", a, b);
		for (int i = 1; i <= n; ++i)ans[i] = '0';
		for (int i = 0; i < 26; ++i)D[i].reset(), L[i].reset(), R[i].reset();
		for (int i = 0; i < m; ++i) 
		{
			int x = b[i] - 'a';
			D[x][i] = 1;
			if(i<4999)L[x][i + 1] = 1;
			if(i)R[x][i - 1] = 1;
		}
		for (int i = 0; i < n; ++i) ans[i] = '0';
		dp[0].reset(); 
		dp[1].reset(); 
		dp[2].reset();

		/*
		dp[i][j][0]=dp[i-1][j-1][2] & (a[i]==b[j-1])
		//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j-1]做匹配

		dp[i][j][1]=dp[i-1][j-1][0] & (a[i]==b[j])
				   |dp[i-1][j-1][1] & (a[i]==b[j])
		//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j]做匹配

		dp[i][j][2]=dp[i-1][j-1][0] & (a[i]==b[j+1])
				   |dp[i-1][j-1][1] & (a[i]==b[j+1])
		//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j+1]做匹配

		这个DP是有for(i)for(j)的
		我们只是把这个DP的for(i)用层层展开滚动数组的形式实现，用bitset来实现for(j)的整体展开
		即，对于位点i，dp这个bitset的j位，如果为1，代表以a[]的位点i为末尾，可以匹配到b[]的位点j
		*/
		for (int i = 0; i < n; ++i) 
		{
			int x = a[i] - 'a';
			bef = (dp[2] << 1);					//dp[j-1][2]
			beh = (dp[1] << 1) | (dp[0] << 1);	//dp[j-1][0] | dp[j-1][1]
			bef[0] = beh[0] = 1;
			dp[0] = bef & L[x];					//dp[0]的意义是，对于a[]的i位点，在匹配b[]的时候，实际是匹配b[]的j-1位点
			dp[1] = beh & D[x];					//dp[1]的意义是，对于a[]的i位点，在匹配b[]的时候，实际是匹配b[]的j位点
			dp[2] = beh & R[x];					//dp[2]的意义是，对于a[]的i位点，在匹配b[]的时候，实际是匹配b[]的j+1位点
			if (dp[1][m - 1] || dp[0][m - 1]) ans[i - m + 1] = '1';
		}
		ans[n] = 0;
		puts(ans);
	}
	return 0;
}
/*
【trick&&吐槽】
这题竟然暴力就够AC了，惊了个呆！

【题意】
给你一个长度为n（1e5）的目标字符串a
我们有一个长度为m（min(5000,n))的基础串b，
对于这个目标字符串，显然有n-m+1个长度为m的子串
问你，在这些子串中，有哪些子串，是可以通过对基础串一些相邻位置的交换，得到的。

即，我们可以选出若干个基础串的若干个位置p[]，使得p[i+1]>p[i]+1，
然后我们swap(p[i],p[i]+1)，就可以实现变形后的基础串与目标字符串的匹配

【类型】
暴力 or bitset

【分析】
尽管暴力可过，但是正解是bitset，我们依然需要学习一下——
这题的暴力做法，其实本身就比较相似于一个DP。

这道题定义f[i][j][k]表示——
a串匹配到位点a[i]
b串匹配到位点b[j]
j这个位置的匹配状态为k（0表示b[j]要与b[j-1]交换，1表示没有交换，2表示b[j+1]交换）

转移方程是这个样子的——
dp[i][j][0]=dp[i-1][j-1][2] & (a[i]==b[j-1])
//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j-1]做匹配

dp[i][j][1]=dp[i-1][j-1][0] & (a[i]==b[j])
           |dp[i-1][j-1][1] & (a[i]==b[j])
//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j]做匹配

dp[i][j][2]=dp[i-1][j-1][0] & (a[i]==b[j+1])
		   |dp[i-1][j-1][1] & (a[i]==b[j+1])
//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j+1]做匹配

=========================================================================

不过该程序的常数巨大，后来还是被加强加版数据卡得TLE了。
我们再来学习另外一种快些的bitset做法，该做法是把a做bitset压位展开的。

我们开bitset<N>bs[3]
再开bitset<N>w[26]
然后w[i]，表示对于字符i，其在a[]串的哪些位置出现。

初始化bs[0][i]都为1，表示匹配b的长度为0的条件下，以i为a[]的匹配起点，都是可以匹配的。
然后我们做m轮次的匹配，每次取出b中的字符。
显然，正常的匹配是这样子的——
bs[nxt]=bs[now]&(w[b[i]]>>i)，即以a[]的每个位置为起点，我们查看每个位置往后走i(i∈[0,m))位的字符，是否依然可以匹配到b串，
不过还存在了交换的匹配方式——
bs[nxt]=bs[pre]&(w[b[i]]>>(i-1))&(w[b[i-1]]>>i)，即考虑交换的匹配。

【时间复杂度&&优化】
O(nm/32)

*/

【HDU5745 2016 Multi-University Training Contest 2L】【bitset高效做法】La Vie en rose 目标串多少子串可以被原始串做相邻交换得到

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre() { freopen("c://test//input.in", "r", stdin); freopen("c://test//output.out", "w", stdout); }
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1, class T2>inline void gmax(T1 &a, T2 b) { if (b>a)a = b; }
template <class T1, class T2>inline void gmin(T1 &a, T2 b) { if (b<a)a = b; }
const int N = 1e5 + 10, M = 5000, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int casenum, casei;
int n, m;
char a[N], b[N], ans[N];
bitset<N>dp[3];
bitset<N>w[26];
int main()
{
	scanf("%d", &casenum);
	for (casei = 1; casei <= casenum; ++casei)
	{
		scanf("%d%d", &n, &m);
		scanf("%s%s", a, b);
		for (int i = 0; i < 26; ++i)w[i].reset();
		for (int i = 0; i < n; ++i)w[a[i] - 'a'][i] = 1;
		dp[0].set();
		dp[1].reset();
		dp[2].reset();
		for (int i = 0; i < m; ++i)
		{
			dp[(i + 1) % 3] = dp[i % 3] & (w[b[i] - 'a'] >> i);
			if (i)
			{
				dp[(i + 1) % 3] |= dp[(i + 2) % 3] & (w[b[i] - 'a'] >> i - 1) &(w[b[i - 1] - 'a'] >> i);
			}
		}
		for (int i = 0; i < n; ++i)ans[i] = '0' + dp[m % 3][i]; ans[n] = 0;
		puts(ans);
	}
	return 0;
}
/*
【trick&&吐槽】
这题竟然暴力就够AC了，惊了个呆！

【题意】
给你一个长度为n（1e5）的目标字符串a
我们有一个长度为m（min(5000,n))的基础串b，
对于这个目标字符串，显然有n-m+1个长度为m的子串
问你，在这些子串中，有哪些子串，是可以通过对基础串一些相邻位置的交换，得到的。

即，我们可以选出若干个基础串的若干个位置p[]，使得p[i+1]>p[i]+1，
然后我们swap(p[i],p[i]+1)，就可以实现变形后的基础串与目标字符串的匹配

【类型】
暴力 or bitset

【分析】
尽管暴力可过，但是正解是bitset，我们依然需要学习一下——
这题的暴力做法，其实本身就比较相似于一个DP。

这道题定义f[i][j][k]表示——
a串匹配到位点a[i]
b串匹配到位点b[j]
j这个位置的匹配状态为k（0表示b[j]要与b[j-1]交换，1表示没有交换，2表示b[j+1]交换）

转移方程是这个样子的——
dp[i][j][0]=dp[i-1][j-1][2] & (a[i]==b[j-1])
//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j-1]做匹配

dp[i][j][1]=dp[i-1][j-1][0] & (a[i]==b[j])
|dp[i-1][j-1][1] & (a[i]==b[j])
//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j]做匹配

dp[i][j][2]=dp[i-1][j-1][0] & (a[i]==b[j+1])
|dp[i-1][j-1][1] & (a[i]==b[j+1])
//a[i-1]与b[0~j-1]匹配了，且a[i]实际要与b[j+1]做匹配

=========================================================================

不过该程序的常数巨大，后来还是被加强加版数据卡得TLE了。
我们再来学习另外一种快些的bitset做法，该做法是把a做bitset压位展开的。

我们开bitset<N>bs[3]
再开bitset<N>w[26]
然后w[i]，表示对于字符i，其在a[]串的哪些位置出现。

初始化bs[0][i]都为1，表示匹配b的长度为0的条件下，以i为a[]的匹配起点，都是可以匹配的。
然后我们做m轮次的匹配，每次取出b中的字符。
显然，正常的匹配是这样子的——
bs[nxt]=bs[now]&(w[b[i]]>>i)，即以a[]的每个位置为起点，我们查看每个位置往后走i(i∈[0,m))位的字符，是否依然可以匹配到b串，
不过还存在了交换的匹配方式——
bs[nxt]=bs[pre]&(w[b[i]]>>(i-1))&(w[b[i-1]]>>i)，即考虑交换的匹配。

【时间复杂度&&优化】
O(nm/32)

*/


snowy_smile
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2019 Multi-University Training Contest 4(2019hdu多校第六场数据与标程）rar
08-11
2019 Multi-University Training Contest 4(2019hdu多校第六场数据与标程）
有2019 Multi-University Training Contest 9，hdu多校第9场的题解.zip
08-19
有2019 Multi-University Training Contest 9，hdu多校第9场的题解，数据标程，有需要的可以下载哦
字符串内位置交换
weixin_38830382的博客
01-19 7623
/** * 字符串内位置交换 * @param target 目标字符串 * @param pos1 位置1 * @param pos2 位置2 * @return 交换位置1 和位置2 后得到的目标字符串(StringIndexOutOfBounds 返回原字符串) */ public static String
[leetcode]87. Scramble String字符串树形颠倒匹配
weixin_30363981的博客
05-18 61
Given a strings1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. Below is one possible representation ofs1="great": great / \ gr ...
CF176B Word Cut
goto_1600的博客
08-28 271
题意：定义一轮操作：对于一个串，从任意地方截断，然后把两部分位置交换得到新的串。 对于aa 串一共进行kk 轮这种操作。 问从aa 串变到bb 串有多少种方法。 f数组定义为操作n次是否变成原串的方案数 需要算出s1经过多少种方式能变成s2 这里有个技巧，如果某个串与目标串不同，他有x次可以转化为目标串，那么目标串有x-1次转化为目标串。 #include<iostream> using namespace std; typedef long long ll; const int mod=1e9
hdu 5745（2016 Multi-University Training Contest 2）
随心丶而遇的博客
07-22 1313
La Vie en rose Time Limit: 14000/7000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 528    Accepted Submission(s): 257 Problem Description Professor Zhang
2019 Multi-University Training Contest 10数据标程.rar
08-22
有2019 Multi-University Training Contest 10的数据和标程，欢迎下载
有2019 Multi-University Training Contest 8数据标程.rar
08-19
有2019 Multi-University Training Contest 8，hdu多校第8场的题解，数据标程，有需要的可以下载哦
2019 Multi-University Training Contest 7数据标程.rar
08-19
有2019 Multi-University Training Contest 7，hdu多校第七场的题解，数据标程，有需要的可以下载哦
【HDU6196 2017 ACM ICPC Asia Regional Shenyang Online C】【爆搜 + 剪枝】happy happy happy 爸爸儿子轮流两头取数 爸爸想输且输少
snowy_smile的博客
09-11 1945
happy happy happy Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 143    Accepted Submission(s): 22 Problem Description Today, Bob
【HDU5583 2015上海赛区K】【暴力合并】Kingdom of Black and White 连续01串权值贡献为len^2最多改变一次最大权值
snowy_smile的博客
11-29 1895
Kingdom of Black and White Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 93    Accepted Submission(s): 41 Problem Description In
【HDU5510 2015沈阳赛区B】【KMP or strstr for循环剪枝】Bazinga 循环处思维灵活转化 时间复杂度均摊思想
snowy_smile的博客
10-31 1881
Bazinga Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 73    Accepted Submission(s): 28 Problem Description Ladies and gentlemen, plea
【Codeforces Round 364 (Div 2)F】【暴力 双连通分量求桥】Break Up n点m边最多割2边最小成本使得S与T不联通
snowy_smile的博客
07-26 1767
F. Break Up time limit per test 3 seconds memory limit per test 256 megabytes input standard input output standard output Again, there are hard times in Berland! Many to
【Code Forces 320D】【贪心+暴力】 "Or" Game 数列乘k次x后求最大or值
snowy_smile的博客
09-17 1748
数列乘k次x后求最大or值
【ZOJ3948 The 17th Zhejiang University Programming Contest A】【暴力 or 讨论】Marjar Cola 瓶盖饮料换可乐
snowy_smile的博客
04-12 1623
Marjar Cola Time Limit: 1 Second      Memory Limit: 65536 KB Marjar Cola is on sale now! In order to attract more customers, Edward, the boss of Marjar Company, decides to launch a promotion: If
【ASC45D】【构造 电阻网络法+暴力冲精度法+比例转换法】醉汉走路二分叉 回家概率恰为p/q
snowy_smile的博客
10-31 1442
【ASC45D】【构造】方法一之电阻网络法 WIKI Gambler's ruin #include #include #include #include #include #include #include #include #include #include #include #include #include #define MS(x,y) memset(x,y,sizeof(x))
【Codeforces Round 272 (Div 2)C】【暴力】Dreamoon and Sums 所有除b结果是模b结果[1,a]倍数字之和
snowy_smile的博客
12-25 1181
C. Dreamoon and Sums time limit per test 1.5 seconds memory limit per test 256 megabytes input standard input output standard output Dreamoon loves summing up something fo
【2016杭电女生赛1003】【暴力】Luck Competition 选数平均数乘2除3 小且最接近的数
snowy_smile的博客
05-22 1123
#include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; void fre() { freopen("c://test//input.in", "r", stdin
A - LOOPS HDU - 3853
最新发布
07-28
回答: 引用\[1\]和引用\[2\]是关于解决HDU - 3853问题的AC代码。这段代码使用了动态规划的思路，通过计算每个点的期望能量来解决问题。其中，f\[i\]\[j\]表示走到(i, j)这个点的期望能量。代码中还有一些特殊情况的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值