void generateCombinations(vector<int>& nums, vector<vector<int>>& ans, vector<int>& cur, int idx, int n,
int cur_sum, int target) {
if(idx == n) {
if(cur_sum == target) {
ans.push_back(cur);
}
return;
}
generateCombinations(nums, ans, cur, idx + 1, n, cur_sum, target);
if(cur_sum + nums[idx] <= target) {
cur.push_back(nums[idx]);
generateCombinations(nums, ans, cur, idx, n, cur_sum + nums[idx], target);
cur.pop_back();
}
}
std::vector<std::string> generateCombinations(std::vector<std::string> inputVector){
if(inputVector.size() == 0){
std::vector<std::string> output;
output.push_back("");
return output;
}
else if (inputVector.size() == 1){
std::vector<std::string> output;
std::string currentString = inputVector[0];
for(int n = 0; n < currentString.size(); n++){output.push_back(currentString.substr(n,1));}
return output;
}
else if(inputVector.size() > 1){
std::vector<std::string> output;
std::string currentString = inputVector.back();
inputVector.pop_back();
std::vector<std::string> previousOutput = generateCombinations(inputVector);
for(int k = 0; k < currentString.size(); k++){
for(int m = 0; m < previousOutput.size(); m++){
output.push_back(previousOutput[m] + currentString[k]);
}
}
return output;
}
std::vector<std::string> dummy; return dummy;
}
void EFMGenerator::generateCombinations(int metaboliteIndex, int inputCount, int outputCount) {
bptInput.init();
bptOutput.init();
bptNonpart.init();
//Identify input, output and non-participating pathways for the given metabolite
int prevSize = pathways.size();
for (int i = prevSize - 1, in = 0, out = inputCount; i >= 0; i--) {
if (pathways[i].isInput(metaboliteIndex)) {
pathwaysPtr[in++] = &pathways[i];
bptInput.addPathway(&pathways[i]);
} else if (pathways[i].isOutput(metaboliteIndex)) {
pathwaysPtr[out++] = &pathways[i];
bptOutput.addPathway(&pathways[i]);
} else {
bptNonpart.addPathway(&pathways[i]);
}
}
//Create reversible trees for inputs and outputs
ReversibleTree inputTree(pathwaysPtr, 0, inputCount);
ReversibleTree outputTree(pathwaysPtr, inputCount, inputCount + outputCount);
//Generate combinations
generateCombinations(inputTree.getRoot(), outputTree.getRoot());
//Update list of pathways in the network
for (int i = pathways.size() - 1; i >= prevSize; i--) {
pathways[i].updateMetaboliteCoefficients(metaboliteIndex);
}
for (int i = prevSize - 1; i >= 0; i--) {
if (pathways[i].isInput(metaboliteIndex) || pathways[i].isOutput(metaboliteIndex)) {
pathways.remove(i);
}
}
clearBPTNodePool();
clearRevNodePool();
}
void EFMGenerator::computeEFMs() {
while(metabs > exterCount) {
int target = selectMetaboliteToEliminate();
generateCombinations(target); //Invisibly adds to candidatePathways.
removeIOPathwaysForMetabolite(target);//Invisibly modifies allPathways.
removeDependentPathways(); //The big 'un.
addCandidatePathwaystoAllPathways(); //And again.
}
}
int main(){
std::string A = "abc";
std::string B = "d";
std::string C = "gh";
std::string D = "xyz";
std::vector<std::string> testInput; testInput.push_back(A); testInput.push_back(B); testInput.push_back(C); testInput.push_back(D);
std::vector<std::string> testOutput = generateCombinations(testInput);
for(int k = 0; k < testOutput.size(); k++){std::cout << testOutput[k] << std::endl;}
return 0;
}
void EFMGenerator::generateCombinations(ReversibleTreeNode* input, ReversibleTreeNode* output) {
ReactionBitData comboLabel;
rbdOr(comboLabel, input->getBitsUsed(), output->getBitsUsed());
if (!isValidPathway(comboLabel)) {
return;
}
if (input->isLeaf()) {
if (output->isLeaf()) {
if (bptInput.isSuperSet(comboLabel, input->getBitsUsed()) || bptOutput.isSuperSet(comboLabel, output->getBitsUsed()) || bptNonpart.isSuperSet(comboLabel)) {
return;
}
int iStart = input->getStart(), iEnd = input->getEnd();
int oStart = output->getStart(), oEnd = output->getEnd();
Pathway *combo = ++pathways;
Pathway *in;
Pathway *out;
for (int i = iStart; i < iEnd; i++) {
for (int o = oStart; o < oEnd; o++) {
in = input->getPathway(i);
out = output->getPathway(o);
combo->setParents(in, out);
combinationsGenerated++;
if (!(bptInput.isSuperSet(combo, in) || bptOutput.isSuperSet(combo, out) || bptNonpart.isSuperSet(combo))) {
combinationsStored++;
combo = ++pathways;
}
}
}
--pathways;
} else {
generateCombinations(input, output->getNode0());
generateCombinations(input, output->getNode1());
}
} else {
if (output->isLeaf()) {
generateCombinations(input->getNode0(), output);
generateCombinations(input->getNode1(), output);
} else {
generateCombinations(input->getNode0(), output->getNode0());
generateCombinations(input->getNode0(), output->getNode1());
generateCombinations(input->getNode1(), output->getNode0());
generateCombinations(input->getNode1(), output->getNode1());
}
}
}
void EFMGenerator::removeNextMetabolite() {
int metaboliteIndex, inputCount, outputCount;
//Find next metabolite to remove
findNextMetaboliteToRemove(metaboliteIndex, inputCount, outputCount);
//Decrement number of remaining metabolites
numMetabolitesRemaining--;
//Move the metabolite to the end of unprocessed metabolites
reorderMetabolites(metaboliteIndex, numMetabolitesRemaining);
metaboliteIndex = numMetabolitesRemaining;
long totalCombinations = inputCount;
totalCombinations *= outputCount;
cout << metabolites[metaboliteIndex] << "\t" << inputCount << "\t" << outputCount << "\t" << (pathways.size() - inputCount - outputCount) << "\t" << totalCombinations << "\t";
if (inputCount == 0) {
removeUnusedOutputs(metaboliteIndex);
} else if (outputCount == 0) {
removeUnusedInputs(metaboliteIndex);
} else {
generateCombinations(metaboliteIndex, inputCount, outputCount);
}
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
vector<vector<int>> ans;
vector<int> cur;
generateCombinations(candidates, ans, cur, 0, candidates.size(), 0, target);
return ans;
}
int main() {
int N, K;
scanf("%d %d", &N, &K);
generateCombinations(N, K);
return 0;
}
