Question

Suppose that you are scheduling a room. You are given a group of activities each of which has a start
and stop time. Two activities are compatible if they do not overlap (one activity finishes before another
one starts). For example, in the following activities, activity A is compatible with activities B and D but
not activity C:

Activity Start Time Stop time
A 1 2
B 2 5
C 1 3
D 5 6

The room has a start time and an end time in which it is available.
Your goal is to write a recursive method to schedule compatible activities that result in the maximum
usage of the room. The usage of the room is defined as the total duration of the scheduled activities,
that is, the sum of (stop time – start time) for all the activities scheduled to run in the room.
For example suppose that the start time and end time in which the room is available is [1,7] for the
above table. Hence, the possible schedules are:
1. Activities A, B,D: with room usage = (2-1)+(5-2) +(6-5) = 5
2. Activities C, D: with room usage = (3-1)+(6-5) = 2
3. Activities A,D: with room usage (5-2)+(6-5) =4
4. Activities A, B: with room usage (2-1)+(5-2)= 4
5. Activities B, D: with room usage (5-2)+(6-5) = 4
Therefore, the set of activities {A,B,D} gives the optimal schedule with the maximum room usage.

What you need to do:
1- Create a class Activitiy.java with three data fields : activityName, startTime, and stopTime . Create accessor (get) and mutator (set) methods for each data field.
2- Create a class Scheduling.java with the following method in it:

public Activity[] getOptimalSchedule( int roomStartTime, int roomEndtime, Activity[] activities)

This method gets the availability span of the room as well as a set of activities to choose from and returns an optimal schedule i.e., a selected set of non-overlapping activities that can be scheduled to run in the room and gives the maximum possible usage of the room. Note, depending on your input, the correct answer may not be unique (that is, there might be several valid schedules with the same total room usage)

Answer 1

Algorithm:

We will first sort the activity array according to the stop time. Then we will apply recursion. Sorting allows us to ease the traversal for checking if any range overlaps with another.

In recursion, we will keep the track of last used index, so that we can check if we can the the current index into consideration or not by checking its intersection with the previous index. Accordingly we will update our answer array. In the recur function, k denotes the number of activities that we have so far considered, prev denotes the last index used and idx denotes the current index. time denotes the range covered so far, and answer array keeps the current solution in hand. When we reach the last index, we know that we have considered one permutation and hence we update our final solution accordingly.

prev = -1 tells none has been taken into consideration. inTheDomain function tells if the current activity is in the room bounds or not. intersect function checks if there's any overlapping.

Here's the code of Activity.java:

public class Activity {
private String activityName;
private int startTime, stopTime;
  
void setStartTime(int x){
this.startTime = x;
}
void setStopTime(int x){
this.stopTime = x;
}
void setActivityName(String x){
this.activityName = x;
}
String getActivityName(){
return this.activityName;
}
int getStartTime(){
return this.startTime;
}
int getStopTime(){
return this.stopTime;
}
  
public int compare(Activity a, Activity b){
if(a.startTime > b.startTime){
return 1;
}
else if(a.startTime < b.startTime){
return 0;
}
else{
if(a.stopTime > b.stopTime){
return 1;
}
else{
return 0;
}
}
}
Activity(String name, int startTime, int stopTime){
this.activityName = name;
this.startTime = startTime;
this.stopTime = stopTime;
}
}

Here's the code for Scheduling.java:

import java.util.*;
public class Scheduling {
private int globalAns, roomStartTime, roomEndTime;
private Activity[] solution;
public int intersect(Activity a, Activity b){
if(a.getStartTime() < b.getStartTime() && a.getStopTime() < b.getStopTime()) return 0;
if(b.getStartTime() < a.getStartTime() && b.getStopTime() < a.getStopTime()) return 0;
return 1;
}
public int inTheDomain(Activity a){
if(a.getStartTime() >= this.roomStartTime && a.getStopTime() <= this.roomEndTime) return 1;
return 0;
}
public void recur(Activity[] activities, Activity[] answer, int idx, int k, int prev, int time){
if(idx == activities.length){
if(time > this.globalAns){
for(int i = 0; i < k; i++){
this.solution[i] = answer[i];
}
}
return;
}
if(inTheDomain(activities[idx]) == 0){
recur(activities, answer, idx+1, k, prev, time);
}
else if(prev == -1 || intersect(activities[idx], activities[prev]) == 0){
recur(activities, answer, idx+1, k, prev, time);
int x = (activities[idx].getStopTime() - activities[idx].getStartTime());
answer[k] = activities[idx];
recur(activities, answer, idx+1, k+1, idx, time+x);
}
else{
recur(activities, answer, idx+1, k, prev, time);
}
}
  
public Activity[] getOptimalSchedule(int roomStartTime, int roomEndtime, Activity[] activities){
Activity[] answer = new Activity[activities.length];
this.solution = new Activity[activities.length];
this.globalAns = 0;
this.roomStartTime = roomStartTime;
this.roomEndTime = roomEndtime;
Arrays.sort(activities, new Comparator<Activity>() {
public int compare(Activity a, Activity b) {
return a.getStopTime() - b.getStopTime();
}
});
recur(activities, answer, 0, 0, -1, 0);
return this.solution;
}
}

And here's the Driver.java for the main function:

import java.util.*;
class Driver{
public static void main(String args[]){
Scheduling s = new Scheduling();
Activity[] activities = new Activity[4];
activities[0] = new Activity("A", 1, 2);
activities[1] = new Activity("B", 2, 5);
activities[2] = new Activity("C", 1, 3);
activities[3] = new Activity("D", 5, 6);
Activity[] solution = new Activity[4];
solution = s.getOptimalSchedule(1, 7, activities);
for(int i = 0; solution[i] != null; i++){
System.out.print(solution[i].getActivityName());
}
System.out.println();
}
}