search.xml

<?xml version="1.0" encoding="utf-8"?>
<search>
  
  
    
    <entry>
      <title><![CDATA[Leetcode Counting Bits(Java)]]></title>
      <url>http://yoursite.com/2016/03/25/Leetcode-Counting-Bits-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1’s in their binary representation and return them as an array.</p>
<p>Example:<br>For num = 5 you should return [0,1,1,2,1,2].</p>
<p>Follow up:</p>
<p>It is very easy to come up with a solution with run time O(n*sizeof(integer)). But can you do it in linear time O(n) /possibly in a single pass?<br>Space complexity should be O(n).<br>Can you do it like a boss? Do it without using any builtin function like __builtin_popcount in c++ or in any other language.<br>Hint:</p>
<p>You should make use of what you have produced already.<br>Divide the numbers in ranges like [2-3], [4-7], [8-15] and so on. And try to generate new range from previous.<br>Or does the odd/even status of the number help you in calculating the number of 1s?</p>
<p><strong>Thinking:</strong></p>
<p>We can divide the numbers into several groups and calculate the current elements based on the prvious ones. For example, in the group of [0-3] and [4-7], the later group’s elements have always one more 1 than the previous group.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int[] countBits(int num) {
    int[] res = new int[num+1];
    res[0] = 0;

    int flag = 1;
    for (int i = 1; i &lt;= num; i++) {
        if (i / flag == 2)    flag *= 2;
        res[i] = res[i % flag] + 1;
    }
    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode Largest Number(Java)]]></title>
      <url>http://yoursite.com/2016/03/10/Leetcode-Largest-Number-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a list of non negative integers, arrange them such that they form the largest number.</p>
<p>For example, given [3, 30, 34, 5, 9], the largest formed number is 9534330.</p>
<p>Note: The result may be very large, so you need to return a string instead of an integer.</p>
<p><strong>Thinking:</strong></p>
<p>I suppose we should sort the numbers in order. For example, if there are two nums, we convert them into strings. Then compare the connection of s1 + s2 and connection s2 + s1. Make sure the compare method. Then what we need is connecting them together.</p>
<p><strong>Solution:</strong></p>
<pre><code>public String largestNumber(int[] nums) {
    PriorityQueue&lt;String&gt; maxHeap = new PriorityQueue&lt;String&gt;(new NumComparator());
    StringBuilder res = new StringBuilder();

    for (int num: nums)
        maxHeap.add(Integer.toString(num));

    while (!maxHeap.isEmpty())
        res.append(maxHeap.poll());

    return res.toString().charAt(0) == &apos;0&apos;? &quot;0&quot; : res.toString();
}

public class NumComparator implements Comparator&lt;String&gt; {

    @Override
    public int compare(String s1, String s2) {
        String str1 = s1 + s2;
        String str2 = s2 + s1;

        return str2.compareTo(str1);
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode Reverse Words in a String(Java)]]></title>
      <url>http://yoursite.com/2016/03/10/Leetcode-Reverse-Words-in-a-String-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an input string, reverse the string word by word.</p>
<p>For example,<br>Given s = “the sky is blue”,<br>return “blue is sky the”.</p>
<p>Update (2015-02-12):<br>For C programmers: Try to solve it in-place in O(1) space.</p>
<p>Clarification:<br>What constitutes a word?<br>A sequence of non-space characters constitutes a word.<br>Could the input string contain leading or trailing spaces?<br>Yes. However, your reversed string should not contain leading or trailing spaces.<br>How about multiple spaces between two words?<br>Reduce them to a single space in the reversed string.</p>
<p><strong>Thinking:</strong></p>
<p>We can use Java API to easily split the String into pieces with String[] strs = s.trim().split(“\s+”). We should to notice the “\s+” match one or many whitespaces.</p>
<p><strong>Solution:</strong></p>
<pre><code>public String reverseWords(String s) {
    String[] strs = s.trim().split(&quot;\\s+&quot;);
    StringBuilder res = new StringBuilder();

    for (int i = strs.length-1; i &gt;= 0; i--) 
        res.append(strs[i] + &quot; &quot;);

    return res.toString().trim();
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode Wiggle Sort II(Java)]]></title>
      <url>http://yoursite.com/2016/03/09/Leetcode-Wiggle-Sort-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an unsorted array nums, reorder it such that nums[0] &lt; nums[1] &gt; nums[2] &lt; nums[3]….</p>
<p>Example:<br>(1) Given nums = [1, 5, 1, 1, 6, 4], one possible answer is [1, 4, 1, 5, 1, 6].<br>(2) Given nums = [1, 3, 2, 2, 3, 1], one possible answer is [2, 3, 1, 3, 1, 2].</p>
<p>Note:<br>You may assume all input has valid answer.</p>
<p>Follow Up:<br>Can you do it in O(n) time and/or in-place with O(1) extra space?</p>
<p><strong>Thinking:</strong></p>
<p>Firstly, we get information from the question is that we should divide all the elements into two groups. One is smaller ones, and the other is greater ones. Then we need to get the median to group them.</p>
<p>So we need the method called quickselect which is used in the kth largest element to get the median. Then rewire the element to new index which use (1+2<em>(i)) % (n|1). It(A(i) = nums[(1+2</em>(i)) % (n|1)]) means:</p>
<p>If the length of array is 10, then</p>
<p>Accessing A(0) actually accesses nums[1].<br>Accessing A(1) actually accesses nums[3].<br>Accessing A(2) actually accesses nums[5].<br>Accessing A(3) actually accesses nums[7].<br>Accessing A(4) actually accesses nums[9].<br>Accessing A(5) actually accesses nums[0].<br>Accessing A(6) actually accesses nums[2].<br>Accessing A(7) actually accesses nums[4].<br>Accessing A(8) actually accesses nums[6].<br>Accessing A(9) actually accesses nums[8].</p>
<p>We firstly put ones greater than median, then median, finally smaller than median. We’ll get the result.</p>
<p>There are some details to notice:</p>
<ol>
<li>In the rewiring process, we need to distinguish whether the length of the array is odd or even. Use the (n|1).</li>
<li>In the 3 way partition process, when move larger element to the head, we don’t need to check it again. Because the element move from the head to the current position is checked before. On the other hand, the element which is moved from the current position to tail, we need to check it again.</li>
</ol>
<p><strong>Solution:</strong></p>
<pre><code>public void wiggleSort(int[] nums) {
    int len = nums.length;
    if (len &lt; 2)    return;

    quickselect(nums, (len-1)/2);
    int mid = nums[(len-1)/2];

    int i = 0, j = len - 1, cur = 0;

    while (cur &lt;= j) {
        if (nums[(2*cur+1)%(len|1)] &gt; mid)
            swap(nums, (2*(cur++)+1)%(len|1), (2*(i++)+1)%(len|1));
        else if (nums[(2*cur+1)%(len|1)] &lt; mid)    
            swap(nums, (2*(cur)+1)%(len|1), (2*(j--)+1)%(len|1));
        else    
            cur++;
    }
}

private void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

private void quickselect(int[] nums, int n) {
    int low = 0, high = nums.length-1;

    while (true) {
        int i = partition(nums, low, high);
        if (i == n)    return;
        else if (i &lt; n) low = i + 1;
        else    high = i - 1;
    }
}

private int partition (int[] nums, int left, int right) {
    int pivot = nums[left];
    int storeIndex = left;
    nums[left] = nums[right];
    for (int i = left; i &lt; right; i++) {
        if (nums[i] &lt;= pivot)
            swap(nums, storeIndex++, i);
    }
    nums[right] = nums[storeIndex];
    nums[storeIndex] = pivot;

    return storeIndex;
}
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/77133/o-n-o-1-after-median-virtual-indexing" target="_blank" rel="external">https://leetcode.com/discuss/77133/o-n-o-1-after-median-virtual-indexing</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode Range Sum Query 2D - Immutable(Java)]]></title>
      <url>http://yoursite.com/2016/03/08/Leetcode-Range-Sum-Query-2D-Immutable-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a 2D matrix matrix, find the sum of the elements inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).</p>
<p><img src="https://leetcode.com/static/images/courses/range_sum_query_2d.png" alt=""></p>
<p>Range Sum Query 2D<br>The above rectangle (with the red border) is defined by (row1, col1) = (2, 1) and (row2, col2) = (4, 3), which contains sum = 8.</p>
<p>Example:</p>
<pre><code>Given matrix = [
  [3, 0, 1, 4, 2],
  [5, 6, 3, 2, 1],
  [1, 2, 0, 1, 5],
  [4, 1, 0, 1, 7],
  [1, 0, 3, 0, 5]
]

sumRegion(2, 1, 4, 3) -&gt; 8
sumRegion(1, 1, 2, 2) -&gt; 11
sumRegion(1, 2, 2, 4) -&gt; 12
</code></pre><p>Note:</p>
<p>1.You may assume that the matrix does not change.</p>
<p>2.There are many calls to sumRegion function.</p>
<p>3.You may assume that row1 ≤ row2 and col1 ≤ col2.</p>
<p><strong>Thinking:</strong></p>
<p>I see this problem as a matrix caculating. We should get the sum of the current i, j (row and column index) from 0, 0. Then caculate the region sum from previous stored values.</p>
<p><strong>Solution:</strong></p>
<pre><code>private int[][] sumMatrix = null;

public NumMatrix(int[][] matrix) {
    if(matrix == null || matrix.length == 0 || matrix[0].length == 0)    return;   
    int m = matrix.length;
    int n = matrix[0].length;
    this.sumMatrix = new int[m+1][n+1];

    for (int i = 1; i &lt;= m; i++) 
        for (int j = 1; j &lt;= n; j++) 
            sumMatrix[i][j] = sumMatrix[i-1][j] + sumMatrix[i][j-1] + matrix[i-1][j-1] - sumMatrix[i-1][j-1];

}

public int sumRegion(int row1, int col1, int row2, int col2) {
    return sumMatrix[row2+1][col2+1] + sumMatrix[row1][col1] - sumMatrix[row2+1][col1] - sumMatrix[row1][col2+1];
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[The Zen of Python]]></title>
      <url>http://yoursite.com/2016/03/08/The-Zen-of-Python/</url>
      <content type="html"><![CDATA[<p><strong>The Zen of Python:</strong></p>
<p>Beautiful is better than ugly.</p>
<p>Explicit is better than implicit.</p>
<p>Simple is better than complex.</p>
<p>Complex is better than complicated.</p>
<p>Flat is better than nested.</p>
<p>Sparse is better than dense.</p>
<p>Readability counts.</p>
<p>Special cases aren’t special enough to break the rules.</p>
<p>Although practicality beats purity.</p>
<p>Errors should never pass silently.</p>
<p>Unless explicitly silenced.</p>
<p>In the face of ambiguity, refuse the temptation to guess.</p>
<p>There should be one– and preferably only one –obvious way to do it.</p>
<p>Although that way may not be obvious at first unless you’re Dutch.</p>
<p>Now is better than never.</p>
<p>Although never is often better than <em>right</em> now.</p>
<p>If the implementation is hard to explain, it’s a bad idea.</p>
<p>If the implementation is easy to explain, it may be a good idea.</p>
<p>Namespaces are one honking great idea – let’s do more of those!</p>
<p>(Reference: <a href="https://www.python.org/dev/peps/pep-0020/" target="_blank" rel="external">https://www.python.org/dev/peps/pep-0020/</a>)</p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Reconstruct Itinerary(Java)]]></title>
      <url>http://yoursite.com/2016/03/08/Leetcode-Reconstruct-Itinerary-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.</p>
<p>Note:<br>If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string. For example, the itinerary </p>
<p> 1.[“JFK”, “LGA”] has a smaller lexical order than [“JFK”, “LGB”].</p>
<p> 2.All airports are represented by three capital letters (IATA code).</p>
<p> 3.You may assume all tickets form at least one valid itinerary.</p>
<p>Example 1:</p>
<pre><code>tickets = [[&quot;MUC&quot;, &quot;LHR&quot;], [&quot;JFK&quot;, &quot;MUC&quot;], [&quot;SFO&quot;, &quot;SJC&quot;], [&quot;LHR&quot;, &quot;SFO&quot;]]
</code></pre><p>Return </p>
<pre><code>[&quot;JFK&quot;, &quot;MUC&quot;, &quot;LHR&quot;, &quot;SFO&quot;, &quot;SJC&quot;].
</code></pre><p>Example 2:</p>
<pre><code>tickets = [[&quot;JFK&quot;,&quot;SFO&quot;],[&quot;JFK&quot;,&quot;ATL&quot;],[&quot;SFO&quot;,&quot;ATL&quot;],[&quot;ATL&quot;,&quot;JFK&quot;],[&quot;ATL&quot;,&quot;SFO&quot;]]
</code></pre><p>Return </p>
<pre><code>[&quot;JFK&quot;,&quot;ATL&quot;,&quot;JFK&quot;,&quot;SFO&quot;,&quot;ATL&quot;,&quot;SFO&quot;].
</code></pre><p>Another possible reconstruction is [“JFK”,”SFO”,”ATL”,”JFK”,”ATL”,”SFO”]. But it is larger in lexical order.</p>
<p><strong>Thinking:</strong></p>
<p>We need to use dfs to travse all the graph and record the graph. But we need to record it in order. So it should be stored in PriorityQueue and store the route while visiting. If it’s stuck we back up but also record the previous information, because we know there are other ways to get there. Until all the edges are visited once, it’s finished.</p>
<p><strong>Solution:</strong></p>
<pre><code>List&lt;String&gt; res = new ArrayList&lt;String&gt;();
HashMap&lt;String, PriorityQueue&lt;String&gt;&gt; map = new HashMap&lt;String, PriorityQueue&lt;String&gt;&gt;();

public List&lt;String&gt; findItinerary(String[][] tickets) {
    for (String[] ticket: tickets)
        map.computeIfAbsent(ticket[0], k -&gt; new PriorityQueue&lt;String&gt;()).add(ticket[1]);
    visit(&quot;JFK&quot;);

    return res;
}

private void visit(String cur) {
    while (map.containsKey(cur) &amp;&amp; !map.get(cur).isEmpty())
        visit(map.get(cur).poll());
    res.add(0, cur);
}
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/84659/short-ruby-python-java-c" target="_blank" rel="external">https://leetcode.com/discuss/84659/short-ruby-python-java-c</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Maximum Product Subarray(Java)]]></title>
      <url>http://yoursite.com/2016/03/07/Leetcode-Maximum-Product-Subarray-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Find the contiguous subarray within an array (containing at least one number) which has the largest product.</p>
<p>For example, given the array [2,3,-2,4],<br>the contiguous subarray [2,3] has the largest product = 6.</p>
<p><strong>Thinking:</strong></p>
<p>This problem is similiar with the MaxSubArray. One thing we need to notice is that we should maintian another variable which is the minimum value of the negative value. When it multiple the negtive value in the array, it maybe the maximum.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int maxProduct(int[] nums) {
    int l = nums.length;
    int max = nums[0];
    int maxhere = nums[0];
    int minhere = nums[0];

    for (int i = 1; i &lt; l; i++) {
        if (nums[i] &gt;= 0) {
            maxhere = Math.max(maxhere*nums[i], nums[i]);
            minhere = Math.min(minhere*nums[i], nums[i]);
        } else {
            int temp = maxhere;
            maxhere = Math.max(minhere*nums[i], nums[i]);
            minhere = Math.min(temp*nums[i], nums[i]);
        }
        max = Math.max(maxhere, max);
    }

    return max;
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Evaluate Reverse Polish Notation(Java)]]></title>
      <url>http://yoursite.com/2016/03/07/Leetcode-Evaluate-Reverse-Polish-Notation-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Evaluate the value of an arithmetic expression in Reverse Polish Notation.</p>
<p>Valid operators are +, -, *, /. Each operand may be an integer or another expression.</p>
<p>Some examples:</p>
<pre><code>[&quot;2&quot;, &quot;1&quot;, &quot;+&quot;, &quot;3&quot;, &quot;*&quot;] -&gt; ((2 + 1) * 3) -&gt; 9
[&quot;4&quot;, &quot;13&quot;, &quot;5&quot;, &quot;/&quot;, &quot;+&quot;] -&gt; (4 + (13 / 5)) -&gt; 6
</code></pre><p><strong>Thinking:</strong></p>
<p>We should use stack and scan the elements of this string array. Whenever we get the operator, we pop element from the stack and push new element to the stack.</p>
<p><strong>Solutioin:</strong></p>
<pre><code>public int evalRPN(String[] tokens) {
    Stack&lt;Integer&gt; stack = new Stack&lt;Integer&gt;();

    for (String s: tokens) {
        if (s.equals(&quot;+&quot;)) {
            int num1 = stack.pop();
            int num2 = stack.pop();
            stack.push(num1+num2);
        }
        else if (s.equals(&quot;-&quot;)) {
            int num1 = stack.pop();
            int num2 = stack.pop();
            stack.push(num2-num1);
        }
        else if (s.equals(&quot;*&quot;)) {
            int num1 = stack.pop();
            int num2 = stack.pop();
            stack.push(num1*num2);
        }
        else if (s.equals(&quot;/&quot;)) {
            int num1 = stack.pop();
            int num2 = stack.pop();
            stack.push(num2/num1);
        }
        else
            stack.push(Integer.parseInt(s));
    }

    return stack.pop();
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Increasing Triplet Subsequence(Java)]]></title>
      <url>http://yoursite.com/2016/03/07/Leetcode-Increasing-Triplet-Subsequence-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array.</p>
<p>Formally the function should:<br>Return true if there exists i, j, k<br>such that arr[i] &lt; arr[j] &lt; arr[k] given 0 ≤ i &lt; j &lt; k ≤ n-1 else return false.<br>Your algorithm should run in O(n) time complexity and O(1) space complexity.</p>
<p>Examples:<br>Given [1, 2, 3, 4, 5],<br>return true.</p>
<p>Given [5, 4, 3, 2, 1],<br>return false.</p>
<p><strong>Thinking:</strong></p>
<p>We need to implement this algorithm in linear time and constant space. So we need to scan this array once and record the information needed in one time. We need to variable to record the information, the first one is the minimum of this array, and the second one is the number which is bigger than its previous elements. If one element is bigger than it, the result will be true. Otherwise, we should update the two variables’ values.</p>
<p><strong>Solution:</strong></p>
<pre><code>public boolean increasingTriplet(int[] nums) {
    int l = nums.length;
    if (l &lt; 3)    return false;
    int min = nums[0];
    int secmin = Integer.MAX_VALUE;

    for (int i = 1; i &lt; l; i++) {
        if (nums[i] &gt; secmin)    return true;
        else if (nums[i] &lt;= min) min = nums[i];
        else if (nums[i] &lt; secmin)    secmin = nums[i];
    }
    return false;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Shortest Path Problem]]></title>
      <url>http://yoursite.com/2016/03/06/Shortest-Path-Problem/</url>
      <content type="html"><![CDATA[<p><strong>Shorstest Path Problem Categories:</strong></p>
<ol>
<li>From a speicific start point;</li>
<li>To a specific end point;</li>
<li>Start and end with a specific point;</li>
<li>Search for all the shortest path in every pair nodes.</li>
</ol>
<p><strong>Dijkstra:</strong></p>
<p>This algorithm is aiming at caculating all the shortest paths from every point to a specific start point. And it’s a greedy algorithm.</p>
<p>Algorithm:</p>
<ol>
<li>Set the distance to the start node as infinity to all the nodes except the start node.</li>
<li>Initial a set which conclude the added nodes, and another set for unvisited nodes.</li>
<li>For the added nodes set, we find the shortest edge from adjancent nodes crossing this set in unvisited set. And add the adjancent node to the added added nodes.</li>
<li>Update the distances of nodes from start node which connect to the last added node.</li>
<li>Do step 3 and 4 repeatedly until all the nodes are in the added set.</li>
</ol>
<p>Pseudoode:</p>
<pre><code>function Dijkstra(Graph, source):

    create vertex set Q

    for each vertex v in Graph:             // Initialization
    dist[v] ← INFINITY                  // Unknown distance from source to v
    prev[v] ← UNDEFINED                 // Previous node in optimal path from source
    add v to Q                          // All nodes initially in Q (unvisited nodes)

    dist[source] ← 0                        // Distance from source to source

    while Q is not empty:
        u ← vertex in Q with min dist[u]    // Source node will be selected first
        remove u from Q 

        for each neighbor v of u:           // where v is still in Q.
            alt ← dist[u] + length(u, v)
            if alt &lt; dist[v]:               // A shorter path to v has been found
                dist[v] ← alt 
                prev[v] ← u 

    return dist[], prev[]
</code></pre><p>Java Code:</p>
<pre><code>public static void dijkstra(int[][] edges, int s, int[] dist, int[] pre) {
    int n = edges.length;

    HashSet&lt;Integer&gt; set = new HashSet&lt;Integer&gt;(n);

    for (int i = 0; i &lt; n; i++) {
        dist[i] = Integer.MAX_VALUE;
        set.add(i);
    }
    dist[s] = 0;

    while (!set.isEmpty()) {
        int min = findMin(set, dist);
        for (int i = 0; i &lt; n; i++) {
            if (edges[min][i] != -1) { // find the neighbors of the node
                if (dist[i] &lt; dist[min] + edges[min][i]) { //relaxation
                    dist[i] = dist[min] + edges[min][i];
                    pre[i] = min;
                }
            }
        }
    }
}
private static int findMin(Set set, int[] dist) {
    int min = Integer.MAX_VALUE, minIdx = -1;
    for (int i = 0; i &lt; dist.length; i++) {
        if (set.contains(i) &amp;&amp; dist[i] &lt; min) {
            min = dist[i];
            minIdx = i;
        }
    }
    set.remove(minIdx);
    return minIdx;
}
</code></pre><p>Running Time:</p>
<p>O(E*lgv)</p>
<p>If use the Fibonacci heap -&gt;  O(V*lgV + E)</p>
<p><strong>Bellman Ford:</strong></p>
<p>Aimming at searching for the shortest path from a specific start node. It is useful also for the graph containing the negative edges. It’s a dynamic programming algorithm.</p>
<p>Algorithm:</p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Maximal Square(Java)]]></title>
      <url>http://yoursite.com/2016/02/27/Leetcode-Maximal-Square-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a 2D binary matrix filled with 0’s and 1’s, find the largest square containing all 1’s and return its area.</p>
<p>For example, given the following matrix:</p>
<pre><code>1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
</code></pre><p>Return 4.</p>
<p><strong>Thinking:</strong></p>
<p>IIf the [i-1][j], [i][j-1] and [i-1][j-1] all have the same length of ‘1’ edge and the [i][j] is ‘1’, the length of the square can increase.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int maximalSquare(char[][] matrix) {
    int m = matrix.length;
    if (m == 0)    return 0;
    int n = matrix[0].length;
    int res = 0;
    int[][] opt = new int[m+1][n+1];

    for (int i = 1; i &lt;= m; i++){
        for (int j = 1; j &lt;= n; j++) {
            if (matrix[i-1][j-1] == &apos;1&apos;) {
                opt[i][j] = Math.min(opt[i-1][j-1], Math.min(opt[i-1][j], opt[i][j-1])) + 1;
                res = Math.max(res, opt[i][j]);
            }
        }
    }

    return res * res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Reorder List(Java)]]></title>
      <url>http://yoursite.com/2016/02/27/Leetcode-Reorder-List-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a singly linked list L: L0→L1→…→Ln-1→Ln,<br>reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…</p>
<p>You must do this in-place without altering the nodes’ values.</p>
<p>For example,<br>Given {1,2,3,4}, reorder it to {1,4,2,3}.</p>
<p><strong>Thinking:</strong></p>
<p>We need three steps to finish this operation. The first one is to find the middle in the linked list. The second one is to reverse the second half of this linked list. The final one is to link these two parts again.</p>
<p><strong>Solution:</strong></p>
<pre><code>public void reorderList(ListNode head) {
    if (head == null || head.next == null)    return;
    ListNode slow = head, fast = head.next, preMiddle, preCurrent, current, p, q;

    //find the middle
    while (fast != null &amp;&amp; fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }

    //reverse the second half
    preMiddle = slow;
    preCurrent = slow.next;
    while (preCurrent.next != null) {
        current = preCurrent.next;
        preCurrent.next = current.next;
        current.next = preMiddle.next;
        preMiddle.next = current;
    }

    //connect two parts
    p = head;
    q = preMiddle.next;
    while (p != preMiddle) {
        preMiddle.next = q.next;
        q.next = p.next;
        p.next = q;
        p = q.next;
        q = preMiddle.next;
    }

}
</code></pre><p>Reference:<a href="https://leetcode.com/discuss/35599/java-solution-with-3-steps" target="_blank" rel="external">https://leetcode.com/discuss/35599/java-solution-with-3-steps</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Word Ladder(Java)]]></title>
      <url>http://yoursite.com/2016/02/26/Leetcode-Word-Ladder-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>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:</p>
<p>Only one letter can be changed at a time<br>Each intermediate word must exist in the word list<br>For example,</p>
<p>Given:<br>beginWord = “hit”<br>endWord = “cog”<br>wordList = [“hot”,”dot”,”dog”,”lot”,”log”]<br>As one shortest transformation is “hit” -&gt; “hot” -&gt; “dot” -&gt; “dog” -&gt; “cog”,<br>return its length 5.</p>
<p>Note:<br>Return 0 if there is no such transformation sequence.<br>All words have the same length.<br>All words contain only lowercase alphabetic characters.</p>
<p><strong>Thinking:</strong></p>
<p>We can search the result from the start word. At every step, we change the every index of the start string and check if it’s in the WordList. If it’s in the range, then we add it to our nodes. Do it like a BFS search. Also in order to be more efficient, we can search also from the end word.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int ladderLength(String beginWord, String endWord, Set&lt;String&gt; wordList) {
    if (beginWord.equals(endWord))    return 1;
    Set&lt;String&gt; startSet = new HashSet&lt;String&gt;();
    Set&lt;String&gt; endSet =  new HashSet&lt;String&gt;();
    int res = 1;
    startSet.add(beginWord);
    endSet.add(endWord);
    while (!wordList.isEmpty() &amp;&amp; !startSet.isEmpty() &amp;&amp; !endSet.isEmpty()) {
        res++;
        Set&lt;String&gt; tempSet = new HashSet&lt;String&gt;();
        for (String nWord: startSet) {
            wordList.remove(nWord);
            for (String ele: check(nWord, wordList)) {
                if (endSet.contains(ele))    return res;
                tempSet.add(ele);
            }
        }
        startSet = tempSet;
        tempSet = new HashSet&lt;String&gt;();
        res++;
        for (String nWord: endSet) {
            wordList.remove(nWord);
            for (String ele: check(nWord, wordList)) {
                if (startSet.contains(ele))    return res;
                tempSet.add(ele);
            }
        }
        endSet = tempSet;
    }
    return 0;
}
private List&lt;String&gt; check(String word, Set&lt;String&gt; wordList) {
    List&lt;String&gt; res = new ArrayList&lt;String&gt;();
    int len = word.length();
    if (len == 1)    {
        res.addAll(wordList);
        return res;
    }
    for (int i = 0; i &lt; len; i++) {
        char[] chs = word.toCharArray();
        for (char j = &apos;a&apos;; j &lt;= &apos;z&apos;; j++) {
            chs[i] = j;
            String temp = String.valueOf(chs);
            if (wordList.contains(temp))    res.add(temp);              
        }
    }
    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Validate Binary Search Tree(Java)]]></title>
      <url>http://yoursite.com/2016/02/26/Leetcode-Validate-Binary-Search-Tree-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a binary tree, determine if it is a valid binary search tree (BST).</p>
<p>Assume a BST is defined as follows:</p>
<p>The left subtree of a node contains only nodes with keys less than the node’s key.<br>The right subtree of a node contains only nodes with keys greater than the node’s key.<br>Both the left and right subtrees must also be binary search trees.</p>
<p><strong>Thinking:</strong></p>
<p>We should use dfs check the root of the range and both its left child and right child.</p>
<p><strong>Solution:</strong></p>
<pre><code>public boolean isValidBST(TreeNode root) {
    return helper(root, Long.MIN_VALUE, Long.MAX_VALUE);
}

private boolean helper(TreeNode root, long a, long b) {
    if (root == null)    return true;
    if (root.val &lt;= a || root.val &gt;= b)    return false;        
    return helper(root.left, a, root.val&lt;b? root.val:b) &amp;&amp; helper(root.right, root.val&gt;a? root.val:a, b);
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Decode Ways(Java)]]></title>
      <url>http://yoursite.com/2016/02/26/Leetcode-Decode-Ways-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>A message containing letters from A-Z is being encoded to numbers using the following mapping:</p>
<p>‘A’ -&gt; 1<br>‘B’ -&gt; 2<br>…<br>‘Z’ -&gt; 26<br>Given an encoded message containing digits, determine the total number of ways to decode it.</p>
<p>For example,<br>Given encoded message “12”, it could be decoded as “AB” (1 2) or “L” (12).</p>
<p>The number of ways decoding “12” is 2.</p>
<p><strong>Thinking:</strong></p>
<p>If we use the recursive way, we should see that the search tree will go down like check [0],[0,1], then [1],[1,2] and [2],[2,3] then [2], [2,3] and [3],[3,4] and [3],[3,4] and [4],[4,5] … There are some nodes are repeated. So we can use interation from bottom to root to store the number of paths in every index of string.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int numDecodings(String s) {
    int l = s.length();
    if (l == 0)    return 0;
    int[] counts = new int[l+1];

    counts[l] = 1;
    if (s.charAt(l-1) != &apos;0&apos;)    counts[l-1] = 1;

    for (int i = l-2; i &gt;=0; i--) {
        if (s.charAt(i) == &apos;0&apos;)    continue;
        counts[i] = Integer.parseInt(s.substring(i, i+2)) &lt;=26? counts[i+1]+counts[i+2] : counts[i+1];
    }

    return counts[0];
}
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/8527/dp-solution-java-for-reference" target="_blank" rel="external">https://leetcode.com/discuss/8527/dp-solution-java-for-reference</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Simplify Path(Java)]]></title>
      <url>http://yoursite.com/2016/02/25/Leetcode-Simplify-Path-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an absolute path for a file (Unix-style), simplify it.</p>
<p>For example,<br>path = “/home/“, =&gt; “/home”<br>path = “/a/./b/../../c/“, =&gt; “/c”<br>click to show corner cases.</p>
<p>Corner Cases:<br>Did you consider the case where path = “/../“?<br>In this case, you should return “/“.<br>Another corner case is the path might contain multiple slashes ‘/‘ together, such as “/home//foo/“.<br>In this case, you should ignore redundant slashes and return “/home/foo”.</p>
<p><strong>Thinking:</strong></p>
<p>The file system is like a tree, and finding path of this tree is like a dfs process. So we can use stack to track the node of dfs. If the string is “..”, we go back, otherwise go to the given dirctory.</p>
<p><strong>Solution:</strong></p>
<pre><code>public String simplifyPath(String path) {
    Stack&lt;String&gt; stack = new Stack&lt;String&gt;();
    String[] paths = path.split(&quot;/&quot;);

    for (String p: paths) {
        p = p.trim();
        if (p.equals(&quot;&quot;) || p.equals(&quot;.&quot;))    continue;
        if (p.equals(&quot;..&quot;))    {
            if (!stack.isEmpty()) {
                stack.pop();
            }
            continue;
        }
        stack.push(p);
    }

    StringBuilder res = new StringBuilder();
    while (!stack.isEmpty()) 
        res.insert(0, &quot;/&quot;.concat(stack.pop()));


    return res.length() == 0? &quot;/&quot;:res.toString();
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Word Search(Java)]]></title>
      <url>http://yoursite.com/2016/02/25/Leetcode-Word-Search-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a 2D board and a word, find if the word exists in the grid.</p>
<p>The word can be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.</p>
<p>For example,<br>Given board =</p>
<p>[<br>  [‘A’,’B’,’C’,’E’],<br>  [‘S’,’F’,’C’,’S’],<br>  [‘A’,’D’,’E’,’E’]<br>]<br>word = “ABCCED”, -&gt; returns true,<br>word = “SEE”, -&gt; returns true,<br>word = “ABCB”, -&gt; returns false.</p>
<p><strong>Thinking:</strong></p>
<p>I assume it’s graph and do dfs in this 2d array. Start from every point and search the result until find the solution or failure. In this process, we need to record the visitied set. In my solution, I used the hashset. But in more efficient way, we can use bit manipulate to mask the visited element.</p>
<p><strong>Solution:</strong></p>
<p>My solution(use HashSet):</p>
<pre><code>public boolean exist(char[][] board, String word) {
    int m = board.length;
    if (m == 0)    return false;
    int n = board[0].length;
    Set&lt;Integer&gt; record = new HashSet&lt;Integer&gt;();
    for (int i = 0; i &lt; m; i++)
        for (int j = 0; j &lt; n; j++)
            if (backtracking(board, word, 0, i, j, record))    return true;
    return false;
}

private boolean backtracking(char[][] board, String word, int index, int i, int j, Set&lt;Integer&gt; record) {
    if (board[i][j] == word.charAt(index) &amp;&amp; !record.contains(i*board[0].length+j)){
        if (index == word.length()-1)    return true;
        boolean res = false;
        record.add(i*board[0].length+j);
        if (i-1&gt;=0)    res |= backtracking(board, word, index+1, i-1, j, record);
        if (!res &amp;&amp; i+1&lt;board.length) res |= backtracking(board, word, index+1, i+1, j, record);
        if (!res &amp;&amp; j-1&gt;=0)    res |= backtracking(board, word, index+1, i, j-1, record);
        if (!res &amp;&amp; j+1&lt;board[0].length) res |= backtracking(board, word, index+1, i, j+1, record);
        record.remove(i*board[0].length+j);
        return res;
    }
    return false;
}
</code></pre><p>use the mask:</p>
<pre><code>public boolean exist(char[][] board, String word) {
    char[] w = word.toCharArray();
    for (int y=0; y&lt;board.length; y++) {
        for (int x=0; x&lt;board[y].length; x++) {
            if (exist(board, y, x, w, 0)) return true;
        }
    }
    return false;
}

private boolean exist(char[][] board, int y, int x, char[] word, int i) {
    if (i == word.length) return true;
    if (y&lt;0 || x&lt;0 || y == board.length || x == board[y].length) return false;
    if (board[y][x] != word[i]) return false;
        board[y][x] ^= 256;
    boolean exist = exist(board, y, x+1, word, i+1)
    || exist(board, y, x-1, word, i+1)
    || exist(board, y+1, x, word, i+1)
    || exist(board, y-1, x, word, i+1);
    board[y][x] ^= 256;
    return exist;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Spiral Matrix(Java)]]></title>
      <url>http://yoursite.com/2016/02/23/Leetcode-Spiral-Matrix-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.</p>
<p>For example,<br>Given the following matrix:</p>
<pre><code>[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
</code></pre><p>You should return [1,2,3,6,9,8,7,4,5].</p>
<p><strong>Thinking:</strong></p>
<p>There are four directions can go, move according to the order of right, down, left, up and check the bound of moving.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;Integer&gt; spiralOrder(int[][] matrix) {
    List&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();
    int m = matrix.length;
    if (m == 0)    return res;
    int n = matrix[0].length;
    int direction = 0;//0right, 1down, 2left, 3up
    int i = 0, j = 0;//position
    int c0 = 1, c1 = 1, c2 = 0, c3 = 1;//row and column limit

    while (c0 + c2 - 1 &lt;= n &amp;&amp; c1 + c3 - 1 &lt;= m) {
        res.add(matrix[i][j]);
        switch (direction) {
        case 0:
            if (j == n-c0){
                direction = (direction+1) % 4;
                c0++;
                res.remove(res.size()-1);
            }
            else
                j++;
            break;
        case 1:
            if (i == m-c1){
                direction = (direction+1) % 4;
                c1++;
                res.remove(res.size()-1);
            }
            else
                i++;
            break;
        case 2:
            if (j == c2){
                direction = (direction+1) % 4;
                c2++;
                res.remove(res.size()-1);
            }
            else
                j--;
            break;
        case 3:
            if (i == c3){
                direction = (direction+1) % 4;
                c3++;
                res.remove(res.size()-1);
            }
            else
                i--;
            break;
        }
    }
    res.add(matrix[i][j]);

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Multiply Strings(Java)]]></title>
      <url>http://yoursite.com/2016/02/23/Leetcode-Multiply-Strings-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given two numbers represented as strings, return multiplication of the numbers as a string.</p>
<p>Note: The numbers can be arbitrarily large and are non-negative.</p>
<p><strong>Thinking:</strong></p>
<p>Simulate the process of multiplying.</p>
<p><img src="https://drscdn.500px.org/photo/130178585/m%3D2048/300d71f784f679d5e70fadda8ad7d68f" alt=""></p>
<p><strong>Solution:</strong> (Record the result from low digits to high digits in array)</p>
<pre><code>public String multiply(String num1, String num2) {
    int l1 = num1.length(), l2 = num2.length();
    int[] res = new int[l1+l2];

    for (int i = l1-1; i &gt;= 0; i--) {
        for (int j = l2-1; j &gt;= 0; j--){
            int index = l1+l2-i-j-2;
            res[index] += (num1.charAt(i) - &apos;0&apos;) * (num2.charAt(j) - &apos;0&apos;);
            res[index+1] += res[index] / 10;
            res[index] = res[index] % 10;
        }
    }

    StringBuilder fres = new StringBuilder();
    for (int i = res.length-1; i &gt;= 0; i--)
        if (!(fres.length() == 0 &amp;&amp; res[i] == 0))   fres.append(res[i]);

    return fres.length() == 0? &quot;0&quot;:fres.toString();
}
</code></pre><p>A little improvement which record the result from high to low digits in array:</p>
<p>public String multiply(String num1, String num2) {<br>    int m = num1.length(), n = num2.length();<br>    int[] pos = new int[m + n];</p>
<pre><code>for(int i = m - 1; i &gt;= 0; i--) {
    for(int j = n - 1; j &gt;= 0; j--) {
        int mul = (num1.charAt(i) - &apos;0&apos;) * (num2.charAt(j) - &apos;0&apos;); 
        int p1 = i + j, p2 = i + j + 1;
        int sum = mul + pos[p2];

        pos[p1] += sum / 10;
        pos[p2] = (sum) % 10;
    }
}  

StringBuilder sb = new StringBuilder();
for(int p : pos) if(!(sb.length() == 0 &amp;&amp; p == 0)) sb.append(p);
return sb.length() == 0 ? &quot;0&quot; : sb.toString();
</code></pre><p>}</p>
<p>Reference: <a href="https://leetcode.com/discuss/71593/easiest-java-solution-with-graph-explanation" target="_blank" rel="external">https://leetcode.com/discuss/71593/easiest-java-solution-with-graph-explanation</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Rotate List(Java)]]></title>
      <url>http://yoursite.com/2016/02/23/Leetcode-Rotate-List-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a list, rotate the list to the right by k places, where k is non-negative.</p>
<p>For example:<br>Given 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL and k = 2,<br>return 4-&gt;5-&gt;1-&gt;2-&gt;3-&gt;NULL.</p>
<p><strong>Thinking:</strong></p>
<p>Firstly, count the length of the linked list. Then get the n-k th node. Finnaly, change the pointer of it and the tail.</p>
<p><strong>Solution:</strong></p>
<pre><code>public ListNode rotateRight(ListNode head, int k) {
    if (head == null || head.next == null)    return head;
    ListNode p = head;
    int count = 1;
    while (p.next != null) {
        p = p.next;
        count++;
    }
    if (k == count)    return head;
    p.next = head;
    p = head;
    for (int i = 1; i &lt; count - k%count; i++) {
        p = p.next;
    }
    ListNode nhead = p.next;
    p.next = null;

    return nhead;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Remove Duplicate Letters(Java)]]></title>
      <url>http://yoursite.com/2016/02/23/Leetcode-Remove-Duplicate-Letters-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>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.</p>
<p>Example:<br>Given “bcabc”<br>Return “abc”</p>
<p>Given “cbacdcbc”<br>Return “acdb”</p>
<p><strong>Thinking:</strong></p>
<p>Record the times characters emerges in the list and check from left to right.Record the smallest character postion of the list until find the unique character, then delete the bigger characters before smallest one and delete smallest from the rest of list.</p>
<p><strong>Solution:</strong></p>
<pre><code>public String removeDuplicateLetters(String s) {
    int[] count = new int[26];
    int smallest = 0;
    if (s.length() == 0)    return &quot;&quot;;
    for (char c: s.toCharArray())    count[c-&apos;a&apos;]++;
    for (int i = 0; i &lt; s.length(); i++){
        if (s.charAt(i) &lt; s.charAt(smallest))    smallest = i;
        if (--count[s.charAt(i) - &apos;a&apos;] == 0)    break;
    }
    return s.charAt(smallest) + removeDuplicateLetters(s.substring(smallest+1).replaceAll(s.charAt(smallest)+&quot;&quot;, &quot;&quot;));
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Number of Digit One(Java)]]></title>
      <url>http://yoursite.com/2016/02/23/Leetcode-Number-of-Digit-One-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an integer n, count the total number of digit 1 appearing in all non-negative integers less than or equal to n.</p>
<p>For example:<br>Given n = 13,<br>Return 6, because digit 1 occurred in the following numbers: 1, 10, 11, 12, 13.</p>
<p>Hint:</p>
<p>Beware of overflow.</p>
<p><strong>Thinking:</strong></p>
<p>This is question to find formula. We should notice that: </p>
<pre><code>1                   1                                                                                     [1, 9]

11                 10  11  12  13  14  15  16  17  18  19                              [10, 19]

1                   21                                                                                   [20, 29]

1                   31                                                                                   [30, 39]

1                   41                                                                                   [40, 49]

1                   51                                                                                   [50, 59]

1                   61                                                                                   [60, 69]

1                   71                                                                                   [70, 79]

1                   81                                                                                   [80, 89]

1                   91                                                                                   [90, 99]

11                 100  101  102  103  104  105  106  107  108  109          [100, 109]

21                 110  111  112  113  114  115  116  117  118  119             [110, 119]

11                 120  121  122  123  124  125  126  127  128  129          [120, 129]
</code></pre><p>We should divide it into three situations in every digit division: one is bigger than 2, another is equal to 1 and the rest is less than 0. </p>
<p><strong>Solution:</strong></p>
<pre><code>public int countDigitOne(int n) {
    int res = 0;
    for (long m = 1; m &lt;= n; m*=10) {
        res += (n/m + 8) / 10 * m + (n/m % 10 == 1? n%m+1:0);
    }
    return res;
}
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/44281/4-lines-o-log-n-c-java-python" target="_blank" rel="external">https://leetcode.com/discuss/44281/4-lines-o-log-n-c-java-python</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Basic Calculator II(Java)]]></title>
      <url>http://yoursite.com/2016/02/22/Leetcode-Basic-Calculator-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Implement a basic calculator to evaluate a simple expression string.</p>
<p>The expression string contains only non-negative integers, +, -, *, / operators and empty spaces . The integer division should truncate toward zero.</p>
<p>You may assume that the given expression is always valid.</p>
<p>Some examples:</p>
<pre><code>&quot;3+2*2&quot; = 7
&quot; 3/2 &quot; = 1
&quot; 3+5 / 2 &quot; = 5
</code></pre><p>Note: Do not use the eval built-in library function.</p>
<p><strong>Thinking:</strong></p>
<p>An efficient way to solve this problem is to use stack get last num for an operation. And in order to delay the operation after get the two numbers, we need a op variable to record the last op until find the second number. What’s more, accroding to their op, numbers push into the stack in different ways. Finnaly, we just need to get the element from stack and add them all.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int calculate(String s) {
    Stack&lt;Long&gt; stack = new Stack&lt;Long&gt;();

    int i = 0;
    char op = &apos;+&apos;;
    long num = 0;

    while (i &lt; s.length()) {
        if (Character.isDigit(s.charAt(i))) {
            while (i &lt; s.length() &amp;&amp; Character.isDigit(s.charAt(i)))
                num = num * 10 + s.charAt(i++) - &apos;0&apos;;
        }
        else if (s.charAt(i) == &apos; &apos;)
            i++;
        else {
            if (op == &apos;+&apos;)
                stack.push(num);
            else if (op == &apos;-&apos;)
                stack.push(-num);
            else if (op == &apos;*&apos;)
                stack.push(stack.pop() * num);
            else if (op == &apos;/&apos;)
                stack.push(stack.pop() / num);
            num = 0;
            op = s.charAt(i++);
        }
    }

    if (op == &apos;+&apos;)
        stack.push(num);
    else if (op == &apos;-&apos;)
        stack.push(-num);
    else if (op == &apos;*&apos;)
        stack.push(stack.pop() * num);
    else if (op == &apos;/&apos;)
        stack.push(stack.pop() / num);

    int res = 0;
    for (Long n: stack)
        res += n;

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Repeated DNA Sequences(Java)]]></title>
      <url>http://yoursite.com/2016/02/22/Leetcode-Repeated-DNA-Sequences-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>All DNA is composed of a series of nucleotides abbreviated as A, C, G, and T, for example: “ACGAATTCCG”. When studying DNA, it is sometimes useful to identify repeated sequences within the DNA.</p>
<p>Write a function to find all the 10-letter-long sequences (substrings) that occur more than once in a DNA molecule.</p>
<p>For example,</p>
<pre><code>Given s = &quot;AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT&quot;,

Return:
[&quot;AAAAACCCCC&quot;, &quot;CCCCCAAAAA&quot;].
</code></pre><p><strong>Thinking:</strong></p>
<p>Because it limits the length of repeated substrings, so we can travse the list one time from the left to right. Pick substring from the list to check whether this substring emerge beofe.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;String&gt; findRepeatedDnaSequences(String s) {
    HashSet&lt;String&gt; set = new HashSet&lt;String&gt;();
    List&lt;String&gt; res = new ArrayList&lt;String&gt;();

    for (int i = 0; i+10 &lt;= s.length(); i ++) {
        String temp = s.substring(i, i+10);
        if (!set.contains(temp)) {
            set.add(temp);
        }
        else {
            if (!res.contains(temp))
                res.add(temp);
        }
    }

    return res;
}
</code></pre><p>More efficient way:(which use the bits to represent map fucntion, reference: <a href="https://leetcode.com/discuss/25399/clean-java-solution-hashmap-bits-manipulation" target="_blank" rel="external">https://leetcode.com/discuss/25399/clean-java-solution-hashmap-bits-manipulation</a>)</p>
<pre><code>public List&lt;String&gt; findRepeatedDnaSequences(String s) {
    HashMap&lt;Character, Integer&gt; map = new HashMap&lt;Character, Integer&gt;();
    HashSet&lt;Integer&gt; set = new HashSet&lt;Integer&gt;();
    HashSet&lt;Integer&gt; second = new HashSet&lt;Integer&gt;();
    List&lt;String&gt; res = new ArrayList&lt;String&gt;();

    if (s.length() &lt; 10)    return res;

    map.put(&apos;A&apos;, 0);
    map.put(&apos;C&apos;, 1);
    map.put(&apos;G&apos;, 2);
    map.put(&apos;T&apos;, 3);

    int v = 0;

    for (int i = 0; i &lt; s.length(); i++) {
        v &lt;&lt;= 2;
        v |= map.get(s.charAt(i));
        v &amp;= 0xfffff;
        if (i &lt; 9)    continue;
        if (!set.add(v) &amp;&amp; second.add(v)) {
            res.add(s.substring(i-9, i+1));
        }
    }

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Count Complete Tree Nodes(Java)]]></title>
      <url>http://yoursite.com/2016/02/22/Leetcode-Count-Complete-Tree-Nodes-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a complete binary tree, count the number of nodes.</p>
<p>Definition of a complete binary tree from Wikipedia:<br>In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.</p>
<p><strong>Thinking:</strong></p>
<p>Firstly, I want to traverse the tree, but we can do better. Because we know its structure is special. For example, if this root’s height is this root’s right child’s height minus 1, its left subtree must be a full tree. So we need to caclulate the rest nodes which remain in its right subtree. Otherwise, we need to go to left.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int countNodes(TreeNode root) {
    int h = height(root);
    if (h == 0)
        return 0;
    if (h == height(root.right)+1){
        return (1 &lt;&lt; (h-1)) + countNodes(root.right);
    } else {
        return (1 &lt;&lt; (h-2)) + countNodes(root.left);
    }
}

private int height(TreeNode root) {
    return root == null? 0 : 1 + height(root.left);
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Sort List(Java)]]></title>
      <url>http://yoursite.com/2016/02/22/Leetcode-Sort-List-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Sort a linked list in O(n log n) time using constant space complexity.</p>
<p><strong>Thinking:</strong></p>
<p>There are three basic algorithm to sort in n*logn time. They are merge sort, heap sort and quick sort. And I implement the sort method in merge sort. In order to do this, I have to implement the function such as getLength, get the mid node, merge and so on.</p>
<p>Basic idea of merge sort is to divide a list into two lists, and make them sorted then merge them together.</p>
<p><strong>Solution:</strong></p>
<pre><code>//merge
public ListNode sortList(ListNode head) {
    int len = getLength(head);
    if (len == 0)    return null;
    ListNode nhead = mergeSort(head, len);
    addTail(nhead, len);
    return nhead;
}

private ListNode mergeSort(ListNode head, int n) {
    if (n &lt;= 1)
        return head;
    ListNode mid = getNode(head, n/2);
    ListNode nhead = mergeSort(head, n/2);
    ListNode nmid = mergeSort(mid, n - n/2);
    return merge(nhead, nmid, n);
}

private int getLength(ListNode head) {
    int l = 0;

    while (head != null) {
        head = head.next;
        l++;
    }

    return l;
}

private ListNode getNode(ListNode head, int index) {
    while (index &gt; 0) {
        head = head.next;
        index--;
    }

    return head;
}

private ListNode merge(ListNode p1, ListNode p2, int len) {
    ListNode dummy = new ListNode(0);
    ListNode p = dummy;
    int l1 = 0;
    int l2 = 0;
    while (l1 &lt; len/2 &amp;&amp; l2 &lt; len - len/2) {
        if (p1.val &lt; p2.val) {
            p.next = p1;
            p1 = p1.next;
            p = p.next;
            l1++;
        } else {
            p.next = p2;
            p2 = p2.next;
            p = p.next;
            l2++;
        }
    }
    if (l1 == len/2) {
        p.next = p2;
    } else {
        p.next = p1;
    }
    return dummy.next;
}

private void addTail(ListNode head, int n) {
    while (n &gt; 1) {
        head = head.next;
        n--;
    }
    head.next = null;
}
</code></pre><p>More efficient method:<br>Reference:<a href="https://leetcode.com/discuss/1709/have-pretty-mergesort-method-anyone-speed-reduce-memory-usage" target="_blank" rel="external">https://leetcode.com/discuss/1709/have-pretty-mergesort-method-anyone-speed-reduce-memory-usage</a></p>
<p>It use the fast pointer and slow pointer to find the middle index of the linked list. Add a null to the first half to implement the merge operation.</p>
<pre><code>public ListNode sortList(ListNode head) {
    if (head == null || head.next == null)
        return head;
    ListNode f = head.next.next;
    ListNode p = head;
    while (f != null &amp;&amp; f.next != null) {
        p = p.next;
        f =  f.next.next;
    }
    ListNode h2 = sortList(p.next);
    p.next = null;
    return merge(sortList(head), h2);
}
public ListNode merge(ListNode h1, ListNode h2) {
    ListNode hn = new ListNode(Integer.MIN_VALUE);
    ListNode c = hn;
    while (h1 != null &amp;&amp; h2 != null) {
        if (h1.val &lt; h2.val) {
            c.next = h1;
            h1 = h1.next;
        }
        else {
            c.next = h2;
            h2 = h2.next;
        }
        c = c.next;
    }
    if (h1 != null)
        c.next = h1;
    if (h2 != null)
        c.next = h2;
    return hn.next;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Permutation Sequence(Java)]]></title>
      <url>http://yoursite.com/2016/02/22/Leetcode-Permutation-Sequence-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>The set [1,2,3,…,n] contains a total of n! unique permutations.</p>
<p>By listing and labeling all of the permutations in order,<br>We get the following sequence (ie, for n = 3):</p>
<p>“123”<br>“132”<br>“213”<br>“231”<br>“312”<br>“321”<br>Given n and k, return the kth permutation sequence.</p>
<p>Note: Given n will be between 1 and 9 inclusive.</p>
<p><strong>Thinking:</strong></p>
<p>We can conclude the position of the element in the searching tree according to the k. For example, there are n subtrees in the first level, so the k/(n-1) means picking the k/(n-1) th element in the array. And delete the element from the element, pick the next one. Do this recursively.</p>
<p><strong>Solution:</strong></p>
<pre><code>public String getPermutation(int n, int k) {
    ArrayList&lt;Integer&gt; nums = new ArrayList&lt;Integer&gt;();
    int fac = 1;
    int[] pos = new int[n+1];
    for (int i = 1; i &lt;= n; i++){
        nums.add(i);
        fac *= i;
    }
    fac /= n;
    k -= 1;
    for (int i = 1; i &lt; n; i++){
        pos[i] = k / fac;
        k %= fac;
        fac /= (n-i);
    }
    StringBuilder res = new StringBuilder();
    for (int i = 1; i &lt;= n; i++){
        res.append(nums.remove(pos[i]));
    }

    return res.toString();
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Longest Substring Without Repeating Characters(Java)]]></title>
      <url>http://yoursite.com/2016/02/21/Leetcode-Longest-Substring-Without-Repeating-Characters-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for “abcabcbb” is “abc”, which the length is 3. For “bbbbb” the longest substring is “b”, with the length of 1.</p>
<p><strong>Thinking:</strong></p>
<p>The basic idea is to maintain a hashmap to keep the exsiting characters. If there is a character appered in the hashmap, then move the index to the last position it emerged. Hold two pointers: one is to record the substring’s start position and the other is to record the substring’s end position. And the pointers can only move forward.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int lengthOfLongestSubstring(String s) {
    HashMap&lt;Character, Integer&gt; alphabeta = new HashMap&lt;Character, Integer&gt;();
    int max = 0;
    int count = 0;
    int idx = 0;

    while (idx+count &lt; s.length()) {

        if (!alphabeta.containsKey(s.charAt(idx + count))) {
            alphabeta.put(s.charAt(idx + count), idx+count);
            count++;
        }
        else {
            idx = alphabeta.get(s.charAt(idx + count)) + 1;
            alphabeta = new HashMap&lt;Character, Integer&gt;();
            count = 0;
        }
        max = Math.max(max, count);
    }

    return max;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Longest Palindromic Substring(Java)]]></title>
      <url>http://yoursite.com/2016/02/21/Leetcode-Longest-Palindromic-Substring-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.</p>
<p><strong>Thinking:</strong></p>
<p>Run from left to right and check each element in different index. The check method is select a index, and expand its range to two sides of it. Record the max value and max substring.</p>
<p><strong>Solution:</strong></p>
<pre><code>int max = 1;
String res = &quot;&quot;;
public String longestPalindrome(String s) {
    if (s.length() &lt; 2)
        return s;
    for (int i = 0; i &lt; s.length() - max/2; i++){

        if (i+1&lt;s.length() &amp;&amp; s.charAt(i) == s.charAt(i+1)){
            check(s, i-1, i+2, 2);
        }

        check(s, i-1, i+1, 1);
    }

    return res;
}

private void check(String s, int i, int j, int len){
    int count = len;
    while (i &gt;= 0 &amp;&amp; j &lt; s.length()){
        if (s.charAt(i) == s.charAt(j))
            count += 2;
        else
            break;
        i--;
        j++;
    }
    if (count &gt; max){
        res = s.substring(i+1, j);
        max = count;
    }

}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Add Two Numbers(Java)]]></title>
      <url>http://yoursite.com/2016/02/21/Leetcode-Add-Two-Numbers-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.</p>
<p>Input: (2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4)<br>Output: 7 -&gt; 0 -&gt; 8</p>
<p><strong>Thinking:</strong></p>
<p>It’s like a problem adding two numbers from the low digits to high digits. We need two variable to record the sum of current digit and whether it will incresce the next digit. Then what we should care about is to traverse the linked list and check whether it’s null pointer.</p>
<p><strong>Solution:</strong></p>
<pre><code>public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    int num1 = 0;
    int num2 = 0;
    int sum = 0;
    int flag = 0;

    if (l1 != null){
        num1 = l1.val;
        l1 = l1.next;
    }
    if (l2 != null){
        num2 = l2.val;
        l2 = l2.next;
    }
    sum = (num1 + num2) % 10;
    flag = (num1 + num2) / 10;
    ListNode head = new ListNode(sum);
    ListNode p = head;

    while (l1 != null || l2 != null){
        num1 = 0;
        num2 = 0;
        if (l1 != null) {
            num1 = l1.val;
            l1 = l1.next;
        }
        if (l2 != null) {
            num2 = l2.val;
            l2 = l2.next;
        }

        sum = (num1 + num2 + flag) % 10;
        flag = (num1 + num2 + flag) / 10;
        p.next = new ListNode(sum);
        p = p.next;
    }

    if (flag == 1)
        p.next = new ListNode(1);

    return head;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Word Break(Java)]]></title>
      <url>http://yoursite.com/2016/02/21/Leetcode-Word-Break-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.</p>
<p>For example, given<br>s = “leetcode”,<br>dict = [“leet”, “code”].</p>
<p>Return true because “leetcode” can be segmented as “leet code”.</p>
<p><strong>Thinking:</strong></p>
<p>This question can be solved in dynamic programming. We can get parts of the string once and check if it’s in the dictionary words and then check the left. And we can store the result of previous substring with index in the array.</p>
<p><strong>Solution:</strong></p>
<pre><code>public boolean wordBreak(String s, Set&lt;String&gt; wordDict) {
    boolean[] valid = new boolean[s.length()+1];

    valid[0] = true;

    for (int i = 1; i &lt;= s.length(); i++) {
        for (int j = i-1; j &gt;= 0; j--){
            if (valid[j] &amp;&amp; wordDict.contains(s.substring(j, i))){
                valid[i] = true;
                break;
            }
        }
    }

    return valid[s.length()];
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/18904/java-implementation-using-dp-in-two-ways" target="_blank" rel="external">https://leetcode.com/discuss/18904/java-implementation-using-dp-in-two-ways</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Clone Graph(Java)]]></title>
      <url>http://yoursite.com/2016/02/21/Leetcode-Clone-Graph-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.</p>
<p>OJ’s undirected graph serialization:<br>Nodes are labeled uniquely.</p>
<p>We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.<br>As an example, consider the serialized graph {0,1,2#1,2#2,2}.</p>
<p>The graph has a total of three nodes, and therefore contains three parts as separated by #.</p>
<p>First node is labeled as 0. Connect node 0 to both nodes 1 and 2.<br>Second node is labeled as 1. Connect node 1 to node 2.<br>Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.<br>Visually, the graph looks like the following:</p>
<pre><code>   1
  / \
 /   \
0 --- 2
     / \
     \_/
</code></pre><p><strong>Thinking:</strong></p>
<p>In order to clone this graph, we need to traverse the graph either using DFS or BFS. In my solution, I use DFS and graph search which will hold a HashMap to record the explored nodes.</p>
<p><strong>Solution:</strong></p>
<pre><code>HashMap&lt;Integer, UndirectedGraphNode&gt; exploredSet = new HashMap&lt;Integer, UndirectedGraphNode&gt;();
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
    return clone(node);
}

private UndirectedGraphNode clone(UndirectedGraphNode node){
    if (node == null) return null;
    UndirectedGraphNode newNode = new UndirectedGraphNode(node.label);

    exploredSet.put(node.label, newNode);

    for (UndirectedGraphNode n: node.neighbors) {
        if (exploredSet.containsKey(n.label)) {
            newNode.neighbors.add(exploredSet.get(n.label));
        } else {
            newNode.neighbors.add(clone(n));
        }
    }

    return newNode;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Additive Number(Java)]]></title>
      <url>http://yoursite.com/2016/02/21/Leetcode-Additive-Number-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Additive number is a string whose digits can form additive sequence.</p>
<p>A valid additive sequence should contain at least three numbers. Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.</p>
<p>For example:<br>“112358” is an additive number because the digits can form an additive sequence: 1, 1, 2, 3, 5, 8.</p>
<p>1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8<br>“199100199” is also an additive number, the additive sequence is: 1, 99, 100, 199.<br>1 + 99 = 100, 99 + 100 = 199<br>Note: Numbers in the additive sequence cannot have leading zeros, so sequence 1, 2, 03 or 1, 02, 3 is invalid.</p>
<p>Given a string containing only digits ‘0’-‘9’, write a function to determine if it’s an additive number.</p>
<p>Follow up:<br>How would you handle overflow for very large input integers?</p>
<p><strong>Thinking:</strong></p>
<p>I noticed that it’s only different in the first time in the iteration becuase we know nothing about the first element. But when found it, we can use the previous two elements to check the next one. So in the first function, we enumerate the first two elements, and check the rest string if it’s valid recursively.</p>
<p><strong>Solution:</strong></p>
<pre><code>public boolean isAdditiveNumber(String num) {

    int len = num.length();

    long num1 = 0;
    long num2 = 0;
    //find the first two elements first
    for (int i = 1; 2*i+1 &lt;= len; i++){
        for (int j = 1; Math.max(i, j) &lt;= len-i-j; j++){
            if (num.charAt(0) == &apos;0&apos; &amp;&amp; i &gt; 1)    return false;//if first char is 0, then it only can be 0
            num1 = Long.parseLong(num.substring(0, i));
            if (num.charAt(i) == &apos;0&apos; &amp;&amp; j &gt; 1)    break;//if second element start with 0, then it only can be 0
            num2 = Long.parseLong(num.substring(i, i+j));
            if (isValid(num1, num2, i+j, num))//check the rest recursively
                return true;
        }
    }

    return false;
}

private boolean isValid(long i, long j, int start, String num){
    if (start == num.length())    return true;//no rest chars left, success
    if (num.charAt(start) == &apos;0&apos;)    return false;
    long sum = 0;
    for (int idx = start+1; idx &lt;= num.length(); idx++){
        sum = Long.parseLong(num.substring(start, idx));
        if (sum - i &gt; j)
            return false;
        if (sum - i == j)
            return isValid(j, sum, idx, num);
    }
    return false;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Coin Change(Java)]]></title>
      <url>http://yoursite.com/2016/02/14/Leetcode-Coin-Change-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>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.</p>
<p>Example 1:<br>coins = [1, 2, 5], amount = 11<br>return 3 (11 = 5 + 5 + 1)</p>
<p>Example 2:<br>coins = [2], amount = 3<br>return -1.</p>
<p>Note:<br>You may assume that you have an infinite number of each kind of coin.</p>
<p><strong>Thinking:</strong></p>
<p>In order to solve this problem, we can use dp which check whether choose current coin to make sure it’s minimum. But using function recursively will waste a lot of time. So we need to use extra space avoiding waste time. Then, we should build up a dp array accroding to the amount of money. Then update the dp value of different amout from zero to the target amout. The DP expression is: dp[i + coins[j]] = Math.min(dp[i + coins[j]], dp[i] + 1)</p>
<p><strong>Solution:</strong></p>
<pre><code>public int coinChange(int[] coins, int amount) {
    int dp[] = new int[amount + 1];
    for (int i = 1; i &lt;= amount; i++) dp[i] = Integer.MAX_VALUE-1;
    for (int i = 0; i &lt;= amount; i++) {
        for (int j = 0; j &lt; coins.length; j++) {
            if (i + coins[j] &lt;= amount)
                dp[i + coins[j]] = Math.min(dp[i + coins[j]], dp[i] + 1);
        }
    }
    return dp[amount] == Integer.MAX_VALUE-1 ? -1 : dp[amount];
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Some basic problems]]></title>
      <url>http://yoursite.com/2016/02/13/Some-basic-problems/</url>
      <content type="html"><![CDATA[<ol>
<li>Hanoi:</li>
</ol>
<p><img src="http://my.csdn.net/uploads/201204/23/1335186818_5426.jpg" alt=""></p>
<pre><code>public  void move(int n,char a,char b,char c){  

    if(n==1){  
        System.out.println(&quot;move from &quot;+a+&quot; to &quot;+c);  
    }else{  
        move(n-1, a,c,b);  
        move(1, a, b, c);  
        move(n-1, b, a, c);  
    }  
}  
</code></pre><ol>
<li>Queue:</li>
</ol>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Some thoughts about interview]]></title>
      <url>http://yoursite.com/2016/02/13/Some-thoughts-about-interview/</url>
      <content type="html"><![CDATA[<p>These days, I have been asked by some questions in interviews. These are not quite difficult questions, but I suppose I didn’t behavior well. There are some reasons I think, and I have to improve it:</p>
<ol>
<li>I am not familiar with the simple and basic question so that I’m not very sure about the solution’s correctness and I have to review it again and again.</li>
<li>My code is not so effienct and some of the interviewers had to remind me that. That’s really terrible but I think they are very nice to let me know that.</li>
<li>My code is not so clean because I didn’t keep a clean mind that time. I suppose it’s kind of nervous that time though I didn’t realize that and I want to solve that problem too hurry. I need to relax my minds next time.</li>
<li>What’s worse, I didn’t have nice communication with interviewers. Because of my bad English and bad preperation for interview. Sorry about that.</li>
</ol>
<p>And below are some questions I have to review:</p>
<ol>
<li>How to realize a queue or stack using array or linkedlist</li>
<li>Binary search and whenever mentioning the sorted array, I think it should come into my mind immediately the binary search</li>
<li>Graph theory about the DFS and BFS</li>
<li>What’s difference between .equals and == in Java</li>
<li>Heap and stack in java</li>
<li>Some detials and desing thoughts of my projects</li>
<li>ood  object oriented design principles (<a href="https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design" target="_blank" rel="external">https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design</a>)</li>
<li>The comparasion between the methods of shortest path (<a href="http://developer.51cto.com/art/201105/262170.htm" target="_blank" rel="external">http://developer.51cto.com/art/201105/262170.htm</a>)</li>
<li>Hanoi (<a href="http://blog.csdn.net/zhutulang/article/details/7491390" target="_blank" rel="external">http://blog.csdn.net/zhutulang/article/details/7491390</a>)</li>
<li>Maze (<a href="http://baobaoyangzhou.blog.163.com/blog/static/11783125020104147195273/" target="_blank" rel="external">http://baobaoyangzhou.blog.163.com/blog/static/11783125020104147195273/</a>)</li>
<li>The realization of DFS not using recursive (<a href="http://blog.csdn.net/lalor/article/details/6845788" target="_blank" rel="external">http://blog.csdn.net/lalor/article/details/6845788</a>) which use stack</li>
</ol>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Majority Element II(Java)]]></title>
      <url>http://yoursite.com/2016/02/10/Leetcode-Majority-Element-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times. The algorithm should run in linear time and in O(1) space.</p>
<p>Hint:</p>
<p>How many majority elements could it possibly have?</p>
<p><strong>Thinking:</strong></p>
<p>This question is similar with Majority Element which can be solved by Boyer–Moore majority vote algorithm.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;Integer&gt; majorityElement(int[] nums) {
    List&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();
    int count1 = 0, count2 = 0, can1 = 0, can2 = 1;

    for (int num: nums){
        if (num == can1)
            count1++;
        else if (num == can2)
            count2++;
        else if (count1 == 0){
            can1 = num;
            count1 = 1;
        }
        else if (count2 == 0){
            can2 = num;
            count2 = 1;
        }
        else{
            count1--;
            count2--;
        }
    }
    count1 = 0;
    count2 = 0;
    for (int num: nums){
        if (num == can1)
            count1++;
        else if (num == can2)
            count2++;
    }

    if (count1 &gt; nums.length / 3)
        res.add(can1);
    if (count2 &gt; nums.length / 3 &amp;&amp; can1 != can2)
        res.add(can2);

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Implement Trie (Prefix Tree)(Java)]]></title>
      <url>http://yoursite.com/2016/02/10/Leetcode-Implement-Trie-Prefix-Tree-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Implement a trie with insert, search, and startsWith methods.</p>
<p>Note:<br>You may assume that all inputs are consist of lowercase letters a-z.</p>
<p><strong>Thinking:</strong></p>
<p>I assume every node has no val, but edges do. So I keep a HashMap for everynode. What’s more, in order to determine whether this node is a leave, I add another boolean value.</p>
<p><strong>Solution:</strong></p>
<pre><code>import java.util.HashMap;

class TrieNode {
    HashMap&lt;Character, TrieNode&gt; edges = new HashMap&lt;Character, TrieNode&gt;();
    boolean leave = false;
    // Initialize your data structure here.
    public TrieNode() {
    }
}

public class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    // Inserts a word into the trie.
    public void insert(String word) {
        TrieNode cur = root;
        for (char c: word.toCharArray()){
            if (!cur.edges.containsKey(c)){
                TrieNode newNode = new TrieNode();
                cur.edges.put(c, newNode);
                cur = newNode;

            }
            else {
                cur = cur.edges.get(c);
            }
        }
        cur.leave = true;
    }

    // Returns if the word is in the trie.
    public boolean search(String word) {
        TrieNode cur = root;
        for (char c: word.toCharArray()){
            if (!cur.edges.containsKey(c)){
                return false;
            }
            else{
                cur = cur.edges.get(c);
            }
        }
        return cur.leave;
    }

    // Returns if there is any word in the trie
    // that starts with the given prefix.
    public boolean startsWith(String prefix) {
        TrieNode cur = root;
        for (char c: prefix.toCharArray()){
            if (!cur.edges.containsKey(c)){
                return false;
            }
            else{
                cur = cur.edges.get(c);
            }
        }
        return true;
    }
}

// Your Trie object will be instantiated and called as such:
// Trie trie = new Trie();
// trie.insert(&quot;somestring&quot;);
// trie.search(&quot;key&quot;);
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Sqrt(x)(Java)]]></title>
      <url>http://yoursite.com/2016/02/10/Leetcode-Sqrt-x-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Implement int sqrt(int x).</p>
<p>Compute and return the square root of x.</p>
<p><strong>Thinking:</strong></p>
<p>We can get the answer using bianry search from the range of integer.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int mySqrt(int x) {
    if ( x &lt;= 1 )
        return x;
    int low = 1;
    int high = Integer.MAX_VALUE;
    while (true){
        int mid = low + (high - low) / 2; //in order to avoid overflow
        if (mid &gt; x / mid){
            high = mid - 1;
        }else{
            if ( (mid+1) &gt; x/(mid+1))
                return mid;
            low = mid + 1;
        }
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Course Schedule(Java)]]></title>
      <url>http://yoursite.com/2016/02/10/Leetcode-Course-Schedule-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>There are a total of n courses you have to take, labeled from 0 to n - 1.</p>
<p>Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]</p>
<p>Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?</p>
<p>For example:</p>
<p>2, [[1,0]]<br>There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.</p>
<p>2, [[1,0],[0,1]]<br>There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.</p>
<p>Note:<br>The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.</p>
<p>click to show more hints.</p>
<p>Hints:<br>This problem is equivalent to finding if a cycle exists in a directed graph. If a cycle exists, no topological ordering exists and therefore it will be impossible to take all courses.<br>Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera explaining the basic concepts of Topological Sort.<br>Topological sort could also be done via BFS.</p>
<p><strong>Thinking:</strong></p>
<p>We can search it from a arbitary node, can search by DFS. If there is a cycle, we will meet the visited nodes once DFS. So we need a array to hold the visited record. By the way, if we want a topological sort, we can hold a current value which is number of nodes initially and decrese one only when meet a sink node.</p>
<p>For BFS, we can find the nodes whose indegree or outdegree is zero, and search from them. If there is a cycle, the number of nodes searched will less than the exact number because in a cycle no nodes’ indegree or outdegree is zero.</p>
<p><strong>Solution:</strong></p>
<p>DFS:</p>
<pre><code>public boolean canFinish(int numCourses, int[][] prerequisites) {
    if (numCourses &lt;= 1)
        return true;
    ArrayList&lt;HashSet&lt;Integer&gt;&gt; edges = new ArrayList&lt;HashSet&lt;Integer&gt;&gt;(numCourses);
    boolean[] visited = new boolean[numCourses];

    for (int i = 0; i &lt; numCourses; i++)
        edges.add(new HashSet&lt;Integer&gt;());

    for (int[] pre: prerequisites){
        edges.get(pre[0]).add(pre[1]);
    }

    for (int i = 0; i &lt; numCourses; i++){
        if (edges.get(i).size() != 0)
            if (!dfs(edges, i, visited))
                return false;
    }

    return true;
}

private boolean dfs(ArrayList&lt;HashSet&lt;Integer&gt;&gt; edges, int i, boolean[] visited){
    if (visited[i] == true)
        return false;
    visited[i] = true;
    while (edges.get(i).size() != 0){
        int j = edges.get(i).iterator().next();

        if (!dfs(edges, j, visited))
            return false;

        edges.get(i).remove(j);
    }
    visited[i] = false; //there is a cycle only when once DFS, so we change it back when onece DFS is finished
    return true;
}
</code></pre><p>BFS:</p>
<pre><code>    public boolean canFinishBFS(int numCourses, int[][] prerequisites) {
    if (numCourses &lt;= 1)
        return true;
    ArrayList&lt;HashSet&lt;Integer&gt;&gt; edges = new ArrayList&lt;HashSet&lt;Integer&gt;&gt;(numCourses);
    int[] inDegree = new int[numCourses];
    Queue&lt;Integer&gt; q = new LinkedList&lt;Integer&gt;();
    int count = 0;

    for (int i = 0; i &lt; numCourses; i++)
        edges.add(new HashSet&lt;Integer&gt;());

    for (int[] pre: prerequisites){
        if (!edges.get(pre[0]).contains(pre[1])){
            edges.get(pre[0]).add(pre[1]);
            inDegree[pre[1]]++;
        }
    }

    for (int i = 0; i &lt; inDegree.length; i++)
        if (inDegree[i] == 0)
            q.add(i);

    while (!q.isEmpty()){
        int i = q.poll();
        count++;
        while (edges.get(i).size() != 0){
            int j = edges.get(i).iterator().next();
            if (--inDegree[j] == 0)
                q.add(j);
            edges.get(i).remove(j);
        }
    }

    return count == numCourses;
}
</code></pre><p>Simpler and more concise BFS solution:</p>
<p>Reference: <a href="https://leetcode.com/discuss/35578/easy-bfs-topological-sort-java" target="_blank" rel="external">https://leetcode.com/discuss/35578/easy-bfs-topological-sort-java</a></p>
<pre><code>public boolean canFinish(int numCourses, int[][] prerequisites) {
    int[][] matrix = new int[numCourses][numCourses]; // i -&gt; j
    int[] indegree = new int[numCourses];

    for (int i=0; i&lt;prerequisites.length; i++) {
        int ready = prerequisites[i][0];
        int pre = prerequisites[i][1];
        if (matrix[pre][ready] == 0)
            indegree[ready]++; //duplicate case
        matrix[pre][ready] = 1;
    }

    int count = 0;
    Queue&lt;Integer&gt; queue = new LinkedList();
    for (int i=0; i&lt;indegree.length; i++) {
        if (indegree[i] == 0) queue.offer(i);
    }
    while (!queue.isEmpty()) {
        int course = queue.poll();
        count++;
        for (int i=0; i&lt;numCourses; i++) {
            if (matrix[course][i] != 0) {
                if (--indegree[i] == 0)
                    queue.offer(i);
            }
        }
    }
    return count == numCourses;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Minimum Height Trees(Java)]]></title>
      <url>http://yoursite.com/2016/02/09/Leetcode-Minimum-Height-Trees-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>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.</p>
<p>Format<br>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).</p>
<p>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.</p>
<p>Example 1:</p>
<p>Given n = 4, edges = [[1, 0], [1, 2], [1, 3]]</p>
<pre><code>  0
  |
  1
 / \
2   3
</code></pre><p>return [1]</p>
<p>Example 2:</p>
<p>Given n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]</p>
<pre><code>0  1  2
 \ | /
   3
   |
   4
   |
   5
</code></pre><p>return [3, 4]</p>
<p>Hint:</p>
<p>How many MHTs can a graph have at most?<br>Note:</p>
<p>(1) According to the definition of tree on Wikipedia: “a tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.”</p>
<p>(2) The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.</p>
<p><strong>Thinking:</strong></p>
<p>We should track the path from every leaves until there are only one or two nodes left. In other words, in the middle of the graph will be the root of the minimum height tree.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;Integer&gt; findMinHeightTrees(int n, int[][] edges) {
    if (n == 1){
        List&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();
        res.add(0);
        return res;
    }
    List&lt;Integer&gt; leaves = new ArrayList&lt;Integer&gt;();
    List&lt;Set&lt;Integer&gt;&gt; adj = new ArrayList&lt;Set&lt;Integer&gt;&gt;(n);
    for (int i = 0; i &lt; n; i++)
        adj.add(new HashSet&lt;Integer&gt;());
    for (int[] edge: edges){
        adj.get(edge[0]).add(edge[1]);
        adj.get(edge[1]).add(edge[0]);
    }
    for (int i = 0; i &lt; n; i++){
        if (adj.get(i).size() == 1)
            leaves.add(i);
    }

    while (n &gt; 2){
        n -= leaves.size();
        List&lt;Integer&gt; newLeaves = new ArrayList&lt;Integer&gt;();
        for (int i: leaves){
            int j = adj.get(i).iterator().next();
            adj.get(j).remove(i);
            if (adj.get(j).size() == 1)
                newLeaves.add(j);
        }
        leaves = newLeaves;
    }

    return leaves;
}
</code></pre><p>Reference:<a href="https://leetcode.com/discuss/71763/share-some-thoughts" target="_blank" rel="external">https://leetcode.com/discuss/71763/share-some-thoughts</a></p>
<p>My previous code(LTE):</p>
<pre><code>public List&lt;Integer&gt; findMinHeightTrees(int n, int[][] edges) {
    List&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();
    int min = Integer.MAX_VALUE;
    int res1 = -1;
    int res2 = -1;

    for (int i = 0; i &lt; n; i++){
        int temp = bfs(n, i, edges);
        if (temp &lt; min){
            min = temp;
            res1 = i;
        }
        else if (temp == min){
            res2 = i;
        }
    }

    if (res1 != -1)
        res.add(res1);
    if (res2 != -1)
        res.add(res2);

    return res;
}

private int bfs(int n, int i, int[][] edges){
    int height = 0;
    boolean[] used = new boolean[edges.length];
    Queue&lt;Integer&gt; q = new LinkedList&lt;Integer&gt;();
    q.add(i);

    while (!q.isEmpty()){
        int num = q.size();
        while (num &gt; 0){
            int temp = q.poll();
            for (int j = 0; j &lt; edges.length; j++){
                if (edges[j][0] == temp || edges[j][1] == temp){
                    if (used[j] == false){
                        if (edges[j][0] == temp)
                            q.add(edges[j][1]);
                        else
                            q.add(edges[j][0]);
                        used[j] = true;
                    }
                }
            }
            num--;
        }
        height++;
    }

    return height;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Next Permutation(Java)]]></title>
      <url>http://yoursite.com/2016/02/09/Leetcode-Next-Permutation-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.</p>
<p>If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).</p>
<p>The replacement must be in-place, do not allocate extra memory.</p>
<p>Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.</p>
<pre><code>1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1
</code></pre><p><strong>Thinking:</strong></p>
<p>The method can be described as below:</p>
<p><img src="http://4.bp.blogspot.com/-4zN0u5JG0vs/UN0xPEkP5yI/AAAAAAAAG9Q/O48ZfwB1i_c/s640/Picture4.png" alt=""></p>
<p><strong>Solution:</strong></p>
<pre><code>public void nextPermutation(int[] nums) {
    if (nums == null || nums.length == 0)
        return;
    int i = nums.length - 2;
    while (i &gt;= 0 &amp;&amp; nums[i] &gt;= nums[i+1]){
        i--;
    }

    if (i == -1){
        reverse(nums, 0, nums.length-1);
        return;
    }

    int j = i+1;
    while (j &lt; nums.length &amp;&amp; nums[j] &gt; nums[i]){
        j++;
    }
    j--;
    swap(nums, i, j);
    reverse(nums, i+1, nums.length-1);

    return;
}
private void swap(int[] nums, int i, int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}
private void reverse(int[] nums, int i, int j){
    while (i &lt; j){
        swap(nums, i++, j--);
    }
}
</code></pre><p>Reference:<a href="http://fisherlei.blogspot.com/2012/12/leetcode-next-permutation.html" target="_blank" rel="external">http://fisherlei.blogspot.com/2012/12/leetcode-next-permutation.html</a><br><a href="http://www.cnblogs.com/springfor/p/3896245.html" target="_blank" rel="external">http://www.cnblogs.com/springfor/p/3896245.html</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Minimum Size Subarray Sum(Java)]]></title>
      <url>http://yoursite.com/2016/02/09/Leetcode-Minimum-Size-Subarray-Sum-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an array of n positive integers and a positive integer s, find the minimal length of a subarray of which the sum ≥ s. If there isn’t one, return 0 instead.</p>
<p>For example, given the array [2,3,1,2,4,3] and s = 7,<br>the subarray [4,3] has the minimal length under the problem constraint.</p>
<p>click to show more practice.</p>
<p>More practice:<br>If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n).</p>
<p><strong>Thinking:</strong></p>
<p>My method is to hold two pointers, one for current index and the other is for the start pointer. Once we find the sum is bigger than target, we increse the startIndex until its sum is smaller than target. Do it while find the minmun of the length.</p>
<p>But there is still more effienct way to solve this problem. We don’t need to reset the startIndex and sum, we just keep it. And it will be the O(n) solution. (Which called a minmum window method I suppose.)</p>
<p>What’s more, binary search is also valid for this problem. Since all elements are positive, the cumulative sum must be strictly increasing. Then, a subarray sum can expressed as the difference between two cumulative sum. Hence, given a start index for the cumulative sum array, the other end index can be searched using binary search.</p>
<p><strong>Solution:</strong></p>
<p>First version:</p>
<pre><code>public int minSubArrayLen(int s, int[] nums) {
    int min = Integer.MAX_VALUE;
    boolean flag = false;
    int temp = 0;
    int startIndex = 0;

    for ( int i = 0; i &lt; nums.length; i++ ){
         temp += nums[i];
         if (temp &gt;= s){
             while (temp &gt;= s){
                 flag = true;
                 temp -= nums[startIndex++];
             }
             int len = i - startIndex + 2;
             i = startIndex-1;
             if (len &lt; min)
                 min = len;
             temp = 0;
         }

    }
    if (flag)
        return min;
    else
        return 0;
}
</code></pre><p>Revised version:</p>
<pre><code>public int minSubArrayLen(int s, int[] nums) {
    int min = Integer.MAX_VALUE;
    boolean flag = false;
    int temp = 0;
    int startIndex = 0;

    for ( int i = 0; i &lt; nums.length; i++ ){
         temp += nums[i];
         if (temp &gt;= s){
             while (temp &gt;= s){
                 flag = true;
                 temp -= nums[startIndex++];
             }
             int len = i - startIndex + 2;
             if (len &lt; min)
                 min = len;
         }

    }
    if (flag)
        return min;
    else
        return 0;
}
</code></pre><p>Reference Code:(Including O(n) and O(nlgn))<br>Reference:<a href="https://leetcode.com/discuss/35378/solutions-java-with-time-complexity-nlogn-with-explanation" target="_blank" rel="external">https://leetcode.com/discuss/35378/solutions-java-with-time-complexity-nlogn-with-explanation</a></p>
<pre><code>public int minSubArrayLen(int s, int[] nums) {
    return solveNLogN(s, nums);
}

private int solveN(int s, int[] nums) {
    int start = 0, end = 0, sum = 0, minLen = Integer.MAX_VALUE;
    while (end &lt; nums.length) {
        while (end &lt; nums.length &amp;&amp; sum &lt; s) sum += nums[end++];
        if (sum &lt; s) break;
        while (start &lt; end &amp;&amp; sum &gt;= s) sum -= nums[start++];
        if (end - start + 1 &lt; minLen) minLen = end - start + 1;
    }
    return minLen == Integer.MAX_VALUE ? 0 : minLen;
}

private int solveNLogN(int s, int[] nums) {
    int[] sums = new int[nums.length + 1];
    for (int i = 1; i &lt; sums.length; i++) sums[i] = sums[i - 1] + nums[i - 1];
    int minLen = Integer.MAX_VALUE;
    for (int i = 0; i &lt; sums.length; i++) {
        int end = binarySearch(i + 1, sums.length - 1, sums[i] + s, sums);
        if (end == sums.length) break;
        if (end - i &lt; minLen) minLen = end - i;
    }
    return minLen == Integer.MAX_VALUE ? 0 : minLen;
}

private int binarySearch(int lo, int hi, int key, int[] sums) {
    while (lo &lt;= hi) {
       int mid = (lo + hi) / 2;
       if (sums[mid] &gt;= key){
           hi = mid - 1;
       } else {
           lo = mid + 1;
       }
    }
    return lo;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Ugly Number II(Java)]]></title>
      <url>http://yoursite.com/2016/02/09/Leetcode-Ugly-Number-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Write a program to find the n-th ugly number.</p>
<p>Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 is the sequence of the first 10 ugly numbers.</p>
<p>Note that 1 is typically treated as an ugly number.</p>
<p>Hint:</p>
<p>The naive approach is to call isUgly for every number until you reach the nth one. Most numbers are not ugly. Try to focus your effort on generating only the ugly ones.<br>An ugly number must be multiplied by either 2, 3, or 5 from a smaller ugly number.<br>The key is how to maintain the order of the ugly numbers. Try a similar approach of merging from three sorted lists: L1, L2, and L3.<br>Assume you have Uk, the kth ugly number. Then Uk+1 must be Min(L1 <em> 2, L2 </em> 3, L3 * 5).</p>
<p><strong>Thinking:</strong></p>
<p>The main idea of this question is to maintain a min heap and get the minimum from the heap once. Because we can see that, the ugly numbers are as below:</p>
<pre><code>(1) 1×2, 2×2, 3×2, 4×2, 5×2, …
(2) 1×3, 2×3, 3×3, 4×3, 5×3, …
(3) 1×5, 2×5, 3×5, 4×5, 5×5, …
</code></pre><p>Furthermore, we can record different factor’s index in the primes in order to make the algorithm more effienct.</p>
<p><strong>Solution:</strong></p>
<p>(LTE)</p>
<pre><code>public int nthUglyNumber1(int n){
    List&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();
    PriorityQueue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();
    heap.add(1);
    int[] primes = {2, 3, 5};
    while (res.size() != n) {
        int num = heap.poll();
        if (res.size() == 0 || num != res.get(res.size()-1))
            res.add(num);
        for ( int j = 0; j &lt; 3; j++){
            heap.add(num * primes[j]);
        }
    }

    return res.get(n-1);
}
</code></pre><p>(AC)</p>
<pre><code>public int nthUglyNumber2(int n) {
    List&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();
    res.add(1);
    int[] index = new int[3];
    int[] list = new int[3];
    int[] primes = {2, 3, 5};
    list[0] = 1;
    list[1] = 1;
    list[2] = 1;

    for (int i = 1; i &lt; n; i++){
        for (int j = 0; j &lt; 3; j++){
            list[j] = res.get(index[j]) * primes[j];
        }
        res.add(Math.min(Math.min(list[0], list[1]), list[2]));
        for (int j = 0; j &lt; 3; j++){
            if (list[j] == res.get(res.size()-1))
                index[j]++;
        }
    }

    return res.get(n-1);
}
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/52716/o-n-java-solution" target="_blank" rel="external">https://leetcode.com/discuss/52716/o-n-java-solution</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Serialize and Deserialize Binary Tree(Java)]]></title>
      <url>http://yoursite.com/2016/02/09/Leetcode-Serialize-and-Deserialize-Binary-Tree-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.</p>
<p>Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.</p>
<p>For example, you may serialize the following tree</p>
<pre><code>  1
 / \
2   3
   / \
  4   5
</code></pre><p>as “[1,2,3,null,null,4,5]”, just the same as how LeetCode OJ serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.<br>Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.</p>
<p><strong>Thinking:</strong></p>
<p>There are serveral thinkings emerged in my mind when I first saw this question. Firstly, I want to finishi the normal method which is the same as the Leetcode presenting. But it is LTE. Then I searched on the Internet and found my solution’s lack and then solved it.</p>
<p><strong>Solution:</strong></p>
<p>Previous Code:</p>
<pre><code>//normal method
// Encodes a tree to a single string.
public String serialize(TreeNode root) {
    String res = &quot;&quot;;
    if (root == null)
        return res;
    Queue&lt;TreeNode&gt; q = new LinkedList&lt;TreeNode&gt;();
    q.add(root);
    res += root.val + &quot;,&quot;;
    while (!q.isEmpty()){
        int num = q.size();
        String nullstr = &quot;&quot;;
        while (num &gt; 0){
            TreeNode n = q.poll();
            if (n.left != null){
                q.add(n.left);
                res += nullstr + n.left.val + &quot;,&quot;;
            }
            else{
                nullstr += &quot;null,&quot;;
            }
            if (n.right != null){
                q.add(n.right);
                res += nullstr + n.right.val + &quot;,&quot;;
            }
            else{
                nullstr += &quot;null,&quot;;
            }
            num--;
        }
    }

    return res;
}

// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {
    TreeNode root;
    if(data.length() == 0)
        return null;
    String[] strs = data.split(&quot;,&quot;);
    root = new TreeNode(Integer.parseInt(strs[0]));
    bfs(root, strs, 1, true);
    bfs(root, strs, 2, false);

    return root;
}
private void bfs(TreeNode node, String[] strs, int index, boolean left){
    if (index &gt;= strs.length)
        return;
    if (strs[index].equals(&quot;null&quot;))
        return;
    TreeNode newNode = new TreeNode(Integer.parseInt(strs[index]));
    if (left){
        node.left = newNode;
    }
    else{
        node.right = newNode;
    }
    bfs(newNode, strs, index*2+1, true);
    bfs(newNode, strs, index*2+2, false);
}
</code></pre><p>Reference Code(<a href="http://blog.csdn.net/ljiabin/article/details/49474445" target="_blank" rel="external">http://blog.csdn.net/ljiabin/article/details/49474445</a>):</p>
<pre><code>public String serialize(TreeNode root) {
    StringBuilder sb = new StringBuilder();

    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;TreeNode&gt;();
    queue.offer(root);

    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        if (node == null) {
            sb.append(&quot;null,&quot;);
        } else {
            sb.append(String.valueOf(node.val) + &quot;,&quot;);
            queue.offer(node.left);
            queue.offer(node.right);
        }
    }

    return sb.toString();
}

// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {
    if (data.isEmpty()) return null;

    String[] vals = data.split(&quot;,&quot;);
    int[] nums = new int[vals.length];
    TreeNode[] nodes = new TreeNode[vals.length];

    for (int i = 0; i &lt; vals.length; i++) {
        if (i &gt; 0) {
            nums[i] = nums[i - 1];
        }
        if (vals[i].equals(&quot;null&quot;)) {
            nodes[i] = null;
            nums[i]++;
        } else {
            nodes[i] = new TreeNode(Integer.parseInt(vals[i]));
        }
    }

    for (int i = 0; i &lt; vals.length; i++) {
        if (nodes[i] == null) {
            continue;
        }
        nodes[i].left = nodes[2 * (i - nums[i]) + 1];
        nodes[i].right = nodes[2 * (i - nums[i]) + 2];
    }

    return nodes[0];
}
</code></pre><p>}</p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Remove Duplicates from Sorted List II(Java)]]></title>
      <url>http://yoursite.com/2016/02/08/Leetcode-Remove-Duplicates-from-Sorted-List-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.</p>
<p>For example,<br>Given 1-&gt;2-&gt;3-&gt;3-&gt;4-&gt;4-&gt;5, return 1-&gt;2-&gt;5.<br>Given 1-&gt;1-&gt;1-&gt;2-&gt;3, return 2-&gt;3.</p>
<p><strong>Thinking:</strong></p>
<p>It’s similar with other linked list question. We should build a dummy node before the head. Hold three pointers to operate the next pointer of these nodes.</p>
<p><strong>Solution:</strong></p>
<pre><code>public ListNode deleteDuplicates(ListNode head) {
    if (head == null)
        return head;
    ListNode dummy = new ListNode(head.val-1);
    dummy.next = head;
    ListNode pre = dummy;
    ListNode p = head;
    ListNode next = head.next;
    while (next != null){
        if (p.val == next.val){
            while (next != null &amp;&amp; p.val == next.val){
                next = next.next;
            }
            pre.next = next;
            if (next == null){
                break;
            } else{
                p = next;
                next = next.next;
            }
        } else{
            pre = p;
            p = p.next;
            next = next.next;
        }
    }

    return dummy.next;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Group Anagrams(Java)]]></title>
      <url>http://yoursite.com/2016/02/08/Leetcode-Group-Anagrams-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an array of strings, group anagrams together.</p>
<p>For example, given: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”],<br>Return:</p>
<pre><code>[
  [&quot;ate&quot;, &quot;eat&quot;,&quot;tea&quot;],
  [&quot;nat&quot;,&quot;tan&quot;],
  [&quot;bat&quot;]
]
</code></pre><p>Note:<br>For the return value, each inner list’s elements must follow the lexicographic order.<br>All inputs will be in lower-case.</p>
<p><strong>Thinking:</strong></p>
<p>This question took me a lot of time. First, I want to get a String from the list, and check its anagrams with the rest of the list. And write the algorithm about the anagrams check. But time exceed. Then I try to change my thinking mode of this problem. We should consider the whole String as a element, and if two strings are anagrams, their new string with sorting are the same. So if we use a hashmap to store its previous string and sorted string, the problem will be easy to solve. So we build a hashmap, its key is the string element from the list, and its value is a new list which contains its key’s anagrams. Finally, we get the results from the hashmap and sort them by Collections.sort method.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;List&lt;String&gt;&gt; groupAnagrams(String[] strs) {
    int count = strs.length;
    List&lt;List&lt;String&gt;&gt; res = new ArrayList&lt;List&lt;String&gt;&gt;();
    if (count == 0)
        return res;
    HashMap&lt;String, List&lt;String&gt;&gt; hash = new HashMap&lt;String, List&lt;String&gt;&gt;();

    for (String str: strs){
        char[] ca = str.toCharArray();
        Arrays.sort(ca);
        String temp = new String(ca);
        if (hash.containsKey(temp)){
            hash.get(temp).add(str);
        }else{
            List&lt;String&gt; tempres = new ArrayList&lt;String&gt;();
            tempres.add(str);
            hash.put(temp, tempres);
        }
    }

    for (List&lt;String&gt; l: hash.values()){
        Collections.sort(l);
        res.add(l);
    }

    return res;
}
</code></pre><p>Reference:<a href="https://en.wikipedia.org/wiki/Anagram" target="_blank" rel="external">https://en.wikipedia.org/wiki/Anagram</a><br><a href="http://javaconceptoftheday.com/anagram-program-in-java/" target="_blank" rel="external">http://javaconceptoftheday.com/anagram-program-in-java/</a><br><a href="http://www.cnblogs.com/springfor/p/3874667.html" target="_blank" rel="external">http://www.cnblogs.com/springfor/p/3874667.html</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Number of Islands(Java)]]></title>
      <url>http://yoursite.com/2016/02/05/Leetcode-Number-of-Islands-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a 2d grid map of ‘1’s (land) and ‘0’s (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.</p>
<p>Example 1:</p>
<pre><code>11110
11010
11000
00000
</code></pre><p>Answer: 1</p>
<p>Example 2:</p>
<pre><code>11000
11000
00100
00011
</code></pre><p>Answer: 3</p>
<p><strong>Thinking:</strong></p>
<p>If we find a island that we didn’t find before, we will use DFS or BFS find the whole land and change its value which will avoid find it again next time.</p>
<p><strong>Solution:</strong></p>
<pre><code>private int m, n;

public int numIslands(char[][] grid) {
    m = grid.length;
    if (m == 0) return 0;
    n = grid[0].length;
    if (n == 0) return 0;

    int ans = 0;
    for (int i = 0; i &lt; m; i++) {
        for (int j = 0; j &lt; n; j++) {
            if (grid[i][j] != &apos;1&apos;) continue;

            ans++;
            dfs(grid, i, j);
        }
    }
    return ans;
}


public void dfs(char[][] grid, int i, int j) {
    if (i &lt; 0 || i &gt;= m || j &lt; 0 || j &gt;= n) return;

    if (grid[i][j] == &apos;1&apos;) {
        grid[i][j] = &apos;2&apos;;
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }
}
</code></pre><p>Reference: <a href="http://blog.csdn.net/ljiabin/article/details/44975717" target="_blank" rel="external">http://blog.csdn.net/ljiabin/article/details/44975717</a></p>
<p><strong>My Stupid Solution::</strong></p>
<pre><code>int res = 0;
public int numIslands(char[][] grid) {
    int rl = grid.length;
    if (rl == 0)
        return 0;
    int cl = grid[0].length;
    int[][] record = new int[rl][cl];
    int[][] visited = new int[rl][cl];


    for (int i = 0; i &lt; rl; i++) {
        for (int j = 0; j &lt; cl; j++) {
            dfsCheck(i, j, grid, record, visited);
        }
    }
    return res;
}

private void dfsCheck(int m, int n, char[][] grid, int[][] record, int[][] visited){
    if (visited[m][n] == 1)
        return;
    visited[m][n] = 1;
    int flag = 0;
    if (grid[m][n] == &apos;1&apos;){
        if (record[m][n] == 0){
            for (int i = -1; i &lt; 2; i++){
                for (int j = -1; j &lt; 2; j++){
                    if (m+i&gt;=0 &amp;&amp; m+i &lt;grid.length &amp;&amp; n+j&gt;=0 &amp;&amp; n+j&lt;grid[0].length &amp;&amp; (i+j == -1 || i+j == 1)){
                        if (record[m+i][n+j] != 0){
                            record[m][n] = record[m+i][n+j];
                            flag = 1;
                        }
                    }
                }
            }
            if (flag == 0)
                record[m][n] = ++res;
        }

        //extension
        for (int i = -1; i &lt; 2; i++){
            for (int j = -1; j &lt; 2; j++){
                if (m+i&gt;=0 &amp;&amp; m+i &lt;grid.length &amp;&amp; n+j&gt;=0 &amp;&amp; n+j&lt;grid[0].length &amp;&amp; (i+j == -1 || i+j == 1)){
                    if (grid[m+i][n+j] == &apos;1&apos; &amp;&amp; visited[m+i][n+j] == 0)
                        dfsCheck(m+i, n+j, grid, record, visited);
                }
            }
        }
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Gas Station(Java)]]></title>
      <url>http://yoursite.com/2016/02/05/Leetcode-Gas-Station-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>There are N gas stations along a circular route, where the amount of gas at station i is gas[i].</p>
<p>You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.</p>
<p>Return the starting gas station’s index if you can travel around the circuit once, otherwise return -1.</p>
<p>Note:<br>The solution is guaranteed to be unique.</p>
<p><strong>Thinking:</strong></p>
<p>Nomally, it can be sovled in n^2 time complexity, check every station whether it is possible. But it will be LTE, so we need a greedy method to sovle this problem. In fact, if previous result of total gas is larger than 0, and current gas station don’t meet the needs, it means all of the previous gas station is not valid. What’s more, it assumes there is only one solution, so what we need to do is to record the fisrt valid station index. In order to check whether it is valid, we also need another variable total to determine whether the set is valid.</p>
<p><strong>Solution1:</strong>(LTM)</p>
<pre><code>public int canCompleteCircuit1(int[] gas, int[] cost) {
    int len = gas.length;

    for (int i = 0; i &lt; len; i++){
        int curGas = 0;
        for (int j = i; ; j++){
            curGas += gas[j%len];
            curGas -= cost[j%len];
            if (curGas &lt; 0)
                break;
            if (j - len == i - 1){
                return i;
            }
        }
    }

    return -1;
}
</code></pre><p><strong>Solution2:</strong>(Greedy)</p>
<pre><code>public int canCompleteCircuit(int[] gas, int[] cost) {
    int len = gas.length;
    int curSum = 0;
    int total = 0;
    int index = 0;

    for (int i = 0; i &lt; len; i++){
        curSum += gas[i] - cost[i];
        total += gas[i] - cost[i];
        if (curSum &lt; 0){
            curSum = 0;
            index = i + 1;
        }
    }
    if (total &lt; 0)
        return -1;
    else
        return index;

}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Git Note]]></title>
      <url>http://yoursite.com/2016/02/02/Git-Note/</url>
      <content type="html"><![CDATA[<ol>
<li>git branch [-a] look at the branches you’ve visited</li>
<li>git branch <branch_name> create a new branch from the current commit version</branch_name></li>
<li>git checkout -b <branch_name></branch_name></li>
<li>git -d branch_name</li>
<li>git merge</li>
<li>git stash</li>
<li>git push -f</li>
<li>git checkout <commit_id></commit_id></li>
<li>git checkout -b new_master</li>
<li>git branch -d master</li>
</ol>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Restore IP Addresses(Java)]]></title>
      <url>http://yoursite.com/2016/02/02/Leetcode-Restore-IP-Addresses-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a string containing only digits, restore it by returning all possible valid IP address combinations.</p>
<p>For example:<br>Given “25525511135”,</p>
<p>return [“255.255.11.135”, “255.255.111.35”]. (Order does not matter)</p>
<p><strong>Thinking:</strong></p>
<p>Valid IP address is between 0 and 255, so we can once detect one to three digits of the string. What’s more, it’s not valid if there is number like “001”. Use bactracing select one to three digits once, and go farther until all the substrings are selected and there are four parts of the result. Then put the result in the list. We should also detect the length of the String because if the length is not between 4 and 12, it’s invalid.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;String&gt; restoreIpAddresses(String s) {
    List&lt;String&gt; res = new ArrayList&lt;String&gt;();

    if (s.length() &lt; 4)
        return res;
    if (s.length() &gt; 12)
        return res;

    backtracing(s, 0, new ArrayList&lt;String&gt;(), res);

    return res;
}

public void backtracing(String s, int start, List&lt;String&gt; tempres, List&lt;String&gt; res){
    if (start == s.length()){
        if (tempres.size() == 4){
            String tempstr = &quot;&quot;;
            tempstr = tempres.get(0) + &quot;.&quot; + tempres.get(1) + &quot;.&quot; + tempres.get(2) + &quot;.&quot; + tempres.get(3);
            res.add(tempstr);
        }
        else{
            return;
        }
    }

    for (int i = start+1; i &lt;= s.length(); i++){
        if (s.charAt(start) == &apos;0&apos; &amp;&amp; i != start+1)
            continue;
        if (i - start &gt; 3)
            break;
        int num = Integer.parseInt(s.substring(start, i));
        if (num &gt; 255)
            break;
        else{
            tempres.add(s.substring(start, i));
            backtracing(s, i, tempres, res);
            tempres.remove(tempres.size() - 1);
        }
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Combination Sum II(Java)]]></title>
      <url>http://yoursite.com/2016/02/02/Leetcode-Combination-Sum-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.</p>
<p>Each number in C may only be used once in the combination.</p>
<p>Note:<br>All numbers (including target) will be positive integers.<br>Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).<br>The solution set must not contain duplicate combinations.<br>For example, given candidate set 10,1,2,7,6,1,5 and target 8,<br>A solution set is:<br>[1, 7]<br>[1, 2, 5]<br>[2, 6]<br>[1, 1, 6] </p>
<p><strong>Thinking:</strong></p>
<p>We should use backtracing to trace all the possible answers. In order to remove duplicate, there are two methods. One is to use hashset, the other is to build a visited array, if the same value is not visited, then don’t visit the value. And there two ways to backtracing, one is to use the return value, and the other is to pass the fucntion value.</p>
<p><strong>Solution1:</strong></p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; combinationSum2(int[] candidates, int target) {
    Arrays.sort(candidates);
    return backtracing(candidates, target, 0);
}

public List&lt;List&lt;Integer&gt;&gt; backtracing(int [] candidates, int target, int left){
    HashSet&lt;List&lt;Integer&gt;&gt; tres = new HashSet&lt;List&lt;Integer&gt;&gt;();
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    int right = candidates.length-1;

    if (left &gt; right){
        return res;
    }
    if (target &lt; candidates[left]){
        return res;
    }
    if (target == candidates[left]){
        List&lt;Integer&gt; list = new ArrayList&lt;Integer&gt;();
        list.add(candidates[left]);
        res.add(list);
        return res;
    }
    if (left == right){
        return res;
    }

    for (int i = left; i &lt;= right; i++){
        for (List&lt;Integer&gt; list: backtracing(candidates, target-candidates[i], i+1)){
            list.add(0, candidates[i]);
            tres.add(list);
        }
        for (List&lt;Integer&gt; list: backtracing(candidates, target, i+1)){
            tres.add(list);
        }
    }

    res.addAll(tres);
    return res;
}
</code></pre><p><strong>Solution2:</strong></p>
<pre><code>public static ArrayList&lt;List&lt;Integer&gt;&gt; combinationSum2(int[] candidates, int target) {  
    ArrayList&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();  
    ArrayList&lt;Integer&gt; item = new ArrayList&lt;Integer&gt;();
    if(candidates == null || candidates.length==0)  
        return res; 

    Arrays.sort(candidates);  
    boolean [] visited = new boolean[candidates.length];
    helper(candidates,target, 0, item ,res, visited);  
    return res;  
}  

private static void helper(int[] candidates, int target, int start, List&lt;Integer&gt; item,   
ArrayList&lt;List&lt;Integer&gt;&gt; res, boolean[] visited){  
    if(target&lt;0)  
        return;  
    if(target==0){  
        res.add(new ArrayList&lt;Integer&gt;(item));  
        return;
    }

    for(int i=start;i&lt;candidates.length;i++){
        if(!visited[i]){
            if(i&gt;0 &amp;&amp; candidates[i] == candidates[i-1] &amp;&amp; visited[i-1]==false)//deal with dupicate
                continue;  
            item.add(candidates[i]);
            visited[i]=true;
            int newtarget = target - candidates[i];
            helper(candidates,newtarget,i+1,item,res,visited);  
            visited[i]=false;
            item.remove(item.size()-1);  
        }
    }  
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Reverse Linked List II(Java)]]></title>
      <url>http://yoursite.com/2016/02/02/Leetcode-Reverse-Linked-List-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Reverse a linked list from position m to n. Do it in-place and in one-pass.</p>
<p>For example:<br>Given 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL, m = 2 and n = 4,</p>
<p>return 1-&gt;4-&gt;3-&gt;2-&gt;5-&gt;NULL.</p>
<p>Note:<br>Given m, n satisfy the following condition:<br>1 ≤ m ≤ n ≤ length of list.</p>
<p><strong>Thinking:</strong></p>
<p>It’s similar with Reverse Linked List, only thing different is to limit the range. So we should to find the start of the reversed linked list and record its previous node. Also, we should add a dummy node for easily operator with the first node. Then use three points as usual pre, cur and next to operate and change the nodes’ next pointers.</p>
<p><strong>Solution:</strong></p>
<pre><code>public ListNode reverseBetween(ListNode head, int m, int n) {
    if (m == n)
        return head;
    ListNode prehead = new ListNode(0);//dummy
    prehead.next = head;
    ListNode pre = prehead;
    ListNode cur = head;
    int idx = 1;

    while (idx &lt; m) {
        pre = cur;
        cur = cur.next;
        idx++;
    }
    ListNode prerever = pre;
    ListNode next = null;
    pre = cur;
    cur = cur.next;
    while (idx &lt; n) {
        next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
        idx++;
    }
    prerever.next.next = cur;
    prerever.next = pre;


    return prehead.next;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Patching Array(Java)]]></title>
      <url>http://yoursite.com/2016/02/02/Patching-Array-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a sorted positive integer array nums and an integer n, add/patch elements to the array such that any number in range [1, n] inclusive can be formed by the sum of some elements in the array. Return the minimum number of patches required.</p>
<p>Example 1:<br>nums = [1, 3], n = 6<br>Return 1.</p>
<p>Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.<br>Now if we add/patch 2 to nums, the combinations are: [1], [2], [3], [1,3], [2,3], [1,2,3].<br>Possible sums are 1, 2, 3, 4, 5, 6, which now covers the range [1, 6].<br>So we only need 1 patch.</p>
<p>Example 2:<br>nums = [1, 5, 10], n = 20<br>Return 2.<br>The two patches can be [2, 4].</p>
<p>Example 3:<br>nums = [1, 2, 2], n = 5<br>Return 0.</p>
<p><strong>Thinking:</strong></p>
<p>The first range we can cover of an array is total, then if we add a new element to this array and this element add &lt;= total, then the new range is [1, add+total). We should also care about the java maxint value, so if we use bit manipulation, it means it is bigger than maxint if total is smaller than zero.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int minPatches(int[] nums, int n) {
    int total = 1; //total is the upper bound of the sum
    int count = 0;
    int index = 0;
    int len = nums.length;

    while (total &lt;= n) {
        if (index &lt; len &amp;&amp; nums[index] &lt;= total){
            total += nums[index++];
        }
        else{
            total &lt;&lt;= 1;
            count++;
            if (total &lt; 0)
                break;
        }
    }


    return count;
} 
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Verify Preorder Serialization of a Binary Tree(Java)]]></title>
      <url>http://yoursite.com/2016/02/01/Leetcode-Verify-Preorder-Serialization-of-a-Binary-Tree-Java/</url>
      <content type="html"><![CDATA[<p>One way to serialize a binary tree is to use pre-order traversal. When we encounter a non-null node, we record the node’s value. If it is a null node, we record using a sentinel value such as #.</p>
<pre><code>     _9_
    /   \
   3     2
  / \   / \
 4   1  #  6
/ \ / \   / \
# # # #   # #
</code></pre><p>For example, the above binary tree can be serialized to the string “9,3,4,#,#,1,#,#,2,#,6,#,#”, where # represents a null node.</p>
<p>Given a string of comma separated values, verify whether it is a correct preorder traversal serialization of a binary tree. Find an algorithm without reconstructing the tree.</p>
<p>Each comma separated value in the string must be either an integer or a character ‘#’ representing null pointer.</p>
<p>You may assume that the input format is always valid, for example it could never contain two consecutive commas such as “1,,3”.</p>
<p>Example 1:<br>“9,3,4,#,#,1,#,#,2,#,6,#,#”<br>Return true</p>
<p>Example 2:<br>“1,#”<br>Return false</p>
<p>Example 3:<br>“9,#,#,1”<br>Return false</p>
<p><strong>Thinking:</strong></p>
<p>Accroding to the correct answer given, we can find the pattern. We should start from # and use stack to store it. When get two #, we should get another element from the string. </p>
<p><strong>Solution:</strong></p>
<pre><code>public boolean isValidSerialization(String preorder) {
    String[] strlist = preorder.split(&quot;,&quot;);
    Stack&lt;String&gt; stack = new Stack&lt;String&gt;();
    Stack&lt;String&gt; tempstack = new Stack&lt;String&gt;();

    for (String s: strlist) {
        stack.push(s);
    }
    while (!stack.isEmpty()) {
        while (!stack.isEmpty() &amp;&amp; stack.peek().equals(&quot;#&quot;)){
            tempstack.push(stack.pop());
        }
        if (tempstack.size() &lt; 2)
            break;
        while (tempstack.size() &gt;= 2 &amp;&amp; !stack.isEmpty() &amp;&amp; !stack.peek().equals(&quot;#&quot;)){
            tempstack.pop();
            tempstack.pop();
            if (!stack.isEmpty() &amp;&amp; !stack.peek().equals(&quot;#&quot;)){
                stack.pop();
                tempstack.push(&quot;#&quot;);
            }
        }
    }

    if (tempstack.size() == 1 &amp;&amp; stack.isEmpty())
        return true;
    else
        return false;
}
</code></pre><p>There is another simpler solution:</p>
<pre><code>public boolean isValidSerialization(String preorder) {
    String[] p = preorder.split(&quot;,&quot;);
    int idx = 0; // stack
    for (int i = 0; i &lt; p.length; i++) {
    if (p[i].equals(&quot;#&quot;)) {
        idx--;
    } else {
        if (idx &lt; 0) { // check
          return false;
        }
        p[idx++] = p[i];
      }
    }
    return idx == -1; // check
  }
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/83903/share-my-java-solution" target="_blank" rel="external">https://leetcode.com/discuss/83903/share-my-java-solution</a></p>
<p>And another much simplier solution which caculate the indegree and outdegree:</p>
<pre><code>public boolean isValidSerialization2(String preorder) {
    String[] nodes = preorder.split(&quot;,&quot;);
    int diff = 1;
    for (String node: nodes) {
        if (--diff &lt; 0) return false;
        if (!node.equals(&quot;#&quot;)) diff += 2;
    }
    return diff == 0;
}
</code></pre><p>Reference: <a href="https://www.hrwhisper.me/leetcode-algorithm-solution/" target="_blank" rel="external">https://www.hrwhisper.me/leetcode-algorithm-solution/</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[AI Note]]></title>
      <url>http://yoursite.com/2016/02/01/AI-Note/</url>
      <content type="html"><![CDATA[<p><strong>Lecture 1:</strong></p>
<p><strong>Lecture 2:</strong></p>
<ol>
<li>What’s Agent?</li>
<li>PEAS</li>
</ol>
<p><strong>Lecture 3:</strong></p>
<ol>
<li>Difference between tree search and graph search:<br> Graph search will record the explored nodes, and won’t explore them again.</li>
</ol>
<p><strong>Lecture 4:</strong></p>
<ol>
<li>DFS, BFS, uniform-cost search, interative deepening search, evaluating search performance about completeness, optimality, time and space complexity</li>
<li>BFS:<br> Completeness: Yes(When b is finite)<br> Optimality: Yes(If path is nondecreasing)<br> Time: O(b^d)<br> Space: O(b^d)</li>
<li>DFS:<br> Completeness: Yes(If graph search version)<br> Optimality: No<br> Time: O(b^m)<br> Space: O(b*m)</li>
<li>Uniform-cost search:<br> Completeness: Yes<br> Optimality: Yes(If path is nondecreasing)<br> Uniform-cost search not optimal if it is terminated when some node in the queue has goal state.</li>
<li>Iterative deepening search:<br> Completeness: Yes<br> Optimality: Yes<br> Time: O(b^d)<br> Space: O(bd)</li>
</ol>
<p><strong>Lecture 5:</strong></p>
<ol>
<li>Uniformed search, bi-directional search, informed search, greedy best first search, A*, interative deepening A*, recursive best first search, simplified memory-bounded A*</li>
<li>Bidirectional search:<br> Search forward from initial state, and backward from goal.<br> Completeness: Yes<br> Optimality: Yes<br> Time: O(b^(d/2)<br> Space: O(b^(d/2)</li>
<li>Greedy best first search:<br> Greedy BFS keeps all the nodes generated in the<br>Frontier, which is sorted based on h(n).<br> Completeness: No<br> Optimality: No<br> Time: O(b^m)<br> Space: O(b^m)</li>
<li>A* Search:<br> Use (approximate) total path cost to guide search<br> Admissible Heurisitic: A heuristic is admissible if it never overestimates the cost to reach the goal<br> e.g. hSLD(n) is admissible because it never overestimates the actual road distance<br> Admissible heuristics does not guarantee that the chosen path is optimal<br> A heuristic is consistent if for every node n and every successor n’ of n generated by any action a<br>h(n) ≤ c(n,a,n’) + h(n’)<br> That is, f(n) is nondecreasing along every path.<br> Completeness: Yes<br> Optimality: Yes(if admissible in tree search or consistent in graph search)</li>
<li>Recursive Best-Frist Search:<br> Keep track of f value (f-limit) of best sibling of path currently exploring<br> Space: O(bd)</li>
<li>Memory-Bounded A*:<br>  I.e., expand best leaves until available memory is full;When full, SMA* drops worst leaf node (highest f-value);Like RBFS, backup forgotten node value to its parent</li>
</ol>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Kth Largest Element in an Array(Java)]]></title>
      <url>http://yoursite.com/2016/01/31/Leetcode-Kth-Largest-Element-in-an-Array-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.</p>
<p>For example,<br>Given [3,2,1,5,6,4] and k = 2, return 5.</p>
<p>Note:<br>You may assume k is always valid, 1 ≤ k ≤ array’s length.</p>
<p><strong>Thinking:</strong></p>
<p>There are three ways to solve this problem:</p>
<ol>
<li>The first one is to build a max heap with size n, and get the top of the heap k times.</li>
<li>The second one is to build a min heap with size k, and keep the biggest top k elements of this array. Finally, get the top of it.</li>
<li>The third one is to use a method called quickselect which uses function partition. It first use a pivot to split the array into two parts, then accroding to this index, choose which part to select.</li>
</ol>
<p><strong>Solution:</strong></p>
<p>Max heap:</p>
<pre><code>public int findKthLargest1(int[] nums, int k) {
    int len = nums.length;
    PriorityQueue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;(len, new HeapComparator());
    for (int i = 0; i &lt; len; i++){
        heap.add(nums[i]);
    }
    for (int i = 0; i &lt; k-1; i++){
        heap.poll();
    }
    return heap.peek();
}

class HeapComparator implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        // TODO Auto-generated method stub
        int i1 = (int)o1;
        int i2 = (int)o2;
        if (i1 &gt; i2)
            return -1;
        else if (i1 == i2)
            return 0;
        else
            return 1;
    }

}
</code></pre><p>Min heap:</p>
<pre><code>public int findKthLargest2(int[] nums, int k) {
    int len = nums.length;
    PriorityQueue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;(k);
    for (int i = 0; i &lt; k; i++){
        heap.add(nums[i]);
    }
    for (int i = k; i &lt; len; i++){
        if (nums[i] &gt; heap.peek()){
            heap.poll();
            heap.add(nums[i]);
        }
    }
    return heap.peek();
}
</code></pre><p>Quickselect:</p>
<pre><code>public int findKthLargest3(int[] nums, int k) {
    int len = nums.length;
    return quickselect(nums, 0, len-1, k);
}

private int quickselect(int[] nums, int left, int right, int k){
    int pivotIndex = partition(nums, left, right, left);
    if (pivotIndex == k-1){
        return nums[pivotIndex];
    }
    else if(pivotIndex &lt; k){
        return quickselect(nums, pivotIndex+1, right, k);
    }
    else{
        return quickselect(nums, left, pivotIndex-1, k);
    }
}

private int partition(int[] nums, int left, int right, int index){
    int pivotvalue = nums[index];
    int storeindex = left;
    nums[index] = nums[right];
    for (int i = left; i &lt; right; i++){
        if (nums[i] &gt; pivotvalue){
            int temp = nums[i];
            nums[i] = nums[storeindex];
            nums[storeindex++] = temp;
        }
    }
    nums[right] = nums[storeindex];
    nums[storeindex] = pivotvalue;
    return storeindex;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Permutations II(Java)]]></title>
      <url>http://yoursite.com/2016/01/31/Leetcode-Permutations-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a collection of numbers that might contain duplicates, return all possible unique permutations.</p>
<p>For example,<br>[1,1,2] have the following unique permutations:<br>[1,1,2], [1,2,1], and [2,1,1].</p>
<p><strong>Thinking:</strong></p>
<p>It’s very similiar with the question permutation, we should use backtracing to go through all the possibilities. For example, we pick the first element of the array, and get the permutation of the rest of this array, and put the first element in every possible position. The only difference bewteen the permutation is that we don’t allow duplicate. We can use hashset to solve this problem.</p>
<p>By the way, I made a mistake this time which I used to make. It’s that in the loop of this:</p>
<pre><code>for (List&lt;Integer&gt; list: backtracing(nums, index+1)){
    for (int i = 0; i &lt;= list.size(); i++){
        List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;(list);
        tempres.add(i, nums[index]);
        tres.add(tempres);
    }
}
</code></pre><p>I shouldn’t use the temporary variable list to operate, because<br>1) the size of it will change;<br>2) we should use it several times instead of once.<br>Then that means we should build another temporary variable. In this case, it’s tempres.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; permuteUnique(int[] nums) {
    return backtracing(nums, 0);
}

private List&lt;List&lt;Integer&gt;&gt; backtracing(int[] nums, int index) {
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    HashSet&lt;List&lt;Integer&gt;&gt; tres = new HashSet&lt;List&lt;Integer&gt;&gt;();
    int len = nums.length;

    if (index &gt;= len){
        return res;
    }

    if (index == len - 1){
        List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;();
        tempres.add(nums[index]);
        res.add(tempres);
        return res;
    }

    for (List&lt;Integer&gt; list: backtracing(nums, index+1)){
        for (int i = 0; i &lt;= list.size(); i++){
            List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;(list);
            tempres.add(i, nums[index]);
            tres.add(tempres);
        }
    }

    res.addAll(tres);
    return res;
}
</code></pre><p>There is another solution is much faster than me. Because it use extra space to record which element is used and use sort to reduce the extra cost to make sure unique. What’s more, the process of adding first and removing after dfs is usually used by people. I suppose I should learn from it.</p>
<p>Code:</p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; permuteUnique(int[] nums) {
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    if(nums==null || nums.length==0) return res;
    boolean[] used = new boolean[nums.length];
    List&lt;Integer&gt; list = new ArrayList&lt;Integer&gt;();
    Arrays.sort(nums);
    dfs(nums, used, list, res);
    return res;
}

public void dfs(int[] nums, boolean[] used, List&lt;Integer&gt; list, List&lt;List&lt;Integer&gt;&gt; res){
    if(list.size()==nums.length){
        res.add(new ArrayList&lt;Integer&gt;(list));
        return;
    }
    for(int i=0;i&lt;nums.length;i++){
        if(used[i]) continue;
        if(i&gt;0 &amp;&amp;nums[i-1]==nums[i] &amp;&amp; !used[i-1]) continue;
        used[i]=true;
        list.add(nums[i]);
        dfs(nums,used,list,res);
        used[i]=false;
        list.remove(list.size()-1);
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Algorithm Note]]></title>
      <url>http://yoursite.com/2016/01/31/Algorithm-Note/</url>
      <content type="html"><![CDATA[<ol>
<li>Chapter 3 Exercises 6中有两个点， 一个是如果一个图的DFS树中没有出现的边，边的两个顶点一定是祖先与孩子的关系；一个是如果一个图的BFS树的BFS树中没有出现的边，边的两个顶点在BFS树中的层数差不会大于1.</li>
<li>如果一个图的DFS树，或者BFS树和图相同，那么原图就没有环，否则就找他们最低的祖先，构成一个环。</li>
</ol>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[VIM]]></title>
      <url>http://yoursite.com/2016/01/30/VIM/</url>
      <content type="html"><![CDATA[<p>一、打开文件、保存、关闭文件(vi命令模式下使用)<br>:w       //保存文件<br>:w vpser.net //保存至vpser.net文件<br>:q          //退出编辑器，如果文件已修改请使用下面的命令<br>:q!        //退出编辑器，且不保存<br>:wq         //退出编辑器，且保存文件</p>
<p>二、插入文本或行(vi命令模式下使用，执行下面命令后将进入插入模式，按ESC键可退出插入模式)<br>一般使用i<br>a      //在当前光标位置的右边添加文本<br>i       //在当前光标位置的左边添加文本<br>A     //在当前行的末尾位置添加文本<br>I      //在当前行的开始处添加文本(非空字符的行首)<br>O     //在当前行的上面新建一行<br>o     //在当前行的下面新建一行<br>R    //替换(覆盖)当前光标位置及后面的若干文本<br>J    //合并光标所在行及下一行为一行(依然在命令模式)</p>
<p>三、移动光标(vi命令模式下使用)<br>1、使用上下左右方向键</p>
<p>2、命令模式下：h   向左、j   向下 、k   向上、l  向右。<br>空格键 向右、Backspace  向左、Enter  移动到下一行首、-  移动到上一行首。</p>
<p>四、删除、恢复字符或行(vi命令模式下使用)<br>x         //删除当前字符<br>nx         //删除从光标开始的n个字符<br>dd      //删除当前行<br>ndd   //向下删除当前行在内的n行<br>u       //撤销上一步操作<br>U      //撤销对当前行的所有操作</p>
<p>五、搜索(vi命令模式下使用)<br>/vpser     //向光标下搜索vpser字符串，vpser可以是正则表达式<br>?vpser     //向光标上搜索vpser字符串<br>n           //向下搜索前一个搜素动作<br>N         //向上搜索前一个搜索动作</p>
<p>*(#)      //当光标停留在某个单词上时, 输入这条命令表示查找与该单词匹配的下(上)一个单词. 同样, 再输入 n 查找下一个匹配处, 输入 N 反方向查找.</p>
<p>g*(g#)        //此命令与上条命令相似, 只不过它不完全匹配光标所在处的单词, 而是匹配包含该单词的所有字符串.</p>
<p>六、跳至指定行(vi命令模式下使用)<br>n+        //向下跳n行<br>n-         //向上跳n行<br>nG        //跳到行号为n的行<br>G           //跳至文件的底部</p>
<p>七、设置行号(vi命令模式下使用)<br>:set  nu     //显示行号<br>:set nonu    //取消显示行号</p>
<p>八、复制、粘贴(vi命令模式下使用)<br>yy    //将当前行复制到缓存区，也可以用 “ayy 复制，”a 为缓冲区，a也可以替换为a到z的任意字母，可以完成多个复制任务。<br>nyy   //将当前行向下n行复制到缓冲区，也可以用 “anyy 复制，”a 为缓冲区，a也可以替换为a到z的任意字母，可以完成多个复制任务。<br>yw    //复制从光标开始到词尾的字符。<br>nyw   //复制从光标开始的n个单词。<br>y^      //复制从光标到行首的内容。  VPS侦探<br>y$      //复制从光标到行尾的内容。<br>p        //粘贴剪切板里的内容在光标后，如果使用了前面的自定义缓冲区，建议使用”ap 进行粘贴。<br>P        //粘贴剪切板里的内容在光标前，如果使用了前面的自定义缓冲区，建议使用”aP 进行粘贴。</p>
<p>九、替换(vi命令模式下使用)<br>:s/old/new      //用new替换行中首次出现的old<br>:s/old/new/g         //用new替换行中所有的old<br>:n,m s/old/new/g     //用new替换从n到m行里所有的old<br>:%s/old/new/g      //用new替换当前文件里所有的old</p>
<p>十、编辑其他文件<br>:e otherfilename    //编辑文件名为otherfilename的文件。</p>
<p>十一、修改文件格式<br>:set fileformat=unix   //将文件修改为unix格式，如win下面的文本文件在linux下会出现^M。</p>
<p>十二、查找帮助<br>当你不知道怎么处理时，直接输入help可以看到帮助文档的起点，ZZ是退出或者：q，不建议使用<br>查找关于某个字母的命令 ：help x   查找关于x的命令。</p>
<p>参考：<a href="http://blog.csdn.net/chenxiaochen32/article/details/7378127" target="_blank" rel="external">http://blog.csdn.net/chenxiaochen32/article/details/7378127</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Palindrome Partitioning(Java)]]></title>
      <url>http://yoursite.com/2016/01/30/Leetcode-Palindrome-Partitioning-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a string s, partition s such that every substring of the partition is a palindrome.</p>
<p>Return all possible palindrome partitioning of s.</p>
<p>For example, given s = “aab”,<br>Return</p>
<pre><code>[
  [&quot;aa&quot;,&quot;b&quot;],
  [&quot;a&quot;,&quot;a&quot;,&quot;b&quot;]
]
</code></pre><p><strong>Thinking:</strong></p>
<p>We should get all the possible partition, it’s obvious we should use backtracing. We partition the string from beginning, and check if it’s palindrome, then check the rest of the substring. If all the substrings are palindrome, we put them in the result. We have to notice the API of Java substring(beginIndex, endIndex) that beginIndex is inclusive but endIndex is exclusive.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;List&lt;String&gt;&gt; partition(String s) {
    List&lt;List&lt;String&gt;&gt; res = new ArrayList&lt;List&lt;String&gt;&gt;();
    int len = s.length();
    if (palindrome(s)){
        List&lt;String&gt; tempres = new ArrayList&lt;String&gt;();
        tempres.add(s);
        res.add(tempres);
    }
    for (int i = 1; i &lt; len; i++){
        if (palindrome(s.substring(0, i))){
            for (List&lt;String&gt; list: partition(s.substring(i))){
                list.add(0, s.substring(0, i));
                res.add(list);
            }
        }
    }
    return res;
}

private boolean palindrome(String s){
    int len = s.length();
    int left = 0;
    int right = len - 1;
    while (left &lt; right){
        if (s.charAt(left) != s.charAt(right)){
            return false;
        }
        left++;
        right--;
    }
    return true;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Binary Tree Zigzag Level Order Traversal(Java)]]></title>
      <url>http://yoursite.com/2016/01/30/Leetcode-Binary-Tree-Zigzag-Level-Order-Traversal-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).</p>
<p>For example:<br>Given binary tree {3,9,20,#,#,15,7},</p>
<pre><code>  3
 / \
9  20
  /  \
 15   7
</code></pre><p>return its zigzag level order traversal as:</p>
<pre><code>[
  [3],
  [20,9],
  [15,7]
]
</code></pre><p><strong>Thinking:</strong></p>
<p>It’s a BFS problem. It’s fine if we need use queue, but because we have to record as a zigzag order, it’s more efficient to use stack. What’s more, we should to notice the order of left and right child.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; zigzagLevelOrder(TreeNode root) {
    int flag = 0;
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    Stack&lt;TreeNode&gt; stack = new Stack&lt;TreeNode&gt;();
    Stack&lt;TreeNode&gt; tempstack = new Stack&lt;TreeNode&gt;();
    if (root == null)
        return res;
    stack.add(root);
    while (!stack.isEmpty() || !tempstack.isEmpty()){
        tempstack = new Stack&lt;TreeNode&gt;();
        List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;();
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            tempres.add(node.val);
            if (flag == 0){
                if (node.left != null){
                    tempstack.add(node.left);
                }
                if (node.right != null){
                    tempstack.add(node.right);
                }
            }
            else{
                if (node.right != null){
                    tempstack.add(node.right);
                }
                if (node.left != null){
                    tempstack.add(node.left);
                }
            }

        }
        res.add(tempres);
        stack.addAll(tempstack);
        flag ^= 1;
    }

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-4Sum(Java)]]></title>
      <url>http://yoursite.com/2016/01/30/Leetcode-4Sum-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.</p>
<p>Note:<br>Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ≤ b ≤ c ≤ d)<br>The solution set must not contain duplicate quadruplets.<br>    For example, given array S = {1 0 -1 0 -2 2}, and target = 0.</p>
<pre><code>A solution set is:
(-1,  0, 0, 1)
(-2, -1, 1, 2)
(-2,  0, 0, 2)
</code></pre><p><strong>Thinking</strong>:</p>
<p>This questions is very similar with 2Sum and 3Sum. There are several way to solve it. </p>
<p><strong>Solution1:</strong></p>
<p>The most common method may use the method of 3Sum, and do that n times.</p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; fourSum1(int[] nums, int target) {
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    Set&lt;List&lt;Integer&gt;&gt; tres = new HashSet&lt;List&lt;Integer&gt;&gt;();
    Arrays.sort(nums);
    int len = nums.length;


    for (int i = 0; i &lt; len-3; i++){
        for (int j = i+1; j &lt; len-2; j++){
            for (int k = j+1; k &lt; len-1; k++){
                int l = len-1;
                while (k &lt; l){
                    int sum = nums[i] + nums[j] + nums[k] + nums[l];
                    if (sum == target){
                        List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;();
                        tempres.add(nums[i]);
                        tempres.add(nums[j]);
                        tempres.add(nums[k]);
                        tempres.add(nums[l]);
                        tres.add(tempres);
                        k++;
                        l--;
                    }
                    else if (sum &gt; target){
                        l--;
                    }
                    else{
                        k++;
                    }
                    while (k &lt; l &amp;&amp; nums[k+1] == nums[k]){
                        k++;
                    }
                    while (k &lt; l &amp;&amp; nums[l-1] == nums[l]){
                        l--;
                    }
                }
            }
        }
    }

    res.addAll(tres);
    return res;
}
</code></pre><p><strong>Solution2:</strong></p>
<p>The second solution is to combine every two numbers as a pair, and make it as a 2sum problem. But for implementing this method, we have to define the data structure by ourself and implement the interface of Comparator to sort the sum of them.</p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; fourSum2(int[] nums, int target){
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    int len = nums.length;
    if (len &lt; 4)
        return res;
    Pair[] pairSum = new Pair[len*(len-1)/2];
    Set&lt;List&lt;Integer&gt;&gt; tres = new HashSet&lt;List&lt;Integer&gt;&gt;();

    int count = 0;
    for (int i = 0; i &lt; len-1; i++){
        for (int j = i+1; j &lt; len; j++){
            Pair ele = new Pair(nums[i], nums[j], i, j);
            pairSum[count++] = ele;
        }
    }
    Arrays.sort(pairSum, new SumComparator());

    int left = 0;
    int right = pairSum.length - 1;
    while (left &lt; right){
        int sum = pairSum[left].getSum() + pairSum[right].getSum();
        if (sum == target){
            int endl = left;
            int endr = right;
            while (pairSum[endl].getSum() == pairSum[endl+1].getSum() &amp;&amp; endl+1 &lt; endr){
                endl++;
            }
            while (pairSum[endr].getSum() == pairSum[endr-1].getSum() &amp;&amp; endl &lt; endr-1){
                endr--;
            }
            for (int i = left; i &lt;= endl; i++){
                for (int j = right; j&gt;= endr; j--){
                    int i1 = pairSum[i].geti();
                    int i2 = pairSum[j].geti();
                    int j1 = pairSum[i].getj();
                    int j2 = pairSum[j].getj();
                    if (i1 == i2 || i1 == j2 || j1 == i2 || j1 == j2){
                        continue;
                    }
                    int[] temp = new int[4];
                    temp[0] = pairSum[i].getN1();
                    temp[1] = pairSum[i].getN2();
                    temp[2] = pairSum[j].getN1();
                    temp[3] = pairSum[j].getN2();
                    Arrays.sort(temp);
                    List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;();
                    tempres.add(temp[0]);
                    tempres.add(temp[1]);
                    tempres.add(temp[2]);
                    tempres.add(temp[3]);
                    tres.add(tempres);
                }
            }
            left = endl+1;
            right = endr-1;
        }
        else if (sum &gt; target){
            right--;
        }
        else{
            left++;
        }
    }

    res.addAll(tres);
    return res;
}

class SumComparator implements Comparator{

    @Override
    public final int compare(Object o1, Object o2) {
        // TODO Auto-generated method stub
        Pair l1 = (Pair)o1;
        Pair l2 = (Pair)o2;
        if (l1.getSum() &gt; l2.getSum())
            return 1;
        else if (l1.getSum() &lt; l2.getSum())
            return -1;
        else
            return 0;
    }
}

class Pair{
    int i;
    int j;
    int n1;
    int n2;
    int sum;
    Pair(int num1, int num2, int i, int j){
        this.n1 = num1;
        this.n2 = num2;
        this.sum = num1 + num2;
        this.i = i;
        this.j = j;
    }
    public int getSum(){
        return this.sum;
    }
    public int getN1(){
        return this.n1;
    }
    public int getN2(){
        return this.n2;
    }
    public int geti(){
        return this.i;
    }
    public int getj(){
        return this.j;
    }
}
</code></pre><p>Reference: <a href="http://blog.csdn.net/linhuanmars/article/details/24826871" target="_blank" rel="external">http://blog.csdn.net/linhuanmars/article/details/24826871</a></p>
<p><strong>Solution3:</strong></p>
<p>The third method is the most efficient method. It has two loop of two points and use some method to break or return early. It really improve the performance of time running.</p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; fourSum3(int[] nums, int target) {
    List&lt;List&lt;Integer&gt;&gt; list = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    Arrays.sort(nums);
    int second = 0, third = 0, nexti = 0, nextj = 0;
    for(int i=0, L=nums.length; i&lt;L-3; i++) {
        if(nums[i]&lt;&lt;2 &gt; target) return list; // return immediately
        for(int j=L-1; j&gt;i+2; j--) {
            if(nums[j]&lt;&lt;2 &lt; target) break; // break immediately
            int rem = target-nums[i]-nums[j];
            int lo = i+1, hi=j-1;
            while(lo&lt;hi) {
                int sum = nums[lo] + nums[hi];
                if(sum&gt;rem) --hi;
                else if(sum&lt;rem) ++lo;
                else {
                    list.add(Arrays.asList(nums[i],nums[lo],nums[hi],nums[j]));
                    while(++lo&lt;=hi &amp;&amp; nums[lo-1]==nums[lo]) continue; // avoid duplicate results
                    while(--hi&gt;=lo &amp;&amp; nums[hi]==nums[hi+1]) continue; // avoid duplicate results
                }
            }
            while(j&gt;=1 &amp;&amp; nums[j]==nums[j-1]) --j; // skip inner loop
        }
        while(i&lt;L-1 &amp;&amp; nums[i]==nums[i+1]) ++i; // skip outer loop
    }
    return list;
}
</code></pre><p>Reference: <a href="https://leetcode.com/discuss/78276/java-little-bit-faster-than-other-common-methods-9ms-beats-95%25" target="_blank" rel="external">https://leetcode.com/discuss/78276/java-little-bit-faster-than-other-common-methods-9ms-beats-95%25</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-3Sum(Java)]]></title>
      <url>http://yoursite.com/2016/01/28/Leetcode-3Sum-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.</p>
<p>Note:<br>Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)<br>The solution set must not contain duplicate triplets.<br>    For example, given array S = {-1 0 1 2 -1 -4},</p>
<pre><code>A solution set is:
(-1, 0, 1)
(-1, -1, 2)
</code></pre><p><strong>Thinking:</strong></p>
<p>Sort the array first. Pick a number from the array, and use other two points to record the position of the array and determine which one should change by the sum of them. What’s more, the result set should has no duplicate, so we can use hashset here.</p>
<p><strong>Solution:</strong></p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; threeSum(int[] nums) {
    int l = nums.length;
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    Set&lt;List&lt;Integer&gt;&gt; tres = new HashSet&lt;List&lt;Integer&gt;&gt;();

    if (l &lt; 3)
        return res;

    Arrays.sort(nums);

    for (int i = 0; i &lt; l-2; i++){
        int k = l-1;
        for (int j = i+1; j &lt; l; j++){
            while (j &lt; k){
                int sum = nums[i] + nums[j] + nums[k];
                if (sum == 0){
                    List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;();
                    tempres.add(nums[i]);
                    tempres.add(nums[j]);
                    tempres.add(nums[k]);
                    tres.add(tempres);
                    while (j &lt; k &amp;&amp; nums[j] == tempres.get(1)){
                        j++;
                    }
                    k--;
                }
                else if (sum &gt; 0){
                    k--;
                }
                else{
                    j++;
                }

            }
        }
    }
    res.addAll(tres);

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Two Sum(Java)]]></title>
      <url>http://yoursite.com/2016/01/28/Leetcode-Two-Sum-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an array of integers, find two numbers such that they add up to a specific target number.</p>
<p>The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.</p>
<p>You may assume that each input would have exactly one solution.</p>
<p>Input: numbers={2, 7, 11, 15}, target=9<br>Output: index1=1, index2=2</p>
<p><strong>Thinking:</strong></p>
<p>We can use hash map to store the rest of nums[i], and if we find which number is equal to the rest beofore, their sum will be target.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int[] twoSum(int[] nums, int target){
    HashMap&lt;Integer, Integer&gt; map = new HashMap&lt;Integer, Integer&gt;();
    int[] res = new int[2];

    for (int i = 0; i &lt; nums.length; i++){
        if (map.containsKey(nums[i])){
            res[0] = map.get(nums[i]) + 1;
            res[1] = i+1;
            break;
        }
        else{
            map.put(target-nums[i], i);
        }
    }

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Game of Life(Java)]]></title>
      <url>http://yoursite.com/2016/01/28/Leetcode-Game-of-Life-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>According to the Wikipedia’s article: “The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970.”</p>
<p>Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):</p>
<p>Any live cell with fewer than two live neighbors dies, as if caused by under-population.<br>Any live cell with two or three live neighbors lives on to the next generation.<br>Any live cell with more than three live neighbors dies, as if by over-population..<br>Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.<br>Write a function to compute the next state (after one update) of the board given its current state.</p>
<p>Follow up:<br>Could you solve it in-place? Remember that the board needs to be updated at the same time: You cannot update some cells first and then use their updated values to update other cells.<br>In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches the border of the array. How would you address these problems?</p>
<p><strong>Thinkings:</strong></p>
<p>It’s difficult quesiont, isn’t it? We have to fully understand when cell become live or dead and try to replace them in place. One solution is to present their status using bits, the first bit represents their current status and second bit represents their next status. For example:</p>
<p>current status is live and next status will be dead is 01<br>current status is dead and next status will be live is 10</p>
<p>And then we can get the current status by:</p>
<pre><code>board[i][j] &amp; 1
</code></pre><p>Get the finnaly status by:</p>
<pre><code>board[i][j] &gt;&gt;= 1
</code></pre><p><strong>Solution:</strong></p>
<pre><code>public void gameOfLife(int[][] board) {
    int m = board.length;
    if (m == 0)
        return;
    int n = board[0].length;

    //int[][] temp = new int[m][n];


    for (int i = 0; i &lt; m; i++){
        for (int j = 0; j &lt; n; j++){
            int count = 0;
            for (int p = -1; p &lt; 2; p++)
                for (int q = -1; q &lt; 2; q++){
                    if (i+p&gt;=0 &amp;&amp; i+p&lt;m &amp;&amp; j+q&gt;=0 &amp;&amp; j+q&lt;n &amp;&amp; !(p==0 &amp;&amp; q==0)){
                        if ((board[i+p][j+q] &amp; 1) == 1)
                            count++;
                    }
                }

            if ((board[i][j] &amp; 1) == 0 &amp;&amp; count == 3){
                //temp[i][j] = 1;
                board[i][j] = 2;
            }
            else if ((board[i][j] &amp; 1) == 1 &amp;&amp; count &lt;=3 &amp;&amp; count &gt;= 2){
                    board[i][j] = 3;

            }
        }
    }

    for (int i = 0; i &lt; m; i++){
        for (int j = 0; j &lt; n; j++){
            //board[i][j] = temp[i][j];
            board[i][j] &gt;&gt;= 1;
        }
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Letter Combinations of a Phone Number(Java)]]></title>
      <url>http://yoursite.com/2016/01/27/Leetcode-Letter-Combinations-of-a-Phone-Number-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a digit string, return all possible letter combinations that the number could represent.</p>
<p>A mapping of digit to letters (just like on the telephone buttons) is given below.</p>
<p><img src="http://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png" alt=""></p>
<pre><code>Input:Digit string &quot;23&quot;
Output: [&quot;ad&quot;, &quot;ae&quot;, &quot;af&quot;, &quot;bd&quot;, &quot;be&quot;, &quot;bf&quot;, &quot;cd&quot;, &quot;ce&quot;, &quot;cf&quot;].
</code></pre><p>Note:<br>Although the above answer is in lexicographical order, your answer could be in any order you want.</p>
<p><strong>Thinking:</strong></p>
<p>We should get all the possiblities of the comibination so we need use backtracing.</p>
<p><strong>Solution:</strong></p>
<pre><code>import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class Solution {
    static private Map&lt;Character, char[]&gt; hmap = new HashMap&lt;Character, char[]&gt;();

    private Character two = new Character(&apos;2&apos;);
    private char[] twoC = {&apos;a&apos;, &apos;b&apos;, &apos;c&apos;};
    private Character three = new Character(&apos;3&apos;);
    private char[] threeC = {&apos;d&apos;, &apos;e&apos;, &apos;f&apos;};
    private Character four = new Character(&apos;4&apos;);
    private char[] fourC = {&apos;g&apos;, &apos;h&apos;, &apos;i&apos;};
    private Character five = new Character(&apos;5&apos;);
    private char[] fiveC = {&apos;j&apos;, &apos;k&apos;, &apos;l&apos;};
    private Character six = new Character(&apos;6&apos;);
    private char[] sixC = {&apos;m&apos;, &apos;n&apos;, &apos;o&apos;};
    private Character seven = new Character(&apos;7&apos;);
    private char[] sevenC = {&apos;p&apos;, &apos;q&apos;, &apos;r&apos;, &apos;s&apos;};
    private Character eight = new Character(&apos;8&apos;);
    private char[] eightC = {&apos;t&apos;, &apos;u&apos;, &apos;v&apos;};
    private Character nine = new Character(&apos;9&apos;);
    private char[] nineC = {&apos;w&apos;, &apos;x&apos;, &apos;y&apos;, &apos;z&apos;};

    public Solution(){
        hmap.put(two, twoC);
        hmap.put(three, threeC);
        hmap.put(four, fourC);
        hmap.put(five, fiveC);
        hmap.put(six, sixC);
        hmap.put(seven, sevenC);
        hmap.put(eight, eightC);
        hmap.put(nine, nineC);
    }

    public List&lt;String&gt; letterCombinations(String digits) {
        List&lt;String&gt; res = new ArrayList&lt;String&gt;();

        backTracing(digits, 0, &quot;&quot;, res);

        return res;
    }

    private void backTracing(String digits, int index, String cur, List&lt;String&gt; res){
        int l = digits.length();
        if (l == 0)
            return;
        if (index == l){
            res.add(cur);
            return;
        }


        Character tmpc = new Character(digits.charAt(index));
        if(hmap.containsKey(tmpc)){
            for (char c :hmap.get(tmpc)){
                backTracing(digits, index+1, cur+c, res);
            }
        }

    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Path Sum II(Java)]]></title>
      <url>http://yoursite.com/2016/01/27/Leetcode-Path-Sum-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a binary tree and a sum, find all root-to-leaf paths where each path’s sum equals the given sum.</p>
<p>For example:<br>Given the below binary tree and sum = 22,</p>
<pre><code>      5
     / \
    4   8
   /   / \
  11  13  4
 /  \    / \
7    2  5   1
</code></pre><p>return</p>
<pre><code>[
      [5,4,11,2],
       [5,8,4,5]
]
</code></pre><p><strong>Thinking:</strong></p>
<p>We should use classic dfs method to solve this problem and record all the results.</p>
<p><strong>Solution:</strong></p>
<p>But my first version of solution is time limit exceeded:</p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; pathSum(TreeNode root, int sum) {
    List&lt;Integer&gt; res = new ArrayList&lt;Integer&gt;();

    return dp(root, sum, res);
}

private List&lt;List&lt;Integer&gt;&gt; dp(TreeNode root, int sum, List&lt;Integer&gt; cur){
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();
    if (root == null)
        return null;
    if (root.left == null &amp;&amp; root.right == null){
        if (root.val == sum){
            cur.add(root.val);
            res.add(cur);
            return res;
        }
        else{
            return res;
        }
    }
    for (List&lt;Integer&gt; ele: dp(root.left, sum-root.val, cur)){
        if (ele != null){
            ele.add(0, root.val);
            res.add(ele);
        }
    }
    for (List&lt;Integer&gt; ele: dp(root.right, sum-root.val, cur)){
        if (ele != null){
            ele.add(0, root.val);
            res.add(ele);
        }
    }

    return res;
}
</code></pre><p>Then I have to improve the effiency of this algorithm, and the code is below:</p>
<pre><code>public List&lt;List&lt;Integer&gt;&gt; pathSum(TreeNode root, int sum) {
    List&lt;Integer&gt; cur = new ArrayList&lt;Integer&gt;();
    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();

    dp(root, sum, cur, res);

    return res;
}

private void dp(TreeNode root, int sum, List&lt;Integer&gt; cur, List&lt;List&lt;Integer&gt;&gt; res){
    if (root == null)
        return;
    //preorder dfs

    sum -= root.val;
    if (root.left == null &amp;&amp; root.right == null){
        if (sum == 0){
            cur.add(root.val);
            List&lt;Integer&gt; tempres = new ArrayList&lt;Integer&gt;();
            tempres.addAll(cur);
            res.add(tempres);
            cur.remove(cur.size() - 1);
        }
        return;
    }
    cur.add(root.val);
    if (root.left != null){
        dp(root.left, sum, cur, res);
    }
    if (root.right != null){
        dp(root.right, sum, cur, res);
    }
    cur.remove(cur.size() - 1);
}
</code></pre><p>It’s very importatn to create a new List while put the current list data to final result, becuase if not we will only copy the address of this variable cur. Then it will be incorrect if we revise cur.</p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Hello World]]></title>
      <url>http://yoursite.com/2016/01/27/hello-world/</url>
      <content type="html"><![CDATA[<p>Welcome to <a href="https://hexo.io/" target="_blank" rel="external">Hexo</a>! This is your very first post. Check <a href="https://hexo.io/docs/" target="_blank" rel="external">documentation</a> for more info. If you get any problems when using Hexo, you can find the answer in <a href="https://hexo.io/docs/troubleshooting.html" target="_blank" rel="external">troubleshooting</a> or you can ask me on <a href="https://github.com/hexojs/hexo/issues" target="_blank" rel="external">GitHub</a>.</p>
<h2 id="Quick_Start"><a href="#Quick_Start" class="headerlink" title="Quick Start"></a>Quick Start</h2><h3 id="Create_a_new_post"><a href="#Create_a_new_post" class="headerlink" title="Create a new post"></a>Create a new post</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo new <span class="string">"My New Post"</span></span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/writing.html" target="_blank" rel="external">Writing</a></p>
<h3 id="Run_server"><a href="#Run_server" class="headerlink" title="Run server"></a>Run server</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo server</span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/server.html" target="_blank" rel="external">Server</a></p>
<h3 id="Generate_static_files"><a href="#Generate_static_files" class="headerlink" title="Generate static files"></a>Generate static files</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo generate</span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/generating.html" target="_blank" rel="external">Generating</a></p>
<h3 id="Deploy_to_remote_sites"><a href="#Deploy_to_remote_sites" class="headerlink" title="Deploy to remote sites"></a>Deploy to remote sites</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo deploy</span><br></pre></td></tr></table></figure>
<p>More info: <a href="https://hexo.io/docs/deployment.html" target="_blank" rel="external">Deployment</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Flatten Binary Tree to Linked List(Java)]]></title>
      <url>http://yoursite.com/2016/01/27/leetcode-flatten-binary-tree-to-linked-list/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a binary tree, flatten it to a linked list in-place.</p>
<p>For example,<br>Given</p>
<pre><code>    1
   / \
  2   5
 / \   \
3   4   6
</code></pre><p>The flattened tree should look like:</p>
<pre><code>1
 \
  2
   \
    3
     \
      4
       \
        5
         \
          6
</code></pre><p>Hint:<br>If you notice carefully in the flattened tree, each node’s right child points to the next node of a pre-order traversal.</p>
<p><strong>Thinking:</strong> </p>
<p>It’s a simple dfs question and it’s pre-order. So we need to make the left-child become right-child of root and make right-child become whole left-child’s right-child. </p>
<p><strong>Solution:</strong></p>
<pre><code>public class Solution {
    public void flatten(TreeNode root) {
        if (root == null)
            return;
        dfs(root);
    }

    public TreeNode dfs(TreeNode root){

        if (root.left == null &amp;&amp; root.right == null){
            return root;
        }

        TreeNode left = null;
        TreeNode right = null;
        TreeNode preleft = root.left;
        TreeNode preright = root.right;
        if (preleft == null){
            return dfs(preright);
        }
        else if(preright == null){
            root.left = null;
            root.right = preleft;
            return dfs(preleft);
        }
        else{
            left = dfs(preleft);
            right = dfs(preright);
            root.left = null;
            root.right = preleft;
            left.right = preright;
            return right;
        }
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Triangle(Java)]]></title>
      <url>http://yoursite.com/2016/01/27/Leetcode-Triangle/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.</p>
<p>For example, given the following triangle:</p>
<pre><code>[
       [2],
     [3,4],
    [6,5,7],
   [4,1,8,3]
]
</code></pre><p>The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).</p>
<p>Note:<br>Bonus point if you are able to do this using only O(n) extra space, where n is the total number of rows in the triangle.</p>
<p><strong>Thinking:</strong><br>It’s a simple dynamic programming question. The expression is dp[i][j] = min(d[i-1][j-1], d[i][j]) + triangle[i][j].</p>
<p>But the first time, my code is time exceed:</p>
<pre><code>public class Solution {
    public int minimumTotal(List&lt;List&lt;Integer&gt;&gt; triangle) {
        int lr = triangle.size();
        if(lr == 0){
            return 0;
        }
        int lc = triangle.get(lr-1).size();
        int min = 100000;
        for(int i = 0; i &lt; lc; i++){
            int tmp = dp(triangle, lr-1, i);
            if(tmp &lt; min)
                min = tmp;
        }
        return min;
    }

    public int dp(List&lt;List&lt;Integer&gt;&gt; triangle, int row, int column){
        if(row == 0){
            return triangle.get(0).get(0);
        }
        int value = triangle.get(row).get(column);
        int size = triangle.get(row-1).size();
        if(column &gt;= size){
            return dp(triangle, row-1, column-1) + value;
        }
        else if(column - 1 &lt; 0){
            return dp(triangle, row-1, column) + value;
        }
        else{
            int res1 = dp(triangle, row-1, column-1) + value;
            int res2 = dp(triangle, row-1, column) + value;
            if(res1 &lt; res2){
                return res1;
            }
            else{
                return res2;
            }
        }
    }
}
</code></pre><p>Then I noticed the bonus, so I change my mind to use <em>iteration</em>:</p>
<pre><code>public class Solution{
    public int minimumTotal(List&lt;List&lt;Integer&gt;&gt; triangle){
        int lr = triangle.size();
        int[] min = new int[lr];
        int[] tempmin = new int[lr];
        min[0] = triangle.get(0).get(0);
        for(int i = 1; i &lt; lr; i++){
            tempmin[0] = min[0] + triangle.get(i).get(0);
            tempmin[i] = min[i-1] + triangle.get(i).get(i);
            for(int j = 1; j &lt; i; j++){
                int res1 = min[j-1] + triangle.get(i).get(j);
                int res2 = min[j] + triangle.get(i).get(j);
                if(res1 &lt; res2)
                    tempmin[j] = res1;
                else
                    tempmin[j] = res2;
            }
            for(int k = 0; k &lt; i+1; k++){
                min[k] = tempmin[k];
            }
        }
        int m = 100000;
        for(int i = 0; i &lt; lr; i++){
            if(min[i] &lt; m)
                m = min[i];
        }
        return m;
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[HTTP method: get and post]]></title>
      <url>http://yoursite.com/2016/01/26/HTTP-method-get-and-post/</url>
      <content type="html"><![CDATA[<p><strong>HTTP:</strong></p>
<p>HTTP is the foundation of data commnication of the World Wide Web. The basic work method of http is request and response.</p>
<p>There are two methods of HTTP request: Get and Post.</p>
<p>Get - get request data from specific source.<br>Post - Push data which will be dealed to specific source.</p>
<p><strong>GET:</strong></p>
<p>Note that the query string (name/value pairs) is sent in the URL of a GET request:</p>
<pre><code>http://www.w3schools.com/tags/ref_httpmethods.asp
</code></pre><p>Some other notes on GET requests:</p>
<p>GET requests can be cached</p>
<p>GET requests remain in the browser history</p>
<p>GET requests can be bookmarked</p>
<p>GET requests should never be used when dealing with sensitive data</p>
<p>GET requests have length restrictions</p>
<p>GET requests should be used only to retrieve data</p>
<p><strong>POST:</strong></p>
<p>Note that the query string (name/value pairs) is sent in the HTTP message body of a POST request:</p>
<pre><code>POST /test/demo_form.asp HTTP/1.1
Host: w3schools.com
name1=value1&amp;name2=value2
</code></pre><p>Some other notes on POST requests:</p>
<p>POST requests are never cached</p>
<p>POST requests do not remain in the browser history</p>
<p>POST requests cannot be bookmarked</p>
<p>POST requests have no restrictions on data length</p>
<p><strong>Compare GET vs. POST:</strong></p>
<table>
<thead>
<tr>
<th>Tables</th>
<th style="text-align:center">GET</th>
<th style="text-align:right">POST</th>
</tr>
</thead>
<tbody>
<tr>
<td>BACK button/Reload</td>
<td style="text-align:center">Harmless</td>
<td style="text-align:right">Data will be re-submitted</td>
</tr>
<tr>
<td>Bookmarked</td>
<td style="text-align:center">can be bookmarked</td>
<td style="text-align:right">Can not be bookmarked</td>
</tr>
<tr>
<td>Cached</td>
<td style="text-align:center">Can be cached</td>
<td style="text-align:right">Can not be cached</td>
</tr>
<tr>
<td>History</td>
<td style="text-align:center">Parameters remain in browser history</td>
<td style="text-align:right">Parameters are not saved in browser history</td>
</tr>
<tr>
<td>Restrictions on data length</td>
<td style="text-align:center">Yes</td>
<td style="text-align:right">No</td>
</tr>
<tr>
<td>Security</td>
<td style="text-align:center">Less secure</td>
<td style="text-align:right">Safer</td>
</tr>
<tr>
<td>Visibility</td>
<td style="text-align:center">Visible</td>
<td style="text-align:right">Not visible in URL</td>
</tr>
</tbody>
</table>
<p>Reference: <a href="http://www.w3schools.com/tags/ref_httpmethods.asp" target="_blank" rel="external">http://www.w3schools.com/tags/ref_httpmethods.asp</a></p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Construct Binary Tree from Preorder and Inorder Traversal(Java)]]></title>
      <url>http://yoursite.com/2016/01/26/Leetcode-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given preorder and inorder traversal of a tree, construct the binary tree.</p>
<p>Note:<br>You may assume that duplicates do not exist in the tree.</p>
<p><strong>Thinking:</strong></p>
<p>This question is similar with Construct Binary Tree from Inorder and Postorder Traversal. We should understand the differences and the sequences of these three methods. And divide into three parts- root, left child and right child.</p>
<p><strong>Solution:</strong></p>
<pre><code>public TreeNode buildTree(int[] preorder, int[] inorder) {
    int l = preorder.length;
    if (l == 0)
        return null;


    return dp(preorder, inorder, 0, l-1, 0, l-1);
    }

    private TreeNode dp(int[] preorder, int[] inorder, int preStart, int preEnd, int inStart, int inEnd){
    if (preStart &gt; preEnd || preEnd &gt;= preorder.length || inEnd &gt;= preorder.length)
        return null;
    TreeNode root = new TreeNode(preorder[preStart]);
    int index = inStart;
    for (; index &lt; inEnd; index++){
        if (inorder[index] == preorder[preStart])
            break;
    }

    TreeNode left = dp(preorder, inorder, preStart+1, preStart+index-inStart, inStart, index-1);
    TreeNode right = dp(preorder, inorder,preStart+index-inStart+1, preEnd, index+1, inEnd);
    root.left = left;
    root.right = right;

    return root;
}    
</code></pre><p>This method can be improved by using HashMap to make it faster when fiding the index of root.<br>Reference:<a href="http://blog.csdn.net/linhuanmars/article/details/24389549" target="_blank" rel="external">http://blog.csdn.net/linhuanmars/article/details/24389549</a><br>Code:</p>
<pre><code>static HashMap&lt;Integer, Integer&gt; map = new HashMap&lt;Integer, Integer&gt;();
public TreeNode buildTree(int[] preorder, int[] inorder) {
    int l = preorder.length;
    if (l == 0)
        return null;
    for (int i = 0; i &lt; l; i++)
        map.put(inorder[i], i);

    return dp(preorder, inorder, 0, l-1, 0, l-1);
}

private TreeNode dp(int[] preorder, int[] inorder, int preStart, int preEnd, int inStart, int inEnd){
    if (preStart &gt; preEnd || inStart &gt; inEnd)
        return null;
    TreeNode root = new TreeNode(preorder[preStart]);

    int index = map.get(preorder[preStart]);

    TreeNode left = dp(preorder, inorder, preStart+1, preStart+index-inStart, inStart, index-1);
    TreeNode right = dp(preorder, inorder,preStart+index-inStart+1, preEnd, index+1, inEnd);
    root.left = left;
    root.right = right;

    return root;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Pow(x, n)(Java)]]></title>
      <url>http://yoursite.com/2016/01/26/Leetcode-Pow-x-n-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Implement pow(x, n).</p>
<p><strong>Thinking:</strong></p>
<p>It’s a simple but not simple question. There are many solutions for this problem. But how can we find the most effienct one. We can use recursion to reduce the times of multipling and check the bound of data to reduce the times of recursions. Finally, the code is below:</p>
<pre><code>static boolean negflag = false;
public double myPow(double x, int n) {
    if (n &lt; 0){
        negflag = true;
        return 1 / dp(x, -n);
    }
    else
        return dp(x, n);

}
private double dp(double x, int n){
    if (n == 0)
        return 1;
    if (n == 1)
        return x;
    if (n == 2)
        return x * x;

    int m = n / 2;
    int k = n % 2;
    double v = dp(x, m);
    if (negflag == true &amp;&amp; v &gt; 100000)
        return 100000;
    if (negflag == false &amp;&amp; v &lt; 0.00001)
        return 0;

    if (k == 0)
        return v * v;
    else
        return v * v * x;
}
</code></pre><p>By the way, I have to metion that my python solution is like, lol:</p>
<pre><code>def myPow(self, x, n):
    return x**n
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Jump Game(Java)]]></title>
      <url>http://yoursite.com/2016/01/26/Leetcode-Jump-Game-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an array of non-negative integers, you are initially positioned at the first index of the array.</p>
<p>Each element in the array represents your maximum jump length at that position.</p>
<p>Determine if you are able to reach the last index.</p>
<p>For example:<br>A = [2,3,1,1,4], return true.</p>
<p>A = [3,2,1,0,4], return false.</p>
<p><strong>Thinking:</strong></p>
<p>It’s a problem can be solved in greedy algorithm. Because we should go as far as possible in current position until we can’t go father. And we should gurantee the value of current position + i (steps can be reached from current postion) + nums[cur + i] be as big as possible.</p>
<p><strong>Solution:</strong></p>
<pre><code>public boolean canJump(int[] nums) {
    int l = nums.length;
    if (nums[0] == 0 &amp;&amp; l &gt; 1)
        return false;
    int cur = 0;
    int temp = nums[0];
    int step = nums[0];
    int max = nums[0];
    int tempcur = 0;

    while (cur + step &lt; l-1){
        for (int i = 1; i &lt;= step; i++){
            temp = cur + i + nums[cur + i];
            if (temp &gt;= max){//current max greedy value
                max = temp;
                if (max &gt;= l)
                    return true;
                tempcur = cur + i;
            }
        }
        if (cur == tempcur)
            return false;
        cur = tempcur;
        step = nums[cur];
    }

    if (max &gt;= l-1)
        return true;
    else
        return false;
}
</code></pre><p>What’s more, we can make it easier by max the value of index. </p>
<pre><code>public boolean canJump(int[] nums) {
    if(nums.length &lt;= 1)
        return true;

    int max = nums[0]; //max stands for the largest index that can be reached.

    for(int i=0; i&lt;nums.length; i++){
        //if not enough to go to next
        if(max &lt;= i &amp;&amp; nums[i] == 0) 
            return false;

        //update max    
        if(i + nums[i] &gt; max){
            max = i + nums[i];
        }

        //max is enough to reach the end
        if(max &gt;= nums.length-1) 
            return true;
    }

    return false;    
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-3Sum Closest(Java)]]></title>
      <url>http://yoursite.com/2016/01/26/Leetcode-3Sum-Closest-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.</p>
<p>For example, given array S = {-1 2 1 -4}, and target = 1.</p>
<p>The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).</p>
<p><strong>Thinking:</strong></p>
<p>In order to improve the performance of algorithm, we should sort the array. Because of that, we can determine where to go using current result.</p>
<p><strong>Solution:</strong></p>
<pre><code>public int threeSumClosest(int[] nums, int target) {
    int l = nums.length;
    if (l &lt; 3)
        return 0;
    int min = Integer.MAX_VALUE;
    int res = 0;
    Arrays.sort(nums);

    for (int i = 0; i &lt; l; i++){
        int j = i + 1;
        int k = l - 1;

        while (j &lt; k){
            int sum = nums[i] + nums[j] + nums[k];
            if (sum == target)
                return sum;
            int diff = Math.abs(sum - target);
            if (diff &lt; min){
                min = diff;
                res = sum;
            }
            if (sum &gt; target)
                k--;
            else
                j++;
        }

    }
    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Construct Binary Tree from Inorder and Postorder Traversal(Java)]]></title>
      <url>http://yoursite.com/2016/01/26/Leetcode-Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given inorder and postorder traversal of a tree, construct the binary tree.</p>
<p>Note:<br>You may assume that duplicates do not exist in the tree.</p>
<p><strong>Thinking:</strong></p>
<p>Inorder traversal will search in order: left, root, right;</p>
<p>Postorder travelsal will search in order: left, right, root.</p>
<p>So we can find the root in postorder and search it in inorder by the value. And find root’s left child and right child node by recursion.</p>
<pre><code>public TreeNode buildTree(int[] inorder, int[] postorder) {
    int l = inorder.length;
    if (l == 0)
        return null;
    TreeNode root = new TreeNode(postorder[l-1]);
    TreeNode left = null;
    TreeNode right = null;
    int index = 0;
    for (; index &lt; l; index++){
        if (inorder[index] == postorder[l-1])
            break;
    }


    if (index &gt; 0){
        int[] leftinorder = new int[index];
        int[] leftpostorder = new int[index];
        System.arraycopy(inorder, 0, leftinorder, 0, index);
        System.arraycopy(postorder, 0, leftpostorder, 0, index);
        left = buildTree(leftinorder, leftpostorder);
    }
    if (index &lt; l-1){
        int[] rightinorder = new int[l-index-1];
        int[] rightpostorder = new int[l-index-1];
        System.arraycopy(inorder, index+1, rightinorder, 0, l-index-1);
        System.arraycopy(postorder, index, rightpostorder, 0, l-index-1);
        right = buildTree(rightinorder, rightpostorder);
    }
    root.left = left;
    root.right = right;

    return root;
}
</code></pre><p>By the way, this code can be improved because in Java we can not easily get the subarray and I use the System.arraycopy. It can be replaced by recording the postion of array.</p>
]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Lowest Common Ancestor of a Binary Tree(Java)]]></title>
      <url>http://yoursite.com/2016/01/26/Leetcode-Lowest-Common-Ancestor-of-a-Binary-Tree-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p>
<p>According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”</p>
<pre><code>           _______3______
         /              \
  ___5__           ___1___
    /      \         /          \
6        2       0         8
         /  \
        7    4
</code></pre><p>For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.</p>
<p><strong>Thinking:</strong></p>
<p>The point to find the lowest common ancestor is to find a node whose left and right childs both have the node we want to find. Because if it’s not the lowest, the node will only belong to one of their child. If search in a pre-order from the root, if one node’s left child and right child both have the keynode or if the node itself is one of the keynode which means the other node will in lower level of this node, it’s the answer we want.</p>
<p><strong>Solution:</strong></p>
<pre><code>public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if (root == null)
        return root;

    if (root.equals(q) || root.equals(p)){
        return root;
    }

    TreeNode l = lowestCommonAncestor(root.left, p, q);
    TreeNode r = lowestCommonAncestor(root.right, p, q);
    if (l != null &amp;&amp; r != null)
        return root;

    return l == null? r: l;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Node.js study note]]></title>
      <url>http://yoursite.com/2016/01/25/Node-js-study-note/</url>
      <content type="html"><![CDATA[<p><strong>Survey:</strong></p>
<p>Node.js is an open-source, cross-platform runtime environment for developing server-side Web applications. Node.js is not a JavaScript framework,[3] but its applications are written in JavaScript and can be run within the Node.js runtime on a wide variety of platforms.</p>
<p>This is my first time to learn Node.js, and I’ll write casully about the process and experience of learning.</p>
<hr>
<p><strong>Content:</strong></p>
<p>–1– Argument variables with process.argv</p>
<pre><code>app.js

function grab(flag){
    var index = process.argv.indexOf(flag);
    return (index === -1) ? null : process.argv[index+1];
}

var greeting = grab(&apos;--greeting&apos;);
var user = grab(&apos;--user&apos;);

if (!user || !greeting) {
    console.log(&quot;You blew it!&quot;);
} else {
    console.log(`Welcome, ${user}, ${greeting}`);
}
</code></pre><p>In this code, we grab the arguments from shell and print it out on the console.</p>
<p>For example, if in the shell:</p>
<pre><code>$node app --user Martin --greeting &quot;hello hello&quot;
</code></pre><p>Then in the console:</p>
<pre><code>Welcome, Martin, hello hello
</code></pre><p>And in this code, I also learned string temple which uses backticks<code>.</code>Welcome, ${user}, ${greeting}` will contain variable user and greeting.</p>
<hr>
<p>–2– Standard input and standard output</p>
<pre><code> var questions = [
&quot;What is your name?&quot;,
&quot;What is your favorite hobby?&quot;,
&quot;What is your preferred programming language?&quot;
];

var answers = [];

function ask(i) {
    process.stdout.write(`\n\n\n\n ${questions[i]}`);
    process.stdout.write(&quot;  &gt;  &quot;);
}

process.stdin.on(&apos;data&apos;, function(data){

    answers.push(data.toString().trim());

    if (answers.length &lt; questions.length) {
        ask(answers.length);
    } else {
        process.exit();
    }
});

process.on(&apos;exit&apos;, function(){

    process.stdout.write(&quot;\n\n\n\n&quot;);

    process.stdout.write(`Go ${answers[1]} ${answers[0]} you can finish writing ${answers[2]} later`);

    process.stdout.write(&quot;\n\n\n\n&quot;);

});

ask(0);
</code></pre><p>In the shell:</p>
<pre><code>What is your name?  &gt;  Martin




 What is your favorite hobby?  &gt;  play games




 What is your preferred programming language?  &gt;  python




Go play games Martin you can finish writing python later
</code></pre><p>Is that funny:)?</p>
<hr>
<p>–3– Global timing functions</p>
<p>There are several functions about the timing such as setInterval, setTimeout and clearInterval. It’s useful while developing web interactive program. </p>
<p>Code:</p>
<pre><code>var waitTime = 3000;
var currentTime = 0;
var waitInterval = 10;
var percentWaited = 0;

function writeWaitingPercent(p){
    process.stdout.clearLine();
    process.stdout.cursorTo(0);
    process.stdout.write(`waiting ... ${p}%`);

}


var interval = setInterval(function(){
    currentTime += waitInterval;
    percentWaited = Math.floor((currentTime/    waitTime)*100);
    //console.log(`waiting ${currentTime/1000} seconds`);
    writeWaitingPercent(percentWaited);
}, waitInterval);

setTimeout(function(){

    clearInterval(interval);
    console.log(&quot;\ndone&quot;);
}, waitTime);

process.stdout.write(&quot;\n\n&quot;);
writeWaitingPercent(percentWaited);
</code></pre><p>In the shell:</p>
<pre><code>waiting ... 81%
done
</code></pre><p>–4– Core modules:</p>
<p>Node.js use require function to get modules. This section is going to show some modules of Node.js.</p>
<p>Code:</p>
<pre><code>var path = require(&apos;path&apos;);
var util = require(&apos;util&apos;);
var v8 = require(&apos;v8&apos;)


util.log( path.basename(__filename) );

var dirUploads = path.join(__dirname, &apos;www&apos;, &apos;fileds&apos;, &apos;uploads&apos;);

util.log(dirUploads);

util.log(v8.getHeapStatistics());
</code></pre><p>In the shell:</p>
<pre><code>node core
28 Jan 23:34:37 - core.js
28 Jan 23:34:37 - /Users/Martin/Documents/martin/    Study/Node/www/fileds/uploads
28 Jan 23:34:37 - { total_heap_size: 7523616,
  total_heap_size_executable: 5242880,
  total_physical_size: 7523616,
  total_available_size: 1491271696,
  used_heap_size: 4094992,
  heap_size_limit: 1535115264 }
</code></pre><p>–5– Collecting information with Readline</p>
<p>Realine is a module of Node.js, it should get the input stream and output stream. Then you can use the API to operate the input and output such as setPrompt, prompt, on and etc. A string in the string can be replaced as s% like in the C, and the JSON string will be replaced as j%.</p>
<p>Code:</p>
<pre><code>var readline = require(&apos;readline&apos;);

var rl = readline.createInterface(process.stdin, process.stdout);

var realPerson = {
    name: &apos;&apos;,
    sayings: []
};

rl.question(&quot;What is the name of a real person?&quot;, function(answer){

    realPerson.name = answer;

    rl.setPrompt(`What would ${realPerson.name} say? `);

    rl.prompt();

    rl.on(&apos;line&apos;, function(sayings){

        realPerson.sayings.push(sayings.trim());

        if (sayings.toLowerCase().trim() == &apos;exit&apos;){
            rl.close();
        }
        else{
        rl.setPrompt(`What else would ${realPerson.name} say? (&apos;exit&apos; to leave)`);
        rl.prompt();
        }
    });

});

rl.on(&apos;close&apos;, function(){
     console.log(&quot;%s is a real person that says j%&quot;,     realPerson.name, realPerson.sayings);
})
</code></pre><p>In the shell:</p>
<pre><code>What is the name of a real person?Martin
What would Martin say? haha
What else would Martin say? (&apos;exit&apos; to leave)heihei
What else would Martin say? (&apos;exit&apos; to leave)exit
Martin is a real person that says j% [ &apos;haha&apos;, &apos;heihei&apos;, &apos;exit&apos; ]
</code></pre><p>–6– Handling events with EventEmitter</p>
<p>There are two modules I have learned from this class. One is event and the other is util. Event has two functions which called on and emit. The fucntion on is for naming the event, and the function emit is for triggling the event. The module util is for inheriting from other class.</p>
<p>Code:</p>
<pre><code>var events = require(&apos;events&apos;);

var emitter = new events.EventEmitter();

emitter.on(&apos;customEvent&apos;, function(message, status){

    console.log(`${status}: ${message}`);

});

emitter.emit(&apos;customEvent&apos;, &quot;Hellow World&quot;, 200);
</code></pre><p>And</p>
<pre><code>node BenFranklin.js 
Ben Franklin: You may delay, but time will not.
</code></pre><p>–7–Exporting custom modules</p>
<p>In this class, I learned that in one js file, we can conclude a export sentence to export a file to become a module. For example, “module.exports = Person;”</p>
<p>Code:</p>
<pre><code>var EventEmitter = require(&apos;events&apos;).EventEmitter;
var util = require(&apos;util&apos;);

var Person = function(name) {
    this.name = name;
};

util.inherits(Person, EventEmitter);

module.exports = Person;
</code></pre><p>–8–Creating child process with exec</p>
<p>In this class, I learned the module called child_process. And it has a function called exec which is aiming at execute the command in the command line.</p>
<p>Code:</p>
<pre><code>var exec = require(&quot;child_process&quot;).exec;

exec(&quot;ls&quot;, function(err, stdout){

    if (err){
        throw err;
    }

    console.log(&quot;Listing Finished&quot;);

    console.log(stdout);

});
</code></pre><p>–9–Creating child process with spawn</p>
<p>Spawn can deal with the situation that you want run serval commands or deal with the stdout and stdin.</p>
<p>Code:</p>
<pre><code>var spawn = require(&quot;child_process&quot;).spawn;

var cp = spawn(&quot;node&quot;, [&quot;alwaysTalking&quot;]);

cp.stdout.on(&quot;data&quot;, function(data){
    console.log(`STDOUT: ${data.toString()}`);
});

cp.on(&quot;close&quot;, function() {

    console.log(&quot;Child Process has ended&quot;);

    process.exit();

});

setTimeout(function () {

    cp.stdin.write(&quot;stop&quot;);

}, 4000);
</code></pre><p>–10–Listing directory files</p>
<p>What’s the differences between synchronously and asynchronously:</p>
<p>When you execute something synchronously, you wait for it to finish before moving on to another task. When you execute something asynchronously, you can move on to another task before it finishes.</p>
<p>That being, said, in the context of computers this translates into executing a process or task on another “thread.” A thread is a series of commands–a block of code–that exists as a unit of work. The operating system can manage multiple threads and assign a thread a piece (“slice”) of processor time before switching to another thread to give it a turn to do some work. At its core (pardon the pun), a processor can simply execute a command–it has no concept of doing two things at one time. The operating system simulates this by allocating slices of time to different threads.</p>
<p>Now, if you introduce multiple cores/processors into the mix, then things CAN actually happen at the same time. The operating system can allocate time to one thread on the first processor, then allocate the same block of time to another thread on a different processor.</p>
<p>All of this is about allowing the operating system to manage the completion of your task while you can go on in your code and do other things.</p>
<p>Reference: <a href="http://stackoverflow.com/questions/748175/asynchronous-vs-synchronous-execution-what-does-it-really-mean" target="_blank" rel="external">http://stackoverflow.com/questions/748175/asynchronous-vs-synchronous-execution-what-does-it-really-mean</a></p>
<p>In this section, I learned read files synchronously or asynchronously.</p>
<p>Code: </p>
<pre><code>var fs = require(&quot;fs&quot;);

fs.readdir(&apos;./lib&apos;, function(err, files){
    if(err){
        throw err;
    }
    console.log(files);
});

console.log(&quot;Reading Files...&quot;);
</code></pre><p>–11–Reading files</p>
<p>Code:</p>
<pre><code>var fs = require(&quot;fs&quot;);

fs.readFile(&quot;./lib/saying.md&quot;, &quot;UTF-8&quot;, function(err, contents){

    if (err) {
        throw err;
    }

    console.log(contents);
});
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Insertion Sort List(Java)]]></title>
      <url>http://yoursite.com/2016/01/24/Leetcode-Insertion-Sort-List-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Sort a linked list using insertion sort.</p>
<p><strong>Thinking:</strong></p>
<p>As the question state, we should apply the insertion sort method to linked list. So we create a ListNode for hold the sorted list, and scan the unsorted list and pick up element to compare the element in the sorted list. Then determine when to insert the value.</p>
<p><strong>Solution:</strong></p>
<pre><code>public class Solution {
    public ListNode insertionSortList(ListNode head) {
        if (head == null || head.next == null)
            return head;
        ListNode res = new ListNode(-1);
        res.next = head;
        ListNode p = res;
        ListNode next = head.next;
        head.next = null;
        head = next;
        while (head != null){
            while (p.next != null){
                //if the value is smaller than one of the sorted list, insert behind it
                if (head.val &lt; p.next.val){
                    next = head.next;
                    head.next = p.next;
                    p.next = head;
                    head = next;
                    p = res;
                    break;
                }
                p = p.next;
            }
            //if the value is bigger than anyone of the sorted list, insert after the whole list
            if (p.next == null){
                next = head.next;
                p.next = head;
                head.next = null;
                head = next;
                p = res;
            }
        }

        return res.next;
    }
}
</code></pre><p>I also copy a refining version of this algorithm from reference: <a href="http://www.cnblogs.com/springfor/p/3862468.html" target="_blank" rel="external">http://www.cnblogs.com/springfor/p/3862468.html</a></p>
<pre><code>public ListNode insertionSortList(ListNode head) {  
    if(head == null||head.next == null)  
        return head;  
    ListNode sortedlisthead = new ListNode(0);  
    ListNode cur = head;
    while(cur!=null){  
        ListNode next = cur.next;  
        ListNode pre = sortedlisthead;  
        while(pre.next!=null &amp;&amp; pre.next.val&lt;cur.val)  
            pre = pre.next;  
        cur.next = pre.next;  
        pre.next = cur;  
        cur = next;  
    }  
    return sortedlisthead.next;  
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Sort Algorithms]]></title>
      <url>http://yoursite.com/2016/01/24/Sort-Algorithms/</url>
      <content type="html"><![CDATA[<h2 id="Survey_3A"><a href="#Survey_3A" class="headerlink" title="Survey:"></a>Survey:</h2><p>This time, we talk about eight kinds of sort algorithms: insertion sort, shell’s sort, simple selection sort, heap sort, bubble sort, quick sort, merge sort and radix sort.</p>
<h2 id="Insertion_sort_3A"><a href="#Insertion_sort_3A" class="headerlink" title="Insertion sort:"></a>Insertion sort:</h2><p><strong>Main Idea:</strong></p>
<p>From the beginning of the list, get one value at a time and insert the value into right position of sorted list until all the values are sorted. And insertion sort is stalbe.</p>
<p><strong>Process:</strong> (From Wikimedia)</p>
<p><img src="https://upload.wikimedia.org/wikipedia/commons/4/42/Insertion_sort.gif" alt=""></p>
<p><strong>Pseudocode:</strong></p>
<pre><code>for i ← 1 to length(A) - 1
    j ← i
    while j &gt; 0 and A[j-1] &gt; A[j]
        swap A[j] and A[j-1]
        j ← j - 1
    end while
end for
</code></pre><p><strong>Implemention in Java:</strong></p>
<pre><code>public static void InsertionSort(int[] num)
{
     int j;
     int key;
     int i;  

     for (j = 1; j &lt; num.length; j++){
        key = num[j];
        for(i = j - 1; (i &gt;= 0) &amp;&amp; (num[i] &lt; key); i--){
            num[i+1] = num[i];
        }
        num[i+1] = key;
    }
}
</code></pre><p><strong>Complexity:</strong></p>
<p><em>Runtime</em>: O(n^2)</p>
<p><em>Memery</em>: O(1)</p>
<hr>
<h2 id="ShellSort_3A"><a href="#ShellSort_3A" class="headerlink" title="ShellSort:"></a>ShellSort:</h2><p><strong>Main Idea:</strong></p>
<p>The method starts by sorting pairs of elements far apart from each other, then progressively reducing the gap between elements to be compared. Starting with far apart elements can move some out-of-place elements into position faster than a simple nearest neighbor exchange.</p>
<p><strong>Process:</strong>(From Wikimedia)</p>
<p><img src="https://upload.wikimedia.org/wikipedia/commons/d/d8/Sorting_shellsort_anim.gif" alt=""></p>
<p><strong>Pesedocode:</strong></p>
<pre><code>gaps = [701, 301, 132, 57, 23, 10, 4, 1]

foreach (gap in gaps)
{
    # Do a gapped insertion sort for this gap size.
    # The first gap elements a[0..gap-1] are already in gapped order
    # keep adding one more element until the entire array is gap sorted
    for (i = gap; i &lt; n; i += 1)
    {
        # add a[i] to the elements that have been gap sorted
        # save a[i] in temp and make a hole at position i
        temp = a[i]
        # shift earlier gap-sorted elements up until the correct location for a[i] is found
        for (j = i; j &gt;= gap and a[j - gap] &gt; temp; j -= gap)
        {
            a[j] = a[j - gap]
        }
        # put temp (the original a[i]) in its correct location
        a[j] = temp
        }
    }
</code></pre><p> <strong>Implemention in Java:</strong></p>
<pre><code>public void shellSort() {
    int inner, outer;
    long temp;
    //find initial value of h
    int h = 1;
    while (h &lt;= len / 3)
      h = h * 3 + 1; // (1, 4, 13, 40, 121, ...)

    while (h &gt; 0) // decreasing h, until h=1
    {
      // h-sort the file
      for (outer = h; outer &lt; len; outer++) {
        temp = data[outer];
        inner = outer;
        // one subpass (eg 0, 4, 8)
        while (inner &gt; h - 1 &amp;&amp; data[inner - h] &gt;= temp) {
          data[inner] = data[inner - h];
          inner -= h;
        }
        data[inner] = temp;
      }
      h = (h - 1) / 3; // decrease h
    }
}
</code></pre><hr>
<h2 id="Simple_Selection_Sort"><a href="#Simple_Selection_Sort" class="headerlink" title="Simple Selection Sort"></a>Simple Selection Sort</h2><p><strong>Main Idea:</strong></p>
<p>Find the smallest(biggest) element in array, put it in the first place. Then find the second smallest… Do these until all the element are sorted.(I suppose it’s a little similar with bubble sort)</p>
<p><strong>Process:</strong>(From Wikimedia)</p>
<p><img src="https://upload.wikimedia.org/wikipedia/commons/4/42/Insertion_sort.gif" alt=""></p>
<p><strong>Pesedocode:</strong></p>
<pre><code>for i ← 1 to length(A) - 1
    j ← i
    while j &gt; 0 and A[j-1] &gt; A[j]
        swap A[j] and A[j-1]
        j ← j - 1
    end while
end for
</code></pre><p><strong>Complexity:</strong></p>
<p><em>Runtime:</em> O(n^2)<br><em>Memery:</em> O(1)</p>
<h2 id="Heapsort"><a href="#Heapsort" class="headerlink" title="Heapsort"></a>Heapsort</h2><p><strong>Main Idea:</strong></p>
<p>Use data structure heap which will store the smallest or biggest value of the array. Then pick up the root of heap   once a time to sort. </p>
<p>Heapsort is a comparison-based sorting algorithm. Heapsort can be thought of as an improved selection sort: like that algorithm, it divides its input into a sorted and an unsorted region, and it iteratively shrinks the unsorted region by extracting the largest element and moving that to the sorted region. The improvement consists of the use of a heap data structure rather than a linear-time search to find the maximum.</p>
<p>This sort is the most important part in this article. I’ll talk about the relative operation and its performance and all the code.</p>
<p><strong>Process:</strong>(From Wikimedia)</p>
<p><img src="https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif" alt=""></p>
<p>In the heap view(an example offered):</p>
<p><img src="https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif" alt=""></p>
<p><strong>Data Structure:</strong></p>
<p>Heap:</p>
<p>A heap is built out of the data. The heap is often placed in an array with the layout of a complete binary tree. The complete binary tree maps the binary tree structure into the array indices; each array index represents a node; the index of the node’s parent, left child branch, or right child branch are simple expressions. For a zero-based array, the root node is stored at index 0; if i is the index of the current node, then</p>
<pre><code>iParent(i)     = floor((i-1) / 2)
iLeftChild(i)  = 2*i + 1
iRightChild(i) = 2*i + 2
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Search for a Range(Java)]]></title>
      <url>http://yoursite.com/2016/01/24/Leetcode-Search-for-a-Range-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a sorted array of integers, find the starting and ending position of a given target value.</p>
<p>Your algorithm’s runtime complexity must be in the order of O(log n).</p>
<p>If the target is not found in the array, return [-1, -1].</p>
<p>For example,<br>Given [5, 7, 7, 8, 8, 10] and target value 8,<br>return [3, 4].</p>
<p><strong>Thinking:</strong></p>
<p>It’s question which should use binary search because it give us a sorted array and it requires O(log n) runtime complexity. Only thing difference between this algorithm and classical binary search is that we should make the range smaller while finding the target instead of returning the index.</p>
<p><strong>Solution:</strong></p>
<pre><code>public class Solution {
    public int[] searchRange(int[] nums, int target) {
        int low = 0;
        int high = nums.length - 1;
        int mid;
        int resl = -1;
        int resr = -1;
        while (low &lt;= high){
            mid = (low + high) / 2;
            if (nums[mid] == target){
                if (nums[low] == target){
                    resl = low;
                    if (resr != -1)
                        break;
                }    
                else
                    low++;

                if (nums[high] == target){
                    resr = high;
                    if (resl != -1)
                        break;
                }
                else
                    high--;
            }
            else if(nums[mid] &gt; target)
                high = mid - 1;
            else
                low = mid + 1;
        }
        int[] res = {resl, resr};
        return res;
    }

}
</code></pre><p>But the algorithm is not so effienct when finding the target so early. In order to make sure the runtime complexity is O(log n), we should also use binary search to find the lower bound and upper bound when finding the target in the array.<br>Reference: <a href="http://www.cnblogs.com/springfor/p/3857704.html" target="_blank" rel="external">http://www.cnblogs.com/springfor/p/3857704.html</a></p>
<p>Code:</p>
<pre><code>public int[] searchRange(int[] A, int target) {
    int [] res = {-1,-1};
    if(A == null || A.length == 0)
        return res;

    //first iteration, find target wherever it is
    int low = 0;
    int high = A.length-1;
    int pos = 0;
    while(low &lt;= high){
        int mid = (low + high)/2;
        pos = mid;
        if(A[mid] &gt; target)
            high = mid - 1;
        else if(A[mid] &lt; target)
            low = mid + 1;
        else{
            res[0] = pos;
            res[1] = pos;
            break;
        }
    }

    if(A[pos] != target)
        return res;

    //second iteration, find the right boundary of this target
    int newlow = pos;
    int newhigh = A.length-1;
    while(newlow &lt;= newhigh){
        int newmid = (newlow+newhigh)/2;
        if(A[newmid] == target)
            newlow = newmid + 1;
        else
            newhigh = newmid - 1;
    }
    res[1] = newhigh;

    //third iteration, find the left boundary of this target
    newlow = 0;
    newhigh = pos;
    while(newlow &lt;= newhigh){
        int newmid = (newlow+newhigh)/2;
        if(A[newmid] == target)
            newhigh = newmid - 1;
        else
            newlow = newmid + 1;
    }
    res[0] = newlow;

    return res;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Partition List(Java)]]></title>
      <url>http://yoursite.com/2016/01/24/Leetcode-Partition-List/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.</p>
<p>You should preserve the original relative order of the nodes in each of the two partitions.</p>
<p>For example,<br>Given 1-&gt;4-&gt;3-&gt;2-&gt;5-&gt;2 and x = 3,<br>return 1-&gt;2-&gt;2-&gt;4-&gt;3-&gt;5.</p>
<p><strong>Thinking:</strong></p>
<p>We should preserve the original relative order of the nodes. So we need two points, one is for recording where to insert the less value node, and the other is for searching the less value node.</p>
<p><strong>Solution1:</strong></p>
<pre><code>public class Solution {
    public ListNode partition(ListNode head, int x) {
        if (head == null)
            return null;
        ListNode prehead = new ListNode(0);
        prehead.next = head;
        ListNode s = prehead;
        ListNode l = prehead;
        while(s != null &amp;&amp; l != null){
            while(s.next != null){
                if (s.next.val &gt;= x)
                    break;
                s = s.next;
            }
            l = s.next;
            if (l == null)
                break;
            while(l.next != null){
                if (l.next.val &lt; x)
                    break;
                l = l.next;
            }
            if (l.next == null)
                break;
            ListNode tmp = l.next;
            l.next = l.next.next;
            tmp.next = s.next;
            s.next = tmp;
        }

        return prehead.next;
    }

}
</code></pre><p>And there is another solution, which uses two lists. One is for recording less value node, and the other is for recording greater value node. And connect them:</p>
<pre><code>public ListNode partition(ListNode head, int x) {
        if(head==null||head.next==null)
            return head;

        ListNode small = new ListNode(-1);
        ListNode newsmallhead = small;
        ListNode big = new ListNode(-1);
        ListNode newbighead = big;

        while(head!=null){
            if(head.val&lt;x){
                small.next = head;
                small = small.next;
            }else{
                big.next = head;
                big = big.next;
            }
            head = head.next;
        }
        big.next = null;

        small.next = newbighead.next;

        return newsmallhead.next;
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Unique Paths II(Java)]]></title>
      <url>http://yoursite.com/2016/01/24/Leetcode-Unique-Paths-II-Java/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Follow up for “Unique Paths”:</p>
<p>Now consider if some obstacles are added to the grids. How many unique paths would there be?</p>
<p>An obstacle and empty space is marked as 1 and 0 respectively in the grid.</p>
<p>For example,<br>There is one obstacle in the middle of a 3x3 grid as illustrated below.</p>
<pre><code>[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
</code></pre><p>The total number of unique paths is 2.</p>
<p>Note: m and n will be at most 100.</p>
<p><strong>Thinking:</strong></p>
<p>This question is similar with Unique Paths, and it’s the same methed to use dynamic programming. Only one difference is that we should check if it’s a obstacle. And if it’s a obstacle, its value of dp should be 0.</p>
<p><strong>Solution:</strong></p>
<pre><code>public class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int lr = obstacleGrid.length;
        if (lr == 0)
            return 0;
        int lc = obstacleGrid[0].length;
        int[][] dp = new int[lr][lc];
        if (obstacleGrid[0][0] == 1){
            return 0;
        }
        dp[0][0] = 1;

        for (int i = 1; i &lt; lr; i++){
            if (obstacleGrid[i][0] == 1)
                break;
            dp[i][0] = 1;
        }
        for (int i = 1; i &lt; lc; i++){
            if (obstacleGrid[0][i] == 1)
                break;
            dp[0][i] = 1;
        }

        for (int i = 1; i &lt; lr; i++)
            for (int j = 1; j &lt; lc; j++){
                if(obstacleGrid[i][j] == 1)
                    continue;
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }

        return dp[lr-1][lc-1];
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Unique Binary Search Trees II(Java)]]></title>
      <url>http://yoursite.com/2016/01/24/Unique-Binary-Search-Trees-II/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given n, generate all structurally unique BST’s (binary search trees) that store values 1…n.</p>
<p>For example,<br>Given n = 3, your program should return all 5 unique BST’s shown below.</p>
<pre><code>1         3     3      2      1
 \       /     /      / \      \
  3     2     1      1   3      2
 /     /       \                 \
2     1         2                 3
</code></pre><p><strong>Thinking:</strong> </p>
<p>It’s a simple dynamic programming question. For n numbers, we should consider the situation that every one become the root, and delete it from the sets and do the same thing for their children.</p>
<p><strong>Solution:</strong></p>
<pre><code>public class Solution {
    public List&lt;TreeNode&gt; generateTrees(int n) {
        return dp(1, n);
    }

    public List&lt;TreeNode&gt; dp(int low, int high){
        List&lt;TreeNode&gt; res = new ArrayList&lt;TreeNode&gt;();
        if (low == high){
            TreeNode n = new TreeNode(low);
            res.add(n);
            return res;
        }
        for (int i = low; i &lt;= high; i++){
            TreeNode n = new TreeNode(i);
            if (i == low){
                for (TreeNode p: dp(low+1, high)){
                    n.right = p;
                    res.add(n);
                    n = new TreeNode(i);
                }
            }
            else if (i == high){
                for (TreeNode p: dp(low, high-1)){
                    n.left = p;
                    res.add(n);
                    n = new TreeNode(i);
                }
            }
            else{
                for (TreeNode p: dp(low, i-1)){
                    for (TreeNode q: dp(i+1, high)){
                        n.left = p;
                        n.right = q;
                        res.add(n);
                        n = new TreeNode(i);
                    }
                }
            }
        }

        return res;
    }
}
</code></pre>]]></content>
    </entry>
    
    <entry>
      <title><![CDATA[Leetcode-Bitwise AND of Numbers Range(Java)]]></title>
      <url>http://yoursite.com/2016/01/24/Leetcode-Bitwise-AND-of-Numbers-Range/</url>
      <content type="html"><![CDATA[<p><strong>Question:</strong></p>
<p>Given a range [m, n] where 0 &lt;= m &lt;= n &lt;= 2147483647, return the bitwise AND of all numbers in this range, inclusive.</p>
<p>For example, given the range [5, 7], you should return 4.</p>
<p><strong>Thinking:</strong></p>
<p>It’s bitwise operation question. Some other questions like are Single Number, Single Number II, Reverse Bits, Repeated DNA Sequences, Grey Code and so on and so forth. This question’s point is to find all the numbers between the range and use the bitwise AND on them. </p>
<p>For example, in the range of [5, 7], there are three numbers:<br>101        110        111<br>Result of thier bitwise is 100. </p>
<p>What’s more, in the example of [26, 30]:<br>11010        11011        11100        11101        11110<br>The result is 11000.</p>
<p><em>Because bits are incresing from the right</em> (low digits), the left of all the numbers are not going to change in the process. The thing we need to do is finding the common part of the left. There are two solutions:</p>
<p><strong>Solution1:</strong></p>
<p>Idea: State a variable and make it all 1 in all digits. Make the variable left shift every time to check if it’s equal between m and n of their bitwise AND. Finally, the result of m bitwise AND with the variable is the answer.<br>Code:</p>
<pre><code>class Solution {
public int rangeBitwiseAnd(int m, int n) {
        int d = Integer.MAX_VALUE;
        while ((m &amp; d) != (n &amp; d)) {
            d &lt;&lt;= 1;
        }
        return m &amp; d;
    }
};
</code></pre><p><strong>Solution2:</strong></p>
<p>Idea:Let m and n make left shift each time if they are different and record the times i they shift. When they are equal, the result of m left shift i is the answer.<br>Code:</p>
<pre><code>class Solution {
public int rangeBitwiseAnd(int m, int n) {
        int i = 0;
        while (m != n) {
            m &gt;&gt;= 1;
            n &gt;&gt;= 1;
            ++i;
        }
        return (m &lt;&lt; i);
    }
};
</code></pre><p>Reference: <a href="http://www.cnblogs.com/grandyang/p/4431646.html" target="_blank" rel="external">http://www.cnblogs.com/grandyang/p/4431646.html</a></p>
]]></content>
    </entry>
    
  
  
</search>