int maxNonOverlapping(vector<pair<int, int>>& intervals) {
    // Sort by end time
    sort(intervals.begin(), intervals.end(), [](auto& a, auto& b) {
        return a.second < b.second;
    });
    
    int count = 0, lastEnd = INT_MIN;
    
    for (auto& [start, end] : intervals) {
        if (start >= lastEnd) {
            count++;
            lastEnd = end;
        }
    }
    
    return count;
}

int minLateness(vector<pair<int, int>>& tasks) {  // {duration, deadline}
    sort(tasks.begin(), tasks.end(), [](auto& a, auto& b) {
        return a.second < b.second;  // Sort by deadline
    });
    
    int time = 0, maxLate = 0;
    
    for (auto& [duration, deadline] : tasks) {
        time += duration;
        maxLate = max(maxLate, time - deadline);
    }
    
    return maxLate;
}

double fractionalKnapsack(vector<pair<int, int>>& items, int W) {
    // Sort by value/weight ratio descending -- most valuable per unit first
    sort(items.begin(), items.end(), [](auto& a, auto& b) {
        return (double)a.second / a.first > (double)b.second / b.first;
    });
    
    double totalValue = 0;
    
    for (auto& [weight, value] : items) {
        if (W >= weight) {
            W -= weight;
            totalValue += value;
        } else {
            totalValue += (double)W / weight * value;
            break;
        }
    }
    
    return totalValue;
}

long long minMergeCost(vector<int>& arr) {
    // Min-heap: always access the two smallest elements
    priority_queue<long long, vector<long long>, greater<long long>> pq(arr.begin(), arr.end());
    
    long long totalCost = 0;
    
    while (pq.size() > 1) {
        long long a = pq.top(); pq.pop();  // Smallest
        long long b = pq.top(); pq.pop();  // Second smallest
        
        totalCost += a + b;    // Pay the merge cost
        pq.push(a + b);        // Merged element goes back into the heap
    }
    
    return totalCost;
}
// Time: O(n log n) -- n-1 merges, each with O(log n) heap operations

bool canJump(vector<int>& nums) {
    int maxReach = 0;  // The farthest index we can reach so far
    
    for (int i = 0; i < nums.size(); i++) {
        if (i > maxReach) return false;  // Can't reach position i at all
        maxReach = max(maxReach, i + nums[i]);  // Extend our reach
    }
    
    return true;  // maxReach >= n-1
}

// Minimum jumps to reach end (BFS-like greedy)
// Think of it as BFS levels: each "jump" covers a range of positions
int minJumps(vector<int>& nums) {
    int jumps = 0, currentEnd = 0, farthest = 0;
    
    for (int i = 0; i < nums.size() - 1; i++) {
        farthest = max(farthest, i + nums[i]);  // Farthest reach from current level
        
        if (i == currentEnd) {  // Exhausted current jump's range
            jumps++;             // Must take another jump
            currentEnd = farthest;  // New range boundary
            // If currentEnd >= n-1, we will reach the end
        }
    }
    
    return jumps;
}
// Worked example: nums = [2, 3, 1, 1, 4]
// i=0: farthest=2, i==currentEnd(0) -> jumps=1, currentEnd=2
// i=1: farthest=4, i!=2
// i=2: farthest=4, i==currentEnd(2) -> jumps=2, currentEnd=4
// Answer: 2 jumps (0->1->4)

int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
    int total = 0, tank = 0, start = 0;
    
    for (int i = 0; i < gas.size(); i++) {
        int diff = gas[i] - cost[i];  // Net gas gain at station i
        total += diff;  // Track global gas balance
        tank += diff;   // Track current attempt's gas balance
        
        if (tank < 0) {
            start = i + 1;  // Can't start from any station [start..i]
            tank = 0;       // Reset tank for new starting attempt
        }
    }
    
    return total >= 0 ? start : -1;  // -1 if total gas < total cost
}

Can you sort the input?
├── Yes → After sorting, can you process greedily?
│   ├── Yes → Try to prove with exchange argument
│   │   ├── Proof works → Use greedy
│   │   └── Can't prove → Test edge cases, maybe DP
│   └── No clear greedy order → Likely DP or other
└── No → Is there a single pass greedy?
    ├── Yes → Track running max/min/sum
    └── No → Probably not greedy