# Problem

There are N children standing in a line. Each child is assigned a rating value.

You are giving candies to these children subjected to the following requirements:

• Each child must have at least one candy.
• Children with a higher rating get more candies than their neighbors.

What is the minimum candies you must give?

Example 1:

Input: [1,0,2]
Output: 5
Explanation: You can allocate to the first, second and third child with 2, 1, 2 candies respectively.


Example 2:

Input: [1,2,2]
Output: 4
Explanation: You can allocate to the first, second and third child with 1, 2, 1 candies respectively.
The third child gets 1 candy because it satisfies the above two conditions.


# Solution: Greedy

First pass: left to right, the right one will have one more candy than the left one if taller.

Second pass: right to left, the left one will be at least one more candy than the right one if taller.

Time Complexity: O(n)

Space Complexity: O(n)

C++

# Problem

At a lemonade stand, each lemonade costs $5. Customers are standing in a queue to buy from you, and order one at a time (in the order specified by bills). Each customer will only buy one lemonade and pay with either a $5$10, or $20 bill.  You must provide the correct change to each customer, so that the net transaction is that the customer pays $5. Note that you don’t have any change in hand at first. Return true if and only if you can provide every customer with correct change. Example 1: Input: [5,5,5,10,20] Output: true Explanation: From the first 3 customers, we collect three$5 bills in order.
From the fourth customer, we collect a $10 bill and give back a$5.
From the fifth customer, we give a $10 bill and a$5 bill.
Since all customers got correct change, we output true.


Example 2:

Input: [5,5,10]
Output: true


Example 3:

Input: [10,10]
Output: false


Example 4:

Input: [5,5,10,10,20]
Output: false
Explanation:
From the first two customers in order, we collect two $5 bills. For the next two customers in order, we collect a$10 bill and give back a $5 bill. For the last customer, we can't give change of$15 back because we only have two $10 bills. Since not every customer received correct change, the answer is false.  # Solution: Simulation + Greedy Always use 10 bill first. Time complexity: O(n) Space complexity: O(1) C++ # Problem There are a number of spherical balloons spread in two-dimensional space. For each balloon, provided input is the start and end coordinates of the horizontal diameter. Since it’s horizontal, y-coordinates don’t matter and hence the x-coordinates of start and end of the diameter suffice. Start is always smaller than end. There will be at most 104 balloons. An arrow can be shot up exactly vertically from different points along the x-axis. A balloon with xstart and xendbursts by an arrow shot at x if xstart ≤ x ≤ xend. There is no limit to the number of arrows that can be shot. An arrow once shot keeps travelling up infinitely. The problem is to find the minimum number of arrows that must be shot to burst all balloons. Example: Input: [[10,16], [2,8], [1,6], [7,12]] Output: 2 Explanation: One way is to shoot one arrow for example at x = 6 (bursting the balloons [2,8] and [1,6]) and another arrow at x = 11 (bursting the other two balloons).  # Solution: Sweep Line Time complexity: O(nlogn) Space complexity: O(1) C++ # Related Problems # Problem 题目大意：给你一些牌，问你能否分组，要求每组w张连续的牌。 https://leetcode.com/problems/hand-of-straights/description/ Alice has a hand of cards, given as an array of integers. Now she wants to rearrange the cards into groups so that each group is size W, and consists of W consecutive cards. Return true if and only if she can. Example 1: Input: hand = [1,2,3,6,2,3,4,7,8], W = 3 Output: true Explanation: Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8]. Example 2: Input: hand = [1,2,3,4,5], W = 4 Output: false Explanation: Alice's hand can't be rearranged into groups of 4. Note: 1. 1 <= hand.length <= 10000 2. 0 <= hand[i] <= 10^9 3. 1 <= W <= hand.length # Solution: Greedy Time complexity: O(nlogn) Space complexity: O(n) # Problem We have jobs: difficulty[i] is the difficulty of the ith job, and profit[i] is the profit of the ith job. Now we have some workers. worker[i] is the ability of the ith worker, which means that this worker can only complete a job with difficulty at most worker[i]. Every worker can be assigned at most one job, but one job can be completed multiple times. For example, if 3 people attempt the same job that pays$1, then the total profit will be $3. If a worker cannot complete any job, his profit is$0.

What is the most profit we can make?

Example 1:

Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
Output: 100
Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get profit of [20,20,30,30] seperately.

Notes:

• 1 <= difficulty.length = profit.length <= 10000
• 1 <= worker.length <= 10000
• difficulty[i], profit[i], worker[i]  are in range [1, 10^5]

# Solution 1: Sorting + Two pointers

Time complexity: O(nlogn + mlogm)

Space complexity: O(n)

# Solution 2: Bucket + Greedy

Key idea: for each difficulty D, find the most profit job whose requirement is <= D.

Three steps:

1. for each difficulty D, find the most profit job whose requirement is == D, best[D] = max{profit of difficulty D}.
2. if difficulty D – 1 can make more profit than difficulty D, best[D] = max(best[D], best[D – 1]).
3. The max profit each worker at skill level D can make is best[D].

Time complexity: O(n)

Space complexity: O(10000)

C++

C++ using map