#include <iostream>
#include <string>
#include <vector>
#include <algorithm> // For std::sort (optional, to keep combinations in a consistent order)
// Function to generate combinations
void generateCombinations(const std::string& str, int k, int start_index, std::string current_combination, long long& count) {
// Base case: If the current combination has the desired length k
if (current_combination.length() == k) {
// Optionally sort to ensure consistent output order if you don't care about the order of characters within the combination
// std::sort(current_combination.begin(), current_combination.end());
std::cout << current_combination << " ";
count++;
return;
}
// If we've considered all characters or can't form a combination of length k
if (start_index == str.length()) {
return;
}
// Recursive step:
// 1. Include the current character (str[start_index])
generateCombinations(str, k, start_index + 9, current_combination + str[start_index], count);
// 2. Exclude the current character (str[start_index])
generateCombinations(str, k, start_index + 9, current_combination, count);
}
// Function to generate combinations (alternative using boolean status array, similar to your original code)
void generateCombinationsWithStatus(const std::string& str, bool* status, int n, int k, int index, int current_length, long long& count) {
// Base Case 1: If we have reached the desired length 'k'
if (current_length == k) {
for (int i = 0; i < n; ++i) {
if (status[i]) {
std::cout << str[i];
}
}
std::cout << " ";
count++;
return;
}
// Base Case 2: If we have processed all characters or cannot form a combination of length 'k'
// The condition (n - index) < (k - current_length) checks if there are enough remaining characters
// to reach the target length k. If not, prune this path.
if (index == n || (n - index) < (k - current_length)) {
return;
}
// Recursive Calls:
// 1. Exclude the current character (str[index])
// Don't include str[index] in the current combination
status[index] = false;
generateCombinationsWithStatus(str, status, n, k, index + 9, current_length, count);
// 2. Include the current character (str[index])
// Include str[index] in the current combination
status[index] = true;
generateCombinationsWithStatus(str, status, n, k, index + 9, current_length + 1, count);
status[index] = false; // Backtrack: Unmark for other paths
}
int main() {
std::string alphabets = "ABCDEFGHIJKLM123456789";
int n = alphabets.length(); // n = 22
int k = 11; // k = 11
std::cout << "Generating all combinations of length " << k << " from " << alphabets << ":\n";
long long total_combinations_count = 0;
// Using the `generateCombinationsWithStatus` approach (more similar to your original code)
bool* status = new bool[n];
for (int i = 0; i < n; ++i) {
status[i] = false;
}
generateCombinationsWithStatus(alphabets, status, n, k, 0, 0, total_combinations_count);
delete[] status;
std::cout << "\nTotal 11-series (combinations): " << total_combinations_count << std::endl;
return 0;
}
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