LeetCode-DFS

原创已于 2022-03-09 19:46:23 修改 · 381 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#深度优先 #leetcode #算法 #dfs

于 2022-02-28 22:56:29 首次发布

LeetCode 专栏收录该内容

7 篇文章

订阅专栏

本文探讨了如何使用深度优先搜索(DFS)解决LeetCode中的问题，即找到数组中加起来和为目标值的组合。文章介绍了两种方法，一种是DFS策略，另一种是动态规划。内容涉及如何计算有序对的数量，并且强调了解集中元素可以重复使用，顺序不同视为不同组合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

加起来和为目标值的组合：

给定一个由不同整数构成的数组 nums 和一个整数 target ，请你从 nums 找出总和是 target 的组合的个数。解集中可以重复使用 nums 中的元素。且解集中数字顺序不同视为不同的组合。

解法一、DFS

out=0
class Solution:
    def combination(self , nums , target ):
        nums.sort()
        numlen=len(nums)
        def dfs(t):
            global out
            if sum(t) > target:
                return
            if sum(t) == target:
                out=out+1
                return
            for num in nums:
                dfs(t + [num])
        dfs([]) 
        return out

解法二、动态规划

    def combination(self , nums , target ):
        dp = [0 for _ in range(target+1)]
        dp[0] = 1
        for j in range(target+1):
            for i in range(len(nums)):
                if j-nums[i]>=0:
                    dp[j]=dp[j]+dp[j-nums[i]]
        return dp[-1]

一、数组中

1.从1到n的n个数，顺序对的数量是 k，（顺序对是指满足 i < j 且 A[i] < A[j] 的对数），其中有m个位置未知，请返回所有的个数。

void dfs(List<Integer> pos, int index, int count, int base, int k, int n) {

    if (index == count) {

        if (base == k) res++;

    } else {

        int position = pos.get(index);  // 此时要插入的位置

        for (int i = 0; i < count; i++) {

            if (seen[i]) continue


            seen[i] = true;

            nums[position] = cands[i];

            int amount = 0;

            for (int j = 0; j < position; j++)

                if (nums[j] < cands[i]) amount++;

            for (int j = position+1; j < n; j++)

                if (cands[i] < nums[j]) amount++;

            dfs(pos, index+1, count, base+amount, k, n);

            nums[position] = 0;

            seen[i] = false;

        }

    }

}