BZOJ 3998 TJOI2015 弦论 后缀自动机

本文介绍了一种使用后缀自动机(SAM)解决求字符串中严格/非严格K小子串问题的方法。首先构建SAM,接着通过BFS计算各状态出现次数,并用DFS计算节点后继状态数。

题目大意:求严格/非严格K小子串 
首先建立Sam 
然后BFS一遍求出每个点代表状态的出现次数 
此时如果是严格的那么每个点代表状态的出现次数都应该是1 
然后DFS一遍求出每个节点的后继状态个数 
然后就随便搞了啊= = 
妈了个鸡卡常数。。。

<code class="language-c++ hljs perl has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background: transparent;"><span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">#include <cstdio></span>
<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">#include <cstring></span>
<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">#include <iostream></span>
<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">#include <algorithm></span>
<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">#define M 500500</span>
using namespace std;
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> type,k;
char <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">s</span>[M],ans[M];<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> tot;
namespace Suffix_Automaton{
    struct Sam{
        Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*son</span>[<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">26</span>],<span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*parent</span>;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> max_dpt,cnt;
        long long size;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> v;
        void* operator new (size_t,<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">_</span>)
        {
            static Sam mempool[M<<<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>],<span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*C</span>=mempool;
            C->max_dpt=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">_</span>;
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> C++;
        }
    }<span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*root</span>=new (<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>)Sam,<span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*last</span>=root;
    void Extend(<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">x</span>)
    {
        Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*p</span>=<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">last</span>;
        Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*np</span>=new (p->max_dpt+<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>)Sam;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(;p&&!p->son[<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">x</span>];p=p->parent)
            p->son[<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">x</span>]=np;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(!p)
            np->parent=root;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">else</span>
        {
            Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*q</span>=p->son[<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">x</span>];
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(p->max_dpt+<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>==<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">q</span>->max_dpt)
                np->parent=<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">q</span>;
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">else</span>
            {
                Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*nq</span>=new (p->max_dpt+<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>)Sam;
                memcpy(nq->son,<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">q</span>->son,sizeof nq->son);
                nq->parent=<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">q</span>->parent;
                <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">q</span>->parent=nq;np->parent=nq;
                <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(;p&&p->son[<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">x</span>]==<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">q</span>;p=p->parent)
                    p->son[<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">x</span>]=nq;
            }
        }
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">last</span>=np;
    }
    void BFS()
    {
        static Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*q</span>[M<<<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>];
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i,r=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>,h=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
        <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">q[++r]</span>=root;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">while</span>(r!=h)
        {
            Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*p</span>=<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">q[++h]</span>;
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(i=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;i<<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">26</span>;i++)
                <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(p->son[i]&&p->son[i]->v!=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>)
                    p->son[i]->v=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>,<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">q[++r]</span>=p->son[i];
        }
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(i=r;i>=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>;i--)
        {
            Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*p</span>=<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">q[i]</span>;
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(type==<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>)
                p->cnt=(bool)p->cnt;
            p->parent->cnt+=p->cnt;
        }
    }
    void DFS(Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*p</span>)
    {
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i;
        p->v=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>;
        p->size=p->cnt;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(i=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;i<<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">26</span>;i++)
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(p->son[i])
            {
                <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(p->son[i]->v!=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">2</span>)
                    DFS(p->son[i]);
                p->size+=p->son[i]->size;
            }
    }
    void Get_Kth(Sam <span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">*p</span>,<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> k)
    {
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(k<=p->cnt)
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> ;
        k-=p->cnt;
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(i=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;i<<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">26</span>;i++)
            <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(p->son[i])
            {
                <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(k<=p->son[i]->size)
                {
                    ans[++tot]=i+<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'a'</span>;
                    Get_Kth(p->son[i],k);
                    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> ;
                }
                k-=p->son[i]->size;
            }
    }
}
<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> main()
{
    using namespace Suffix_Automaton;
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">int</span> i;
    scanf(<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"<span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">%s</span><span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">%d</span><span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">%d</span>"</span>,<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">s</span>+<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>,&type,&k);
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">for</span>(i=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>;<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">s</span>[i];i++) 
    {
        Extend(<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">s</span>[i]-<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">'a'</span>);
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">last</span>->cnt++;
    }
    BFS();root->cnt=<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
    DFS(root);
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">if</span>(root->size<k)
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> cout<<-<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span><<endl,<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
    Get_Kth(root,k);
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">printf</span>(<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"<span class="hljs-variable" style="color: rgb(102, 0, 102); box-sizing: border-box;">%s</span>\n"</span>,ans+<span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">1</span>);
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> <span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box;">0</span>;
}</code>
跟网型逆变器小干扰稳定性分析与控制策略优化研究(Simulink仿真实现)内容概要:本文围绕跟网型逆变器的小干扰稳定性展开分析,重点研究其在电力系统中的动态响应特性及控制策略优化问题。通过构建基于Simulink的仿真模型,对逆变器在不同工况下的小信号稳定性进行建模与分析,识别系统可能存在的振荡风险,并提出相应的控制优化方法以提升系统稳定性和动态性能。研究内容涵盖数学建模、稳定性判据分析、控制器设计与参数优化,并结合仿真验证所提策略的有效性,为新能源并网系统的稳定运行提供理论支持和技术参考。; 适合人群:具备电力电子、自动控制或电力系统相关背景,熟悉Matlab/Simulink仿真工具,从事新能源并网、微电网或电力系统稳定性研究的研究生、科研人员及工程技术人员。; 使用场景及目标:① 分析跟网型逆变器在弱电网条件下的小干扰稳定性问题;② 设计并优化逆变器外环与内环控制器以提升系统阻尼特性;③ 利用Simulink搭建仿真模型验证理论分析与控制策略的有效性;④ 支持科研论文撰写、课题研究或工程项目中的稳定性评估与改进。; 阅读建议:建议读者结合文中提供的Simulink仿真模型,深入理解状态空间建模、特征值分析及控制器设计过程,重点关注控制参数变化对系统极点分布的影响,并通过动手仿真加深对小干扰稳定性机理的认识。
### NOIP2015 运输计划 BZOJ4326 题解分析 #### 问题背景 该问题是经典的图论优化问题之一,主要考察树结构上的路径操作以及高效的数据处理能力。题目要求在一个由 $n$ 个节点组成的无向连通树中找到最优的一条边将其改造为虫洞(通过此边不需要耗费时间),从而使得给定的 $m$ 条运输路径中的最长耗时最小化。 --- #### 解决方案概述 解决这一问题的核心在于利用 **二分答案** 和 **树上差分技术** 的组合来实现高效的计算过程。以下是具体的技术细节: 1. **二分答案**: 设当前目标是最小化的最大路径长度为 $T_{\text{max}}$。我们可以通过二分的方式逐步逼近最终的结果。每次尝试验证是否存在一种方式将某条边改为虫洞后使所有路径的最大值不超过当前设定的目标值 $mid$[^1]。 2. **路径标记与统计**: 使用树上差分的思想对每一条路径进行标记并快速统计受影响的情况。假设两点之间的最近公共祖先 (Lowest Common Ancestor, LCA) 是 $r = \text{lca}(u_i, v_i)$,则可以在三个位置分别施加影响:增加 $(u_i + 1), (v_i + 1)$ 同时减少 $(r - 2)$。这种操作能够有效覆盖整条路径的影响范围,并便于后续统一查询和判断[^1]。 3. **数据结构支持**: 结合线段树或者 BIT (Binary Indexed Tree),可以进一步加速区间修改和单点查询的操作效率。这些工具帮助我们在复杂度范围内完成大量路径的同时更新和检索需求[^2]。 4. **实际编码技巧**: 实现过程中需要注意一些边界条件和技术要点: - 正确维护 DFS 序列以便映射原树节点到连续编号序列; - 准备好辅助函数用于快速定位 LCA 节点及其对应关系; - 编码阶段应特别留意变量初始化顺序及循环终止逻辑以防潜在错误发生。 下面给出一段基于上述原理的具体 Python 实现代码作为参考: ```python from collections import defaultdict, deque class Solution: def __init__(self, n, edges): self.n = n self.graph = defaultdict(list) for u, v, w in edges: self.graph[u].append((v, w)) self.graph[v].append((u, w)) def preprocess(self): """Preprocess the tree to get dfs order and lca.""" pass def binary_search_answer(self, paths): low, high = 0, int(1e9) best_possible_time = high while low <= high: mid = (low + high) // 2 if self.check(mid, paths): # Check feasibility with current 'mid' best_possible_time = min(best_possible_time, mid) high = mid - 1 else: low = mid + 1 return best_possible_time def check(self, limit, paths): diff_array = [0]*(self.n+1) for path_start, path_end in paths: r = self.lca(path_start, path_end) # Apply difference on nodes based on their relationship. diff_array[path_start] += 1 diff_array[path_end] += 1 diff_array[r] -= 2 suffix_sum = [sum(diff_array[:i]) for i in range(len(diff_array)+1)] # Verify whether any edge can be modified within given constraints. possible_to_reduce_max = False for node in range(1, self.n+1): parent_node = self.parent[node] if suffix_sum[node]-suffix_sum[parent_node]>limit: continue elif not possible_to_reduce_max: possible_to_reduce_max=True return possible_to_reduce_max # Example usage of class methods would follow here... ``` --- #### 总结说明 综上所述,本题的关键突破点在于如何巧妙运用二分策略缩小搜索空间,再辅以恰当的树形结构遍历技术和差分手段提升整体性能表现。这种方法不仅适用于此类特定场景下的最优化求解任务,在更广泛的动态规划领域也有着广泛的应用前景[^3]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值