Bupt summer training for 2013_String

最新推荐文章于 2018-04-04 00:49:34 发布
最新推荐文章于 2018-04-04 00:49:34 发布
阅读量691 收藏
点赞数
分类专栏： 搜索 前缀 & 后缀 文章标签： bupt ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013007900/article/details/38391037
版权 
A - Crazy Search(POJ 1200)

解题思路：

还有什么比离散化之后直接hash解决简单粗暴的呢？

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define eps 1e-9
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
template<class T>
inline bool read(T &n)
{
T x = 0, tmp = 1; char c = getchar();
while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if(c == EOF) return false;
if(c == '-') c = getchar(), tmp = -1;
while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
n = x*tmp;
return true;
}
template <class T>
inline void write(T n)
{
if(n < 0)
{
putchar('-');
n = -n;
}
int len = 0,data[20];
while(n)
{
data[len++] = n%10;
n /= 10;
}
if(!len) data[len++] = 0;
while(len--) putchar(data[len]+48);
}
//-----------------------------------
const int MAXN=16000010;
const int MOD=100007;
char str[MAXN];
bool hash[10000000];
int ansi[256];
int main()
{
int n,nc;
while(read(n)&&read(nc))
{
int ans=0;
gets(str);
memset(hash,0,sizeof(hash));
memset(ansi,0,sizeof(ansi));
int len=strlen(str);
for(int i=0;i<len;i++)
ansi[str[i]]=1;
int cnt=0;
for(int i=0;i<256;i++)
if(ansi[i])
ansi[i]=cnt++;
for(int i=0;i<len-n+1;i++)
{
ull sum=0;
for(int j=i;j<i+n;j++)
sum=sum*nc+ansi[str[j]];
if(!hash[sum])
{
ans++;
hash[sum]=true;
}
}
write(ans);
putchar('\n');
}
return 0;
}
B - Power Strings

利用KMP的失配函数，将自己作为模板链进行匹配

然后根据失配数组的性质计算出向前移动几位数字使得字符串匹配

则移动的数字就是循环节


#include <algorithm>
#include <iostream>
include <cstring>
#include <iomanip>
##include <climits>
#include <complex>
include <cstdio>
#
#include <fstream>
#include <cassert>
#include <bitset>
#include <vector>
#include <deque>
nclude <set>
#in
#include <queue>
#include <stack>
#include <ctime>
#
iclude <map>
#include <cmath>
#define EPS 1e-10
namespace std;
temp
#define INF 0x3f3f3f3f
#define ll __int64
usin
glate<class T>
inline bool read(T &n)
{
;
while((c < '0' || c > '9') && c !=
T x = 0, tmp = 1; char c = getchar(
)'-' && c != EOF) c = getchar();
if(c == EOF) return false;
c <= '9') x *= 10, x += (c - '0'),c = get
if(c == '-') c = getchar(), tmp = -1;
while(c >= '0' &&
char();
n = x*tmp;
return true;
}

-----------------------------const int MAXN=10000010; char str[MAXN];
-----------------------------
const int MAXN=10000010;
char str[MAXN];
//-----------------------------------------
-
int next[MAXN];
int getFail()
{
next[0]=next[1]=0;
int n=strlen(str);
for(int i=1;i<n;i++)
{
xt[n]>0&&n%(n-next
int j=next[i];
while(j&&str[i]!=str[j])
j=next[j];
next[i+1]=str[i]==str[j]?j+1:0;
}
if(n
e[n])==0)
return n/(n-next[n]);
else
return 1;
}
int main()
{
while(scanf("%s",str)!=EOF)
{
if(str[0] == '.')
continue;
printf("%d\n",getFail());
}
return 0;
}

C - Colored Sticks

Trie树+并查集+欧拉回路

将所有出现过的字符串插入Trie树，并返回编号

将所有颜色的编号用并查集维护起来，并且记录编号的入度

最后查看有多少点不在并查集中，以及欧拉回路的入度奇偶性


#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define CLR(x,y) memset(x,y,sizeof(x))
#define eps 1e-9
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
template<class T>
inline bool read(T &n)
{
T x = 0, tmp = 1; char c = getchar();
while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if(c == EOF) return false;
if(c == '-') c = getchar(), tmp = -1;
while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
n = x*tmp;
return true;
}
template <class T>
inline void write(T n)
{
if(n < 0)
{
putchar('-');
n = -n;
}
int len = 0,data[20];
while(n)
{
data[len++] = n%10;
n /= 10;
}
if(!len) data[len++] = 0;
while(len--) putchar(data[len]+48);
}
//-----------------------------------
const int MAXN=500005;
struct Trie
{
int child[MAXN*10][26],root;
int flag[MAXN*10];
int sz;
int idx(char c) { return c-'a'; }
Trie()
{
root=sz=1;CLR(child[1],0);flag[1]=0;
}
void insert(const char *str,const int v)
{
int *cur=&root;
for(const char *p=str;*p;p++)
{
cur=&child[*cur][idx(*p)];
if(*cur==0)
{
*cur=++sz;
CLR(child[sz],0);
flag[*cur]=0;
}
}
flag[*cur]=v;
}
int find(const char *str)
{
int *cur=&root;
for(const char *p=str;*p && *cur;p++)
cur=&child[*cur][idx(*p)];
if(*cur==0)
return 0;
return flag[*cur];
}
}trie;
int fa[MAXN];
int find_fa(int x)
{
if(fa[x]==x)
return x;
else
return fa[x]=find_fa(fa[x]);
}
void Merge(int x,int y)
{
int xx=find_fa(x),yy=find_fa(y);
fa[xx]=yy;
}
char a[20],b[20];
int deg[MAXN];
void init()
{
for(int i=1;i<MAXN;i++)
fa[i]=i,deg[i]=0;
}
bool check(int cnt)
{
int euler=0;
int father=0,fath=find_fa(1);
for(int i=1;i<cnt;i++)
{
euler+=(deg[i]&1);
father+=( find_fa(i)!=fath );
}
return father || euler>2;
}
int main()
{
// freopen("data.txt","r",stdin);
int cnt=1;
init();
while(scanf("%s %s",a,b)!=EOF)
{
int s=trie.find(a);
if(!s)
{
trie.insert(a,cnt);
s=cnt++;
}
int t=trie.find(b);
if(!t)
{
trie.insert(b,cnt);
t=cnt++;
}
if(find_fa(s)!=find_fa(t))
Merge(s,t);
deg[s]++;
deg[t]++;
}
if(check(cnt))
puts("Impossible");
else
puts("Possible");
return 0;
}
D - DNA repair

解题思路以及见：http://blog.csdn.net/u013007900/article/details/38490739

E - Kindergarten

这题和字符串没啥关系吧？

本题是要求图中的最大完全子图（最大团）中顶点的个数（最大团的规模 或 称为 最大完全数）。普通图的最大团则是一个NP问题，目测是要暴力枚举。

由于原图的补图是一个二分图，其 最大完全数 等价于其补图的最大独立集中元素的个数，于是可以根据二分图的性质求出这个最大独立集。

定理：

二分图最大独立集=顶点数 - 二分图最大匹配

最大完全数 = 原图补图的 最大独立集的规模

概念：

最大完全子图：每个点都两两相连，共有 n * ( n-1 )  / 2 条边，又称为最大团

最大完全数：图中最大完全子图的顶点个数，又称为最大团的规模

独立集：图中任意两个顶点都不相连的顶点集合，可以理解为孤立点的集合

补图：原来图连边的不连，不连边的连边，形成的新图称为补图

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define CLR(x,y) memset(x,y,sizeof(x))
#define eps 1e-9
#define INF 0x3f3f3f3f

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=210;

bool mapp[MAXN][MAXN];
int from[MAXN],G,B,m;
bool used[MAXN];

bool match(int x)
{
	for(int i=1;i<=B;i++)
		if(mapp[x][i] && !used[i])
		{
			used[i]=true;
			if(from[i]==-1 || match(from[i]))
			{
				from[i]=x;
				return true;
			}
		}
	return false;
}

int hungry()
{
	int tot=0;
	CLR(from,-1);
	for(int i=1;i<=G;i++)
	{
		CLR(used,0);
		if(match(i))
			tot++;
	}
	return tot;
}


int main()
{
    freopen("data.txt","r",stdin);
    int Cas=1;
	while(read(G)&&read(B)&&read(m)&&G&&B&&m)
	{
	    for(int i=1;i<=G;i++)
            for(int j=1;j<=B;j++)
                mapp[i][j]=true;
		int u,v;
		for(int i=0;i<m;i++)
		{
			read(u),read(v);
			mapp[u][v]=false;
		}
		printf("Case %d: %d\n",Cas++,B+G-hungry());
	}
	return 0;
}

























Trie树+并查集+欧拉回路

将所有出现过的字符串插入Trie树，并返回编号

将所有颜色的编号用并查集维护起来，并且记录编号的入度

最后查看有多少点不在并查集中，以及欧拉回路的入度奇偶性


SuPhoebe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BUPT_transform.zip_BUPT__BUPT_transform_bupt matlab
07-14
本源码结合了rotate和skew，既可以单独执行rorate或者skew，也可以改变此两种方法的顺序来研究不同转换顺序带来的不同结果
BUPT Summer Training 2（2013长沙邀请赛） 7.05 总结
Tri_integral的专栏
07-06 1068
题目是长沙邀请赛的，当时他们回来的时候说几乎全是数学题，不知道我们去会怎么样，今天终于要打了。 上来先看到A题，跟之前ss和hq的组合数学期末考试最后一题一模一样，只不过a、b都为2、3，m为10,n为偶数，所以可以手算。但是这题强化版的大家一时都想不出来，于是她们来看A，我去看E。 E题正巧是我学的信安数学基础里面的一道公式题（中国剩余定理不能合并两条模数不互质的式子），高次同余式求解，但是
bupt summer training for 16 #2 ——计算几何
weixin_33725126的博客
07-19 81
https://vjudge.net/contest/171368#overview A.一个签到题，用叉积来判断一个点在一条线的哪个方向 可以二分，数据范围允许暴力 1 #include <cstdio> 2 3 struct point { 4 int x, y; 5 }a[5010]; 6 7 int n, m, x[2]...
BUPT-SUMMER-TRAINING-搜索
Mr.Phoebe的专栏
07-24 715
比赛地址 A - Sticks 剪枝
「CodeForces - 598B」Queries on a String
weixin_33843947的博客
07-19 70
BUPT 2017 summer training (for 16) #1I 题意 字符串s（1 ≤ |s| ≤ 10 000），有m（1 ≤ m ≤ 300）次操作，每次给l,r,k，代表将r位置插入l位置前，执行k（1 ≤ k ≤ 1 000 000）次。输出最后的s。 题解 等价与将字符串的[l...r-k]和[r-k+1...r]两部分调换一下。 k对r-l取模一下。然后模拟。 还有种方法...
sw.zip_BUPT_lowpass_pcm java
09-23
多媒体中的图像处理的coursework，里面有从基本到复杂的高斯噪音处理和PGM，PCM的应用。
lib_bupt.tar.gz_AVRX
09-24
AVR单片机下，集成了实时内核的一个库 含有稳定的串口通信，I2C通信的通用函数
datalink_BUPT_计网大作业_滑动窗口协议_
09-29
北邮计算机网络大作业滑动窗口协议，都已经搜到这里来了，懂的都懂。
BUPT_IS_Bank
05-17
BUPT_IS_Bank:A Simple Banking System author: Ty.Wings E-mail: 这是之前我写的软工Case Study（EBU_5304），目前看来每年的Case Study应该都是银行系统，甚至连要求都没有改。希望对学弟学妹和需要类似JAVA ...
4和7是一个幸运数字
Mr.Phoebe的专栏
04-04 6725
一个比较有趣的面试题 题意： 仅由4和7组成的十进制数字被称为幸运数字，如，4，7，44，47。 那么仅由幸运数字乘积得到的数字为超级幸运数字，如，28 = 4 * 7。 现在给你两个数字表示上下限，让你求这段区间内有多少个超级幸运数字。总共有1000组查询，上下限最多到1012101210^{12}。 思路： 第一想法是容斥搞一下，但是其实非常难，因为除了爆搜很难去构造出仅由幸运数字...
BUPT 2014新生暑假个人排位赛11
Mr.Phoebe的专栏
08-06 1493
488. 小妹妹个数
Poj 1112 Team Them Up!
Mr.Phoebe的专栏
08-12 1076
首先分析这道题目，题目给出的是一个有向图，即如果有A认识B，但不一定有B认识A。但是在所分配的组里面，任意两个人都要互相认识。 1、 先读入数据建立有向图，然后对这个有向图进行处理，如果两个点之间的边是单向边，就认为两个点之间无边（因为这两个人不互相认识），对于两个点间的双向边，即建立一条无向边（这两个人互相认识），这样就可以把一个有向图转化为一个无向图。 2、 将这个无向图转化为它的
Gym 100339A Bike Roads
Mr.Phoebe的专栏
02-11 1075
Andrew Stankevich Contest 23 Petrozavodsk, February 1, 2007 Problem A. Bike Roads Andrew lives at countryside. The area he lives at has two bike roads, each of which has the form of acircle
HDU 5025 Saving Tang Monk
Mr.Phoebe的专栏
09-20 986
//By LH #include #include #include #include using namespace std; const int dx[4] = {0, 1, 0, -1}; const int dy[4] = {1, 0, -1, 0}; int n, m, sx, sy, ex, ey, ans; char a[102][102]; bool v[102][102][1
HDU 5352 MZL's City
Mr.Phoebe的专栏
08-05 900
题意： 给你n个点，m次操作，和整数k 1操作，每次可以修复k个属于x所在连通块内的点 2操作，修复x与y之间的路，双向边 3操作，给你一个p，表示有p条路被毁坏了 思路： 其实说实话，如果没有想到关键部分，个人觉得不是特别好做。 第一想法比较接近于网络流或者贪心，但是因为要删边，所以很多人觉得网络流不能解决。 之后看了题解之后
BUPT2014新生暑假个人排位赛07
Mr.Phoebe的专栏
07-28 794
B469. 暑假作业题
HDU 5385 The path
Mr.Phoebe的专栏
08-13 747
如果我们知道每个点的disdis值和最短路径树的话，方案是很容易构造的我们可以采取贪心做法，一开始将11号点作为最短路径树的根，然后左边从22开始，右边从nn开始，只要之前加入的点有边连向他们就加入这样一个点加入的时间就是他的disdis值，最短路径树上的父亲也可以确定，于是输出时非树边长度为nn，树边长度为两个端点disdis之差。// whn6325689 // Mr.Pho
UVALIVE 4887 Soccer && UVELIVE 4882
Mr.Phoebe的专栏
02-25 718
2015 UESTC Winter Training #6 训练赛的两道搜索模拟题 uvalive 4882 // whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include #include #include #include #include #include #include
bupt[email protected]
最新发布
11-26
bupt[email protected]是北京邮电大学学生李三的电子邮箱地址。bu为北京邮电大学的缩写，pt为邮电的拼音首字母，lisan为李三的英文名。163.com为电子邮箱的域名，代表该邮箱是在163.com域名下注册的。通过这个邮箱地址...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值