虚拟机设计团队把类加载阶段中的 "通过一个类的全限定名来获取描述此类的二进制字节流" 这个动作放到 Java 虚拟机外部去实现，以便让应用程序自己决定如何
去获取需要的类。 实现这个动作的 代码模块 称为 "类加载器"。

  /**
    * left <= right
    * @param nums
    * @param target
    * @return
    */
public int binarySearch(int[] nums, int target) {
   int left = 0, right = nums.length - 1; // [left,right]
   while (left <= right) { // left == right
      int mid = (right - left) / 2 + left;
      if (nums[mid] < target) {
         left = mid + 1; // [mid + 1,right]
      } else if (nums[mid] > target) {
         right = mid - 1; // [left ,mid - 1]
      } else {
         return mid;
      }
   }
   return -1;
}

Given a string S, we can transform every letter individually to be lowercase or uppercase to create another string.  Return a list of all possible strings we could create.

Examples:Input: S = "a1b2"
Output: ["a1b2", "a1B2", "A1b2", "A1B2"]

Input: S = "3z4"
Output: ["3z4", "3Z4"]

Input: S = "12345"
Output: ["12345"]
Note:
S will be a string with length between 1 and 12.
S will consist only of letters or digits.

Given an unsorted array of integers, find the length of longest increasing subsequence.
Example:

Input: [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
Note:
	* 
There may be more than one LIS combination, it is only necessary for you to return the length.
	* 
Your algorithm should run in O(n2) complexity.


Follow up: Could you improve it to O(n log n) time complexity?

Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:
	1. 
Only one letter can be changed at a time
	2. 
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.


Note:
	* 
Return an empty list if there is no such transformation sequence.
	* 
All words have the same length.
	* 
All words contain only lowercase alphabetic characters.
	* 
You may assume no duplicates in the word list.
	* 
You may assume beginWord and endWord are non-empty and are not the same.


Example 1:

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output:
[
["hit","hot","dot","dog","cog"],
["hit","hot","lot","log","cog"]
]
Example 2:
Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: []

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:
	1. 
Only one letter can be changed at a time.
	2. 
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.


Note:
	* 
Return 0 if there is no such transformation sequence.
	* 
All words have the same length.
	* 
All words contain only lowercase alphabetic characters.
	* 
You may assume no duplicates in the word list.
	* 
You may assume beginWord and endWord are non-empty and are not the same.


Example 1:

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.
Example 2:
Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

Word Ladder 单向宽度优先搜索 与 双向宽度优先搜索的时间复杂度比较: