《编程之美: 求二叉树中节点的最大距离》的另一个解法

最新推荐文章于 2024-07-14 19:56:17 发布
最新推荐文章于 2024-07-14 19:56:17 发布
阅读量1.6k 收藏
点赞数
文章标签： 编程 2010 graph 算法 数据结构 null
 
12
0
(请您对文章做出评价)
Spiga

《编程之美: 求二叉树中节点的最大距离》的另一个解法

2010-02-25 03:32 by Milo Yip, 7408 visits, 收藏, 编辑

昨天花了一个晚上为《编程之美》，在豆瓣写了一篇书评《迟来的书评和感想──给喜爱编程的朋友》。书评就不转载到这里了，取而代之，在这里介绍书里其中一条问题的另一个解法。这个解法比较简短易读及降低了空间复杂度，或者可以说觉得比较「美」吧。

问题定义

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。写一个程序求一棵二叉树中相距最远的两个节点之间的距离。

书上的解法

书中对这个问题的分析是很清楚的，我尝试用自己的方式简短覆述。

计算一个二叉树的最大距离有两个情况:

  • 情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。
  • 情况B: 路径不穿过根节点，而是左子树或右子树的最大距离路径，取其大者。

只需要计算这两个情况的路径距离，并取其大者，就是该二叉树的最大距离。

我也想不到更好的分析方法。

但接着，原文的实现就不如上面的清楚 (源码可从这里下载):

view source print ?
01// 数据结构定义
02struct NODE
03{
04    NODE* pLeft;        // 左子树
05    NODE* pRight;       // 右子树
06    int nMaxLeft;       // 左子树中的最长距离
07    int nMaxRight;      // 右子树中的最长距离
08    char chValue;       // 该节点的值
09};
10  
11int nMaxLen = 0;
12  
13// 寻找树中最长的两段距离
14void FindMaxLen(NODE* pRoot)
15{
16    // 遍历到叶子节点，返回
17    if(pRoot == NULL)
18    {
19        return;
20    }
21  
22    // 如果左子树为空，那么该节点的左边最长距离为0
23    if(pRoot -> pLeft == NULL)
24    {
25        pRoot -> nMaxLeft = 0; 
26    }
27  
28    // 如果右子树为空，那么该节点的右边最长距离为0
29    if(pRoot -> pRight == NULL)
30    {
31        pRoot -> nMaxRight = 0;
32    }
33  
34    // 如果左子树不为空，递归寻找左子树最长距离
35    if(pRoot -> pLeft != NULL)
36    {
37        FindMaxLen(pRoot -> pLeft);
38    }
39  
40    // 如果右子树不为空，递归寻找右子树最长距离
41    if(pRoot -> pRight != NULL)
42    {
43        FindMaxLen(pRoot -> pRight);
44    }
45  
46    // 计算左子树最长节点距离
47    if(pRoot -> pLeft != NULL)
48    {
49        int nTempMax = 0;
50        if(pRoot -> pLeft -> nMaxLeft > pRoot -> pLeft -> nMaxRight)
51        {
52            nTempMax = pRoot -> pLeft -> nMaxLeft;
53        }
54        else
55        {
56            nTempMax = pRoot -> pLeft -> nMaxRight;
57        }
58        pRoot -> nMaxLeft = nTempMax + 1;
59    }
60  
61    // 计算右子树最长节点距离
62    if(pRoot -> pRight != NULL)
63    {
64        int nTempMax = 0;
65        if(pRoot -> pRight -> nMaxLeft > pRoot -> pRight -> nMaxRight)
66        {
67            nTempMax = pRoot -> pRight -> nMaxLeft;
68        }
69        else
70        {
71            nTempMax = pRoot -> pRight -> nMaxRight;
72        }
73        pRoot -> nMaxRight = nTempMax + 1;
74    }
75  
76    // 更新最长距离
77    if(pRoot -> nMaxLeft + pRoot -> nMaxRight > nMaxLen)
78    {
79        nMaxLen = pRoot -> nMaxLeft + pRoot -> nMaxRight;
80    }
81}

这段代码有几个缺点:

  1. 算法加入了侵入式(intrusive)的资料nMaxLeft, nMaxRight
  2. 使用了全局变量 nMaxLen。每次使用要额外初始化。而且就算是不同的独立资料，也不能在多个线程使用这个函数
  3. 逻辑比较复杂，也有许多 NULL 相关的条件测试。

我的尝试

我认为这个问题的核心是，情况A 及 B 需要不同的信息: A 需要子树的最大深度，B 需要子树的最大距离。只要函数能在一个节点同时计算及传回这两个信息，代码就可以很简单:

view source print ?
01#include <iostream>
02  
03using namespace std;
04  
05struct NODE
06{
07    NODE *pLeft;
08    NODE *pRight;
09};
10  
11struct RESULT
12{
13    int nMaxDistance;
14    int nMaxDepth;
15};
16  
17RESULT GetMaximumDistance(NODE* root)
18{
19    if (!root)
20    {
21        RESULT empty = { 0, -1 };   // trick: nMaxDepth is -1 and then caller will plus 1 to balance it as zero.
22        return empty;
23    }
24  
25    RESULT lhs = GetMaximumDistance(root->pLeft);
26    RESULT rhs = GetMaximumDistance(root->pRight);
27  
28    RESULT result;
29    result.nMaxDepth = max(lhs.nMaxDepth + 1, rhs.nMaxDepth + 1);
30    result.nMaxDistance = max(max(lhs.nMaxDistance, rhs.nMaxDistance), lhs.nMaxDepth + rhs.nMaxDepth + 2);
31    return result;
32}

计算 result 的代码很清楚；nMaxDepth 就是左子树和右子树的深度加1；nMaxDistance 则取 A 和 B 情况的最大值。

为了减少 NULL 的条件测试，进入函数时，如果节点为 NULL，会传回一个 empty 变量。比较奇怪的是 empty.nMaxDepth = -1，目的是让调用方 +1 后，把当前的不存在的 (NULL) 子树当成最大深度为 0。

除了提高了可读性，这个解法的另一个优点是减少了 O(节点数目) 大小的侵入式资料，而改为使用 O(树的最大深度) 大小的栈空间。这个设计使函数完全没有副作用(side effect)。

测试代码

以下也提供测试代码给读者参考 (页数是根据第7次印刷，节点是由上至下、左至右编号):

view source print ?
01void Link(NODE* nodes, int parent, int left, int right)
02{
03    if (left != -1)
04        nodes[parent].pLeft = &nodes[left]; 
05  
06    if (right != -1)
07        nodes[parent].pRight = &nodes[right];
08}
09  
10void main()
11{
12    // P. 241 Graph 3-12
13    NODE test1[9] = { 0 };
14    Link(test1, 0, 1, 2);
15    Link(test1, 1, 3, 4);
16    Link(test1, 2, 5, 6);
17    Link(test1, 3, 7, -1);
18    Link(test1, 5, -1, 8);
19    cout << "test1: " << GetMaximumDistance(&test1[0]).nMaxDistance << endl;
20  
21    // P. 242 Graph 3-13 left
22    NODE test2[4] = { 0 };
23    Link(test2, 0, 1, 2);
24    Link(test2, 1, 3, -1);
25    cout << "test2: " << GetMaximumDistance(&test2[0]).nMaxDistance << endl;
26  
27    // P. 242 Graph 3-13 right
28    NODE test3[9] = { 0 };
29    Link(test3, 0, -1, 1);
30    Link(test3, 1, 2, 3);
31    Link(test3, 2, 4, -1);
32    Link(test3, 3, 5, 6);
33    Link(test3, 4, 7, -1);
34    Link(test3, 5, -1, 8);
35    cout << "test3: " << GetMaximumDistance(&test3[0]).nMaxDistance << endl;
36  
37    // P. 242 Graph 3-14
38    // Same as Graph 3-2, not test
39  
40    // P. 243 Graph 3-15
41    NODE test4[9] = { 0 };
42    Link(test4, 0, 1, 2);
43    Link(test4, 1, 3, 4);
44    Link(test4, 3, 5, 6);
45    Link(test4, 5, 7, -1);
46    Link(test4, 6, -1, 8);
47    cout << "test4: " << GetMaximumDistance(&test4[0]).nMaxDistance << endl;
48}

你想到更好的解法吗?

« 博主前一篇： 混合语言的游戏开发系统架构
» 博主后一篇： 解构Unity的腳本物件模型
Add your comment

21 条回复

1929379
  1. #1楼 yeka      2010-02-25 06:30
    Milo又熬夜啦.......
    　 回复　 引用　 查看　   
  2. #2楼 陈硕      2010-02-25 08:56
    第 19~21 行有线程安全问题：

    static const RESULT empty = { 0, -1 }; // trick: nMaxDepth is -1 and then caller will plus 1 to balance it as zero.
    if (!root)
    return empty;

    建议改为：

    if (!root) {
    RESULT empty = { 0, -1 }; // trick: nMaxDepth is -1 and then caller will plus 1 to balance it as zero.
    return empty;
    // trust compiler, POD data will be optimized well.
    }

    因为按标准，function static variable 只在函数第一次调用时初始化，这个的初始化只有在最新的编译器里才是线程安全的。
    在旧的编译器（GCC 3 及以前）上，原来的写法可能会读到 partial initialized 'empty' 变量，如果两个线程同时（首次）调用 GetMaximumDistance 的话。
    　 回复　 引用　 查看　   
  3. #3楼 秋醒半梦时[未注册用户]2010-02-25 09:12
    这不就是求树的直径的问题吗？
    树的直径最简单的解法(无论是几叉)：
    从任意一点i一次BFS找到树中与他距离最远的点j，从j再一次BFS找到树中里j最远的点k,那么D[j][k](j与k的距离)即为答案。

    稍微好理解的方法：树形动态规划
    　 回复　 引用　   
  4. #4楼 Dbger      2010-02-25 10:07
    @陈硕
    如果非要考虑多线程安全，我倾向于用“全局变量”来表示这些常用的常量，就和向量，矩阵类中一些单元向量，单元矩阵等。
    　 回复　 引用　 查看　   
  5. #5楼 Jeffrey Zhao      2010-02-25 10:46
    我觉得直接把递归语意翻译过来最直接和清晰吧：
    view source print ?
    01type BinaryTree = 
    02| Node of BinaryTree * BinaryTree
    03| Empty
    04  
    05let rec height (tree: BinaryTree) = 
    06    match tree with
    07    | Empty -> 0
    08    | Node (l, r) -> 1 + max (height l) (height r)
    09  
    10let rec calculate (tree: BinaryTree) =
    11    match tree with
    12    | Empty -> 0
    13    | Node (l, r) ->
    14        (height l) + (height r)
    15        |> max (calculate l)
    16        |> max (calculate r)

    这里我用了F#，不过C#，C++其实也是一回事情吧。
    　 回复　 引用　 查看　   
  6. #6楼 Todd Wei      2010-02-25 12:11
    @秋醒半梦时
    进行两次BFS：先从树根A出发进行广度优先搜索(BFS)，找到最远的结点B，然后再从结点B出BFS，找到离B最远的结点C，BC就是最大距离。

    下面是正确性证明
    假设存在结点X和Y，它们的距离是所有结点中最大的；分两种情况讨论：
    1. 若路径XY与路径AB有交点O，
    ...A
    ...|
    X-O--Y
    ...|
    ...B
    由于|OB| >= |OX|且|OB| >= |OY|，所以，|BX| >= |XY|，|BY| >= |XY|。即从B出发可以构造出最长路径。

    2.若路径XY与路径AB无交点，
    A...B X...Y
    A是树根，XY与B分属不同的子树，假设XY的最近祖先为O，由于
    |AB| >= |AO| + |AX|，所以|BY| = |AB| + |AO| + |OY| > |XY|。即从B出发构造出长于XY的路径，与假设XY是最长路径矛盾。
    　 回复　 引用　 查看　   
  7. #7楼[楼主] Milo Yip      2010-02-25 12:19
    @Dbger
    @陈硕
    我覺得兩個方法都可以解決潛在的多線程問題。我現在先相信compiler，改用了陳碩的寫法。
    從另一個角度看這個問題，local static variable是會做成side effect，所以 thread-safe 會不成立。
    　 回复　 引用　 查看　   
  8. #8楼[楼主] Milo Yip      2010-02-25 12:40
    @Jeffrey Zhao
    我未學過任何一個 functional programming 語言。希望趙大能指正不對的地方。

    用 FP 的確可以增加可讀性，同時能減少錯誤的機會。

    FP 能對 pure function 用自動的 cache optimization，這是優點也是缺點。如果沒有這優化，在你提供的代碼中，height 的調用次數估計是 O(n^2)；而有了這優化，就需要O(n)的空間去儲存n 個 height()的運算結果。而這優化我估計應該需要做 table lookup，帶來額外 overhead。

    我的嘗試中，並不需要O(n)的額外空間，而且仍維持每節點只遍歷一次。

    又反過來說，在效能上，FP 的好處是可以自動做並行，用 procedural 語言手動做這個就會顯得複雜。
    　 回复　 引用　 查看　   
  9. #9楼[楼主] Milo Yip      2010-02-25 13:09
    @Todd Wei
    @秋醒半梦时
    多謝你們的回應，我方知道這個「距離」應該是叫「直徑」(Tree Diameter)。

    這該我找到一點參考文章:
    http://www.cs.duke.edu/courses/spring00/cps100/assign/trees/diameter.html
    http://www.cs.cmu.edu/afs/cs.cmu.edu/project/phrensy/pub/papers/LeisersonM88/node17.html

    發現前一篇文章基本上和Jeffrey的嘗試一樣，但用 procedural programming 會有O(N^2)的 height() 調用。我覺得我寫的邊界條件(那個trick)可能不需要，今晚回家試試。

    第二篇談到的幾個詞彙我都不太認識，可能要再多看一些參考。也想請教，用 BFS 的方法會比現時的方法簡單或高效麼? 還是現時的方法實際上有錯誤?
    　 回复　 引用　 查看　   
  10. #10楼 Todd Wei      2010-02-25 13:20
    @Milo Yip
    BFS是O(N)的，所以复杂度更低。特别是基于BFS的方法不局限于2叉树，而前面递归方法在多叉树情况下复杂度会更高。
    　 回复　 引用　 查看　   
  11. #11楼 Jeffrey Zhao      2010-02-25 13:23
    @Milo Yip
    其实你的算法还是用了O(h)的空间啦，h是高度，（非尾）递归算法嘛，栈空间是省不了的。
    的确这里height会反复调用，所以如果必要的话，还是要做memorization的。
    作了momorization以后，时间和空间“复杂度”和你的过程式算法是一致的了。
    　 回复　 引用　 查看　   
  12. #12楼[楼主] Milo Yip      2010-02-25 13:31
    @Jeffrey Zhao
    引用 Jeffrey Zhao：
    @Milo Yip
    其实你的算法还是用了O(h)的空间啦，h是高度，（非尾）递归算法嘛，栈空间是省不了的。
    的确这里height会反复调用，所以如果必要的话，还是要做memorization的。
    作了momorization以后，时间和空间“复杂度”和你的过程式算法是一致的了。

    本文也提及，我的嘗試用了O(h)的棧空間代替原文的O(n) intrusive data，而你寫的height函數的memorization空間是O(n)。因為 h <= n，O(h)應該是比 O(n)好吧。
    　 回复　 引用　 查看　   
  13. #13楼[楼主] Milo Yip      2010-02-25 13:36
    引用Todd Wei：
    @Milo Yip
    BFS是O(N)的，所以复杂度更低。特别是基于BFS的方法不局限于2叉树，而前面递归方法在多叉树情况下复杂度会更高。

    我的嘗試也是O(N)，而且只需遍歷一次。跟據你的描述，BFS要做兩次，而且要加入parent? 不過對於一般的多叉樹，可能BFS的方法是最好的方法。
    　 回复　 引用　 查看　   
  14. #14楼 Todd Wei      2010-02-25 15:09
    @Milo Yip
    哦，是的，你的递归也是O(N)，开始分析错了。

    树哪个结点作为parent没关系，任选即可。图论里面对树的一种定义方式是：具有n个结点和n+1条边的连通图。
    　 回复　 引用　 查看　   
  15. #15楼 郑晖      2010-02-25 16:06
    @Milo Yip
    >>我方知道這個「距離」應該是叫「直徑」(Tree Diameter)。
    的确是“直径”——在数学中直径的定义是：一个距离空间中任意两点间距离的上确界(supremum)。
    　 回复　 引用　 查看　   
  16. #16楼 秋醒半梦时[未注册用户]2010-02-25 17:03
    引用Todd Wei：
    @Milo Yip
    哦，是的，你的递归也是O(N)，开始分析错了。

    树哪个结点作为parent没关系，任选即可。图论里面对树的一种定义方式是：具有n个结点和n+1条边的连通图。


    我所了解的树的定义是：一个无环的无向图
    　 回复　 引用　   
  17. #17楼[楼主] Milo Yip      2010-02-25 17:04
    @郑晖
    引用 郑晖：
    @Milo Yip
    >>我方知道這個「距離」應該是叫「直徑」(Tree Diameter)。
    的确是“直径”——在数学中直径的定义是：一个距离空间中任意两点间距离的上确界(supremum)。

    謝謝鄭老師的數學指導。在網上找到了關於這個的定義:

    http://mathworld.wolfram.com/GeneralizedDiameter.html
    http://mathworld.wolfram.com/Supremum.html
    　 回复　 引用　 查看　   
  18. #18楼 郑晖      2010-02-25 17:17
    引用Milo Yip：
    引用郑晖：
    @Milo Yip
    >>我方知道這個「距離」應該是叫「直徑」(Tree Diameter)。
    的确是“直径”——在数学中直径的定义是：一个距离空间中任意两点间距离的上确界(supremum)。

    謝謝鄭老師的數學指導。在網上找到了關於這個的定義:

    http://mathworld.wolfram.com/GeneralizedDiameter.html
    http://mathworld.wolfram.com/Supremum.html


    http://mathworld.wolfram.com/GeneralizedDiameter.html
    上面对的直径定义尚不足够general，它只提到了欧氏空间（Euclidean space R^n ），
    实际可扩展到更广泛的距离空间（metric space）。事实上，你这里提到的树就不是欧氏空间（因为这里的距离并非欧氏距离）。
    　 回复　 引用　 查看　   
  19. #19楼[楼主] Milo Yip      2010-02-25 17:27
    @郑晖
    是的，我理解只要是 metric 就可以定義 diameter。
    　 回复　 引用　 查看　   
  20. #20楼 flyinghearts      2010-05-19 14:05
    这是我的解法：
    http://blog.csdn.net/flyinghearts/archive/2010/05/19/5605995.aspx

    欢迎大家指正。
    　 回复　 引用　 查看　   
  21. #21楼 gzroy      2010-10-06 18:24
    这是我的递归解法，欢迎交流：
    http://blog.csdn.net/yui/archive/2010/10/06/5924020.aspx
    　 回复　 引用　 查看　   
slmmlk2011_2
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
编程之美：求二叉树中节点的最大距离
ben1010101010的博客
04-13 315
1.问题描述 写一个程序求一棵二叉树相距最远的两个节点之间的距离 如下图： 2.分析与解法 对于任意一个节点，以该节点为根，假设这个根有k个孩子节点，那么距离最远的两个节点U与V之间的路径与这个根节点的关系有两种。 1)若路径经过Root，则U和V是属于不同子树的，且它们都是该子树中到根节点最远的节点，否则跟它们的距离最远相矛盾 2)如果路径不经过Root，那么它们一定属于根的...
剑指Offer(Python多种思路实现):重建二叉树
12-23
在递归解法中，首先我们需要创建一个`TreeNode`类来表示二叉树的节点，包含节点值、左子节点和右子节点： ```python class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None...
《编程之美: 求二叉树中节点的最大距离》的另一个解法（觉得比书上的好）
hysfwjr的专栏
05-24 658
《编程之美: 求二叉树中节点的最大距离》的另一个解法 问题定义 如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。写一个程序求一棵二叉树中相距最远的两个节点之间的距离。 书上的解法 书中对这个问题的分析是很清楚的，我尝试用自己的方式简短覆述。 计算一个二叉树的最大距离有两个情况: 情况A: 路径经过左子树的最深节点，通
c语言编程之美输入二叉树,《编程之美: 求二叉树中节点的最大距离》的另一个解法...
weixin_32297123的博客
05-22 104
昨天花了一个晚上为《编程之美》，在豆瓣写了一篇书评《迟来的书评和感想──给喜爱编程的朋友》。书评就不转载到这里了，取而代之，在这里介绍书里其中一条问题的另一个解法。这个解法比较简短易读及降低了空间复杂度，或者可以说觉得比较「美」吧。问题定义如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。写一个程序求一棵二叉树中相距最远的两个节点之间的距离。书上...
编程之美: 求二叉树中节点的最大距离
知之可否
06-16 2203
问题定义 如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。写一个程序求一棵二叉树中相距最远的两个节点之间的距离。 书上的解法 书中对这个问题的分析是很清楚的，我尝试用自己的方式简短覆述。 计算一个二叉树的最大距离有两个情况: 情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。情况B: 路
[转载]《编程之美: 求二叉树中节点的最大距离》的另一个解法
weixin_34026484的博客
03-15 54
本文提出的解法比原书清晰的多，全文转载一下。 原作者：Milo Yip 原文链接：http://www.cnblogs.com/miloyip/archive/2010/02/25/binary_tree_distance.html 昨天花了一个晚上为《编程之美》，在豆瓣写了一篇书评《迟来的书评和感想──给喜爱编程的朋友》。书评就不转载到这里了，取...
【数据结构与算法】《编程之美: 求二叉树中节点的最大距离》的另一个解法
09-24 71
昨天花了一个晚上为《编程之美》，在豆瓣写了一篇书评《迟来的书评和感想──给喜爱编程的朋友》。书评就不转载到这里了，取而代之，在这里介绍书里其中一条问题的另一个解法。这个解法比较简短易读及降低了空间复杂度，或者可以说觉得比较「美」吧。 问题定义 如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。写一个程序求一棵二叉树中相距最远的两个节点
编程之美: 求二叉树中节点的最大距离》的好解法
xiang_ma的专栏
05-09 872
转自 ：http://aclay.blog.163.com/blog/static/208468235201272392954636/ 昨天花了一个晚上为《编程之美》，在豆瓣写了一篇书评《迟来的书评和感想──给喜爱编程的朋友》。书评就不转载到这里了，取而代之，在这里介绍书里其中一条问题的另一个解法。这个解法比较简短易读及降低了空间复杂度，或者可以说觉得比较「美」吧。 问题定义
《编程之美: 求二叉树中节点的最大距离》
ly969434341的专栏
04-19 333
1.二叉树中节点的最大距离（树的最长路径）——递归解法： http://blog.csdn.net/hgqqtql/article/details/39795321 2.
python-leetcode面试题解之第124题二叉树中的最大路径和-题解.zip
05-06
在这个代码中，`TreeNode`是二叉树节点的定义，包含节点值、左子节点和右子节点。`maxPathSum`函数计算最大路径和，它使用了一个全局变量`global_max`来记录全局的最大路径和，以及一个内部的`dfs`函数进行深度优先...
leetcode卡-leetcode-binary-tree-card:LeetCode二叉树卡片问题的章节智解
07-06
比如，你可以遇到这样的问题：给定一组二叉树卡片，每张卡片代表一个二叉树节点，你需要根据这些卡片重建原始的二叉树。这需要对二叉树的性质有深入理解，如如何通过遍历序列恢复二叉树，或者利用递归和迭代的方式来...
【Python学习-二叉树-递归】【剑指offer】之重建二叉树
12-21
在Python中，可以创建一个`TreeNode`类表示二叉树的节点，然后定义一个`reConstructBinaryTree`方法来处理重建过程。以下是相应的代码实现： ```python class TreeNode: def __init__(self, x): self.val = x ...
python-leetcode面试题解之第129题求根节点到叶节点数字之和-题解.zip
05-07
在本压缩包中，我们关注的是一个与Python编程和LeetCode面试相关的题目，具体是第129题——"Sum Root to Leaf Numbers"（根到叶节点数字之和）。这是一道典型的树形结构问题，涉及到二叉树的遍历。在LeetCode上，...
36. Adam 算法详解
qq_41238579的博客
07-10 946
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 58
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 181
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 60
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
高频算法题目总结1
08-04
"这是一个关于Java算法的总结，涵盖了链表操作、二叉树遍历、缓存设计、数组问题、字符串处理等多种算法题目。" 这篇总结涉及了多个计算机科学中的经典算法题目，主要集中在数据结构（如链表、数组、二叉树）和算法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值