大白话 Manacher算法

最新推荐文章于 2024-09-25 11:53:45 发布
最新推荐文章于 2024-09-25 11:53:45 发布
阅读量1k 收藏 21
点赞数 21
分类专栏： 算法 文章标签： 算法 Manacher Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mp9105/article/details/138378741
版权

Manacher 算法

Manacher 算法简介

Manacher 算法用于解决字符串中最长回文子串最大长度问题。

解释一下：

  • 回文：这个很好理解了，就是字符串正序和逆序是相同的

    • 字符串长度为奇数时，该回文字符串一定会有个中心对称轴，例如 “abcba” 关于中间的 ‘c’ 左右对称

    • 字符串长度为偶数时，只有一个虚拟的对称轴，例如"abba"，只需要左右相同即可。

  • 子串：字符串中连续的字符序列

    • 一定注意了，必须得是连续的，例如对于字符串 “abcde”，“abc”、“bcd”…都是它的子串，但是类似"abd"、"ace"这种就不是它的子串了。

例如：

str=“123”，其中的最长回文子串为"1"、“2"或者"3”，所以返回 1。

str=“abbac”，其中的最长回文子串为"aabb"，所以返回 4。

str=“abc1234321ab”，其中的最长回文子串为"1234321"，所以返回 7。

整体思路

从左到右遍历字符串，遍历到每个字符的时候，都看看以这个字符作为中心能够产生多大的回文字符串。比如 str=“abacaba”，以 str[0]=='a’为中心的回文字符串最大长度为 1，以 str[1]==‘b’ 为中心的回文字符串最大长度为 3，……其中最大的回文子串是以 str[3]=='c’为中心的时候。

字符串预处理

上面的处理方式中会有一个问题，当回文字符串长度为偶数时，由于没有实际存在的中心轴，就没有办法通过上面方式求解了。

我们可以通过填充值的方式来避免出现偶数的回文串，可以对str 进行处理，把每个字符开头、结尾和中间插入一个特殊字符’#'来得到一个新的字符串数组。比如 str=“bcbaa”，处理后为"#b#c#b#a#a#"，然后从每个字符左右扩出去的方式找最大回文子串就方便多了。

  • 对奇回文来说，不这么处理也能通过扩的方式找到，比如"bcb"，从’c’开始向左右两侧扩出去能找到最大回文。处理后为"#b#c#b#"，从’c’开始向左右两侧扩出去依然能找到最大回文。

  • 对偶回文来说，不处理而直接通过扩的方式是找不到的，比如"aa"，因为没有确定的轴，但是处理后为"#a#a#"，就可以通过从中间的’#'扩出去的方式找到最大回文。

代码如下

    private static char[] manacherString(String s) {
        char[] chars = s.toCharArray();
        int n = (chars.length << 1) + 1;
        char[] ans = new char[n];
        int index = 0;
        for (int i = 0; i < n; i++) {
            ans[i] = (i & 1) == 0 ? '#' : chars[index++];
        }
        return ans;
    }

几个概念

假设 str 处理之后的字符串记为 charArr。对每个字符（包括特殊字符）都进行“优化后”的扩充过程。

为了后面能更加方便地介绍 Manacher 算法，这里先介绍几个概念。

回文半径

由于charArr中回文串长度都是奇数，那么它一定会有一个中心对称轴，回文半径就是该中心对称轴到两端的距离（包括端点）。

例如，对于"#a#b#c#b#a#"，它中心为 ‘c’，中心点+左边是 “#a#b#c”，中心点+右边是 “c#b#a#”，它们的长度都是6，因此回文半径长度是6。可以看到，如果还原为原始字符串，那么原始字符串的长度为5，因此原始回文字符串长度=回文半径-1。

再比如，对于"#a#b#b#a#"，它中心为正中间的 ‘#’，中心点+左边是 “#a#b#”，中心点+右边是 “#b#a#”，它们的长度都是5，因此回文半径长度是5。可以看到，如果还原为原始字符串，那么原始字符串的长度为4，因此也有原始回文字符串长度=回文半径-1。

所以，无论原始回文字符串长度为奇数还是偶数，它的长度都是扩展后回文半径-1。

回文半径数组pArr

长度与 charArr 长度一样。

pArr[i]的意义是以 i 位置上的字符（charArr[i]）作为回文中心的情况下，扩出去得到的最大回文半径是多少。

举例说明，对"#c#a#b#a#c#"来说，pArr[0…9]为[1,2,1,2,1,6,1,2,1,2,1]。整个过程就是在从左到右遍历的过程中，依次计算每个位置的最大回文半径值。

最右扩展位置pR及对应中心c

这个变量的意义是之前遍历的所有字符的所有回文半径中，最右即将到达的位置。

还是以 “#c#a#b#a#c#” 为例来说，还没遍历之前，pR 初始设置为-1。

  • charArr[0]==‘#’：回文半径为 1，所以目前回文半径向右只能扩到位置 0，回文半径最右即将到达的位置变为 1（pR=1），此时对应的中心位置更新，也即是 c == 0。

  • charArr[1]=='c’的回文半径为 2，此时所有的回文半径向右能扩到位置 2，所以回文半径最右即将到达的位置变为 3（pR=3），此时对应的中心位置更新，也即是 c == 1。

  • charArr[2]=='#'的回文半径为 1，所以位置 2 向右只能扩到位置 2，回文半径最右即将到达的位置不变，仍是 3（pR=3），c不变。

  • charArr[3]=='a’的回文半径为 2，所以位置 3 向右能扩到位置 4，回文半径最右即将到达的位置变为 5（pR=5），此时对应的中心位置更新，也即是 c == 3。

  • charArr[4]=='#'的回文半径为 1，所以位置 4 向右只能扩到位置 4，回文半径最右即将到达的位置不变，仍是 5（pR=5），c不变。

  • charArr[5]=='b’的回文半径为 6，所以位置 4 向右能扩到位置 10，回文半径最右即将到达的位置变为 11（pR=11），此时对应的中心位置更新，也即是 c == 5。此时已经到达整个字符数组的结尾，所以之后的过程中pR 和c也都将不再变化。

换句话说，pR 就是遍历过的所有字符中向右扩出来的最大右边界。只要右边界更往右，pR 就更新。

image

算法流程

主流程

只要能够从左到右依次算出数组 pArr 每个位置的值，最大的那个值实际上就是处理后的 charArr 中最大的回文半径，根据最大的回文半径，再对应回原字符串，整个问题就解决了。

假设现在计算到位置 index 的字符 charArr[i]，在 i 之前位置的计算过程中，都会不断地更新pR 和 c 的值，即位置 index 之前的 c 这个回文中心扩出了一个目前最右的回文边界 pR。

再次强调一下，pR是c点所在回文区域最右侧+1的位置

走到index会有以下几种情况：

情况1：index < pR，此时，之前的回文串已经罩不住index了

image

情况2：index >= pR，此时，之前的回文串还能罩住index

此时 i 关于 c 的对称点为 i’，此时又可以分为以下三种情况

image

情况2-1：i’ 的回文半径覆盖区域（下图绿色区域）还仍在c覆盖区域内部

image

情况2-2：i’ 的回文半径覆盖区域（下图绿色区域）已经越过了 c 点覆盖的区域

image

情况2-3：i’ 的回文半径覆盖区域（下图绿色区域）刚好到达c点覆盖区域的左侧

image

具体分析

情况1：之前的回文串已经罩不住index

此时，没有优化空间，我们从 index 位置开始，向左右两侧扩出去检查，此时的“扩”过程没有获得加速。

情况2-1：之前的回文串能罩住index，i’ 回文范围未到达c回文范围左侧

我们假设i’ 回文半径覆盖范围，记做A，A左边为a位置，右边为b位置

那么一定可以在 i 周围画一个和 i’ 回文半径覆盖相同半径的区域，记做X，假设X区域左边是x位置，右边是y位置。

那么由于原始字符串关于c在 left ~ pr-1 范围内都是对称的，则 A 区域与 X 区域构成的字符串必然是逆序的，又因为 A 区域关于 i’ 是对称的，那么 X 区域一定是关于 i 对称的。则pArr[i] 至少与 pArr[i’] 是相等的。

那么 pArr[i] 能不能 > pArr[i’] 呢？答案是不能的。

我们假设 pArr[i] > pArr[i’]，则必然有 x 位置的值 == y位置的值

由于对称性，a位置的值 == y 位置的值，b位置的值 == x 位置的值

那么可以得到 a位置的值 == b 位置的值，阔到了i’ 回文覆盖的范围外面了，明显矛盾了。

image

也就是说，这种情况下，pArr[i] = pArr[i’]，且 pR以及c 都不变

情况2-2：之前的回文串能罩住index，i’ 回文范围越过了c回文范围左侧

我们假设c覆盖的回文的最左侧为 left 位置，left位置左边为a位置（a=left-1），a关于i’的对称位置为b。

再假设pr指向的位置为y位置，y关于i对称的位置为x。

现在要证明 pArr[i] == pr - index。

首先，由于i’的范围已经越过 left 了，在 left ~ pr-1范围内 i 与 i’ 又是对称的，那么i点的回文半径必定是可以取到 pr - index 的。

现在来证明 pArr[i] 不可能 > pr - index。

还是采用反证法，如果可i的回文半径可以 > pr - index，那么y位置的值 == x位置的值

由于 c 的回文范围为 left~pr-1（也就是y-1），那么a位置的值必然 != y位置的值

而由于对称性 a位置的值 == b位置的值 == x位置的值，于是得到：

x位置的值 != y位置的值，这与前面的假设是矛盾的，因此 pArr[i] = pr - index 成立。

image

这种情况下，pR与c也不用进行更新。

情况2-3：之前的回文串能罩住index，i’ 回文范围正好到达c回文范围左边界

这种情况下，无法直接获得答案，需要对 i 的回文范围进行扩充

由于对称性，我们知道 pArr[i] >= pr - index，于是可以将半径从 pr - index + 1 开始逐一比较 i 的左右字符是否相等，直到取到最大的回文半径。

image

代码实现

逐行翻译上面的实现思路，代码如下

    public static int manacher(String s) {
        if (s == null || s.isEmpty()) {
            return 0;
        }
        char[] str = manacherString(s);
        int n = str.length;
        // 之前遍历的所有字符的所有回文半径中，最右即将到达的位置的下一个位置
        // 一开始 pR 还没有扩充，指向-1
        int pR = -1;
        // 当前 pR 对应的中心回文子串的中心位置
        int c = -1;
        // 记录每个位置的回文半径
        int[] pArr = new int[n];
        // 记录回文半径的最大值
        int max = 0;
        // 临时变量
        int r;
        for (int index = 0; index < n; index++) {
            if (index < pR) { // 当前最右点可以包住 index
                // 3  4  5  6  7  8  9  10  11  12
                //       i'    c     i          pR
    
                // i' 正好到达 L 时，半径应当为 pR - i
                int rRange = pR - index;
    
                // i 关于 c 的对称点
                int iLeft = 2 * c - index;
                if (pArr[iLeft] < rRange) { // i'的半径 在 [L..R] 内部，不用扩
                    pArr[index] = pArr[iLeft];
                    // 半径 小于 c 半径，max不用更新
                } else if (pArr[iLeft] > rRange) { // i'的半径 在 [L..R] 外部，不用扩
                    pArr[index] = rRange;
                    // 半径 小于 i‘ 半径，max不用更新
                } else {
                    // 接着扩，半径至少为 rangeR 了
                    r = rRange;
                    while (index - r > -1 && index + r < n && str[index - r] == str[index + r]) {
                        r++;
                    }
                    pArr[index] = r;
                    max = Math.max(max, r);
                }
            } else { // 当前最右点可以包不住 index
                // 3  4  5  6  7  8  9  10  11  12  13  14  15  16
                //                              pR      i
    
                // 一次也匹配不上时的半径也应当为1
                r = 1;
                while (index - r > -1 && index + r < n && str[index - r] == str[index + r]) {
                    r++;
                }
                pArr[index] = r;
                max = Math.max(max, r);
            }
            // 更新 pR
            if (index + pArr[index] > pR) {
                pR = index + pArr[index];
                c = index;
            }
        }
        return max - 1;
    }

当然，上面这段代码在结构上还能略做优化

我们可以将这四种情况都抽象为下面过程：

  • 初始化一个 回文半径

  • 迭代获取最大回文半径（如果有必要）

  • 更新 pArr

  • 更新 pR 以及 c（如果有必要）

    public static int manacher(String s) {
        if (s == null || s.isEmpty()) {
            return 0;
        }
        char[] str = manacherString(s);
        int n = str.length;
        int pR = -1;
        int c = -1;
        int[] pArr = new int[n];
        int max = 0;
        int r = 0;
        for (int index = 0; index < n; index++) {
            // 情况1: r = 1
            // 情况2-1: r = pArr[2 * c - index]
            // 情况2-2: 情况2-3: r = pR - index
            r = index < pR ? Math.min(pR - index, pArr[2 * c - index]) : 1;
            // 情况1、情况2-3才会走进这个循环，然后扩充r
            // 情况2-3以及情况2-2直接略过
            while (index + r < n && index - r > -1 && str[index - r] == str[index + r]) {
                r++;
            }
            // 填充 pArr
            pArr[index] = r;
            max = Math.max(max, r);
            // 如有必要（情况1、情况2-3），更新 pR 以及 c
            if (index + pArr[index] > pR) {
                pR = index + pArr[index];
                c = index;
            }
        }
        return max - 1;
    }

时间复杂度

分析迭代过程，对于情况 2-1 以及 情况 2-2，都只需要有限步都能获取答案，由于 index 取值从 0~n 单增，那么走到这两个分支的情况下，最多只需要 O(n) 的复杂度。

再来看 情况1 以及 情况2-2 两个分支，这两个步骤中迭代次数都是将 qR 从前一个更新到 当前步的次数，而 qR 的取值范围是 -1 ~ n，因此时间复杂度也为O(n)。

由于这几个分支只会走其中一个，因此整体的时间复杂度是 O(n)。

完整代码及对数器

    public class Manacher {
    
        public static void main(String[] args) {
            // comp();
            System.out.println(longestPalindrome("cbbd"));
        }
    
        public static int manacher(String s) {
            if (s == null || s.isEmpty()) {
                return 0;
            }
            char[] str = manacherString(s);
            int n = str.length;
            // 之前遍历的所有字符的所有回文半径中，最右即将到达的位置的下一个位置
            // 一开始 pR 还没有扩充，指向-1
            int pR = -1;
            // 当前 pR 对应的中心回文子串的中心位置
            int c = -1;
            // 记录每个位置的回文半径
            int[] pArr = new int[n];
            // 记录回文半径的最大值
            int max = 0;
            // 临时变量
            int r = 0;
            for (int index = 0; index < n; index++) {
                r = index < pR ? Math.min(pR - index, pArr[2 * c - index]) : 1;
                while (index + r < n && index - r > -1 && str[index - r] == str[index + r]) {
                    r++;
                }
                pArr[index] = r;
                max = Math.max(max, r);
                if (index + pArr[index] > pR) {
                    pR = index + pArr[index];
                    c = index;
                }
            }
            return max - 1;
        }
    
        public static int manacher2(String s) {
            if (s == null || s.isEmpty()) {
                return 0;
            }
            char[] str = manacherString(s);
            int n = str.length;
            // 之前遍历的所有字符的所有回文半径中，最右即将到达的位置的下一个位置
            // 一开始 pR 还没有扩充，指向-1
            int pR = -1;
            // 当前 pR 对应的中心回文子串的中心位置
            int c = -1;
            // 记录每个位置的回文半径
            int[] pArr = new int[n];
            // 记录回文半径的最大值
            int max = 0;
            // 临时变量
            int r;
            for (int index = 0; index < n; index++) {
                if (index < pR) { // 当前最右点可以包住 index
                    // 3  4  5  6  7  8  9  10  11  12
                    //       i'    c     i          pR
    
                    // i' 正好到达 L 时，半径应当为 pR - i
                    int rRange = pR - index;
    
                    // i 关于 c 的对称点
                    int iLeft = 2 * c - index;
                    if (pArr[iLeft] < rRange) { // i'的半径 在 [L..R] 内部，不用扩
                        pArr[index] = pArr[iLeft];
                        // 半径 小于 c 半径，max不用更新
                    } else if (pArr[iLeft] > rRange) { // i'的半径 在 [L..R] 外部，不用扩
                        pArr[index] = rRange;
                        // 半径 小于 i‘ 半径，max不用更新
                    } else {
                        // 接着扩，半径至少为 rangeR 了
                        r = rRange;
                        while (index - r > -1 && index + r < n && str[index - r] == str[index + r]) {
                            r++;
                        }
                        pArr[index] = r;
                        max = Math.max(max, r);
                    }
                } else { // 当前最右点可以包不住 index
                    // 3  4  5  6  7  8  9  10  11  12  13  14  15  16
                    //                              pR      i
    
                    // 一次也匹配不上时的半径也应当为1
                    r = 1;
                    while (index - r > -1 && index + r < n && str[index - r] == str[index + r]) {
                        r++;
                    }
                    pArr[index] = r;
                    max = Math.max(max, r);
                }
                // 更新 pR
                if (index + pArr[index] > pR) {
                    pR = index + pArr[index];
                    c = index;
                }
            }
            return max - 1;
        }
    
        /**
         * 扩展字符串，abba => #a#b#b#a#
         * <p>主要是可以将偶数个数的回文串转换为奇数个中心对称的回文串，方便统一处理
         */
        private static char[] manacherString(String s) {
            char[] chars = s.toCharArray();
            int n = (chars.length << 1) + 1;
            char[] ans = new char[n];
            int index = 0;
            for (int i = 0; i < n; i++) {
                ans[i] = (i & 1) == 0 ? '#' : chars[index++];
            }
            return ans;
        }
    
        /**
         * for test：暴力解，求解每一个位置的回文字符串的长度，时间复杂度O(n^2)
         */
        public static int right(String s) {
            if (s == null || s.isEmpty()) {
                return 0;
            }
            char[] str = manacherString(s);
            int max = 0;
            for (int i = 0; i < str.length; i++) {
                int l = i - 1;
                int r = i + 1;
                while (l >= 0 && r < str.length && str[l] == str[r]) {
                    l--;
                    r++;
                }
                max = Math.max(max, r - l - 1);
            }
            return max / 2;
        }
    
        /**
         * for test
         */
        public static String getRandomString(int possibilities, int size) {
            char[] ans = new char[(int) (Math.random() * size) + 1];
            for (int i = 0; i < ans.length; i++) {
                ans[i] = (char) ((int) (Math.random() * possibilities) + 'a');
            }
            return String.valueOf(ans);
        }
    
        private static void comp() {
            int possibilities = 25;
            int strSize = 20;
            int testTimes = 5000000;
            System.out.println("test begin");
            for (int i = 0; i < testTimes; i++) {
                String str = getRandomString(possibilities, strSize);
                int ans1 = manacher(str);
                int ans2 = manacher2(str);
                int ans3 = right(str);
                if (ans1 != ans2 || ans1 != ans3) {
                    System.out.println(str);
                    System.out.println(ans1);
                    System.out.println(ans2);
                    throw new RuntimeException("Oops!");
                }
            }
            System.out.println("test finish");
        }
    
    }

参考资料

https://www.bilibili.com/video/BV1YH4y1h7MU/

https://leetcode.cn/problems/longest-palindromic-substring/solutions/255195/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/

mpmt91
关注
专栏目录
大白话SVM算法课程
06-15
SVM之线性可分时损失函数的求解-对w,b变量求偏导09_SVM之线性可分时损失函数的求解-对β变量求解.10_SVM之线性可分时算法整体流程11_SVM之线性可分时案例12_SVM之线性不可分时软间隔介绍13_SVM之线性不可分时软间隔...
大白话XGBoost算法--彻底了解XGBoost
06-21
本文通过XGBoost的算法思想到XGBoost的目标函数转换，通过泰勒公式和叶节点的角度对XGBoost目标函数进行转换，然后通过树结构的生成策略去生成每一颗模型树，最后讲解于GBDT的算法区别以及相关参数。 目录如下： ...
Manacher算法的应用
桃夭丶的博客
01-27 198
Manacher算法是大家常用的，用来求回文串系列问题的算法 具体算法过程，我不多说，不知道的，可以看：Manacher算法详述 通过Manacher算法之后，我们会得到几个比较重要的信息： 首先，就是这个字符串有无回文子串，以及最长的回文子串的长度。 其次，就是以某一点为中心的回文半径，也就是 p 数组。 出题人比较喜欢在这个上面做文章 ...
Manacher算法及应用
qq_40428904的博客
07-28 270
问题：给定一个字符串str，返回str中最长回文子串的长度 暴力解法：比如给定 "aba"，遍历每个字符，首先来到 a，左右扩，左扩出界，记长度为1。然后来到 b，左右扩，左边的字符等于右边，长度加2，再扩出界，记长度为3。再来到 a，右扩出界，记为1。最长就为3。这种暴力扩法的时间复杂度为O(N^2) ! 注意当字符数量为偶数时，比如 "abba"，按照上述扩法是不能找出回文串的，故对原字符...
manacher算法（仅用于回文）——算法详解
风中的微尘的博客
10-01 323
算法简介：manacher算法是一个能够在线性时间内得到一个字符串中最长回文子串的算法，性能比其他的算法，如字符串哈希还要优秀，且不会被造数据卡住。是处理回文串最有效的工具。 算法分析： 1.首先有一个问题，那就是我们如何处理奇数回文串和偶数回文串这两种不同情况。我们可以采取如下处理方式： 假设存在一个字符串str:abbabba 将其转化为s：$#a#b#b#a#b#b#a#& 原则是首尾两个字符不同，和中间的字符也不同（防止出现访问越界），中间所有字符相同。 2.现在我们来观察一下 以我们
Manacher算法详细解析 （马拉车算法）
weixin_44134344的博客
02-05 1403
应用场景： 如求最长回文子串的题目，或者结合其他算法求解算法题目时可以用到。 求最长回文子串题目：给你一个字符串s，询问s最长回文子串的长度是多少？（如abaa的最长回文子串是aba，长度为3。) 结合其他算法的题目：有一道结合扩展kmp的算法题目如下Problem M. Mediocre String Problem（马拉车+拓展KMP)https://blog.csdn.net/weixin_44134344/article/details/1100...
大白话DC3算法
mp9105的博客
05-19 1184
DC3 算法入门
大白话讲解遗传算法
飘过的春风
04-21 3944
博客原文：cnblogs.com/heaad/archive/2010/12/23/1914725.html 　遗传算法 ( GA , Genetic Algorithm ) ，也称进化算法 。 遗传算法是受达尔文的进化论的启发，借鉴生物进化过程而提出的一种启发式搜索算法。因此在介绍遗传算法前有必要简单的介绍生物进化知识。 一.进化论知识  　　作为遗传算法生物背景的介绍，下
大白话讲解EM算法
Miracle.Zhao的博客
09-08 2392
001、一个非常简单的例子假设现在有两枚硬币1和2，,随机抛掷后正面朝上概率分别为P1，P2。为了估计这两个概率，做实验，每次取一枚硬币，连掷5下，记录下结果，如下： 硬币 结果 统计 1 正正反正反 3正-2反 2 反反正正反 2正-3反 1 正反反反反 1正-4反 2 正反反正正 3正-2反 1 反正正反反 2正-3反 可以很容易地估计出P1和P2，如下：P1 = （3+1+2）/ 15 = 0
大白话解析模拟退火算法
蚂蚁搬家
04-02 665
优化算法入门系列文章目录（更新中）： 　　1. 模拟退火算法 　　2. 遗传算法   一. 爬山算法 ( Hill Climbing )          介绍模拟退火前，先介绍爬山算法。爬山算法是一种简单的贪心搜索算法，该算法每次从当前解的临近解空间中选择一个最优解作为当前解，直到达到一个局部最优解。          爬山算法实现很简单，其主要缺点是会陷入局
大白话讲解BP算法
u013989587的博客
10-12 887
大白话讲解BP算法 https://blog.csdn.net/zhaomengszu/article/details/77834845
大白话EM算法--从此爱上EM迭代
06-19
1.1EM算法之回顾最大似然估计1.2EM算法之回顾贝叶斯估计1.3EM算法之回顾K-means算法1.4EM算法之算法目标引入1.5EM算法之目标函数转换--利用Jensen不等式1.6EM算法之目标函数求解--关于Q(z, θ)的表达1.7EM算法流程...
大白话GBDT算法-通俗理解GBDT原理
06-21
第一个模块通过预测年龄的直观案例理解GBDT算法流程。 第二个模块通过GBDT的三要素：GB(梯度提升)，DT(回归树)和Shrinkage(缩减)理解GBDT的算法核心。 第三个模块通过剖析分类和回归损失函数来讲解GBDT在分类和回归...
大白话解析模拟退火算法.pdf
01-09
模拟退火算法是一种启发式搜索策略，源自物理中的固体退火过程，用于解决优化问题，尤其是那些具有多个局部最优解的问题。它结合了贪婪算法的特点，即每次选择局部最优解，但通过引入随机性，避免陷入局部最优，有望...
189. 轮转数组（C++）
weixin_45813121的博客
09-25 438
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
Python实现Phong着色模型算法
qq_42568323的博客
09-24 1320
通过本文的介绍，我们详细阐述了Phong着色模型的基本原理，并使用Python实现了相关的算法。通过定义向量、光源、材质和着色器等类，我们可以灵活地计算光照和着色效果，为更复杂的三维图形渲染打下基础。Phong着色模型是计算机图形学中的经典光照模型，尽管随着技术的发展，出现了更复杂的光照模型（如Blinn-Phong、物理基础渲染等），但其简洁明了的特点仍然使其在许多应用中得以广泛使用。希望通过本次学习，读者能够深入理解Phong着色模型，并能够在实际项目中应用该算法。
完全二叉树和堆排序
最新发布
2301_80412275的博客
09-25 511
在满足第一个条件的前提下，最后一层的节点从左到右填充，没有空隙。
算法训练营打卡Day14
Zoe_igxgx的博客
09-25 236
题目1.226.翻转二叉树题目2.101. 对称二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值