每日总结-05-18

最新推荐文章于 2025-05-24 15:42:30 发布
原创 最新推荐文章于 2025-05-24 15:42:30 发布 · 950 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了如何运用AC自动机解决特定问题，并通过三个实例展示了AC自动机在不同场景下的应用，包括自动机上的树上DP、字符串匹配问题及模式串在Trie树上的动态规划。此外，文章还探讨了如何优化空间复杂度，通过状态压缩和滚动数组技巧实现高效求解。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

今天起得比较晚，又浪费了点时间，真可耻。。

下午又为校赛出了俩题，至此，校赛的四道题目已经完毕。又检查了一番，没有错误，就等待着明天的汇总了~。

AC自动机的题目今天就刷了三道，还是没有完成之前的目标。现在vj也进不去了，想通宵，都不给机会~~

只能等明天再刷完了，拖延不是一个好习惯。

----------------------------------------------------------------------------------------------------------

1,hdu-4511-小明系列故事――女友的考验

抢了CZ的FB，心里很高兴，哈哈

AC自动机越来越模板了，就先创建非法路径的自动机。然后再树上求1点到n点的最短路。我当时没有注意要“只能走到比当前所在点编号大的位置； ”的条件，错了N次，伤心。。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<string.h>
#include<math.h>
using namespace std;
#define LL __int64
#define maxn 55
const int maxnode=110*5;
const int childnum=55;
const int mod=1000000007;
const int INF=99999999;
struct list
{
    double  x;
    double y;
}node[maxn];
struct listt
{
    int p;
    int t;
    double dis;
    friend bool operator <(const listt &a,const listt &b)
    {
        return a.dis>b.dis;
    }
}pp,qq;
double dist(int x,int y)
{
    double xx,yy;
    xx=node[x].x-node[y].x;
    yy=node[x].y-node[y].y;
    double sum=xx*xx+yy*yy;
    return 1.0*sqrt(1.0*sum);
}
priority_queue<listt>que;
struct ac_tree
{
    int chd[maxnode][childnum];
    int val[maxnode];
    int fail[maxnode];
    int key[1<<11];
    int Q[maxnode];
    int ID[128];
    int sz;
    int vis[maxn][maxnode];
    void init()
    {
        fail[0]=0;
        for(int i=0;i<childnum;i++)
        {
            ID[i]=i;
        }
    }
    void reset()
    {
        memset(chd,0,sizeof(chd));
        sz=1;
    }
    void insert(vector<int>vec,int k)
    {
        int p=0;
        int len=vec.size();
        for(int i=0;i<len;i++)
        {
            int c=ID[vec[i]];
            if(!chd[p][c])
            {
                memset(chd[sz],0,sizeof(chd[sz]));
                val[sz]=0;
                chd[p][c]=sz++;
            }
            p=chd[p][c];
        }
        val[p]=k;
    }
    void ac_build()
    {
        int *s=Q,*e=Q;
        for(int i=1;i<childnum;i++)
        {
            if(chd[0][i])
            {
                fail[chd[0][i]]=0;
                *e++=chd[0][i];
            }
        }
        while(s!=e)
        {
            int u=*s++;
            if(val[fail[u]])val[u]+=val[fail[u]];
            for(int i=1;i<childnum;i++)
            {
                int &v=chd[u][i];
                if(v)
                {
                    *e++=v;
                    fail[v]=chd[fail[u]][i];
                  //  val[v]=(val[v]+val[fail[v]]);
                }
                else v=chd[fail[u]][i];
            }
        }
    }
    int word(int n)
    {
        while(!que.empty())que.pop();
        memset(vis,0,sizeof(vis));
        pp.p=1;
        pp.t=chd[0][1];
        pp.dis=0.0;
        que.push(pp);
        int cr;
        vis[1][pp.t]=1;
        while(!que.empty())
        {
            pp=que.top();
            que.pop();
          //  cout<<"____________"<<endl;
           // cout<<pp.p<<endl;
            if(pp.p==n)
            {
                printf("%.2f\n",pp.dis);
                return 0;
            }
            for(int i=pp.p+1;i<=n;i++)
            {
                cr=chd[pp.t][i];
                if(i==pp.p)continue;
                if(val[cr])continue;
                //if(vis[i][cr])continue;
               // cout<<pp.p<<" "<<i<<" "<<cr<<endl;
                vis[i][cr]=1;
                qq.p=i;
                qq.t=cr;
                qq.dis=1.0*pp.dis+1.0*dist(pp.p,qq.p);
                que.push(qq);
            }
        }
        cout<<"Can not be reached!"<<endl;
    }
}AC;
char temp[155];
int main()
{
    AC.init();
    int n,m,k,x;
    int T;
    while(~scanf("%d%d",&n,&m))
    {
        if(!(n||m))break;
        for(int i=1;i<=n;i++)
        {
            scanf("%lf%lf",&node[i].x,&node[i].y);
        }
        AC.reset();
        vector<int>vec;
        for(int i=1;i<=m;i++)
        {
            vec.clear();
            scanf("%d",&k);
            while(k--)
            {
                scanf("%d",&x);
                vec.push_back(x);
            }
            AC.insert(vec,1);
        }
        AC.ac_build();
        AC.word(n);
    }
    return 0;
}

2，hdu-4758-Walk Through Squares

1.对自动机上每个状态dp,dp[a][b][c][d]表示经过了a个字符，匹配了b个R，在c这个状态，d是4进制数，表示是否经过串1和串2

也就是一个树上DP，想好状态转移方程就好了。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
#define LL int
const int maxnode=101*2;
const int childnum=2;
const int mod=1000000007;
const int INF=99999999;
struct ac_tree
{
    int chd[maxnode][childnum];
    int val[maxnode];
    int fail[maxnode];
    int key[1<<11];
    int Q[maxnode];
    int ID[128];
    int sz;
    int dp[104][104][maxnode][4];
    void init()
    {
        fail[0]=0;
        for(int i=0;i<childnum;i++)
        {
            ID[i+'a']=i;
        }
        ID['R']=0;ID['D']=1;
    }
    void reset()
    {
        memset(chd,0,sizeof(chd));
        sz=1;
    }
    void insert(char str[],int k)
    {
        int p=0;
        int len=strlen(str);
        for(int i=0;i<len;i++)
        {
            int c=ID[str[i]];
            if(!chd[p][c])
            {
                memset(chd[sz],0,sizeof(chd[sz]));
                val[sz]=0;
                chd[p][c]=sz++;
            }
            p=chd[p][c];
        }
        val[p]=k;
    }
    void ac_build()
    {
        int *s=Q,*e=Q;
        for(int i=0;i<childnum;i++)
        {
            if(chd[0][i])
            {
                fail[chd[0][i]]=0;
                *e++=chd[0][i];
            }
        }
        while(s!=e)
        {
            int u=*s++;
          //  if(val[fail[u]])val[u]|=val[fail[u]];
            for(int i=0;i<childnum;i++)
            {
                int &v=chd[u][i];
                if(v)
                {
                    *e++=v;
                    fail[v]=chd[fail[u]][i];
                    val[v]=(val[v]|val[fail[v]]);
                }
                else v=chd[fail[u]][i];
            }
        }
    }
    int word(int n,int m)
    {
        memset(dp,0,sizeof(dp));
        dp[0][0][0][0]=1;
        int cr;
        int t;
        for(int i=0;i<=n;i++)
        {
            for(int j=0;j<=m;j++)
            {
                for(int k=0;k<sz;k++)
                {
                    for(int z=0;z<4;z++)
                    {
                        if(dp[i][j][k][z]==0)continue;
                       // dp[i][j][k][z]%=mod;
                    //    cout<<i<<" "<<j<<" "<<k<<" "<<z<<endl;
                        cr=chd[k][0];
                        t=z|val[cr];
                        dp[i+1][j][cr][t]+=dp[i][j][k][z];
                        dp[i+1][j][cr][t]%=mod;
                        cr=chd[k][1];
                        t=z|val[cr];
                        dp[i][j+1][cr][t]+=dp[i][j][k][z];
                        dp[i][j+1][cr][t]%=mod;
                    }
                }
            }
        }
        int ans=0;
        for(int i=0;i<sz;i++)
        {
            ans+=dp[n][m][i][3];
            ans%=mod;
        }
        ans=ans%mod;
        cout<<ans<<endl;
    }
}AC;
char temp[155];
int main()
{
    AC.init();
    int n,m,k;
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        AC.reset();
        for(int i=1;i<=2;i++)
        {
            scanf("%s",temp);
            AC.insert(temp,(1<<(i-1)));
        }
        AC.ac_build();
        AC.word(n,m);
    }
    return 0;
}

3，hdu-4057- Rescue the Rabbit

dp[i][j][k]，表示长度为i的串，位于Trie上的状态j，模式串的状态为k的最大价值。

状态压缩一下，就变成了普通的树上DP了，还需要滚动数组压缩一下空间。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
const int maxnode=101*10;
const int childnum=4;
const int mod=20090717;
const int INF=99999999;
struct ac_tree
{
    int chd[maxnode][childnum];
    int val[maxnode];
    int fail[maxnode];
    int key[1<<11];
    int Q[maxnode];
    int ID[128];
    int sz;
    int dp[2][maxnode][1<<10];
    void init()
    {
        fail[0]=0;
        for(int i=0;i<childnum;i++)
        {
            ID[i+'a']=i;
        }
        ID['A']=0;ID['T']=1;
        ID['G']=2;ID['C']=3;
    }
    void reset()
    {
        memset(chd,0,sizeof(chd));
        sz=1;
    }
    void insert(char str[],int k,int d)
    {
        key[k]=d;
        int p=0;
        int len=strlen(str);
        for(int i=0;i<len;i++)
        {
            int c=ID[str[i]];
            if(!chd[p][c])
            {
                memset(chd[sz],0,sizeof(chd[sz]));
                val[sz]=0;
                chd[p][c]=sz++;
            }
            p=chd[p][c];
        }
        val[p]=k;
    }
    void ac_build()
    {
        int *s=Q,*e=Q;
        for(int i=0;i<childnum;i++)
        {
            if(chd[0][i])
            {
                fail[chd[0][i]]=0;
                *e++=chd[0][i];
            }
        }
        while(s!=e)
        {
            int u=*s++;
          //  if(val[fail[u]])val[u]|=val[fail[u]];
            for(int i=0;i<childnum;i++)
            {
                int &v=chd[u][i];
                if(v)
                {
                    *e++=v;
                    fail[v]=chd[fail[u]][i];
                    val[v]=(val[v]|val[fail[v]]);
                }
                else v=chd[fail[u]][i];
            }
        }
    }
    int word(int n,int m)
    {
        int s=0;
        int l=1;
        int tai=(1<<m);
        int cr,tr;
        memset(dp,0,sizeof(dp));
        dp[0][0][0]=1;
        for(int i=0;i<n;i++)
        {
            l=1-s;
            memset(dp[l],0,sizeof(dp[l]));
           // cout<<"__"<<endl;
            for(int j=0;j<sz;j++)
            {
                for(int k=0;k<tai;k++)
                {
                    if(dp[s][j][k]==0)continue;
                    //cout<<j<<" "<<k<<endl;
                    for(int z=0;z<childnum;z++)
                    {
                        cr=chd[j][z];
                      //  cout<<j<<"+"<<z<<"="<<cr<<endl;
                        tr=val[cr]|k;
                        dp[l][cr][tr]=1;
                    }
                }
            }
            s=l;
        }
        int maxx=-1;
        int tt=0;
        for(int j=0;j<sz;j++)
        {
            for(int k=0;k<tai;k++)
            {
                if(dp[s][j][k]==0)continue;
               // cout<<j<<" "<<k<<endl;
                tt=0;
                for(int i=0;i<m;i++)
                {
                    if(k&(1<<i))tt+=key[1<<i];
                }
                maxx=max(tt,maxx);
            }
        }
        if(maxx<0)cout<<"No Rabbit after 2012!"<<endl;
        else cout<<maxx<<endl;
    }
}AC;
char temp[155];
int main()
{
    AC.init();
    int n,m,k;
    while(~scanf("%d%d",&n,&m))
    {
        AC.reset();
        for(int i=1;i<=n;i++)
        {
            scanf("%s %d",temp,&k);
            AC.insert(temp,(1<<(i-1)),k);
        }
        AC.ac_build();
        AC.word(m,n);
    }
    return 0;
}









青竹梦
关注
MySQL数据一致性守护者：pt-table-checksum原理与实战全解析
专注于编程、AI、人工智能等多个领域内容研究和分析
06-03 545
MySQL数据一致性校验工具pt-table-checksum解析 本文深入介绍了Percona Toolkit中的pt-table-checksum工具，它专门用于检测MySQL主从复制环境中的数据不一致问题。文章从数据一致性的重要性入手，详细剖析了该工具的核心原理：通过智能分块计算CRC32校验值，并利用复制机制比对主从库结果。工具具有动态分块、索引优化、负载保护等特性，能在不影响生产环境的情况下高效运行。文中还提供了完整的使用指南，包括安装配置、参数解析和典型应用场景（主从验证、数据迁移检查等），并解
每日打卡 2020-05-18
我的博客
05-18 245
践行每日打卡，早睡早起早做，轻快前行。 学习：精读一篇文章/看一功能，看几页书，写一总结； 工作：追踪进展，处理积压事务，规划和总结； 生活：做运动，学做理财，写下感悟； 附件 高效习惯——立下flag与动力；时间与deadline；计划与分解；专注的空间与排除干扰；执行与惩罚；奖励与劳逸结合；支线小任务与习惯培养；千里之行始于足下；向前看，没有任何一个失败会真的决定人生，今日再战。 ...
go每日新闻--2020-05-02
韩亚军的博客
05-02 513
go 语言中文网(每日资讯)_2020-05-02 一、Go 语言中文网 Go 框架解析:echo Go Web 编程–使用 bcrpyt 哈希用户密码 消息队列 NSQ 源码学习笔记 (一) 2020 重学 Go 系列：31. 说说 Go 语言里的空接口 二、 容器时代 Kubernetes 服务质量和 OOM 详解 三、GoUpUp Go 每日一库之 sqlc Go 每日一库专辑 ...
go每日新闻--2021-01-05
韩亚军的博客
01-05 328
go中文网每日资讯--2021-01-05 一、#公众号：Go语言中文网 漫画：Go 布道师的“神秘”社区在召唤你 Go 语言同步原语的基石 Go 经典入门系列 36：写入文件 二、#公众号：亚军进化史 Go每日信息--2021-01-04 三、#公众号：代码与远方 探索Golang协程实现——从v1.0开始 四、#公众号：五分选手 HTTP/2 中的注意事项 六、#公众号：Go101 Go 1.16 中原本欲支持的结构体字段标签合并写法特性被取消了 七、#公众号：字节跳动技术团队 如何优雅
机器学习-05-特征工程
IT从业者的成长历程
03-19 1816
本系列是机器学习课程的系列课程，主要介绍机器学习中特征工程部分。
go每日新闻(2021-05-05)——如何成为一个更好的开发者
韩亚军的博客
05-06 364
每日一谚: In Go, the underlying machine is the real machine rather than a single abstract machine. The model of computation is that of the computer. Here is the key, Go gives you direct access to the machine while still providing abstraction mechanisms to all.
Hive SQL 题目总结 - 尚硅谷
qq_25127933的博客
09-25 2599
​手写HQL第一题 表结构：uid,subject_id,score 求：找出所有科目成绩都大于某一学科平均成绩的学生数据集如下​​ 1001 01 90 1001 02 90 1001 03 90 1002 01 85 1002 02 85 1002 03 70 1003 01 70 1003 02 70 1003 03 85 1) 建表语句 crea.
TechCrunch 最新文章 (2025-05-24)
Albert_Lsk的博客
05-24 1192
TechCrunch最新日报（2025-05-24）
每日学习打卡-汇总处
大林程序员
04-03 3641
无，就是一个打卡而已
每日总结app_干货|效率app分享（数据分析记录／时间管理／习惯养成）
weixin_28864485的博客
12-25 1964
前言以下分享的app都是我日常使用的，有时间管理的，备忘的，习惯养成的，日常数据记录的，各司其职，没有功能重复，也同样缺一不可。 这些app都有很多替代者，但本篇文章没有测评去对比其他app（但是我大部分都下过，在心里有过对比），主要是直接给大家做一个推荐，给出一个答案。 代办事项———things其实苹果自带的待办事项就能实现很多功能，这里还想提一下我之前一直用的记录待办的app“水滴清单”，界...
【Python-因特网客户端编程-05】如何使用 Python连接到 FTP 服务器每天下班后自动移动文件
weixin_46453070的博客
05-29 1847
通过上述步骤，你可以编写一个 Python 脚本，使用 FTP 协议自动移动文件，并使用调度工具在下班后自动运行该脚本。确保测试脚本并验证其在你的环境中正常工作，以确保自动化过程顺利进行。通过任务计划程序，你可以方便地设置和管理定时任务。按照上述步骤配置后，任务计划程序将每天晚上6点自动执行指定的 Python 脚本，确保你的 FTP 操作按时进行。
leetcode分类-Java-grammar1:java学习资料,使用技巧,各方面应用,基于jdk1.8.151版本之前的总结,各个版本更改
06-30
leetcode 分类 Java-grammar 例子都采用java1.8.151 经过在公司一段时间,梳理了github上很多没用的例子,决定从今天开始,每天github打卡,复习...2018.05.05 更新java socket的10大参数和serversocket的一个阻塞参数.对10
每日总结Q
weixin_51847874的博客
07-12 168
** 学习总结 现实是此岸,理想是彼岸。中间隔着湍急的河流,行动则是架在川上的桥梁 学习内容： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 8:00~9:05*0 学习打卡 9:00~11:30学习java基本语法 15:00~18:00 VJ刷题 20.00：总结 学习产出： java总结： Java数据类型和语言相似较高，Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布
哈工大威海集合论与图论课件.zip
08-23
哈工大威海集合论与图论课件
基于扰动观察法的光伏MPPTBoost变换器最大功率点跟踪技术研究
08-23
光伏最大功率点跟踪（MPPT）技术及其在光伏发电系统中的重要性。重点讨论了基于扰动观察法（P&O）的MPPT技术和MPPT Boost变换器的应用。扰动观察法通过周期性改变光伏阵列的工作电压或电流并观察输出功率变化，进而调整工作点，确保光伏阵列始终处于最大功率点附近。而MPPT Boost变换器则通过高效的电压或电流控制，进一步提高了系统的输出效率。两者结合使用，在光强和温度等环境条件变化时，能够显著提升光伏系统的发电效率和寿命。 适用人群：从事光伏系统设计、安装和维护的专业技术人员，以及对清洁能源技术感兴趣的科研人员。 使用场景及目标：适用于需要优化光伏系统性能的场合，如太阳能电站、分布式光伏发电系统等。目标是提高光伏系统的发电效率，降低能耗，延长设备使用寿命。 其他说明：本文不仅提供了理论依据和技术细节，还强调了清洁能源发展的重要性和未来的研究方向。
哈工大威海近世代数课件.zip
08-23
哈工大威海近世代数课件
Micro API Framework 是一款基于go-micro打造的starter-kit微服务框架.zip
08-23
Micro API Framework 是一款基于go-micro打造的starter-kit微服务框架.zip
学生测验分数数据集（16列，1053条记录）CSV
08-23
该数据集包含注册创新与创业课程的学生的匿名测验分数。数据是从整个学期进行的多个测验中收集的。对于最终评估，考虑了最好的 9 个分数，然后缩减到最高 30 个。 特征： Roll Number：唯一的学生标识符 Quiz 1至 ： 个人测验分数（满分 5 分）Quiz N Total：所有测验分数的总和
基于 go 模板引擎的 web开发 代码生成器 code generator.zip
最新发布
08-23
基于 go 模板引擎的 web开发 代码生成器 code generator.zip
如何使用perl -e 的方式计算出来
05-30
好的，用户现在想用Perl来计算从指定日期（比如05/18/25）到当前日期的天数。之前他们提到了使用passwd -s命令获取的日期格式是两位数的年份，现在需要转换成四位数，然后计算天数差。首先，我需要确认用户提供的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值