【算法】矩阵快速幂优化动态规划

已于 2023-09-17 21:55:23 修改
阅读量177 收藏
点赞数
分类专栏： 算法 文章标签： 算法 矩阵 动态规划 快速幂 DP 递推
于 2023-09-17 20:24:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43406895/article/details/132930260
版权

文章目录

知识讲解

矩阵快速幂可以将 O ( n ) O(n) O(n) 的 DP 优化成 O ( log ⁡ n ) O(\log{n}) O(logn) 的时间复杂度。

前置知识——快速幂，可见：【算法基础：数学知识】4.4 快速幂

我们拿递推公式 d p [ i ] = d p [ i − 1 ] + [ i − 2 ] dp[i] = dp[i - 1] + [i - 2] dp[i]=dp[i−1]+[i−2] 举例，
为了将其表示成矩阵乘法，添加一个式子 d p [ i − 1 ] = d p [ i − 1 ] dp[i - 1] = dp[i - 1] dp[i−1]=dp[i−1]
两个式子合并可以得——
在这里插入图片描述
这是因为 d p [ i ] = 1 ∗ d p [ i − 1 ] + 1 ∗ [ i − 2 ] dp[i] = 1 * dp[i - 1] + 1 * [i - 2] dp[i]=1∗dp[i−1]+1∗[i−2] , d p [ i − 1 ] = 1 ∗ d p [ i − 1 ] + 0 ∗ [ i − 2 ] dp[i - 1] = 1 * dp[i - 1] + 0 * [i - 2] dp[i−1]=1∗dp[i−1]+0∗[i−2]

这样就可以对递推矩阵使用快速幂来将 n 次递推的时间复杂度简化到 logn。

题目列表

[矩阵快速幂] 题目列表📕

题目列表来源：https://leetcode.cn/problems/string-transformation/solutions/2435348/kmp-ju-zhen-kuai-su-mi-you-hua-dp-by-end-vypf/

70. 爬楼梯

https://leetcode.cn/problems/climbing-stairs/
在这里插入图片描述

提示：
1 <= n <= 45

解法1——线性DP
class Solution {
    public int climbStairs(int n) {
        if (n <= 1) return n;
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for (int i = 2; i < n; ++i) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n - 1];
    }
}
解法2——矩阵快速幂

根据递推公式，可以得出矩阵快速幂的矩阵是什么。

class Solution {
    public int climbStairs(int n) {
        if (n <= 2) return n;
        // m是根据递推公式来的
        int[][] m = {
            {1, 1},
            {1, 0}
        };
        return pow(m, n - 2)[0][0];
    }

    public int[][] pow(int[][] m, int k) {
        // dp[0] = 1,dp[1] = 2
        int[][] res = {
            {2, 0},
            {1, 0}
        };
        for (; k != 0; k /= 2) {
            if (k % 2 == 1) res = mul(m, res);
            m = mul(m, m);
        }
        return res;
    }

    public int[][] mul(int[][] x, int[][] y) {
        int[][] res = new int[2][2];
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                res[i][j] = x[i][0] * y[0][j] + x[i][1] * y[1][j];
            }
        }
        return res;
    }
}

也可以更简洁一些，从 dp[0] 开始写，代码如下：

class Solution {
    public int climbStairs(int n) {
        // m是根据递推公式来的
        int[][] m = {
            {1, 1},
            {1, 0}
        };
        return pow(m, n)[0][0];
    }

    public int[][] pow(int[][] m, int k) {
        // dp[0] = 1
        int[][] res = {
            {1, 0},
            {0, 0}
        };
        for (; k != 0; k /= 2) {
            if (k % 2 == 1) res = mul(m, res);
            m = mul(m, m);
        }
        return res;
    }

    public int[][] mul(int[][] x, int[][] y) {
        int[][] res = new int[2][2];
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                res[i][j] = x[i][0] * y[0][j] + x[i][1] * y[1][j];
            }
        }
        return res;
    }
}

509. 斐波那契数

https://leetcode.cn/problems/fibonacci-number/
在这里插入图片描述
提示：
0 <= n <= 30

跟上一题差不多，注意初始值变了。

class Solution {
    public int fib(int n) {
        if (n == 0) return n;
        // m是根据递推公式来的
        int[][] m = {
            {1, 1},
            {1, 0}
        };
        return pow(m, n - 1)[0][0];
    }

    public int[][] pow(int[][] m, int k) {
        // dp[0] = 1
        int[][] res = {
            {1, 0},
            {0, 0}
        };
        for (; k != 0; k /= 2) {
            if (k % 2 == 1) res = mul(m, res);
            m = mul(m, m);
        }
        return res;
    }

    public int[][] mul(int[][] x, int[][] y) {
        int[][] res = new int[2][2];
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                res[i][j] = x[i][0] * y[0][j] + x[i][1] * y[1][j];
            }
        }
        return res;
    }
}

1137. 第 N 个泰波那契数

https://leetcode.cn/problems/n-th-tribonacci-number/

在这里插入图片描述
提示：
0 <= n <= 37
答案保证是一个 32 位整数，即 answer <= 2^31 - 1。

对矩阵稍作修改即可。

class Solution {
    public int tribonacci(int n) {
        if (n <= 1) return n;
        // m是根据递推公式来的
        int[][] m = {
            {1, 1, 1},
            {1, 0, 0},
            {0, 1, 0}
        };
        return pow(m, n - 2)[0][0];
    }

        public int[][] pow(int[][] m, int k) {
        // dp[0] = 0, dp[1] = 1, dp[2] = 1
        int[][] res = {
            {1, 0, 0},
            {1, 0, 0},
            {0, 0, 0}
        };
        for (; k != 0; k /= 2) {
            if (k % 2 == 1) res = mul(m, res);
            m = mul(m, m);
        }
        return res;
    }

    public int[][] mul(int[][] x, int[][] y) {
        int[][] res = new int[3][3];
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                res[i][j] = x[i][0] * y[0][j] + x[i][1] * y[1][j] + x[i][2] * y[2][j];
            }
        }
        return res;
    }
}

1220. 统计元音字母序列的数目

https://leetcode.cn/problems/count-vowels-permutation/

在这里插入图片描述

提示：
1 <= n <= 2 * 10^4

解法1——线性DP
class Solution {
    final long MOD = (int)1e9 + 7;
    public int countVowelPermutation(int n) {
        long[][] dp = new long[n][5];
        Arrays.fill(dp[0], 1);
        for (int i = 1; i < n; ++i) {
            dp[i][0] = dp[i - 1][1];
            dp[i][1] = (dp[i - 1][0] + dp[i - 1][2]) % MOD;
            dp[i][2] = (dp[i - 1][0] + dp[i - 1][1] + dp[i - 1][3] + dp[i - 1][4]) % MOD;
            dp[i][3] = (dp[i - 1][2] + dp[i - 1][4]) % MOD;
            dp[i][4] = dp[i - 1][0];
        }
        long ans = 0;
        for (long x: dp[n - 1]) ans = (ans + x) % MOD;
        return (int)ans;
    }
}
解法2——矩阵快速幂优化DP
class Solution {
    final long MOD = (int)1e9 + 7;

    public int countVowelPermutation(int n) {
        long[][] m = {
            {0, 1, 0, 0, 0},
            {1, 0, 1, 0, 0},
            {1, 1, 0, 1, 1},
            {0, 0, 1, 0, 1},
            {1, 0, 0, 0, 0}
        };
        long[][] res = pow(m, n - 1);
        long ans = 0;
        for (int i = 0; i < 5; ++i) ans = (ans + res[i][0]) % MOD;
        return (int)ans;
    }

    public long[][] pow(long[][] m, int k) {
        long[][] res = {
            {1, 0, 0, 0, 0},
            {1, 0, 0, 0, 0},
            {1, 0, 0, 0, 0},
            {1, 0, 0, 0, 0},
            {1, 0, 0, 0, 0}
        };
        for (; k != 0; k /= 2) {
            if (k % 2 == 1) res = mul(m, res);
            m = mul(m, m);
        }
        return res;
    }

    public long[][] mul(long[][] x, long[][] y) {
        long[][] res = new long[5][5];
        for (int i = 0; i < 5; ++i) {
            for (int j = 0; j < 5; ++j) {
                res[i][j] = (x[i][0] * y[0][j] + x[i][1] * y[1][j] + x[i][2] * y[2][j] + x[i][3] * y[3][j] + x[i][4] * y[4][j]) % MOD;
            }
        }
        return res;
    }
}

552. 学生出勤记录 II（🚹递归公式 & 矩阵快速幂优化🐂）

https://leetcode.cn/problems/student-attendance-record-ii/
在这里插入图片描述
提示：
1 <= n <= 10^5

解法1——动态规划
class Solution {
    final int MOD = (int)1e9 + 7;

    public int checkRecord(int n) {
        // 长度，A 的数量，结尾连续 L 的数量
        int[][][] dp = new int[n + 1][2][3];    
        dp[0][0][0] = 1;
        for (int i = 1; i <= n; ++i) {
            // 以P结尾
            for (int j = 0; j < 2; ++j) {
                for (int k = 0; k < 3; ++k) {
                    dp[i][j][0] = (dp[i][j][0] + dp[i - 1][j][k]) % MOD;
                }
            }
            // 以A结尾
            for (int k = 0; k < 3; ++k) {
                dp[i][1][0] = (dp[i][1][0] + dp[i - 1][0][k]) % MOD;
            }
            // 以L结尾
            for (int j = 0; j < 2; ++j) {
                for (int k = 1; k < 3; ++k) {
                    dp[i][j][k] = (dp[i][j][k] + dp[i - 1][j][k - 1]) % MOD;
                }
            }
        }

        int ans = 0;
        for (int j = 0; j < 2; ++j) {
            for (int k = 0; k < 3; ++k) {
                ans = (ans + dp[n][j][k]) % MOD;
            }
        }
        return ans;
    }
}
解法2——矩阵快速幂优化DP（TODO）
在这里插入代码片

790. 多米诺和托米诺平铺⭐（🚹想出递推公式）

https://leetcode.cn/problems/domino-and-tromino-tiling/
在这里插入图片描述
提示：
1 <= n <= 1000

解法1——动态规划1 分最后一列的状态

https://leetcode.cn/problems/domino-and-tromino-tiling/solutions/1962465/duo-mi-nuo-he-tuo-mi-nuo-ping-pu-by-leet-7n0j/
在这里插入图片描述

class Solution {
    final int MOD = (int)1e9 + 7;

    public int numTilings(int n) {
        // 0空，1上，2下，3满
        int[][] dp = new int[n][4];
        dp[0][0] = dp[0][3] = 1;
        for (int i = 1; i < n; ++i) {
            dp[i][0] = dp[i - 1][3];
            dp[i][1] = (dp[i - 1][0] + dp[i - 1][2]) % MOD;
            dp[i][2] = (dp[i - 1][0] + dp[i - 1][1]) % MOD;
            dp[i][3] = (((dp[i - 1][0] + dp[i - 1][1]) % MOD + dp[i - 1][2]) % MOD + dp[i - 1][3]) % MOD;
        }
        return dp[n - 1][3];
    }
}
解法2——动态规划2 列出式子找通项公式（TODO 还没想明白）

https://leetcode.cn/problems/domino-and-tromino-tiling/solutions/1968516/by-endlesscheng-umpp/
在这里插入图片描述

class Solution {
    final long MOD = (long)1e9 + 7;

    public int numTilings(int n) {
        if (n <= 2) return n;
        long[] dp = new long[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; ++i) {
            dp[i] = (dp[i - 1] * 2 + dp[i - 3]) % MOD;
        }
        return (int)dp[n];
    }
}
解法3——矩阵快速幂优化DP
class Solution {
    final int MOD = (int)1e9 + 7;

    public int numTilings(int n) {
        // 0空，1上，2下，3满
        long[][] m = {
            {0, 0, 0, 1},
            {1, 0, 1, 0},
            {1, 1, 0, 0},
            {1, 1, 1, 1}
        };
        return (int)pow(m, n - 1)[3][0];
    }

    public long[][] pow(long[][] m, int k) {
        long[][] res = {
            {1, 0, 0, 0},
            {0, 0, 0, 0},
            {0, 0, 0, 0},
            {1, 0, 0, 0}
        };
        for (; k != 0; k >>= 1) {
            if ((k & 1) == 1) res = mul(m, res);
            m = mul(m, m);
        }
        return res;
    }

    public long[][] mul(long[][] a, long[][] b) {
        long[][] c = new long[4][4];
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                c[i][j] = (a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j] + a[i][3] * b[3][j]) % MOD;
            }
        }
        return c;
    }
}
# 相关链接
[【力扣周赛】第 362 场周赛（⭐差分&匹配&状态压缩DP&矩阵快速幂优化DP&KMP）](https://blog.csdn.net/qq_43406895/article/details/132824604)
Wei *
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
快速幂入门文献-用于旋翼飞行器的控制
03-17
快速幂 快速幂算法在旋翼飞行器控制中的应用并非直接关联，快速幂作为一种高效的数学算法...例如，在设计某种迭代算法时，若需快速求解矩阵指数函数（如系统动态模型矩阵的指数形式），这时快速幂算法就可以派上用场。
全面的算法代码库
04-08
简单的快速幂 Fast-Exponentiation 树状数组 Fenwick-Tree 所有结点对之间的最短路径（Floyd） Floyd-Warshall 凸包算法（Graham扫描法） Graham-Scan 辗转相除法求最大公约数 Greatest-Common-Divisor 堆排序 ...
蓝桥杯 2015_9 矩阵快速幂 + 动态规划
Unyielding will
03-28 245
题目描述： 赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。  经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！ 我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。  假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。  atm想计算一下有多少种不同的可能的垒骰子方式
【知识点】快速幂与矩阵快速幂
Macw07的博客
04-26 1168
快速幂和快速矩阵的基本概念。
模拟题 czy的后宫
jjs98
05-19 1306
【题目描述】 czy要妥善安排他的后宫，他想在机房摆一群妹子，一共有n个位置排成一排，每个位置可以摆妹子也可以不摆妹子。有些类型妹子如果摆在相邻的位置（隔着一个空的位置不算相邻），就不好看了。假定每种妹子数量无限，求摆妹子的方案数。 【输入格式】 输入有m+1行，第一行有两个用空格隔开的正整数n、m，m表示妹子的种类数。接下来的m行，每行有m个字符1或0,若第i行第j列为1，则表示第i种
矩阵快速幂模板以及其应用矩阵加速递推
M3ng@L的博客
08-27 761
计算这样的递推次数很多的式子，我们需要一个更简化更快捷的计算方式，也就是矩阵快速幂。我们只需要构造最小限度能解决问题的矩阵就好，无论是矩阵初始值还是转移矩阵，所以还是需要具体问题具体分析地来构造矩阵。的矩阵，其实列向量还是行向量都可以，只要转移矩阵也是对应的即可）那么根据转移矩阵表现出来的与原数列的关系，我们可以这样来看。的矩阵初始值浪费了计算空间，所以构造其他形式的初始矩阵。的初始矩阵的话，对应数列的递推关系是不完整的；得到的新矩阵的第一项数据即是斐波那契数列的第。把矩阵乘法展开，得到。......
poj 3734 Blocks （矩阵快速幂优化的动态规划）
Gavin的专栏
05-20 553
题目大意： 有4种颜色，去涂满n个格子，其中要求红和绿两种颜色涂偶数次。问：最终有多少种不同的填涂方案。 解题思路： 一开始以为是排列组合，但是n的范围太大。 可以很明显的得到一个dp方程：dp[i][j][k] 表示涂第i 位，红色是否为偶数，绿色是否为偶数，值表示种数。 dp[i][0][0] = dp[i-1][0][0]*2+dp[i-1][0][1]*1+dp[i-1][1][
易语言-高效数据结构及算法模块
06-29
当前已支持算法：快速排序、插入排序、堆排序、归并排序、取最大、取最小、向下取整、向上取整、反转字节集、反转文本、反转数组、扩展欧几里得、中国剩余定理、快速幂、线性回归相关、线性规划 当前已支持数据结构...
lrucacheleetcode-Practice-Of-Algorithm:算法练习
06-29
lru cache leetcode ...动态规划,矩阵快速幂 leetcode 模拟 leetcode 字符串遍历 leetcode 图 DFS leetcode 图 DFS leetcode 数组循环右移 leetcode 暴力 动态规划 空间优化 leetcode 一次遍历 双指针
幂运算 数组_快速幂运算在动态规划中的应用
weixin_39710594的博客
01-12 218
我们知道动态规划主要可以用来解决两类问题：优化问题组合计数问题花花今天就来和大家聊一聊在组合计数问题中，如何使用快速幂运算来进行加速，把时间复杂度从O(n)降低到O(logn)。用到的知识点有二进制和矩阵运算。在这期节目中我们假设大家已经推导出了组合计数问题的状态转移方程，如果对动态规划不太熟悉的同学们可以翻一下往期的文章，或者回复 DP 获取内容。首先我们来看一下 LeetCode...
meethigher-快速幂实战
meethigher的博客
08-28 531
快速幂用来高效计算高次方，正常计算时间复杂度为O(n)，使用快速幂可以做到O(log₂n)
矩阵快速幂+动态规划=蓝桥杯 垒骰子
Code-CHAN的博客
04-12 152
矩阵快速幂+动态规划=蓝桥杯 垒骰子 如果还不知道什么是矩阵快速幂，可以参加我的另一篇文章：矩阵快速幂详解 题目 分析 看到 nnn 的范围达到了 10910^{9}109 ，如果使用暴力搜索是不现实的。 我们看看是否可以利用动态规划解决问题呢？ 首先定义我们 dpdpdp 数组的含义： dp[i][j]dp[i][j]dp[i][j] 为第 iii 个骰子， jjj 面朝上时的组合数。 列出 base case： 只有一个骰子时，jjj 面朝上时，有四种方式。因为骰子有四个侧面，可以选择任意侧面。 即：
快速幂及矩阵快速幂——加快运算
Stillboring的博客
06-01 204
为什么需要快速幂呢？ 在求解n^k的时候如果k比较小，那么我们可以用k个n相乘来求得结果，但是当k比较大的时候，这种朴素求法就 很容易超时，这时候我们可以使用快速幂算法求解。 在现实生活中，如果让你求2^20次方，你会怎么求？ 一般我们会这样来求 让 2 * 2 = 4,这样就能算出2^2的值了。 让 4 * 4 =16,这样就能算出2^4的值了。 让16 * 16 = 256,这样就能算出2 ...
矩阵加速快速幂模板
m0_73557680的博客
10-04 49
矩阵加速快速幂
快速幂算法及其在动态规划中的应用(矩阵幂)
CS_boy的博客
01-29 997
小天使请安
质数和约数
2302_77099705的博客
05-21 1127
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
算法训练营36
最新发布
stmfresher的博客
05-22 191
代码随想录上的思路，让加油 - 耗油，如果所有的总和都<0 那肯定跑不完，然后用一个currsum 统计从 0 开始到当前i 的 剩余油之和，如果 < 0 说明 起始位置肯定在为 i + 1，然后currsum 置零，在重复上面操作，最后返回 start 就行。这道题从两边开始算就好，先从左向右只考虑右边小孩比左边小孩大，然后从右向左考虑，最后取两次糖果数组里大的，然后最后求和即可。根据通过情况反复挑战最终AC过了，这里和原来的差别是他的排序是用绝对值排序的，这样的思路会很简单。
每日一题（PTA Advanced1003）：Emergency-dfs
m0_75015083的博客
05-22 132
【代码】每日一题（PTA Advanced1003）：Emergency-dfs。
通过Wirtinger流进行相位恢复：理论与算法
xy_optics的博客
05-22 876
Wirtinger流，包含通过谱方法初始化并使用类似梯度下降的新更新规则迭代地细化估计。这种方法承诺通过最少数量的随机测量实现精确的相位恢复，同时在计算和数据资源方面都具有高效性。传统方法，如Gerchberg-Saxton算法及其变体，通过迭代地应用投影，使频谱的幅度与观察数据匹配。这些方法依赖于关于信号的先验知识，并且缺乏理论上的收敛保证。Wirtinger流算法初始猜测zoz_ozo​是通过计算从测量数据构建的矩阵的主特征向量得到的。使用非凸目标函数的梯度迭代地细化zzz。
用java写一个BigInteger优化的矩阵快速幂算法，
04-03
以下是一个使用BigInteger实现的矩阵快速幂算法的示例代码： ```java import java.math.BigInteger; public class MatrixPower { public static BigInteger[][] matrixPower(BigInteger[][] m, long p) { int size = m.length; BigInteger[][] res = new BigInteger[size][size]; for (int i = 0; i < size; i++) { res[i][i] = BigInteger.ONE; } while (p > 0) { if ((p & 1) != 0) { res = matrixMultiply(res, m); } m = matrixMultiply(m, m); p >>= 1; } return res; } public static BigInteger[][] matrixMultiply(BigInteger[][] a, BigInteger[][] b) { int size = a.length; BigInteger[][] res = new BigInteger[size][size]; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { for (int k = 0; k < size; k++) { if (res[i][j] == null) { res[i][j] = BigInteger.ZERO; } res[i][j] = res[i][j].add(a[i][k].multiply(b[k][j])); } } } return res; } public static void main(String[] args) { BigInteger[][] matrix = {{BigInteger.valueOf(1), BigInteger.valueOf(1)}, {BigInteger.valueOf(1), BigInteger.valueOf(0)}}; BigInteger[][] result = matrixPower(matrix, 10); System.out.println(result[0][1]); // Output: 55 } } ``` 这个示例代码计算了斐波那契数列的第10项，其中矩阵`matrix`表示斐波那契数列的递推式，即F(n) = F(n-1) + F(n-2)，其中F(0)=0，F(1)=1。在这里，我们使用了BigInteger来处理大数值的计算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wei *

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值