logseq_notes/pages/OJ notes/pages/Leetcode Combinations.md

Leetcode Combinations

2022-07-19 20:09

Algorithms:

#algorithm #backtrack

Difficulty:

#coding_problems #difficulty_medium

Additional tags:

#leetcode #CS_list_need_understanding

Revisions:

2022-09-21

Related topics:

Links:

• Link to problem

• Explanation

  ---

Problem

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

You may return the answer in any order.

Examples

Example 1:

**Input:** n = 4, k = 2
**Output:**
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

Example 2:

**Input:** n = 1, k = 1
**Output:** [[1]]

Constraints

Constraints:

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

Thoughts

[!summary] This is a #backtrack problem

The link I mentioned on the links section already have a good explanation on the topic.

In my eyes, backtracking means DFS-like recursion and searching in solving problems.

First, it add a option in the combinations, then backtrack it And when it's done, it gets poped out and try another solution, and backtrack.

Solution

Backtracking

class Solution {
void backtrack(vector<vector<int>> &ans, vector<int> &combs, int n, int nex,
               int k) {
  if (k == 0) {
    ans.push_back(combs);
  } else {
    // try different solutions
    for (int i = nex; i <= n; i++) {
      combs.push_back(i);

      backtrack(ans, combs, n, i + 1, k - 1);

      combs.pop_back();
    }
  }
}

public:
vector<vector<int>> combine(int n, int k) {
  vector<vector<int>> ans = {};
  vector<int> combs = {};

  backtrack(ans, combs, n, 1, k);

  return ans;
}
};

Alternative solution using private values

class Solution {
vector<vector<int>> ans;
vector<int> combs = {};
int N, K;
void backtrack(int cur) {
  if (combs.size() == K) {
    // we reached the end, should push to the answer array
    ans.push_back(combs);
    return;
  } else if (cur <= N) {
    combs.push_back(cur);
    backtrack(cur + 1);

    combs.pop_back();
    backtrack(cur + 1);
  }
}

public:
vector<vector<int>> combine(int n, int k) {
  N = n;
  K = k;
  backtrack(1);

  return ans;
}
};