leetcode——Combinations

刚开始的思路是 一个大小是K的数组，最开始的值是（比如k=4）1 2 3 4，然后最末尾递增到n，然后倒数第二位再开始...可以用for循环，但是有k个嵌套for循环，不知道该怎么实现。还是用了最笨的方法：

void ComBT(int n, int i, int k, int *flag, int** ret, int *returnSize,int *column){
	if (i == n)
	{
		int j, count = 0;
		for (j = 0; j<n; j++)
		{
			if (flag[j] == 1)
			{
				count++;
			}
		}
		if (count == k)
		{
			count = 0;
			int *col = (int*)malloc(k*sizeof(int));
			for (j = 0; j<n; j++)
			{
				if (flag[j] == 1)
				{
					col[count++] = j+1;
				}
			}
			column[*returnSize] = k;
			ret[*returnSize] = col;
			(*returnSize)++;
		}
		return;
	}
	flag[i] = 1; ComBT(n, i + 1, k, flag, ret, returnSize,column);
	flag[i] = 0; ComBT(n, i + 1, k, flag, ret, returnSize,column);
}
int** combine(int n, int k, int** columnSizes, int* returnSize) {
	int size = n;
	for (int i = n - 1; i> n - k && i > n/2; i--)
	{
		size *= i;
	}
	*returnSize = 0;
	int **ret = (int**)malloc(size*sizeof(int*));
	int *column = (int*)malloc(size*sizeof(int));
	*columnSizes = column;
	int *flag = (int*)calloc(n, sizeof(int));
	ComBT(n, 0, k, flag, ret, returnSize,column);
	return ret;
}

发生的错误：

① column的值全都为k，想用memset，原来memset是对每一个字节置位

②ret的大小，以前有不明确大小的试过realloc，但是当空余的空间不够时会重新开辟一个空间，把数据放进去，这对递归来说是不可行的，，这道题的大小可能引起overflow，测试用例最大为n=26

③判断太冗余了，可以加个计数改进一下

找到了我的思路的实现：（转自：http://www.cnblogs.com/kaituorensheng/p/3706360.html）

vector< vector<int> > ret;
vector<int> a;

void build(int dep, int maxDep, int n, int start)
{
    if (dep == maxDep)
    {
        ret.push_back(a);
        return;
    }

    for (int i = start; i <= n; ++i)
    {
        a[dep] = i;
        build(dep + 1, maxDep, n, i + 1);
    }
}

vector< vector<int> > combine(int n, int k)
{
    a.resize(k);
    ret.clear();
    build(0, k, n, 1);
    return ret;
}

非常漂亮！

也可以不用for循环：

转自：http://blog.csdn.net/sunbaigui/article/details/8980735

class Solution {  
//using recurrence to get these combinations  
public:  
    vector<vector<int> > combine(int n, int k) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function  
        vector<int> temp;  
        vector<vector<int> > ans;  
        combine_rec(ans , temp , n , k , 1);  
        return ans;  
  
    }  
    void combine_rec(vector<vector<int> > &ans , vector<int>& temp , int n , int k , int index)   
    {  
  
        if (k == 0)  
            ans.push_back(temp);  
  
        else if (k > 0 && index <= n)  
        {  
            temp.push_back(index);  
            combine_rec(ans , temp , n , k-1 , index+1);  
  
            temp.pop_back();  
            combine_rec(ans , temp , n , k , index+1);  
        }  
    }  
};