Lowest Common Ancestor of a Binary Tree 问题描述

Given a binary tree, find the lowest common ancestor of two given nodes in the tree.

给定一棵二叉树，求最近公共祖先。

Lowest Common Ancestor of a Binary Tree 问题描述

Given a binary tree, find the lowest common ancestor of two given nodes in the tree.

给定一棵二叉树，求最近公共祖先。

## leetcode Count of Range Sum

Given an integer array

`nums`

, return the number of range sums that lie in`[lower, upper]`

inclusive.

Range sum`S(i, j)`

is defined as the sum of the elements in`nums`

between indices`i`

and`j`

(`i`

≤`j`

), inclusive.

Note:

A naive algorithm ofO(n^{2}) is trivial. You MUST do better than that.

Example:

Givennums=`[-2, 5, -1]`

,lower=`-2`

,upper=`2`

,

Return`3`

.

The three ranges are :`[0, 0]`

,`[2, 2]`

,`[0, 2]`

and their respective sums are:`-2, -1, 2`

.

## leetcode Coin Change

You are given coins of different denominations and a total amount of money

amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return`-1`

.

Example 1:

coins =`[1, 2, 5]`

, amount =`11`

return`3`

(11 = 5 + 5 + 1)

Example 2:

coins =`[2]`

, amount =`3`

return`-1`

.

Note:

You may assume that you have an infinite number of each kind of coin.

## leetcode Create Maximum Number

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]`

## leetcode Maximum Product of Word Lengths

Given a string array

`words`

, find the maximum value of`length(word[i]) * length(word[j])`

where the two words do not share common letters. You may assume that each word will contain only lower case letters. If no such two words exist, return 0.

Example 1:Given

`["abcw", "baz", "foo", "bar", "xtfn", "abcdef"]`

Return`16`

The two words can be`"abcw", "xtfn"`

.

Example 2:Given

`["a", "ab", "abc", "d", "cd", "bcd", "abcd"]`

Return`4`

The two words can be`"ab", "cd"`

.

Example 3:Given

`["a", "aa", "aaa", "aaaa"]`

Return`0`

No such pair of words.

Follow up:

Could you do better than O(n^{2}), wherenis the number of words?

Given an Iterator class interface with methods:

`next()`

and`hasNext()`

, design and implement a PeekingIterator that support the`peek()`

operation — it essentially peek() at the element that will be returned by the next call to next()Here is an example. Assume that the iterator is initialized to the beginning of the list:

`[1, 2, 3]`

.Call

`next()`

gets you 1, the first element in the list.Now you call

`peek()`

and it returns 2, the next element. Calling`next()`

after thatreturn 2.stillYou call

`next()`

the final time and it returns 3, the last element. Calling`hasNext()`

after that should return false.

Hint:

- Think of “looking ahead”. You want to cache the next element.
- Is one variable sufficient? Why or why not?
- Test your design with call order of
`peek()`

before`next()`

vs`next()`

before`peek()`

.- For a clean implementation, check out Google’s guava library source code.

Follow up: How would you extend your design to be generic and work with all types, not just integer?

## leetcode Remove Duplicate Letters

Given a string which contains only lowercase letters, remove duplicate letters so that every letter appear once and only once. You must make sure your result is the smallest in lexicographical order among all possible results.

Example:Given

`"bcabc"`

Return`"abc"`

Given

`"cbacdcbc"`

Return`"acdb"`

## leetcode Count of Smaller Numbers After Self

You are given an integer array

numsand you have to return a newcountsarray. Thecountsarray has the property where`counts[i]`

is the number of smaller elements to the right of`nums[i]`

.

Example:Given nums = [5, 2, 6, 1]

To the right of 5 there are 2 smaller elements (2 and 1).

To the right of 2 there is only 1 smaller element (1).

To the right of 6 there is 1 smaller element (1).

To the right of 1 there is 0 smaller element.Return the array

`[2, 1, 1, 0]`

.

## leetcode Minimum Height Trees

For a undirected graph with tree characteristics, we can choose any node as the root. The result graph is then a rooted tree. Among all possible rooted trees, those with minimum height are called minimum height trees (MHTs). Given such a graph, write a function to find all the MHTs and return a list of their root labels.

Format

The graph contains`n`

nodes which are labeled from`0`

to`n - 1`

. You will be given the number`n`

and a list of undirected`edges`

(each edge is a pair of labels).You can assume that no duplicate edges will appear in

`edges`

. Since all edges are undirected,`[0, 1]`

is the same as`[1, 0]`

and thus will not appear together in`edges`

.

Example 1:Given

`n = 4`

,`edges = [[1, 0], [1, 2], [1, 3]]`

12345 0|1/ \2 3return

`[1]`