leetcode

Author: ayoubzulfiqar

Diff for: CombinationSumIV/combination_sum_iv.dart

@@ -0,0 +1,59 @@
+/*
+
+-* 377. Combination Sum IV *-
+
+Given an array of distinct integers nums and a target integer target, return the number of possible combinations that add up to target.
+
+The test cases are generated so that the answer can fit in a 32-bit integer.
+
+ 
+
+Example 1:
+
+Input: nums = [1,2,3], target = 4
+Output: 7
+Explanation:
+The possible combination ways are:
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
+Note that different sequences are counted as different combinations.
+Example 2:
+
+Input: nums = [9], target = 3
+Output: 0
+ 
+
+Constraints:
+
+1 <= nums.length <= 200
+1 <= nums[i] <= 1000
+All the elements of nums are unique.
+1 <= target <= 1000
+ 
+
+Follow up: What if negative numbers are allowed in the given array? How does it change the problem? What limitation we need to add to the question to allow negative numbers?
+
+
+*/
+
+class Solution {
+  int combinationSum4(List<int> nums, int target) {
+    final List<int> dp = List.filled(nums.length, target + 1);
+    dp[0] = 1;
+
+    for (int i = 1; i <= target; i++) {
+      for (int number in nums) {
+        if (i - number >= 0) {
+          dp[i] += dp[i - number];
+        }
+      }
+    }
+
+    return dp[target];
+  }
+}

Diff for: CombinationSumIV/combination_sum_iv.go

@@ -0,0 +1,32 @@
+package main
+
+import "sort"
+
+func helper(nums []int, n int, memo map[int]int) int {
+	if val, found := memo[n]; found {
+		return val
+	}
+	if n == 0 {
+		return 1
+	}
+	if n < nums[0] {
+		return 0
+	}
+
+	count := 0
+	for _, num := range nums {
+		if n-num < 0 {
+			break
+		}
+		count += helper(nums, n-num, memo)
+	}
+
+	memo[n] = count
+	return count
+}
+
+func combinationSum4(nums []int, target int) int {
+	sort.Ints(nums)
+	memo := make(map[int]int)
+	return helper(nums, target, memo)
+}

Diff for: CombinationSumIV/combination_sum_iv.md

@@ -0,0 +1,31 @@
+#
+
+This code is a Go implementation of a dynamic programming approach to solve the "Combination Sum IV" problem. The problem statement is to count the number of possible combinations of the given `nums` array that add up to a specific `target` value. Combinations are counted without considering the order of elements in the combination.
+
+Here's a step-by-step explanation of the code:
+
+1. Import the "sort" package, which is used later to sort the `nums` array.
+2. Define a helper function called `helper`. This function takes three parameters: `nums` (the input array of numbers), `n` (the target value to reach), and `memo` (a memoization map to store computed results for subproblems).
+
+3. Check if the result for the current target `n` is already computed and stored in the `memo` map. If so, return the stored value to avoid redundant calculations.
+
+4. If `n` equals 0, it means a valid combination is found, so return 1 to count it.
+
+5. If `n` is less than the smallest number in the `nums` array, return 0, as it's impossible to form the target value with the given numbers.
+
+6. Initialize a `count` variable to 0, which will be used to count the valid combinations.
+
+7. Iterate through the `nums` array, and for each number `num`, recursively call the `helper` function with the updated target `n - num`. Add the result to the `count` variable. This step calculates the number of combinations that include the current number.
+
+8. Store the `count` in the `memo` map for the current `n` to avoid recomputation.
+
+9. Return the final `count` as the result.
+
+10. Define the `combinationSum4` function, which is the entry point for solving the problem. Inside this function:
+    - Sort the `nums` array in ascending order to optimize the algorithm.
+    - Create an empty memoization map `memo`.
+    - Call the `helper` function with `nums`, `target`, and `memo` as arguments and return the result.
+
+The time complexity of this solution depends on the input values. In the worst case, it can be exponential, but memoization is used to store previously computed results, which can significantly reduce redundant calculations. Therefore, the average time complexity is much better than the worst case, and it can be considered O(N * T), where N is the length of the `nums` array, and T is the target value.
+
+The space complexity is O(T), where T is the target value, due to the space required for the `memo` map.

Diff for: FindCriticalAndPseudoCriticalEdgesInMinimumSpanningTree/find_critical_and_pseudocritical_edges_in_minimum_spanning_tree.dart

@@ -144,8 +144,8 @@ class Solution {
       final List<bool> mstEdgeSet,
       final List<List<int>> minimumSpanningTree,
       final List<List<List<int>>> graph) {
-    int weight = 0;
     final DisjointSet ds = DisjointSet(n);
+    int weight=0;
 
     for (int i = 0; i < edges.length; i++) {
       if (ds.union(edges[i][0], edges[i][1])) {