算法 {矩阵DP(矩阵优化递推DP)}

算法 {矩阵DP(矩阵优化递推DP)}

矩陣DP

定义

有個若干個DP (比如有3個DP: DP0[ N], DP1[ N], DP2[ N]), 每一個DP的遞推式 滿足線性組合, 即$DP0/1/2[i]=k1\ast DP0[i-1]+k2\ast DP1[i-1]+k3\ast DP2[i-1]$;

for( int i = 1; i < N; ++i){
	DP0[ i] = k0*DP0[ i-1] + k1*DP1[ i-1] + k2*DP2[ i-1];
	DP1[ i] = k3*DP0[ i-1] + k4*DP1[ i-1] + k5*DP2[ i-1];
	DP2[ i] = k6*DP0[ i-1] + k7*DP1[ i-1] + k8*DP2[ i-1];
}

這個時間是$O(N)$的, 如果$N$很大 比如$>1e8$ 那麼可以把以上過程 轉換為 矩陣乘法;

DP[3] = { DP0[0], DP1[0], DP2[0]}; (初值)
A[3][3] = { {k0, k3, k6}, {k1, k4, k7}, {k2, k5, k8}};

可以發現 執行矩陣乘法`DP * A = DPP` 會得到DPP[0]=DP0[1] DPP[1]=DP1[1] DPP[2]=DP2[1];
換句話說 `* A`表示: 進行了一次DP的遞推 (即對應樸素算法的for循環);
因此 要得到樸素算法的DP?[ N-1] 即進行了`N-1`次的遞推, 即`DP * A*...*A`(一共有N-1個A);

根據*矩陣乘法*的傳遞律, 比如你要進行5個遞推 那麼他等價於`(DP*A)*(A*A*A*A)`
因此`DP * A^n` 可以用快速冪計算, 有以下两种做法:  
1: 你可以先求出`AA: A^n`, 然後最後執行DP*AA;
2: DP也可以直接參與到快速冪裡, 即`DP*(A^1) * (A^2) * (A^4) * ...`;

错误

比如要快速幂求A^k, 最初答案矩阵 设置成全1 这是错误的!
矩阵乘法中的单位1 即单位矩阵, 不是全1, 而是主对角线为1 其他为0;

性质

算法

代碼

//{ ___DP_MatrixMultiply (矩阵优化递推DP)
template< class _T_> std::vector< _T_> ___DP_MatrixMultiply( std::vector<_T_> _initDP, std::vector<std::vector<_T_> > _factor, long long _count){
//< 比如`initDP = [DP0, DP1], factor: [[a,b], [c,d]]`, 则表示DP递推式为`DP0 = a*DP0 + b*DP1, DP1 = c*DP0 + d*DP1`;
//  . `_count`为递推次数, 即`initDP`进行`count`次递推后 结果为*返回值*;
    ASSERT_( _count >= 0, _count);
    ASSERT_( _initDP.size()==_factor.size() && _factor.size()==_factor[0].size());
    int const N = _initDP.size();
    { // `factor`转换为其转置矩阵
        for( int i = 0; i < N; ++i){
            for( int j = i+1; j < N; ++j){
                std::swap( _factor[i][j], _factor[j][i]);
            }
        }
    }
    auto temp1 = _initDP;
    auto temp2 = _factor;
    while( _count > 0){
        if( _count & 1){ // DP *= factor;
            for( int col = 0; col < N; ++col){
                temp1[ col] = 0;
                for( int i = 0; i < N; ++i){
                    temp1[ col] += (_initDP[ i] * _factor[ i][ col]);
                }
            }
            _initDP = temp1;
        }
        _count >>= 1;
        { // factor *= factor
            for( int row = 0; row < N; ++row){
                for( int col = 0; col < N; ++col){
                    temp2[ row][ col] = 0;
                    for( int i = 0; i < N; ++i){
                        temp2[ row][ col] += (_factor[ row][ i] * _factor[ i][ col]);
                    }
                }
            }
            _factor = temp2;
        }
    }
    return _initDP;
}
//} ___DP_MatrixMultiply

例题

@LINK: https://editor.csdn.net/md/?not_checkout=1&articleId=139273191;
求4.....4(长度为1e9)这个10进制数的取模值;
DP矩阵里 放一个常数;

@DELI;

@LINK: https://editor.csdn.net/md/?not_checkout=1&articleId=132818193;`;

@DELI;

AcWing-1305. GT考试

AcWing-1304. 佳佳的斐波那契

AcWing-1303. 斐波那契前 n 项和

筆記

The nature of Matrix-Multiplication in Algorithm is $DP$, so it is vital to review some notion of $DP$:
0 $Time(Order)$, the DP-Value of Time-$i$ ($DP[i]$) always depends on $DP[<i]$;
. . For example, $Fibonacci[i]=Fibonacci[i-1]+Fibonacci[i-2]$;
1 State, at every Time-$i$, $DP$ has several $States$;
. . e.g., $DP[n]$ has just one-state ($DP[i]$); $DP[n][m]$ has $m$-states $DP[i][0,1,...,m-1]$;

@Delimiter

The Matrix-Multiplication in Algorithm must be in the form:
$$Dp[a_0,a_1,...,a_{n-1}]\ast Factor\left[\begin{array}{cccc}{k}_{0,0}& k_{0,1}& ...& k_{0,n-1}\\ ...& & & \\ k_{n-1,0}& k_{n-1,1}& ...& k_{n-1,n-1}\end{array}\right]=Result[b_0,b_1,...,b_{n-1}]$$

$Dp$ must be a $1\ast n$ Row-Matrix;
$Factor$ must be a $n\ast n$ Square-Matrix;
Then, $Result$ is a $1\ast n$ Row-Matrix;
We called $Dp,Result$ the $\text{ DP-Matrix}$

If we denote $Dp[a_0,a_1,...,a_{n-1}]$ as the DP-Time-$i$ (i.e., $DP[i]$), then $Result[b_0,b_1,...,b_{n-1}]$ would be the DP-Time-$i+1$ (i.e., $DP[i+1]$);
. More specifically, the phrase $Dp[a_0,a_1,...,a_{n-1}]=DP[i]$ means that, $DP[i]$ has $n$ $States$ $a_0,...,a_{n-1}$;
. So, $a_i,b_i$ denote the same DP-State, just the Time of $a_i$ is $k$ and the Time of $b_i$ is $k+1$;

Then, $b_i=C_0\ast a_0+C_1\ast a_1+...+C_{n-1}\ast a_{n-1}$ where $C_i$ are all $Constants$;
. That is, $bi$ is a Linear-Combination of all $a_i$;
. Cuz $C_i$ must be $Constants$, the DP-State-Transformation must be in the form of Linear-Combination (i.e., $\text{Constant * DP-State}$) (if not, that DP not fit the Matrix-Multiplication);
. . e.g., $DP[i]=DP[i-1]\ast DP[i-2]$ is Infeasible;

The utmost point is to clarify the correspondence between The-Time of the matrix-$Dp[...]$ and The-Time of the DP of all its elements $a_i$;
. e.g., Calculate the $S[i]={\sum }_{j=1}^{i}F[j]$ where $F[]$ is the Fibonacci;
. . Suppose the DP-Time of the matrix $Dp[...]$ is $i$, and we let $a_0=F[i],a_1=F[i+1],a_2=S[i]$ (suppose these three values are already gained);
. . We need to update $b_i$ correctly, that is, to determine those $k_{i,j}$ in the matrix-$Factor$;
. . Then, the matrix-$Result$ would be The-Time $i+1$ (cuz the matrix-$Dp$ is Time-$i$); Therefore, $b_0$ denotes $F[i+1]$, $b_1=F[i+2]$, $b_2=S[i+1]$;
. . We need to find the relation between $a_i,b_j$, so $b_0=a_1$, $b_1=a_0+a_1$, $b_2=a_2+a_1$; This is valid due to the form of every formula is Linear-Combination;

@Delimiter

Initially, if we set the matrix-$Dp[...]$ as DP-Time-$0$, we wanna it to be DP-Time-$i$;
. That is, $Dp[...]\ast Factor\ast Factor\ast ...\ast Factor$ where the number of $Factor$ is $i$; the result would be the DP-Time-$i$;
. Matrix-Multiplication satisfies the Combination-Property, then it can be transformed to $Dp[...]\ast (Facto{r}^i)$, we can use Binary-Exponentiation to solve it;

@DELI;

$\text{Property-0}$

The elements $a_i$ in the matrix-$Dp[a_0,a_1,...]$ can be divided into two-types:
0 $a_i$ is a DP-State; The value of $a_i$ depends on the DP-Time of the matrix-$Dp[...]$ (of course, $a_i$ is not a Constant);
1 $a_i$ is a Constant; Whatever the DP-Time of the matrix-$Dp[...]$ is, $a_i$ is always the same;

For example, $dp[i]=2\ast dp[i-1]+5$, then we transform it to $2\ast dp[i-1]+1\ast 5$ which satisfying the requirement that $2,1$ are Constants;
. Let the matrix-$Dp[a,b]$ be the DP-Time-$i$ where $a=dp[i],b=5$;
. Then the matrix-$Result[c,d]$ be the DP-Time-$i+1$ where $c=dp[i+1]=2\ast dp[i]+5,d=5$, so $c=2\ast a+1\ast b,d=b$ satisfying the Linear-Combination;

@Delimiter

$\text{Property-1}$

Once the DP-Time of the matrix-$Dp[...]$ is settled (suppose it is $i$), then the DP-Time of all its DP-Elements $a_i$ is also fixed;
. e.g., Let the DP-Time of the matrix-$Dp[a,b,c,d]$ is $i$, where $a=d{p}_1[i],b=d{p}_2[i-1],c=d{p}_3[i+1]$ and $d$ is a Constant-Element;
. . Now, given you another matrix-$T[d,e,f]$ whose DP-Time is $j$, then we would know that, $d=d{p}_1[j],e=d{p}_2[j-1],f=d{p}_3[j+1]$$;