Java实现的连续奇数(n+2*x)是合数的算法题暴力算法(2)

package com.test.test.zhihe;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 连续6个奇数a,a+2,a+4,a+6,a+8,a+10都是合数，求最小的a
 */
public class ZhishuTest {
 /**
 * 判断某个数是否是合数. 相较于质数
 * @param num
 * @return
 */
 public static boolean He(int num){
 // 平方根
 int sq = ((Double)Math.sqrt(num)).intValue();
 // 2 ...... sq
 for (int i = 2; i <= sq; i++) {
  int mo = num % i;
  if(0 == mo){
  return true;
  }
 }
 //
 return false;
 }

 /**
 * 主函数
 * @param args
 */
 public static void main(String[] args) {
 test();
 }
 public static void test() {
 // 开始时间
 long startMillis = System.currentTimeMillis();
 // 上次完成时间
 long preMillis = System.currentTimeMillis();
 // 本次完成时间
 long curMillis = System.currentTimeMillis();
 //
 int lianxu = 1000;
 int start = 1;
 int times = 1;
 for (int x = 1; x <= lianxu; x++) {
  if(times > x){
  continue;// 跳过,进入下一次循环
  } else {
  times = x;
  }
  List<Map<Integer, Integer>> resList = testTimesHe(x, start, false);
  //
  // 如果有数字,则进行处理
  if(null == resList || resList.isEmpty()){
  // 找不到，就不会再有下一个了...
  // 深层嵌套太恶心了。。。
  break;
  }
  int size = resList.size();
  // 遍历
  Iterator<Map<Integer, Integer>> iteratorR = resList.iterator();
  while (iteratorR.hasNext()) {
  Map<Integer, Integer> map = (Map<Integer, Integer>) iteratorR.next();
  //
  if(null != map && !map.isEmpty()){
   // Map遍历太恶心了.烂Java
   Set<Integer> keys= map.keySet();
   Iterator<Integer> iteratorK = keys.iterator();
   if(iteratorK.hasNext()){
   Integer key = iteratorK.next(); // 次数
   Integer value = map.get(key); // 最小n
   //
   // 本次完成时间
   curMillis = System.currentTimeMillis();
   //
   long allTimeout = curMillis - startMillis;
   long curTimeout = curMillis - preMillis;
   System.out.println(""+key+"次连续n="+value +",连续值个数: "+size +
    ";耗时: " + curTimeout + "ms,总计： "+allTimeout+"ms");
   // 处理数据,贪婪处理过的就不处理了
   if(key > 0 && value > 0){
    times = key+1;
    start = value;
   }
   }
  }
  }
  // 计入上次完成时间
  preMillis = System.currentTimeMillis();
 }
 //
 // 本次完成时间
 curMillis = System.currentTimeMillis();
 //
 long allTimeout = curMillis - startMillis;
 long curTimeout = curMillis - preMillis;
 System.out.println("本次已经跑完了,下一个值超出了100次 " +
  ";无用耗时: " + curTimeout + "ms,总计： "+allTimeout+"ms");
 }
 
 
 /**
 * 
 * 测试 times 次的+2都是合数的最小n
 * @param times 计算次数
 * @param start 起始数字
 * @param onlyStart 只计算单个start值.用于递归.外部调用应该传入
 * @return
 */
 public static List<Map<Integer, Integer>> testTimesHe(int times,int start, boolean onlyStart) {
 //
 List<Map<Integer, Integer>> resList= new ArrayList<Map<Integer, Integer>>();
 //
 // 防御式编程
 if(start < 1){
  return resList;
 }
 if(0 == start % 2){ // 不处理偶数
  return resList;
 }
 if(times < 1){
  times = 1;
 }
 //
 int result = -1;
 //
 for (int i = start; i < Integer.MAX_VALUE; i+=2) {
  //
  // 避免一直计算不返回
  if(onlyStart && i > start){ // start 不满足,就直接
  return resList;
  }
  for (int j = 0; j < times; j++) {
  int n = i + 2*j;
  //
  if(!He(n)){
   break;// 内层退出
  }
  //
  if(j+1 == times){
   // 跑到结果了. times 次都满足
   result = i;
   break;// 这里退不退无所谓,跑到for的最后了
  }
  }
  //
  if(result > 0){
  //
  //System.out.println("result = "+result);
  //
  Map<Integer, Integer> resMap = new HashMap<Integer, Integer>();
  resMap.put(times, result);
  resList.add(resMap);
  // 尝试下一个次数,递归; 其实这个递归还可以继续优化一点; 贪婪算法,直接加下一次。。。
  // startTimes, 直接加这个参数。。。贪婪递归?
  // 多1次,从result这个数开始
  int t = times +1;
  int s = result;
  List<Map<Integer, Integer>> nextList = testTimesHe(t, s, true);
  // 如果有下一层的数字,则加入到当前结果
  if(null != nextList && false==nextList.isEmpty()){
   resList.addAll(nextList);
  }
  
  //
  break;// 外层退出
  }
 }
 //
 return resList;
 }
}