Find non-overlap jobs with max cost

　　

Given a set of n jobs with [start time, end time, cost] find a subset so that no 2 jobs overlap and the cost is maximum.
Job: （start_time, end_time] --- cost

如果只是求maxCost, 一维就可以做。

但是如果要知道有选了哪些job，则需要存成二维。

 package leetcode;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;

 class Job{
     Integer start_time;
     Integer end_time;
     Integer cost;
     public Job(Integer s, Integer e, Integer c){
         start_time = s;
         end_time = e;
         cost = c;
     }

     public String toString(){
         StringBuilder sb = new StringBuilder();
         sb.append("Job: start [" + start_time + "], end ["+ end_time + "], cost [" + cost + "];");
         return sb.toString();
     }
 }

 public class FindNonOverlapJobs {
     public static ArrayList<Job> findJobsWithMaxCost(Job[] jobList){
         ArrayList<Job> result = new ArrayList<Job> ();
         if(jobList == null || jobList.length == 0) return result;
         Arrays.sort(jobList, new Comparator<Job>(){
             public int compare(Job j1, Job j2){
                 return j1.end_time > j2.end_time ? 1 : (j1.end_time == j2.end_time ? 0 : -1);
             }
         });
         int len = jobList.length;
         int[][] dp = new int[len + 1][jobList[len - 1].end_time + 1];
         for(int i = 1; i <= len; i ++){
             Job tmp = jobList[i - 1];
             int start = tmp.start_time;
             int end = tmp.end_time;
             for(int j = 0; j < dp[0].length; j ++){
                 if(j < end){
                     dp[i][j] = dp[i - 1][j];
                 }else if(j == end){
                     dp[i][j] = Math.max(dp[i - 1][start] + tmp.cost, dp[i - 1][j]);
                 }else{
                     dp[i][j] = dp[i][j - 1];
                 }
             }
         }

         int i = dp[0].length - 1;
         while(i > 0){
             if(dp[len][i] == dp[len][i - 1]) i --;
             else{
                 int j = len;
                 while(j > 0 && dp[j][i] == dp[j - 1][i]) j --;
                 result.add(jobList[j - 1]);
                 i --;
             }
         }
         return result;
     }

 public static void main(String[] args){
     Job[] test = new Job[5];
     test[0] = new Job(1,3,4);
     test[1] = new Job(3,5,2);
     test[2] = new Job(2,3,3);
     test[3] = new Job(1,2,2);
     test[4] = new Job(2,6,3);
     ArrayList<Job> result = findJobsWithMaxCost(test);
     for(int i = 0; i < result.size(); i ++){
         System.out.println(result.get(i).toString());
     }
 }
 }

Output:

Job: start [3], end [5], cost [2];

Job: start [2], end [3], cost [3];

Job: start [1], end [2], cost [2];