hdu 1566 奇怪的公式 （Java大数输出结果）

详见代码，第一种在无法成连续递增子序列的情况下对3种情形分别讨论，第二种优化了3种情形讨论时的判断，减少了代码量嘿嘿。

import java.math.BigInteger;
import java.util.*;
public class Test {
    public static void main(String[] args) {
        Scanner sz = new Scanner(System.in);
        BigInteger res=null;
        while (sz.hasNext())
        {
            int n=sz.nextInt();
//           拎出2个从1开始的情况
            if(n<5)
            {
                if(n==3) System.out.println("2 1 2");
                else if(n==4) System.out.println("2 1 3");
                //输出结果
                System.out.println(n-1);
            }
//            边数>5时，开始从2枚举边数的长度
            else
            {
//              存储结果，累成鸡
                res=BigInteger.ONE;
                int ans=n;
                int index=2;
                while(index<=ans)
                {
                    ans-=index;
                    index++;
                }

//              正好可以为连续递增序列（20,27等），直接累乘输出即可
                if(ans==0)
                {
//                  输出边数
                    System.out.print(index-2);
                    for(int i=2;i<index;i++)
                    {
                        System.out.print(" "+i);
                        res=res.multiply(BigInteger.valueOf(i));
                    }
                    System.out.println();
                }
//              无法构成连续递增序列（21,39等)
/*
                分3种情况，ans<index-2， （剩余量不够分，（index-2）条边从后往前分配剩余量）
                ans=index-2,(剩余量够分，（index-2）条边加上增量 即可)
                ans>index-2  (（index-2）条边都加上增量，再从后往前依次分配剩余量)
                例如：   24 ans:4  index:7 add:0  end:4  则 2,4,5,6,7
                        25 ans:5  index:7 add:1  end:0  则 3,4,5,6,7
                        26 ans:6  index:7 add:1  end:1  则 3,4,5,6,8
*/
                else
                {
//                  System.out.println("ans:"+ans+"  index:"+index);
 //                 输出边数
                    System.out.print(index-2);
//                    每边需要的增量
                    int add=ans/(index-2);
//                    加完剩余的量
                    int end=ans%(index-2);

                    if(ans<index-2)
                    {
//                      前N项不需要加剩余量
                        int cnt=index-2-ans;
                        for(int w=2;w<index;w++)
                        {
                            if(cnt==0)
                            {
                                System.out.print(" "+(w+1));
                                res=res.multiply(BigInteger.valueOf(w+1));
                            }
                            else
                            {
                                System.out.print(" "+w);
                                res=res.multiply(BigInteger.valueOf(w));
                                cnt--;
                            }
                        }
                    }
                    else if(ans==index-2)
                    {
                        for(int w=2+add;w<=index;w++)
                        {
                            System.out.print(" "+w);
                            res=res.multiply(BigInteger.valueOf(w));
                        }
                    }
                    else
                    {
//                      前N项不需要加剩余量
                        int cnt=index-2-end;
                        for(int w=2+add;w<index+add;w++)
                        {
                            if(cnt==0)
                            {
                                System.out.print(" "+(w+1));
                                res=res.multiply(BigInteger.valueOf(w+1));
                            }
                            else
                            {
                                System.out.print(" "+w);
                                res=res.multiply(BigInteger.valueOf(w));
                                cnt--;
                            }
                        }
                    }
                    System.out.println();
                }
                System.out.println(res);
            }
        }
    }
}

import java.math.BigInteger;
import java.util.*;

public class Test {
    public static void main(String[] args) {
        Scanner sz = new Scanner(System.in);
        BigInteger res=null;
        while (sz.hasNext())
        {
            int n=sz.nextInt();
//           拎出2个从1开始的情况
            if(n<5)
            {
                if(n==3) System.out.println("2 1 2");
                else if(n==4) System.out.println("2 1 3");
                //输出结果
                System.out.println(n-1); 
            }
//            边数>5时，开始从2枚举边数的长度
            else
            {
//              存储结果，累成鸡
                res=BigInteger.ONE;
                int ans=n;
                int index=2;
                while(index<=ans)
                {
                    ans-=index;
                    index++;
                }

//              正好可以为连续递增序列（20,27等），直接累乘输出即可
                if(ans==0)
                {
//                  输出边数
                    System.out.print(index-2);
                    for(int i=2;i<index;i++)
                    {
                        System.out.print(" "+i);
                        res=res.multiply(BigInteger.valueOf(i));
                    }
                    System.out.println();
                }
//              无法构成连续递增序列（21,39等)
/*
                分3种情况，ans<index-2， （剩余量不够分，（index-2）条边从后往前分配剩余量）
                ans=index-2,(剩余量够分，（index-2）条边加上增量 即可)
                ans>index-2  (（index-2）条边都加上增量，再从后往前依次分配剩余量)
                例如：   24 ans:4  index:7 add:0  end:4  则 2,4,5,6,7
                        25 ans:5  index:7 add:1  end:0  则 3,4,5,6,7
                        26 ans:6  index:7 add:1  end:1  则 3,4,5,6,8
*/
                else
                {
//                   System.out.println("ans: "+ans+"  index: "+index);
//                   输出边数
                    System.out.print(index-2);
//                    每边需要的增量
                    int add=ans/(index-2);
//                    加完剩余的量
                    int end=ans%(index-2);

                    int j=2+add;
                    index+=add;

                    while(j<index-end)
                    {
                        System.out.print(" "+j);
                        res=res.multiply(BigInteger.valueOf(j));
                        j++;
                    }
                    j++;
                    while(j<=index)
                    {
                        System.out.print(" "+j);
                        res=res.multiply(BigInteger.valueOf(j));
                        j++;
                    }
                    System.out.println();
                }
                System.out.println(res);
            }
        }
    }
}