华为OJ——尼科彻斯定理

题目描述

　　验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
　　例如：
　　1^3=1
　　2^3=3+5
　　3^3=7+9+11
　　4^3=13+15+17+19

• 接口说明
  原型：

  /*
  功能: 验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
  原型：
  int GetSequeOddNum(int m,char * pcSequeOddNum);
  输入参数：
  int m：整数(取值范围：1～100)

  返回值：
  m个连续奇数(格式：“7+9+11”);
  */
  public String GetSequeOddNum(int m)
  {
  /在这里实现功能/
  return null;
  }

• 输入描述:
  输入一个int整数

• 输出描述:

  输出分解后的string

• 示例1
  输入
  　　6
  输出
  　　31+33+35+37+39+41

实现代码：

• 思路：
  找数学规律：对于整数n,满足条件的连续n个奇数，其初始值为n*(n-1)+1

package cn.c_shuang.demo66_1;

import java.util.Scanner;
/**
 * 尼科彻斯定理
 * @author Cshuang
 *
 */
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
            int n=in.nextInt();
            int st=n*n-n+1;//初始值为n*(n-1)+1
            for(int i=0;i<n-1;i++){
                System.out.print(st+"+");
                st+=2;
            }
            System.out.println(st);
        }
        in.close();
    }
}

• 另外方法
  考虑递归迭代查找：对于n相对较小只有几十的时候（不超过20）还能正常查找，但是一旦超过会出现Exception in thread “main” java.lang.StackOverflowError，即栈溢出的情况。但是这种递归的思想还是值得参考的。

package cn.c_shuang.demo66;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
 * 尼科彻斯定理
 * @author Cshuang
 *
 */
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
            int n=in.nextInt();
            Long sum=(long) (n*n*n);
            int init=1;//初始递归的第一个值
            int index=1;//每次递归一种可能的第一个值
            List<Integer> result=new ArrayList<Integer>();
            caculate(init,index,n,sum,result);
        }
            in.close();
    }

    private static void caculate(int init,int index,int n,Long sum, List<Integer> result) {
        result.add(index);
        sum-=index;
        if(sum==0&&result.size()==n){//说明找到符合条件的可能
            for (int i = 0; i < result.size(); i++) {
                if(i<result.size()-1)
                    System.out.print(result.get(i)+"+");
                else
                    System.out.println(result.get(i));
            }
            return;
        }else if(sum<index){//只要出现最终sum小于当前的值，说明该种索引不成功，换一个，但是在换的时候，得恢复现场
            result.clear();//清空result里面的有效值
            sum=(long) (n*n*n);//还原sum
            init+=2;//将初始的init+2
            index=init;//在将init赋值给index
        }else
            index+=2;//每次的索引都得+2，因为数是连续的
        caculate(init,index,n,sum,result);
    }
}