Question

嗨，大家好我已经坚持了一段时间了 - 这是 -

问题---给定一个大小为n的数组，找到并返回此的所有子集 array ....递归地执行此操作

我的方法 - 考虑一个大小为3的数组 - {10,11,12}。考虑第一个元素 - 我有2个选项要么不接受它。所以我为第一个元素工作，然后让其他人重复。

int helper(int in[],int si,int n,int output[][20]){
                       //si - starting index , n  - size
  if(si == n){
    output[0][0] = 0;        //using 0 for null
    return 1;               //helper returns the number of subsets of array 
  }

  int smallSize = helper(in,si+1,n,output);
  for(int i =0;i<smallSize;i++){
    output[i+smallSize][0] = in[si];        
    for(int k = 0;k<4;k++){
      output[i+smallSize][k+1] = output[i][k];
    }
  }
  return smallSize*2;
}

int subset(int input[], int n, int output[][20]) {
  return helper(input,0,n,output);
}

我想将所有子集存储在二维数组输出中并返回子集数。

我似乎得到了零？

Answer 1

你的基本情况很糟糕。它必须代表一个空数组。不确定是否可以使用本机数组数据结构来执行此操作。

一般来说，有多种方法可以解决所有子集＆＃34; （或＆＃34;所有组合＆＃34;问题）。 Google for＆＃34;所有组合的组合＆＃34; （和相关的＆＃34;列表的所有排列＆＃34;）用于其他方式。

这些类型的问题具有指数复杂性（对于排列而言是因子复杂性），因此请小心输入N的大小。

你有正确的想法，但由于你使用的是原生数组，所以缺少了东西。由于您已经标记了C ++，因此如果您使用STL，它将使生活变得更加轻松。

以下是递归执行此操作的一种方法：

vector<vector<int> > AllCombinations(vector<int> input) {
  //base case
  if(0 == input.size()) {
    //1 element of empty/null set
    return vector<vector<int> >(1, vector<int>());
  }
  //recursion case
  const int last = input.back();
  input.pop_back();
  vector<vector<int> > result = AllCombinations(input);
  result.reserve(result.size() * 2);
  //add last element to previous result
  const size_t resultSize = result.size();
  for(size_t i = 0; i < resultSize; ++i) {
    vector<int> tmp = result[i];
    tmp.push_back(last);
    result.push_back(tmp);
  }
  return result;
}

复杂性： O（2 ^ N）

Answer 2

不需要使用Si变量。下面给出的是正确的代码。我假设null值为0，并将每一行（即子集）的大小存储在第0列，所以结果从每一行的第1列开始。

int subset(int input[], int n, int output[][20]) {
    // Write your code here
 if(n<=0) {
      output[0][0]=0;
      return 1;
  }

  int smallOutput = subset(input+1,n-1,output);
  for(int i=0;i<smallOutput;i++) {
      int col = output[i][0] +1;
     output[i+smallOutput][0] = col;
       output[i+smallOutput][1] = input[0];
      for(int j=2; j<col+1;j++) {
        output[i+smallOutput][j] = output[i][j-1];
      }

  }

  return 2*smallOutput;
}

Answer 3

template<class AChild> C(AChild child)
  : a(std::make_unique<AChild>(std::move(child))) {};

}

Answer 4

这是我的方法：-

    id                 time               time1 numb    numb_diff
0    1  2020-01-01 12:00:15 2020-01-01 12:00:00    1          NaN
1    1  2020-01-01 12:00:30 2020-01-01 12:00:00    5          4.0
2    1  2020-01-01 12:00:45 2020-01-01 12:00:00    8          3.0
3    2  2020-01-03 08:00:00 2020-01-03 08:00:00    0         -8.0    #Changing time1 to the min of time the group(id = 2)
4    2  2020-01-03 08:00:15 2020-01-03 08:00:00    4          4.0

使用递归c ++

4 个答案: