字符串与大数处理之”Ugly Problem“

Everyone hates ugly problems. 
You are given a positive integer. You must represent that number by sum of palindromic numbers. 
A palindromic number is a positive integer such that if you write out that integer as a string in decimal without leading zeros, the string is an palindrome. For example, 1 is a palindromic number and 10 is not.

Input

　　In the first line of input, there is an integer T denoting the number of test cases.

　　For each test case, there is only one line describing the given integer s (1≤s≤10^1000).

Output

　　For each test case, output “Case #x:” on the first line where x is the number of that test case starting from 1. Then output the number of palindromic numbers you used, n, on one line. n must be no more than 50. Then output n lines, each containing one of your palindromic numbers. Their sum must be exactly s.

Sample Input

　　2

　　18

　　1000000000000

Sample Output

　　　　Case #1: 2

　　　　9

　　　　9

　　　　Case #2:2

　　　　999999999999

　　　　1

Hint

　　　　9 + 9 = 18

　　　　999999999999 + 1 = 1000000000000

题目大意：给你一个不超过1000位的整数，将其分解成若干个回文数，总数不超过50个。

解题思路：取字符串的前一半，减一，翻转过去，大数减小数，循环上述过程直到小于20。

　　　　　小于20的时候进行特判

　　　　　　　　　　　　　　　　　12到19拆成　　11 + x

　　　　　　　　　　　　　　　　　11不动

　　　　　　　　　　　　　　　　　10拆成　　　 　1 + 9

　　　　　　　　　　　　　　　　　小于10不动

　　　　　注意不要把”0“算进去

　　　　　等于20的情况不需要特判，因为20还在while里面继续循环成11+9，然后9这个数才会从while里出来。

　　　　　如： 9657932　　取9657　　变成9656　　翻转为9656569　　再用9657932-9656569　　循环下去即可

AC代码：

import java.util.*;
import java.lang.Math;
import java.math.BigInteger; 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        String enter = sc.nextLine();
        BigInteger one = new BigInteger("1");
        BigInteger zero = new BigInteger("0");
        BigInteger twenty = new BigInteger("20");
        int k = 1;
        while(t > 0){
            String in = sc.nextLine();
            int sum = 0;
            String out[] = new String[50];
            int index = 0;int flag = 0;
            BigInteger inn = new BigInteger(in);
            while((inn.subtract(twenty)).compareTo(zero) != -1){
                if(in.length() % 2 == 1){
                    int l = in.length();
                    String sub = in.substring(0,l/2 + 1);
                    
                    BigInteger bi = new BigInteger(sub);
                    bi = bi.subtract(one);
                    if((String.valueOf(bi)).length() != (l/2)+1){flag = 1;}
                    
                    StringBuffer b1 = new StringBuffer(String.valueOf(bi));
                    StringBuffer b2 = new StringBuffer(String.valueOf(bi));
                    if(flag == 0){b2.deleteCharAt(l/2);flag = 0;}
                                        
                    b1 = b1.append(b2.reverse());
                    out[index] = String.valueOf(b1);index ++;sum ++;
                    
                    BigInteger tt = new BigInteger(String.valueOf(b1));
                    inn = inn.subtract(tt);
                    in = String.valueOf(inn);
                    
                }
                else{
                    int l = in.length();
                    String sub = in.substring(0,l/2);
                    
                    BigInteger bi = new BigInteger(sub);
                    bi = bi.subtract(one);
                    StringBuffer b1 = new StringBuffer(String.valueOf(bi));
                    StringBuffer b2 = new StringBuffer(String.valueOf(bi));
                    b1 = b1.append(b2.reverse());
                    out[index] = String.valueOf(b1);index ++;sum ++;
                    
                    BigInteger tt = new BigInteger(String.valueOf(b1));
                    inn = inn.subtract(tt);
                    in = String.valueOf(inn);
                    
                }    
            }
            int last = Integer.valueOf(in);
            if(last <= 19 && last >= 12){
                out[index] = "11";index ++;
                int te = last - Integer.valueOf("11");
                out[index] = String.valueOf(te);index ++;
                sum = sum + 2;
            }
            else if(last == 11){out[index] = "11";index ++;sum ++;}
            else if(last == 10){out[index] = "9";index ++;out[index] = "1";index ++;sum = sum + 2;}
            else if(last >= 1 && last <= 9){out[index] = String.valueOf(last);index ++;sum ++;}
            System.out.println("Case #" + k + ":");System.out.println(sum);
            for(int i = 0;i < index;i ++){
                System.out.println(out[i]);
            }
            k ++;t --;
        }
    }
}

一开始将题意理解为有10^1000那么长的字符串，以为用不了substring()；浪费了好长时间。。。

奇数的if里面有个flag，是判断是不是取半后出现了10000-1=9999类似的情况，有的话就出大问题了。

偶数就没有这种问题，我试了下，1000 = 898 + 3 + 99，就不会是 999 + 1。。。

当然可以加上flag，却会更麻烦，因为偶数长度变成了奇数长度，还得删去一个字符再反转，所以没有加flag判断。。。

下面稍作讲解java大整数类（BigInteger类）以及StringBuffer在本题中出现的方法

　　　　BigInteger类：要使用　　import java.math.BigInteger; 

　　　　　　声明：大整数类不能像int型声明并赋初值（int i = 1;），要使用　　BigInteger x = new BigInteger(str);　　这种方法。

　　　　　　比较：大整数类也不能用符号比较，只能用类似比较字符串的方法来比较，如出现在19行的　　while((inn.subtract(twenty)).compareTo(zero) != -1)

　　　　　　　　　if(a.compareTo(b) == -1) 　　=> a < b
　　　　　　　　　if(a.compareTo(b) == 0) 　　 => a == b
　　　　　　　　　if(a.compareTo(b) == 1)　　  => a > b

　　　　　　运算：

　　　　　　　　　a.add(b) 　　　　　　大整数加法

　　　　　　　　　a.subtract(b)　　　　 大整数减法

　　　　　　　　　a.multiply(b) 　 　　　大整数乘法

　　　　　　　　　a.divide(b)　　　　　 大整数除法(取整)

　　　　　　　　　a.remainder(b)　　　 大整数取模

　　　　StringBuffer类：

　　　　　　声明：和大整数类有些相似，在括号里放入初值　　StringBuffer x = new StringBuffer(str);　　但是StringBuffer无法使用‘+’这种运算符运算。

　　　　　　字符串反转：　　　　x.reverse();　　

　　　　　　字符串追加：　　　　x.append(str);

　　　　　　按索引删除字符：　　x.deleteCharAt(index);

　　　　要注意的是，这些StringBuffer的方法都会返回到本身，因此语句执行后，这个字符串就会改变。

　　　　我们用一个小的示例程序来说明：

import java.util.*;

public class Main{
    public static void main(String[] args){
        String str1 = "aaabbb";
        String str2 = str1 + "ccc";
        System.out.println("str1: " + str1);
        System.out.println("str2: " + str2);
        StringBuffer stb1 = new StringBuffer(str1);
        StringBuffer stb2 = new StringBuffer(str1);
        StringBuffer stb3 = new StringBuffer(str1);
        stb2 = stb2.append(stb1.reverse());
        System.out.println("stb1: " + stb1);
        System.out.println("stb2: " + stb2);
        stb3 = stb3.append(stb1.deleteCharAt(2));
        System.out.println("stb1: " + stb1);
        System.out.println("stb2: " + stb2);
        System.out.println("stb3: " + stb3);
    }
}

//output

//str1: aaabbb
//str2: aaabbbccc

//stb1: bbbaaa
//stb2: aaabbbbbbaaa

//stb1: bbaaa
//stb2: aaabbbbbbaaa
//stb3: aaabbbbbaaa

　　　　从示例中我们可以看出，进行操作后str1没有改动，但是stb1却一直发生变化。