1.
There are two sorted arrays nums1 and nums2 of size m and n respectively.
Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
Example 1:
nums1 = [1, 3] nums2 = [2] The median is 2.0
Example 2:
nums1 = [1, 2] nums2 = [3, 4] The median is (2 + 3)/2 = 2.5
Solution:
def median(A, B):
m, n = len(A), len(B)
if m > n:
A, B, m, n = B, A, n, m
if n == 0:
raise ValueError
imin, imax, half_len = 0, m, (m + n + 1) / 2
while imin <= imax:
i = (imin + imax) / 2
j = half_len - i
if i < m and B[j-1] > A[i]:
# i is too small, must increase it
imin = i + 1
elif i > 0 and A[i-1] > B[j]:
# i is too big, must decrease it
imax = i - 1
else:
# i is perfect
if i == 0: max_of_left = B[j-1]
elif j == 0: max_of_left = A[i-1]
else: max_of_left = max(A[i-1], B[j-1])
if (m + n) % 2 == 1:
return max_of_left
if i == m: min_of_right = B[j]
elif j == n: min_of_right = A[i]
else: min_of_right = min(A[i], B[j])
return (max_of_left + min_of_right) / 2.0
In a N x N grid
representing a field of cherries, each cell is one of three possible integers.
Your task is to collect maximum number of cherries possible by following the rules below:
Example 1:
Input: grid = [[0, 1, -1], [1, 0, -1], [1, 1, 1]] Output: 5 Explanation: The player started at (0, 0) and went down, down, right right to reach (2, 2). 4 cherries were picked up during this single trip, and the matrix becomes [[0,1,-1],[0,0,-1],[0,0,0]]. Then, the player went left, up, up, left to return home, picking up one more cherry. The total number of cherries picked up is 5, and this is the maximum possible.
Note:
grid
is an
N
by
N
2D array, with
1 <= N <= 50
.
Each
grid[i][j]
is an integer in the set
{-1, 0, 1}
.
It is guaranteed that grid[0][0] and grid[N-1][N-1] are not -1.
Solution:
class Solution(object):
def cherryPickup(self, grid):
def bestpath(grid):
N = len(grid)
NINF = float('-inf')
dp = [[NINF] * N for _ in xrange(N)]
dp[-1][-1] = grid[-1][-1]
for i in xrange(N-1, -1, -1):
for j in xrange(N-1, -1, -1):
if grid[i][j] >= 0 and (i != N-1 or j != N-1):
dp[i][j] = max(dp[i+1][j] if i+1 < N else NINF,
dp[i][j+1] if j+1 < N else NINF)
dp[i][j] += grid[i][j]
if dp[0][0] < 0: return None
ans = [(0, 0)]
i = j = 0
while i != N-1 or j != N-1:
if j+1 == N or i+1 < N and dp[i+1][j] >= dp[i][j+1]:
i += 1
else:
j += 1
ans.append((i, j))
return ans
ans = 0
path = bestpath(grid)
if path is None: return 0
for i, j in path:
ans += grid[i][j]
grid[i][j] = 0
for i, j in bestpath(grid):
ans += grid[i][j]
return ans
3.
Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋
times.
You may assume that the array is non-empty and the majority element always exist in the array.
Example 1:
Input: [3,2,3] Output: 3
Example 2:
Input: [2,2,1,1,1,2,2] Output: 2
Solution:
class Solution:
def majorityElement(self, nums):
nums.sort()
return nums[len(nums)//2]