(This problem is an interactive problem.)

You may recall that an array A is a mountain array if and only if:

• A.length >= 3
• There exists some i with 0 < i < A.length - 1 such that:
  • A[0] < A[1] < ... A[i-1] < A[i]
  • A[i] > A[i+1] > ... > A[A.length - 1]

Given a mountain array mountainArr, return the minimum index such that mountainArr.get(index) == target.  If such an index doesn’t exist, return -1.

You can’t access the mountain array directly.  You may only access the array using a MountainArray interface:

• MountainArray.get(k) returns the element of the array at index k (0-indexed).
• MountainArray.length() returns the length of the array.

Submissions making more than 100 calls to MountainArray.get will be judged Wrong Answer.  Also, any solutions that attempt to circumvent the judge will result in disqualification.

Example 1:

Input: array = [1,2,3,4,5,3,1], target = 3
Output: 2
Explanation: 3 exists in the array, at index=2 and index=5. Return the minimum index, which is 2.

Example 2:

Input: array = [0,1,2,4,2,1], target = 3
Output: -1
Explanation: 3 does not exist in the array, so we return -1.

Constraints:

• 3 <= mountain_arr.length() <= 10000
• 0 <= target <= 10^9
• 0 <= mountain_arr.get(index) <= 10^9

Solution: Binary Search

1. Find the peak index of the mountain array using binary search.
2. Perform two binary searches in two sorted subarrays (ascending one and descending one)

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

class Solution {
public:
  int findInMountainArray(int target, MountainArray &mountainArr) {
    const int n = mountainArr.length();
    
    auto binary_search = [&](int l, int r, function<bool(int)> cond) {
      while (l < r) {
        int m = l + (r - l) / 2;
        if (cond(m)) r = m;
        else l = m + 1;
      }  
      return l;
    };
    
    int p = binary_search(0, n - 1, [&](int i) -> bool {
      return mountainArr.get(i) > mountainArr.get(i + 1);
    });    
    
    // if (target > mountainArr.get(p)) return -1;
    // if (target == mountainArr.get(p)) return p;
    
    int l = binary_search(0, p, [&](int i) -> bool {
      return mountainArr.get(i) >= target;
    });
    
    if (mountainArr.get(l) == target) return l;
    
    int r = binary_search(p, n - 1, [&](int i) -> bool {
      return mountainArr.get(i) <= target;
    });        
    
    if (mountainArr.get(r) == target) return r;
    
    return -1;
  }
};

class Solution:
  def findInMountainArray(self, target: int, arr: 'MountainArray') -> int:
    def binary_search(l, r, cond):
      while l < r:
        m = l + (r - l) // 2
        if cond(m): r = m
        else: l = m + 1
      return l
    
    n = arr.length()    
    p = binary_search(0, n - 1, lambda i: arr.get(i) > arr.get(i + 1))
    l = binary_search(0, p, lambda i: arr.get(i) >= target)
    if arr.get(l) == target: return l
    r = binary_search(p, n - 1, lambda i: arr.get(i) <= target)
    if arr.get(r) == target: return r
    return -1

The post 花花酱 1095. Find in Mountain Array – EP369 appeared first on Huahua's Tech Road.

On the sea represented by a cartesian plane, each ship is located at an integer point, and each integer point may contain at most 1 ship.

You have a function Sea.hasShips(topRight, bottomLeft) which takes two points as arguments and returns true if and only if there is at least one ship in the rectangle represented by the two points, including on the boundary.

Given two points, which are the top right and bottom left corners of a rectangle, return the number of ships present in that rectangle.  It is guaranteed that there are at most 10 ships in that rectangle.

Submissions making more than 400 calls to hasShips will be judged Wrong Answer.  Also, any solutions that attempt to circumvent the judge will result in disqualification.

Example :

Input: 
ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]
Output: 3
Explanation: From [0,0] to [4,4] we can count 3 ships within the range.

Constraints:

• On the input ships is only given to initialize the map internally. You must solve this problem “blindfolded”. In other words, you must find the answer using the given hasShips API, without knowing the ships position.
• 0 <= bottomLeft[0] <= topRight[0] <= 1000
• 0 <= bottomLeft[1] <= topRight[1] <= 1000

Solution: Divide and Conquer

If the current rectangle contains ships, subdivide it into 4 smaller ones until
1) no ships contained
2) the current rectangle is a single point (e.g. topRight == bottomRight)

Time complexity: O(logn)
Space complexity: O(logn)

// Author: Huahua
class Solution {
public:
  // Modify the interface to pass sea as a reference.
  int countShips(Sea& sea, vector<int> topRight, vector<int> bottomLeft) {
    int x1 = bottomLeft[0], y1 = bottomLeft[1];
    int x2 = topRight[0], y2 = topRight[1];    
    if (x1 > x2 || y1 > y2 || !sea.hasShips(topRight, bottomLeft))
      return 0;
    if (x1 == x2 && y1 == y2)
      return 1;
    int xm = x1 + (x2 - x1) / 2;
    int ym = y1 + (y2 - y1) / 2;
    return countShips(sea, {xm, ym}, {x1, y1}) + countShips(sea, {xm, y2}, {x1, ym + 1})
         + countShips(sea, {x2, ym}, {xm + 1, y1}) + countShips(sea, {x2, y2}, {xm + 1, ym + 1});
  }
};

The post 花花酱 LeetCode 1274. Number of Ships in a Rectangle appeared first on Huahua's Tech Road.

The function is constantly increasing, i.e.:

• f(x, y) < f(x + 1, y)
• f(x, y) < f(x, y + 1)

The function interface is defined like this: 

interface CustomFunction {
public:
  // Returns positive integer f(x, y) for any given positive integer x and y.
  int f(int x, int y);
};

For custom testing purposes you’re given an integer function_id and a target z as input, where function_id represent one function from an secret internal list, on the examples you’ll know only two functions from the list.  

You may return the solutions in any order.

Example 1:

Input: function_id = 1, z = 5
Output: [[1,4],[2,3],[3,2],[4,1]]
Explanation: function_id = 1 means that f(x, y) = x + y

Example 2:

Input: function_id = 2, z = 5
Output: [[1,5],[5,1]]
Explanation: function_id = 2 means that f(x, y) = x * y

Constraints:

• 1 <= function_id <= 9
• 1 <= z <= 100
• It’s guaranteed that the solutions of f(x, y) == z will be on the range 1 <= x, y <= 1000
• It’s also guaranteed that f(x, y) will fit in 32 bit signed integer if 1 <= x, y <= 1000

Solution1 : Brute Force

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> findSolution(CustomFunction& customfunction, int z) {
    vector<vector<int>> ans;    
    for (int x = 1; x <= 1000; ++x) {
      if (customfunction.f(x, 1) > z) break;
      for (int y = 1; y <= 1000; ++y) {
        int t = customfunction.f(x, y);
        if (t > z) break;
        if (t == z) ans.push_back({x, y});        
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1237. Find Positive Integer Solution for a Given Equation appeared first on Huahua's Tech Road.

Problem:

https://leetcode.com/problems/first-bad-version/description/

You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.

Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.

You are given an API bool isBadVersion(version) which will return whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.

Solution 1: Brute Force

Time Complexity: O(n) TLE

Space Complexity: O(1)

Solution 2: Binary Search

Time Complexity: O(logn)

Space Complexity: O(1)

// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

// Author: Huahua
// Running time: 2 ms
class Solution {
public:
  int firstBadVersion(int n) {
    int l = 1;
    int r = n;
    while (l < r) {
      int m = l + (r - l) / 2;
      if (isBadVersion(m))
        r = m;
      else
        l = m + 1;
    }
    return l;
  }
};

The post 花花酱 LeetCode 278. First Bad Version appeared first on Huahua's Tech Road.