package main.com.lift;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.junit.Test;
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
public class MatchTitle {
//存放各种上楼方式组合、
public static List> makeupList= Lists.newArrayList();
//存放每个人要去的楼层
public static List postionList=Lists.newArrayList();
//存放多人占坑方式组合
public static List>> zhankengList=Lists.newArrayList();
public static void main(String[] args) {
int n=3;//楼层数
int m=4;//电梯数
int peopleNum=100;//人数
List>> l1=Lists.newArrayList();
for(int i=1;i<=n;i++){
forTop(i);//到达顶层组合算法
l1.add(makeupList);
}
List> oneLiftCombin=Lists.newArrayList();
l1.forEach(item ->{
oneLiftCombin.addAll(item);
});
zhankeng(m,oneLiftCombin);//占坑组合
Map>,Double> result= Maps.newHashMap();
BaseDao baseDao=new BaseDao();
MatchTitle matchTitle=new MatchTitle();
LinkedBlockingQueue queue=matchTitle.peopleAndNumPosition(peopleNum,n);//生成等电梯的人的排队序列
for(int i=0;i> newlj=convert(zhankengList.get(i));//将每次上的楼层个数改成楼层数
if(iscontainAllNum(newlj,n)){
//首先判断电梯组合是不是包含了所有楼层
continue;
}
//*********************************************执行每种电梯组合的运行时间**********************************************
LinkedBlockingQueue queue2=new LinkedBlockingQueue<>();//生成等电梯的人的排队序列
queue2.addAll(queue);
ExecuteRun executeRun=new ExecuteRun();
double resulttime=0;
try{
resulttime=executeRun.runanswer(newlj,queue2);
}catch (Exception e){
e.printStackTrace();
}
//一边循环一边保存
baseDao.save(newlj.toString(),resulttime);
result.put(newlj,resulttime);
System.gc();
}
System.out.println("");
result.forEach((k,v)->{
System.out.println(k+" : "+v);
});
//根据value排序
Map>,Double> resultSort=sortMapByValue(result);
System.out.println(resultSort.get(0));
};
@Test
public void alone(){
int peopleNum=2000;
int m=26;
Map>,Double> result=Maps.newHashMap();
BaseDao baseDao=new BaseDao();
MatchTitle matchTitle=new MatchTitle();
LinkedBlockingQueue queue=matchTitle.peopleAndNumPosition(peopleNum,m);//生成等电梯的人的排队序列
String one="[[1,3,5,7,9,11,13,15,17,19,21,23,25],[2,4,6,8,10,12,14,16,18,20,22,24,26]]";
String two="[[1,2,3,4,5,6,7,8,9,10,11,12,13],[14,15,16,17,18,19,20,21,22,23,24,25,26]]";
List onelist= JSON.parseArray(one);
List twolist=JSON.parseArray(two);
List>> lTest=Lists.newArrayList();
lTest.add(onelist);
lTest.add(twolist);
for(int i=0;i> newlj=lTest.get(i);//将每次上的楼层个数改成楼层数
if(!iscontainAllNum(newlj,m)){
//首先判断电梯组合是不是包含了所有楼层
continue;
}
//*****************************************执行每种电梯组合的运行时间******************************************
LinkedBlockingQueue queue2=new LinkedBlockingQueue<>();//生成等电梯的人的排队序列
queue2.addAll(queue);
ExecuteRun executeRun=new ExecuteRun();
double resulttime=0;
try{
resulttime=executeRun.runanswer(newlj,queue2);
}catch (Exception e){
e.printStackTrace();
}
//一边循环一边保存
// baseDao.save(newlj.toString(),resulttime);
result.put(newlj,resulttime);
System.gc();
}
System.out.println("");
result.forEach((k,v)->{
System.out.println(k+" : "+v);
});
//根据value排序
Map>,Double> resultSort=sortMapByValue(result);
}
/**
* 从一次上一层楼，两层，三次，n层一次迭代，得出所有情况的由底层到达顶层的上电梯组合方式
* @param n
*/
public static void forTop(int n){
for(int i=1;i<=n;i++){
int num=n-i;
List lists=Lists.newArrayList();
lists.add(i);
boolean flag=true;
if(num>0){
flag=false;
forNotTop(num,lists);
}
if(flag)makeupList.add(lists);
}
}
public static void forNotTop(int n,List lists){
List list=Lists.newArrayList();
list.addAll(lists);
//循环本次余下楼层可能的组合方式
for(int i=1;i<=n;i++){
int num=n-i;
lists.add(i);
//flag是true的话，说明刚好在本次循环的楼层中达到了顶层
boolean flag=true;
//num==0 说明到达了顶层，不要继续往下迭代
if(num>0){
flag=false;
forNotTop(num,lists);
}
//体现flag的作用，排除递归中的重复元素，只把本次循环到达顶层的情况加入到总的list
if(flag)makeupList.add(list);
//使用存放的临时上级数据，继续迭代本次循环的其他情况
lists=Lists.newArrayList();
lists.addAll(list);
}
}
/**
* 占坑组合
* @param m
* @param lm
*/
public static void zhankeng(int m,List> lm){
int b=m;
for(int i=0;i> lists=Lists.newArrayList();
lists.add(lm.get(i));
//当前的人所有情况是否完成
boolean flag=true;
//当前人与其他人的组合情况是否结束，没有结束就进入到字方法中循环其他人的
if(m>0){
flag=false;
zhankengson(m,lm,lists);
}
if(false)zhankengList.add(lists);
m=b;
}
}
public static void zhankengson(int i,List> lm,List> lists){
//创建临时变量，存储上次循环的情况，以便于下一个的多有情况组合
List> list=Lists.newArrayList();
list.addAll(lists);
int b=i;
for(int j=0;j0){
flag=false;
zhankengson(i,lm,lists);
}
if(flag)zhankengList.add(lists);
//使用存放的临时上级数据，继续迭代本次循环的其他情况
lists=Lists.newArrayList();
lists.addAll(list);
}
}
/**
* //如将[[1,1,1,1],[1,1,2],[1,2,1],[1,3],[2,1,1],[2,2],[3,1],[4]
* //改成[[1,2,,3,4],[1,2,4],[1,3,4],[1,4],[2,3,4],[2,4]
* @param l1
* @return
*/
public static List> convert(List> l1){
List> resultlist=Lists.newArrayList();
for(int i=0;i l2=l1.get(i);
List ltmp=Lists.newArrayList();
int tmp=0;
for(int j=0;j> produceElem,int n){
List allNum=Lists.newArrayList();
for(List int1:produceElem){
for(Integer int2:int1){
allNum.add(int2);
}
}
allNum=Lists.newArrayList(new TreeSet(allNum));
if(allNum.size()>,Double> sortMapByValue(Map>,Double> result){
Map>,Double> sortedMap=Maps.newLinkedHashMap();
List>,Double>> entryList=Lists.newArrayList(result.entrySet());
Collections.sort(entryList, new Comparator>, Double>>() {
@Override
public int compare(Map.Entry>, Double> o1, Map.Entry>, Double> o2) {
return o1.getValue().compareTo(o2.getValue());
}
});
Iterator>,Double>> iterator=entryList.iterator();
Map.Entry>,Double> tmpEntry=null;
while(iterator.hasNext()){
tmpEntry=iterator.next();
sortedMap.put(tmpEntry.getKey(),tmpEntry.getValue());
}
return sortedMap;
}
/**
* 随机生成人的个数，以及每个人所属的楼层
* @param m
* @param n
* @return
*/
public LinkedBlockingQueue peopleAndNumPosition(int m,int n){
LinkedBlockingQueue queue=new LinkedBlockingQueue<>();
for( int i=0;i
