Longest Palindromic Substring using Palindromic Tree | Set 3

using System;

class PalindromicTree {
    const int MAXN = 1000;

    // Node structure
    struct Node
    {
        // Store start and end indexes of current Node
        // inclusively
        public int start, end;

        // Store length of substring
        public int length;

        // Store insertion Node for all characters a-z
        public int[] insertEdge;

        // Store the Maximum Palindromic Suffix Node for the
        // current Node
        public int suffixEdge;
    }

    // Two special dummy Nodes as explained above
    static Node root1, root2;

    // Store Node information for constant time access
    static Node[] tree;

    // Keep track of the current Node while insertion
    static int currNode;
    static string s;
    static int ptr;

    // Function to insert a character into the Palindromic
    // Tree
    static void Insert(int idx)
    {
        // STEP 1

        /* Search for Node X such that s[idx] X s[idx]
         * is the maximum palindrome ending at position idx.
         * Iterate down the suffix link of currNode to find
         * X. */
        int tmp = currNode;
        while (true) {
            int curLength = tree[tmp].length;
            if (idx - curLength >= 1
                && s[idx] == s[idx - curLength - 1])
                break;
            tmp = tree[tmp].suffixEdge;
        }

        /* Now we have found X...
         * X = string at Node tmp
         * Check: if s[idx] X s[idx] already exists or not
         */
        if (tree[tmp].insertEdge[s[idx] - 'a'] != 0) {
            // s[idx] X s[idx] already exists in the tree
            currNode = tree[tmp].insertEdge[s[idx] - 'a'];
            return;
        }

        // Creating a new Node
        ptr++;

        // Initializing the insertEdge array for the new
        // Node
        tree[ptr].insertEdge = new int[26];

        // Making the new Node as a child of X with weight
        // as s[idx]
        tree[tmp].insertEdge[s[idx] - 'a'] = ptr;

        // Calculating the length of the new Node
        tree[ptr].length = tree[tmp].length + 2;

        // Updating the end point for the new Node
        tree[ptr].end = idx;

        // Updating the start for the new Node
        tree[ptr].start = idx - tree[ptr].length + 1;

        // STEP 2

        /* Setting the suffix edge for the newly created
         * Node tree[ptr]. Finding some String Y such that
         * s[idx] + Y + s[idx] is the longest possible
         * palindromic suffix for the newly created Node. */

        tmp = tree[tmp].suffixEdge;

        // Making the new Node as the current Node
        currNode = ptr;
        if (tree[currNode].length == 1) {
            // If the new palindrome's length is 1,
            // making its suffix link to be a null string
            tree[currNode].suffixEdge = 2;
            return;
        }
        while (true) {
            int curLength = tree[tmp].length;
            if (idx - curLength >= 1
                && s[idx] == s[idx - curLength - 1])
                break;
            tmp = tree[tmp].suffixEdge;
        }

        // Now we have found string Y
        // Linking the current Node's suffix link with
        // s[idx]+Y+s[idx]
        tree[currNode].suffixEdge
            = tree[tmp].insertEdge[s[idx] - 'a'];
    }

    // Driver program
    static void Main()
    {
        // Initializing the tree
        root1.length = -1;
        root1.suffixEdge = 1;
        root1.insertEdge = new int[26];

        root2.length = 0;
        root2.suffixEdge = 1;
        root2.insertEdge = new int[26];

        tree = new Node[MAXN];
        tree[1] = root1;
        tree[2] = root2;
        ptr = 2;
        currNode = 1;

        // Given string
        s = "forgeeksskeegfor";
        int l = s.Length;

        for (int i = 0; i < l; i++)
            Insert(i);

        int maxx = 0;
        string result = "";

        for (int i = 3; i <= ptr; i++) {
            string res = "";
            for (int j = tree[i].start; j <= tree[i].end;
                 j++)
                res += s[j];
            if (res.Length > maxx) {
                maxx = res.Length;
                result = res;
            }
        }
        Console.WriteLine(result);
    }
}