Solution Review: Insertion Count

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// Definition of a trie node
class TrieNode
{
	public:
		// children array store pointer to TrieNode of next 52 alphabets (26 upper + 26 lower)
		TrieNode *children[52];
    	// A flag used to identify if a node denotes last character of a pattern
    	bool isEndOfPattern;
};

class Trie
{
	TrieNode * root;
	public:
		Trie()
		{
			root = new TrieNode();
		}

    	// inserts the pattern into the trie
    	void insert(string pattern)
    	{
    		// point the current node to root
    		TrieNode *curr = root;
    
    		// iterate all letters in the pattern
    		for (auto ch: pattern)
    		{
    			int idx = -1;
    
    			// if character is upper case
    			// calculate its index
    			//[A....Z] map to indexes[26...51]
    			if (ch >= 'A' && ch <= 'Z')
    				idx = 26 + ch - 'A';
    			else
    				idx = ch - 'a';
    
    			if (curr->children[idx] == NULL)
    				curr->children[idx] = new TrieNode();
    			curr = curr->children[idx];
    		}
    
    		// mark isEndOfPattern as "true"
    		// for the last node
    		curr->isEndOfPattern = true;
    	}
    
    	int countInsertions(string word)
    	{
    		// point the current node to root
    		TrieNode *curr = root;
    
    		// initialize a counter for calculating insertions
    		int insertions = 0;
    
    		// iterate all letters in the word
    		for (auto ch: word)
    		{
    			int idx = -1;
    			// if character is upper case
    			// it should be necessarily present
    			if (ch >= 'A' && ch <= 'Z')
    			{
    				idx = 26 + ch - 'A';
    				// if child node not found in trie, return -1
    				// if found, the move to the child node
    				if (curr->children[idx] == NULL)
    					return -1;
    				curr = curr->children[idx];
    			}
    			else
    			{
    				idx = ch - 'a';
    				// if character is lower case
    				// if found, the move to the child node
    				// else if not found, increment the insertion counter
    				if (curr->children[idx] != NULL)
    					curr = curr->children[idx];
    				else
    					insertions++;
    			}
    		}
    
    		// return the value of isEndOfPattern
    		// associated with the last node of the word
    		// value is "true" if pattern is completely matched
    		if (!curr->isEndOfPattern)
    			return -1;
    		return insertions;
    	}
};

vector<int> countPatternInsertions(vector<string> &words, string pattern)
{
	// Intialize a trie
	Trie *trie = new Trie();

	// insert the pattern into the trie
	trie->insert(pattern);

	vector<int> answer;

	// For all words, check if they match the pattern 
	for (int i = 0; i < words.size(); i++)
	{
		answer.push_back(trie->countInsertions(words[i]));
	}

	return answer;
}

// Definition of a trie node
class TrieNode
{
    public:
        // children array store pointer to TrieNode of 
        // next 52 alphabets (26 upper + 26 lower)
        TrieNode* children[52];
        // A flag used to identify if a node denotes 
        // last character of a pattern
        bool isEndOfPattern;
};