会议占用时间计算（华为od机考题）

一、题目

1.原题

现有若干个会议，所有会议共享一个会议室，
用数组表示每个会议的开始时间和结束时间，
格式：
数组：[[会议1开始时间，会议1结束时间], [会议2开始时间，会议2结束时间]]。
请计算会议室占用时间段。

二、思路与代码过程

1.思路

从键盘动态获取数组，

对数组用先按第一个元素排序，然后在第一个元素前提下按照第二个元素排序；

得到排序好的数组后，对数组进行是否需要组合判断，需要的话进入组合判断；

组合完成之后，移除被组合的两个数组，加入组合好的新数组；

对会议时间段数组递归到不需要组合，输出即可。

2.代码过程

①main函数

public static void main(String[] args) {
        /*
        ArrayList<int[]> conferences = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        while (true) {
            int start = sc.nextInt();
            if (start == -1) {
                break;
            }
            int end = sc.nextInt();
            conferences.add(new int[]{start, end});
        }
        sc.close();
        for (int[] conf : conferences) {
            System.out.println(Arrays.toString(conf));
        }
         */
        int[][] con = {{19,20},{2,9},{3,6},{3,10},{2,7}};
        ArrayList<int[]> conferences = new ArrayList<>();
        for (int[] arr : con) {
            conferences.add(arr);
            System.out.println(Arrays.toString(arr));
        }
        System.out.println();
        TimeJoint(conferences);
    }

②TimeJoint函数

private static void TimeJoint(ArrayList<int[]> conferences) {
        //先按开始时间排序，开始时间相同下按结束时间排序
        conferences.sort(Comparator.comparingInt
                ((int[] arr) -> arr[0]).thenComparingInt(arr -> arr[1]));
        boolean needconnect = needConnect(conferences);
        if (needconnect) {
            //此时的会议开始时间和结束时间都是顺序
            //设置循环次数，重组后的数组数量肯定小于等于一开始的数组数量
            for (int i = 0; i < conferences.size()-1; i++) {
                int[] arr1 = conferences.get(i);
                int[] arr2 = conferences.get(i+1);

                int start1 = arr1[0];
                int start2 = arr2[0];
                int end1 = arr1[1];
                int end2 = arr2[1];
                System.out.println("end2:"+end2);

                //start1一定小于等于start2，end1一定小于等于end2

                //1:s1  e1   s2  e2 无重合不需要重组替换
                if (end1 < start2 ) {
                    continue;
                }
                //2:s1  s2  e2  e1 会议1包含会议2 替换（移除重新组合加入）
                if (start1<=start2&&end2<=end1){
                    int[] arr3 = new int[]{start1,end1};
                    conferences.remove(arr1);
                    conferences.remove(arr2);
                    conferences.add(arr3);
                }
                //3:s1  s2  e1  e2 会议1与会议2部分重叠 替换（移除重新组合加入）
                if (start1<=start2&&start2<=end1&&end1<=end2){
                    int[] arr4 = new int[]{start1,end2};
                    conferences.remove(arr1);
                    conferences.remove(arr2);
                    conferences.add(arr4);
                }
                TimeJoint(conferences);
            }
        }else {
            System.out.println("当前会议室占用时间段为：");
            for (int[] arr : conferences) {
                System.out.println(Arrays.toString(arr));
            }
        }
    }

③needConnect判断

private static boolean needConnect(ArrayList<int[]> conferences) {
        boolean needconnect = false;
        int length = conferences.size();
        for (int i = 0; i < length-2; i++) {
            int[] arr1 = conferences.get(i);
            int[] arr2 = conferences.get(i+1);
            int start1 = arr1[0];
            int start2 = arr2[0];
            int end1 = arr1[1];
            int end2 = arr2[1];
            if (end1 < start2 ) {
                needconnect = false;
            }
            if (start1<=start2&&end2<=end1){
                needconnect = true;
            }
            if (start1<=start2&&start2<=end1&&end1<=end2){
                needconnect = true;
            }
        }
        return needconnect;
    }

三、运行结果

1.运行截图

2.带数据分析运行结果

[19, 20]
[2, 9]
[3, 6]
[3, 10]
[2, 7]

[2, 7]
[2, 9]
[3, 6]
[3, 10]
[19, 20]

还有需要重组的

arr1:[2, 7]
arr2:[2, 9]
start1:2
start2:2
end1:7
end2:9
1和2部分重叠,重组如下
[2, 9]

[3, 6]
[3, 10]
[19, 20]
[2, 9]

[2, 9]
[3, 6]
[3, 10]
[19, 20]

还有需要重组的

arr1:[2, 9]
arr2:[3, 6]
start1:2
start2:3
end1:9
end2:6
1包含2,重组如下
[2, 9]

[3, 10]
[19, 20]
[2, 9]

[2, 9]
[3, 10]
[19, 20]

还有需要重组的

arr1:[2, 9]
arr2:[3, 10]
start1:2
start2:3
end1:9
end2:10
1和2部分重叠,重组如下
[2, 10]

[19, 20]
[2, 10]

[2, 10]
[19, 20]

没有需要重组的了

当前会议室占用时间段为：
[2, 10]
[19, 20]

3.带数据分析完整代码

import java.util.*;

public class test31 {
    public static void main(String[] args) {
        /*
        ArrayList<int[]> conferences = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        while (true) {
            int start = sc.nextInt();
            if (start == -1) {
                break;
            }
            int end = sc.nextInt();
            conferences.add(new int[]{start, end});
        }
        sc.close();
        for (int[] conf : conferences) {
            System.out.println(Arrays.toString(conf));
        }
         */
        int[][] con = {{19,20},{2,9},{3,6},{3,10},{2,7}};
        ArrayList<int[]> conferences = new ArrayList<>();
        for (int[] arr : con) {
            conferences.add(arr);
            System.out.println(Arrays.toString(arr));
        }
        System.out.println();
        TimeJoint(conferences);
    }

    //重组后
    static ArrayList<int[]> conferencesConnected = new ArrayList<>();
    private static void TimeJoint(ArrayList<int[]> conferences) {
        //先按开始时间排序，开始时间相同下按结束时间排序
        // /*
        conferences.sort(Comparator.comparingInt
                ((int[] arr) -> arr[0]).thenComparingInt(arr -> arr[1]));
        for (int[] arr : conferences) {
            System.out.println(Arrays.toString(arr));
        }
        System.out.println();

        boolean needconnect = needConnect(conferences);
        if (needconnect) {
            System.out.println("还有需要重组的\n");
            //此时的会议开始时间和结束时间都是顺序
            //设置循环次数，重组后的数组数量肯定小于等于一开始的数组数量
            for (int i = 0; i < conferences.size()-1; i++) {
                int[] arr1 = conferences.get(i);
                int[] arr2 = conferences.get(i+1);
                System.out.println("arr1:"+Arrays.toString(arr1));
                System.out.println("arr2:"+Arrays.toString(arr2));

                int start1 = arr1[0];
                int start2 = arr2[0];
                int end1 = arr1[1];
                int end2 = arr2[1];

                System.out.println("start1:"+start1);
                System.out.println("start2:"+start2);
                System.out.println("end1:"+end1);
                System.out.println("end2:"+end2);

                //start1一定小于等于start2，end1一定小于等于end2

                //1:s1  e1   s2  e2 无重合不需要重组替换
                if (end1 < start2 ) {
                    System.out.println("e1<s2,无需组合");
                    System.out.println();
                    conferencesConnected.add(arr1);
                    conferencesConnected.add(arr2);
                    continue;
                }
                //2:s1  s2  e2  e1 会议1包含会议2 替换（移除重新组合加入）
                if (start1<=start2&&end2<=end1){
                    System.out.println("1包含2,重组如下");
                    int[] arr3 = new int[]{start1,end1};

                    System.out.println(Arrays.toString(arr3));
                    System.out.println();
                    conferencesConnected.add(arr3);
                    conferences.remove(arr1);
                    conferences.remove(arr2);
                    conferences.add(arr3);
                }
                //3:s1  s2  e1  e2 会议1与会议2部分重叠 替换（移除重新组合加入）
                if (start1<=start2&&start2<=end1&&end1<=end2){
                    System.out.println("1和2部分重叠,重组如下");
                    int[] arr4 = new int[]{start1,end2};

                    System.out.println(Arrays.toString(arr4));
                    System.out.println();
                    conferencesConnected.add(arr4);
                    conferences.remove(arr1);
                    conferences.remove(arr2);
                    conferences.add(arr4);
                }

                for (int[] arr : conferences) {
                    System.out.println(Arrays.toString(arr));
                }
                System.out.println();
                TimeJoint(conferences);
            }
        }else {
            System.out.println("没有需要重组的了\n");
            System.out.println("当前会议室占用时间段为：");
            for (int[] arr : conferences) {
                System.out.println(Arrays.toString(arr));
            }
        }
    }

    private static boolean needConnect(ArrayList<int[]> conferences) {
        boolean needconnect = false;
        int length = conferences.size();
        for (int i = 0; i < length-2; i++) {
            int[] arr1 = conferences.get(i);
            int[] arr2 = conferences.get(i+1);
            int start1 = arr1[0];
            int start2 = arr2[0];
            int end1 = arr1[1];
            int end2 = arr2[1];
            if (end1 < start2 ) {
                needconnect = false;
            }
            if (start1<=start2&&end2<=end1){
                needconnect = true;
            }
            if (start1<=start2&&start2<=end1&&end1<=end2){
                needconnect = true;
            }
        }
        return needconnect;
    }
}