Question

您建议我使用什么算法来解决以下问题？

我想解决根据日历可用性找到适合所有（或几乎所有）参与者的最佳时段的问题。

我正在使用Java并希望能够为这些参与者安排会议。我将参与者的可用性数据分为半小时段。我希望找到所有这些参与者都可以参加的时间。

可用性问题如下所示

|Participant   | 09:00 | 09:30 | 10:00     | 10:30 | 11:00 | 11:30 |
|Person 1      | Free  | Busy  | **Free**  | Free  | Busy  | Free  | 
|Person 2      | Free  | Busy  | **Free**  | Free  | Busy  | Busy  | 
|Person 3      | Free  | Busy  | **Free**  | Free  | Busy  | Busy  | 
|Person 4      | Free  | Busy  | **Free**  | Free  | Busy  | Busy  | 
|Person 5      | Free  | Busy  | **Free**  | Free  | Busy  | Free  |

我想选择适合每个人的时段。理想情况下，我希望算法选择至少一个选项。然后，我可以将约束应用于所选时间以找到最佳值。

Answer 1

可用性计划可以转换为array of bits，其中Free为1，Busy为0.我在下面指定了一个示例作为指南：

|Participant | 09:00 | 09:30 | 10:00 | 10:30 | 11:00 | 11:30 |
|Person 1    | Free  | Busy  | Free  | Free  | Busy  | Free  |

Person 1的位数组看起来像：1 | 0 | 1 | 1 | 0 | 1

由于您以30分钟为增量设置周期，因此24小时时间范围内的位数组不会超过48。在Java中，长数据类型足以保存此位数组的值。将每个参与者的可用时隙转换为位数组。然后，将按位运算符AND应用于每个参与者的可用调度的位数组表示。结果位数组将是所有参与者的共同空闲时间。

Answer 2

安排像这样的DataStructure。

地图

从第1天到第N天，按键的范围几乎可以。我假设接下来的30天，所以按键的范围从第1天到第30天。

假设需要10人预约会议。每个人都应该在那个位置免费为会议预订。

我假设在8小时工作日内有30分钟的时段。所以一天会有16个插槽。

因此对于Day1-＆gt;您将持有10人的可用性作为10乘16二维int数组/矩阵。每个单元格将保持0或1. 0表示此人不可用，1表示他可用。

关键是迭代地成对地对每个人/槽进行AND。（插槽0上的Person1可用性）＆amp; （插槽0上的Person2可用性）。如果为0则立即中断循环，因为我们找不到此插槽的匹配项。如果重复的ANDs为一天/时隙组合产生1，则到达特定日期的时段的精确匹配。我在下面附上了我的代码。包com.ramesh.tests;

    import java.util.Map;
    import java.util.Random;
    import java.util.TreeMap;

    public class CalendarFinder {

        public static void main(String[] args) {
            int n=10 ;// no. of persons
            int m=30 ;//no.of days
            Map<String,int[][]> personCalendar = preparePersonCalendars(n,m);
            printPersonCalendar(personCalendar);
            Map<String,int[][]> testData = prepareTestData(n,m);
            printPersonCalendar(testData);
            meetingSlotFinder(testData);
            meetingSlotFinder(personCalendar);
        }

        private static Map<String,int[][]> preparePersonCalendars(int n, int m) {
            Random rnd = new Random();
            Map<String,int[][]> personCalendar = new TreeMap<String,int[][]>();
            for(int i=0; i<m; i++) { //iterate over days
                int[][] daysSlots = new int[n][16];
                for(int j=0;j<n;j++) { //iterate over persons
                    for(int slot=0;slot<16;slot++) { 
                        daysSlots[j][slot] = rnd.nextInt(2);
                    }
                }
                personCalendar.put(i<9 ? "Day_0"+(i+1) : "Day_"+(i+1), daysSlots);
            }
            return personCalendar;
        }

        private static Map<String,int[][]> prepareTestData(int n, int m) {
            Map<String,int[][]> testData = new TreeMap<String,int[][]>();
            for(int i=0; i<m; i++) { //iterate over days
                int[][] daysSlots = new int[n][16];
                for(int j=0;j<n;j++) { //iterate over persons
                    for(int slot=0;slot<16;slot++) { 
                        daysSlots[j][slot] = i%5==0 && slot%6==0 ? 1 : 0;
                    }
                }
                testData.put(i<9 ? "Day_0"+(i+1) : "Day_"+(i+1), daysSlots);
            }
            return testData;
        }

        private static void printPersonCalendar(Map<String,int[][]> personCalendar) {
            for(Map.Entry<String, int[][]> calendar: personCalendar.entrySet()) {
                System.out.println("Printing Calendar availability for : " + calendar.getKey());
                int[][] pCalArray = calendar.getValue();
                for(int i=0; i<pCalArray.length; i++) {
                    System.out.println("Person : " + (i+1));
                    for(int j=0;j<pCalArray[0].length;j++) {
                        System.out.print(" " + pCalArray[i][j]);
                    }
                    System.out.print("\r\n");
                }
            }
        }

        private static void meetingSlotFinder(Map<String,int[][]> personCalendar) {
            int ctr=0;
            for(Map.Entry<String, int[][]> calendar: personCalendar.entrySet()) {
                int[][] pCalArray = calendar.getValue();
                for(int j=0;j<pCalArray[0].length;j++) { // iterate over slots
                    int result = 1;
                    for(int i=0; i<pCalArray.length-1; i++) { //iterate over persons
                        ctr++;
                        result = result & pCalArray[i][j]& pCalArray[i+1][j];
                        if(result==0) break;
                    }
                    if(result == 1)
                        System.out.println("**** Meeting match at Day : " + 
                                calendar.getKey() + " and at slot: " + j);
                    else
                        System.out.println("Couldn't find any meeting match at Day : " + 
                                calendar.getKey() + " and at slot: " + j);
                }
            }
            System.out.println("#@$&* Total Iterations performed : " + ctr); 
        }

    }

为参与者组找到最佳可能时隙的算法

2 个答案: