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

<p>You&#39;re given the <code>startTime</code>, <code>endTime</code> and <code>profit</code> arrays, return the maximum profit you can take such that there are no two jobs in the subset with overlapping time range.</p>

<p>If you choose a job that ends at time <code>X</code> you will be able to start another job that starts at time <code>X</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/10/10/sample1_1584.png" style="width: 380px; height: 154px;" /></strong></p>

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

<p><strong class="example">Example 2:</strong></p>

<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/10/10/sample22_1584.png" style="width: 600px; height: 112px;" /> </strong></p>

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

<p><strong class="example">Example 3:</strong></p>

<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/10/10/sample3_1584.png" style="width: 400px; height: 112px;" /></strong></p>

<pre>
<strong>Input:</strong> startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
<strong>Output:</strong> 6
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= startTime.length == endTime.length == profit.length &lt;= 5 * 10<sup>4</sup></code></li>
	<li><code>1 &lt;= startTime[i] &lt; endTime[i] &lt;= 10<sup>9</sup></code></li>
	<li><code>1 &lt;= profit[i] &lt;= 10<sup>4</sup></code></li>
</ul>

from functools import cache
from collections import defaultdict

class Solution:
    def jobScheduling(self, startTime: List[int], endTime: List[int], profit: List[int]) -> int:
        sorted_buckets = defaultdict(list)
        for idx, start_time in enumerate(startTime):
            sorted_buckets[start_time].append(idx)
        index = sorted(sorted_buckets.keys())

        @cache
        def find_next_start_time(end_time):
            low, high = 0, len(index)
            while low < high:
                mid = (low + high) // 2
                time = index[mid]
                if time < end_time:
                    low = mid + 1
                else:
                    high = mid
            return low, 0

        def step_forward(start_time_idx, block_idx):
            if len(sorted_buckets[index[start_time_idx]]) == block_idx + 1:
                return start_time_idx + 1, 0
            else:
                return start_time_idx, block_idx + 1

        '''
        dp[start, idxs] := 
            Given a start time cutoff, and a list of available blocks, return maximum profit
            
            either the first block is used or not. if used, then advance to end time and try again
            otherwise, move to next block (advancing startTime too) and try again

            base case: if no valid blocks after startTime, or if idx out of range, 0 profit
        '''
        @cache
        def max_profit(start_time_idx, block_idx):
            if start_time_idx >= len(index):
                return 0

            underlying_block_idx = sorted_buckets[index[start_time_idx]][block_idx]
            
            block_profit, block_end_time = profit[underlying_block_idx], endTime[underlying_block_idx]
            return max(
                block_profit + max_profit(*find_next_start_time(block_end_time)),
                max_profit(*step_forward(start_time_idx, block_idx))
            )
        return max_profit(0, 0)
        

92506