palindrome

package palindrome;

/*Problem Statement
    

A palindrome is a string that reads the same forward and backward.

A palindrome substring is a contiguous sequence of characters taken from a string that form a palindrome.

A palindrome substring of a string is maximal if we can't extend it to get a bigger palindrome substring.

For example, string "acdadc" has 2 maximal palindrome substrings - "a" (the first one) and "cdadc".

All other palindrome substrings (like "dad" or "c") can be extended to "cdadc", so they are not maximal.

You will be given a String[] str.

Concatenate the elements of str to form one long string, and return the number of maximal palindrome substrings contained in that string.

Definition
         
Class:     MaximalPalindromeSubstrings
Method:     countMaximalPalindromeSubstrings
Parameters:     String[]
Returns:     int
Method signature:     int countMaximalPalindromeSubstrings(String[] str)

(be sure your method is public)
    
Constraints
-     str will contain between 1 and 50 elements, inclusive.
-     Each element of str will contain between 1 and 50 characters, inclusive.
-     Each character of each element of str will be a lowercase letter ('a'-'z').
Examples
0)     {"acdadc"}    Returns: 2    The example from the problem statement.
1)     {"ababab"}    Returns: 2    The two maximal palindrome substrings here are "ababa" and "babab".
2)     {"aaaa","bbb","axxx"}    Returns: 3    Remember to use the whole input!
3)     {"abacabbacaacdbdcacxcbbbbcabababacccbazhhaahh"}    Returns: 14

This problem statement is the exclusive and proprietary property of TopCoder, Inc.
Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited.
(c)2003, TopCoder, Inc. All rights reserved. */

public class MaximalPalindromeSubstrings {

    
    public static int countMaximalPalindromeSubstrings(String[] str) {
        
        int length = 0;
        for(int i = 0; i < str.length; i++) {
            length = length + str[i].length();
        }
        
        char[] array = new char[length];
        
        int p = 0;
        for(int i = 0; i < str.length; i++) {
            char[] tempArray = str[i].toCharArray();
            for(int j = 0; j < tempArray.length; j++) {
                array[p] = tempArray[j];
                p++;
            }
        }
        
        p = 0;
        while(p<length) {
            int index = 0;
            while(p - index >=0 && p + index < length) {
                if(array[p - index] == array[p + index]) index++;
                else break;
            }
            index--;
            save(p - index, p + index);
            
            index = 0;
            if((p + 1 < length) && (array[p] == array[p + 1])) {
                while(p - index >=0 && p + 1 + index < length) {
                    if(array[p - index] == array[p + 1 + index]) index++;
                    else break;
                }
                index--;
                save(p - index, p + 1 + index);
            }
            p++;
        }

        print(array);
        return root -1;
    }
    
    
    // Stack for the result storage.
    private static Pair[] result = new Pair[100];
    
    private static int root = 0;
    
    static class Pair {
        int start = 0;
        int end = 0;
        
        Pair(int i, int j) {
            start = i;
            end = j;
        }
    }
    
    /*
     * Check if there is a larger ranger or smaller range.
     * Erase the smaller range if needed.
     */
    private static void save(int i, int j) {
        if(root == 0) {
            Pair pair = new Pair(i, j);
            result[0] = pair;
            root++;
        }
        else {
            int cursor = root - 1;
            
            if (result[cursor].start <= i && result[cursor].end >= j) return;
            
            while(cursor >= 0) {
                if(result[cursor].start >= i && result[cursor].end <= j) {
                    cursor--;
                    result[root - 1] = null;
                    root--;    
                }
                else break;
            }
            
            Pair pair = new Pair(i, j);
            result[root] = pair;
            root++;
            
        }
    }
    
    /*
     * print the result out.
     */
    private static void print(char[] array) {
        for(int i = 0; i < root; i++) {
            for(int j = result[i].start; j <= result[i].end; j++) {
                System.out.print(array[j]);
            }
            System.out.print("/n");
        }
    }
}




public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        try {
            
            String[] a = {"aaaa","bbb","axxx"};
            String b = "abacabbacaacdbdcacxcbbbbcabababacccbazhhaahh";
            MaximalPalindromeSubstrings.countMaximalPalindromeSubstrings(new String[]{b});
        } catch(Exception e) {
            e.printStackTrace();
        }

    }
}