CF351C Jeff and Brackets

CF351C Jeff and Brackets

广义矩阵加速 DP

题意

构造一个长度为 \(n×m\) 的合法括号序列。

第 \(i\) 个位置上的左括号代价为 \(a_{i~\text{mod}~n}\)，右括号代价为 \(b_{i~\text{mod}~n}\)。

​

求最小代价。（\(1\leq n\leq 20,1\leq m\leq 10^7\)）

题解

我们设 \(f_{i,j}\) 为到第 \(i\) 的位置、有 \(j\) 个左括号未被匹配的最小代价。

显然有：

\[f_{i,j}=
\left\{
\begin{aligned}
&\min ( f_{i-1,j-1}+a_{i~\text{mod}~n},f_{i-1,j+1}+b_{i~\text{mod}~n} )&j>0\\
&f_{i-1,1}+b_{i~\text{mod}~n}&j=0
\end{aligned}
\right.
\]

其中 \(f_{0,0}=0,f_{0,j}=+\infin(j\neq 0)\)。

这里有一个很关键的性质，就是 \(j\leq n\)。

证明（口胡版）：若有一段 \(n+1\) 个连续的左括号，已经覆盖了模 \(n\) 意义下的所有下标，那么一定存在一个右括号能与对应模 \(n\) 下的下标相同的左括号交换，满足交换后序列仍然合法，且代价不变。

因此时间复杂度是 \(O(n^2m)\) 的。

---

考虑优化。

发现转移是存在周期的，周期为 \(n\)，即模 \(n\) 意义下相同的 \(i\) 对应的转移方程形式上是一样的，所以各个周期内的转移方程是一样的，可以用矩阵加速。

形式上，在第一个周期内，将 \(f_{i,0},f_{i,1},\dots,f_{i,n}\) 打包成一个向量 \(A\)，将转移抽象成一个矩阵，那么你就可以求出 \(0 \rightarrow n\) 的转移矩阵 \(T\)，又因为总长度恰好是 \(n\times m\)，所以答案就在 \(T^m\) 中。

具体的，对于第一周期 \(0\rightarrow n\)，我们设

\[A_i=
\begin{bmatrix}
f_{i,0}\\f_{i,1}\\\vdots\\f_{i,n}
\end{bmatrix},
M_i=
\begin{bmatrix}
+\infty&b_i & +\infty & \cdots & +\infty \\
a_i &+ \infty & b_i & +\infty & \vdots \\
+\infty & a_i & +\infty & b_i\\
\vdots & +\infty & a_i &\ddots\\
+\infty & \cdots
\end{bmatrix}
\]

定义 \((\min,+)\) 为 广义矩阵乘法 \(A_{i,j}*B_{i,j}\)，其中 \(C_{i,j}=\min_{k=0}^{n} (A_{i,k} + B_{k,j})\)。

则前面的转移方程可表示为 \(A_i=M_i*A_{i-1}\)。

进一步的，有 \(A_{n}=M_{n-1}*\dots*M_2*M_1*A_0\)。

根据各个周期转移方程相同，有

\[A_{2n}=M_{n-1}*\dots*M_2*M_1*A_n\\A_{3n-1}=M_{n-1}*\dots*M_2*M_1*A_{2n}\\ \dots
\]

联立起来得到：\(A_{mn}=(M_{n-1}*\dots*M_2*M_1)^m*A_0\)

其中 \(A_0=\begin{bmatrix}
0\\+\infin\\\vdots\\+\infin
\end{bmatrix}\)，答案为 \(f_{mn,0}=(M_{n-1}*\dots*M_2*M_1)^m_{0,0}\)。

用矩阵快速幂计算即可，时间复杂度为 \(O(n \log m)\)。

代码

代码使用了封装矩阵和保险防越界的写法，直观易读。

long long 建议怕爆就全开，反正没有 MLE 的风险。

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N=25;
const int INF=1e18;

int n,m;
int a[N],b[N];

struct mat{
    int m[N][N];

    int* operator [] (size_t i) {return m[i];}
    const int* operator [] (size_t i) const {return m[i];}

    mat() {for(int i=0;i<=n;i++) for(int j=0;j<=n;j++) m[i][j]=INF;}
    mat operator * (const mat& b) const {
        mat res;
        for(int i=0;i<=n;i++)
            for(int k=0;k<=n;k++){
                if(m[i][k]==INF) continue;
                const int a=m[i][k];
                for(int j=0;j<=n;j++) res[i][j]=min(res[i][j],a+b[k][j]);
            }
        return res;
    }
    mat operator ^ (int b) const {
        mat res,a=(*this);
        res.init();
        while(b){
            if(b&1) res=res*a;
            a=a*a,b>>=1;
        }
        return res;
    }
    void init(){
        for(int i=0;i<=n;i++)
            for(int j=0;j<=n;j++)
                if(i==j) m[i][j]=0;
                else m[i][j]=INF;
    }
    void build(int a,int b){for(int i=0;i<=n;i++) m[i+1][i]=a,m[i][i+1]=b;}
};

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin>>n>>m;
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0;i<n;i++) cin>>b[i];

    mat M,T;
    T.init();
    for(int i=0;i<n;i++){
        M.build(a[i],b[i]);
        T=M*T;
    }
    cout<<(T^m)[0][0];
    return 0;
}