Problem:

Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k <= m + n from digits of the two. The relative order of the digits from the same array must be preserved. Return an array of the k digits. You should try to optimize your time and space complexity.

Example 1:

nums1 = [3, 4, 6, 5]
nums2 = [9, 1, 2, 5, 8, 3]
k = 5
return [9, 8, 6, 5, 3]

Example 2:

nums1 = [6, 7]
nums2 = [6, 0, 4]
k = 5
return [6, 7, 6, 0, 4]

Example 3:

nums1 = [3, 9]
nums2 = [8, 9]
k = 3
return [9, 8, 9]

题目大意：给你两个数字数组和k，返回从两个数组中选取k个数字能够组成的最大值。

Idea: Greedy + DP

Solution:

Time complexity: O(k * (n1+n2)^2)

Space complexity: O(n1+n2)

C++

// Author: Huahua

// Runtime: 26 ms

class Solution {

public:

vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {

vector<int> ans;

const int n1 = nums1.size();

const int n2 = nums2.size();

for (int i = max(0, k - n2); i <= min(k, n1); ++i)

ans = max(ans, maxNumber(maxNumber(nums1, i),

maxNumber(nums2, k - i)));

return ans;

}

private:

vector<int> maxNumber(const vector<int>& nums, int k) {

vector<int> ans(k);

int j = 0;

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

while (j > 0 && nums[i] > ans[j - 1]

&& nums.size() - i > k - j) --j;

if (j < k) ans[j++] = nums[i];

}

return ans;

}

vector<int> maxNumber(const vector<int>& nums1, const vector<int>& nums2) {

vector<int> ans(nums1.size() + nums2.size());

auto s1 = nums1.cbegin();

auto e1 = nums1.cend();

auto s2 = nums2.cbegin();

auto e2 = nums2.cend();

int index = 0;

while (s1 != e1 || s2 != e2)

ans[index++] =

lexicographical_compare(s1, e1, s2, e2) ? *s2++ : *s1++;

return ans;

}

};

Java

// Author: Huahua

// Runtime: 18 ms

class Solution {

public int[] maxNumber(int[] nums1, int[] nums2, int k) {

int[] best = new int[0];

for (int i = Math.max(0, k - nums2.length);

i <= Math.min(k, nums1.length); ++i)

best = max(best, 0,

maxNumber(maxNumber(nums1, i),

maxNumber(nums2, k - i)), 0);

return best;

}

private int[] maxNumber(int[] nums, int k) {

int[] ans = new int[k];

int j = 0;

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

while (j > 0 && nums[i] > ans[j - 1]

&& nums.length - i > k - j) --j;

if (j < k)

ans[j++] = nums[i];

}

return ans;

}

private int[] maxNumber(int[] nums1, int[] nums2) {

int[] ans = new int[nums1.length + nums2.length];

int s1 = 0;

int s2 = 0;

int index = 0;

while (s1 != nums1.length || s2 != nums2.length)

ans[index++] = max(nums1, s1, nums2, s2) == nums1 ?

nums1[s1++] : nums2[s2++];

return ans;

}

private int[] max(int[] nums1, int s1, int[] nums2, int s2) {

for (int i = s1; i < nums1.length; ++i) {

int j = s2 + i - s1;

if (j >= nums2.length) return nums1;

if (nums1[i] < nums2[j]) return nums2;

if (nums1[i] > nums2[j]) return nums1;

}

return nums2;

}

https://leetcode.com/problems/cut-off-trees-for-golf-event/

Problem:

You are asked to cut off trees in a forest for a golf event. The forest is represented as a non-negative 2D map, in this map:

0 represents the obstacle can’t be reached.
1 represents the ground can be walked through.
The place with number bigger than 1 represents a tree can be walked through, and this positive number represents the tree’s height.

You are asked to cut off all the trees in this forest in the order of tree’s height – always cut off the tree with lowest height first. And after cutting, the original place has the tree will become a grass (value 1).

You will start from the point (0, 0) and you should output the minimum steps you need to walk to cut off all the trees. If you can’t cut off all the trees, output -1 in that situation.

You are guaranteed that no two trees have the same height and there is at least one tree needs to be cut off.

Example 1:

Input:

[

[1,2,3],

[0,0,4],

[7,6,5]

]

Output: 6

Example 2:

Input:

[

[1,2,3],

[0,0,0],

[7,6,5]

]

Output: -1

Example 3:

Input:

[

[2,3,4],

[0,0,5],

[8,7,6]

]

Output: 6

Explanation: You started from the point (0,0) and you can cut off the tree in (0,0) directly without walking.

Hint: size of the given matrix will not exceed 50×50.

Idea:

Greedy + Shortest path

Identify and sort the trees by its heights, then find shortest paths between

0,0 to tree[1]
tree[1] to tree[2]
…
tree[n-1] to tree[n]

Time complexity: O(m^2n^2)

Space complexity: O(mn)

Solution:

// Author: Huahua

// Running time: 282 ms

class Solution {

public:

int cutOffTree(vector<vector<int>>& forest) {

m_ = forest.size();

n_ = forest[0].size();

// {height, x, y}

vector<tuple<int,int,int>> trees;

for (int y = 0; y < m_; ++y)

for (int x = 0; x < n_; ++x)

if (forest[y][x] > 1)

trees.emplace_back(forest[y][x], x, y);

// sort trees by height

sort(trees.begin(), trees.end());

int sx = 0;

int sy = 0;

int total_steps = 0;

// Move from current position to next tree to cut

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

int tx = get<1>(trees[i]);

int ty = get<2>(trees[i]);

int steps = BFS(forest, sx, sy, tx, ty);

if (steps == INT_MAX) return -1;

// Cut the tree, not necessary

forest[ty][tx] = 1;

total_steps += steps;

sx = tx;

sy = ty;

}

return total_steps;

}

private:

// min steps to go from (sx,sy) to (tx,ty) based on current map

// INT_MAX means not reachable

int BFS(const vector<vector<int>>& forest,

int sx, int sy,

int tx, int ty) {

static int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

auto visited = vector<vector<int>>(m_, vector<int>(n_, 0));

// {x, y}

queue<pair<int,int>> q;

q.emplace(sx, sy);

int steps = 0;

while (!q.empty()) {

int new_nodes = q.size();

while (new_nodes--) {

auto node = q.front();

q.pop();

const int cx = node.first;

const int cy = node.second;

// Found the shortest path

if (cx == tx && cy == ty)

return steps;

for (int i = 0; i < 4; ++i) {

const int x = cx + dirs[i][0];

const int y = cy + dirs[i][1];

// Out of bound or unwalkable

if (x < 0 || x == n_

|| y < 0 || y == m_

|| !forest[y][x]

|| visited[y][x]) continue;

// Mark x, y as visited

visited[y][x] = 1;

q.emplace(x, y);

}

++steps;

}

// Impossible to reach

return INT_MAX;

}

int m_;

int n_;

};

Posts tagged as “greedy”

花花酱 LeetCode 321. Create Maximum Number

Idea: Greedy + DP

Solution:

C++

Java

花花酱 LeetCode 675. Cut Off Trees for Golf Event