动态规划入门:如何用Java解决PTA上的回文串和矩阵链相乘问题?

AI 应用开发 × 算法面试题:业务场景实战 12 题【TopK、LRU、RRF 融合、相似度、限流算法,含手撕代码与底层答案】 本文聚焦AI应用岗算法面试新趋势,剖析12道融合业务场景的高频题:从海量日志中挖掘慢查询(分治+小顶堆)、亿级去重(布隆过滤器)、向量与关键词融合排序(RRF)、语义缓存设计(带租户隔离与TTL的LRU)到限流策略(令牌桶+滑动窗口),强调“场景复述→算法选型→手撕代码→生产落地”四步答题框架。突出考察点已从纯算法转向工程权衡、业务理解与系统设计能力,如误判容忍度、实时性与内存预算的平衡,助力开发者应对2026年真实技术挑战。 阅读详情

动态规划实战:从回文串构造到矩阵链乘优化,用Java攻克PTA经典难题

算法学习路上,动态规划(Dynamic Programming, DP)常常是那道分水岭。很多朋友在初次接触时,会被它“状态”、“转移方程”、“最优子结构”这些术语绕晕,感觉懂了概念,一遇到PTA(程序设计类实验辅助教学平台)上的题目又无从下手。我自己刚开始刷题时也这样,对着“回文串”和“矩阵链相乘”这类题目发愣,明明知道是动态规划,却不知道如何把问题拆解成代码。

这篇文章,我想和你一起,像解谜一样,把这两个PTA上的经典动态规划问题彻底搞懂。我们不只满足于AC(Accept),更要理解背后的设计思路,知道为什么这么定义状态,以及如何写出清晰、高效的Java代码。你会发现,一旦掌握了核心的思考框架,很多动态规划问题都会变得有迹可循。

1. 动态规划思维重塑:从“记忆化搜索”到“自底向上”

在直接切入具体问题前,我们有必要统一一下对动态规划本质的理解。很多人把它等同于“填表格”,这没错,但容易流于形式。我更愿意把它看作一种 “聪明的暴力搜索”。

想象一下,你要计算斐波那契数列的第n项。最直接的递归写法是 fib(n) = fib(n-1) + fib(n-2)。但你会发现,计算 fib(5) 时,fib(3) 被重复计算了多次。动态规划的核心思想就是:把已经解决过的子问题的答案存起来,避免重复计算。

这引出了动态规划的两个关键实现方式:

  • 记忆化搜索(自顶向下):在递归函数中,加入一个缓存(比如数组或哈希表),每次计算前先查缓存,算完后存入缓存。这更符合人类的自然思维——从大问题分解到小问题。
  • 递推(自底向上):先解决最小的子问题,然后逐步组合,解决更大的问题。这就是我们常说的“填表法”,通常用循环实现,效率更高,也是PTA题目中最常见的考察形式。

对于PTA的编程题,我们通常采用递推方式,因为它代码结构清晰,且避免了递归可能带来的栈溢出风险。一个通用的思考流程可以总结为以下几步:

  1. 定义状态:用 dp[i] 或 dp[i][j] 这样的数组表示什么?它必须能够描述问题在某个阶段的情况。
  2. 确定状态转移方程:这是最核心的一步。找出 dp[i] 和之前状态(如 dp[i-1], dp[i-2] 等)之间的关系。这本质上是一个递推公式。
  3. 初始化:最小的、不可再分的子问题答案是什么?这通常是 dp[0], dp[1] 或 dp[i][i] 的值。
  4. 确定计算顺序:为了保证在计算当前状态时,它所依赖的子状态都已经被计算出来,我们需要确定正确的循环顺序。
  5. 返回结果:最终答案对应的是哪个状态?是 dp[n],还是 dp[0][m]?

提示:在纸上画一画状态表,手动模拟一下前几步的填充过程,是理解动态规划极其有效的方法,能帮你直观地验证转移方程是否正确。

下面,我们就带着这个“五步思考法”,去破解两个具体的难题。

2. 回文串构造问题:寻找“最长的回文子序列”

PTA上的题目描述通常是:给定一个字符串,可以在任意位置添加字符,求使其变成回文串所需的最少添加字符数。

例如:输入 "Ab3bd",输出 2(可以添加两个字符变成 "dAb3bAd" 或 "Adb3bdA")。

2.1 问题转化与状态定义

直接思考“添加几个字符”可能有点绕。我们换个角度:一个字符串添加字符变成回文串,等价于保留原字符串中的部分字符构成一个回文子序列,然后为不在这个子序列里的字符在对称位置补上对应的字符。

因此,最少添加字符数 = 原字符串长度 - 原字符串中最长回文子序列(Longest Palindromic Subsequence, LPS)的长度。

这样一来,问题就变成了经典的最长回文子序列问题。我们的状态可以定义为: dp[i][j]:表示字符串 s 中从下标 i 到下标 j(包含两端)的子串中,最长回文子序列的长度。

这里 i 和 j 代表子串的左右边界。我们的目标是求出 dp[0][n-1](n 为字符串长度)。

2.2 推导状态转移方程

如何求 dp[i][j] 呢?我们考虑子串的两端字符 s.charAt(i) 和 s.charAt(j):

  • 情况一:两端字符相等。如果 s.charAt(i) == s.charAt(j),那么这两个字符肯定可以成为最终回文子序列的两端。因此,dp[i][j] 就等于去掉这两端后中间部分的最长回文子序列长度加2。

    dp[i][j] = dp[i+1][j-1] + 2; (当 i < j-1)
    

    注意边界:当 i == j 时,子串只有一个字符,它本身就是回文,长度为1。当 i == j-1 且字符相等时,回文长度为2。

  • 情况二:两端字符不相等。如果 s.charAt(i) != s.charAt(j),那么这两个字符不可能同时作为回文子序列的两端。最长回文子序列要么在 s[i+1...j] 中,要么在 s[i...j-1] 中。我们取两者的最大值。

    dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1]);
    

2.3 Java实现与细节

根据上面的分析,我们需要一个二维数组 dp。注意计算顺序:由于 dp[i][j] 依赖于 dp[i+1][j-1]、dp[i+1][j] 和 dp[i][j-1],即依赖于“左下”、“下”、“左”三个方向的值。因此,我们需要从下往上、从左往右地遍历,或者固定子串长度,从小到大计算。

以下是采用固定子串长度的Java实现,这种方式逻辑更清晰:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int n = s.length();
        
        // dp[i][j] 表示 s[i..j] 的最长回文子序列长度
        int[][] dp = new int[n][n];
        
        // 初始化:单个字符的子串,回文长度为1
        for (int i = 0; i < n; i++) {
            dp[i][i] = 1;
        }
        
        // len 表示当前考虑的子串长度,从2开始到n
        for (int len = 2; len <= n; len++) {
            for (int i = 0; i <= n - len; i++) {
                int j = i + len - 1; // 子串右端点
                if (s.charAt(i) == s.charAt(j)) {
                    // 两端字符相等
                    if (len == 2) {
                        dp[i][j] = 2; // 只有两个相同字符
                    } else {
                        dp[i][j] = dp[i + 1][j - 1] + 2;
                    }
                } else {
                    // 两端字符不等
                    dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        
        // 最少添加字符数 = 原长 - 最长回文子序列长度
        int lpsLength = dp[0][n - 1];
        int minAdd = n - lpsLength;
        System.out.println(minAdd);
        sc.close();
    }
}

代码要点解析:

  • 我们使用 len 循环来控制子串长度,确保在计算较长子串时,其内部较短的子串已经计算完毕。
  • 当 len=2 且两端字符相等时,是一个特殊情况,中间没有子串(i+1 > j-1),直接赋值为2。
  • 最终结果 dp[0][n-1] 就是整个字符串的最长回文子序列长度。

为了更直观地理解填充过程,我们以字符串 "abbc" 为例,观察 dp 表的最终状态:

i\j0(a)1(b)2(b)3(c)
01122
1-122
2--11
3---1

注意:表格中 - 表示无效区域(i>j)。dp[0][3] 的值为2,最长回文子序列是 "bb",所以最少需要添加 4 - 2 = 2 个字符(如变成 "bcb" 需要添加一个,但题目要求回文,所以是 "bcbcb"? 这里示例可能不完美,但说明了计算过程)。

3. 矩阵链相乘问题:优化计算顺序以节省代价

这是动态规划另一个教科书级的例子。问题描述:给定一系列矩阵 A1, A2, ..., An,其中矩阵 Ai 的维度是 p[i-1] x p[i]。确定一个乘法结合的顺序,使得计算 A1*A2*...*An 所需的总标量乘法次数最少。

例如:三个矩阵维度分别是 10x100, 100x5, 5x50。按 (A1*A2)*A3 计算需要 10*100*5 + 10*5*50 = 5000 + 2500 = 7500 次。按 A1*(A2*A3) 计算需要 100*5*50 + 10*100*50 = 25000 + 50000 = 75000 次。显然第一种顺序更优。

3.1 理解问题与最优子结构

矩阵乘法满足结合律,但不满足交换律。不同的加括号方式(即计算顺序)会导致巨大的计算量差异。关键点在于,最后一次乘法发生的位置。如果我们把矩阵链在位置 k 处分开,变成 (A1...Ak) 和 (A(k+1)...An) 两部分先分别计算,最后再相乘,那么总代价就是: 计算左边链的最小代价 + 计算右边链的最小代价 + 两边结果矩阵相乘的代价。

这完美符合动态规划的“最优子结构”性质:整个问题的最优解包含了其子问题的最优解。

3.2 状态定义与转移方程

我们定义状态: dp[i][j]:表示计算矩阵链 Ai...Aj(i <= j)所需的最少标量乘法次数。

我们的目标是 dp[1][n](注意,通常输入中矩阵从1开始编号,与数组下标0开始需要做好转换)。

状态转移方程基于“最后一次乘法位置k”的枚举: dp[i][j] = min{ dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j] },其中 k 的取值范围是 i <= k < j。

这里 p[i-1]*p[k]*p[j] 是合并左右两部分结果矩阵的代价。左部分矩阵维度是 p[i-1] x p[k],右部分矩阵维度是 p[k] x p[j],相乘的代价就是这三个数的乘积。

初始化:当 i == j 时,只有一个矩阵,不需要乘法,所以 dp[i][i] = 0。

3.3 Java实现与计算顺序

计算 dp[i][j] 需要知道它左边和下边的值(因为 k 在 i 和 j 之间)。一种常见的遍历顺序是:按矩阵链的长度 len 从小到大进行。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 矩阵个数
        int[] p = new int[n + 1]; // 维度数组,p[0]到p[n]
        for (int i = 0; i <= n; i++) {
            p[i] = sc.nextInt();
        }
        
        // dp[i][j] 表示计算 Ai...Aj 的最小代价,1-based索引
        int[][] dp = new int[n + 1][n + 1];
        
        // 初始化:单个矩阵代价为0
        for (int i = 1; i <= n; i++) {
            dp[i][i] = 0;
        }
        
        // len 表示矩阵链的长度(包含的矩阵个数),从2开始
        for (int len = 2; len <= n; len++) {
            for (int i = 1; i <= n - len + 1; i++) { // 链的起点
                int j = i + len - 1; // 链的终点
                dp[i][j] = Integer.MAX_VALUE; // 初始化为无穷大
                // 枚举分割点k
                for (int k = i; k < j; k++) {
                    int cost = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j];
                    if (cost < dp[i][j]) {
                        dp[i][j] = cost;
                    }
                }
            }
        }
        
        System.out.println(dp[1][n]);
        sc.close();
    }
}

复杂度分析:三层循环,时间复杂度为 O(n³)。对于PTA题目中 n <= 100 的限制,完全可行。空间复杂度为 O(n²)。

为了加深理解,我们用一个简单例子手动推导。假设 p = [30, 35, 15, 5, 10, 20],对应5个矩阵:A1(30x35), A2(35x15), A3(15x5), A4(5x10), A5(10x20)。

计算 dp[1][5] 需要枚举 k=1,2,3,4:

  • k=1: cost = dp[1][1]+dp[2][5]+303520 = 0 + ? + 21000
  • k=2: cost = dp[1][2]+dp[3][5]+301520 = (303515) + ? + 9000
  • ... 最终通过子问题的递推,可以算出最小值为11875。

注意:在实际编程中,我们通常使用1-based索引来处理矩阵编号,这样更直观,但需要小心数组边界。p 数组的长度是 n+1,dp 数组的维度也是 [n+1][n+1],并忽略第0行和第0列。

4. 举一反三:动态规划的常见模式与PTA刷题策略

通过上面两个问题的深入剖析,我们可以看到,尽管问题领域不同(字符串 vs. 线性代数),但其动态规划的解题框架是相通的。在PTA上,动态规划题目还有几种非常高频的类型,掌握其模式能极大提升解题效率。

4.1 经典模型识别

问题类型典型PTA题目状态定义核心转移方程特征
线性DP最大子段和、最长递增子序列dp[i] 表示以第i个元素结尾的某种最优解通常只与前面有限个状态相关
背包问题0-1背包、完全背包dp[i][j] 表示前i个物品在容量j下的最优解基于“放”与“不放”的选择
区间DP矩阵链乘、石子合并、回文串dp[i][j] 表示区间 [i, j] 上的最优解枚举区间分割点 k
路径/网格DP寻宝(数字三角形)、最小路径和dp[i][j] 表示到达位置 (i, j) 的最优解来自上方或左方的转移

4.2 针对PTA的实战编码技巧

在PTA平台提交Java代码解决动态规划问题时,有几个细节能帮你避免不必要的失分:

  1. 输入输出效率:当数据量较大时(如 n=10000),使用 Scanner 可能较慢。可以考虑使用 BufferedReader。

    import java.io.*;
    public class Main {
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String[] firstLine = br.readLine().split(" ");
            int n = Integer.parseInt(firstLine[0]);
            // ... 后续处理
        }
    }
    
  2. 数组大小:根据题目给出的数据范围(如 n<=1000)声明数组,宁可稍微开大一点,避免边界溢出。例如,对于区间DP,数组大小常设为 n+5。

  3. 初始化:务必仔细处理边界条件的初始化。例如,在求“最小值”问题时,通常需要将 dp 数组初始化为一个很大的数(如 Integer.MAX_VALUE),但要注意后续加法运算可能导致的整数溢出,有时用 0x3f3f3f3f 这类较大的安全数作为“无穷大”更稳妥。

  4. 空间优化:有些DP问题,当前状态只与前一两个状态有关,可以用滚动数组将空间复杂度从 O(n²) 降到 O(n) 甚至 O(1)。这在PTA中不一定是必须的,但能体现对算法的深入理解。例如,0-1背包的一维数组优化:

    int[] dp = new int[C + 1];
    for (int i = 0; i < n; i++) {
        for (int j = C; j >= weight[i]; j--) { // 注意逆序!
            dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    

4.3 调试与验证思路

当你写出代码但结果不对时,可以尝试:

  • 小数据测试:自己构造几个小的、能口算的测试用例,在本地运行,用打印语句输出关键的 dp 表,与手动计算的结果对比。
  • 理解样例:PTA的样例输入输出通常涵盖了关键情况(如全负数、边界值)。确保你的程序能通过样例。
  • 画图辅助:对于区间DP,在纸上画出矩阵链或字符串区间,标出 i, j, k,有助于检查转移方程是否正确。

动态规划的学习曲线确实比较陡峭,但它的回报也非常丰厚。它不仅是一类重要的算法,更是一种强大的问题分析和分解的思维方式。我在刷了几十道PTA的DP题目后,最大的感触是:不要怕“硬想”。拿到一个新题,先尝试自己定义状态、推导方程,哪怕一开始是错的,这个思考过程的价值远大于直接看题解。回文串和矩阵链相乘这两个问题,就像两把钥匙,帮你打开了动态规划宫殿的两扇大门,门后的世界,还需要你用自己的代码一步步去探索。

RTX 4060笔记本也能跑!保姆级教程:用Ollama在Windows上部署DeepSeek-R1-8B模型 本文详细介绍了如何在RTX 4060笔记本上通过Ollama本地部署DeepSeek-R1-8B模型,提供从环境配置到性能调优的全流程优化指南。针对笔记本用户的显存、散热等问题,给出了量化模型选择、启动参数优化及散热解决方案,帮助用户在消费级硬件上高效运行大语言模型。 阅读详情

相关推荐

手把手教你配置UEFI Secure Boot:从密钥生成到系统验证(附避坑指南)

本文详细介绍了如何配置UEFI Secure Boot,从密钥生成到系统验证的全过程,包括PK、KEK等关键密钥的生成方法,以及常见问题的解决方案。通过实战案例和避坑指南,帮助用户有效提升系统启动安全性,防止恶意软件植入。

weixin_30776273的博客 343

PTA练习动态规划

目录1 最大子段和2 0-1背包3 回文串问题4 矩阵链相乘问题5 寻宝 1 最大子段和 给定n个整数(可能为负数)组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整数均为负数时,定义子段和为0。 要求算法的时间复杂度为O(n)。 输入格式: 输入有两行: 第一行是n值(1<=n<=10000); 第二行是n个整数。 输出格式: 输出最大子段和。 输入样例: 在这里给出一组输入。例如: 6 -2 11 -4 13

愤怒的阿木木的博客 2336

SBP依赖计算中的蝴蝶效应:一个Prefab修改如何触发全量重建?

本文深入探讨了Unity中SBP(Scriptable Build Pipeline)依赖计算的蝴蝶效应,解析了Prefab修改如何触发全量重建的机制。通过分析Asset与Object的层级关系、依赖计算的三种维度及CacheEntry系统,揭示了全量重建的根本原因,并提供了依赖可视化工具开发、优化策略与最佳实践,帮助开发者提升构建效率。

weixin_29015051的博客 446

PTA动态规划实战:从最大子段和到背包问题,5个经典题目详解(附Java代码)

本文深入解析PTA平台上的5个经典动态规划问题,包括最大子段和、0-1背包、回文串、矩阵链相乘和寻宝问题,提供详细的解题思路和Java代码实现。通过从简单到复杂的案例,帮助读者掌握动态规划的核心思想和应用技巧,提升算法竞赛和面试中的解题能力。

weixin_30399821的博客 416

Chkdsk误删文件?5步教你从FOUND.000文件夹找回重要数据(附工具推荐)

本文详细介绍了当Chkdsk误删文件后,如何从FOUND.000文件夹中找回重要数据的5个步骤。包括理解Chkdsk与FOUND.000的关系、定位与访问FOUND.000文件夹、手动恢复CHK文件的技巧、使用UnCHK工具自动化恢复以及预防数据丢失的关键措施。适用于Windows用户解决数据丢失问题,特别是NTFS文件系统下的文件恢复。

weixin_30687051的博客 393

单相PWM整流器的数学模型、工作原理

单相PWM整流器的数学模型、工作原理

weixin_58670090的博客 1万+

PTA实战:动态规划经典问题解析与优化

本文以PTA平台实战为例,深入解析动态规划经典问题,包括最大子段和、0-1背包、回文串与编辑距离、矩阵链相乘及寻宝路径。通过剖析核心思想、状态转移方程与空间优化技巧,提供清晰的Java/C++代码实现,旨在帮助读者掌握动态规划的精髓,提升算法解题能力。

xxx12的博客 868

PADS VX2.7学习记录05-PADS Layout设计文件Gerber等输出整理

在“PDF Document”栏中,依次选中除REF-TOP和REF-BOT之外的文件,单击图标,将其余PDF Document文件进行删除,如图所示。然后单击【生成PDF】按钮,即可创建一份PDF格式的位号图。

tianpu2320959696的博客 1028

【算法拾光】队列|在每个树⾏中找最⼤值 + 最后⼀块⽯头的重量

本文总结两道经典算法题:一是通过层序遍历(BFS)逐层找最大值,利用队列分层处理,每层维护最大值;二是用大根堆(优先队列)模拟石头碰撞过程,每次取最大两块石头,差值重新入堆,直至剩余一块或无石。前者适用于树的层次遍历,后者适合动态获取最值场景。核心思想:队列用于分层遍历,堆用于高效取极值。

wuqingyigexiaoba的博客 202

我的宠物狗学编程:从零开始的代码之旅

在这个示例中,我们定义了一个名为"interact"的函数,它通过输入函数获取用户的输入,并根据输入执行相应的代码块。在编程中,我们使用条件语句来根据不同的条件执行不同的代码块。对于我的狗狗,我将创建一个名为"feed"的函数来表示它的进食行为,并根据不同的条件输出不同的信息。在这个示例中,我们定义了一个名为"feed"的函数,并使用一个参数"food"来表示食物。对于我的狗狗,我将创建一个名为"dog_name"的变量来存储它的名字。对于我的狗狗,我将创建一个名为"bark"的函数来表示它的叫声。

2301_79331387的博客 337

[企业AI落地] RAG 知识库系统在多租户环境下的细粒度权限隔离设计

多租户 RAG 系统真正的风险不只是搜不到,而是把不该看到的内容查出来、说出来、写回去。本文结合多客户售后知识助手场景,用元数据结构、向量检索过滤、回答策略和审计回写示例拆解租户、资源、检索、生成、审计五层权限边界。

技术小甜甜:传播可落地技术,帮助个人和企业降低解决真实场景问题的成本 223

把 KV Cache 压到 FP4:BitDecoding-FP4 的算法-系统协同设计复盘

长上下文推理卡在KV Cache的显存与带宽上,而现有FP4方案要么精度崩、要么速度废。这篇文章复盘BitDecoding-FP4如何用三个算法补丁加一个系统重构,在B300上把服务吞吐提升2.4–3.0倍,精度几乎不掉。

helloagent的博客 319

【微服务】Spring Aop原理深入解析

spring原理深度解析

congge 1万+

【算法拾光】链表 哈希表|K个一组翻转链表 + 两数之和

K个一组翻转链表需分段反转,借助哑节点与前驱指针维护连接,避免断链;两数之和利用哈希表实现O(1)查找,空间换时间,高效定位目标组合。前者考察链表指针操作,后者聚焦映射关系构建,均为面试高频题。

wuqingyigexiaoba的博客 341

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

排序算法深度笔记(下):非比较类排序的线性突破与工程边界

排序算法时间复杂度额外空间复杂度稳定性是否基于比较选择排序O(N^2)(O(1))不稳定是冒泡排序O(N^2)(O(1))稳定是插入排序O(N^2)(O(1))稳定是归并排序O(N\log N)(O(N))稳定是快速排序O(N\log N)O(log N)不稳定是堆排序O(N\log N)O(1)不稳定是计数排序(O(N + M))O(M))稳定否基数排序O(N)稳定否桶排序平均O(N) / 最坏O(N^2)

2401_87069538的博客 617

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

优选算法:分治-归并排序

交易逆序对的总数

Wangshijie1015的博客 154

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

408 算法 06|堆与 Top-K:最小的 10 个数,到底该用数组还是堆

2022(42) 找 100 万个数里最小的 10 个,官方给了"10 元素有序数组"和"大根堆"两种答案。我把两种都实现并数了比较次数:k=10 时两者几乎打平,k=10000 时堆少 111 倍。另附 2021(42) 计数排序的比较次数与稳定性实测。

m0_56226131的博客 453

算法64,字母异位词分组

代码核心思路是:互为字母异位词的字符串,在对其字符进行排序后,一定会得到相同的字符串。因此,可以将排序后的字符串作为哈希表的键(Key)来进行分组。

sheshibenniaodan的博客 219

408 算法 04|主元素与三元组最小距离:两种“扫描时做决定“的思路

2013(41) 的主元素用摩尔投票一遍选出候选,但真正的考点是"选完必须验票";2020(41) 的三元组最小距离,三指针每次只挪最小的那个,靠的是 D=2×(max−min) 这个恒等式。两套完整 C 代码加真实输出,附官方评分档位表。

m0_56226131的博客 457

牛客周赛165C题(前后缀性质,递推,排序,枚举)

题目大意:给定长度为 `n` 的数组,选择 `k ∈ [1,n]`,将前 `k` 个元素整体翻转,后面的元素不变。要求操作后的整个数组非递减,统计满足条件的 `k` 的数量。题目链接:https://ac.nowcoder.com/acm/contest/141721/C。时间复杂度:O(nlogn)

2501_94316951的博客 175

【MPC 算法】Python 实战:模型预测控制(MPC)算法原理与代码实现

本文介绍模型预测控制(MPC)原理与Python实现。MPC通过滚动优化预测未来状态,结合系统模型、目标函数与约束条件,动态生成最优控制序列。以一阶温度系统为例,使用CVXPY构建凸优化问题,实现加热功率的智能调控。代码包含模型预测、目标函数设计(含温度跟踪与控制平滑惩罚)、输入约束及滚动更新机制。仿真结果表明,MPC能快速稳定温度至目标值60℃,且控制动作平滑合理,体现其在复杂系统中的优越性。

赖德发的博客 70

算法61,判定是否为字符重排

两字符串能互为重排 ⇔。

sheshibenniaodan的博客 227

【前缀和+复合离散化】题解:双色矩形(two)_数据结构_算法优化_预处理_二维前缀和_STL_C++算法竞赛

给定一个 $n \times n$ 的黑白棋盘,初始按 $i+j$ 奇偶染色,经 $k$ 个格子颜色翻转后,求子矩形中黑白格子数差的绝对值最大值。由于 $n$ 可达 $10^9$,但 $k \leq 50$,可离散化关键点。枚举所有由修改点构成的矩形及其四边向外扩展(共 $16$ 种扩展方式),利用二维前缀和快速计算变化量,结合奇偶性判断多出的格子颜色,最终取最大绝对差。时间复杂度为 $O(k^4)$,在 $k \leq 50$ 下可行。

YLCHUP的博客 214

算法62&&63,存在重复元素

判断整数数组中是否有任意元素出现至少两次。:判断数组中是否存在两个。,且索引差值的绝对值。

sheshibenniaodan的博客 105

商业综合体公摊电费分摊算法:512 商户双层权重与尾差实测

公摊电费分摊算法是指把公共回路电量按公示权重拆到每户的规则化计算过程,核心不是权重多精巧,而是每张账单都能被租户手算复现。某珠三角商业综合体 512 户商户实测:固定费与变动费按 4:6 加权,尾差用余数递补压到 0.01 千瓦时精度,24 个月 12288 张账单重算差异为零,月度争议从 31 起降到 2 起。适用边界:商铺与租户已独立装表、公共回路已分项计量的商业综合体适用;末端未装表、靠总表减合计倒推公摊的场景不适用,先把表补齐再谈分摊。

185

考拉兹猜想 - 7

本文通过引入虚数单位重构Collatz猜想的迭代逻辑,指出偶数减半与奇数“乘3加1”的过程在虚数坐标下等价于归结操作。关键在于:乘3加1使奇数跃升至偶数,随后持续减半,而虚数单位代表“无限减1”,实现无限向有限的转化。无论初始值如何,减半始终主导,最终归结为4-2-1循环。该视角消解了正向思维中的速度竞争疑虑,证明归结是必然结果。

杨铸人的博客 93
上一篇: FastAPI WebSocket避坑指南:从连接建立到错误处理的完整流程
下一篇: 从ECU设计视角看DTC:工程师如何用ISO 14229-1规范设计故障码系统?
python9snake
博客等级 码龄1天 0粉丝 1724原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值