#include <vector>
    #include <map>
    #include <set>
    #include <iostream>
    #include <string>
    #include <cstdint>
 
    typedef std::string IDdoc;
    typedef uint32_t position;
 
    typedef std::pair<IDdoc,position> Occurrence;
    typedef std::vector<Occurrence> OccurrencesOfWord;
    typedef std::map<std::string /*word*/, OccurrencesOfWord> Dictionary;
    typedef std::set<IDdoc> Matches;
 
    bool findMatchesForPhrase(const std::string& phrase, const Dictionary& dictionary, Matches& matches)
    {
        size_t pos = 0;
        size_t len = 0;
        while (pos < phrase.length()) {
            size_t end = phrase.find(' ', pos);
            size_t len = ((end == phrase.npos) ? phrase.length() : end) - pos;
            std::string word(phrase, pos, len);
            pos += len + 1; // to skip the space.
 
            // ignore words not in the dictionary.
            auto dictIt = dictionary.find(word);
            if (dictIt == dictionary.end())
                continue;
 
            auto& occurrences = dictIt->second; // shortcut/alias,.
            for (auto& occurIt : occurrences) {
                // Add all the IDdoc's of this occurence to the set.
                matches.insert(occurIt.first);
            }
        }
 
        return !matches.empty();
    }
 
    void addToDictionary(Dictionary& dict, const char* word, const char* doc, uint32_t position)
    {
        dict[word].push_back(std::make_pair(std::string(doc), position));
    }
 
    int main(int argc, const char** argv)
    {
        std::string phrase("pizza is life");
        Dictionary dict;
 
        addToDictionary(dict, "pizza", "book1", 10);
        addToDictionary(dict, "pizza", "book2", 30);
        addToDictionary(dict, "life", "book1", 1);
        addToDictionary(dict, "life", "book3", 1);
        addToDictionary(dict, "goat", "book4", 99);
 
        Matches matches;
        bool result = findMatchesForPhrase(phrase, dict, matches);
 
        std::cout << "result = " << result << std::endl;
        for (auto& ent : matches) {
            std::cout << ent << std::endl;
        }
 
        return 0;
    }

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