Combinations

Problem

Given two integers n and k, return all possible combinations of k numbers chosen from the range [1, n].

You may return the answer in any order.

Example 1:

Input: n = 4, k = 2
Output: [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
Explanation: There are 4 choose 2 = 6 total combinations.
Note that combinations are unordered, i.e., [1,2] and [2,1] are considered to be the same combination.

Example 2:

Input: n = 1, k = 1
Output: [[1]]
Explanation: There is 1 choose 1 = 1 total combination.

Constraints:

  • 1 <= n <= 20
  • 1 <= k <= n

Solution

Another Backtracking

Time: O(n! / (n - k) * k!) Space: O(k)

This implementation is worse because I’m using a contains check to avoid duplicates. My prior approach was better since it used a separate variable. Alternatively, a set would also be okay, though it would require a set -> list conversion step.

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        var ans = new ArrayList<List<Integer>>();
        solve(n, k, List.of(), ans);
        return ans;
    }

    void solve(int n, int k, List<Integer> curr, List<List<Integer>> ans) {
        if (curr.size() == k) {
            ans.add(curr);
            return;
        }

        for (var i = 1; i <= n; i++) {
            if (curr.contains(i)) {
                continue;
            }
            var l = new ArrayList<>(curr);
            l.add(i);
            solve(i, k, l, ans);
        }
    }
}

Backtracking

Time: O(n! / (n - k)!) Space: O(n)

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        var ans = new ArrayList<List<Integer>>();
        solve(n, k, 1, List.of(), ans);
        return ans;
    }

    public void solve(int n, int k, int x, List<Integer> curr, List<List<Integer>> ans) {
        if (k == 0) {
            ans.add(curr);
            return;
        }

        // choose one from n
        for (var i = x; i <= n; i++) {
            var copy = new ArrayList<>(curr);
            copy.add(i);
            solve(n, k - 1, i + 1, copy, ans);
        }
    }
}

Recent posts from blogs that I like

Kimi K3, and what we can still learn from the pelican benchmark

via Simon Willison

Brushstrokes: Eugène Delacroix

Initially, he followed tradition, painting studies sketchily and finished work tight and with academic finish. He progressively presented more painterly works, becoming radical in his later years.

via The Eclectic Light Company

Notes on the Fourier Transform

The Fourier series is a great tool for analyzing periodic functions. But what about functions that don’t repeat? We’ve seen that we can compute Fourier series for a non-periodic function defined on a finite interval, as long as we don’t care about its behavior beyond that interval. Let’s extend this...

via Eli Bendersky