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];