Number of ways to form a given String from the given set of Strings

using System;

public class TrieNode {
  public bool endOfWord = false;
  public TrieNode[] children = new TrieNode[26];
}

public class Trie {
  private TrieNode root = new TrieNode();

  // Insert a string into the trie
  public void Insert(string s)
  {
    TrieNode prev = root;
    foreach(char c in s)
    {
      int index = c - 'a';
      if (prev.children[index] == null)
        prev.children[index] = new TrieNode();
      prev = prev.children[index];
    }
    prev.endOfWord = true;
  }

  // Find the number of ways to form the given string
  // using the strings in the trie
  public int WaysOfFormingString(string str)
  {
    int n = str.Length;
    int[] count = new int[n];

    // For each index i in the input string
    for (int i = 0; i < n; i++) {
      TrieNode ptr = root;
      // Check all possible substrings of str ending
      // at index i
      for (int j = i; j >= 0; j--) {
        char ch = str[j];
        int index = ch - 'a';
        if (ptr.children[index] == null)
          break;
        ptr = ptr.children[index];
        if (ptr.endOfWord)
          // If the substring ending at index j is
          // in the trie, update the count
          count[i] += j > 0 ? count[j - 1] : 1;
      }
    }

    // The final count is the number of ways to form the
    // entire string
    return count[n - 1];
  }
}

public class Program {
  public static void Main()
  {
    string str = "abab";
    string[] dictionary = { "a", "b", "ab" };
    int m = dictionary.Length;
    Trie trie = new Trie();

    // Insert the reversed strings into the trie
    foreach(string s in dictionary)
    {
      char[] arr = s.ToCharArray();
      Array.Reverse(arr);
      trie.Insert(new string(arr));
    }

    // Find the number of ways to form the input string
    // using the strings in the trie
    Console.WriteLine(trie.WaysOfFormingString(str));
  }
}

// This code is contributed by lokeshpotta20.

// C# code to implement the approach

using System;
using System.Collections.Generic;

namespace ConsoleApp
{
  class Gfg
  {
    static long p = 31, m = 1000000007;

    //x riased to y
    static int power(int x, int y, int mod)
    {
      int res = 1;
      while (y > 0)
      {
        // If y is odd, multiply x with result
        if (y % 2 == 1)
          res = (int)((res * (long)x) % mod);
        // y = y/2
        y = y >> 1;

        // Change x to x^2
        x = (int)((x * (long)x) % mod);
      }
      return res % mod;
    }

    //getting the hash value of string s
    static int get_hash(string s)
    {
      long hash = 0;
      long p_pow = 1;
      int n = s.Length;
      for (int i = 0; i < n; i++)
      {
        hash = ((hash + (s[i] - 'a' + 1) * p_pow) % m);
        p_pow = (p_pow * p) % m;
      }
      return (int)hash;
    }

    //constructing hash values of all prefix
    // of string s
    static List<int> hashing(string s)
    {
      int n = s.Length;
      List<int> hash = new List<int>(n);
      hash.Add(s[0] - 'a' + 1);
      long p_pow = p;

      for (int i = 1; i < n; i++)
      {
        hash.Add((int)((hash[i - 1] + (s[i] - 'a' + 1) * p_pow) % m));
        p_pow = (p_pow * p) % m;
      }
      return hash;
    }

    // Function to find number of ways
    // of forming string str
    static int waysOfFormingString(string s, List<string> dic)
    {
      int n = s.Length;
      int k = dic.Count;
      // map (length, hash_values)
      Dictionary<int, HashSet<int>> hashGrp = new Dictionary<int, HashSet<int>>();

      //hash values for all strings
      for (int i = 0; i < k; i++)
      {
        int p = get_hash(dic[i]);
        if (!hashGrp.ContainsKey(dic[i].Length))
          hashGrp[dic[i].Length] = new HashSet<int>();
        hashGrp[dic[i].Length].Add(p);
      }

      // hashed array for prefix of str
      List<int> hashedArr = hashing(s);

      // required answer for prefixes of str
      List<int> count = new List<int>(new int[n]);
      for (int i = 0; i < n; i++)
      {
        // traversing every lengths of strings
        // in dictionary[]
        foreach (KeyValuePair<int, HashSet<int>> x in hashGrp)
        {
          int len = x.Key;
          if (i + 1 < len) break;
          //calculating hash[j....i]
          int p_pow = power((int)p, i - len + 1, (int)m);

          int hashedValue = (i + 1 != len) ?
            ((hashedArr[i] - hashedArr[i - len]) / p_pow) :
          (hashedArr[i] / p_pow);

          // whether hash value of string of length len
          //exist in an array of strings 
          if (x.Value.Contains(hashedValue))
            count[i] += (i + 1 != len) ? count[i - len] : 1;
        }
      }
      //return answer
      return count[n - 1];
    }

    // Driver program to test above functions
    static void Main(string[] args)
    {
      // given string str
      string str = "abab";

      //set of strings
      List<string> dictionary = new List<string> { "a", "b", "ab" };

      Console.WriteLine(waysOfFormingString(str, dictionary));
    }
  }
}