[LeetCode] Combinations

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

For example,
If n = 4 and k = 2, a solution is:

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

Hide Tags

 Backtracking

 

思路：DFS，类似于backtrace

class Solution {
    vector<vector<int> > m_res;
    vector<int>  m_array;
    public:
        void dfs(int n, int k, int start)
        {   
            if(k == m_array.size())
            {   
                m_res.push_back(m_array);
                return;
            }   
            for(int i = start; i <= n; i++)
            {   
                m_array.push_back(i);
                dfs(n, k, i + 1); 
                m_array.pop_back();
            }   

        }   

        vector<vector<int> > combine(int n, int k)
        {   
            dfs(n, k, 1); 
            return m_res;
        }   
};

思路2：子集树的标准写法略加变形，更好理解的dfs其实是这样：

class Solution {
    vector<vector<int> > m_res;
    vector<int>  m_array;
    public:
        void dfs(int n, int k, int dep)
        {   
            if(k == m_array.size())
            {   
                m_res.push_back(m_array);
                return;
            }   

            if(dep > n)
                return;

            for(int i = 0; i< 2 ;i++)
            {   
                if(i == 0)
                {   
                    m_array.push_back(dep);
                    dfs(n, k, dep+ 1); 
                    m_array.pop_back();
                }   
                else
                {   
                    dfs(n, k, dep+1);
                }   
            }   

        }   

        vector<vector<int> > combine(int n, int k)
        {   
            dfs(n, k, 1); 
            return m_res;
        }
};

 思路3：对思路2中包含不包含做一下精简：

class Solution {
    vector<vector<int> > m_res;
    vector<int>  m_array;
    public:
        void dfs(int n, int k, int dep)
        {   
            if(k == m_array.size())
            {   
                m_res.push_back(m_array);
                return;
            }   

            if(dep > n)
                return;

            // contain the element
            m_array.push_back(dep);
            dfs(n, k, dep+ 1);
            m_array.pop_back();

            // don't contain the element
            dfs(n, k, dep+1); 
              

        }   

        vector<vector<int> > combine(int n, int k)
        {   
            dfs(n, k, 1); 
            return m_res;
        }
};