bzoj4231 回忆树（AC自动机+fail树+KMP(+树状数组)）

最新推荐文章于 2022-06-15 23:16:32 发布
最新推荐文章于 2022-06-15 23:16:32 发布
阅读量962 收藏 1
点赞数
分类专栏： 数据结构 & 图论 # 树状数组 ---------------字符串 AC自动机 fail树 题解 思维题 bzoj 树链剖分 文章标签： 字符串 AC自动机 bzoj KMP 树状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bfk_zr/article/details/79266701
版权
题解 同时被 3 个专栏收录
150 篇文章 0 订阅
订阅专栏
bzoj
83 篇文章 0 订阅
订阅专栏
数据结构 & 图论
64 篇文章 0 订阅
订阅专栏

bzoj4231 回忆树

原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=3881

题意：
回忆树是树。
具体来说，是n个点n-1条边的无向连通图，点标号为1~n，每条边上有一个字符（出于简化目的，我们认为只有小写字母）。
对一棵回忆树来说，回忆当然是少不了的。
一次回忆是这样的：你想起过往，触及心底…唔,不对，我们要说题目。
这题中我们认为回忆是这样的：给定2个点u，v(u可能等于v)和一个非空字符串s，问从u到v的简单路径上的所有边按照到u的距离从小到大的顺序排列后，边上的字符依次拼接形成的字符串中给定的串s出现了多少次。

数据范围
n<=100000，m<=100000，询问串的总长<=300000

题解：
好题…
要求字符串在一条链上匹配多少次，对回忆树建树是没有办法的，不能像bzoj3926那样每个叶子提出来建一棵Trie。
于是这道题是离线，对要查询的串（的正串和反串）建AC自动机。

同样，A包含串B多少次，就是A在AC自动机上的每个节点，有多少在B结尾节点的fail树子树中。
于是，DFS原树的同时，在AC自动机上匹配，

由于链是要拐弯的，同时还有方向，这个不好处理，于是把一条链拆成三部分：
拐弯处：长度为2|T|，用KMP暴力匹配
剩下的两段一个是正着匹配，一个是倒着，于是询问串需要把正反串都插入AC自动机，

于是询问都变成了从根到某个点路径的一部分（直了…），就可以一边dfs一边处理了。

就如同天天爱跑步的处理方式，在对应的起始端点push进这个询问，以及是需要加还是减，查询的是fail树的哪个子树。

然后在DFS原树同时在AC自动机上转移时，进入这个点把AC自动机上对应点+1，离开时-1，
询问就是查询fail树子树权值和。

代码： 

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int N=110005;
const int M=300015;
queue<int> Q;
vector<int> V[N],ID[N];
char str[M];
namespace AC
{
    int ch[2*M][26],root,tail,head[2*M],nxt[2*M],to[2*M],num,fail[2*M];
    int in[2*N],out[2*M],inc,C[2*M];
    inline void build(int u,int v) {num++; to[num]=v; nxt[num]=head[u]; head[u]=num; inc=0;}
    inline void init(){root=1,tail=1,num=0;}
    inline int insert(int opt)
    {
        int len=strlen(str); int tmp=root;
        for(int j=0,i;j<len;j++)
        {
            if(opt==1) i=j; else i=len-j-1;
            int c=str[i]-'a';
            if(!ch[tmp][c]) ch[tmp][c]=++tail;
            tmp=ch[tmp][c];
        }
        return tmp;
    }
    inline void getfail()
    {
        for(int i=0;i<26;i++) if(ch[root][i]) fail[ch[root][i]]=root,build(root,ch[root][i]),Q.push(ch[root][i]); else ch[root][i]=root;
        while(!Q.empty())
        {
            int top=Q.front(); Q.pop();
            for(int i=0;i<26;i++)
            {
                if(!ch[top][i]) ch[top][i]=ch[fail[top]][i];
                else
                {
                    int u=ch[top][i];
                    fail[u]=ch[fail[top]][i];
                    build(fail[u],u);
                    Q.push(u);
                }
            }
        }       
    }
    inline void dfs(int u)
    {
        inc++; in[u]=inc;
        for(int i=head[u];i;i=nxt[i]) dfs(to[i]);
        out[u]=inc;
    }
    inline void add(int x,int d){for(int i=x;i<=inc;i=i+(i&(-i))) C[i]+=d;}
    inline int query(int x){int ret=0;for(int i=x;i;i=i-(i&(-i))) ret+=C[i]; return ret;}
}

int head[N],to[2*N],w[2*N],nxt[2*N],num=0,n,m,ans[N],fa[N],dep[N],_w[N],size[N],son[N],top[N],dfn=0,seq[N],loc[N];
int nx[M],s[M],t[M],pos[N][2];
inline void build(int u,int v,int ww)
{
    num++;
    w[num]=ww;
    to[num]=v;
    nxt[num]=head[u];
    head[u]=num;
}
inline void dfs(int u,int f)
{
    dep[u]=dep[f]+1; fa[u]=f; size[u]=1;
    for(int i=head[u];i;i=nxt[i]) 
    {
        if(to[i]==f) continue;
        _w[to[i]]=w[i];
        dfs(to[i],u);
        size[u]+=size[to[i]];
        if(size[son[u]]<size[to[i]]) son[u]=to[i];
    }
}
inline void dfs1(int u,int f,int tp)
{
    loc[u]=++dfn,seq[dfn]=u; top[u]=tp;
    if(son[u]) dfs1(son[u],u,tp);
    for(int i=head[u];i;i=nxt[i])
    {
        if(to[i]==f||to[i]==son[u]) continue;
        dfs1(to[i],u,to[i]);
    }
}
inline int getlca(int u,int v)
{
    while(top[u]!=top[v]) 
    {
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        u=fa[top[u]];
    }
    return dep[u]<dep[v]?u:v;
}
inline int getpoint(int u,int d)
{
    while(dep[u]-dep[top[u]]<d){d-=(dep[u]-dep[top[u]]+1),u=fa[top[u]];}
    return seq[loc[u]-d];
}
inline void kmp(int u,int v,int lca,int id)
{
    int lent=strlen(str),lens=0;
    int x=getpoint(u,dep[u]-min(dep[u],dep[lca]+lent-1));
    int y=getpoint(v,dep[v]-min(dep[v],dep[lca]+lent-1));   
    lens=dep[x]-dep[lca]+dep[y]-dep[lca];
    int tmp=x,i=0,j; while(tmp!=lca) s[i++]=_w[tmp],tmp=fa[tmp];
    tmp=y,i=1; while(tmp!=lca) s[lens-i]=_w[tmp],tmp=fa[tmp],i++;
    for(int i=0;i<lent;i++) t[i]=str[i]-'a';
    nx[0]=-1; i=0,j=-1;
    while(i<lent) 
    {
        if(j==-1||t[i]==t[j]) {i++; j++; nx[i]=j;}
        else j=nx[j];
    }
    i=0,j=0; int ret=0;
    while(i<lens)
    {
        if(j==-1||s[i]==t[j]) 
        {
            i++; j++;
            if(j==lent){ret++; j=nx[j];}
        }
        else j=nx[j];
    }
    pos[id][0]=AC::insert(1); pos[id][1]=AC::insert(-1);
    ans[id]=ret;
    if(u!=x)
    {
        ID[x].push_back(-id); ID[u].push_back(id);
        V[x].push_back(pos[id][1]); V[u].push_back(pos[id][1]);
    }
    if(v!=y)
    {
        ID[y].push_back(-id); ID[v].push_back(id);
        V[y].push_back(pos[id][0]); V[v].push_back(pos[id][0]);
    }
}
inline void dfs2(int u,int f,int x)
{
    AC::add(AC::in[x],1); 
    int sz=V[u].size(); 
    for(int i=0;i<sz;i++)
    {

        int ret=AC::query(AC::out[V[u][i]])-AC::query(AC::in[V[u][i]]-1);
        if(ID[u][i]>0) ans[ID[u][i]]+=ret;
        else ans[-ID[u][i]]-=ret;
    }
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==f) continue;
        dfs2(v,u,AC::ch[x][w[i]]);
    }
    AC::add(AC::in[x],-1);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++)
    {
        int u,v; scanf("%d%d",&u,&v); scanf("%s",str);
        build(u,v,str[0]-'a'); build(v,u,str[0]-'a');
    }
    dfs(1,1); dfs1(1,1,1); AC::init();
    for(int i=1;i<=m;i++)
    {
        int u,v; scanf("%d%d",&u,&v);  scanf("%s",str);

        if(u==v) continue; int lca=getlca(u,v); 
        kmp(u,v,lca,i);
    }
    AC::getfail();  
    AC::dfs(1);
    dfs2(1,1,1);
    for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
    return 0;
}

然后这是我原来写的倍增版本的代码（改正后），没有namespace套namespace这种鬼畜玩意儿：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int N=100005;
const int M=300015;
const int P=17;
queue<int> Q;
vector<int> V[N],ID[N];
char str[M];
struct AC_
{
    int ch[2*M][26],root,tail,head[2*M],nxt[2*M],to[2*M],num,fail[2*M];
    int in[2*N],out[2*M],inc,C[2*M];
    void build(int u,int v) {num++; to[num]=v; nxt[num]=head[u]; head[u]=num; inc=0;}
    void init(){root=1,tail=1,num=0;}
    int insert(int opt)
    {
        int len=strlen(str); int tmp=root;
        for(int j=0,i;j<len;j++)
        {
            if(opt==1) i=j; else i=len-j-1;
            int c=str[i]-'a';
            if(!ch[tmp][c]) ch[tmp][c]=++tail;
            tmp=ch[tmp][c];
        }
        return tmp;
    }
    void getfail()
    {
        for(int i=0;i<26;i++) if(ch[root][i]) fail[ch[root][i]]=root,build(root,ch[root][i]),Q.push(ch[root][i]); else ch[root][i]=root;
        while(!Q.empty())
        {
            int top=Q.front(); Q.pop();
            for(int i=0;i<26;i++)
            {
                if(!ch[top][i]) ch[top][i]=ch[fail[top]][i];
                else
                {
                    int u=ch[top][i];
                    fail[u]=ch[fail[top]][i];
                    build(fail[u],u);
                    Q.push(u);
                }
            }
        }       
    }
    void dfs(int u)
    {
        inc++; in[u]=inc;
        for(int i=head[u];i;i=nxt[i]) dfs(to[i]);
        out[u]=inc;
    }
    void add(int x,int d){for(int i=x;i<=inc;i=i+(i&(-i))) C[i]+=d;}
    inline int query(int x){int ret=0;for(int i=x;i;i=i-(i&(-i))) ret+=C[i]; return ret;}
}AC;
int head[N],to[2*N],w[2*N],nxt[2*N],num=0,n,m,ans[N],anc[N][P+3],dep[N],_w[N];
int nx[M],s[M],t[M],pos[N][2];
void build(int u,int v,int ww)
{
    num++;
    w[num]=ww;
    to[num]=v;
    nxt[num]=head[u];
    head[u]=num;
}
void dfs1(int u,int f)
{
    dep[u]=dep[f]+1; anc[u][0]=f;
    for(int i=1;i<P;i++) anc[u][i]=anc[anc[u][i-1]][i-1];
    for(int i=head[u];i;i=nxt[i]) if(to[i]!=f) _w[to[i]]=w[i],dfs1(to[i],u);
}
inline int getlca(int u,int v)
{
    if(dep[u]<dep[v]) swap(u,v);
    int d=dep[u]-dep[v];
    for(int i=0;d;d>>=1,i++) if(d&1) u=anc[u][i];
    if(u==v) return u;
    for(int i=P-1;i>=0;i--)
    if(anc[u][i]!=anc[v][i]) u=anc[u][i],v=anc[v][i];
    return anc[u][0];
}
inline int getpoint(int u,int d) {for(int i=0;d;d>>=1,i++) if(d&1) u=anc[u][i]; return u;}
void kmp(int u,int v,int lca,int id)
{
    int lent=strlen(str),lens=0;
    int x=getpoint(u,dep[u]-min(dep[u],dep[lca]+lent-1));
    int y=getpoint(v,dep[v]-min(dep[v],dep[lca]+lent-1));
    lens=dep[x]-dep[lca]+dep[y]-dep[lca];
    int tmp=x,i=0,j; while(tmp!=lca) s[i++]=_w[tmp],tmp=anc[tmp][0];
    tmp=y,i=1; while(tmp!=lca) s[lens-i]=_w[tmp],tmp=anc[tmp][0],i++;
    for(int i=0;i<lent;i++) t[i]=str[i]-'a';
    nx[0]=-1; i=0,j=-1;
    while(i<lent) 
    {
        if(j==-1||t[i]==t[j]) {i++; j++; nx[i]=j;}
        else j=nx[j];
    }
    i=0,j=0; int ret=0;
    while(i<lens)
    {
        if(j==-1||s[i]==t[j]) 
        {
            i++; j++;
            if(j==lent){ret++; j=nx[j];}
        }
        else j=nx[j];
    }
    pos[id][0]=AC.insert(1); pos[id][1]=AC.insert(-1);
    ans[id]=ret;
    if(u!=x)
    {
        ID[x].push_back(-id); ID[u].push_back(id);
        V[x].push_back(pos[id][1]); V[u].push_back(pos[id][1]);
    }
    if(v!=y)
    {
        ID[y].push_back(-id); ID[v].push_back(id);
        V[y].push_back(pos[id][0]); V[v].push_back(pos[id][0]);
    }
}
void dfs2(int u,int f,int x)
{
    AC.add(AC.in[x],1); 
    int sz=V[u].size(); 
    for(int i=0;i<sz;i++)
    {   
        int ret=AC.query(AC.out[V[u][i]])-AC.query(AC.in[V[u][i]]-1);
        if(ID[u][i]>0) ans[ID[u][i]]+=ret;
        else ans[-ID[u][i]]-=ret;
    }
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==f) continue;
        dfs2(v,u,AC.ch[x][w[i]]);
    }
    AC.add(AC.in[x],-1);
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++)
    {
        int u,v; scanf("%d%d%s",&u,&v,str);
        build(u,v,str[0]-'a'); build(v,u,str[0]-'a');
    }
    dfs1(1,1); AC.init();
    for(int i=1;i<=m;i++)
    {
        int u,v; scanf("%d%d",&u,&v); scanf("%s",str);
        if(u==v) continue; int lca=getlca(u,v); 
        kmp(u,v,lca,i);
    }
    AC.getfail();   
    AC.dfs(1);
    dfs2(1,1,1);
    for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
    return 0;
}

昨晚上脑子有点不清楚这里写图片描述

自己没写对拍就一直交，卡了一晚上评测，非常抱歉，感谢大家的不杀之恩。

最后查出来的错：
1.求lca时 swap(u,u);
2.kmp忘记 j=nxt[j];
3.自己nxt[N]和nx[N]两个数组搞混了。

最初以为是倍增慢了，没有去查无限循环的错，改成链剖还是T，才想到是不是哪里写挂了，
长代码一定要静态查错+对拍。

Bfk_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
wangjunrui666#bzoj-problem##4882. [Lydsy1705月赛]卡常生成树1
07-25
为了避免输入数据过于庞大，数据进行了压缩，解压方式可用下面这段代码解释：//在点i与点j之间添加一条边权为w的边第一行包含一个正整数T(1<=T<=50)，表示
【BZOJ4231】回忆树
cz_xuyixuan的博客
04-22 534
【题目链接】 点击打开链接 【思路要点】 分开处理路径上竖直的字符串和在 LcaLcaLca 处拐弯的字符串。 在 LcaLcaLca 处拐弯的字符串总数在 O(∑∣S∣)O(\sum|S|)O(∑∣S∣) 级别，可以直接 KmpKmpKmp 判断。 竖直的字符串可以在离线询问后通过 ACACAC 自动机和树状数组处理。 时间复杂度 O(NLogN+MLogN+∑∣S∣)O(NLogN...
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
（自己写的动态点分治巨垃圾，常数是别人的两倍） 用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的贡献，再暴力向上跳合并父节点来自其它节点的贡献。 因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的信息 + 连向父节点的边的贡献得到，考虑在每个节点再维护一个线段树，按距离建树用来统计子树内的节点到其父节点距离为 p 的点权和，这样便可以暴力爬树统计子树外的节点的贡献。 理论复杂度为 O(nlog⁡2n)O(n \log^2 n)O(nlog2n)，但常数巨大，况
bzoj4231 回忆树
Johnny817的博客
02-28 203
题目描述 题解 对询问串建立 AC\text{AC}AC 自动机，考虑建出 fail\text{fail}fail 树， fail\text{fail}fail 树上节点所代表的串是这个节点子树内每个点所代表的的串的后缀。所以我们可以把链分成两条，把正反串都放入 AC\text{AC}AC 自动机中，对于一条链 (lca,u)(lca,u)(lca,u) ，对于不包含 lcalcalca 的子串，...
AC自动机和Fail树
融雪时分的博客
01-22 506
Fail树与阿狸的打字机 萌新第一次试着写博客…全是口胡(/□＼*)，可能以后也不会有时间再写了 相关数据结构：AC自动机，树状数组（线段树） Fail指针的基本性质：某只结点的Fail指针，指向它所代表的字符串的最长的后缀的结点。 性质：每只结点沿着其Fail指针一直走，最终会走到根节点。 这样，将每只结点和其Fail指针指向的结点连边，就形成了一个树，其根与原Trie树相同，称为Fail树。 ...
AC自动机
xiaolu567的博客
06-15 1035
解决在一个大字符串中，找到多个候选字符串的问题1）把所有匹配串生成一棵前缀树 2）前缀树节点增加fail指针 3）fail指针的含义：如果必须以当前字符结尾，当前形成的路径是str，剩下哪一个字符串的前缀和str的后缀，拥有最大的匹配长度。fail指针就指向那个字符串的最后一个字符所对应的节点。前缀树的头结点fail指针一定是指向空头结点 下级直接节点(它只往下一级的节点) fail指针一律指向头部 底层的fail指针先建完前缀树之后再去设置建完之后,然后再根据宽度优先的顺序设置每一个节点的fail指针某一
BZOJ 4231 回忆树（AC自动机+BIT+KMP）
Freopen的博客
04-02 345
回忆树是树。 具体来说，是n个点n-1条边的无向连通图，点标号为1~n，每条边上有一个字符（出于简化目的，我们认为只有小写字母）。 对一棵回忆树来说，回忆当然是少不了的。 一次回忆是这样的：你想起过往，触及心底…唔,不对，我们要说题目。 这题中我们认为回忆是这样的：给定2个点u，v(u可能等于v)和一个非空字符串s，问从u到v的简单路径上的所有边按照到u的距离从小到大的顺序排列后，边上的字符依次...
【学习笔记】ac自动机&fail树
weixin_34415923的博客
01-03 452
定义 解决文本串和多个模式串匹配的问题； 本质是由多个模式串形成的一个字典树，由tie的意义知道：trie上的每一个节点都是一个模式串的前缀； 在trie上加入fail边，一个节点fail边指向这个节点所代表的前缀的最长后缀节点（除开自身的后缀）； 也就是说如果x->y，那么y所代表的串是x所代表的串在trie上出现过的最大后缀； 例子 （黑边为t...
bzoj4231回忆树——AC自动机
aizhuji9626的博客
07-02 159
bzoj4231 回忆树 给定一颗Trie树，每次询问u到v的路径上构成的字符串包含了给定模式串T多少次。 思路 考虑离线之后对于所有的模式串建立AC自动机，考虑跨过lca的串范围有限，直接暴力kmp即可。 然后我们就将一次询问拆成了两条链了，可以将每次询问挂在链上然后离线去dfs，每次dfs时将这个节点添加进AC自动机匹配，对于一段u到v的链，我们在链头的某一个位置减去之前不合法的匹配...
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
Link-Cut-Tree 动态树经典讲稿附例题
10-11
适用ACM和OI等算法选手，Link-Cut-Tree 动态树经典讲稿，附BZOJ多道优秀练习题，原作者吉大附中实验学校 PoPoQQQ
【BZOJ4231】回忆树（AC自动机）（KMP）（DFS序）（树状数组）
zxyoi_dreamer的博客（不定期诈尸）
09-23 168
传送门 题解： 一个串在从uuu到vvv的路径上匹配，我们直接分情况搞。 首先，匹配没有横跨LCA，那么一定是LCA−>uLCA->uLCA−>u的路径上匹配反串，LCA−>vLCA->vLCA−>v匹配原串，直接用AC的fail树上DFS序离线上树状数组，一波就能搞了。 然后是横跨了LCA的，直接把前后提一个∣S∣−1|S|-1∣S∣−1长度的串出来做匹配就...
回溯法-子集树递归树-装载问题
weixin_52034824的博客
04-14 1454
回溯法 深度优先策略（回忆深度优先遍历二叉树思路） 解题步骤： 1)针对所给问题，定义问题的解空间； 2)确定易于搜索的解空间结构； 3)以深度优先方式搜索解空间，并在搜索过程中用剪枝函数（****约束函数除去不满足约束的子树，限界函数减去得不到最优解的子树**）**避免无效搜索 ## 子集树和递归树 扩展结点:一个正在产生儿子的结点称为扩展结点。 活结点:一个自身已生成但其儿子还没有全部生成的节点称做活结点。 死结点:一个所有儿子已经产生的结点称做死结点。 1.当所给的问题是从n个元素的集合S中找
【BZOJ #4231】—回忆树（Kmp+Ac自动机）
Stargazer的博客
09-25 295
传送门 考虑把经过LcaLcaLca提出来暴力KmpKmpKmp统计 总长度只有O(∣S∣)O(|S|)O(∣S∣)的 现在只用考虑一段链 差分后就是到根的一条链 考虑从根dfsdfsdfs，dfsdfsdfs的同时在AcAcAc自动机上走，把每个点点权加一 对于每个询问就是failfailfail树子树和 走出去的的时候减一 对正反串分别建一个AcAcAc自动机就可以了 #include<...
1285. 单词 ac自动机 + fail树
m0_51068403的博客
09-21 171
传送门 文章目录题意：思路： 题意： 一篇论文由若干单词构成，且单词间是隔开的，给你nnn个单词，要求你计算每个单词在论文中出现了多少次。 1≤n≤2001\le n\le 2001≤n≤200，所有单词总长不超过1e61e61e6 思路： 考虑一种比较暴力的写法，我们将所有串仍acacac自动机里面，让后遍历每个单词，将其视为要匹配的串，每次都跑一遍，复杂度O(n1e6)O(n1e6)O(n1e6)，还带常数，给了1s1s1s显然过不去。 考虑每个单词在其他单词中出现的位置，都是一些前缀的后缀！所以我们可
bzoj4231: 回忆树
weixin_30267785的博客
08-03 218
一道好题。 考虑拆分询问，对于经过LCA的出现位置，可以把前链和后链接近LCA部分的slen-1个字符直接取出进行KMP计算，复杂度O(sigema S) 那么现在就要计算树上一条上至下的链形成的串中，询问串出现了多少次（前链是下至上的，把询问串反过来即可） 考虑把这样的询问拆分成两条根到点的链，离线询问，将询问串建成AC自动机。 最后遍历整棵树同时AC自动机识别，搜到对应位置+...
bzoj4727 [POI2017]Turysta（竞赛图构造哈密顿回路）
Bfk的博客
01-23 1548
bzoj4727 [POI2017]Turysta原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=4727题意： 给出一个n个点的有向图，任意两个点之间有且仅一条有向边。对于每个点v，求出从v出发的一条经过点数最多， 且没有重复经过同一个点两次以上的简单路径。输入第一行包含一个正整数n(2<=n<=2000)，表示点数。接下来n-1行，其
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
题目描述 有一个 $n$ 个点的棋盘，每个点上有一个数字 $a_i$，你需要从 $(1,1)$ 走到 $(n,n)$，每次只能往右或往下走，每个格子只能经过一次，路径上的数字和为 $S$。定义一个点 $(x,y)$ 的权值为 $a_x+a_y$，求所有满足条件的路径中，所有点的权值和的最小值。 输入格式 第一行一个整数 $n$。 接下来 $n$ 行，每行 $n$ 个整数，表示棋盘上每个点的数字。 输出格式 输出一个整数，表示所有满足条件的路径中，所有点的权值和的最小值。 数据范围 $1\leq n\leq 300$ 输入样例 3 1 2 3 4 5 6 7 8 9 输出样例 25 算法1 (树形dp) $O(n^3)$ 我们可以先将所有点的权值求出来，然后将其看作是一个有权值的图，问题就转化为了在这个图中求从 $(1,1)$ 到 $(n,n)$ 的所有路径中，所有点的权值和的最小值。 我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子都被遍历过了，那么我们就可以计算出从它的左儿子到它的右儿子的路径中，所有点的权值和的最小值，然后再将这个值加上当前节点的权值，就可以得到从根节点到当前节点的路径中，所有点的权值和的最小值。 时间复杂度 树形dp的时间复杂度是 $O(n^3)$。 C++ 代码 算法2 (动态规划) $O(n^3)$ 我们可以使用动态规划来解决这个问题，具体来说，我们可以定义 $f(i,j,s)$ 表示从 $(1,1)$ 到 $(i,j)$ 的所有路径中，所有点的权值和为 $s$ 的最小值，那么我们就可以得到如下的状态转移方程： $$ f(i,j,s)=\min\{f(i-1,j,s-a_{i,j}),f(i,j-1,s-a_{i,j})\} $$ 其中 $a_{i,j}$ 表示点 $(i,j)$ 的权值。 时间复杂度 动态规划的时间复杂度是 $O(n^3)$。 C++ 代码

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值