举个例子来说明：
一个数5553141：他包含了2个1，1个3，1个4，3个5；
那么和起来写：21131435就是5553141的Inventory 数；
然后题目要求，给出一个数n( 最多80位)，他可以被归到如下四类：
1）n is self-inventorying（n用给出那个数代，下同）
即对给出的数，求出他的Inventory 数，如果是本身，则输出该行；
例如：31123314的Inventory数仍然是31123314，输出: 31123314 is self-inventorying
2) n is self-inventorying after j steps 
对一个数求他的Inventory 数，然后再对他的Inventory数继续求，如实我们可以得到一个序列：n[0]->n[1]->n[2]…n[j]…. 如此往复，当1<=j<=15时。如果n[j]的Inventory数等于他本身，则输出该行；
例如: 21221314 -> 31321314 -> (31321314)，输出: 21221314 is self-inventorying after 2 steps
3) n enters an inventory loop of length k 
仍然用n的序列说明: n[0]->n[1]->n[2]…n[j]…n[i]…. (0<=j<i<=15)，当n[i]的Inventory数(记作n[k]) 等于n[0]…n[i-1]的中n[j]时，那么很显然，再求下会形成一个循环；因此我们要找出是否存在最小(k>=1)使得n序列够成循环，输出这个k;
例如: 314213241519 --> 412223241519 -->314213241519，对应上述的n[j] --> n[i] -> (n[k]) 
4) n can not be classified after 15 iterations
如果在找出15个数后，没有满足上述的任何一条，那么就输出该行；

import java.util.*;
import java.io.*;

public class poj_1016{
    
    public static void main(String rgs[]) throws Exception
    {        
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        while(true){
            String s = cin.next();
            if(s.equals("-1"))
                break;
            String[] t = new String[16];
            int i;
            t[0]=s;
            for(i=0;i<15;i++){
                t[i+1] = change(t[i]);
                int res = Judge (t,i+1); //判断循环类型
                if(res==1 && i==0){
                    System.out.println(s+" is self-inventorying ");
                    break;
                }
                if(res==1){
                    System.out.println(s+" is self-inventorying after "+i+" steps ");
                    break;
                }
                if(res>0){
                    System.out.println(s+" enters an inventory loop of length "+res+" ");
                       break;
                }
            }
            if(i==15)
                System.out.println(s+" can not be classified after 15 iterations ");
        }
    }
    
    public static String change(String s){
        int i,n=s.length();
        int[] count=new int[10];
        String t="";
        Arrays.fill(count,0);
        for(i=0;i<n;i++)
            count[s.charAt(i)-'0']++;
        for(i=0;i<10;i++){
            if(count[i]>0)
                t+=String.valueOf(count[i])+String.valueOf(i);
        }        
        return t;
    }
    
    public static int Judge(String[] t,int ind){
        for(int i=0;i<ind;i++){
            if(t[ind].equals(t[i])){
                if(ind==i+1)
                    return 1;
                else 
                    return ind-i;
            }
        }
        return 0;
    }

}

【题意简述】求浮点数的n次幂。
【分析】高精度计算，运用Math.BigDecimal。
注意：
1.R的值并不一定是6位，也有可能是少于6位，但最多6位。如0.12、23什么的。
1.要包括R=0和n=0的情况。
3.因为是循环输入，所以，每次运算结束时记得要把存储空间清零。
4.小数点有三种位置可能：(1).123类型，小数点在最前面；(2)0.123类型，小数点在数字中间；(3)123.，小数点在数字的最后。
5.多余的零的存在，如 000012，000.02，0011.2，12.000，00.000，等都要考虑到。
6.输出格式。0.123应该是.123,123.应该是123 。

import java.util.*;
import java.io.*;
import java.math.*;

public class poj_1001{
    
    public static void main(String rgs[]) throws Exception
    {
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
            char[] c = Double.toString(in.nextDouble()).toCharArray();   
            BigDecimal bd = new BigDecimal(c);  
            int i,n,power = in.nextInt();
            BigDecimal result = bd.pow(power);  
            String s = result.toPlainString();
            n=s.length();            
            for(i=n-1;;i--)
                if(s.charAt(i) != '0')
                    break;
            if(s.charAt(i) == '.')
                i--;
            s=s.substring(0,i+1);
            if (s.charAt(0) == '0'){
                if(s.equals("0"))
                    System.out.println(0);
                else
                    System.out.println(s.substring(1));
            }
            else  
                System.out.println(s) ;    
        }
    }
}

【题意简述】输入一个整数，输出这个整数相邻的2个素数之间的长度，若该整数本身就是素数，则直接输出0。
【分析】素数选择法。

import java.util.*;
import java.io.*;

public class poj_3518{
    
    public static void main(String rgs[]) throws Exception
    {
        boolean[] prime=new boolean[1299710];
        Arrays.fill(prime,true);
        prime[1] = false;
        prime[0] = false;
        for(int i=2; i<=10000; ++i){
            if(prime[i])
                for (int j=i; i*j<1299710; ++j)
                    prime[i*j] = false;
        }
        int n, left, right;
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        n = cin.nextInt();
        while(n!=0){
            if(prime[n])
                System.out.println(0);
            else{
                right = left = n;
                while(!prime[--left]);
                while(!prime[++right]);
                System.out.println(right - left);                
            }
            n = cin.nextInt();
        }
    }
}