LintCode 1-30;

Difficulty--Naive

463.Sort Integer  整数排序：http://www.lintcode.com/en/problem/sort-integers/#

冒泡排序：(两两比较取出最大的放最后)

(外循环-趟数0,n-1;内循环-有序区的比较次数n-i-1趟;判断a[j] a[j+1])

public class Solution {
    /**
     * @param A an integer array
     * @return void
     */
    public void sortIntegers(int[] a) {
        // Write your code here
        int tmp = 0;
        int size = a.length;
        for (int i = 0; i < size - 1; i++) {
            for (int j = 0; j < size - i - 1; j++){
                if (a[j] > a[j + 1]) {
                    tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                }
            }
        }
    }
}

选择排序：(一趟:从无序区中找到最小的数放到有序区的末尾)

(外循环i 0,n-1;内循环为j=i+1,n; 判断a[i] a[j])

public class Solution {
    /**
     * @param A an integer array
     * @return void
     */
    public void sortIntegers(int[] a) {
        // Write your code here
        int tmp = 0;
        int size = a.length;
        for (int i = 0; i < size - 1; i++) {
            for (int j = i + 1; j < size; j++){
                if (a[i] > a[j]) {
                    tmp = a[j];
                    a[j] = a[i];
                    a[i] = tmp;
                }
            }
        }
    }
}

插入排序：(一次：从无序区中的第一位与有序区序列中从后向前扫描；大于target则向后移，小于则插入该位置)

(外循环i:1-n; tar=a[i]; 内循环j=i,j>0&&tar<a[j-1],j--;  a[j]=a[j-1] ; 循环外a[j]=tar;)

public class Solution {
    /**
     * @param A an integer array
     * @return void
     */
    public void sortIntegers(int[] a) {
        // Write your code here
        int size = a.length;
        int j;
        for (int i = 1; i < size; i++) {
            int tar = a[i];
            for (j = i; j > 0 && tar < a[j - 1]; j--) {
                a[j] = a[j - 1];
            }
            a[j] = tar;
        }
    }
}

366.Fibonacci：http://www.lintcode.com/en/problem/fibonacci/

我的解法：数组（考虑到数组个数的固定，需要讨论0，1情况）

class Solution {
    /**
     * @param n: an integer
     * @return an integer f(n)
     */
    public int fibonacci(int n) {
        // write your code here
        int[] array = new int[n];
        array[0] = 0;
        if (n > 1){
            array[1] = 1;
            if (n > 2) {
                for (int i = 2; i < n; i++) {
                    array[i] = array[i - 1] + array[i - 2];
                }
            }
        }
        return array[n - 1];
    }
}

九章：赋值 移动 

(a,b, for(0,n-1)c=a+b,a,b return a) (n=1时不执行循环,n=2时执行循环，先求出两数之和作为下一位数，再将a,b分别后移一位)

class Solution {
    /**
     * @param n: an integer
     * @return an integer f(n)
     */
    public int fibonacci(int n) {
        int a = 0;
        int b = 1;
        for (int i = 0; i < n - 1; i++) {
            int c = a + b;
            a = b;
            b = c;
        }
        return a;
    }
}

452.Remove Linked List Elements：http://www.lintcode.com/en/problem/remove-linked-list-elements/

从链表中删除元素：(dummy为head的前指针；dummy.next=head; head=dummy 相当于dummy成为新的head,是静态的；然后head开始向后移动；这样整个链表就没有特殊节点了，所有节点都有前指针) [while(!=null) 判断(.val = val; .next=.next.next) else (head = head.next) return dummy.next]

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    /**
     * @param head a ListNode
     * @param val an integer
     * @return a ListNode
     */
    public ListNode removeElements(ListNode head, int val) {
        // Write your code here
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        head = dummy;
        while (head.next != null) {
            if (head.next.val == val){
                head.next = head.next.next;
            } else {
                head = head.next;
            }
        }
        return dummy.next;
    }
}

Difficulty--Easy/Medium

1.A+B Problem:http://www.lintcode.com/en/problem/a-b-problem/#

A+B:(x=x^y, y=(x&y)<<1)

位运算实现整数加法本质就是用二进制进行运算。其主要用了两个基本表达式：

x^y //执行加法，不考虑进位。
(x&y)<<1 //进位操作
令x=x^y ；y=(x&y)<<1 进行迭代，每迭代一次进位操作右面就多一位0，最多需要“加数二进制位长度”次迭代就没有进位了，此时x^y的值就是结果。

我们来做个3位数的加法：
101+011=1000 //正常加法
位运算加法：
（1） 101 ^ 011 = 110
(101 & 011)<<1 = 010
（2） 110 ^ 010 = 100
(110 & 010)<<1 = 100
（3） 100 ^ 100 = 000
(100 & 100)<<1 = 1000
此时进行相加操作就没有进位了，即000 ^ 1000=1000即是最后结果。

class Solution {
    /*
     * param a: The first integer
     * param b: The second integer
     * return: The sum of a and b
     */
    public int aplusb(int a, int b) {
        while(b != 0){
            int carry = a & b;
            a = a ^ b;
            b = carry << 1;
        }
        return a;
    }
}

class Solution {
    /*
     * param a: The first integer
     * param b: The second integer
     * return: The sum of a and b
     */
    public int aplusb(int a, int b) {
        // write your code here, try to do it without arithmetic operators.
        if (b == 0) {
            return a;
        }
        int sum = a ^ b;
        int carry = (a & b) << 1;
        return aplusb(sum, carry);
    }
};

2.Trailing Zeros:http://www.lintcode.com/en/problem/trailing-zeros/

求n!尾零的个数:(n!尾零=n!中质因子5的个数=floor(n/5)+floor(n/25)+……)

(while(n!=0) sum+=n/5;n=n/5)

class Solution {
    /*
     * param n: As desciption
     * return: An integer, denote the number of trailing zeros in n!
     */
    public long trailingZeros(long n) {
        // write your code here
        long sum = 0;
        while (n != 0) {
            sum += n / 5;
            n /= 5;
        }
        return sum;
    }
};

3.Digit Counts:http://www.lintcode.com/en/problem/digit-counts/

计算0-n中含有数字k的个数：(先求出单个数i含有k的个数--(考虑特殊i=0;k=0) while(i!=0)i%10=k,cnt++;i=i/10;  digitCounts=[k,n]求和singleCount)

(singleCount if;while-if(余数)cnt++;i/10;  digitCounts=[k,n]singCount)

class Solution {
    /*
     * param k : As description.
     * param n : As description.
     * return: An integer denote the count of digit k in 1..n
     */
    public int digitCounts(int k, int n) {
        // write your code here
        int cnt = 0;
        for (int i = k; i <= n; i++) {
            cnt += singleCount(i, k);
        }
        return cnt;
    }
    public int singleCount(int i, int k) {
        if (i == 0 && k == 0){
            return 1;
        }
        int cnt = 0;
        while (i > 0){
            if (i % 10 == k) {
                cnt++;
            }
            i /= 10;
        }
        return cnt;
    }
};

4.Ugly Number II：http://www.lintcode.com/en/problem/ugly-number-ii/

求第n个丑数(只含2.3.5因子)：(new ArrayList, uglys.add(1),定义3个指针p2/p3/p5,分别代表指向3个数组中已添加的位置；和uglys的LastNumber比较，<=则指针后移一位；取3个数组所指的min作为uglys.add;注意get(p)指向的是已经添加到uglys中的数;所以代码中用到的都需要是get(p)*2/3/5)

(ArrayList<Integer>(); add(1); for(1-n) lastNumber,while(<=)p++; add(Math.min(Math.min)))

1-n的丑数：1,2,3,4,5,6,8,9,10,12,15…… 可以分为如下3组：

(1)1, 1×2, 2×2, 3×2, 4×2, 5×2, 6×2, 8×2, …
(2)1, 1×3, 2×3, 3×3, 4×3, 5×3, 6×3, 8×3, …
(3)1, 1×5, 2×5, 3×5, 4×5, 5×5, 6×5, 8×5, … 

只需每次添加的数为3组中最小的值

class Solution {
    /**
     * @param n an integer
     * @return the nth prime number as description.
     */
    public int nthUglyNumber(int n) {
        List<Integer> uglys = new ArrayList<Integer>();
        uglys.add(1);
        int p2 = 0, p3 = 0, p5 = 0;
        // p2, p3 & p5 share the same queue: uglys
        for (int i = 1; i < n; i++) {
            int lastNumber = uglys.get(i - 1);
            while (uglys.get(p2) * 2 <= lastNumber) p2++;
            while (uglys.get(p3) * 3 <= lastNumber) p3++;
            while (uglys.get(p5) * 5 <= lastNumber) p5++;
            uglys.add(Math.min(
                Math.min(uglys.get(p2) * 2, uglys.get(p3) * 3),
                uglys.get(p5) * 5
            ));
        }
        return uglys.get(n - 1);
    }
};

5.Kth Largest Element:http://www.lintcode.com/en/problem/kth-largest-element/

第K大的数

LeetCode discuss:https://discuss.leetcode.com/category/223/kth-largest-element-in-an-array

(to do)

 Arrays.sort -- O(nlgn);

class Solution {
    /*
     * @param k : description of k
     * @param nums : array of nums
     * @return: description of return
     */
    public int kthLargestElement(int k, int[] nums) {
        // write your code here
        Arrays.sort(nums);
        return nums[nums.length-k];
    }
};

6.Merge Two Sorted Arrays:http://www.lintcode.com/en/problem/merge-two-sorted-arrays/

合并两个已排数组:(C=[A+B];插入排序思想,A为有序区,B为无序区;)

(for1:c[i]=a[i];  for2:c[i]=b[i-al],tar;  for2.1: j=i,c[j-1]>tar,j-- ; c[j]=tar)

class Solution {
    /**
     * @param A and B: sorted integer array A and B.
     * @return: A new sorted integer array
     */
    public int[] mergeSortedArray(int[] A, int[] B) {
        // Write your code here
        int al = A.length;
        int bl = B.length;
        int[] C = new int[al + bl];
        for (int i = 0; i < al; i++) {
            C[i] = A[i];
        }
        for (int i = al; i < al + bl; i++) {
            C[i] = B[i - al];
            int tar = C[i];
            int j;
            for (j = i; j > 0 && C[j - 1] > tar; j--){
                C[j] = C[j - 1];
            }
            C[j] = tar;
        }
        return C;
    }
}

7.Binary Tree Serialization:http://www.lintcode.com/en/problem/binary-tree-serialization/

二叉树的序列化和反序列化:(to do)

8.Rotate-String:http://www.lintcode.com/en/problem/rotate-string/

根据给定偏移量旋转字符串:

9.Fizz Buzz:http://www.lintcode.com/en/problem/fizz-buzz/

打印1-n，其中整除3的用Fizz代替，整除5的用Buzz代替，整除15的用Fizz Buzz代替；

(ArrayList; 15放在第一个判断;add ; else if; else(String.valueOf(i)));

class Solution {
    /**
     * param n: As description.
     * return: A list of strings.
     */
    public ArrayList<String> fizzBuzz(int n) {
        ArrayList<String> results = new ArrayList<String>();
        for (int i = 1; i <= n; i++) {
            if (i % 15 == 0) {
                results.add("fizz buzz");
            } else if (i % 5 == 0) {
                results.add("buzz");
            } else if (i % 3 == 0) {
                results.add("fizz");
            } else {
                results.add(String.valueOf(i));
            }
        }
        return results;
    }
}

11. Search Range in Binary Search Tree:http://www.lintcode.com/en/problem/search-range-in-binary-search-tree/

找出给定范围的二叉树中的值:(遍历和递归思想;root>k1 那么要递归遍历左树(找出所有大于k1的); k1<=root<=k2,add; root>k2,递归遍历右树)

(result; helper; >k1,k1<=root<=k2,<k2;)

public class Solution {
    private ArrayList<Integer> results;
    /**
     * @param root: The root of the binary search tree.
     * @param k1 and k2: range k1 to k2.
     * @return: Return all keys that k1<=key<=k2 in increasing order.
     */
    public ArrayList<Integer> searchRange(TreeNode root, int k1, int k2) {
        results = new ArrayList<Integer>();
        helper(root, k1, k2);
        return results;
    }
    
    private void helper(TreeNode root, int k1, int k2) {
        if (root == null) {
            return;
        }
        if (root.val > k1) {
            helper(root.left, k1, k2);
        }
        if (root.val >= k1 && root.val <= k2) {
            results.add(root.val);
        }
        if (root.val < k2) {
            helper(root.right, k1, k2);
        }
    }
}

12.Min Stack:http://www.lintcode.com/en/problem/min-stack/

实现栈minStack的push,pop,min功能;要求时间复杂度均为O(1):(建立两个栈分别为stack和minStack,其中stack正常push和pop,而minStack只push进min值,注意：两个栈的大小始终相同！)

(push: stack.push; if(empty) else push min(num,peek);  pop:minStack.pop,return stack.pop;  min:return minStack.peek)

Java Stack类：isEmpty(),peek()查看顶部对象,pop()移除顶部对象并作为返回值返回该对象,push()压入顶部;

public class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;
    
    public MinStack() {
        stack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }

    public void push(int number) {
        stack.push(number);
        if (minStack.isEmpty()) {
            minStack.push(number);
        } else {
            minStack.push(Math.min(number, minStack.peek()));
        }
    }

    public int pop() {
        minStack.pop();
        return stack.pop();
    }

    public int min() {
        return minStack.peek();
    }
}

13.strStr:http://www.lintcode.com/en/problem/strstr/

匹配字符串:(外循环i(0,sl-tl-1); 内循环j(0,tl); if(!=),break; if(j=tar)return i;)

ps:数组array.length属性;字符串String.length()方法;String.charAt(i);

注意：1.String.length()括号; 2.if(==)判断语句，不要漏写=; 3.for循环条件不要漏+1

class Solution {
    /**
     * Returns a index to the first occurrence of target in source,
     * or -1  if target is not part of source.
     * @param source string to be scanned.
     * @param target string containing the sequence of characters to match.
     */
    public int strStr(String source, String target) {
        if (source == null || target == null) {
            return -1;
        }
        
        for (int i = 0; i < source.length() - target.length() + 1; i++) {
            int j = 0;
            for (j = 0; j < target.length(); j++) {
                if (source.charAt(i + j) != target.charAt(j)) {
                    break;
                }
            }
            // finished loop, target found
            if (j == target.length()) {
                return i;
            }
        }
        return -1;
    }
}

14.First Position of Target:http://www.lintcode.com/en/problem/first-position-of-target/

O(logn)查找第一个目标数--二分查找:

[ while判断 start+1<end(表示之间至少有一个数);  mid=start+()/2 ;

if(=tar)end=mid(要找出first 为了防重复需要mid=end继续查找左半查找);  if(<tar)start; if(>tar)end;

if(nums[start]=tar)return start;if()return end; (start)要放在前面判断;]

class Solution {
    /**
     * @param nums: The integer array.
     * @param target: Target to find.
     * @return: The first position of target. Position starts from 0.
     */
    public int binarySearch(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        int start = 0, end = nums.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] == target) {
                end = mid;
            } else if (nums[mid] < target) {
                start = mid;
                // or start = mid + 1
            } else {
                end = mid;
                // or end = mid - 1
            }
        }
        
        if (nums[start] == target) {
            return start;
        }
        if (nums[end] == target) {
            return end;
        }
        return -1;
    }
}

2016.12.9

15.Permutations:http://www.lintcode.com/en/problem/permutations/

返回给定数组的全排列: 

(helper(rst,list,num):判断if(size()=length)add,return; for()if(contain->continue)add,helper,remove;    permute:1.nul;l 2.length==0;  new list,helper,return rst;)

个人对代码流程的理解：

（for循环i=0;add num[0];递归helper()到(执行for i=0continue i=1add)[1,2]继续递归;remove,执行for(i=2)[1,3]）->remove->for循环i=1；

From LeetCode Discuss;

To generate all possible permutations, we need to remove the least recently added element while we are going up the recursive call stack.
In the first iteration of the for loop we add all permutations, that start with nums[0]. Then, before we can begin building all permutations starting with nums[1], we need to clear the tempList (which currently contains permutations from the first iteration of the for loop) - that's exactly what tempList.remove(tempList.size() - 1) line does.

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
         ArrayList<List<Integer>> rst = new ArrayList<List<Integer>>();
         if (nums == null) {
             return rst; 
         }
         
         if (nums.length == 0) {
            rst.add(new ArrayList<Integer>());
            return rst;
         }

         ArrayList<Integer> list = new ArrayList<Integer>();
         helper(rst, list, nums);
         return rst;
    }
    
    public void helper(ArrayList<List<Integer>> rst, ArrayList<Integer> list, int[] nums){
        if(list.size() == nums.length) {
            rst.add(new ArrayList<Integer>(list));
            return;
        }
        
        for(int i = 0; i < nums.length; i++){
            if(list.contains(nums[i])){
                continue;
            }
            list.add(nums[i]);
            helper(rst, list, nums);
            list.remove(list.size() - 1);
        }
        
    }
}

16.Permutations II:http://www.lintcode.com/en/problem/permutations-ii/

 含重复数组的全排列：(利用visited做标记,判断语句使得重复部分的数字顺序和结果中的顺序相同;)

(helper(rst,list,visited,nums); if(size=length)add,return;  for()if(v=1||i!=0&[i]=[i-1]&v[i-1]=0)continue,  v1,add,help,remove,v0);

 (permuteUnique:rst; null,length==0; sort,list,visited,help,return);

class Solution {
    /**
     * @param nums: A list of integers.
     * @return: A list of unique permutations.
     */
    public List<List<Integer>> permuteUnique(int[] nums) {
    
        ArrayList<List<Integer>> results = new ArrayList<List<Integer>>();
    
        if (nums == null) {
            return results;
        }
    
        if(nums.length == 0) {
            results.add(new ArrayList<Integer>());
            return results;
        }

        Arrays.sort(nums);
        ArrayList<Integer> list = new ArrayList<Integer>();
        int[] visited = new int[nums.length];
        for ( int i = 0; i < visited.length; i++){
            visited[i] = 0;
        }
     
        helper(results, list, visited, nums);    
        return results;
    }
    
    
    public void helper(ArrayList<List<Integer>> results, 
                   ArrayList<Integer> list, int[] visited, int[] nums) {
        
        if(list.size() == nums.length) {
            results.add(new ArrayList<Integer>(list));
            return;
        }
        
        for(int i = 0; i < nums.length; i++) {
            if ( visited[i] == 1 || ( i != 0 && nums[i] == nums[i - 1]
            && visited[i-1] == 0)){
                continue;
            }
            /*
            上面的判断主要是为了去除重复元素影响。
            比如，给出一个排好序的数组，[1,2,2]，那么第一个2和第二2如果在结果中互换位置，
            我们也认为是同一种方案，所以我们强制要求相同的数字，原来排在前面的，在结果
            当中也应该排在前面，这样就保证了唯一性。所以当前面的2还没有使用的时候，就
            不应该让后面的2使用。
            */
            visited[i] = 1;
            list.add(nums[i]);
            helper(results, list, visited, nums);
            list.remove(list.size() - 1);
            visited[i] = 0;
        }
     } 
}

17.Subsets:http://www.lintcode.com/en/problem/subsets/

子集：(定义pos,作为递归的起点)

(helper(rst,list,nums,pos); add; for(pos)add,helper(i+1),remove)

(subSet:异常处理(null/length==0)rst;  sort,list,helper(,,,0),return);

public class Solution {
    public ArrayList<ArrayList<Integer>> subsets(int[] num) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(num == null || num.length == 0) {
            return result;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        Arrays.sort(num);  
        subsetsHelper(result, list, num, 0);

        return result;
    }


    private void subsetsHelper(ArrayList<ArrayList<Integer>> result,
        ArrayList<Integer> list, int[] num, int pos) {

        result.add(new ArrayList<Integer>(list));

        for (int i = pos; i < num.length; i++) {

            list.add(num[i]);
            subsetsHelper(result, list, num, i + 1);
            list.remove(list.size() - 1);
        }
    }
}

18.Subsets II:http://www.lintcode.com/en/problem/subsets-ii/

带重复数字的子集：(在循环开始就需要判断它是否为重复数字，如果是，那么只执行first one)；(注意判断语句i>pos要在前，不然会出现数组[-1]错误)

(helper(rst,list,nums,pos); add; for(pos)if(&&) add,helper(i+1),remove)

(subSet:(null,length); sort,list,helper,return)

class Solution {
    /**
     * @param nums: A set of numbers.
     * @return: A list of lists. All valid subsets.
     */
    public ArrayList<ArrayList<Integer>> subsetsWithDup(int[] nums) {
        // write your code here
        ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
        if (nums.length == 0 || nums == null){
            return rst;
        }
        Arrays.sort(nums);
        ArrayList<Integer> list = new ArrayList<Integer>();
        helper(rst, list, nums, 0);
        return rst;
    }
    public void helper(ArrayList<ArrayList<Integer>> rst, ArrayList<Integer> list,
    int[] nums, int pos){
        rst.add(new ArrayList<Integer>(list));
        for (int i = pos; i < nums.length; i++){
            if (i > pos && nums[i] == nums[i - 1]){
                continue;
            }
            list.add(nums[i]);
            helper(rst, list, nums, i + 1);
            list.remove(list.size() - 1);
        }
    }
}

22. Flatten List：http://www.lintcode.com/en/problem/flatten-list/

平面列表：嵌套数组转为纯数字数组；recursion(题目方法的说明没太看懂，但根据方法名大概就可以推出了)(方法总漏掉括号()！！)；

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *
 *     // @return true if this NestedInteger holds a single integer,
 *     // rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds,
 *     // if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // @return the nested list that this NestedInteger holds,
 *     // if it holds a nested list
 *     // Return null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
public class Solution {

    // @param nestedList a list of NestedInteger
    // @return a list of integer
    public List<Integer> flatten(List<NestedInteger> nestedList) {
        // Write your code here
        List<Integer> rst = new ArrayList<Integer>();
        for (NestedInteger ele : nestedList){
            if (ele.isInteger()){
                rst.add(ele.getInteger());
            } else {
                rst.addAll(flatten(ele.getList()));
            }
        }
        return rst;
    }
}

28.Search a 2D Matrix:http://www.lintcode.com/en/problem/search-a-2d-matrix/

搜索二维矩阵：

for循环(不用考虑异常，因为异常是 for循环条件不满足，不会执行)

public class Solution {
    /**
     * @param matrix, a list of lists of integers
     * @param target, an integer
     * @return a boolean, indicate whether matrix contains target
     */
    public boolean searchMatrix(int[][] matrix, int target) {
        // write your code here
        for (int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix[0].length; j++){
                if(matrix[i][j] == target){
                    return true;
                }
            }
        }
        return false;
    }
}  

两次BinarySearch：(第一次search确定row,第二次确定col;)

(if if; while(+1<) matrix[mid][0] mid,mid; if(<=)row=end/start false;  while()matrix[row][mid]正常binarySearch )

(注意：第一次的while必须是(start+1<end),对应的if内=mid,=mid  反例：[1,2][3,4][5,6][7,8][9,10] search 6;如果用mid+1,那么或判断错误--start=4(7),end=5(9))

(注意：mid的定义必须在while内部，总是写错！  注意： end=length-1！！)

(判断row的准确位置，if(=end) if(=start) else(false 例如：num < start的情况) )

我的解法：第二次正常binarySearch 范围用了(<=),判断用的mid-1/mid+1;

public class Solution {
    /**
     * @param matrix, a list of lists of integers
     * @param target, an integer
     * @return a boolean, indicate whether matrix contains target
     */
    public boolean searchMatrix(int[][] matrix, int target) {
        // write your code here
        if (matrix == null || matrix.length == 0){
            return false;
        }
        if (matrix[0] == null || matrix[0].length == 0){
            return false;
        }
        int start = 0;
        int end = matrix.length - 1;
        int row ;
        while (start + 1 < end) {
            int mid = start + (end - start)/2;
            if (matrix[mid][0] == target){
                return true;
            } else if (matrix[mid][0] < target) {
                start = mid ;
            } else {
                end = mid ;
            }
        }
        if (matrix[end][0] <= target){
            row = end;
        } else if (matrix[start][0] <= target){
            row = start;
        } else {
            return false;
        }
     
        start = 0;
        end = matrix[0].length - 1;
        while (start <= end) {
            int mid = start + (end - start)/2;
            if (matrix[row][mid] == target){
                return true;
            } else if (matrix[row][mid] < target) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        return false;
    }
}

九章解法：两次都是(+1<),判断为mid,并且需要额外判断start,end;  (虽然有的时候不必要，但好处是模版化！！不用担心异常情况，比如上面的反例；)

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0) {
            return false;
        }
        if (matrix[0] == null || matrix[0].length == 0) {
            return false;
        }
        
        int row = matrix.length;
        int column = matrix[0].length;
        
        // find the row index, the last number <= target 
        int start = 0, end = row - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (matrix[mid][0] == target) {
                return true;
            } else if (matrix[mid][0] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (matrix[end][0] <= target) {
            row = end;
        } else if (matrix[start][0] <= target) {
            row = start;
        } else {
            return false;
        }
        
        // find the column index, the number equal to target
        start = 0;
        end = column - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (matrix[row][mid] == target) {
                return true;
            } else if (matrix[row][mid] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (matrix[row][start] == target) {
            return true;
        } else if (matrix[row][end] == target) {
            return true;
        }
        return false;
    }
}

一次BinarySearch：(将Matrix看成m*n长的list，mid对应的number=Matrix[mid/col][mid%col]两个都是col,别写错了)；

(1.两组异常(null,len;null,len);2.start,end,row,col,mid,num;while(<=),if()start=+1;end=-1);

(注意，while里的条件(<=),对应下面的是mid+1和mid-1)(九章里解法是(+1<),对应=mid,=mid,同时必须要单独列出start和end情况，不明白为什么要这样求解)；

(ps:mid=s+(e-s)/2 而不用 (e+s)/2目的是防止e和s都很大时溢出的情况)

public class Solution {
    /**
     * @param matrix, a list of lists of integers
     * @param target, an integer
     * @return a boolean, indicate whether matrix contains target
     */
    public boolean searchMatrix(int[][] matrix, int target) {
        // write your code here
        if (matrix == null || matrix.length == 0){
            return false;
        }
        if (matrix[0] == null || matrix[0].length == 0){
            return false;
        }
        int start = 0;
        int row = matrix.length;
        int col = matrix[0].length;
        int end = row * col - 1;
        while (start <= end){
            int mid = start + (end - start) / 2;
            int num = matrix[mid / col][mid % col];
            if (num == target){
                return true;
            } else if (num < target){
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        return false;
    }
}

29.Interleaving String:http://www.lintcode.com/en/problem/interleaving-string/

交叉字符串:(二维动态规划1.异常判断length;  2.一个循环判断s3前几个字符的出处, s3=s1 [i][0]/s3=s2 [0][j];  3.两个for循环判断interleaved[i][j]);

(1.if; 2.bo [0][0]; 3.for(i)(j) if(i-1)(j-1); 4.for(ij) if(i+j-1 && iter[i-1][j] ||) 5.return[len()][len()])

(几个错误点：1.首先判断长度;初始化[len+1][len+1],[0][0] 2.for条件[1,len()]; 3.String.length()是方法,要加括号; 4.if 判断为[i-1]; 5.return[len][len])

(因为二维数字里多了首位[0,0] charAt(j-1)表示第j位，而interleaved[i][j-1]表示第j-1个数)

s1, s2只有两个字符串，因此可以展平为一个二维地图，判断是否能从左上角走到右下角。

当s1到达第i个元素，s2到达第j个元素:

地图上往右一步就是s2[j-1]匹配s3[i+j-1]。

地图上往下一步就是s1[i-1]匹配s3[i+j-1]。

public class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        if (s1.length() + s2.length() != s3.length()) {
            return false;
        }
        
        boolean [][] interleaved = new boolean[s1.length() + 1][s2.length() + 1];
        interleaved[0][0] = true;
        
        for (int i = 1; i <= s1.length(); i++) {
            if(s3.charAt(i - 1) == s1.charAt(i - 1) && interleaved[i - 1][0])
                interleaved[i][0] = true;
        }
        
        for (int j = 1; j <= s2.length(); j++) {
            if(s3.charAt(j - 1) == s2.charAt(j - 1) && interleaved[0][j - 1])
                interleaved[0][j] = true;
        }
        
        for (int i = 1; i <= s1.length(); i++) {
            for (int j = 1; j <= s2.length(); j++) {
                if(((s3.charAt(i + j - 1) == s1.charAt(i - 1) && interleaved[i - 1][j]))
                    || ((s3.charAt(i + j - 1)) == s2.charAt(j - 1) && interleaved[i][j - 1]))
                interleaved[i][j] = true;
            }
        }
        
        return interleaved[s1.length()][s2.length()];
    }
}

30.Insert Interval: http://www.lintcode.com/en/problem/insert-interval/

插入区间：(定义pos记录位置;newInterval和interval无重叠时,小于new的pos++,并且都可直接add;最后再add(pos,new); 有重叠时,先把无重叠部分add,在把重叠的几个区间合并add)

(1.if; 2.rst,pos; 3.for()if(<)pos++,add,elseif(>)add else(min,max) 4.add(pos,newInter) 5.return);

public class Solution {
    public ArrayList<Interval> insert(ArrayList<Interval> intervals, Interval newInterval) {
        if (newInterval == null || intervals == null) {
            return intervals;
        }

        ArrayList<Interval> results = new ArrayList<Interval>();
        int insertPos = 0;

        for (Interval interval : intervals) {
            if (interval.end < newInterval.start) {
                results.add(interval);
                insertPos++;
            } else if (interval.start > newInterval.end) {
                results.add(interval);
            } else {
                newInterval.start = Math.min(interval.start, newInterval.start);
                newInterval.end = Math.max(interval.end, newInterval.end);
            }
        }

        results.add(insertPos, newInterval);

        return results;
    }
}

31.Partition Array: http://www.lintcode.com/en/problem/partition-array/

数组划分：(todo)

32.Minimum Window Substring：http://www.lintcode.com/en/problem/minimum-window-substring/

最小子串覆盖：