Skip to content

1235. Maximum Profit in Job Scheduling

SourceWeekly Contest 159 Q4DifficultyHardRating2022

Description

We have n jobs, where every job is scheduled to be done from startTime[i] to endTime[i], obtaining a profit of profit[i].

You're given the startTime, endTime and profit arrays, return the maximum profit you can take such that there are no two jobs in the subset with overlapping time range.

If you choose a job that ends at time X you will be able to start another job that starts at time X.

 

Example 1:

Input: startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
Output: 120
Explanation: The subset chosen is the first and fourth job. 
Time range [1-3]+[3-6] , we get profit of 120 = 50 + 70.

Example 2:

Input: startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]
Output: 150
Explanation: The subset chosen is the first, fourth and fifth job. 
Profit obtained 150 = 20 + 70 + 60.

Example 3:

Input: startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
Output: 6

 

Constraints:

  • 1 <= startTime.length == endTime.length == profit.length <= 5 * 104
  • 1 <= startTime[i] < endTime[i] <= 109
  • 1 <= profit[i] <= 104

Solutions

Thinking

Jobs must not overlap. \(n \le 5\times 10^4\) rules out subset search. Whether we take job \(i\) only affects jobs that start no earlier than its end.

After sorting by start, \(\textit{dfs}(i)\) takes the better of skipping \(i\) and taking \(i\) then jumping to the first job with \(\textit{start}\ge \textit{end}_i\). That index is a binary search on the sorted starts. Memoization evaluates each \(i\) once.

First, we sort the jobs by start time in ascending order, then design a function \(\textit{dfs}(i)\) to represent the maximum profit that can be obtained starting from the \(i\)-th job. The answer is \(\textit{dfs}(0)\).

The calculation process of function \(\textit{dfs}(i)\) is as follows:

For the \(i\)-th job, we can choose to do it or not. If we don't do it, the maximum profit is \(\textit{dfs}(i + 1)\); if we do it, we can use binary search to find the first job that starts after the end time of the \(i\)-th job, denoted as \(j\), then the maximum profit is \(\textit{profit}[i] + \textit{dfs}(j)\). We take the larger of the two. That is:

\[ \textit{dfs}(i)=\max(\textit{dfs}(i+1),\textit{profit}[i]+\textit{dfs}(j)) \]

Where \(j\) is the smallest index that satisfies \(\textit{startTime}[j] \ge \textit{endTime}[i]\).

In this process, we can use memoization search to save the answer of each state to avoid repeated calculations.

The time complexity is \(O(n \log n)\), where \(n\) is the number of jobs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Solution:
    def jobScheduling(
        self, startTime: list[int], endTime: list[int], profit: list[int]
    ) -> int:
        @cache
        def dfs(i):
            if i >= n:
                return 0
            _, e, p = jobs[i]
            j = bisect_left(jobs, e, lo=i + 1, key=lambda x: x[0])
            return max(dfs(i + 1), p + dfs(j))

        jobs = sorted(zip(startTime, endTime, profit))
        n = len(profit)
        return dfs(0)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Solution {
    private int[][] jobs;
    private int[] f;
    private int n;

    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
        n = profit.length;
        jobs = new int[n][3];
        for (int i = 0; i < n; ++i) {
            jobs[i] = new int[] {startTime[i], endTime[i], profit[i]};
        }
        Arrays.sort(jobs, (a, b) -> a[0] - b[0]);
        f = new int[n];
        return dfs(0);
    }

    private int dfs(int i) {
        if (i >= n) {
            return 0;
        }
        if (f[i] != 0) {
            return f[i];
        }
        int e = jobs[i][1], p = jobs[i][2];
        int j = search(jobs, e, i + 1);
        int ans = Math.max(dfs(i + 1), p + dfs(j));
        f[i] = ans;
        return ans;
    }

    private int search(int[][] jobs, int x, int i) {
        int left = i, right = n;
        while (left < right) {
            int mid = (left + right) >> 1;
            if (jobs[mid][0] >= x) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
public:
    int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
        int n = profit.size();
        vector<tuple<int, int, int>> jobs(n);
        for (int i = 0; i < n; ++i) jobs[i] = {startTime[i], endTime[i], profit[i]};
        sort(jobs.begin(), jobs.end());
        vector<int> f(n);
        function<int(int)> dfs = [&](int i) -> int {
            if (i >= n) return 0;
            if (f[i]) return f[i];
            auto [_, e, p] = jobs[i];
            tuple<int, int, int> t{e, 0, 0};
            int j = lower_bound(jobs.begin() + i + 1, jobs.end(), t, [&](auto& l, auto& r) -> bool { return get<0>(l) < get<0>(r); }) - jobs.begin();
            int ans = max(dfs(i + 1), p + dfs(j));
            f[i] = ans;
            return ans;
        };
        return dfs(0);
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func jobScheduling(startTime []int, endTime []int, profit []int) int {
    n := len(profit)
    type tuple struct{ s, e, p int }
    jobs := make([]tuple, n)
    for i, p := range profit {
        jobs[i] = tuple{startTime[i], endTime[i], p}
    }
    sort.Slice(jobs, func(i, j int) bool { return jobs[i].s < jobs[j].s })
    f := make([]int, n)
    var dfs func(int) int
    dfs = func(i int) int {
        if i >= n {
            return 0
        }
        if f[i] != 0 {
            return f[i]
        }
        j := sort.Search(n, func(j int) bool { return jobs[j].s >= jobs[i].e })
        ans := max(dfs(i+1), jobs[i].p+dfs(j))
        f[i] = ans
        return ans
    }
    return dfs(0)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
function jobScheduling(startTime: number[], endTime: number[], profit: number[]): number {
    const n = startTime.length;
    const f = new Array(n).fill(0);
    const idx = new Array(n).fill(0).map((_, i) => i);
    idx.sort((i, j) => startTime[i] - startTime[j]);
    const search = (x: number) => {
        let l = 0;
        let r = n;
        while (l < r) {
            const mid = (l + r) >> 1;
            if (startTime[idx[mid]] >= x) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l;
    };
    const dfs = (i: number): number => {
        if (i >= n) {
            return 0;
        }
        if (f[i] !== 0) {
            return f[i];
        }
        const j = search(endTime[idx[i]]);
        return (f[i] = Math.max(dfs(i + 1), dfs(j) + profit[idx[i]]));
    };
    return dfs(0);
}

Thinking

Solution 1 sorts by start and fills one suffix table. Sorting by end instead, \(dp[i]\) is the best profit among the first \(i\) jobs: skip inherits \(dp[i-1]\); take adds \(dp[j]\) for the last job that ends before this start, with \(j\) still from binary search.

Solution 1 sorts by start and fills a suffix table. Here we sort by end and define a prefix table.

First, sort the jobs, this time we sort by end time in ascending order, then define \(dp[i]\), which represents the maximum profit that can be obtained from the first \(i\) jobs. The answer is \(dp[n]\). Initialize \(dp[0]=0\).

For the \(i\)-th job, we can choose to do it or not. If we don't do it, the maximum profit is \(dp[i]\); if we do it, we can use binary search to find the last job that ends before the start time of the \(i\)-th job, denoted as \(j\), then the maximum profit is \(\textit{profit}[i] + dp[j]\). We take the larger of the two. That is:

\[ dp[i+1] = \max(dp[i], \textit{profit}[i] + dp[j]) \]

Where \(j\) is the largest index that satisfies \(\textit{endTime}[j] \leq \textit{startTime}[i]\).

The time complexity is \(O(n \log n)\), where \(n\) is the number of jobs.

Similar problems:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution:
    def jobScheduling(
        self, startTime: list[int], endTime: list[int], profit: list[int]
    ) -> int:
        jobs = sorted(zip(endTime, startTime, profit))
        n = len(profit)
        dp = [0] * (n + 1)
        for i, (_, s, p) in enumerate(jobs):
            j = bisect_right(jobs, s, hi=i, key=lambda x: x[0])
            dp[i + 1] = max(dp[i], dp[j] + p)
        return dp[n]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Solution {
    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
        int n = profit.length;
        int[][] jobs = new int[n][3];
        for (int i = 0; i < n; ++i) {
            jobs[i] = new int[] {startTime[i], endTime[i], profit[i]};
        }
        Arrays.sort(jobs, (a, b) -> a[1] - b[1]);
        int[] dp = new int[n + 1];
        for (int i = 0; i < n; ++i) {
            int j = search(jobs, jobs[i][0], i);
            dp[i + 1] = Math.max(dp[i], dp[j] + jobs[i][2]);
        }
        return dp[n];
    }

    private int search(int[][] jobs, int x, int n) {
        int left = 0, right = n;
        while (left < right) {
            int mid = (left + right) >> 1;
            if (jobs[mid][1] > x) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Solution {
public:
    int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
        int n = profit.size();
        vector<tuple<int, int, int>> jobs(n);
        for (int i = 0; i < n; ++i) jobs[i] = {endTime[i], startTime[i], profit[i]};
        sort(jobs.begin(), jobs.end());
        vector<int> dp(n + 1);
        for (int i = 0; i < n; ++i) {
            auto [_, s, p] = jobs[i];
            int j = upper_bound(jobs.begin(), jobs.begin() + i, s, [&](int x, auto& job) -> bool { return x < get<0>(job); }) - jobs.begin();
            dp[i + 1] = max(dp[i], dp[j] + p);
        }
        return dp[n];
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
func jobScheduling(startTime []int, endTime []int, profit []int) int {
    n := len(profit)
    type tuple struct{ s, e, p int }
    jobs := make([]tuple, n)
    for i, p := range profit {
        jobs[i] = tuple{startTime[i], endTime[i], p}
    }
    sort.Slice(jobs, func(i, j int) bool { return jobs[i].e < jobs[j].e })
    dp := make([]int, n+1)
    for i, job := range jobs {
        j := sort.Search(i, func(k int) bool { return jobs[k].e > job.s })
        dp[i+1] = max(dp[i], dp[j]+job.p)
    }
    return dp[n]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
function jobScheduling(startTime: number[], endTime: number[], profit: number[]): number {
    const n = profit.length;
    const jobs: [number, number, number][] = Array.from({ length: n }, (_, i) => [
        startTime[i],
        endTime[i],
        profit[i],
    ]);
    jobs.sort((a, b) => a[1] - b[1]);
    const dp: number[] = Array.from({ length: n + 1 }, () => 0);
    const search = (x: number, right: number): number => {
        let left = 0;
        while (left < right) {
            const mid = (left + right) >> 1;
            if (jobs[mid][1] > x) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    };
    for (let i = 0; i < n; ++i) {
        const j = search(jobs[i][0], i);
        dp[i + 1] = Math.max(dp[i], dp[j] + jobs[i][2]);
    }
    return dp[n];
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Solution {

    func binarySearch<T: Comparable>(inputArr: [T], searchItem: T) -> Int? {
        var lowerIndex = 0
        var upperIndex = inputArr.count - 1

        while lowerIndex < upperIndex {
            let currentIndex = (lowerIndex + upperIndex) / 2
            if inputArr[currentIndex] <= searchItem {
                lowerIndex = currentIndex + 1
            } else {
                upperIndex = currentIndex
            }
        }

        if inputArr[upperIndex] <= searchItem {
            return upperIndex + 1
        }
        return lowerIndex
    }

    func jobScheduling(_ startTime: [Int], _ endTime: [Int], _ profit: [Int]) -> Int {
        let zipList = zip(zip(startTime, endTime), profit)
        var table: [(startTime: Int, endTime: Int, profit: Int, cumsum: Int)] = []

        for ((x, y), z) in zipList {
            table.append((x, y, z, 0))
        }
        table.sort(by: { $0.endTime < $1.endTime })
        let sortedEndTime = endTime.sorted()

        var profits: [Int] = [0]
        for iJob in table {
            let index: Int! = binarySearch(inputArr: sortedEndTime, searchItem: iJob.startTime)
            if profits.last! < profits[index] + iJob.profit {
                profits.append(profits[index] + iJob.profit)
            } else {
                profits.append(profits.last!)
            }
        }
        return profits.last!
    }
}

Thinking

Jobs must not overlap. \(n \le 5\times 10^4\) rules out subset search. Whether we take job \(i\) only affects jobs that start no earlier than its end.

After sorting by start, skipping calls \(i+1\) before it returns, so the chain has length \(n\) and overflows the stack.

Later indices are known if we walk from the end. Let \(f[i]\) be the best profit from job \(i\), with \(f[n]=0\), and binary-search the next compatible job while filling \(i\) from \(n-1\) down to \(0\).

First, we sort the jobs by start time in ascending order. Let \(f[i]\) be the maximum profit that can be obtained starting from the \(i\)-th job. The answer is \(f[0]\), and \(f[n] = 0\).

Fill \(i\) from \(n - 1\) down to \(0\). For the \(i\)-th job we can skip it, which keeps \(f[i + 1]\), or take it. Binary search finds the first job \(j\) that starts at or after \(\textit{end}_i\). Taking it earns \(\textit{profit}[i] + f[j]\). Take the larger of the two:

\[ f[i]=\max(f[i+1],\textit{profit}[i]+f[j]) \]

Where \(j\) is the smallest index that satisfies \(\textit{startTime}[j] \ge \textit{endTime}[i]\). Because \(j > i\), \(f[j]\) is already filled.

The time complexity is \(O(n \log n)\), where \(n\) is the number of jobs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Solution:
    def jobScheduling(
        self, startTime: list[int], endTime: list[int], profit: list[int]
    ) -> int:
        jobs = sorted(zip(startTime, endTime, profit))
        n = len(profit)
        f = [0] * (n + 1)
        for i in range(n - 1, -1, -1):
            _, e, p = jobs[i]
            j = bisect_left(jobs, e, lo=i + 1, key=lambda x: x[0])
            f[i] = max(f[i + 1], p + f[j])
        return f[0]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Solution {
    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
        int n = profit.length;
        int[][] jobs = new int[n][3];
        for (int i = 0; i < n; ++i) {
            jobs[i] = new int[] {startTime[i], endTime[i], profit[i]};
        }
        Arrays.sort(jobs, (a, b) -> a[0] - b[0]);
        int[] f = new int[n + 1];
        for (int i = n - 1; i >= 0; --i) {
            int e = jobs[i][1], p = jobs[i][2];
            int j = search(jobs, e, i + 1);
            f[i] = Math.max(f[i + 1], p + f[j]);
        }
        return f[0];
    }

    private int search(int[][] jobs, int x, int i) {
        int left = i, right = jobs.length;
        while (left < right) {
            int mid = (left + right) >> 1;
            if (jobs[mid][0] >= x) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class Solution {
public:
    int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
        int n = profit.size();
        vector<tuple<int, int, int>> jobs(n);
        for (int i = 0; i < n; ++i) jobs[i] = {startTime[i], endTime[i], profit[i]};
        sort(jobs.begin(), jobs.end());
        vector<int> f(n + 1);
        for (int i = n - 1; i >= 0; --i) {
            auto [_, e, p] = jobs[i];
            tuple<int, int, int> t{e, 0, 0};
            int j = lower_bound(jobs.begin() + i + 1, jobs.end(), t, [&](auto& l, auto& r) -> bool { return get<0>(l) < get<0>(r); }) - jobs.begin();
            f[i] = max(f[i + 1], p + f[j]);
        }
        return f[0];
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
func jobScheduling(startTime []int, endTime []int, profit []int) int {
    n := len(profit)
    type tuple struct{ s, e, p int }
    jobs := make([]tuple, n)
    for i, p := range profit {
        jobs[i] = tuple{startTime[i], endTime[i], p}
    }
    sort.Slice(jobs, func(i, j int) bool { return jobs[i].s < jobs[j].s })
    f := make([]int, n+1)
    for i := n - 1; i >= 0; i-- {
        j := sort.Search(n, func(k int) bool { return jobs[k].s >= jobs[i].e })
        f[i] = max(f[i+1], jobs[i].p+f[j])
    }
    return f[0]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function jobScheduling(startTime: number[], endTime: number[], profit: number[]): number {
    const n = startTime.length;
    const f = new Array(n + 1).fill(0);
    const idx = new Array(n).fill(0).map((_, i) => i);
    idx.sort((i, j) => startTime[i] - startTime[j]);
    const search = (x: number, left: number) => {
        let l = left;
        let r = n;
        while (l < r) {
            const mid = (l + r) >> 1;
            if (startTime[idx[mid]] >= x) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l;
    };
    for (let i = n - 1; i >= 0; --i) {
        const j = search(endTime[idx[i]], i + 1);
        f[i] = Math.max(f[i + 1], f[j] + profit[idx[i]]);
    }
    return f[0];
}

Comments