SPOJ7258--SUBLEX(SAM)

最新推荐文章于 2019-01-16 22:56:00 发布
最新推荐文章于 2019-01-16 22:56:00 发布
阅读量759 收藏
点赞数
分类专栏： 字符串_后缀自动机 文章标签： SPOJ7258
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scut_pein/article/details/14533821
版权
转载请注明出处，谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=contents     by---cxlove  

题目：给出一个串，查询字典序排在第k个的是哪个子串

http://www.spoj.pl/problems/SUBLEX/

由于SAM能遍历所有的子串，只要预处理出某个结点的后继中有多少个不同的子串就可以了。

首先以每个结点为终态算一个子串，所以初始化计数为1。

然后按照拓扑序，用后继更新pre。类似数DP那种。

SPOJ很卡时，需要各种优化，首先是经典的拓扑。

一次预处理，把后继全部存好，以为相应的字母。

有个地方需要注意，在查询的时候，有个k--。因为以当前字母结束也是一个子串，所以需要减掉

 

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<queue>
#define inf 100000005
#define M 40
#define N 200015
#define maxn 300005
#define eps 1e-10
#define zero(a) fabs(a)<eps
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define mem(a,b) memset(a,b,sizeof(a))
#define LL unsigned long long
#define MOD 1000000007
#define lson step<<1
#define rson step<<1|1
#define sqr(a) ((double)(a)*(a))
#define Key_value ch[ch[root][1]][0]
#define test puts("OK");
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct SAM
{
    SAM *pre,*son[26];
    int len,cnt;
}*root,*tail,que[N],*b[N];
char str[N/2];
int son[N][26],cnt[N];
int tot=0;
int c[N];
char ch[N][26];
void add(int c,int l)
{
    SAM *p=tail,*np=&que[tot++];
    np->len=l;
    while(p&&p->son[c]==NULL) p->son[c]=np,p=p->pre;
    if(p==NULL) np->pre=root;
    else
    {
        SAM *q=p->son[c];
        if(p->len+1==q->len) np->pre=q;
        else
        {
            SAM *nq=&que[tot++];
            *nq=*q;
            nq->len=p->len+1;
            np->pre=q->pre=nq;
            while(p&&p->son[c]==q) p->son[c]=nq,p=p->pre;
        }
    }
    tail=np;
}
void slove(int k)
{
    int l=0;
    int now=0;
    while(k)
    {
        for(int i=0;i<cnt[now];i++)
        {
            if(k>que[son[now][i]].cnt)
            {
                k-=que[son[now][i]].cnt;
            }
            else
            {
                str[l++]=ch[now][i];
                now=son[now][i];
                k--;
                break;
            }
        }
    }
    str[l]='\0';
    puts(str);
}
int main()
{
    root=tail=&que[tot++];
    scanf("%s",str);
    int l=strlen(str);
    for(int i=0;str[i];i++) add(str[i]-'a',i+1);
    for(int i=0;i<tot;i++) c[que[i].len]++;
    for(int i=1;i<tot;i++) c[i]+=c[i-1];
    for(int i=0;i<tot;i++) b[--c[que[i].len]]=&que[i];
    for(int i=0;i<tot;i++) que[i].cnt=1;
    for(int i=tot-1;i>=0;i--)
    {
        SAM *p=b[i];
        for(int j=0;j<26;j++)
        {
            if(p->son[j])
            {
                int u=p-que,v=p->son[j]-que;
                son[u][cnt[u]]=v;
                ch[u][cnt[u]++]=j+'a';
                p->cnt+=p->son[j]->cnt;
            }
        }
    }
    int q,k;
    scanf("%d",&q);
    while(q--)
    {
        scanf("%d",&k);
        slove(k);
    }
    return 0;
}

 

自己的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 90080
#define LL long long int
char str[maxn],ans[maxn];
int pos = 0;
struct SAM
{
    SAM *pre,*son[26];
    int len,sonnum,Son[26];
	char ch[26];
	LL g;
}que[maxn<<1],*root,*tail,*b[maxn<<1];
int tot;
int C[maxn<<1];
void add(int c,int l)
{
    SAM *p=tail,*np=&que[tot++];
    np->len=l;	tail=np;
    while(p&&p->son[c]==NULL) p->son[c]=np,p=p->pre;
    if(p==NULL) 
	{
		np->pre=root;
	}
    else
    {
        SAM *q=p->son[c];
        if(p->len+1==q->len) 
		{
			np->pre=q;
		}
        else
        {
            SAM *nq=&que[tot++];
            *nq=*q;
            nq->len=p->len+1;
            np->pre=q->pre=nq;
            while(p&&p->son[c]==q) p->son[c]=nq,p=p->pre;
        }
    }
}

void init(int n)
{
	tot = 0;pos = 0;
	/*for(int i = 0;i < n;i++)
	{
		que[i].g = 0;	que[i].pre = NULL;	que[i].sonnum = 0;
		for(int j = 0;j < 26;j++)	
		{
			que[i].son[j] = NULL;
		}
		memset(que[i].son,0,sizeof(que[i].son));
	}*/
	root = tail = &que[tot++];
	//memset(C,0,sizeof(C));
}

inline int max(int a,int b)
{
	return a>b?a:b;
}

void dfs(SAM * now,int k)
{
	if(k == 0)	return;
	for(int i = 0;i < now -> sonnum;i++)
	{
		if(now -> son[now -> Son[i]] -> g >= k)
		{
			ans[pos++] = now -> ch[i];
			dfs(now -> son[now ->Son[i]],k-1);
			return;
		}
		else k -= now -> son[now -> Son[i]] -> g;
	}
}

int main()
{
	//freopen("in.txt","r",stdin);
	scanf("%s",str);
		int len = strlen(str);
		init(len << 1);/
		for(int i = 0;i < len;i++)
		{
			add(str[i] - 'a',i + 1);
		}//
		for(int i = 0;i < tot;i++)	C[que[i].len]++;///
		for(int i = 1;i <= len;i++)	C[i] += C[i-1];//
		for(int i = 0;i < tot;i++)	b[--C[que[i].len]] = &que[i];
		for(int i = 0;i < tot;i++)	que[i].g = 1;///
		for(int i = tot-1;i >= 0;i--)
		{
			for(int j = 0;j < 26;j++)
			{
				if(b[i]->son[j])	
				{
					b[i] -> Son[b[i]->sonnum] = j;
					b[i] -> ch[b[i]->sonnum] = j+'a';
					b[i] -> sonnum++;
					b[i] -> g += b[i] -> son[j] -> g;
				}
			}
		}/
		int q;
		scanf("%d",&q);
		while(q--)
		{
			int k;
			scanf("%d",&k);
			pos = 0;
			dfs(&que[0],k);
			ans[pos++] = '\0';
			printf("%s\n",ans);
		}
	return 0;
}


 


#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 90080
#define LL long long int
char str[maxn],ans[maxn];
int pos = 0;
struct SAM
{
    SAM *pre,*son[26];
    int len,sonnum,Son[26];
	char ch[26];
	LL g;
}que[maxn<<1],*root,*tail,*b[maxn<<1];
int tot;
int C[maxn<<1];
void add(int c,int l)
{
    SAM *p=tail,*np=&que[tot++];
    np->len=l;	tail=np;
    while(p&&p->son[c]==NULL) p->son[c]=np,p=p->pre;
    if(p==NULL) 
	{
		np->pre=root;
	}
    else
    {
        SAM *q=p->son[c];
        if(p->len+1==q->len) 
		{
			np->pre=q;
		}
        else
        {
            SAM *nq=&que[tot++];
            *nq=*q;
            nq->len=p->len+1;
            np->pre=q->pre=nq;
            while(p&&p->son[c]==q) p->son[c]=nq,p=p->pre;
        }
    }
}

void init(int n)
{
	tot = 0;pos = 0;
	/*for(int i = 0;i < n;i++)
	{
		que[i].g = 0;	que[i].pre = NULL;	que[i].sonnum = 0;
		for(int j = 0;j < 26;j++)	
		{
			que[i].son[j] = NULL;
		}
		memset(que[i].son,0,sizeof(que[i].son));
	}*/
	root = tail = &que[tot++];
	//memset(C,0,sizeof(C));
}

inline int max(int a,int b)
{
	return a>b?a:b;
}

void dfs(SAM * now,int k)
{
	if(k == 0)	return;
	for(int i = 0;i < now -> sonnum;i++)
	{
		if(now -> son[now -> Son[i]] -> g >= k)
		{
			ans[pos++] = now -> ch[i];
			dfs(now -> son[now ->Son[i]],k-1);
			return;
		}
		else k -= now -> son[now -> Son[i]] -> g;
	}
}

int main()
{
	//freopen("in.txt","r",stdin);
	scanf("%s",str);
		int len = strlen(str);
		init(len << 1);/
		for(int i = 0;i < len;i++)
		{
			add(str[i] - 'a',i + 1);
		}//
		for(int i = 0;i < tot;i++)	C[que[i].len]++;///
		for(int i = 1;i <= len;i++)	C[i] += C[i-1];//
		for(int i = 0;i < tot;i++)	b[--C[que[i].len]] = &que[i];
		for(int i = 0;i < tot;i++)	que[i].g = 1;///
		for(int i = tot-1;i >= 0;i--)
		{
			for(int j = 0;j < 26;j++)
			{
				if(b[i]->son[j])	
				{
					b[i] -> Son[b[i]->sonnum] = j;
					b[i] -> ch[b[i]->sonnum] = j+'a';
					b[i] -> sonnum++;
					b[i] -> g += b[i] -> son[j] -> g;
				}
			}
		}/
		int q;
		scanf("%d",&q);
		while(q--)
		{
			int k;
			scanf("%d",&k);
			pos = 0;
			dfs(&que[0],k);
			ans[pos++] = '\0';
			printf("%s\n",ans);
		}
	return 0;
}


 


 

SCUT_Pein
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SPOJ Tool-crx插件
03-10
隐藏网站评论的工具。 隐藏该问题的注释和标签的扩展名。 支持语言:English
spoj-codechef-codeforces:终极备份
06-21
竞技编程这个 repo 包含（几乎）所有程序： codechef.com codeforces.com 间谍网黑客等级网Hande : sananth12 在所有平台上统计数据代码总行数：22,410+ 程序总数：500+
spoj7258：Lexicographical Substring Search 后缀自动机
ws_fqk
03-23 700
经典题，找不重复字典序第kk小的字符串。 先跑出SAM，然后在SAM上DP。 因为从SAM的起点跑可以跑出所有的子串，所以我们用dpidp_i表示从ii点出发跑出的子串的个数，显然有 dpi=∑j=azdpchi,j+1dp_i=\sum_{j=a}^z dp_{ch_{i,j}}+1然后每次按照a..za..z的顺序从起点开始dfsdfs，如果沿chi,jch_{i,j}的方向走下去的个数≤
POJ-1741 Tree（树分治）
十分残念的博客
07-14 1118
Tree Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 22767   Accepted: 7527 Description Give a tree with n vertices,each edge has a length(positive integer
spoj7258
lyc
03-20 933
此题是求第k大子串 因为自动机本身就包含所有的子串，然后边又是有字典序的，且我们可以通过dp知道某个节点后可以拓展出多少个子串 由于每个节点都是自己的子串，所以初始化计数的时候为1 那么我预处理出各个点与k的关系，然后在自动机上跑的话就直接字典序，边跑边判K，然后这样输出就好了 扫到最后的时候需要k--因为本身也是一个串 还是用top扫 我们可以建一颗类似于字典树的扫描，那么对
SPOJ 7258 SUBLEX （SAM）
窝不是爱酱,喵~~~~
11-27 3233
转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents    by---cxlove    题目：给出一个串，查询字典序排在第k个的是哪个子串 http://www.spoj.pl/problems/SUBLEX/  由于SAM能遍历所有的子串，只要预处理出某个结点的后继中有多少个不同的子串就可以了。
SPOJ7258(后缀自动机--第k大的子串)
ACdreamer
09-01 3238
题目：http://www.spoj.com/problems/SUBLEX/   题意：给一个字符串，然后给Q个询问，每个询问输入一个数K，输出子串中字典序为K的字符串。 #include #include #include #include using namespace std; const int N=250005; struct State {
SPOJ-2.zip_SPOJ_SPOJ-TRIKA.cpp_online judge_sPOJ-Solution_spoj2
09-24
Some Solution of Problem in SPOJ (Sphere Online Judge) solved in various algorithm.
SPOJ-solutions:最好的
03-26
SPOJ解决方案 最好的：我的SPOJ
SPOJ7258
weixin_30509393的博客
02-20 85
传送门 这题可以参考平衡树求第k大的过程，需要预处理一下从当前节点往下走能走出多少个子串。 原本准备存个图用反向的topsort，发现极为麻烦，看了别人的代码后发现，他们按step大小用了基排，省了很多麻烦。 仔细看了一下构造过程，貌似确实有这样的性质，后创建且step大的节点在fail树上处于儿子的地位，在原图上处于被转移点的地位。 如果性质成立，那么这里也就说得通了。 #incl...
SPOJ7258 SUBLEX 后缀自动机
forever_shi的博客
12-02 178
题目链接 链接是洛谷有翻译的链接。 题意： 给你一个字符串，有T次询问，每次问你在整个字符串中排名为k的子串是哪一个。字符串长度&amp;lt;=90000，T&amp;lt;=500，只统计本质不同的串。 题解： 后缀自动机题，因为后缀自动机有着很强的处理子串的能力。 看到排名第k，我们可能会想到主席树，但是显然主席树是没法维护具体某个字符串，但是主席树查询第k大的思想我们是可以使用的。主席树的方法是看左子树的...
【SPOJ】7258. Lexicographical Substring Search（后缀自动机）
12-05 86
http://www.spoj.com/problems/SUBLEX/ 后缀自动机系列完成QAQ。。。撒花。。明天or今晚写个小结？ 首先得知道：后缀自动机中，root出发到任意一个状态的路径对应一个子串，而且不重复。（原因似乎是逆序后缀树？ 所以我们在自动机上预处理每一个状态的子串数目，然后从小到大枚举字符。 子串数目可以这样预处理出：s[x]=sum{s[y]}+1, y是...
spoj7258 SUBLEX Lexicographical Substring Search
Elijahqi
04-10 212
http://www.elijahqi.win/archives/3001 题意翻译 给定一个字符串，求排名第k小的串 注意样例的\n是换行 输入格式： 第一行给定主串(len&lt;=90000) 第二行给定询问个数T&lt;=500 随后给出T行T个询问，每次询问排名第k小的串，范围在int内 输出格式： 对于每一个询问，输出T行，每行为排名第k小的串 感谢@Creeper...
SPOJ 7258 SUBLEX 后缀数组_二分答案_前缀和
EM LGH
01-16 139
SPOJ 7258 SUBLEX 后缀数组_二分答案_前缀和 Code: #include &lt;cstdio&gt; #include &lt;algorithm&gt; #include &lt;cstring&gt; #define setIO(s) freopen(s".in","r",stdin) #define maxn 10000...
SPOJ7258 SUBLEX - Lexicographical Substring Search(后缀自动机)
weixin_34334744的博客
06-28 86
Little Daniel loves to play with strings! He always finds different ways to have fun with strings! Knowing that, his friend Kinan decided to test his skills so he gave him a string S and asked him Q q...
spoj 7258
weixin_30808693的博客
01-10 96
Lexicographical Substring Search Time Limit: 1000MS Memory Limit: Unknown 64bit IO Format: %lld & %llu Description Little Daniel loves to play with strings! He always finds...
[SPOJ7258]SUBLEX - Lexicographical Substring Search
srand(time(0))
04-04 460
后缀自动机
SPOJ 7258 SUBLEX - Lexicographical Substring Search （后缀自动机）
clover_hxy的博客
12-20 699
P2675【后缀自动机】第k小子串I Time Limit : 10000 MS   Memory Limit : 123456 KB Description 给定一个字符串s，每次提问它的第k小子串。 如果某个字符串再s中重复出现，将其看做一个子串。 Input Format 第一行一个字符串s. 第二行一
洛谷SPOJ如何注册
最新发布
07-27
2. 在网站顶部导航栏中找到“题库”选项，将鼠标悬停在上面，然后选择“SPOJ”。 3. 在SPOJ页面上，您会看到一个提示，要求您注册SPOJ账号并进行绑定。点击提示中的链接，将会跳转到SPOJ注册页面。 4. 在SPOJ注册...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值