Posts tagged as “greedy”

花花酱 LeetCode 826. Most Profit Assigning Work

By zxi on April 29, 2018

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)

// Author: Huahua

// Running time: 90 ms

class Solution {

public:

int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {

const int n = difficulty.size();

vector<pair<int, int>> jobs; // difficulty, profit

for (int i = 0; i < n; ++i)

jobs.emplace_back(difficulty[i], profit[i]);

std::sort(jobs.begin(), jobs.end());

std::sort(worker.begin(), worker.end());

int ans = 0;

int i = 0;

int best = 0;

for (int level : worker) {

while (i < n && level >= jobs[i].first)

best = max(best, jobs[i++].second);

ans += best;

}

return ans;

}

};

Solution 2: Bucket + Greedy

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

Three steps:

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

Time complexity: O(n)

Space complexity: O(10000)

C++

// Author: Huahua

// Running time: 112 ms

class Solution {

public:

int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {

const int N = 100000;

// max profit at difficulty i

vector<int> max_profit(N + 1, 0);

for (int i = 0; i < difficulty.size(); ++i)

max_profit[difficulty[i]] = max(max_profit[difficulty[i]], profit[i]);

for (int i = 2; i <= N; ++i)

max_profit[i] = max(max_profit[i], max_profit[i - 1]);

int ans = 0;

for (int level : worker)

ans += max_profit[level];

return ans;

}

};

C++ using map

// Author: Huahua

// Running time: 112 ms

class Solution {

public:

int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {

map<int, int> bests;

for (int i = 0; i < difficulty.size(); ++i)

bests[difficulty[i]] = max(bests[difficulty[i]], profit[i]);

int best = 0;

for (auto it = bests.begin(); it != bests.end(); ++it)

it->second = best = max(it->second, best);

int ans = 0;

for (int level : worker)

ans += prev(bests.upper_bound(level))->second;

return ans;

}

};

花花酱 LeetCode 822. Card Flipping Game

By zxi on April 29, 2018

Problem

题目大意：每张牌的正反面各印着一个数，你可以随便翻牌。找出一个最小的数使得其他牌当前正面的数值都不和它相等。

On a table are N cards, with a positive integer printed on the front and back of each card (possibly different).

We flip any number of cards, and after we choose one card.

If the number X on the back of the chosen card is not on the front of any card, then this number X is good.

What is the smallest number that is good? If no number is good, output 0.

Here, fronts[i] and backs[i] represent the number on the front and back of card i.

A flip swaps the front and back numbers, so the value on the front is now on the back and vice versa.

Example:

Input: fronts = [1,2,4,4,7], backs = [1,3,4,1,3]
Output: 2
Explanation: If we flip the second card, the fronts are [1,3,4,4,7] and the backs are [1,2,4,1,3]. We choose the second card, which has number 2 on the back, and it isn't on the front of any card, so 2 is good.

Note:

1 <= fronts.length == backs.length <= 1000.
1 <= fronts[i] <= 2000.
1 <= backs[i] <= 2000.

Solution: Hashset

C++

// Author: Huahua

// Running time: 23 ms

class Solution {

public:

int flipgame(vector<int>& fronts, vector<int>& backs) {

unordered_set<int> same;

for (int i = 0; i < fronts.size(); ++i)

if (fronts[i] == backs[i])

same.insert(fronts[i]);

int ans = INT_MAX;

for (int v : fronts)

if (v < ans && !same.count(v)) ans = v;

for (int v : backs)

if (v < ans && !same.count(v)) ans = v;

return ans == INT_MAX ? 0 : ans;

}

};

花花酱 LeetCode 807. Max Increase to Keep City Skyline

By zxi on March 24, 2018

Problem

题目大意：给你一个二维地图和每个坐标的大楼高度，求出总增高的最大值使得城市的天际线（投影）保持不变。

In a 2 dimensional array grid, each value grid[i][j] represents the height of a building located there. We are allowed to increase the height of any number of buildings, by any amount (the amounts can be different for different buildings). Height 0 is considered to be a building as well.

At the end, the “skyline” when viewed from all four directions of the grid, i.e. top, bottom, left, and right, must be the same as the skyline of the original grid. A city’s skyline is the outer contour of the rectangles formed by all the buildings when viewed from a distance. See the following example.

What is the maximum total sum that the height of the buildings can be increased?

Example:
Input: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
Output: 35
Explanation: 
The grid is:
[ [3, 0, 8, 4], 
  [2, 4, 5, 7],
  [9, 2, 6, 3],
  [0, 3, 1, 0] ]

The skyline viewed from top or bottom is: [9, 4, 8, 7]
The skyline viewed from left or right is: [8, 7, 9, 3]

The grid after increasing the height of buildings without affecting skylines is:

gridNew = [ [8, 4, 8, 7],
            [7, 4, 7, 7],
            [9, 4, 8, 7],
            [3, 3, 3, 3] ]

Notes:

1 < grid.length = grid[0].length <= 50.
All heights grid[i][j] are in the range [0, 100].
All buildings in grid[i][j] occupy the entire grid cell: that is, they are a 1 x 1 x grid[i][j] rectangular prism.

Solution: Greedy

Find the max of each row and column, increase the height of building at i,j to min(max_row[i], max_col[j]).

Time Complexity: O(m*n)

Space complexity: O(m+n)

C++

// Author: Huahua

class Solution {

public:

int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {

int m = grid.size();

int n = grid[0].size();

vector<int> x(n, 0);

vector<int> y(n, 0);

for (int i = 0; i < m; ++i)

for (int j = 0; j < n; ++j) {

x[j] = max(x[j], grid[i][j]);

y[i] = max(y[i], grid[i][j]);

}

int ans = 0;

for (int i = 0; i < m; ++i)

for (int j = 0; j < n; ++j)

ans += min(x[i], y[j]) - grid[i][j];

return ans;

}

};

花花酱 LeetCode 789. Escape The Ghosts

By zxi on February 24, 2018

题目大意：给你目的地坐标以及幽灵的坐标，初始点在(0,0)，每次你和幽灵都可以移动一步。问你是否可以安全到达终点。

You are playing a simplified Pacman game. You start at the point (0, 0), and your destination is (target[0], target[1]). There are several ghosts on the map, the i-th ghost starts at (ghosts[i][0], ghosts[i][1]).

Each turn, you and all ghosts simultaneously *may* move in one of 4 cardinal directions: north, east, west, or south, going from the previous point to a new point 1 unit of distance away.

You escape if and only if you can reach the target before any ghost reaches you (for any given moves the ghosts may take.) If you reach any square (including the target) at the same time as a ghost, it doesn’t count as an escape.

Return True if and only if it is possible to escape.

Example 1:

Input:

ghosts = [[1, 0], [0, 3]]

target = [0, 1]

Output: true

Explanation:

You can directly reach the destination (0, 1) at time 1, while the ghosts located at (1, 0) or (0, 3) have no way to catch up with you.

Example 2:

Input:

ghosts = [[1, 0]]

target = [2, 0]

Output: false

Explanation:

You need to reach the destination (2, 0), but the ghost at (1, 0) lies between you and the destination.

Example 3:

Input:

ghosts = [[2, 0]]

target = [1, 0]

Output: false

Explanation:

The ghost can reach the target at the same time as you.

Note:

All points have coordinates with absolute value <= 10000.
The number of ghosts will not exceed 100.

Solution: Greedy / Math

You can escape if and only if no ghosts can reach target before you. Just need to compare the Manhattan distance.

如果所有的幽灵都无法在你之前到达target，那么你可以逃脱。只要比较曼哈顿距离即可。

C++

Time complexity: O(|ghost|)

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

bool escapeGhosts(vector<vector<int>>& ghosts, vector<int>& target) {

const int steps = abs(target[0]) + abs(target[1]);

for (const auto& g: ghosts)

if (abs(g[0] - target[0]) + abs(g[1] - target[1]) <= steps)

return false;

return true;

}

};

Java

// Author: Huahua

// Running time: 4 ms

class Solution {

public boolean escapeGhosts(int[][] ghosts, int[] target) {

final int steps = Math.abs(target[0]) + Math.abs(target[1]);

for (int[] g : ghosts)

if (Math.abs(g[0] - target[0]) + Math.abs(g[1] - target[1]) <= steps)

return false;

return true;

}

Python3

"""

Author: Huahua

Running time: 40 ms

"""

class Solution:

def escapeGhosts(self, ghosts, target):

steps = abs(target[0]) + abs(target[1])

return not any(abs(x - target[0]) + abs(y - target[1]) <= steps for x, y in ghosts)

花花酱 LeetCode 763. Partition Labels

By zxi on January 25, 2018

题目大意：把字符串分割成尽量多的不重叠子串，输出子串的长度数组。要求相同字符只能出现在一个子串中。

Problem:

A string S of lowercase letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts.

Example 1:

Input: S = "ababcbacadefegdehijhklij"

Output: [9,7,8]

Explanation:

The partition is "ababcbaca", "defegde", "hijhklij".

This is a partition so that each letter appears in at most one part.

A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

Solution 0: Brute Force

Time complexity: O(n^2)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 15 ms

class Solution {

public:

vector<int> partitionLabels(string S) {

vector<int> ans;

size_t start = 0;

size_t end = 0;

for (size_t i = 0; i < S.size(); ++i) {

end = max(end, S.find_last_of(S[i]));

if (i == end) {

ans.push_back(end - start + 1);

start = end + 1;

}

return ans;

}

};

Python

"""

Author: Huahua

Running time : 48 ms

"""

class Solution:

def partitionLabels(self, S):

ans = []

start, end = 0, 0

for i in range(len(S)):

end = max(end, S.rfind(S[i]))

if i == end:

ans.append(end - start + 1)

start = end + 1

return ans

Solution 1: Greedy

Time complexity: O(n)

Space complexity: O(26/128)

C++

// Author: Huahua

// Running time: 6 ms

class Solution {

public:

vector<int> partitionLabels(string S) {

vector<int> last_index(128, 0);

for (int i = 0; i < S.size(); ++i)

last_index[S[i]] = i;

vector<int> ans;

int start = 0;

int end = 0;

for (int i = 0; i < S.size(); ++i) {

end = max(end, last_index[S[i]]);

if (i == end) {

ans.push_back(end - start + 1);

start = end + 1;

}

return ans;

}

};

Java

// Author: Huahua

// Running time: 16 ms

class Solution {

public List<Integer> partitionLabels(String S) {

int lastIndex[] = new int[128];

for (int i = 0; i < S.length(); ++i)

lastIndex[(int)S.charAt(i)] = i;

List<Integer> ans = new ArrayList<>();

int start = 0;

int end = 0;

for (int i = 0; i < S.length(); ++i) {

end = Math.max(end, lastIndex[(int)S.charAt(i)]);

if (i == end) {

ans.add(end - start + 1);

start = end + 1;

}

return ans;

}

Python3

"""

Author: Huahua

Running time: 78 ms

"""

class Solution:

def partitionLabels(self, S):

last_index = {}

for i, ch in enumerate(S):

last_index[ch] = i

start = end = 0

ans = []

for i, ch in enumerate(S):

end = max(end, last_index[ch])

if i == end:

ans.append(end - start + 1)

start = end + 1

return ans