Recursion with anagrams - c++

Question

I am attempting to use recursion and keep getting overflow errors. I am not sure what to do.
I want to feed one of my functions with all the anagrams but I am not sure how. I can't fit everything into one function, so I made two: one that makes the anagrams and one that searches through the dictionary to find all the matches. But it's not working, and I have no idea what else to do. And in my anagram function, I want to return back to my permutation function, but I can't without returning a string. I need it to return nothing and go back to the function.
#include <iostream>
#include <fstream>
#include <istream>
#include <string>
using namespace std;
const int MAXRESULTS = 20; // Max matches that can be found
const int MAXDICTWORDS = 30000; // Max words that can be read in
const int MAXPERMUTATIONS = 720; //enough permutations for a 6 letter word
//Beginning of assignment functions
//Read Dictionary function that uses recursion
int readDictionary(istream &, string[]);
//Permuation function
int recursivePermute(string, const string[], int, string[]);
//Print function
void recurPrint(const string[], int);
//swap characters in a string
void swap(string*, string*);
//permutation function
string Permutator(string, int, int, int);
//
//End of Assignment functions
int main()
{
string Permutations[MAXPERMUTATIONS];
string results[MAXRESULTS];
string dict[MAXDICTWORDS];
ifstream dictfile; // file containing the list of words
int nwords; // number of words read from dictionary
string word;
dictfile.open("words.txt");
if (!dictfile) {
cout << "File not found!" << endl;
return (1);
}
nwords = readDictionary(dictfile, dict);
cout << "Please enter a string for an anagram: ";
cin >> word;
//Make all the permutations and store them in an array
int numMatches = recursivePermute(word, dict, nwords, results);
if (numMatches == 0)
cout << "No matches found" << endl;
else
recurPrint(results, numMatches);
}
/***************************************************************************************************
Name: readDictionary
input: ifstream reference, string array
Description: This function returns the number of words added into the array from the dictionary.
****************************************************************************************************/
int readDictionary(istream &file, string DicArr[])
{
int counter = 0;
if (counter > MAXDICTWORDS)
return counter;
if (getline(file, DicArr[0]))
{
counter++;
return counter += readDictionary(file, DicArr + 1);
}
else
return counter;
}
/*****************************************************************************************************
Name: recursivePermute
Input: string, const string array, int, string array
Description: Places all the permutations of word, which are found in dict into results.
Returns the number of matched words found. This number should not be larger than
MAXRESULTS since that is the size of the array. The size is the number of words
inside the dict array.
*******************************************************************************************************/
int recursivePermute(string word, const string dict[], int size, string results[])
{
//count to iterate through the dictionary array and keep in bounds
//numresults to keep track of the number of results
int numResults = 0;
//if statement to if the number of results goes over the limit
if (numResults > MAXRESULTS)
return numResults;
if (size == 0)
return numResults;
//if there is a match check the dictionary
if (word == dict[0])
{
results[0] = word;
numResults++;
}
numResults += recursivePermute(Permutator(word, 0, word.length() - 1, 0), dict + 1, size - 1, results);
return numResults;
}
/*******************************************************************************************************
Name: recurPrint
Input:const string array, int
Description: Prints out the results
*********************************************************************************************************/
void recurPrint(const string results[], int size)
{
if (size == 1)
{
cout << "matching word \"" << results[0] << "\" found!\n" << endl;
return;
}
if (size == 0)
return;
cout << results[size - 1];
recurPrint(results, size - 1);
}
/****************************************************************************************************
name: swap
input: string pointer
description: This functions swaps two characters in a string
*****************************************************************************************************/
void swap(string* a, string* b)
{
string temp;
temp = *a;
*a = *b;
*b = temp;
}
/******************************************************************************************************
********************************************************************************************************/
string Permutator(string word, int beg, int end, int count)
{
string a;
if (count == end)
return word;
if (beg == end)
return;
if(count <= end)
{
swap(word[beg], word[count]);
Permutator(word, beg + 1, end, count);
swap(word[beg], word[count]);
Permutator(word, beg, end, count + 1);
}
}
/******************************************************************************************************
*******************************************************************************************************/
ok, so I've narrowed down my problem. I am having issues with this function, which I am using to feed each permutation into my other function that will check each permutation against the dictionary which is an array of strings.
string Permutator(string word, int beg, int end, int count)
{
if (count == end)
return word;
if (beg == end)
if (count <= end)
{
swap(word[beg], word[count]);
Permutator(word, beg + 1, end, count);
swap(word[beg], word[count]);
}
}
This would work if it was void, but I need it to return a string, but when I change the return type my entire algorithm goes out of whack. The loops, which in this assignment can only be recursions, do not work as they are supposed to. I am out of ideas not sure what else I can do.

Answer 1

std::map<std::string, std::vector<std::string>> seems appropriate:
std::vector<std::string> allWords /*= */;
std::map<std::string, std::vector<std::string>> dictionary;
for (const std::string& word : allWords) {
auto w = word;
std::sort(w.begin(), w.end());
dictionary[w].push_back(word);
}
And then
std::vector<std::string>
find_words_from_anagram(const std::map<std::string, std::vector<std::string>>& dictionary,
const std::string& word)
{
auto w = word;
std::sort(w.begin(), w.end());
auto it = dictionary.find(w);
if (it == dictionary.end()) {
return {}; // No match.
}
return it->second;
}
Trick is to normalize entry instead of checking for all permutations.