Good Article:    http://blog.youkuaiyun.com/zyfo2/article/details/8592955

public class Solution { public boolean isPalindrome(String s) { // Start typing your Java solution below if(s.length() == 1 || s.length() == 0 ) return true; Strin

public String addBinary(String a, String b) { // char resi = '0'; int lena = a.length(); int lenb = b.length(); int len = (lena > lenb ? lena : lenb) - 1; int i

public int climbStairs(int n) { // Start typing your Java solution below // DO NOT write main() function if(n == 0) return 0; if(n == 1) return 1; int[] arr = new

public int[] plusOne(int[] digits) { if(digits.length < 1) return null; String ans = ""; int resi = 0; for(int i = digits.length - 1; i>=0; i--) { int cu

DP Min[ i,  j] = Min( Min[i - 1][j] + grid[i][j], Min[i][j - 1] + grid[ i ][ j ]); public int minPathSum(int[][] grid) { // Start typing your Java solution below [[1]] //

public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // Start typing your Java solution below // DO NOT write main() function ListNode ans = new ListNode(0); ListNode he

public class LastWordLength { public int lengthOfLastWord(String s) { // if(s == null || s.length() == 0 ) return 0; s = s.trim(); s = s.replaceAll("[ ]+", " ");

Iterate the intervals list. Compare newInterval with each item in the list. If overlapping, update the item. Otherwise(no overlapping), add newInterval into list. Then delete duplicates or merge overl

import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; class Interval { int start; int end; Interval() {start = 0; end = 0;} Interval(int s, int e) {start = s; end

public ArrayList spiralOrder(int[][] matrix) { // ArrayList result = new ArrayList(); if(matrix == null) return result; if(matrix.length < 1) return result;

/* Leetcode JumpGame Given an array of non-negative integers, you are initially positioned at the first index of the array. Each element in the array represents your maximum jump length at that posi

O(n) solution public class MaxSubArray { public int maxSubArray(int[] A) { int sum = 0, curr = 0; int max = Integer.MIN_VALUE; for(curr = 0; curr < A.length; curr++) {

public class Pow { // //recursive version // //stack overflow when n is large // public double pow(double x, int n) { // // if(n < 0) { // return 1.0/pow(x, -n); // } // /

Given a collection of numbers that might contain duplicates, return all possible unique permutations. For example, [1,1,2] have the following unique permutations: [1,1,2], [1,2,1], and [2,1,1

import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; /* * Given an array of strings, return all groups of strings that are anagrams. * Note: All inputs will be in lower-c

public int minDistance(String word1, String word2) { // int rowNum = word1.length(); int colNum = word2.length(); int[][] dist = new int[rowNum + 1][colNum + 1]; for