LeetCode (M)

Maximum Depth of Binary Tree

 Total Accepted: 14814 Total Submissions: 34098My Submissions

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

# Definition for a  binary tree node# class TreeNode:#     def __init__(self, x):#         self.val = x#         self.left = None#         self.right = Noneclass Solution:    # @param root, a tree node    # @return an integer    def maxDepth(self, root):        if root == None: return 0        return max(Solution().maxDepth(root.left), Solution().maxDepth(root.right)) + 1

Minimum Depth of Binary Tree

 Total Accepted: 11272 Total Submissions: 38773My Submissions

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

class Solution:    def minDepth(self, root):        if root == None: return 0        if root.left == None and root.right == None:            return 1        ans = -1        if root.left != None:            ans = Solution().minDepth(root.left)        if root.right != None:            tmp = Solution().minDepth(root.right)            if ans == -1:                ans = tmp            else:                ans = min(ans, tmp)        if ans == -1: ans = 0        return ans + 1

Multiply Strings

 Total Accepted: 6273 Total Submissions: 31601My Submissions

Given two numbers represented as strings, return multiplication of the numbers as a string.

Note: The numbers can be arbitrarily large and are non-negative.

class Solution:    # @param num1, a string    # @param num2, a string    # @return a string    def multiply(self, num1, num2):        return str(int(num1)*int(num2))

Merge Intervals

 Total Accepted: 7692 Total Submissions: 38282My Submissions

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

/** * Definition for an interval. * struct Interval { *     int start; *     int end; *     Interval() : start(0), end(0) {} *     Interval(int s, int e) : start(s), end(e) {} * }; */class Solution {public:    vector<Interval> merge(vector<Interval> &intervals) {        vector<Interval> res;        vector<pair<int, int> > vec;        const int m = intervals.size();        if (m == 0) return res;        for (int i = 0; i < m; ++i) {            int s = intervals[i].start, e = intervals[i].end;            vec.push_back(make_pair(s, 0));            vec.push_back(make_pair(e, 1));        }        sort(vec.begin(), vec.end());        int cnt = 1, s = vec[0].first, e;        const int n = vec.size();        for (int i = 1; i < n; ++i) {            if (vec[i].second == 0)                ++cnt;            else                --cnt;            if (cnt == 0) {                e = vec[i].first;                res.push_back(Interval(s, e));                ++i;                if (i >= n) break;                s = vec[i].first;                cnt = 1;            }        }        return res;    }};

Merge Sorted Array

 Total Accepted: 11726 Total Submissions: 36955My Submissions

Given two sorted integer arrays A and B, merge B into A as one sorted array.

Note:
You may assume that A has enough space (size that is greater or equal to m + n) to hold additional elements from B. The number of elements initialized in A and B are m andn respectively.

class Solution:    # @param A  a list of integers    # @param m  an integer, length of A    # @param B  a list of integers    # @param n  an integer, length of B    # @return nothing    def merge(self, A, m, B, n):        k = m + n - 1        i = m - 1        j = n - 1        while k >= 0:            if i < 0 or j < 0: break            if A[i] > B[j]:                A[k] = A[i]                i = i - 1            else:                A[k] = B[j]                j = j - 1            k = k - 1        while i >= 0:            A[k] = A[i]            k = k - 1            i = i - 1        while j >= 0:            A[k] = B[j]            k = k - 1            j = j - 1

Merge Two Sorted Lists

 Total Accepted: 12625 Total Submissions: 39274My Submissions

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

# Definition for singly-linked list.# class ListNode:#     def __init__(self, x):#         self.val = x#         self.next = Noneclass Solution:    # @param two ListNodes    # @return a ListNode    def mergeTwoLists(self, l1, l2):        if l1 == None: return l2        if l2 == None: return l1        if l1.val < l2.val:            head = l1            l1 = l1.next        else:            head = l2            l2 = l2.next        p = head        while l1 != None and l2 != None:            if l1.val < l2.val:                p.next = l1                l1 = l1.next            else:                p.next = l2                l2 = l2.next            p = p.next        if l1 != None: p.next = l1        if l2 != None: p.next = l2        return head

Merge k Sorted Lists

 Total Accepted: 9161 Total Submissions: 39314My Submissions

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     ListNode *next; *     ListNode(int x) : val(x), next(NULL) {} * }; */typedef pair<int, int> pii; class Solution {public:    ListNode *mergeKLists(vector<ListNode *> &lists) {        priority_queue<pii, vector<pii>, greater<pii>> q;        const int n = lists.size();        vector<ListNode*> pointers(n, reinterpret_cast<ListNode*>(NULL));        for (int i = 0; i < n; ++i) {            if (lists[i] != NULL) q.push(make_pair(lists[i]->val, i));            pointers[i] = lists[i];        }        ListNode *head = NULL;        ListNode *p = head;        while (!q.empty()) {            const int i = q.top().second;            q.pop();            if (p == NULL)                head = p = pointers[i];            else {                p->next = pointers[i];                p = p->next;            }            pointers[i] = pointers[i]->next;            if (pointers[i] != NULL) q.push(make_pair(pointers[i]->val, i));        }        return head;    }};

Minimum Path Sum

 Total Accepted: 9635 Total Submissions: 31688My Submissions

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

class Solution:    # @param grid, a list of lists of integers    # @return an integer    def minPathSum(self, grid):        m = len(grid)        n = len(grid[0])        for i in range(n-1):            grid[0][i+1] = grid[0][i] + grid[0][i+1]        for i in range(m-1):            grid[i+1][0] = grid[i][0] + grid[i+1][0]        for i in range(m-1):            for j in range(n-1):                grid[i+1][j+1] += min(grid[i][j+1], grid[i+1][j])        return grid[m-1][n-1]

Maximum Subarray

 Total Accepted: 14357 Total Submissions: 44085My Submissions

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.

click to show more practice.

More practice:

If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

class Solution:def maxSubArray(self, A):cur = 0ans = A[0]l = len(A)for j in range(l):cur += A[j]ans = max(ans, cur)if cur < 0: cur = 0return ans

Maximal Rectangle Total Accepted: 10411 Total Submissions: 48083 My Submissions

Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.

class Solution {        int maximalRectangleInHistogram(vector<int> &histogram) {                stack<pair<int, int> > buffer;                const int n = histogram.size();                int ans = 0;                buffer.push(make_pair(histogram[0], 1));                for (int i = 1; i < n; ++i) {                        if (histogram[i] > buffer.top().first) {                                buffer.push(make_pair(histogram[i], 1));                        }                        else if (histogram[i] == buffer.top().first) {                                int cnt = buffer.top().second;                                buffer.pop();                                buffer.push(make_pair(histogram[i], cnt + 1));                        }                        else {                                int cnt = 0;                                while (buffer.size() > 0) {                                        if (buffer.top().first < histogram[i]) break;                                        cnt += buffer.top().second;                                        ans = max(ans, buffer.top().first * cnt);                                        buffer.pop();                                }                                buffer.push(make_pair(histogram[i], cnt + 1));                        }                }                while (buffer.size() > 0) {                        ans = max(ans, buffer.top().first * buffer.top().second);                        int cnt = buffer.top().second;                        buffer.pop();                        if (buffer.size() > 0) {                                pair<int, int> tmp = buffer.top();                                buffer.pop();                                buffer.push(make_pair(tmp.first, tmp.second + cnt));                        }                }                return ans;        }public:        int maximalRectangle(vector<vector<char> > &matrix) {                if (matrix.size() == 0 || matrix[0].size() == 0) return 0;                const int r = matrix.size(), c = matrix[0].size();                vector<int> histogram(c, 0);                int ans = 0;                for (int i = 0; i < r; ++i) {                        for (int j = 0; j < c; ++j) {                                if (matrix[i][j] == '1')                                        ++histogram[j];                                else                                        histogram[j] = 0;                        }                        ans = max(ans, maximalRectangleInHistogram(histogram));                }                return ans;        }};