Leetcode 254. Factor Combinations

原创于 2021-01-20 08:31:31 发布 · 160 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#backtracking #recursion #dfs

Leetcode 专栏收录该内容

278 篇文章

订阅专栏

这篇博客探讨了两种方法来找到一个整数的所有因子，方法1基于回溯，时间复杂度为O(n^logn)，而方法2通过优化将时间复杂度降低到O(sqrt(n)^logn)。博主详细分析了算法的实现和优化过程。

在这里插入图片描述
方法1: 这题其实和39题差不多，39是sum，这题是乘积。时间复杂O(n^logn)，空间复杂logn。时间复杂度分析如下：

class Solution {
    public List<List<Integer>> getFactors(int n) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        dfs(n, 2, path, res);
        return res;
    }
    
    public void dfs(int n, int start, List<Integer> path, List<List<Integer>> res){
        if(n == 1) {
            if(path.size() > 1) res.add(new ArrayList<>(path));
            return;
        }
        for(int i = start; i <= n; i++){
            if(n % i != 0) continue;
            path.add(i);
            dfs(n/i, i, path, res);
            path.remove(path.size()-1);
        }
    }
}

方法2: 方法1的小优化。时间复杂度变为O(sqrt(n)^logn)。

class Solution {
    public List<List<Integer>> getFactors(int n) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        dfs(n, 2, path, res);
        return res;
    }
    
    public void dfs(int n, int start, List<Integer> path, List<List<Integer>> res){
        for(int i = start; i * i<= n; i++){
            if(n % i != 0) continue;
            path.add(i);
            path.add(n / i);
            res.add(new ArrayList<>(path));
            path.remove(path.size()-1);
            dfs(n/i, i, path, res);
            path.remove(path.size()-1);
        }
    }
}