2019 OI日记

//  我觉得记日记是个好习惯吧 毕竟指不定哪天就学不下去了 就AFO了 就没有梦了   //

[置顶]活跃于你谷普及训练场、ybt(没底气说全部)、loj(提高基础部分)  //优先级从前往后 因为我还是太菜了

2019.1.26 :

寒假开始了 带着并不可观的期末成绩也无力去冲刺了 不可以颓废.
 听了老叶的动员大会 感觉自己迟早AFO
 于是可以努力学些东西了 至少要不留遗憾.
      幸好有我女人陪我（逃

[欧拉图规律]  //超级重要的样子
⒈凡是由偶点组成的连通图，一定可以一笔画成。画时可以把任一偶点为起点，最后一定能以这个点为终点画完。
⒉凡是只有两个奇点的连通图（其余都为偶点），一定可以一笔画成。画时必须把一个奇点为起点，另一个奇点终点。
⒊其他情况的图都不能一笔画出。（有偶数个奇点除以二便可算出此图需几笔画成。）   来源：CSDN——LLXL

今日下午 过掉了 排序EX @Luogu普及练习场
希望早日刷完普及 补补基础啊 这个效率太慢了啊 不行不行还是太菜了

每日份加油@！

2019.1.27 :

(上午)

[哈希]哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法。/baike

上午算是磨掉了哈希基础题吧... 外带一个自认为可读性为零的看不懂的广搜   勉强看懂了吧  [链] 我还是太菜了
//loj #103.子串查找

#include<bits/stdc++.h>
using namespace std;
unsigned long long kk[1000005],k=99979,s,sum[1000005];
int l1,l2,ans;
char s1[1000005],s2[1000005];
int main()
{
    kk[0]=1; for(int i=1;i<100000;i++) kk[i]=kk[i-1]*k;//预处理k^n
    scanf("%s%s",s2+1,s1+1);
    l1=strlen(s1+1),l2=strlen(s2+1);
    for(int i=1;i<=l2;i++) sum[i]=sum[i-1]*k+s2[i];//计算主串哈希值
    for(int i=1;i<=l1;i++) s=s*k+s1[i];//计算匹配串哈希值
    for(int i=0;i<=l2-l1;i++) if(s==sum[i+l1]-sum[i]*kk[l1]) ans++;//枚举起点为i、长度为n的子串，判断是否与匹配串相匹配
    printf("%d",ans);
    return 0;
}

//还有#10036...
（今天尽量要熟悉hash 继续努力:-）

(下午)有点困啊 然后肩膀这疼的要命 和奴仆聊天的时候左手大拇指突然抽了 真是丧

（码了几道深搜 @Luogu

请继续加油 要做你们一辈子的大哥>

2019.1.28 :

（上午）继续练习了shit hash算法 我发四再也不碰字符串了  打个模板都调死 我真的太菜了 //@Luogu P3370 \ P2957

（中午）Ljh大佬可回收大垃圾桶里捡一大沓书着实吓到我了 哦还有他循环不尽的This Way Back Home.

（下午）较为高效地 通过了 @Luogu-普及训练场 深度优先搜索以及贪心 两个板块 （真相是每个过3道就点完成 （我就是这么菜

[欧几里德算法] 即辗转相除法的另一个貌似更大气的名字.

欧几里德算法又称辗转相除法，是指用于计算两个正整数a，b的最大公因数。应用领域有数学和计算机两个方面。计算公式gcd(a,b) = gcd(b,a mod b)。欧几里德算法和扩展欧几里德算法可使用多种编程语言实现。

定理：两个整数的最大公约数等于其中较小的那个数和两数相除余数的最大公约数。最大公约数（Greatest Common Divisor）缩写为GCD。 /baike

我稍微捣鼓了一下证明...好吧还是自行百度吧 （太菜了我  （上面那个baike是链

 

         给自己留下一个拓展欧几里德算法的大坑  我感觉我初中生涯都填不上了。

         来自今天的加油.

 

 

2019.1.29 :

 上午：也只有上午了 填了两道模拟题 就当练ACM了 @Luogu（模拟是真的烦啊烦啊烦啊烦啊烦啊烦啊烦啊烦啊...

幸好今天loj爆炸升天 不用查作业了    关于loj上之前我做过的题目 基本都是抄的题解 现在自己码起来觉得好痛苦啊... 还是太菜了 要努力学习提高知识啊 我才不想被不明不白的淘汰了。Oi事业是一个值得奉献一生的事业 虽然我很菜 没有大佬的逆天天赋 没有大佬的码力深厚 但是我有大佬对Code的爱好与兴趣。寒假集训第一期就这么结束了.余下的日子不知会不会更一些乱七八糟的与Oi无关的东西 我希望还是可以记一下日记啊 尽管就这么跑题了。

 来自今天的加油~     // 关于她啊 —— 知其不可偏为之 虽千万人吾往矣  （五句话真的不好开口浪费机会呢 现在就很焦灼 （逃

 

 

  

 

一口气补上好几周 在家里根本就刷不了Oi 老机子不知怎的就调试不了 不知道是什么毛病 不管了...

还是做了几天作业的吧我觉得 头几天和老妈吵了一次 挺严重的 颓废了两天啊睡觉到中午手机玩到半夜 现在想想觉得没有猝死已是奇迹

春节期间 好的我不负众望的入了农药的坑 一学期没玩操作与意识几乎都没有了 和表哥表弟和好朋友各种躺也上了砖石啊 砖石真的好打过铂金

她不理我了两三天啊 又一段颓废的日子 白天写写作业打打农药 以忙碌来强行让自己别想她 晚上在床上是真翻来覆去睡不着啊 正如我说的 没了你我怎会好过

还真没想过语文作业怎么办 其他作业都做的七七八八了吧 明天就是初九 该回校敲code了 真好 我想死它了 （尽管要被淘汰了...

无论怎样 丧的情绪是不允许出现 或是流露的.

然后便是这好几周的姗姗来迟的加油  一定要努力改变自己啊 让自己高看一眼也好.

 

 

 

 

 

2019.2.13 :

今日：KMP算法

KMP算法是一种字符串匹配算法。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n)。/baike

注：由于KMP算法只预处理B串，因此这种算法很适合这样的问题：给定一个B串和一群不同的A串，问B串是哪些A串的子串。/信息学奥赛一本通·提高篇

还是先@Luogu的模板题   P3375【模板】KMP字符串匹配   ←这是个链 

Code：

#include<bits/stdc++.h>
using namespace std;
char a[],b[];
int nxt[],la,lb;
void getnext()
{
    int k=;nxt[]=;
    for(int i=;i<=lb;i++)
    {
         while(k>&&b[k+]!=b[i+])k=nxt[k];
         if(b[k+]==b[i+])k++;
         nxt[i+]=k;
    }
}
void kmp()
{
    int k=;
    for(int i=;i<la;i++)
    {
        while(k>&&b[k+]!=a[i+])k=nxt[k];
        if(b[k+]==a[i+])k++;
        if(k==lb)printf("%d\n",i-k+),k=nxt[k];
    }
}
int main()
{
    scanf("%s%s",a+,b+);
    la=strlen(a+),lb=strlen(b+);
    getnext();
    kmp();
    for(int i=;i<=lb;i++)printf("%d ",nxt[i]);
    return ;
}

关于这个这个Next数组的妙用 我至今不能理解 看来没得空了

顺带Ac@loj #10043 #10035 #10045.（长吁一口气

数论什么的暂时放弃了 不仅难而且我现在是需要大量时间来掌握提高算法的 尽管普及都没学会

今日份加油↖(^ω^)↗

2019.2.14:

 情人节快洛！

今日:  Trie 字典树

Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希表高 。/baike

树的每条边上恰好对应一个字符，每个顶点代表从根到该节点的路径所对应的字符串（将所有经过的边上的字符按顺序连接起来）。有时我们也称Trie上的边为转移，顶点为状态。/ybt·提高

我真的觉得需要放一张图来帮助我理解 4个月前的我听的雾死... 图这就来 来自百科

Trie可以用几个数组来储存它的关键信息。代码展示如下：

int ch[N][Z]； //Z为字符集大小
bool bo[N]; //若bo[]=true则表示从根到该点经过的边上字母组成的字符串是实际字符串集合中的元素

展现一下Trie的插入（例为插入一个字符串S）：

void insert(char *s)  //char *s表示一个字符数组
{
    int len=strlen(s),u=;  //1为根节点
    for(int i=;i<len;i++)
    {
        int c=s[i]-'a';
        if(!ch[u][c]) ch[u][c]=++tot; //若不存在这条边则要新建一个节点与转移边
        u=ch[u][c];  //tot为总点数
    }
    bo[u]=true;  //在串的结尾处将bo赋值，表示它代表一个实际字符串集合中的元素
}

查询一个字符串S是否是给定字符串集合中某个串的前缀 与插入大同小异啊

bool find(char *s)
{
    int len=strlen(s),u=;
    for(int i=;i<len;i++)
    {
        int c=s[i]-'';
        if(!tr[u][c]) return ;
        u=tr[u][c];
    }
    return ;
}            

字典树运用很灵性啊还可以看看今天把find和insert结合查询的题目 @loj#10049 [链]

今日份加油啊！/今天话有点多...

由于AC自动机过难就手动跳过了 至此字符串算法已学习。

2019.2.15:

今日上午：Kruskal (并查集优化 （最小生成树

主体思路：将边按权值排序后，每次选取两端点未在一集合的的边加入生成树，直到加入了n-1条边  。这里使用并查集判断待加入边的两端点是否在同一集合（避免构建环）并加入生成树的操作。

应该算复习... 不想给代码了...确实很简单...

今日下午：Prim (堆优化 （最小生成树

  主体思路：将整个图分成V_A和V_B两个集合，最开始的V_A仅包含一个点（有时题目中输入的那种），每次操作从V_B中取出一个距离V_A最小的点加入V_A，直到所有的点都加入V_A。这里可以使用堆来记录V_B中每个点到V_A的最短距离并维护其最小值（STL大法好），在加入点之后该距离需要更新。需要注意的是，V_A最开始包含的点不同，其所形成的最小生成树的形态也不同，但边权和的最小值是唯一的。

其实也算复习 但是我从未用过堆优化啊而且之前用邻接矩阵存的

Code：//未使用堆优化

#include<bits/stdc++.h>
using namespace std;
struct edge{int v,w,next;}e[];//注意是无向图，开两倍数组(等效于200005*2)
int head[],dis[],cnt,n,m,tot,now=,ans;
bool vis[];
void add(int x,int y,int z){e[++cnt].v=y,e[cnt].w=z,e[cnt].next=head[x],head[x]=cnt;}//链式前向星加边
int prim()
{
    for(int i=;i<=n;i++) dis[i]=; //先把dis数组附为极大值
    for(int i=head[];i;i=e[i].next) dis[e[i].v]=min(dis[e[i].v],e[i].w); //这里要注意重边，所以要用到min
    while(++tot<n)//最小生成树边数等于点数-1
    {
        int minn=;//把minn置为极大值
        vis[now]=;//标记点已经走过
        //枚举每一个没有使用的点
        //找出最小值作为新边
        //注意这里不是枚举now点的所有连边，而是1~n
        for(int i=;i<=n;i++)
        if(!vis[i]&&minn>dis[i]) minn=dis[i],now=i;
        ans+=minn;
        for(int i=head[now];i;i=e[i].next)//枚举now的所有连边，更新dis数组
        {
            int v=e[i].v;
            if(dis[v]>e[i].w&&!vis[v]) dis[v]=e[i].w;
        }
    }
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=,x,y,z;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z),add(y,x,z);//无向图双向建边
    }
    printf("%d",prim());
    return ;
}

Q1：两种最小生成树算法如何区分并选用？

A1：P对点进行操作，K对边进行操作（废话！） 观察两个算法的时间复杂度，堆优化的P为O((n+m)logm)，并查集的K为O(mlogm+mα(n))，可以发现P适合用于稠密图，K适合用于稀疏图。（前文 α(n)是一次并查集的复杂度

Q2：为何示例代码不使用堆优化？

A2：因为我不会... 因为对于一个稠密图来说，这并不能快多少。详见zubizakeli大佬的一篇博客。[链]

今日份加油！

2019.2.16：

  今日：最短路径

1、Dijkstra + 堆优化 blingbling

    算法思想：如果图是不带负权的有向图或无向图，我们可以使用类似于Prim算法的贪心策略，从起点v0每次新拓展一个距离最短的点，再以这个点为中心点，更新起点到其他所有点的距离。可以使用堆优化查找操作，时间复杂度降为O((n+m)logm)。

2、Floyd 算法 blingbling

    算法思想：如果图没有负环，可以使用动态规划型的Floyd算法求解最短路径。设d[i][j][k]表示路径中间只允许经过节点1-k的情况下，i到j的最短路距离。

分类：1 最短路径经过点k,d[i][j][k]=d[i][k][k-1]+d[k][j][k-1];

2 最短路径不经过点k,d[i][j][k]=d[i][j][k-1];

　核心code：

for(int k=;k<=n;k++)
    for(int i=;i<=n;i++)
        for(int j=;j<=n;j++)
            d[i][j]=min(d[i][k]+d[k][j],d[i][j]);

3、Bellman-Ford 算法 blingbling  合并在下面“SPFA”算法。‘

4、SPFA 算法 blingbling

    SPFA算法在国际上通称为“队列优化的Bellman-Ford算法”，仅在中国流行“SPFA算法”的称谓。

算法思想：设立一个先进先出的队列用来保存待优化的节点，优化时每次取出队首节点u，并且用u点当前的最短路估计值对u点所指向的节点v进行松弛操作，如果v点的最短路估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出节点来进行松弛操作，直到队列为空为止。

一般单源最短路问题采用D+堆的算法，多源最短路问题F有很大的发挥空间，若有负环的情况请果断采用已死的SPFA.

附：一个很棒很棒的教学材料 链

加油.

然后我颓废了很长的一段时间 甚至一度被认为退役选手

但我不曾放弃

分割------

noip已经不在 能力认证比赛不会轻易放弃

不想就这样碌碌无为 随便就退役

所以我应该加油了Er

2019.9.15  CSP-S 训练模拟题

险些爆0...（8分差不了太多了

第一题的不会做是我Dp太菜的表现

而第二题不敢打暴力我也是怕了

前两题均已在@Luogu订正

T3黑题有点Hentai （题目都没读懂

请继续加油！