map contain

import java.util.*;

public class scheduleGreedy {

class scheduleWrapper{

booleanisStart;

scheduleRequest schedule;

public scheduleWrapper(scheduleRequestschedule,boolean isStart){

this.isStart =isStart;

this.schedule =schedule;

}

}

private staticfinal int locNum =6;

private staticfinal int timeNum = 20;

List<Map<Integer,List<scheduleWrapper>>> contentList;

Map<String,scheduleRequest> detectDup;

List<scheduleRequest> acceptedOut;

List<scheduleRequest> rejectedOut;

public scheduleGreedy(){

contentList = new ArrayList<>();

detectDup = new HashMap<>();

acceptedOut = new ArrayList<>();

rejectedOut = new ArrayList<>();

for(inti=0;i<locNum;i++){

contentList.add(new HashMap<Integer,List<scheduleWrapper>>());

}

}

public void init(List<scheduleRequest>listInput){

for(scheduleRequestschedule:listInput){

intlocation = schedule.location;

Map<Integer, List<scheduleWrapper>>timeMap=contentList.get(location-1);

scheduleWrapper start = new scheduleWrapper(schedule,true);

if(!timeMap.containsKey(schedule.starttime)){

timeMap.put(schedule.starttime,new ArrayList<scheduleWrapper>());

}

timeMap.get(schedule.starttime).add(start);

scheduleWrapper end = new scheduleWrapper(schedule,false);

if(!timeMap.containsKey(schedule.endtime)){

timeMap.put(schedule.endtime,new ArrayList<scheduleWrapper>());

}

timeMap.get(schedule.endtime).add(end);

}

}

public void schedule(intlocation){

Map<Integer, List<scheduleWrapper>>content =contentList.get(location-1);

for(inti=1;i<=timeNum;i++){

if(content.get(i)==null)continue;

for(scheduleWrapperschedule: content.get(i)){

String id = schedule.schedule.id;

if(!schedule.isStart &&detectDup.containsKey(id) && i == detectDup.get(id).endtime){

acceptedOut.add(detectDup.get(id));

detectDup.remove(id);

}

}

for(scheduleWrapperschedule:content.get(i)){

String id = schedule.schedule.id;

if(detectDup.containsKey(id)){

if(computeDuration(detectDup.get(id))<computeDuration(schedule.schedule)){

rejectedOut.add(detectDup.get(id));

detectDup.put(id,schedule.schedule);

}else{

rejectedOut.add(schedule.schedule);

}

}elseif (detectDup.size()>=3){

scheduleRequestshortest = findShortest(detectDup);

if(computeDuration(shortest)<computeDuration(schedule.schedule)){

rejectedOut.add(shortest);

detectDup.remove(shortest.id);

detectDup.put(id,schedule.schedule);

}else{

rejectedOut.add(schedule.schedule);

}

}else{

detectDup.put(id,schedule.schedule);

}

}

}

}

public int computeDuration(scheduleRequestschedule){

returnschedule.endtime-schedule.starttime;

}

public scheduleRequest findShortest(Map<String, scheduleRequest>map){

int min = Integer.MIN_VALUE;

scheduleRequest shortest =null; 

for(scheduleRequestschedule:map.values()){

if(min <computeDuration(schedule)){

min = computeDuration(schedule);

shortest =schedule;

}

}

returnshortest;

}

public void printReslut(){

for(scheduleRequests:acceptedOut){

System.out.println("starting time is " +s.starttime +" ending time is " + s.endtime +" id is " + s.id);

}

System.out.println("rejected output");

for(scheduleRequests:rejectedOut){

System.out.println("starting time is " +s.starttime +" ending time is " + s.endtime +" id is " + s.id);

}

}

}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;


public class Schedule {


List<scheduleRequest> acceptedOutput;
List<scheduleRequest> rejectedOutput;
Map<Integer, List<scheduleRequest>> content;


public Schedule() {
acceptedOutput = new ArrayList<>();
rejectedOutput = new ArrayList<>();
content = new HashMap<>();
}


public void initSchedule(List<scheduleRequest> list) {
for (int i = 0; i < list.size(); i++) {
int location = list.get(i).location;
if (!content.containsKey(location)) {
content.put(location, new ArrayList<scheduleRequest>());
}
List<scheduleRequest> request = content.get(location);
request.add(list.get(i));
}


for (List<scheduleRequest> schedule : content.values()) {
Collections.sort(schedule, new scheduleComparator());
}


}


public void generateOutput() {
for (List<scheduleRequest> schedules : content.values()) {
Map<Integer, Set<String>> dup = new HashMap<>();


int track = 0;
while (track < 3) {
track++;
int[] ps = new int[schedules.size()];
for (int i = 0; i < schedules.size(); i++) {
ps[i] = searchLastCompatiable(schedules, schedules.get(i));
}
int[] tmp = new int[schedules.size() + 1];
findLongestUtilization(schedules, ps, tmp);
outputValid(schedules, dup, ps, tmp);
removeInvalid(schedules, dup);
}


}
}


public void findLongestUtilization(List<scheduleRequest> schedules, int[] ps, int[] tmp) {
tmp[0] = 0;
System.out.println(Arrays.toString(ps));
for (int i = 0; i < schedules.size(); i++) {
scheduleRequest current = schedules.get(i);
int duration = current.endtime - current.starttime;
int index = ps[i] + 1;
int max = Math.max(duration + tmp[index], tmp[i]);
tmp[i + 1] = max;
}
}


public void outputValid(List<scheduleRequest> schedules, Map<Integer, Set<String>> dup, int[] ps, int[] tmp) {
for (int i = schedules.size() - 1; i >= 0;) {
scheduleRequest current = schedules.get(i);
int duration = current.endtime - current.starttime;
int index = ps[i] + 1;
if (duration + tmp[index] >= tmp[i]) {
acceptedOutput.add(current);
System.out.println("current is " + current.starttime + " " + current.endtime + " " + current.id);
i = ps[i];
for (int t = current.starttime; t < current.endtime; t++) {
if (!dup.containsKey(t)) {
dup.put(t, new HashSet<String>());
}
dup.get(t).add(current.id);
}


} else {
i--;
}
}
}


public void removeInvalid(List<scheduleRequest> schedules, Map<Integer, Set<String>> dup) {
Iterator<scheduleRequest> i = schedules.iterator();
while (i.hasNext()) {
scheduleRequest current = i.next();
for (int t = current.starttime; t < current.endtime; t++) {
if (dup.containsKey(t) && dup.get(t).contains(current.id)) {
rejectedOutput.add(current);
i.remove();
break;


}
}
}
}


public int searchLastCompatiable(List<scheduleRequest> schedules, scheduleRequest target) {
int left = 0;
int right = schedules.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (schedules.get(mid).endtime == target.starttime) {
return mid;
} else if (schedules.get(mid).endtime > target.starttime) {
right = mid - 1;


} else {
left = mid + 1;


}
}


return left - 1;
}
}


class scheduleComparator implements Comparator<scheduleRequest> {
public int compare(scheduleRequest s1, scheduleRequest s2) {
if (s1.endtime == s2.endtime)
return s1.starttime - s2.starttime;
return s1.endtime - s2.endtime;
}


}