leetcode 823. 带因子的二叉树

每日一题，2023.8.29

给出一个含有不重复整数元素的数组 arr ，每个整数 arr[i] 均大于 1。

用这些整数来构建二叉树，每个整数可以使用任意次数。其中：每个非叶结点的值应等于它的两个子结点的值的乘积。

满足条件的二叉树一共有多少个？答案可能很大，返回 对 109 + 7 取余 的结果。

示例 1:

输入: arr = [2, 4]
输出: 3
解释: 可以得到这些二叉树: [2], [4], [4, 2, 2]

示例 2:

输入: arr = [2, 4, 5, 10]
输出: 7
解释: 可以得到这些二叉树: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].

提示：

• 1 <= arr.length <= 1000
• 2 <= arr[i] <= 109
• arr 中的所有值 互不相同

代码如下：详细注释和详细代码中有描述

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

class Solution {
public:
    int numFactoredBinaryTrees(vector<int>& arr) {
        long long int rus = 0;
        vector<long long int> nums;
        sort(arr.begin(), arr.end());
        int i, j, k;
        for (i = 0; i < arr.size(); i++)
        {
            nums.push_back(1);//任何一个数至少有他本身一个子树
            for (j = 0; j < i; j++)
            {
                if (arr[j] > 100000 || arr[j] * arr[j] > arr[i])
                //后续不会出现新的未考虑的因子,重点：1.不能直接比较大小，乘积超过int不能置于比较符号两侧。2.范围要在10**6的位置，10**5不能保证，不知道为啥
                {
                    break;
                }
                if (arr[i] % arr[j] != 0)
                    continue;
                else
                {
                    bool flag = false;
                    long int t = arr[i] / arr[j];
                    for (k = j; k < i; k++)//k从j开始，可以节约运算时间（可以利用双指针规避）
                    {
                        if (arr[k] == t)
                        {
                            flag = true;
                            break;
                        }
                        else
                        {
                            if (arr[k] > t)
                            {
                                flag = false;
                                break;
                            }
                        }
                    }
                    if (flag)
                    {
                        if (k == j)
                        {
                            nums[i] += nums[j] * nums[j];
                        }
                        else
                        {
                            nums[i] += nums[j] * nums[k] * 2;
                        }

//动态规划思想
                    }
                }
            }
            nums[i] = nums[i] % 1000000007;
        }
        for (int i = 0; i < nums.size(); i++)
        {
            rus += nums[i];
            rus = rus % 1000000007;
        }
        return rus;
    }
};