Найти наибольший палиндром, который получится в результате произведения двух чисел

public class Palindrome {
 
    int findMax(int n) {
        
        int number = (int) Math.pow(10, n) - 1;
        int length = String.valueOf(number).length();
        int max = 0;
        
        for (int j = number; j > 0; j--) {
            long res = number * j;
            int l = String.valueOf(res).length();
            String strnumber = String.valueOf(res);
            int k = 0, count = 0;
            for (; k < l / 2; k++) 
                if (strnumber.charAt(k) == strnumber.charAt(l - k - 1)) count++;
            
            if (count == k) {
                max = Integer.parseInt(strnumber);
                break;
            } 
        }
        return max;
        
    }
    
    public static void main(String[] args) {
        Palindrome p = new Palindrome();
        System.out.println(p.findMax(4));
    }
}

public class Palindrome {
 
    long findMax(int n) {
        
        //узнаем самое большое n-циферное число так,
        //что возведем в n-ую степень 10 и отнимем 1.
        long number = (long) Math.pow(10, n) - 1;
 
        for (long j = number; j > 0; j--) { //цикл начинаем от самого большого n-циферного числа
            long res = number * j; //переумножаем самое большое n-цифреное и пришедшее число в цикле
            int l = String.valueOf(res).length(); //берем длину числа, которое получили в результате умножения
            String strnumber = String.valueOf(res); //int переводим в String
            int k = 0, count = 0;
            for (; k < l / 2; k++) //стандартный цикл для палиндромов
                if (strnumber.charAt(k) == strnumber.charAt(l - k - 1)) count++; //сравниваем первые и поселедний знак в числе,
                                                                                 //второе и предпоследний и т.д.
                                                                                 //count - обычный счетчик. Узнаем, сколько пар в числе между собой равны.
            if (count == k) return Long.parseLong(strnumber);  //если count равен количеству элементов, которое сравнивали 
        }
        return 0;
    }
    
    public static void main(String[] args) {
        Palindrome p = new Palindrome();
        System.out.println(p.findMax(5));
    }
}

class Euler4 {
    public static void main(String[] args) {
        int n;                                  //число палиндром
        int nl;                 //длина числа палиндрома
        int nMod;               //на что делим
        int diff;               //разница
        int degMult;                //степень
        int newN;
        string st;
        max=0;              
        for (int i=100; i<1000; i++) {
            for (int j=100; j<1000; j++) {
                n=i*j;                      //Произведение трёхзначных чисел
                newN=0;                     //Перевёрнутое число
                nMod=10;                    //Делитель кратный 10
                diff=0;                     //разница
                nl=(string st = String.valueof(n)).length;      //определяем длину n             
                degMult=nl-1;                   //Степень умножения
                for (int x=0; x<nl; x++) {          //Цикл для построение перевёрнутого числа
                    newN+=(n%nMod-diff)*(10^(degMult)); 
                    diff=n%nMod;                
                    nMod=nMod*10;
                    degMult-=2;                     
                }
                if (newN=n & n>max) max=n;          //проверка на палиндромность и максимальность
                                            
            }
        }
    }
}

public class Palindrome {
    class StackLong{
        long[] arr;
        int m = -1;
        public StackLong(int i){
            arr = new long[i];
        }
        public void push(long a){
            arr[++m] = a;
        }
        public long pop(){
            return arr[m--];
        }
        public boolean isEmpty(){
            if (m==-1)
                return true;
            else
                return false;
        }
        public int getSize(){
            return m+1;
        }
    }
 
 
    public boolean checkPalindrome(long a){
        String palindrome = Long.toString(a);
        StringBuilder reverse = new StringBuilder(palindrome).reverse();
        String reversepal = String.valueOf(reverse);
        if(palindrome.equals(reversepal))
            return true;
        else
            return false;
    }
 
 
    public long findMax(int n){
        int dec = 10;
        long number = 1;
        for(int j = n; j > 0; j--){
            number *=dec;
        }
        long consta = 1;
        for(int j = n-1; j > 0; j--){
            consta *=dec;
        }
        number--; //понижение переменной до максимально вожможного n-значного числа
 
        long res = 1;
        //StackLong stack1 = new StackLong((int) (number-1));
        //System.out.println(stack1.pop());
        //StackLong stack2 = new StackLong((int) (number-1));
        long[] arr = new long[(int)number-1];
 
        long maxmul = number*number;
 
        foo:
        for(long outer_number_2 = number;outer_number_2 >=consta;outer_number_2--){
            long outer_number_1 = number;
            long maxmulouter = outer_number_1 * outer_number_2;
            long maxmulinner = 0;
 
            long inner_number_1_mminner = 0;
            long inner_number_2_mminner = 0;
 
            if(checkPalindrome(maxmulouter)){
                res = maxmulouter;
                System.out.println(outer_number_1 + " " + outer_number_2);
                break foo;
            }
 
            if(maxmulouter < maxmul){
                //aaaSystem.out.println(outer_number_1 + "*" + outer_number_2 + " = " + maxmulouter + "<" + maxmul + " = true");
                int counter = 0;
 
                foo2:
                for(long inner_number_1 = number-1;inner_number_1>=outer_number_2;inner_number_1--){
                    if(arr[((int) (inner_number_1 - 1))] == 0){
                        arr[((int) inner_number_1-1)] = inner_number_1;
                    }
                    //System.out.println(arr[((int) inner_number_1-1)]);
 
                    long inner_number_2 = arr[((int) inner_number_1-1)];
 
                    long tempmminner = inner_number_1*inner_number_2;
 
                    if(checkPalindrome(tempmminner)){
                        res = tempmminner;
                        System.out.println(inner_number_1 + " " + inner_number_2);
                        break foo;
                    }
 
                    if(tempmminner < maxmul){
                        if(maxmulinner<tempmminner){
                            maxmulinner = tempmminner;
                            inner_number_1_mminner = inner_number_1;
                            inner_number_2_mminner = inner_number_2;
                        }
                        //System.out.println(inner_number_1 + "*" + inner_number_2 + " = " + maxmulinner + "<" + maxmul + " = true");
                    } else {
                        arr[((int) (inner_number_1 - 1))] = --inner_number_2;
                        inner_number_1++;
                        //System.out.println(inner_number_1 + "*" + inner_number_2 + " = " + maxmulinner + "<" + maxmul + " = false");
                    }
                }
                if(maxmulouter > maxmulinner){
                    maxmul = maxmulouter;
                } else {
                    maxmul = maxmulinner;
                    arr[((int) (inner_number_1_mminner - 1))] = inner_number_2_mminner - 1;
                    outer_number_2++;
                }
            } else {
                //aaaSystem.out.println(outer_number_1 + "*" + outer_number_2 + " = " + maxmulouter + "<" + maxmul + " = false");
            }
            //aaaSystem.out.println(maxmul);
        }
        return res;
    }
    public static void main(String[] args){
        Palindrome a = new Palindrome();
        System.out.println(a.findMax(5));
    }
}

import java.util.*;
 
/**
 * Created by GoldenMelon on 26.06.2015.
 */
public class Palindrome {
    Comparator<Node> comparator = new NodeComparator();
    PriorityQueue<Node> queue = new PriorityQueue<>(comparator);
    Palindrome(){
 
    }
    public boolean checkPalindrome(long a){
        String palindrome = Long.toString(a);
        StringBuilder reverse = new StringBuilder(palindrome).reverse();
        String reversepal = String.valueOf(reverse);
        if(palindrome.equals(reversepal))
            return true;
        else
            return false;
    }
    public void findMax(int n){
        int dec = 10;
        long number = 1;
        for(int j = 0; j < n; j++){
            number *=dec;
        }
        number--; //понижение переменной до максимально вожможного n-значного числа
        queue.add(new Node(true,number,number,number*number));
        while(!checkPalindrome(queue.peek().productOfMul)){
            Node temp = queue.poll();
            temp.secondMul = temp.secondMul-1;
            temp.productOfMul = temp.firstMul * temp.secondMul;
            if(temp.enterFirst){
                if((temp.firstMul-temp.secondMul == 2)){
                    temp.enterFirst = false;
                    queue.add(new Node(true,temp.firstMul-1,temp.firstMul-1,(temp.firstMul-1)*(temp.firstMul-1)));
                }
            }
            queue.add(temp);
        }
        System.out.println(queue.peek().productOfMul);
        System.out.println(queue.peek().firstMul + " " + queue.peek().secondMul);
    }
    public static void main(String[] args) {
 
        Palindrome pl = new Palindrome();
        pl.findMax(9);
    }
    static class NodeComparator implements Comparator<Node>{
 
        @Override
        public int compare(Node o1, Node o2) {
            if(o1.productOfMul < o2.productOfMul){
                return 1;
            }
            if(o1.productOfMul > o2.productOfMul){
                return -1;
            }
            return 0;
        }
    }
}
class Node{
    boolean enterFirst = true;
    long firstMul;
    long secondMul;
    long productOfMul;
    public Node(boolean e,long f,long s, long p){
        enterFirst = e;
        firstMul = f;
        secondMul = s;
        productOfMul = p;
    }
}