我需要關於如何使用數組來打印所有可能序列的想法。 例如，制定一個列出所有可能序列的算法
array 1: AA BB
array 2: CC
array 3: DD EE FF
array 4: GG
現在我需要從任何給定的陣列列出所有可能的組合，使用每個陣列僅1序列，就像這樣：
AA CC DD GG
AA CC EE GG
AA CC FF GG
BB CC DD GG
BB CC EE GG
BB CC FF GG
有誰知道或關閉上啓動我這個怎麼做？
我假設你的意思是每個數組元素的數量是未知的，我使用sizeof（）。和其他人一樣，你只需要嵌套5個循環。
int main()
{
//naming arrays a,b,c,d,e, change accordingly
//this function prints the combinations of 1 char
int aElements = sizeof(a)/sizeof(a[0]);
int bElements = sizeof(b)/sizeof(b[0]);
int cElements = sizeof(c)/sizeof(c[0]);
int dElements = sizeof(d)/sizeof(d[0]);
int eElements = sizeof(e)/sizeof(e[0]);
for (int i = 0; i < aElements; i++){
for (int j = 0; j < bElements; j++){
for (int k = 0; k < cElements; k++){
for (int l = 0; l < dElements; l++){
for (int m = 0; m < eElements; m++){
cout << a[i] << b[j] << c[k] << d[l] << e[m] << endl;
}
}
}
}
}
}
爲了找出組合的數量，你可以把一個計數器在內部循環，或者只是除以（在這種情況下，1）組合多個元素的數量，乘以所有的人。 E.G，在你的例子中它將是（4/1）*（2/1）*（2/1）*（6/1）*（2/1）= 192個組合。如果你按2個字符進行組合，在第二個例子中，它將是（4/2）*（2/2）*（2/2）*（6/2）*（2/2）= 6個組合。下面的函數打印出的2
int main()
{
//naming arrays a,b,c,d,e, change accordingly
//this function prints the combinations of 2 chars
int aElements = sizeof(a)/sizeof(a[0]);
int bElements = sizeof(b)/sizeof(b[0]);
int cElements = sizeof(c)/sizeof(c[0]);
int dElements = sizeof(d)/sizeof(d[0]);
int eElements = sizeof(e)/sizeof(e[0]);
for (int i = 0; i < aElements - 1; i+=2){
for (int j = 0; j < bElements - 1; j+=2){
for (int k = 0; k < cElements - 1; k+=2){
for (int l = 0; l < dElements - 1; l+=2){
for (int m = 0; m < eElements - 1; m+=2){
cout << a[i] << a[i+1] << b[j] << b[j+1] << c[k] << c[k+1] << d[l] << d[l+1] << e[m] << e[m+1] << endl;
}
}
}
}
}
}
我所做的第二個2，而不是1是增量計數器的組合，從要素數量減去1不要去出界，和而連續打印2種元素比1.這將適用於任何數量的字符組合。
如果這些是4個不同的數組，我想不出更好的選擇，然後編寫4個嵌套循環，每個循環遍歷一個數組。如果你有一個包含所有數組的二維數組，我會建議你使用遞歸。
就我所見，您不需要關心從中獲取序列的數組的順序。在這種情況下，遞歸確實有幫助。看起來在某種程度上這樣的：
void printSequences(ListOfYourArrays list, int index) {
if (list.size() > index) {
array a = list.getElementAt(index);
//Make a cycle that reads items from your array one by one
while (...)
System.out.print(item);
//And now you need to print all combinations for the rest of arrays in you list
printSequences(list, index + 1);
} else
System.out.println();
}
所有你需要做的就是你的一陽指添加到列表中，並調用一個函數
printSequences(list, 0);
這將打印'AA BB ...' – 2013-03-12 09:30:45
另一種可能性將是「計數」目前的組合（例如，在計數二進制）。從（0,0,0,0）開始計數到最大數組索引（1,0,2,0）。在每一步中，首先在第一個索引中加1。如果它是大於最大索引（這裏是1）時，將其設置爲零，並與下一個索引進行
結果：
（0,0,0,0） - > AA CC DD GG
（1,0,0,0） - > BB CC DD GG
（0,0,1,0） - > AA CC EE GG
（1,0， 1,0） - > BB CC EE GG
（0 ，0,2,0） - > AA CC FF GG
（1,0,2,0） - > BB CC FF GG
4迴路引出到N POW（4）。
分割四點陣列循環到2.
for each(arr 1){
for each(arr 2)
insert into container 1.
}
for each(arr 3){
for each(arr 4)
insert into container 2.
}
for each(container 1){
for each(container 2)
insert into container3 (*iter 1 + *iter 2)
}
所以複雜性將是最大3NPow（2）這將是小於N POW（4）
不復雜複雜性不會改變這樣做.. !!對於firt循環它是NPow（2）第二個循環它是Npow（2），對於第三個循環它（M）Pow（2）在這裏M = NPow（2）你說容器的大小是NPow（2）。 。！所以它不會改變，最後它是NPow（4）..！ – MissingNumber 2013-04-17 07:11:14
EDITED FOR UPDATE
我們需要不是逐一更新每個指令，通過迭代組合來更新...
請參閱：How can I iterate throught every possible combination of n playing cards
所以現在它看起來像這樣
#include <iostream>
#include <vector>
#include <string>
using namespace std;
bool UpdateCombination (std::vector<int> &comboindices, int count, int n)
{
for (int i = 1; i <= n; ++i)
{
if (comboindices[n - i] < count - i)
{
++comboindices[n - i];
for (int j = n - i + 1; j < n; ++j)
{
comboindices[j] = comboindices[j-1] + 1;
}
return false;
}
}
return true;
}
void ResetCombination (std::vector<int> &comboindices, int n)
{
comboindices.resize(n);
for (int i = 0; i < n; ++i)
{
comboindices[i] = i;
}
}
void PrintArrays (const std::vector<std::vector<std::string>> items, int count)
{
std::vector<std::vector<int>> indices;
int n = items.size();
indices.resize(items.size());
for(auto i = indices.begin(); i != indices.end(); ++i)
{
ResetCombination((*i),count);
}
while (true) //Iterate until we've used all of the last array of items
{
for (int i = 0; i < n; ++i)
{
cout << "{";
for (auto j = indices[i].begin(); j != indices[i].end(); ++j)
{
int ji = (*j);
cout << (items[i])[ji] << " ";
}
cout << "} ";
}
cout << endl;
//Update to the next indice
for (int i = n - 1; i >= 0; --i)
{
bool done = UpdateCombination (indices[i],items[i].size(),count);
if (!done)
{
break;
}
else if (done && i == 0)
{
return; //Escape.
}
else
{
ResetCombination(indices[i],count);
}
}
}
}
//{A,B,C,D},{A,B},{A,B},{A,B,C,D,E,F},{A,B}
int main() {
vector<vector<string>> lists;
lists.resize(5);
lists[0].push_back("A");
lists[0].push_back("B");
lists[0].push_back("C");
lists[0].push_back("D");
lists[1].push_back("A");
lists[1].push_back("B");
lists[2].push_back("A");
lists[2].push_back("B");
lists[3].push_back("A");
lists[3].push_back("B");
lists[3].push_back("C");
lists[3].push_back("D");
lists[3].push_back("E");
lists[3].push_back("F");
lists[4].push_back("A");
lists[4].push_back("B");
PrintArrays(lists,2);
int pause;
cin >> pause;
return 0;
}
給予我們...
{A B } {A B } {A B } {A B } {A B }
{A B } {A B } {A B } {A C } {A B }
{A B } {A B } {A B } {A D } {A B }
{A B } {A B } {A B } {A E } {A B }
{A B } {A B } {A B } {A F } {A B }
{A B } {A B } {A B } {B C } {A B }
{A B } {A B } {A B } {B D } {A B }
{A B } {A B } {A B } {B E } {A B }
{A B } {A B } {A B } {B F } {A B }
{A B } {A B } {A B } {C D } {A B }
{A B } {A B } {A B } {C E } {A B }
{A B } {A B } {A B } {C F } {A B }
{A B } {A B } {A B } {D E } {A B }
{A B } {A B } {A B } {D F } {A B }
{A B } {A B } {A B } {E F } {A B }
{A C } {A B } {A B } {A B } {A B }
{A C } {A B } {A B } {A C } {A B }
{A C } {A B } {A B } {A D } {A B }
{A C } {A B } {A B } {A E } {A B }
{A C } {A B } {A B } {A F } {A B }
{A C } {A B } {A B } {B C } {A B }
{A C } {A B } {A B } {B D } {A B }
{A C } {A B } {A B } {B E } {A B }
{A C } {A B } {A B } {B F } {A B }
{A C } {A B } {A B } {C D } {A B }
{A C } {A B } {A B } {C E } {A B }
{A C } {A B } {A B } {C F } {A B }
{A C } {A B } {A B } {D E } {A B }
{A C } {A B } {A B } {D F } {A B }
{A C } {A B } {A B } {E F } {A B }
{A D } {A B } {A B } {A B } {A B }
{A D } {A B } {A B } {A C } {A B }
{A D } {A B } {A B } {A D } {A B }
{A D } {A B } {A B } {A E } {A B }
{A D } {A B } {A B } {A F } {A B }
{A D } {A B } {A B } {B C } {A B }
{A D } {A B } {A B } {B D } {A B }
{A D } {A B } {A B } {B E } {A B }
{A D } {A B } {A B } {B F } {A B }
{A D } {A B } {A B } {C D } {A B }
{A D } {A B } {A B } {C E } {A B }
{A D } {A B } {A B } {C F } {A B }
{A D } {A B } {A B } {D E } {A B }
{A D } {A B } {A B } {D F } {A B }
{A D } {A B } {A B } {E F } {A B }
{B C } {A B } {A B } {A B } {A B }
{B C } {A B } {A B } {A C } {A B }
{B C } {A B } {A B } {A D } {A B }
{B C } {A B } {A B } {A E } {A B }
{B C } {A B } {A B } {A F } {A B }
{B C } {A B } {A B } {B C } {A B }
{B C } {A B } {A B } {B D } {A B }
{B C } {A B } {A B } {B E } {A B }
{B C } {A B } {A B } {B F } {A B }
{B C } {A B } {A B } {C D } {A B }
{B C } {A B } {A B } {C E } {A B }
{B C } {A B } {A B } {C F } {A B }
{B C } {A B } {A B } {D E } {A B }
{B C } {A B } {A B } {D F } {A B }
{B C } {A B } {A B } {E F } {A B }
{B D } {A B } {A B } {A B } {A B }
{B D } {A B } {A B } {A C } {A B }
{B D } {A B } {A B } {A D } {A B }
{B D } {A B } {A B } {A E } {A B }
{B D } {A B } {A B } {A F } {A B }
{B D } {A B } {A B } {B C } {A B }
{B D } {A B } {A B } {B D } {A B }
{B D } {A B } {A B } {B E } {A B }
{B D } {A B } {A B } {B F } {A B }
{B D } {A B } {A B } {C D } {A B }
{B D } {A B } {A B } {C E } {A B }
{B D } {A B } {A B } {C F } {A B }
{B D } {A B } {A B } {D E } {A B }
{B D } {A B } {A B } {D F } {A B }
{B D } {A B } {A B } {E F } {A B }
{C D } {A B } {A B } {A B } {A B }
{C D } {A B } {A B } {A C } {A B }
{C D } {A B } {A B } {A D } {A B }
{C D } {A B } {A B } {A E } {A B }
{C D } {A B } {A B } {A F } {A B }
{C D } {A B } {A B } {B C } {A B }
{C D } {A B } {A B } {B D } {A B }
{C D } {A B } {A B } {B E } {A B }
{C D } {A B } {A B } {B F } {A B }
{C D } {A B } {A B } {C D } {A B }
{C D } {A B } {A B } {C E } {A B }
{C D } {A B } {A B } {C F } {A B }
{C D } {A B } {A B } {D E } {A B }
{C D } {A B } {A B } {D F } {A B }
{C D } {A B } {A B } {E F } {A B }
檢出輸出。 http://ideone.com/L5AZVv
老ideone鏈接： http://ideone.com/58ARAZ
的TOC答案是正確的，如果你有一個可變數量的陣列。如果你總是有4個數組，你可以簡單地使用4個嵌套循環。
for (unsigned int i1 = 0; i1 < a1.size(); ++i1)
for (unsigned int i2 = 0; i2 < a2.size(); ++i2)
for (unsigned int i3 = 0; i3 < a3.size(); ++i3)
for (unsigned int i4 = 0; i4 < a4.size(); ++i4)
cout << a1[i1] << " " << a2[i2] << " " << a3[i3] << " " << a4[i4] << std::endl;
請看這裏http://ideone.com/YcW84Q瞭解完整的代碼。
C++ 11風格！
#include <iostream>
#include <vector>
#include <utility>
#include <iterator>
// metaprogramming boilerplate:
template<typename... L>
struct first_type {};
template<typename T, typename... L>
struct first_type<T, L...> {
typedef T type;
};
template<typename... L>
using FirstType = typename first_type<L...>::type;
namespace aux {
using std::begin;
template<typename C>
auto adl_begin(C&&c)->decltype(begin(std::forward<C>(c)));
template<typename C>
auto adl_cbegin(C const&c)->decltype(begin(c));
}
template<typename Container>
struct iterator_type {
typedef decltype(aux::adl_begin(std::declval<Container>())) iterator;
typedef decltype(aux::adl_cbegin(std::declval<Container>())) const_iterator;
};
template<typename Container>
using IteratorType = typename iterator_type<Container>::iterator;
template<typename Container>
struct value_type {
typedef typename std::iterator_traits< IteratorType<Container> >::value_type type;
};
template<typename Container>
using ValueType = typename value_type<Container>::type;
// Actual problem specific code:
template<typename Func, typename T>
void ForEachPossibility_Helper(Func&& f, std::vector<T>& result) {
f(result);
}
template<typename Func, typename T, typename Container, typename... Containers>
void ForEachPossibility_Helper(Func&& f, std::vector<T>& result, Container&& arr0, Containers&&... arrays) {
for(auto const& str:arr0) {
result.push_back(str);
ForEachPossibility_Helper(std::forward<Func>(f), result, std::forward<Containers>(arrays)...);
result.pop_back();
}
}
template<typename Func, typename... Containers>
void ForEachPossibility(Func&& f, Containers&&... arrays) {
typedef ValueType<FirstType<Containers...>> T;
std::vector<T> result;
ForEachPossibility_Helper(std::forward<Func>(f), result, std::forward<Containers>(arrays)...);
}
const char* arr1[] = {"AA", "BB"};
const char* arr2[] = {"CC"};
const char* arr3[] = {"DD", "EE", "FF"};
const char* arr4[] = {"GG"};
int main() {
ForEachPossibility([](std::vector<const char*> const& result){
for(auto&& str:result) {
std::cout << str;
}
std::cout << "\n";
}, arr1, arr2, arr3, arr4);
}
請注意，循環只有2個，其中一個用於打印。
注意：這是一個基本的C++類，所以我需要使用這個基本的方法，而不是向量或任何東西 – Foxic 2013-04-17 20:45:26
[幾個向量的笛卡爾積]的副本（http://stackoverflow.com/questions/2405242/笛卡爾積的-幾個矢量）。 – 2013-04-17 21:59:52
正如我所說的，我需要一個不使用向量的基本方法，所以這個問題不會幫助我 – Foxic 2013-04-18 02:21:58