题意

给你一个数字n（n < 10^1000)，将其拆成若干个回文串（不超过50个）输出拆分方案

分析

不难想到，我们可以每次给n减一个小于他的最大的回文串，这样能够尽量构造出最少数量的回文串，方法可以使直接将前一半反转贴到后一半，如果比原来的数字大，那么前一半减少1，再反转贴为后一半
比较坑的地方就是 如果构造出来的是11比n大， 那么前一半-1变成了00 ，特判一下，应该为9；如果构造出来是101比n大，应该特判为99

这个题没太多好讲的，我想在这里记录一下java编程心得，以后也会更新

主体框架

import java.util.*;
import java.lang.*;
import java.math.*;
import java.text.*;
import java.io.*;
public class Main
{
    public static void main(String[] args)  {
        try
        {
            Scanner cin = new Scanner(System.in);
                    //文件流
            //PrintWriter out = new PrintWriter(new FileWriter("output.txt"));
                //Scanner cin = new Scanner(new File("input.txt"));  
        }catch(Exception e ){

        }
        
        
    }
}

这里的类名,在提交到oj上时，一定要取为Main，但是本机运行的时候，一定要取为和文件名相同的名字，否则会CE

输入

int n = cin.nextInt(); //读入一个整数
BigInteger n = cin.nextBigInteger(); // 读入一个大整数
double n = cin.nextDouble(); // 读入一个浮点数
String n = cin.next(); // 读入一个字符串
while(n = cin.hasNextInt()){
...
}

这里看起来是很有规律可循的……
输入输出优化

输出

int n = 10;
System.out.print("n = "+n); //不换行
System.out.println("n = "+n);//换行

print 会输出
n = 10
println 会输出
n =
10

定义数据类型

单个变量感觉和c++ 差别不大
int 是基本数据类型 Integer 是int的包装类
基本数据类型，分为boolean、byte、int、char、long、short、double、float；
为了能够将这些基本数据类型当成对象操作，Java为每 一个基本数据类型都引入了对应的包装类型
比如排序需要自定义排序规则时，只能用包装类型
定义数组为

Type [] s = new Type [55];

以及使用BigInteger 方法将字符串转为BigInteger时

BigInteger n = new BigInteger(s,10);

第一个参数为字符串，第二个参数为相应进制，对这个new,我现在不是太理解

比较大小

这里需要明白compareTo 和 == 的区别
通俗来说 == 是强相等，必须等号两边是同一个对象（可以理解成地址相同）才会返回True
而a.compareTo(b) 只要a和b数值相等就返回True
具体的比较方法，如果该数据类型有定义比较规则，就按比较规则来，比如String按字典序，按数值大小
compareTo的返回值表示比较的结果，如果 a>b 返回正数，a 和b相等 返回 0 ,a<b 返回负数

字符串String的一些操作

具体可以查阅 String.
String不等同于char[] ,它的值在创建后就不能改变
char[] 转String

char data[] = {'a', 'b', 'c'};
String str = new String(data);

取String的下标为i到j的子串

String subs = s.substring(i,j+1);

取字符串s下标为i的字符

char c  = s.charAt(i);

比较两个字符串大小

s1.compareTo(s2);

BigInteger的一些操作

具体可以查阅 BigInteger
四则运算

a = a.add(b); // a+=b;
a = a.subtract(b); // a-=b
a = a.multiply(b); // a*=b;
a = a.divide(b); //a/=b;
a = a.remainder(b) ; // a%=b;

位运算

a = a.and(b); // a = a&b;
a = a.or(b); // a = a|b;
a = a.xor(b) // a = a^b;
a = a.shiftLeft(n) // a = (a<<n);
a = a.shiftRight(n) // a=(a>>n)

BigDecimal的一些操作

因为我还没用过BigDecimal,直接先扔链接
BigDecimal

shell操作

这里不算是将java知识点，在shell下运行java,标准读入以及文件读入,应该还比较好理解

javac name.java // 编译
java name // 运行，标准读入，标准输出
java name <data.in //运行，文件读入，标准输出
java name >data.out // 运行，标准读入，文件输出
java name <data.int >data.out // 运行，文件读入，文件输出

STL （Collections）

java中也有类似c++STL 的存在，是一个叫做Collections的class，东西太多，不是很熟悉，先丢链接
Collections
讲一下排序方法

• 以自然顺序（从小到大）排序

nt[] a = new int[15];
int n = cin.nextInt();
for(int i = 1;i<=n;i++) a[i] = cin.nextInt();
Arrays.sort(a,1,n+1); 

• 自定义顺序（从大到小）顺序

import java.io.*;
import java.lang.*; 
import java.util.*;
import java.math.*;
import java.text.*;
public class test
{
    public static void main(String[] args)
    {
        Scanner cin = new Scanner(System.in);
        Integer[] a = new Integer[15];
        int n = cin.nextInt();
        for(int i = 1;i<=n;i++) a[i] = cin.nextInt();
        Comparator <Integer> c = new Mycomparator();   // 实例化一个Comparator对象 
        Arrays.sort(a,1,n+1,c);
        for(int i = 1;i<=n;i++) System.out.print(a[i]+" ");
        System.out.println();
    }
}
class Mycomparator implements Comparator <Integer>  
{  
        public int compare(Integer x, Integer y)
        {  
          
            if(x > y) return -1;  
            if(x < y) return 1;  
            return 0;  
        }  
}

AC代码

import java.util.Scanner;
import java.math.*;
import java.text.*;
public class Main
{
    public static void main(String[] args)
    {
        Scanner cin = new Scanner(System.in);
        int T = cin.nextInt();
        String [] s = new String [55];
        for(int Case=1;Case<=T;Case++)
        {
            BigInteger n = cin.nextBigInteger();
            int ans = 0;
            while(ans < 50 && n.compareTo(BigInteger.valueOf(0))>0 )
            {
                String t = n.toString();
                int lenth = t.length();
                if(lenth == 1){
                    ans+=1;s[ans] = t;
                    break;
                }
                    String t1 = "";
                    String t2 = "";
                    int mid = lenth/2-1;
                    for(int i = 0;i<=mid;i++)
                        t2 += t.charAt(i);
                    t1 = t2;
                    if(lenth %2!=0) t1 += t.charAt(lenth/2);
                    for(int i = mid;i>=0;i--)
                        t1+=t2.charAt(i);
                    BigInteger m = new BigInteger(t1,10);
                    if(n.compareTo(m)<0)
                    {
                        if(t1.compareTo("11") == 0) t1 = "9";
                        else if(t1.compareTo("101") == 0) t1 = "99";
                        else{
                            m = new BigInteger(t2,10);
                            m = m.subtract(BigInteger.ONE);
                            if(m.compareTo(BigInteger.ZERO) == 0){
                                t1 = "";
                                t1 += t.charAt(lenth/2);
                            }
                            else{
                                t2 = "";
                                t2+=m.toString();
                                mid = t2.length()-1; 
                                t1 = t2;
                                if(lenth%2 != 0)
                                t1 += t.charAt(lenth/2);
                                for(int i = mid;i>=0;i--)   t1+=t2.charAt(i);
                            }
                        }
                    }
                //
                ans+=1;
                s[ans] = t1;
                m = new BigInteger(t1,10);
                n = n.subtract(m);
            }
            System.out.println("Case #"+Case+":");
                    System.out.println(ans);
                    for(int i = 1;i<=ans;i++) System.out.println(s[i]);
        }
    }
}