Question

基本上，我想创建一个字符串向量的所有可能的映射到一个int的向量。我有以下内容：

std::vector<std::string> my_strings;
std::vector<unsigned int> my_ints;
my_strings.size() = 20; // not code, just for demonstration.
my_ints.size() = 4; // not code, just for demonstration.

std::vector<std::map<std::string, unsigned int> > all_possible_joint_mappings;

因此，我希望将all_possible_joint_mappings的所有可能排列填充到my_strings到my_ints。有什么好办法来实现这个目标？

示例联合映射将是：

string_1 -> int_1
string_2 -> int_1
string_3 -> int_1
string_4 -> int_4
string_5 -> int_2
...
string_20 -> int_3

Answer 1

您只需迭代一个集合并在内部循环中迭代其他集合：

std::vector<std::pair<std::string, unsigned int> > all_possible_joint_mappings;

for ( std::vector<std::string>::const_iterator s = my_strings.begin(); s != my_strings.end(); ++s )
{
    for ( std::vector<unsigned int>::const_iterator i = my_ints.begin(); i != my_ints.end(); ++i )
        all_possible_joint_mappings.push_back( std::make_pair( *s, *i ) );
    }
}

请注意，向量只需包含对来完成工作。

亲切的问候托

Answer 2

如果您想要从每个string值到多个int值的映射，并且您希望在单个容器中使用所有排列，那么请使用专门为此目的设计的容器类型（{{ 1}}）。这是一个例子：

std::multimap

Answer 3

下面的代码将以递归方式生成所有3个字母单词的std::vector< std::vector<int> >（按字典顺序排列），其中每个字母都来自4个字母的字母。有64 = 4^3个这样的词。

请注意，简单的双循环是不够的，您需要递归单词中的每个字母，并且对于每个字母，您需要一个循环。 O(K^N)的总复杂度为N - 来自K - 字母字母的字母，而不是O(K*N)作为双循环。

它以直接的方式概括了一个4个字母的字母表中的20个字母的单词（尽管这是2 ^ 40 = 1个12个不同的单词）。当然，将它们与原始字符串相匹配是一种简单的方式。

#include <array>
#include <cstddef>
#include <vector>
#include <iostream>

template<typename T, int K, int N>
void generate_all_multisets(
    std::array<T, K> const& alphabet, 
    std::vector< std::vector<T> >& all_words, 
    std::vector<T>& current_word, 
    int current_letter
)
{
    if (current_letter == N) {
        all_words.push_back(current_word);
        for (auto k = 0; k != N; ++k) 
            std::cout << current_word[k];
        std::cout << "\n";
        return;
    }   

    auto const tmp = current_word[current_letter];
    for (auto letter = alphabet.begin(); letter != alphabet.end(); ++letter) {
        current_word[current_letter] = *letter;
        generate_all_multisets<T, K, N>(alphabet, all_words, current_word, current_letter + 1);
    }
    current_word[current_letter] = tmp; 
}

template<typename T, int K, int N>
void generate_all_words(
    std::array<T, K> const& alphabet, 
    std::vector< std::vector<T> >& all_words
)
{
    // first word
    std::vector<T> word(N, alphabet.front());
    generate_all_multisets<T, K, N>(alphabet, all_words, word, 0);
}

int main()
{
    std::array<int, 4> alphabet = { 1, 2, 3, 4};
    auto const word_length = 3; 

    std::vector< std::vector<int> > all_words;
    generate_all_words<int, 4, 3>(alphabet, all_words);
    return 0;
}

编辑：Ideone

上的输出

如何计算字符串映射到整数之间的所有排列

3 个答案: