MatchTitle 主程序入口

MatchTitle 主程序入口MatchTitle 主程序入口

大家好,又见面了,我是你们的朋友全栈君。

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<List<Integer>> makeupList= Lists.newArrayList();
    //存放每个人要去的楼层
    public static List<Integer> postionList=Lists.newArrayList();
    //存放多人占坑方式组合
    public static  List<List<List<Integer>>> zhankengList=Lists.newArrayList();

    public static void main(String[] args) {
        int n=3;//楼层数
        int m=4;//电梯数
        int peopleNum=100;//人数
        List<List<List<Integer>>> l1=Lists.newArrayList();
        for(int i=1;i<=n;i++){
            forTop(i);//到达顶层组合算法
            l1.add(makeupList);
        }
        List<List<Integer>> oneLiftCombin=Lists.newArrayList();
        l1.forEach(item ->{
            oneLiftCombin.addAll(item);
        });
        zhankeng(m,oneLiftCombin);//占坑组合
        Map<List<List<Integer>>,Double> result= Maps.newHashMap();
        BaseDao baseDao=new BaseDao();
        MatchTitle matchTitle=new MatchTitle();
        LinkedBlockingQueue<Integer> queue=matchTitle.peopleAndNumPosition(peopleNum,n);//生成等电梯的人的排队序列
        for(int i=0;i<zhankengList.size();i++){
            List<List<Integer>> newlj=convert(zhankengList.get(i));//将每次上的楼层个数改成楼层数
            if(iscontainAllNum(newlj,n)){
                //首先判断电梯组合是不是包含了所有楼层
                continue;
            }
            //*********************************************执行每种电梯组合的运行时间**********************************************
            LinkedBlockingQueue<Integer> 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<List<List<Integer>>,Double> resultSort=sortMapByValue(result);
        System.out.println(resultSort.get(0));
    };

    @Test
    public void alone(){
        int peopleNum=2000;
        int m=26;
        Map<List<List<Integer>>,Double> result=Maps.newHashMap();
        BaseDao baseDao=new BaseDao();
        MatchTitle matchTitle=new MatchTitle();
        LinkedBlockingQueue<Integer> 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<List<List<Integer>>> lTest=Lists.newArrayList();
        lTest.add(onelist);
        lTest.add(twolist);
        for(int i=0;i<lTest.size();i++){
            List<List<Integer>> newlj=lTest.get(i);//将每次上的楼层个数改成楼层数
            if(!iscontainAllNum(newlj,m)){
                //首先判断电梯组合是不是包含了所有楼层
                continue;
            }
            //*****************************************执行每种电梯组合的运行时间******************************************
            LinkedBlockingQueue<Integer> 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<List<List<Integer>>,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<Integer> 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<Integer> lists){
        List<Integer> 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<List<Integer>> lm){
        int b=m;
        for(int i=0;i<lm.size();i++){
            // m--表示当前的位置已定,去掉,只考虑其他的人
            m--;
            List<List<Integer>> 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<List<Integer>> lm,List<List<Integer>> lists){
        //创建临时变量,存储上次循环的情况,以便于下一个的多有情况组合
        List<List<Integer>> list=Lists.newArrayList();
        list.addAll(lists);
        int b=i;
        for(int j=0;j<lm.size();j++){
            lists.add(lm.get(j));
            i--;

            boolean flag=true;
            if(i>0){
                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<List<Integer>> convert(List<List<Integer>> l1){
        List<List<Integer>> resultlist=Lists.newArrayList();
        for(int i=0;i<l1.size();i++){
            List<Integer> l2=l1.get(i);
            List<Integer> ltmp=Lists.newArrayList();
            int tmp=0;
            for(int j=0;j<l2.size();j++){
                ltmp.add(tmp+l2.get(j));
                tmp+=l2.get(j);
            }
            resultlist.add(ltmp);
        }
        return  resultlist;
    }
    /**
     * 判断是否包含了所有楼层
     * @param produceElem
     * @param n
     * @return
     */
    public static boolean iscontainAllNum(List<List<Integer>> produceElem,int n){
        List<Integer> allNum=Lists.newArrayList();
        for(List<Integer> int1:produceElem){
            for(Integer int2:int1){
                allNum.add(int2);
            }
        }
        allNum=Lists.newArrayList(new TreeSet<Integer>(allNum));
        if(allNum.size()<n){
            return false;
        }
        return  true;
    }
    /**
     * 根据map的value排序
     * @param result
     * @return
     */
    public static Map<List<List<Integer>>,Double> sortMapByValue(Map<List<List<Integer>>,Double> result){
        Map<List<List<Integer>>,Double> sortedMap=Maps.newLinkedHashMap();
        List<Map.Entry<List<List<Integer>>,Double>> entryList=Lists.newArrayList(result.entrySet());
        Collections.sort(entryList, new Comparator<Map.Entry<List<List<Integer>>, Double>>() {
            @Override
            public int compare(Map.Entry<List<List<Integer>>, Double> o1, Map.Entry<List<List<Integer>>, Double> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
        });
        Iterator<Map.Entry<List<List<Integer>>,Double>> iterator=entryList.iterator();
        Map.Entry<List<List<Integer>>,Double> tmpEntry=null;
        while(iterator.hasNext()){
            tmpEntry=iterator.next();
            sortedMap.put(tmpEntry.getKey(),tmpEntry.getValue());
        }
        return sortedMap;
    }
    /**
     * 随机生成人的个数,以及每个人所属的楼层
     * @param m
     * @param n
     * @return
     */
    public LinkedBlockingQueue<Integer> peopleAndNumPosition(int m,int n){
        LinkedBlockingQueue<Integer> queue=new LinkedBlockingQueue<>();
        for( int i=0;i<m;i++){
            queue.offer((int)(Math.random()*n)+1);
        }
        return queue;
    }
}

 

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/105944.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • python 进制转换[通俗易懂]

    python 进制转换[通俗易懂]文章目录前言一、Python提供的进制转换方法1.二进制转十进制2.八进制转十进制3.十六进制转十进制4.十进制转十六进制5.十进制转二进制6.十进制转八进制二、自定义进制转换1.转十进制2.十进制转七进制总结前言十进制是我们常用的数字形式,但机器使用的却是二进制,八进制,十六进制之类的,所以进制转换是基础要求,很多编程语言提供的有进制转换的方法,下面我们开始学习一、Python提供的进制转换方法1.二进制转十进制s=’1001’print(int(s,2))结果如下:in..

  • 大一c语言图书管理系统_基于java的图书管理系统

    大一c语言图书管理系统_基于java的图书管理系统C课程设计——图书管理系统1、题目意义图书馆,作为文献的聚集地和展示平台,常常扮演着引领文化前进的角色,是每个大学不可或缺的基础设施,而图书管理系统则是一个图书馆能够正常运转的关键。本次课程设计使用C语言制作程序来实现图书的登记,删除,查询,浏览以及读者的借阅,还书,会员登录,修改密码等功能。程序中涉及到数据链表和文件指针的操作,包括结构体数据定义,使用及文件的读写,定位,修改等。2、设计思…

    2022年10月11日
  • HTML表格代码_html如何制作表格代码

    HTML表格代码_html如何制作表格代码表格代码<table></tabie><tablewidth(表格宽度。可以用像素或百分比表示。)=””height=””(行高)border=””(边框)cellpadding=””(内容跟单元格边框的边距。)cellspacing=””(单元格之间的间距。)align=””(对齐方式。)bgcolor=””(背景色)background=””(背景图片。)><tr(行)align=””(一行的内容的水平对齐方式)valign(一行的内容的垂平对齐.

  • python3 gil锁_python gil 多线程

    python3 gil锁_python gil 多线程前言python的使用者都知道Cpython解释器有一个弊端,真正执行时同一时间只会有一个线程执行,这是由于设计者当初设计的一个缺陷,里面有个叫GIL锁的,但他到底是什么?我们只知道因为他导致pyt

  • python对字符串中指定字符进行替换[通俗易懂]

    python对字符串中指定字符进行替换[通俗易懂](1)替换指定的所有字符:string.replace(‘a’,‘b’)表示将字符串string中所有字符为’a’的替换为’b’。例子string=”abcabcabc”string=string.replace(‘a’,’b’)print(string)输出bbcbbcbbc(2)替换指定位置i的字符为字符s:列表化字符串再以字符串形式输出例子i,s…

  • 在Pycharm中使用git工具「建议收藏」

    在Pycharm中使用git工具「建议收藏」在Pycharm中使用git工具File->settings->versioncontrol->git;然后从双击.gitignore文件会让你安装git的插件,安装完成重启IED。此时你的项目应该已经在版本控制之中。所以你有提交的内容,先commit,然后选择版本库中的分支push就可以了。

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号