LintCode 1098 · Path Sum IV (二叉树遍历好题)

最新推荐文章于 2024-10-01 05:04:32 发布

纸上得来终觉浅绝知此事要躬行

最新推荐文章于 2024-10-01 05:04:32 发布

阅读量430

点赞数 6

分类专栏： algorithm-design 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/roufoo/article/details/135565100

版权

algorithm-design 专栏收录该内容

817 篇文章 4 订阅

订阅专栏

这篇文章介绍了一种解决给定表示深度小于5的二叉树的三数字列表，计算从根到所有叶节点路径和的算法。通过遍历和递归，利用unordered_map存储节点值和代码，计算路径总和。

摘要由CSDN通过智能技术生成

1098 · Path Sum IV
Algorithms
Medium

Description
If the depth of a tree is smaller than 5, then this tree can be represented by a list of three-digits integers.

For each integer in this list:

1.The hundreds digit represents the depth D of this node, 1 <= D <= 4.
2.The tens digit represents the position P of this node in the level it belongs to, 1 <= P <= 8. The position is the same as that in a full binary tree.
3.The units digit represents the value V of this node, 0 <= V <= 9.

Given a list of ascending three-digits integers representing a binary tree with the depth smaller than 5, you need to return the sum of all paths from the root towards the leaves.

Example
Example 1:

Input: [113, 215, 221]
Output: 12
Explanation:
The tree that the list represents is:
3
/
5 1

The path sum is (3 + 5) + (3 + 1) = 12.
Example 2:

Input: [113, 221]
Output: 4
Explanation:
The tree that the list represents is:
3

1

The path sum is (3 + 1) = 4.

解法1：遍历即可。注意把num分为code和value两部分。code又可以分为layer和pos两部分。

class Solution {
public:
    /**
     * @param nums: the list
     * @return: the sum of all paths from the root towards the leaves
     */
    int pathSumIV(vector<int> &nums) {
        int n = nums.size();
        for (auto num : nums) {
            int value = num % 10;
            int code = num / 10;
            um[code] = value;
        }
        helper(11, 0);
        return totalPathSum;
    }
private:
    unordered_map<int, int> um; //<code, value>, e.g, 113=><11, 3>
    int totalPathSum = 0;
    void helper(int code, int pathSum) {
        if (um.find(code) == um.end()) return;
        pathSum += um[code];
        int pos = code % 10;
        int layer = code / 10;

        int leftPos = pos * 2 - 1, leftCode = (layer + 1) * 10 + leftPos;
        int rightPos = pos * 2, rightCode = (layer + 1) * 10 + rightPos;

        if (um.find(leftCode) == um.end() && um.find(rightCode) == um.end()) { //叶子节点
            totalPathSum += pathSum;
            return;
        }
        helper(leftCode, pathSum);
        helper(rightCode, pathSum);
    }
};