最小的回文数（java 实现）

最小的回文数

时间限制: 1 Sec 内存限制: 32 MB

题目描述

回文数是从前往后和从后往前得到的数是相同的。
现给你一个正整数N，请你找到比N大的最小的那个回文数P。

输入

输入包含多组测试数据。
每组输入一个正整数N，N不超过10000位，并且N不包含前导0。

输出

对于每组输入，输出比N大的最小的那个回文数P。

样例输入

44
3
175

样例输出

55
4
181

注意

正常情况下用 java 的时间应该是 c++ 的两倍的，但是，老师好像没有改时间，还是 1s 导致一些从c++改为 java 的代码超时了，当然也可能是服务器不太行的问题，学校 oj 跑不动啊，还有一堆奇怪的错误。
这道题不是很难，注意就是一些 java 的语法知识，给不会的同学提供一个思路，虽然写的复杂了点。

代码

import java.math.BigInteger;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String str = in.nextLine();
            int len = str.length();
            if (len == 1) {
                if (str.charAt(0) == '9') {
                    System.out.println("11");
                } else {
                    System.out.println((char) (str.charAt(0) + 1));
                }
                continue;
            }
            if (len % 2 == 1) {
                String pre = str.substring(0, len / 2);
                String back = str.substring(len / 2 + 1, len);
                String use = reverse1(pre);
                if (use.compareTo(back) > 0) {
                    System.out.println(pre + str.charAt(len / 2) + reverse1(pre));
                } else {
                    BigInteger bigInteger = new BigInteger(pre + str.charAt(len / 2));
                    int preLen = pre.length() + 1;
                    bigInteger = bigInteger.add(BigInteger.valueOf(1));
                    pre = String.valueOf(bigInteger);
                    if (pre.length() > preLen) {
                        pre = pre.substring(0, len / 2 + 1);
                        System.out.println(pre + reverse1(pre));
                    } else {
                        System.out.println(pre + reverse1(pre.substring(0, len / 2)));
                    }
                }
            } else {
                String pre = str.substring(0, len / 2);
                String back = str.substring(len / 2, len);
                String use = reverse1(pre);
                if (use.compareTo(back) > 0) {
                    System.out.println(pre + reverse1(pre));
                } else {
                    if (pre.charAt(len / 2 - 1) == '9') {
                        BigInteger bigInteger = new BigInteger(pre);
                        int preLen = pre.length();
                        bigInteger = bigInteger.add(BigInteger.valueOf(1));
                        pre = String.valueOf(bigInteger);
                        if (pre.length() > preLen) {
                            System.out.println(pre.substring(0, len / 2) + reverse1(pre));
                        } else {
                            System.out.println(pre + reverse1(pre));
                        }
                    } else {
                        if (len / 2 == 1) {
                            pre = String.valueOf((char) (pre.charAt(0) + 1));
                        } else {
                            pre = pre.substring(0, len / 2 - 1) + (char) ((pre.charAt(len / 2 - 1) + 1));
                        }
                        System.out.println(pre + reverse1(pre));
                    }
                }
            }
        }
    }
 
    public static String reverse1(String str) {
        return new StringBuffer(str).reverse().toString();
    }
}