<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" xml:lang="zh-CN"><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="https://gybaoyu.github.io/feed.xml" rel="self" type="application/atom+xml" /><link href="https://gybaoyu.github.io/" rel="alternate" type="text/html" hreflang="zh-CN" /><updated>2026-04-17T11:30:40+00:00</updated><id>https://gybaoyu.github.io/feed.xml</id><title type="html">Abalone</title><subtitle>个人主页与技术博客，记录经历、项目和文章。</subtitle><entry><title type="html">一阶常微分方程常见题型归纳</title><link href="https://gybaoyu.github.io/2026/04/17/%E4%B8%80%E9%98%B6%E5%B8%B8%E5%BE%AE%E5%88%86%E6%96%B9%E7%A8%8B%E5%B8%B8%E8%A7%81%E9%A2%98%E5%9E%8B%E5%BD%92%E7%BA%B3.html" rel="alternate" type="text/html" title="一阶常微分方程常见题型归纳" /><published>2026-04-17T00:00:00+00:00</published><updated>2026-04-17T00:00:00+00:00</updated><id>https://gybaoyu.github.io/2026/04/17/%E4%B8%80%E9%98%B6%E5%B8%B8%E5%BE%AE%E5%88%86%E6%96%B9%E7%A8%8B%E5%B8%B8%E8%A7%81%E9%A2%98%E5%9E%8B%E5%BD%92%E7%BA%B3</id><content type="html" xml:base="https://gybaoyu.github.io/2026/04/17/%E4%B8%80%E9%98%B6%E5%B8%B8%E5%BE%AE%E5%88%86%E6%96%B9%E7%A8%8B%E5%B8%B8%E8%A7%81%E9%A2%98%E5%9E%8B%E5%BD%92%E7%BA%B3.html"><![CDATA[<h3 id="a-可分离变量">A. 可分离变量</h3>

<ul>
  <li><strong>长相</strong>：能整理成 $y’=f(x)g(y)$，或 $A(y)\,dy=B(x)\,dx$。</li>
  <li><strong>识别关键词</strong>：左右能“纯 $x$、纯 $y$”分开。</li>
  <li><strong>首选解法</strong>：分离变量后两边积分。</li>
</ul>

<h3 id="b-一阶线性">B. 一阶线性</h3>

<ul>
  <li><strong>长相</strong>：$y’+P(x)y=Q(x)$（或等价变形）。</li>
  <li><strong>识别关键词</strong>：$y$ 和 $y’$ 都是一阶，且对 $y$ 是线性的（没有 $y^2,\,\sqrt y$ 等）。</li>
  <li><strong>首选解法</strong>：积分因子 $\mu=e^{\int P(x)dx}$，两边同乘积分因子然后左边变成$\mu(y’+P(x)y)-&gt;(\mu y)’$，最后左右同时求积分左边$\mu y=\int Q(x)\mu dx$。</li>
</ul>

<h3 id="c-伯努利">C. 伯努利</h3>

<ul>
  <li><strong>长相</strong>：$y’+P(x)y=Q(x)y^n,\;n\neq0,1$。</li>
  <li><strong>识别关键词</strong>：在线性方程基础上多了一个 $y^n$ 非线性项。</li>
  <li><strong>首选解法</strong>：令 $u=y^{1-n}$，化为一阶线性再解。</li>
</ul>

<h3 id="d-齐次一阶">D. 齐次（一阶）</h3>
<ul>
  <li><strong>长相</strong>：$y’=F(y/x)$，或 $Mdx+Ndy=0$ 且 $M,N$ 同次齐次。</li>
  <li><strong>识别关键词</strong>：式子里常出现 $y/x$、$x/y$，或分子分母同次。</li>
  <li><strong>首选解法</strong>：令 $v=y/x$（或 $x=vy$）降为可分离。</li>
</ul>

<h3 id="e-恰当方程">E. 恰当方程</h3>
<ul>
  <li><strong>长相</strong>：$M(x,y)\,dx+N(x,y)\,dy=0$。</li>
  <li><strong>识别关键词</strong>：先算 $\partial M/\partial y$ 与 $\partial N/\partial x$，若相等则恰当。</li>
  <li><strong>首选解法</strong>：找势函数 $\Phi$，写成 $\Phi(x,y)=C$。</li>
</ul>

<h3 id="f-线性分式">F. 线性分式</h3>
<ul>
  <li><strong>长相</strong>：$y’=\dfrac{a_1x+b_1y+c_1}{a_2x+b_2y+c_2}$。</li>
  <li><strong>识别关键词</strong>：分子、分母都是 $x,y$ 的一次式。</li>
  <li><strong>首选解法</strong>：先平移去常数项，再化为齐次（或特殊情形做线性代换）。</li>
</ul>

<h3 id="g-隐式含导数如-fxyy0">G. 隐式含导数（如 $F(x,y,y’)=0$）</h3>
<ul>
  <li><strong>长相</strong>：不容易直接写成 $y’=f(x,y)$。</li>
  <li><strong>识别关键词</strong>：$y’$ 以平方、指数、复合等形式出现。</li>
  <li><strong>首选解法</strong>：设 $p=y’$ 做参数化，或改写成 $x(y)$（即 $dx/dy$）后求解。</li>
</ul>

<h2 id="1-可分离含可直接积分">1. 可分离（含可直接积分）</h2>

<p><strong>特点（识别）</strong>：右端只含 $x$，或可整理成 $A(y)\,dy=B(x)\,dx$。</p>

<h3 id="例题15">例题（15）</h3>
<p>\(\frac{dy}{dx}=\frac{y}{e^x}+\frac{y}{x}
=y\!\left(e^{-x}+\frac1x\right)\)</p>

<p><strong>解法</strong>：可直接分离变量。<br />
\(\frac{dy}{y}=\left(e^{-x}+\frac1x\right)\,dx\)
积分得
\(\ln|y|=-e^{-x}+\ln|x|+C\)
\(\boxed{\,y=Cx\,e^{-e^{-x}}\,}\)</p>

<hr />

<h2 id="2-伯努利方程">2. 伯努利方程</h2>

<p><strong>特点（识别）</strong>：可整理成 $y’+P(x)y=Q(x)y^n$（本节两题都是 $n=2$）。</p>

<h3 id="例题6">例题（6）</h3>
<p>\((xy+1)y\,dx-x\,dy=0
\Rightarrow
\frac{dy}{dx}=\frac{y}{x}+y^2\)</p>

<p>是 $y’-\frac1x y=y^2$（$n=2$ 的伯努利方程）。</p>

<p>令 $u=y^{-1}$，则 $u’=-y^{-2}y’$。代换后得
\(u'+\frac1x u=-1\)
为一阶线性方程。积分因子 $\mu=x$，
\((xu)'=-x
\Rightarrow xu=-\frac{x^2}{2}+C
\Rightarrow
\frac1y=-\frac x2+\frac Cx\)
\(\boxed{\,y=\frac{2x}{C-x^2}\,}\)</p>

<h3 id="例题8">例题（8）</h3>
<p>\(\frac{dy}{dx}=\frac yx+\frac{y^2}{x^3}
\Rightarrow
y'-\frac1x y=\frac1{x^3}y^2\)</p>

<p>同样令 $u=y^{-1}$，得
\(u'+\frac1x u=-\frac1{x^3}\)
积分因子 $\mu=x$，
\((xu)'=-\frac1{x^2}
\Rightarrow xu=\frac1x+C
\Rightarrow
\frac1y=\frac1{x^2}+\frac Cx\)
\(\boxed{\,y=\frac{x^2}{1+Cx}\,}\)</p>

<hr />

<h2 id="3-先化为-xxy-再解">3. 先化为 $x=x(y)$ 再解</h2>

<p><strong>特点（识别）</strong>：直接对 $y’$ 下手不顺，但改写成 $dx/dy$ 后结构明显变简单（可分离/线性）。</p>

<h3 id="例题11">例题（11）</h3>
<p>\(\frac{dy}{dx}=\frac{x-y+1}{x+y^2+3}
\Rightarrow
\frac{dx}{dy}=\frac{x+y^2+3}{x-y+1}\)</p>

<p>令
\(u=x-y+1\quad(\Rightarrow x=u+y-1,\; \frac{dx}{dy}=u'+1)\)
代入得
\(u'+1=\frac{u+y^2+y+2}{u}
\Rightarrow
u'=\frac{y^2+y+2}{u}
\Rightarrow
u\,du=(y^2+y+2)\,dy\)
\(\frac{u^2}{2}=\frac{y^3}{3}+\frac{y^2}{2}+2y+C\)
还原 $u=x-y+1$：
\(\boxed{\,(x-y+1)^2=\frac{2}{3}y^3+y^2+4y+C\,}\)</p>

<hr />

<h2 id="4-通过代换化为一阶线性">4. 通过代换化为一阶线性</h2>

<p><strong>特点（识别）</strong>：原式里出现像 $e^{-y}y’$、$\ln y$、$y^m y’$ 这种“某个复合函数的导数”结构。</p>

<h3 id="例题3">例题（3）</h3>

<p>\(\frac{dy}{dx}=4e^{-y}\sin x-1\)
移项并乘 $e^y$：
\(e^y\!\left(\frac{dy}{dx}+1\right)=4\sin x\)
令 $u=e^y$，则 $u’=e^y y’$，方程化为
\(u'+u=4\sin x\)
积分因子为 $e^x$，解得
\(u=2(\sin x-\cos x)+Ce^{-x}\)
还原：
\(\boxed{\,y=\ln\!\big|2(\sin x-\cos x)+Ce^{-x}\big|\,}\)</p>

<h3 id="例题12">例题（12）</h3>

\[e^{-y}\!\left(\frac{dy}{dx}+1\right)=xe^x\]

<p>令 $z=e^{-y}$，则 $z’=-e^{-y}y’$。原式变为
\(z-z'=xe^x
\Rightarrow
z'-z=-xe^x\)
这是线性方程。积分因子 $\mu=e^{-x}$，
\((ze^{-x})'=-x
\Rightarrow
ze^{-x}=-\frac{x^2}{2}+C\)
\(e^{-y}=e^x\!\left(C-\frac{x^2}{2}\right)
\Rightarrow
\boxed{\,y=-x-\ln\!\left|C-\frac{x^2}{2}\right|\,}\)</p>

<hr />

<h2 id="5-隐式方程-fyy0参数反函数思路">5. 隐式方程 $F(y,y’)=0$（参数/反函数思路）</h2>

<p><strong>特点（识别）</strong>：方程主要是 $y$ 与 $y’$ 的关系，常先解出 $y’$ 或 $dx/dy$ 再积分。</p>

<h3 id="例题20">例题（20）</h3>
<p>\(y^2\!\left[1-\left(\frac{dy}{dx}\right)^2\right]=1\)</p>

<p>化为
\(\left(\frac{dy}{dx}\right)^2=1-\frac1{y^2}\)
改写为
\(\frac{dx}{dy}=\pm\frac{y}{\sqrt{y^2-1}}\)
积分：
\(x=\pm\sqrt{y^2-1}+C\)
等价隐式解：
\(\boxed{\,y^2-(x-C)^2=1\,}\)</p>

<hr />

<h2 id="6-其余题型补充用于覆盖章节总结">6. 其余题型补充（用于覆盖章节总结）</h2>

<h3 id="61-齐次方程补13">6.1 齐次方程（补：13）</h3>
<p><strong>特点（识别）</strong>：可化为 $y’=F(y/x)$，优先试 $v=y/x$。</p>

<p>\((x^2+y^2)\,dx-2xy\,dy=0
\Rightarrow
\frac{dy}{dx}=\frac{x^2+y^2}{2xy}\)
右端是 $y/x$ 的函数组合（齐次型），令 $v=y/x$（$y=vx$）化为可分离方程后积分。</p>

<h3 id="62-一阶线性方程补14">6.2 一阶线性方程（补：14）</h3>

<p><strong>特点（识别）</strong>：标准型 $y’+P(x)y=Q(x)$，直接用积分因子。</p>

<p>\(\frac{dy}{dx}=x+y+1
\Rightarrow
y'-y=x+1\)
积分因子 $e^{-x}$，可得
\(\boxed{\,y=Ce^x-x-2\,}\)</p>

<h3 id="63-恰当方程补22">6.3 恰当方程（补：22）</h3>
<p><strong>特点（识别）</strong>：先验算 $\partial M/\partial y=\partial N/\partial x$。
\(\frac{2x}{y^3}\,dx+\frac{y^2-3x^2}{y^4}\,dy=0\)
设 $M=\frac{2x}{y^3},\;N=\frac{y^2-3x^2}{y^4}$，有
\(\frac{\partial M}{\partial y}=\frac{\partial N}{\partial x}=-\frac{6x}{y^4}\)
故为恰当方程，构造势函数 $\Phi$：
\(\Phi_x=\frac{2x}{y^3}\Rightarrow \Phi=\frac{x^2}{y^3}+g(y)\)
再由 $\Phi_y=N$ 得 $g’(y)=\frac1{y^2}\Rightarrow g(y)=-\frac1y$。<br />
因此
\(\boxed{\,\frac{x^2}{y^3}-\frac1y=C\,}\)</p>

<h3 id="64-线性分式方程补27">6.4 线性分式方程（补：27）</h3>
<p><strong>特点（识别）</strong>：分子分母均为 $x,y$ 一次式，先平移坐标再化齐次。</p>

<p>\(\frac{dy}{dx}=\frac{2x+3y+4}{4x+6y+5}\)
分子分母对 $x,y$ 都是一阶，属线性分式型；先平移去常数，再化为齐次方程求解。</p>]]></content><author><name></name></author><summary type="html"><![CDATA[A. 可分离变量]]></summary></entry><entry><title type="html">P4170 [CQOI2007] 涂色</title><link href="https://gybaoyu.github.io/2025/03/25/P4170-CQOI2007-%E6%B6%82%E8%89%B2.html" rel="alternate" type="text/html" title="P4170 [CQOI2007] 涂色" /><published>2025-03-25T13:30:48+00:00</published><updated>2025-03-25T13:30:48+00:00</updated><id>https://gybaoyu.github.io/2025/03/25/P4170%20%5BCQOI2007%5D%20%E6%B6%82%E8%89%B2</id><content type="html" xml:base="https://gybaoyu.github.io/2025/03/25/P4170-CQOI2007-%E6%B6%82%E8%89%B2.html"><![CDATA[<blockquote>
  <p>记录一道做过的蓝题</p>
</blockquote>

<h2 id="题目描述">题目描述</h2>

<p>假设你有一条长度为 $5$ 的木板，初始时没有涂过任何颜色。你希望把它的 $5$ 个单位长度分别涂上红、绿、蓝、绿、红色，用一个长度为 $5$ 的字符串表示这个目标：$\texttt{RGBGR}$。</p>

<p>每次你可以把一段连续的木板涂成一个给定的颜色，后涂的颜色覆盖先涂的颜色。例如第一次把木板涂成 $\texttt{RRRRR}$，第二次涂成 $\texttt{RGGGR}$，第三次涂成 $\texttt{RGBGR}$，达到目标。</p>

<p>用尽量少的涂色次数达到目标。</p>

<h2 id="输入格式">输入格式</h2>

<p>输入仅一行，包含一个长度为 $n$ 的字符串，即涂色目标。字符串中的每个字符都是一个大写字母，不同的字母代表不同颜色，相同的字母代表相同颜色。</p>

<h2 id="输出格式">输出格式</h2>

<p>仅一行，包含一个数，即最少的涂色次数。</p>

<h2 id="输入输出样例-1">输入输出样例 #1</h2>

<h3 id="输入-1">输入 #1</h3>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>AAAAA
</code></pre></div></div>

<h3 id="输出-1">输出 #1</h3>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>1
</code></pre></div></div>

<h2 id="输入输出样例-2">输入输出样例 #2</h2>

<h3 id="输入-2">输入 #2</h3>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>RGBGR
</code></pre></div></div>

<h3 id="输出-2">输出 #2</h3>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>3
</code></pre></div></div>

<h2 id="说明提示">说明/提示</h2>

<p>$40\%$ 的数据满足 $1\le n\le 10$。
$100\%$ 的数据满足 $1\le n\le 50$。</p>

<h2 id="思路">思路</h2>
<p>首先我们可以把涂色过程归类为几种策略：</p>

<ol>
  <li>先涂一个大区间，然后一个小区间包含在大区间内。
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>AAABBBBAAA
</code></pre></div>    </div>
  </li>
  <li>涂两个并列且没有交集的区间。（如果有交集会互相覆盖，又相当于没有交集了，所以不用考虑）
    <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>AAAAABBBB
</code></pre></div>    </div>
  </li>
</ol>

<p>那么用这两个策略，我们针对一个区间 <code class="language-plaintext highlighter-rouge">[l, r]</code> 进行讨论：</p>

<ul>
  <li>如果 <code class="language-plaintext highlighter-rouge">l = r</code>，显然有初始化 <code class="language-plaintext highlighter-rouge">f_l,r = 1</code>。</li>
  <li>如果 <code class="language-plaintext highlighter-rouge">s_l = s_r</code>，那么这个区间有可能使用策略一，那么有 <code class="language-plaintext highlighter-rouge">f_l,r = min{f_l+1,r, f_l,r-1}</code>。我们想象把第一步的大区间向外延伸一格即可，即可得到当前状态且不用新增步数。</li>
  <li>无论 <code class="language-plaintext highlighter-rouge">s_l</code> 和 <code class="language-plaintext highlighter-rouge">s_r</code> 是否相等，都有可能使用策略二。我们用区间DP的常规操作，枚举一下断点即可。
有 <code class="language-plaintext highlighter-rouge">f_l,r = min{f_l,r, f_l,i + f_i+1,r} (l ≤ i &lt; r)</code>。</li>
</ul>

<p>时间复杂度 <code class="language-plaintext highlighter-rouge">O(n^3)</code>，空间复杂度 <code class="language-plaintext highlighter-rouge">O(n^2)</code>。</p>

<h2 id="题解代码">题解代码</h2>
<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;bits/stdc++.h&gt;</span><span class="cp">
</span><span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">N</span><span class="p">;</span>
<span class="n">string</span> <span class="n">str</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">dp</span><span class="p">[</span><span class="mi">301</span><span class="p">][</span><span class="mi">301</span><span class="p">];</span><span class="c1">//表示从i到j的最小次数</span>
<span class="kt">char</span> <span class="n">s</span><span class="p">[</span><span class="mi">301</span><span class="p">];</span>
<span class="kt">char</span> <span class="n">tmp</span><span class="p">;</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
	<span class="n">cin</span><span class="o">&gt;&gt;</span><span class="n">str</span><span class="p">;</span>
	<span class="n">N</span> <span class="o">=</span> <span class="n">str</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>
	<span class="n">memset</span><span class="p">(</span><span class="n">dp</span><span class="p">,</span><span class="mh">0x3f3f</span><span class="p">,</span><span class="k">sizeof</span> <span class="n">dp</span><span class="p">);</span>
	<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;=</span><span class="n">N</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
		<span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">str</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">];</span>
		<span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
	<span class="p">}</span>

	<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">len</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="n">len</span> <span class="o">&lt;=</span><span class="n">N</span> <span class="p">;</span> <span class="o">++</span><span class="n">len</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">l</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">l</span><span class="o">+</span><span class="n">len</span><span class="o">-</span><span class="mi">1</span><span class="o">&lt;=</span><span class="n">N</span><span class="p">;</span> <span class="o">++</span><span class="n">l</span><span class="p">)</span> <span class="p">{</span>
			<span class="kt">int</span> <span class="n">r</span> <span class="o">=</span> <span class="n">l</span><span class="o">+</span><span class="n">len</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span>
			<span class="k">if</span><span class="p">(</span><span class="n">s</span><span class="p">[</span><span class="n">l</span><span class="p">]</span> <span class="o">==</span> <span class="n">s</span><span class="p">[</span><span class="n">r</span><span class="p">])</span><span class="n">dp</span><span class="p">[</span><span class="n">l</span><span class="p">][</span><span class="n">r</span><span class="p">]</span> <span class="o">=</span> <span class="n">min</span><span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">l</span><span class="o">+</span><span class="mi">1</span><span class="p">][</span><span class="n">r</span><span class="p">],</span><span class="n">dp</span><span class="p">[</span><span class="n">l</span><span class="p">][</span><span class="n">r</span><span class="o">-</span><span class="mi">1</span><span class="p">]);</span>
			<span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="n">l</span><span class="p">;</span><span class="n">i</span> <span class="o">&lt;</span> <span class="n">r</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
				<span class="n">dp</span><span class="p">[</span><span class="n">l</span><span class="p">][</span><span class="n">r</span><span class="p">]</span> <span class="o">=</span> <span class="n">min</span><span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">l</span><span class="p">][</span><span class="n">r</span><span class="p">],</span><span class="n">dp</span><span class="p">[</span><span class="n">l</span><span class="p">][</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">][</span><span class="n">r</span><span class="p">]);</span>
		<span class="p">}</span>
	<span class="p">}</span>
	<span class="n">cout</span><span class="o">&lt;&lt;</span><span class="n">dp</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="n">N</span><span class="p">];</span>
	<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>]]></content><author><name></name></author><summary type="html"><![CDATA[记录一道做过的蓝题]]></summary></entry><entry><title type="html">动态规划的一些学习记录~</title><link href="https://gybaoyu.github.io/2025/02/14/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%9A%84%E4%B8%80%E4%BA%9B%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95~.html" rel="alternate" type="text/html" title="动态规划的一些学习记录~" /><published>2025-02-14T04:53:58+00:00</published><updated>2025-02-14T04:53:58+00:00</updated><id>https://gybaoyu.github.io/2025/02/14/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%9A%84%E4%B8%80%E4%BA%9B%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95~</id><content type="html" xml:base="https://gybaoyu.github.io/2025/02/14/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%9A%84%E4%B8%80%E4%BA%9B%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95~.html"><![CDATA[<h1 id="dp-动态规划">DP 动态规划</h1>

<h2 id="0动态规划三要素">0.动态规划三要素</h2>

<ol>
  <li><strong>状态定义：由背包问题相关的变量描述的一个东西</strong>
    <ol>
      <li>定义状态往往是最难的一步，这决定了对问题整体的建模</li>
      <li>例如状态可以是：<strong>“前 i 个物品在容量 j 下的最大价值”</strong></li>
      <li>定义好状态后，再由此给出状态转移方程</li>
    </ol>
  </li>
  <li><strong>状态转移方程：描述如何从一个状态到另一个状态</strong>
    <ol>
      <li>延续上面的状态定义，令<code class="language-plaintext highlighter-rouge">dp[i][j]</code>表示 <strong>“前 i 个物品在容量  j 下的最大价值”</strong></li>
      <li>那么如果是0-1背包，状态转移方程则是：<code class="language-plaintext highlighter-rouge">dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])</code></li>
      <li><strong>初始条件和边界(问题的最小规模下的解)</strong>
        <ol>
          <li>例如，在背包问题中，当没有物品或背包容量为0时，最大价值为0。</li>
        </ol>
      </li>
    </ol>
  </li>
</ol>

<h2 id="1背包dp用dp求解背包问题">1.背包DP（用DP求解背包问题）</h2>

<ul>
  <li>
    <p>背包问题：给定一组物品，每个物品有重量和价值，在不超过背包容量的前提下，如何选择物品使总价值最大</p>

    <ul>
      <li>0-1背包：每种物品只有一个，选择放入(1)或不放入(0)背包</li>
    </ul>
  </li>
</ul>

<p><img src="/assets/images/1768376363406.png" alt="1768376363406.png" width="50%" height="auto" style="display: inline-block" /></p>

<ul>
  <li>完全背包：每种物品都有无限个</li>
</ul>

<p><img src="/assets/images/1768376616621.png" alt="1768376616621.png" width="50%" height="auto" style="display: inline-block" /></p>

<p><strong>小结：可以发现0-1背包和完全背包的差别其实就是一个倒序遍历一个正序遍历（正序遍历意味着可以选无限个，倒序则意味着只能选一个或者不选）</strong></p>

<ul>
  <li>多重背包：每种物品都有数量限制</li>
</ul>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code>      <span class="c1">// 遍历每个物品</span>
      <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
          <span class="c1">// 遍历每种容量（从后往前）</span>
          <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="n">W</span><span class="p">;</span> <span class="n">j</span> <span class="o">&gt;=</span> <span class="n">wt</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="n">j</span><span class="o">--</span><span class="p">)</span> <span class="p">{</span>
              <span class="c1">// 遍历当前物品的选择数量k</span>
              <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">k</span> <span class="o">&lt;=</span> <span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">&amp;&amp;</span> <span class="n">k</span> <span class="o">*</span> <span class="n">wt</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="n">j</span><span class="p">;</span> <span class="n">k</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
                  <span class="n">dp</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">max</span><span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">j</span><span class="p">],</span> <span class="n">dp</span><span class="p">[</span><span class="n">j</span> <span class="o">-</span> <span class="n">k</span> <span class="o">*</span> <span class="n">wt</span><span class="p">[</span><span class="n">i</span><span class="p">]]</span> <span class="o">+</span> <span class="n">k</span> <span class="o">*</span> <span class="n">val</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
              <span class="p">}</span>
          <span class="p">}</span>
      <span class="p">}</span>
</code></pre></div></div>

<p>其实这个也是正序遍历，只不过相当于把第i种的k个看成了k种，转化为了0-1背包</p>

<p>附：多重背包的二进制优化（?本质上是通过类似于以2为底的指数增长来更快的选完物品数量）</p>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code>	<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
	    <span class="c1">// 二进制拆分</span>
	    <span class="kt">int</span> <span class="n">num</span> <span class="o">=</span> <span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">// 当前物品的数量</span>
	    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">k</span> <span class="o">&lt;=</span> <span class="n">num</span><span class="p">;</span> <span class="n">k</span> <span class="o">*=</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
	        <span class="c1">// 拆分出一个二进制分组</span>
	        <span class="kt">int</span> <span class="n">newWt</span> <span class="o">=</span> <span class="n">k</span> <span class="o">*</span> <span class="n">wt</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">// 新物品的重量</span>
	        <span class="kt">int</span> <span class="n">newVal</span> <span class="o">=</span> <span class="n">k</span> <span class="o">*</span> <span class="n">val</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">// 新物品的价值</span>
	        <span class="c1">// 从后往前更新dp数组</span>
	        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="n">W</span><span class="p">;</span> <span class="n">j</span> <span class="o">&gt;=</span> <span class="n">newWt</span><span class="p">;</span> <span class="n">j</span><span class="o">--</span><span class="p">)</span> <span class="p">{</span>
	            <span class="n">dp</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">max</span><span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">j</span><span class="p">],</span> <span class="n">dp</span><span class="p">[</span><span class="n">j</span> <span class="o">-</span> <span class="n">newWt</span><span class="p">]</span> <span class="o">+</span> <span class="n">newVal</span><span class="p">);</span>
	        <span class="p">}</span>
	        <span class="n">num</span> <span class="o">-=</span> <span class="n">k</span><span class="p">;</span> <span class="c1">// 减去已经拆分的数量</span>
	    <span class="p">}</span>
	    <span class="c1">// 处理剩余的部分</span>
	    <span class="k">if</span> <span class="p">(</span><span class="n">num</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
	        <span class="kt">int</span> <span class="n">newWt</span> <span class="o">=</span> <span class="n">num</span> <span class="o">*</span> <span class="n">wt</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
	        <span class="kt">int</span> <span class="n">newVal</span> <span class="o">=</span> <span class="n">num</span> <span class="o">*</span> <span class="n">val</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
	        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="n">W</span><span class="p">;</span> <span class="n">j</span> <span class="o">&gt;=</span> <span class="n">newWt</span><span class="p">;</span> <span class="n">j</span><span class="o">--</span><span class="p">)</span> <span class="p">{</span>
	            <span class="n">dp</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">max</span><span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">j</span><span class="p">],</span> <span class="n">dp</span><span class="p">[</span><span class="n">j</span> <span class="o">-</span> <span class="n">newWt</span><span class="p">]</span> <span class="o">+</span> <span class="n">newVal</span><span class="p">);</span>
	        <span class="p">}</span>
	    <span class="p">}</span>
	<span class="p">}</span>
</code></pre></div></div>

<h2 id="11-补充记忆化搜索">1.1 补充：记忆化搜索</h2>

<ul>
  <li>记忆化搜索：一种通过记录已经遍历过的状态的信息，从而避免 对同一状态重复遍历的搜索实现方式。</li>
  <li>因为记忆化搜索确保了每个状态只访问一次，它也是一种常见的 动态规划实现方式，一般基于dfs</li>
</ul>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">//基于dfs的记忆化搜索(vis数组就是“记忆”，表示这个状态的东西是否被访问过)</span>
<span class="kt">bool</span> <span class="nf">dfs</span><span class="p">(</span><span class="kt">int</span> <span class="n">n</span><span class="p">,</span><span class="kt">int</span> <span class="n">m</span><span class="p">){</span>
    <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">&lt;</span><span class="n">m</span><span class="p">)</span><span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
    <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">==</span><span class="n">m</span><span class="p">)</span><span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
    <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">%</span><span class="mi">3</span><span class="o">!=</span><span class="mi">0</span><span class="o">||</span><span class="n">vis</span><span class="p">[</span><span class="n">n</span><span class="p">])</span><span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
    <span class="n">vis</span><span class="p">[</span><span class="n">n</span><span class="p">]</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span><span class="c1">//加入记忆</span>
    <span class="kt">int</span> <span class="n">p</span><span class="o">=</span><span class="n">n</span><span class="o">/</span><span class="mi">3</span><span class="p">,</span><span class="n">q</span><span class="o">=</span><span class="n">p</span><span class="o">*</span><span class="mi">2</span><span class="p">;</span>
    <span class="k">return</span> <span class="n">dfs</span><span class="p">(</span><span class="n">p</span><span class="p">,</span><span class="n">m</span><span class="p">)</span><span class="o">||</span><span class="n">dfs</span><span class="p">(</span><span class="n">q</span><span class="p">,</span><span class="n">m</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="2线性dp">2.线性DP</h2>

<ul>
  <li>线性 DP 不是某一种 DP , 而是一类 DP 的统称.</li>
  <li>线性 DP 指转移的形式是线性的, 不是指复杂度是线性的.</li>
</ul>

<h3 id="21-一维">2.1 一维</h3>

<ul>
  <li>
    <p>题目描述</p>
  </li>
  <li>
    <p>给出一个长度为 <code class="language-plaintext highlighter-rouge">n</code> 的序列 <code class="language-plaintext highlighter-rouge">a</code>，选出其中连续且非空的一段使得这段和最大。</p>
  </li>
  <li>思路</li>
  <li>首先定义<code class="language-plaintext highlighter-rouge">dp[i]</code> 表示只考虑前 <code class="language-plaintext highlighter-rouge">i</code> 个元素时, <code class="language-plaintext highlighter-rouge">a[i]</code> 所在的子段的最大和，然后题目所求的答案就是<code class="language-plaintext highlighter-rouge">max(dp[1],dp[2]...dp[n])</code>，初始状态<code class="language-plaintext highlighter-rouge">dp[0]=0</code></li>
  <li>状态转移方程：<code class="language-plaintext highlighter-rouge">dp[i] = max(dp[i - 1] + a[i], a[i])</code>即只考虑前<code class="language-plaintext highlighter-rouge">i</code>个元素时<code class="language-plaintext highlighter-rouge">a[i]</code>所在子段要么是它本身要么是他前一个加上他本身(因为<code class="language-plaintext highlighter-rouge">dp[i]</code>一定要包含<code class="language-plaintext highlighter-rouge">a[i]</code>)</li>
</ul>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="n">dp</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>  <span class="c1">// 初始条件</span>
  <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
      <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">max</span><span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="n">a</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">a</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
  <span class="p">}</span>
  <span class="kt">int</span> <span class="n">ans</span> <span class="o">=</span> <span class="o">-</span><span class="n">INF</span><span class="p">;</span>
  <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
      <span class="n">ans</span> <span class="o">=</span> <span class="n">max</span><span class="p">(</span><span class="n">ans</span><span class="p">,</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
  <span class="p">}</span>
</code></pre></div></div>

<ul>
  <li>优化：滚动数组(减少掉一维，因为从头到尾只用到了<code class="language-plaintext highlighter-rouge">dp[i]</code>和<code class="language-plaintext highlighter-rouge">dp[i-1]</code>)</li>
</ul>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span> <span class="n">ans</span> <span class="o">=</span> <span class="o">-</span><span class="n">INF</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">sum</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">sum</span> <span class="o">=</span> <span class="n">max</span><span class="p">(</span><span class="n">sum</span> <span class="o">+</span> <span class="n">a</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">a</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
    <span class="n">ans</span> <span class="o">=</span> <span class="n">max</span><span class="p">(</span><span class="n">ans</span><span class="p">,</span> <span class="n">sum</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<h3 id="22-二维">2.2 二维</h3>

<ul>
  <li>题目描述</li>
  <li>
    <p>有一个<code class="language-plaintext highlighter-rouge">n</code>行<code class="language-plaintext highlighter-rouge">m</code>列的网格. 某人从左上角<code class="language-plaintext highlighter-rouge">(1,1)</code>出发, 前往右下角<code class="language-plaintext highlighter-rouge">(n,m)</code> ,若要求 每一步只能向下走或向右走, 且不能走入行数和列数都为偶数的格, 求他行进的方案数.</p>
  </li>
  <li>思路
    <ul>
      <li>定义<code class="language-plaintext highlighter-rouge">dp[i][j]</code>表示从<code class="language-plaintext highlighter-rouge">(1,1)</code>到<code class="language-plaintext highlighter-rouge">(i,j)</code>的方案数，则答案为<code class="language-plaintext highlighter-rouge">dp[n][m]</code></li>
      <li>状态转移方程<code class="language-plaintext highlighter-rouge">dp[i][j]=dp[i-1][j]+dp[i][j-1](i,j不同时为偶数)</code></li>
      <li>初始条件<code class="language-plaintext highlighter-rouge">dp[1][1]=1</code></li>
    </ul>
  </li>
</ul>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">j</span> <span class="o">&lt;=</span> <span class="n">m</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">if</span> <span class="p">(</span><span class="n">i</span> <span class="o">==</span> <span class="mi">1</span> <span class="o">&amp;&amp;</span> <span class="n">j</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span> <span class="k">continue</span><span class="p">;</span>
        <span class="k">if</span> <span class="p">((</span><span class="n">i</span> <span class="o">&amp;</span> <span class="mi">1</span><span class="p">)</span> <span class="o">||</span> <span class="p">(</span><span class="n">j</span> <span class="o">&amp;</span> <span class="mi">1</span><span class="p">))</span> <span class="p">{</span>
            <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="n">j</span><span class="p">]</span> <span class="o">+</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">];</span>
        <span class="p">}</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<h3 id="23-三维">2.3 三维</h3>
<ul>
  <li>题目描述
    <ul>
      <li>某人带着<code class="language-plaintext highlighter-rouge">2</code>单位的酒出发, 一路上遇到店<code class="language-plaintext highlighter-rouge">n</code>次, 遇到花<code class="language-plaintext highlighter-rouge">m</code>次, 最后一次遇到的是花, 且正好将酒喝光. 已知他遇到店时, 拥有的酒量会翻一倍; 遇到花时, 拥有的酒量会减少<code class="language-plaintext highlighter-rouge">1</code>单位. 求他路上遇到店和花的顺序的方案数, 答案对(1e9+7)取模.  规定: 没有酒时遇到店是合法的, 但遇到花是不合法的.</li>
    </ul>
  </li>
  <li>思路
    <ul>
      <li><code class="language-plaintext highlighter-rouge">dp[i][j][k]</code>表示走了<code class="language-plaintext highlighter-rouge">i</code>步，经过了<code class="language-plaintext highlighter-rouge">j</code>次店，当前酒量为<code class="language-plaintext highlighter-rouge">k</code>的方案数(即想要达成这样的状态可以有多少种花和店的排列)</li>
      <li>状态转移方程
        <ul>
          <li>上一步遇到花<code class="language-plaintext highlighter-rouge">dp[i][j][k]=dp[i][j][k]+dp[i-1][j][k+1]</code></li>
          <li>上一步遇到店<code class="language-plaintext highlighter-rouge">dp[i][j][k]=dp[i][j][k]+dp[i-1][j-1][k/2]</code></li>
        </ul>
      </li>
      <li>初始条件
        <ul>
          <li><code class="language-plaintext highlighter-rouge">dp[1][0][2]=1</code></li>
        </ul>
      </li>
      <li>由题最后一次遇到的是花, 且正好将酒喝光，所以答案<code class="language-plaintext highlighter-rouge">dp[n+m][n][1]</code></li>
    </ul>
  </li>
</ul>

<div class="language-cpp highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">dp</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">][</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>  <span class="c1">// 初始条件</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">n</span> <span class="o">+</span> <span class="n">m</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o">&lt;=</span> <span class="n">n</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">k</span> <span class="o">&lt;=</span> <span class="n">m</span><span class="p">;</span> <span class="n">k</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
            <span class="c1">// 遇到花</span>
            <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="o">+</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span> <span class="o">+</span> <span class="mi">1</span><span class="p">])</span> <span class="o">%</span> <span class="n">MOD</span><span class="p">;</span>
            <span class="c1">// 遇到店</span>
            <span class="k">if</span> <span class="p">(</span><span class="n">j</span> <span class="o">&amp;&amp;</span> <span class="p">(</span><span class="n">k</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">))</span> <span class="p">{</span>
                <span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">dp</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="o">+</span> <span class="n">dp</span><span class="p">[</span><span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="n">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">][</span><span class="n">k</span> <span class="o">/</span> <span class="mi">2</span><span class="p">])</span> <span class="o">%</span> <span class="n">MOD</span><span class="p">;</span>
            <span class="p">}</span>
        <span class="p">}</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="3区间dp">3.区间DP</h2>

<p><img src="/assets/images/1768377004174.png" alt="1768377004174.png" width="50%" height="auto" style="display: inline-block" /></p>]]></content><author><name></name></author><summary type="html"><![CDATA[DP 动态规划]]></summary></entry><entry><title type="html">2024年最爱的方大同歌曲Top10！</title><link href="https://gybaoyu.github.io/2025/01/16/2025%E5%B9%B4%E6%9C%80%E5%96%9C%E6%AC%A2%E7%9A%84%E6%96%B9%E5%A4%A7%E5%90%8C%E6%AD%8C%E6%9B%B2Top10.html" rel="alternate" type="text/html" title="2024年最爱的方大同歌曲Top10！" /><published>2025-01-16T04:53:58+00:00</published><updated>2025-01-16T04:53:58+00:00</updated><id>https://gybaoyu.github.io/2025/01/16/2025%E5%B9%B4%E6%9C%80%E5%96%9C%E6%AC%A2%E7%9A%84%E6%96%B9%E5%A4%A7%E5%90%8C%E6%AD%8C%E6%9B%B2Top10</id><content type="html" xml:base="https://gybaoyu.github.io/2025/01/16/2025%E5%B9%B4%E6%9C%80%E5%96%9C%E6%AC%A2%E7%9A%84%E6%96%B9%E5%A4%A7%E5%90%8C%E6%AD%8C%E6%9B%B2Top10.html"><![CDATA[<blockquote>
  <p>虽说是2024的年度最爱，但实际上是25年才写的，毕竟24年这博客还没上线（或者说已经下线了）。以后这个top10会每年更新一次，多少也算记录我音乐口味的变化了hhhhh。既然是我的个人博客，也就懒得叠甲了，总之直接开始！</p>
</blockquote>

<h2 id="首先是提名">首先是提名！</h2>

<blockquote>
  <p>从下面的几张专辑里选出了我认为有潜力竞争Top10的歌曲！每张专辑给的歌曲数目不定！像15，JTW听得较少，因此相对给的歌曲比较少（这样也正符合我纪录自己音乐口味的需求）</p>
</blockquote>

<h3 id="soulboy--春风吹每天每天叫我怎么说我们能不能总结"><strong>《soulboy》</strong> <img src="/assets/media/fangdatong-top10/soulboy.jpg" alt="soulboy.jpg" width="5%" height="auto" style="display: inline-block" /> ：春风吹，每天每天，叫我怎么说，我们能不能，总结</h3>

<h3 id="爱爱爱--苏丽珍歌手与模特goodbye-melody-roseif-you-leave-me-now"><strong>《爱爱爱》</strong> <img src="/assets/media/fangdatong-top10/%E7%88%B1%E7%88%B1%E7%88%B1.jpg" alt="爱爱爱.jpg" width="5%" height="auto" style="display: inline-block" /> ：苏丽珍，歌手与模特，Goodbye Melody Rose，If you leave me now</h3>

<h3 id="未来--love-song暖十九八七忘了美丽sorry"><strong>《未来》</strong> <img src="/assets/media/fangdatong-top10/%E6%9C%AA%E6%9D%A5.jpg" alt="未来.jpg" width="5%" height="auto" style="display: inline-block" /> ：Love Song，暖，十九八七…，忘了美丽，Sorry</h3>

<h3 id="橙月--小小虫1234567三人游100种表情爱我吧orange-moon"><strong>《橙月》</strong> <img src="/assets/media/fangdatong-top10/%E6%A9%99%E6%9C%88.jpg" alt="橙月.jpg" width="5%" height="auto" style="display: inline-block" /> ：小小虫，1234567，三人游，100种表情，爱我吧，Orange Moon</h3>

<h3 id="回到未来--爱立刻bb88"><strong>《回到未来》</strong> <img src="/assets/media/fangdatong-top10/%E5%9B%9E%E5%88%B0%E6%9C%AA%E6%9D%A5.jpg" alt="回到未来.jpg" width="5%" height="auto" style="display: inline-block" /> ：爱立刻，BB88</h3>

<h3 id="jtw西游记--run-from-your-love听很不低调"><strong>《JTW西游记》</strong> <img src="/assets/media/fangdatong-top10/JTW.jpg" alt="JTW.jpg" width="5%" height="auto" style="display: inline-block" /> ：Run From Your Love，听，很不低调</h3>

<hr />

<h1 id="排名来咯">排名来咯！</h1>

<h2 id="no10-每天每天">No.10 《每天每天》</h2>
<p>收录于《Soulboy》，娃娃作词。<br />
<strong>简单评价</strong>：最耐听，适合每天每天听。</p>

<h2 id="no9-歌手与模特儿">No.9 《歌手与模特儿》</h2>
<p>收录于《爱爱爱》，林夕作词。<br />
最有梗的一集《歌手与模特儿》-&gt;《大同与薛凯琪》。“我为你写了一首歌，可是你完全认不得，还问我是用心送给谁的，我只好敷衍是写给歌迷的。”<br />
<strong>简单评价</strong>：诙谐的歌词和唱法，最有趣的一首歌，听起来轻松解压。</p>

<h2 id="no8-1234567">No.8 《1234567》</h2>
<p>收录于《橙月》，葛大为作词。<br />
演唱会里的唱这首歌的时候就是我认为方大同最具魅力的时刻，超帅吉他弹唱+超强律动+超甜歌词，以至于我一度在网上找谱尝试学习这首歌的弹唱，然而方大同的歌曲都是好听难唱，以至于最后我根本拿不出手hhh，并且他的律动感我实在模仿不出来。<br />
<strong>简单评价</strong>：《1234567》展现了我心中的律动感。</p>

<h2 id="no7-苏丽珍">No.7 《苏丽珍》</h2>
<p>收录于《爱爱爱》，周耀辉作词。<br />
方大同版的《苏三说》，个人认为这首歌的桥是他最神的桥之一。最推荐的方大同入门曲，旋律超好听。</p>

<h2 id="no6-春风吹">No.6 《春风吹》</h2>
<p>收录于《Soulboy》，周耀辉作词。<br />
编曲最符合歌名的一首。阿卡贝拉+戏曲风格，各种稀奇古怪的音色如同春风吹后复苏各种小动物，春意盎然。<br />
<strong>简单评价</strong>：微风+小动物般的春意盎然。</p>

<h2 id="no5-goodbye-melody-rose">No.5 《Goodbye Melody Rose》</h2>
<blockquote>
  <p>方大同：”这首歌叫Goodbye Melody Rose。Melody就是旋律，Rose就是玫瑰，纪念朋友。”<br />
收录于《爱爱爱》，周耀辉作词。<br />
<strong>简单评价</strong>：极其饱满的情绪，纪念朋友，同时传递力量。</p>
</blockquote>

<h2 id="no4-小小虫">No.4 《小小虫》</h2>
<p>收录于《橙月》，农夫作词。<br />
清新的鼓点节奏+点缀音色，前奏最有画面感，微风+小晴天的下午在大学校园骑自行车。<br />
<strong>简单评价</strong>：清新校园感。</p>

<h2 id="no3-sorry">No.3 《Sorry》</h2>
<p>收录于专辑《未来》，娃娃作词。<br />
最爱的编曲和唱法，超爽听感。每次“I’m so sorry”接桥段就是一次超爽释放。<br />
<strong>简单评价</strong>：跟着乐器一起点头的都是真爱。</p>

<h2 id="no2-忘了美丽">No.2 《忘了美丽》</h2>
<p>收录于专辑《未来》，本人作词。<br />
<strong>简单评价</strong>：丰富、优雅、舒适，是方大同最被低估的歌曲。</p>

<h2 id="no1-我们能不能">No.1 《我们能不能》</h2>
<p>收录于第一张专辑《Soulboy》，发布于2005年11月16日。<br />
<strong>简单评价</strong>：以“爱”为主题，强律动性，抓耳耐听的桥段，深刻平实的歌词，展现方大同的音乐核心——爱。</p>

<blockquote>
  <p>“我们能不能有一天没有战争”<br />
“有一天没有伤痕”<br />
“有一天仇恨痛的没有那么深”<br />
“如果我们想看见”<br />
“我们一定能实现”<br />
“只需要一点时间”<br />
“真正去改变”</p>
</blockquote>

<h2 id="top-0论外orange-moon">Top 0（论外）《Orange Moon》</h2>
<p>收录于《橙月》，隐藏曲目。<br />
简单描述：单纯吉他弹唱，但情感表达清晰。</p>
<blockquote>
  <p>“I’ll search for the orange moon”<br />
“that lit up our love on the ocean”<br />
“while I held your hand.”<br />
“If I see the horizon”<br />
“glow just the same as it did when we stood on the hill”<br />
“I’ll make the arrangements, just wait on that corner for me”</p>
</blockquote>]]></content><author><name></name></author><summary type="html"><![CDATA[虽说是2024的年度最爱，但实际上是25年才写的，毕竟24年这博客还没上线（或者说已经下线了）。以后这个top10会每年更新一次，多少也算记录我音乐口味的变化了hhhhh。既然是我的个人博客，也就懒得叠甲了，总之直接开始！]]></summary></entry></feed>