BZOJ 3998 TJOI2015 弦论 后缀自动机

最新推荐文章于 2019-05-03 23:06:00 发布
转载 最新推荐文章于 2019-05-03 23:06:00 发布 · 2.4k 阅读 · 0

本文介绍了一种使用后缀自动机（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>
love__linux
关注
【BZOJ3998】【TJOI2015】弦论 后缀自动机
辗转山河弋流歌
04-29 2819
题解： 首先我们可以建一个后缀自动机。 然后每条路径走到每个点都是一个串，它们是有字典序的。 我们只需要统计出往每个点走之后都有多少串就好了。 fi=(∑fson)+numif_i = (\sum {f_{son}})+num_i 对于不计重复的情况下，numi=1num_i=1 对于计算重复的情况下，每个节点都有多种走到最后的方式，numinum_i 就是看有这个种数。 比如 ab
【bzoj3998】[TJOI2015]弦论 后缀自动机
Oxer的专栏
06-29 669
非常好的一道裸题 T=1 每个节点的出现次数=它的right集合大小 初始时，每加入一个节点，它对应的right集合大小就为1 T=0 每个节点算一次，即把right集合大小强制变为1 对深度计数排序后，节点i对fa[i]产生贡献 计算出size[i]表示包含节点i在内，所有的能转移到的子串的出现次数之和 注意：不能按bfs序处理size，因为计算size时，还
BZOJ3998 TJOI2015弦论（后缀自动机）
weixin_30616969的博客
05-03 142
　　先考虑相同子串视为一个。按SAM的拓扑序预处理出从每个节点开始能得到多少个本质不同子串（注意虽然一个节点对应多个子串，但到达该点时当前的子串显然是确定为其中一个的），然后按位贪心即可。 　　相同子串视为多个的做法也没有本质区别。求出每个节点的right集合大小，同样预处理出从每个节点开始能得到多少个子串按位贪心。 #include<iostream> #include&...
BZOJ3998 TJOI2015 弦论 后缀自动机
a18700013354的博客
02-28 145
题意：求一个字符串的第K小字串，T=0表示不同位置相同的子串算作一个，T=1算作多个 题意： 建出SAM来跑第K子串，由于一个点所代表的子串在原串出现次数为其子树叶子结点的数量，因而有： T==1，每个点的|right|=1 T==2，每个点的|right|=子树叶子结点数 BFS跑出所有子串出现的次数即|right|，DFS统计每个节点的出现次数和，具体细节看代码。 然后处...
BZOJ 3998 TJOI 2015 弦论 后缀自动机
とある黄鱼のOIブログ
04-17 657
求第k大子串 http://blog.youkuaiyun.com/huanghongxun/article/details/51164051#include <cstring> #include <cstdio> #define FOR(i,j,k) for(i=j;i<=k;++i) const int rt = 1, N = 1000005; int last = 1, cnt = 1, len = 0
BZOJ 3998 TJOI2015弦论
Rayment的博客
05-03 388
Problem BZOJ Solution 建立后缀自动机，然后我们可以用类似二叉搜索树的思想。先排出拓扑序，然后将这个节点所代表的子串的个数处理出来，然后枚举第k小的是否在其中即可。 我们不妨令g[u]表示从节点u开始能代表的后缀个数，那么可以做一个拓扑动规。 我们容易得到方程： g[u]=sz[u]+∑u−&amp;amp;gt;vg[v]g[u]=sz[u]+∑u−&amp;amp;gt;vg[v]g[u]...
BZOJ 3998 TJOI2015 弦论 后缀自动机+DAG上的dp
diezhan7052的博客
03-08 141
题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=3998 题意概述：对于一个给定长度为N的字符串，求它的第K小子串是什么，T为0则表示不同位置的相同子串算作一个。T=1则表示不同位置的相同子串算作多个。N<=500000,K<=10^9. 应该是有三种做法的（当然后缀树我还没有看），于是就把这个东西当成...
[BZOJ3998][TJOI2015]弦论 后缀自动机
DOFYPXY的博客
12-26 446
建出SAM。 假设T=0，那么除了根节点每个点代表1个串。 假设T=1，那么除了根节点每个点代表其right集合大小个字串。 先把每个点代表多少个串统计出来，然后就可统计统计转移到某个点之后还能走出多少个字串。 代码：#include<iostream> #include<cstdio> #include<cstring> #define ll long long using namespa
bzoj 3998: [TJOI2015]弦论 （后缀自动机）
clover_hxy的博客
12-20 583
3998: [TJOI2015]弦论 Time Limit: 10 Sec  Memory Limit: 256 MB Submit: 2024  Solved: 665 [Submit][Status][Discuss] Description 对于一个给定长度为N的字符串，求它的第K小子串是什么。 Input  第一行是一个仅由小写英文字母构成的字符串S 第二行为两
BZOJ3998 [TJOI2015]弦论（后缀自动机求字典序第k小子串）
qq_21829533的博客
02-14 826
题目链接 先考虑相同子串算不同的情况 性质一：后缀自动机中parent树中一个节点子树中np类节点的个数为该串在原串中出现的次数 根据这个性质可以通过一遍parent树上的dfs求出每个点的出现次数 后缀自动机里每个节点代表的串是多个的，但是这些串出现的次数都是一样的。 因此我们沿着字符边走到一个点的时候，这个点的权值就是这个字符串的出现次数 此时可以考虑到和权值线段树找第k大的思路：树上二分 记...
BZOJ 3997 TJOI2015 组合数学 Dilworth定理
世界
04-21 3874
题目大意：给定一个网格图，每次从左上角出发，只能往右或往下走，最后到达右下角，每个格子有最低经过次数，问最少走几次 Dilworth定理：DAG的最小链覆盖=最大点独立集 最小链覆盖指选出最少的链(可以重复)使得每个点都在至少一条链中 最大点独立集指最大的集合使集合中任意两点不可达 此题中最大点独立集显然是一个集合满足集合中任意两点都是左下-右上的关系 DP一遍就能出解 复杂度O(Tmn)
bzoj3473: 字符串（后缀自动机+启发式合并）
苟为蒟蒻又何妨
12-22 439
传送门 调代码调的我怀疑人生。 启发式合并用迭代写怎么都跑不过（雾 换成了dfsdfsdfs版本的终于过了233. 题意简述：求给出nnn个字串，对于每个给定的字串求出其有多少个字串在至少kkk个剩下字串中出现过。 显然先对所有字串建一个samsamsam出来，然后对于每个状态用一个setsetset维护在哪些字串里面出现过（这个显然需要在建完parentparentparent树之后启发式合并...
Bzoj3172——单词（AC自动机）
wangyh1008的博客
08-08 333
3172: [Tjoi2013]单词Time Limit: 10 Sec&amp;amp;nbsp;&amp;amp;nbsp;Memory Limit: 512 MBSubmit: 5051&amp;amp;nbsp;&amp;amp;nbsp;Solved: 2467[Submit][Status][Discuss]Description某人读论文，一篇论文是由许多单词组成。但他发现一个单词会在论文中出现很多次，现在想知道每个单词分别在论文中出现多少次。I...
BZOJ 3170 TJOI 2013 松鼠聚会 切比雪夫距离
(╯°口°)╯(┴—┴
12-23 1039
题目大意：给出平面上的一些点，求这些点中的一个使得所有点到这个点的切比雪夫距离之和最短。 思路：切比雪夫距离和曼哈顿距离是可以相互转化的，具体实现就是吧一个点的坐标由(x,y)变成(x - y,x + y)，求切比雪夫距离就可以转化成求曼哈顿距离了，很好推。 然后就是暴力枚举每一个点，统计出来每个点的曼哈顿距离之和，最后取一个最小值。 CODE： #include #
Zernike 多项式在圆形、六边形、椭圆形、矩形或环形瞳孔上应用（Matlab代码实现）
12-06
Zernike 多项式在圆形、六边形、椭圆形、矩形或环形瞳孔上应用（Matlab代码实现）内容概要：本文主要介绍Zernike多项式在不同形状瞳孔（如圆形、六边形、椭圆形、矩形或环形）上的应用，并提供了相应的Matlab代码实现方法。该技术常用于光学系统中的波前分析与像差校正，能够有效描述各种非标准瞳孔形状下的光学特性，适用于需要精确建模和仿真光学系统的科研与工程场景。文中强调借助Matlab工具进行算法开发与验证，提升科研效率。; 适合人群：具备一定光学基础知识和Matlab编程能力的高校学生、科研人员及从事光学系统设计的工程师。; 使用场景及目标：① 光学像差分析与建模；② 自适应光学系统仿真；③ 不规则瞳孔条件下波前传感与矫正算法研究；④ 高级光学教学与实验演示。; 阅读建议：建议读者结合Matlab代码实践操作，深入理解Zernike多项式的数学原理及其在不同几何形状瞳孔上的正交性与展开特性，同时可参考文档中提供的其他相关案例进行拓展学习。
斯坦福大学深度学习课程CS231n个人学习与作业记录项目_深度学习计算机视觉卷积神经网络图像分类目标检测语义分割神经网络架构反向传播优化算法激活函数损失函数数据增强模型训练验证测试.zip
最新发布
12-06
斯坦福大学深度学习课程CS231n个人学习与作业记录项目_深度学习计算机视觉卷积神经网络图像分类目标检测语义分割神经网络架构反向传播优化算法激活函数损失函数数据增强模型训练验证测试.zip
mysqltools8-权威指南项目是一个全面深入的MySQL数据库自动化运维与高效管理解决方案的详细技术文档与最佳实践集合_该项目详细阐述了如何利用ansible自动化工具实现M.zip
12-06
mysqltools8-权威指南项目是一个全面深入的MySQL数据库自动化运维与高效管理解决方案的详细技术文档与最佳实践集合_该项目详细阐述了如何利用ansible自动化工具实现M.zip
基于Vue与SpringCloud的微服务分布式博客系统设计与实现
12-06
**项目名称：** 基于Vue.js与Spring Cloud架构的博客系统设计与开发——微服务分布式应用实践 **项目概述：** 本项目为计算机科学与技术专业本科毕业设计成果，旨在设计并实现一个采用前后端分离架构的现代化博客平台。系统前端基于Vue.js框架构建，提供响应式用户界面；后端采用Spring Cloud微服务架构，通过服务拆分、注册发现、配置中心及网关路由等技术，构建高可用、易扩展的分布式应用体系。项目重点探讨微服务模式下的系统设计、服务治理、数据一致性及部署运维等关键问题，体现了分布式系统在Web应用中的实践价值。 **技术架构：** 1. **前端技术栈：** Vue.js 2.x、Vue Router、Vuex、Element UI、Axios 2. **后端技术栈：** Spring Boot 2.x、Spring Cloud (Eureka/Nacos、Feign/OpenFeign、Ribbon、Hystrix、Zuul/Gateway、Config) 3. **数据存储：** MySQL 8.0（主数据存储）、Redis（缓存与会话管理） 4. **服务通信：** RESTful API、消息队列（可选RabbitMQ/Kafka） 5. **部署与运维：** Docker容器化、Jenkins持续集成、Nginx负载均衡 **核心功能模块：** - 用户管理：注册登录、权限控制、个人中心 - 文章管理：富文本编辑、分类标签、发布审核、评论互动 - 内容展示：首页推荐、分类检索、全文搜索、热门排行 - 系统管理：后台仪表盘、用户与内容监控、日志审计 - 微服务治理：服务健康检测、动态配置更新、熔断降级策略 **设计特点：** 1. **架构解耦：** 前后端完全分离，通过API网关统一接入，支持独立开发与部署。 2. **服务拆分：** 按业务域划分为用户服务、文章服务、评论服务、文件服务等独立微服务。 3. **高可用设计：** 采用服务注册发现机制，配合负载均衡与熔断器，提升系统容错能力。 4. **可扩展性：** 模块化设计支持横向扩展，配置中心实现运行时动态调整。 **项目成果：** 完成了一个具备完整博客功能、具备微服务典型特征的分布式系统原型，通过容器化部署验证了多服务协同运行的可行性，为云原生应用开发提供了实践参考。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
【NOIP2015】运输计划 bzoj4326
04-13
### NOIP2015 运输计划 BZOJ4326 题解分析 #### 问题背景 该问题是经典的图论优化问题之一，主要考察树结构上的路径操作以及高效的数据处理能力。题目要求在一个由 $n$ 个节点组成的无向连通树中找到最优的一条边将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值