You are given an integer array gain of length n where gain[i] is the net gain in altitude between points i​​​​​​ and i + 1 for all (0 <= i < n). Return the highest altitude of a point.

Example 1:

Input: gain = [-5,1,5,0,-7]
Output: 1
Explanation: The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.

Example 2:

Input: gain = [-4,-3,-2,-1,4,3,2]
Output: 0
Explanation: The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.

Constraints:

• n == gain.length
• 1 <= n <= 100
• -100 <= gain[i] <= 100

Solution: Running Max

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int largestAltitude(vector<int>& gain) {
    int ans = 0;
    int cur = 0;
    for (int diff : gain)
      ans = max(ans, cur += diff);
    return ans;
  }
};

The post 花花酱 LeetCode1732. Find the Highest Altitude appeared first on Huahua's Tech Road.

Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).

Example 1:

Input: num = 9669
Output: 9969
Explanation: 
Changing the first digit results in 6669.
Changing the second digit results in 9969.
Changing the third digit results in 9699.
Changing the fourth digit results in 9666. 
The maximum number is 9969.

Example 2:

Input: num = 9996
Output: 9999
Explanation: Changing the last digit 6 to 9 results in the maximum number.

Example 3:

Input: num = 9999
Output: 9999
Explanation: It is better not to apply any change.

Constraints:

• 1 <= num <= 10^4
• num‘s digits are 6 or 9.

Solution: Greedy

Replace the highest 6 to 9, if no 6, return the original number.

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maximum69Number (int num) {
    string s = to_string(num);
    for (int i = 0; i < s.length(); ++i) {
      if (s[i] == '6') {
        s[i] = '9';
        return stoi(s);
      }
    }
    return num;
  }
};

The post 花花酱 LeetCode 1323. Maximum 69 Number appeared first on Huahua's Tech Road.

Problem

Given an integer array, find three numbers whose product is maximum and output the maximum product.

Example 1:

Input: [1,2,3]
Output: 6

Example 2:

Input: [1,2,3,4]
Output: 24

Note:

1. The length of the given array will be in range [3,10⁴] and all elements are in the range [-1000, 1000].
2. Multiplication of any three numbers in the input won’t exceed the range of 32-bit signed integer.

Idea:

Find the top 3 numbers t1, t2, t3, and bottom 2 numbers, b1, b2.

If all numbers are positives,  answer must be t1 * t2 * t3.

Since the number can go negative, the answer must be either t1*t2*t3 or b1 * b2 * t1, if b1 and b2 are both negatives.

ex. nums: [5, 1, -6, 3, -1]

t1, t2, t3: 5, 3, 1

b1, b2: -6, -1

t1 * t2 * t3 = 15

t1 * b1 * b2 = 30

Solution 1: Manual Tracking

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
// Running time: 28 ms
class Solution {
public:
  int maximumProduct(vector<int>& nums) {
    int max1 = INT_MIN;
    int max2 = INT_MIN;
    int max3 = INT_MIN;
    int min1 = INT_MAX;
    int min2 = INT_MAX;

    for (const int num: nums) {
      if (num > max1) {
          max3 = max2;
          max2 = max1;
          max1 = num;
      } else if (num > max2) {
          max3 = max2;
          max2 = num;
      } else if (num > max3) {
          max3=num;
      }

      if (num < min1) {
          min2 = min1;
          min1 = num;
      } else if (num < min2) {
          min2=num;
      }
    }

    return max(max1*max2*max3, max1*min1*min2);
  }
};

Solution 2: Sorting

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua
// Running time: 48 ms
class Solution {
public:
  int maximumProduct(vector<int>& nums) {
    int n = nums.size();
    sort(nums.rbegin(), nums.rend());
    return max(nums[0] * nums[1] * nums[2], nums[0] * nums[n - 1] * nums[n - 2]);
  }
};

Solution 3: Two Heaps (Priority Queues)

Time complexity: O(nlog3)

Space complexity: O(2 + 3)

// Author: Huahua
// Running time: 40 ms
class Solution {
public:
  int maximumProduct(vector<int>& nums) {
    priority_queue<int, vector<int>, less<int>> min_q; // max_heap
    priority_queue<int, vector<int>, greater<int>> max_q; // min_heap
    
    for (int num : nums) {
      max_q.push(num);
      if (max_q.size() > 3) max_q.pop();
      min_q.push(num);
      if (min_q.size() > 2) min_q.pop();
    }
    
    int max3 = max_q.top(); max_q.pop();
    int max2 = max_q.top(); max_q.pop();
    int max1 = max_q.top(); max_q.pop();
    int min2 = min_q.top(); min_q.pop();
    int min1 = min_q.top(); min_q.pop();
    
    return max(max1 * max2 * max3, max1 * min1 * min2); 
  }
};

The post 花花酱 LeetCode 628. Maximum Product of Three Numbers appeared first on Huahua's Tech Road.

https://leetcode.com/problems/third-maximum-number/description/

Given a non-empty array of integers, return the third maximum number in this array. If it does not exist, return the maximum number. The time complexity must be in O(n).

Example 1:

Input: [3, 2, 1]

Output: 1

Explanation: The third maximum is 1.

Example 2:

Input: [1, 2]

Output: 2

Explanation: The third maximum does not exist, so the maximum (2) is returned instead.

Example 3:

Input: [2, 2, 3, 1]

Output: 1

Explanation: Note that the third maximum here means the third maximum distinct number.
Both numbers with value 2 are both considered as second maximum.

Solution: Set

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 9 ms
class Solution {
public:
  int thirdMax(vector<int>& nums) {
    set<int> s;
    for (int num : nums) {
      s.insert(num);
      if (s.size() > 3) s.erase(s.begin());
    }
    return s.size() != 3 ? *s.rbegin() : *s.begin();
  }
};

Python3

"""
Author: Huahua
Running time: 52 ms
"""
class Solution:
  def thirdMax(self, nums):
    s = set()
    for num in nums:
      s.add(num)
      if len(s) > 3: s.remove(min(s))
    return min(s) if len(s) == 3 else max(s)

The post 花花酱 LeetCode 414. Third Maximum Number appeared first on Huahua's Tech Road.

Problem:

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
the contiguous subarray [4,-1,2,1] has the largest sum = 6.

Idea:

DP

Solution:

C++

// Author: Huahua
// Runtime: 6 ms (better than 98.66%)
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> f(nums.size());
        f[0] = nums[0];
        
        for (int i = 1; i < nums.size(); ++i)
            f[i] = max(f[i - 1] + nums[i], nums[i]);
        
        return *std::max_element(f.begin(), f.end());
    }
};

The post 花花酱 LeetCode 53. Maximum Subarray appeared first on Huahua's Tech Road.

题目大意：方块落下后会堆叠在重叠的方块之上，问每一块方块落下之后最高的方块的高度是多少？

Problem:

On an infinite number line (x-axis), we drop given squares in the order they are given.

The i-th square dropped (positions[i] = (left, side_length)) is a square with the left-most point being positions[i][0] and sidelength positions[i][1].

The square is dropped with the bottom edge parallel to the number line, and from a higher height than all currently landed squares. We wait for each square to stick before dropping the next.

The squares are infinitely sticky on their bottom edge, and will remain fixed to any positive length surface they touch (either the number line or another square). Squares dropped adjacent to each other will not stick together prematurely.

Return a list ans of heights. Each height ans[i] represents the current highest height of any square we have dropped, after dropping squares represented by positions[0], positions[1], ..., positions[i].

Example 1:

Input: [[1, 2], [2, 3], [6, 1]]
Output: [2, 5, 5]
Explanation:

After the first drop of 
positions[0] = [1, 2]:
_aa
_aa
-------
The maximum height of any square is 2.


After the second drop of 
positions[1] = [2, 3]:
__aaa
__aaa
__aaa
_aa__
_aa__
--------------
The maximum height of any square is 5.  
The larger square stays on top of the smaller square despite where its center
of gravity is, because squares are infinitely sticky on their bottom edge.


After the third drop of 
positions[1] = [6, 1]:
__aaa
__aaa
__aaa
_aa
_aa___a
--------------
The maximum height of any square is still 5.

Thus, we return an answer of 
[2, 5, 5]

Example 2:

Input: [[100, 100], [200, 100]]
Output: [100, 100]
Explanation: Adjacent squares don't get stuck prematurely - only their bottom edge can stick to surfaces.

Note:

• 1 <= positions.length <= 1000.
• 1 <= positions[i][0] <= 10^8.
• 1 <= positions[i][1] <= 10^6.

Idea:

Range query with map

Solution:

C++ map

// Author: Huahua
// Runtime: 29 ms
class Solution {
public:
    vector<int> fallingSquares(vector<pair<int, int>>& positions) {
        vector<int> ans;
        map<pair<int, int>, int> b; // {{start, end}, height}        
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            int start = kv.first;
            int size = kv.second;
            int end = start + size;
            // first range intersect with new_interval
            auto it = b.upper_bound({start, end});
            if (it != b.begin()) {
                auto it2 = it;
                if ((--it2)->first.second > start) it = it2;
            }
            
            int baseHeight = 0;
            vector<tuple<int, int, int>> ranges;
            while (it != b.end() && it->first.first < end) {
                const int s = it->first.first;
                const int e = it->first.second;
                const int h = it->second;
                if (s < start) ranges.emplace_back(s, start, h);
                if (e > end) ranges.emplace_back(end, e, h);
                // max height of intesected ranges
                baseHeight = max(baseHeight, h);
                it = b.erase(it);
            }
            
            int newHeight = size + baseHeight;
            
            b[{start, end}] = newHeight;
            
            for (const auto& range: ranges)
                b[{get<0>(range), get<1>(range)}] = get<2>(range);
            
            maxHeight = max(maxHeight, newHeight);            
            ans.push_back(maxHeight);
        }
        return ans;
    }
};

C++ vector without merge

// Author: Huahua
// Runtime: 46 ms
class Solution {
public:
    vector<int> fallingSquares(vector<pair<int, int>>& positions) {
        vector<int> ans;
        vector<Interval> intervals;
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            int start = kv.first;
            int end = start + kv.second;            
            int baseHeight = 0;
            for (const Interval& interval : intervals) {
                if (interval.start >= end || interval.end <= start)             
                    continue;
                baseHeight = max(baseHeight, interval.height);
            }
            int height = kv.second + baseHeight;
            intervals.push_back(Interval(start, end, height));
            maxHeight = max(maxHeight, height);
            ans.push_back(maxHeight);
        }
        return ans;
    }
private:
    struct Interval {
        int start;
        int end;
        int height;
        Interval(int start, int end, int height) 
            : start(start), end(end), height(height) {}
    };
};

C++ / vector with merge (slower)

// Author: Huahua
// Runtime: 86 ms
class Solution {
public:
    vector<int> fallingSquares(vector<pair<int, int>>& positions) {
        vector<int> ans;
        vector<Interval> intervals;
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            vector<Interval> tmp;
            int start = kv.first;
            int end = start + kv.second;            
            int baseHeight = 0;
            for (const Interval& interval : intervals) {
                if (interval.start >= end || interval.end <= start) {
                    tmp.push_back(interval);                
                    continue;
                }
                baseHeight = max(baseHeight, interval.height);
                if (interval.start < start || interval.end > end)
                    tmp.push_back(interval);
            }
            int height = kv.second + baseHeight;
            tmp.push_back(Interval(start, end, height));
            intervals.swap(tmp);
            maxHeight = max(maxHeight, height);
            ans.push_back(maxHeight);
        }
        return ans;
    }
private:
    struct Interval {
        int start;
        int end;
        int height;
        Interval(int start, int end, int height) 
            : start(start), end(end), height(height) {}
    };
};

Related Problems:

• [解题报告] LeetCode 715. Range Module
• [解题报告] LeetCode 218. The Skyline Problem
• [解题报告] LeetCode 57. Insert Interval

The post 花花酱 LeetCode 699. Falling Squares appeared first on Huahua's Tech Road.

Problem:

Given a 2D binary matrix filled with 0’s and 1’s, find the largest square containing only 1’s and return its area.

For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

Return 4.

Idea:

Dynamic programming

Solution 0: O(n^5)

Solution 1: O(n^3)

Solution 2: O(n^2)

Solution 1:

// Author: Huahua
// Time complexity: O(n^3)
// Running time: 39 ms
class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty()) return 0;
        int m = matrix.size();
        int n = matrix[0].size();
        
        // sums[i][j] = sum(matrix[0][0] ~ matrix[i-1][j-1])
        vector<vector<int>> sums(m + 1, vector<int>(n + 1, 0));
        for (int i = 1; i <= m; ++i)
            for (int j = 1; j <= n; ++j)        
                sums[i][j] = matrix[i - 1][j - 1] - '0' 
                             + sums[i - 1][j]
                             + sums[i][j - 1]
                             - sums[i - 1][j - 1];
        
        int ans = 0;
        for (int i = 1; i <= m; ++i)
            for (int j = 1; j <= n; ++j)
                for (int k = min(m - i + 1, n - j + 1); k > 0; --k) {
                    int sum = sums[i + k - 1][j + k - 1]
                            - sums[i + k - 1][j - 1]
                            - sums[i - 1][j + k - 1]
                            + sums[i - 1][j - 1];
                    // full of 1
                    if (sum == k*k) {
                        ans = max(ans, sum);
                        break;
                    }
                }

        return ans;
    }
};

Solution 2:

// Author: Huahua
// Time complexity: O(n^2)
// Running time: 6 ms
class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty()) return 0;
        int m = matrix.size();
        int n = matrix[0].size();
        
        vector<vector<int>> sizes(m, vector<int>(n, 0));
        
        int ans = 0;
        
        for (int i = 0; i < m; ++i)
            for (int j = 0; j < n; ++j) {
                sizes[i][j] = matrix[i][j] - '0';
                if (!sizes[i][j]) continue;                            
                
                if (i == 0 || j == 0) {
                    // do nothing
                } else if (i == 0)
                    sizes[i][j] = sizes[i][j - 1] + 1;
                else if (j == 0)
                    sizes[i][j] = sizes[i - 1][j] + 1;
                else
                    sizes[i][j] = min(min(sizes[i - 1][j - 1], 
                                          sizes[i - 1][j]),
                                          sizes[i][j - 1]) + 1;
                
                ans = max(ans, sizes[i][j]*sizes[i][j]);
            }
        return ans;
    }
};

The post 花花酱 LeetCode 221. Maximal Square appeared first on Huahua's Tech Road.