remove old links

Author: GoodCoder666

index.xml

@@ -1516,8 +1516,8 @@ $$<p><br>
         <description>&lt;p&gt;&lt;a class=&#34;link&#34; href=&#34;https://www.luogu.com.cn/problem/P9754&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;题目传送门&lt;/a&gt;&lt;br&gt;
 &lt;a class=&#34;link&#34; href=&#34;https://www.luogu.com.cn/blog/best-blogs/solution-p9754&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
-    &gt;洛谷博客&lt;/a&gt; &lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/134758697&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
-    &gt;CSDN&lt;/a&gt;&lt;/p&gt;
+    &gt;洛谷博客&lt;/a&gt; &lt;a class=&#34;link&#34; href=&#34;https://www.cnblogs.com/stanleys/p/18403713/csps2023-t3&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+    &gt;博客园&lt;/a&gt;&lt;/p&gt;
 &lt;h3 id=&#34;基本思路&#34;&gt;基本思路
 &lt;/h3&gt;&lt;p&gt;本题主要考查编码能力，所以直接给出基本思路：&lt;/p&gt;
 &lt;ul&gt;
@@ -4147,7 +4147,7 @@ $0\le s_{i,j}\le 10^{16}$&lt;/p&gt;
 &lt;/h3&gt;&lt;p&gt;对于两种算法，都需要预处理出每个结点的深度。&lt;br&gt;
 &lt;strong&gt;一个结点的深度定义为这个结点到树根的距离。&lt;/strong&gt;&lt;/p&gt;
 &lt;p&gt;要预处理出所有结点的深度，很简单：&lt;br&gt;
-运用&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126263935&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+运用&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-tree-dp/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;树形dp&lt;/a&gt;的方法，令 $h_u$ 表示结点 $u$ 的深度，逐层向下推进：&lt;/p&gt;
 &lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
 &lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
@@ -4871,7 +4871,7 @@ $$&lt;p&gt;&lt;br&gt;
 &lt;p&gt;运行时间：$128\mathrm{ms}$&lt;br&gt;
 使用内存：$6.90\mathrm{MB}$&lt;/p&gt;
 &lt;h3 id=&#34;树状数组&#34;&gt;树状数组
-&lt;/h3&gt;&lt;p&gt;关于树状数组的原理我已经在&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126441412&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+&lt;/h3&gt;&lt;p&gt;关于树状数组的原理我已经在&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-fenwick-tree/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;这篇文章&lt;/a&gt;中讲过，这里不再多说了。下面我们考虑如何应用树状数组解决 RMQ 问题。&lt;/p&gt;
 &lt;h4 id=&#34;原算法&#34;&gt;原算法
 &lt;/h4&gt;&lt;p&gt;树状数组可以用&lt;code&gt;lowbit&lt;/code&gt;操作实现&lt;code&gt;prefixSum&lt;/code&gt;（前缀和）以及&lt;code&gt;update&lt;/code&gt;（更新）操作，时间复杂度均为$\mathcal O(N\log N)$。不仅是加法，&lt;strong&gt;对于任意满足结合律的运算这两种操作都有效。&lt;/strong&gt;&lt;/p&gt;
@@ -6515,7 +6515,7 @@ $N$次操作后是否能到达终点$t$？&lt;strong&gt;注意：必须为最终
 &lt;/div&gt;&lt;hr&gt;
 &lt;h2 id=&#34;扩展概念运算&#34;&gt;扩展概念&amp;amp;运算
 &lt;/h2&gt;&lt;h3 id=&#34;lowbit&#34;&gt;lowbit
-&lt;/h3&gt;&lt;p&gt;&lt;code&gt;lowbit(x)&lt;/code&gt;即为二进制下$x$的最低位，如&lt;code&gt;lowbit(10010) = 10&lt;/code&gt;、&lt;code&gt;lowbit(1) = 1&lt;/code&gt;。严格来说$0$没有&lt;code&gt;lowbit&lt;/code&gt;，部分情况下可视为&lt;code&gt;lowbit(0) = 1&lt;/code&gt;。利用&lt;code&gt;lowbit&lt;/code&gt;函数可实现&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126441412&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+&lt;/h3&gt;&lt;p&gt;&lt;code&gt;lowbit(x)&lt;/code&gt;即为二进制下$x$的最低位，如&lt;code&gt;lowbit(10010) = 10&lt;/code&gt;、&lt;code&gt;lowbit(1) = 1&lt;/code&gt;。严格来说$0$没有&lt;code&gt;lowbit&lt;/code&gt;，部分情况下可视为&lt;code&gt;lowbit(0) = 1&lt;/code&gt;。利用&lt;code&gt;lowbit&lt;/code&gt;函数可实现&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-fenwick-tree/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;树状数组&lt;/a&gt;等数据结构。&lt;/p&gt;
 &lt;p&gt;&lt;strong&gt;lowbit 计算方式&lt;/strong&gt;&lt;/p&gt;
 &lt;ol&gt;
@@ -6547,7 +6547,7 @@ $N$次操作后是否能到达终点$t$？&lt;strong&gt;注意：必须为最终
 时间复杂度$\mathcal O(1)$。相比(1)来说，代码更短，速度更快。&lt;/li&gt;
 &lt;li&gt;&lt;code&gt;x &amp;amp; (x - 1)&lt;/code&gt;&lt;br&gt;
 &lt;strong&gt;注意：&lt;code&gt;x &amp;amp; (x - 1)&lt;/code&gt;不是&lt;code&gt;lowbit(x)&lt;/code&gt;，而是&lt;code&gt;x - lowbit(x)&lt;/code&gt;。&lt;/strong&gt;&lt;br&gt;
-这种方法常用于&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126441412&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+这种方法常用于&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-fenwick-tree/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;树状数组&lt;/a&gt;中，可提升&lt;code&gt;x - lowbit(x)&lt;/code&gt;的计算速度。&lt;/li&gt;
 &lt;/ol&gt;
 &lt;h3 id=&#34;popcount&#34;&gt;popcount
@@ -6883,8 +6883,8 @@ P.S. 这函数，不知是哪位神仙想出来的……&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;&lt;h5 id=&#34;习题atcoder-beginner-contest-258-g---trianglehttpsatcoderjpcontestsabc258tasksabc258_g&#34;&gt;习题：&lt;a class=&#34;link&#34; href=&#34;https://atcoder.jp/contests/abc258/tasks/abc258_g&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;AtCoder Beginner Contest 258 G - Triangle&lt;/a&gt;
-&lt;/h5&gt;&lt;p&gt;题意和解法见&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/125582361#t15&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
-    &gt;https://blog.csdn.net/write_1m_lines/article/details/125582361#t15&lt;/a&gt;。&lt;/p&gt;
+&lt;/h5&gt;&lt;p&gt;题意和解法见&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/abc258/#%E9%A2%98%E7%9B%AE%E5%A4%A7%E6%84%8F-2&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+    &gt;我的题解&lt;/a&gt;。&lt;/p&gt;
 &lt;h3 id=&#34;深度优先搜索dfs的位运算优化&#34;&gt;深度优先搜索（DFS）的位运算优化
 &lt;/h3&gt;&lt;p&gt;本算法其实还是&lt;strong&gt;二进制表示子集&lt;/strong&gt;的一种优化，不过内容较多，所以单独放了出来。&lt;/p&gt;
 &lt;p&gt;考虑经典的&lt;strong&gt;八皇后问题&lt;/strong&gt;：&lt;/p&gt;
@@ -8433,10 +8433,10 @@ $$&lt;p&gt;&lt;br&gt;
 &lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
 &lt;/div&gt;
 &lt;/div&gt;&lt;h2 id=&#34;prim&#34;&gt;Prim
-&lt;/h2&gt;&lt;p&gt;Prim算法于1930年由捷克数学家Vojtěch Jarník发现，在1957年又由美国计算机科学家Robert C. Prim独立发现。1959年，Edsger Wybe Dijkstra（没错，就是&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126316941&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+&lt;/h2&gt;&lt;p&gt;Prim算法于1930年由捷克数学家Vojtěch Jarník发现，在1957年又由美国计算机科学家Robert C. Prim独立发现。1959年，Edsger Wybe Dijkstra（没错，就是&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-dijkstra/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;Dijkstra&lt;/a&gt;算法的发明者）再次发现了该算法。因此，在某些场合，Prim算法又被称为DJP算法、Jarník算法或Prim－Jarník算法。&lt;/p&gt;
 &lt;h3 id=&#34;prim-算法流程&#34;&gt;Prim 算法流程
-&lt;/h3&gt;&lt;p&gt;Prim与&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126316941&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+&lt;/h3&gt;&lt;p&gt;Prim与&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-dijkstra/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;Dijkstra&lt;/a&gt;很相似，将顶点分为$S$和$T$两个集合，具体流程如下：&lt;/p&gt;
 &lt;ol&gt;
 &lt;li&gt;初始时，所有顶点全部在$S$中，$T$为空集。&lt;/li&gt;
@@ -8701,7 +8701,7 @@ $$&lt;p&gt;&lt;br&gt;
         <guid>https://goodcoder666.github.io/p/algonotes-dijkstra/</guid>
         <description>&lt;h2 id=&#34;前言&#34;&gt;前言
 &lt;/h2&gt;&lt;p&gt;Dijkstra算法可在$\mathcal O(m\log m)$或$\mathcal O(m\log n)$的时间内求解无负权单源最短路问题。本文中，我们将详细介绍算法的原理、实现，以及常用的两种优化。&lt;/p&gt;
-&lt;p&gt;另外，Dijkstra算法也不要乱用，比如说多源的最短路，用Dijkstra求解的复杂度只有$\mathcal O(nm\log m)$，但太麻烦，如果数据范围允许，直接用&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126310381&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+&lt;p&gt;另外，Dijkstra算法也不要乱用，比如说多源的最短路，用Dijkstra求解的复杂度只有$\mathcal O(nm\log m)$，但太麻烦，如果数据范围允许，直接用&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-floyd/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;Floyd&lt;/a&gt;就能在$\mathcal O(n^3)$的时间内完成任务。&lt;/p&gt;
 &lt;p&gt;废话不多说，下面来看Dijkstra算法的流程。&lt;/p&gt;
 &lt;h2 id=&#34;流程&#34;&gt;流程
@@ -9127,7 +9127,7 @@ $$&lt;p&gt;&lt;br&gt;
 
         <guid>https://goodcoder666.github.io/p/algonotes-floyd/</guid>
         <description>&lt;h2 id=&#34;前言&#34;&gt;前言
-&lt;/h2&gt;&lt;p&gt;在图中，如果要求任意两点间的距离，则可以使用&lt;code&gt;Floyd&lt;/code&gt;（$\mathcal O(N^3)$;)）和&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/126316941&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+&lt;/h2&gt;&lt;p&gt;在图中，如果要求任意两点间的距离，则可以使用&lt;code&gt;Floyd&lt;/code&gt;（$\mathcal O(N^3)$;)）和&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/algonotes-dijkstra/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;Dijkstra&lt;/a&gt;（$\mathcal O(NM\log M)$:)）。对于比较小的数据范围（一般为顶点数$N\le 150$），可以使用Floyd算法。本文将讲述Floyd算法的原理、实现和扩展应用。&lt;/p&gt;
 &lt;p&gt;如果有哪里写得不好请各位dalao多多指教，谢谢！&lt;/p&gt;
 &lt;h2 id=&#34;原理&#34;&gt;原理
@@ -33065,7 +33065,7 @@ $A_M~B_M$&lt;/p&gt;
         <pubDate>Tue, 21 Apr 2020 18:32:00 +0800</pubDate>
 
         <guid>https://goodcoder666.github.io/p/python-lambda-functions/</guid>
-        <description>&lt;p&gt;&lt;strong&gt;温馨提示：如果读者没有学过&lt;code&gt;def&lt;/code&gt;定义函数，请先看&lt;a class=&#34;link&#34; href=&#34;https://blog.csdn.net/write_1m_lines/article/details/105641275&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
+        <description>&lt;p&gt;&lt;strong&gt;温馨提示：如果读者没有学过&lt;code&gt;def&lt;/code&gt;定义函数，请先看&lt;a class=&#34;link&#34; href=&#34;https://goodcoder666.github.io/p/python-def-functions/&#34;  target=&#34;_blank&#34; rel=&#34;noopener&#34;
     &gt;这里&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;
 &lt;h1 id=&#34;定义形式&#34;&gt;定义形式
 &lt;/h1&gt;&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;

p/algonotes-bwop/index.html

@@ -781,7 +781,7 @@ <h4 id="洛谷-p1100-高低位交换httpswwwluogucomcnproblemp1100"><a class="li
 </div><hr>
 <h2 id="扩展概念运算">扩展概念&amp;运算
 </h2><h3 id="lowbit">lowbit
-</h3><p><code>lowbit(x)</code>即为二进制下$x$的最低位，如<code>lowbit(10010) = 10</code>、<code>lowbit(1) = 1</code>。严格来说$0$没有<code>lowbit</code>，部分情况下可视为<code>lowbit(0) = 1</code>。利用<code>lowbit</code>函数可实现<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126441412"  target="_blank" rel="noopener"
+</h3><p><code>lowbit(x)</code>即为二进制下$x$的最低位，如<code>lowbit(10010) = 10</code>、<code>lowbit(1) = 1</code>。严格来说$0$没有<code>lowbit</code>，部分情况下可视为<code>lowbit(0) = 1</code>。利用<code>lowbit</code>函数可实现<a class="link" href="https://goodcoder666.github.io/p/algonotes-fenwick-tree/"  target="_blank" rel="noopener"
     >树状数组</a>等数据结构。</p>
 <p><strong>lowbit 计算方式</strong></p>
 <ol>
@@ -813,7 +813,7 @@ <h2 id="扩展概念运算">扩展概念&amp;运算
 时间复杂度$\mathcal O(1)$。相比(1)来说，代码更短，速度更快。</li>
 <li><code>x &amp; (x - 1)</code><br>
 <strong>注意：<code>x &amp; (x - 1)</code>不是<code>lowbit(x)</code>，而是<code>x - lowbit(x)</code>。</strong><br>
-这种方法常用于<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126441412"  target="_blank" rel="noopener"
+这种方法常用于<a class="link" href="https://goodcoder666.github.io/p/algonotes-fenwick-tree/"  target="_blank" rel="noopener"
     >树状数组</a>中，可提升<code>x - lowbit(x)</code>的计算速度。</li>
 </ol>
 <h3 id="popcount">popcount
@@ -1149,8 +1149,8 @@ <h4 id="扩展stdbitset">扩展：std::bitset
 </div>
 </div><h5 id="习题atcoder-beginner-contest-258-g---trianglehttpsatcoderjpcontestsabc258tasksabc258_g">习题：<a class="link" href="https://atcoder.jp/contests/abc258/tasks/abc258_g"  target="_blank" rel="noopener"
     >AtCoder Beginner Contest 258 G - Triangle</a>
-</h5><p>题意和解法见<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/125582361#t15"  target="_blank" rel="noopener"
-    >https://blog.csdn.net/write_1m_lines/article/details/125582361#t15</a>。</p>
+</h5><p>题意和解法见<a class="link" href="https://goodcoder666.github.io/p/abc258/#%E9%A2%98%E7%9B%AE%E5%A4%A7%E6%84%8F-2"  target="_blank" rel="noopener"
+    >我的题解</a>。</p>
 <h3 id="深度优先搜索dfs的位运算优化">深度优先搜索（DFS）的位运算优化
 </h3><p>本算法其实还是<strong>二进制表示子集</strong>的一种优化，不过内容较多，所以单独放了出来。</p>
 <p>考虑经典的<strong>八皇后问题</strong>：</p>

p/algonotes-dijkstra/index.html

@@ -369,7 +369,7 @@ <h2 class="article-title">
 
     <h2 id="前言">前言
 </h2><p>Dijkstra算法可在$\mathcal O(m\log m)$或$\mathcal O(m\log n)$的时间内求解无负权单源最短路问题。本文中，我们将详细介绍算法的原理、实现，以及常用的两种优化。</p>
-<p>另外，Dijkstra算法也不要乱用，比如说多源的最短路，用Dijkstra求解的复杂度只有$\mathcal O(nm\log m)$，但太麻烦，如果数据范围允许，直接用<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126310381"  target="_blank" rel="noopener"
+<p>另外，Dijkstra算法也不要乱用，比如说多源的最短路，用Dijkstra求解的复杂度只有$\mathcal O(nm\log m)$，但太麻烦，如果数据范围允许，直接用<a class="link" href="https://goodcoder666.github.io/p/algonotes-floyd/"  target="_blank" rel="noopener"
     >Floyd</a>就能在$\mathcal O(n^3)$的时间内完成任务。</p>
 <p>废话不多说，下面来看Dijkstra算法的流程。</p>
 <h2 id="流程">流程

p/algonotes-floyd/index.html

@@ -369,7 +369,7 @@ <h2 class="article-title">
 
 
     <h2 id="前言">前言
-</h2><p>在图中，如果要求任意两点间的距离，则可以使用<code>Floyd</code>（$\mathcal O(N^3)$;)）和<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126316941"  target="_blank" rel="noopener"
+</h2><p>在图中，如果要求任意两点间的距离，则可以使用<code>Floyd</code>（$\mathcal O(N^3)$;)）和<a class="link" href="https://goodcoder666.github.io/p/algonotes-dijkstra/"  target="_blank" rel="noopener"
     >Dijkstra</a>（$\mathcal O(NM\log M)$:)）。对于比较小的数据范围（一般为顶点数$N\le 150$），可以使用Floyd算法。本文将讲述Floyd算法的原理、实现和扩展应用。</p>
 <p>如果有哪里写得不好请各位dalao多多指教，谢谢！</p>
 <h2 id="原理">原理

p/algonotes-lca/index.html

@@ -443,7 +443,7 @@ <h2 id="求解算法">求解算法
 </h3><p>对于两种算法，都需要预处理出每个结点的深度。<br>
 <strong>一个结点的深度定义为这个结点到树根的距离。</strong></p>
 <p>要预处理出所有结点的深度，很简单：<br>
-运用<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126263935"  target="_blank" rel="noopener"
+运用<a class="link" href="https://goodcoder666.github.io/p/algonotes-tree-dp/"  target="_blank" rel="noopener"
     >树形dp</a>的方法，令 $h_u$ 表示结点 $u$ 的深度，逐层向下推进：</p>
 <div class="highlight"><div class="chroma">
 <table class="lntable"><tr><td class="lntd">

p/algonotes-mst/index.html

@@ -666,10 +666,10 @@ <h3 id="参考代码">参考代码
 </span></span></code></pre></td></tr></table>
 </div>
 </div><h2 id="prim">Prim
-</h2><p>Prim算法于1930年由捷克数学家Vojtěch Jarník发现，在1957年又由美国计算机科学家Robert C. Prim独立发现。1959年，Edsger Wybe Dijkstra（没错，就是<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126316941"  target="_blank" rel="noopener"
+</h2><p>Prim算法于1930年由捷克数学家Vojtěch Jarník发现，在1957年又由美国计算机科学家Robert C. Prim独立发现。1959年，Edsger Wybe Dijkstra（没错，就是<a class="link" href="https://goodcoder666.github.io/p/algonotes-dijkstra/"  target="_blank" rel="noopener"
     >Dijkstra</a>算法的发明者）再次发现了该算法。因此，在某些场合，Prim算法又被称为DJP算法、Jarník算法或Prim－Jarník算法。</p>
 <h3 id="prim-算法流程">Prim 算法流程
-</h3><p>Prim与<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126316941"  target="_blank" rel="noopener"
+</h3><p>Prim与<a class="link" href="https://goodcoder666.github.io/p/algonotes-dijkstra/"  target="_blank" rel="noopener"
     >Dijkstra</a>很相似，将顶点分为$S$和$T$两个集合，具体流程如下：</p>
 <ol>
 <li>初始时，所有顶点全部在$S$中，$T$为空集。</li>

p/algonotes-rmq/index.html

@@ -687,7 +687,7 @@ <h4 id="初始化">初始化
 <p>运行时间：$128\mathrm{ms}$<br>
 使用内存：$6.90\mathrm{MB}$</p>
 <h3 id="树状数组">树状数组
-</h3><p>关于树状数组的原理我已经在<a class="link" href="https://blog.csdn.net/write_1m_lines/article/details/126441412"  target="_blank" rel="noopener"
+</h3><p>关于树状数组的原理我已经在<a class="link" href="https://goodcoder666.github.io/p/algonotes-fenwick-tree/"  target="_blank" rel="noopener"
     >这篇文章</a>中讲过，这里不再多说了。下面我们考虑如何应用树状数组解决 RMQ 问题。</p>
 <h4 id="原算法">原算法
 </h4><p>树状数组可以用<code>lowbit</code>操作实现<code>prefixSum</code>（前缀和）以及<code>update</code>（更新）操作，时间复杂度均为$\mathcal O(N\log N)$。不仅是加法，<strong>对于任意满足结合律的运算这两种操作都有效。</strong></p>