My Solution

Fisrt

Author: jinrf

My Solutions/AddTwoNumbers.java

@@ -0,0 +1,46 @@
+import java.util.*;
+
+public class AddTwoNumbers {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+		Deque<Integer> s1 = new ArrayDeque<>();
+		Deque<Integer> s2 = new ArrayDeque<>();
+
+		while (l1 != null) {
+			s1.push(l1.val);
+			l1 = l1.next;
+		}
+		while (l2 != null) {
+			s2.push(l2.val);
+			l2 = l2.next;
+		}
+
+		int carry = 0;
+		ListNode tail = null;
+		while (!s1.isEmpty() || !s2.isEmpty()) {
+
+			int op1 = s1.isEmpty() ? 0 : s1.pop();
+			int op2 = s2.isEmpty() ? 0 : s2.pop();
+			int sum = op1 + op2 + carry;
+			ListNode n = new ListNode(sum);
+			n.next = tail;
+			tail = n;
+			carry = sum >= 10 ? 1 : 0;
+		}
+		if (carry == 1) {
+			ListNode n = new ListNode(1);
+			n.next = tail;
+			tail = n;
+		}
+		return tail;
+	}
+
+}

My Solutions/Anagram.java

@@ -0,0 +1,48 @@
+import java.util.*;
+
+public class Anagram {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public List<String> anagrams(String[] strs) {
+		List<String> l = new ArrayList<>();
+		int len = strs.length;
+		if (len < 2)
+			return l;
+
+		Map<String, List<Integer>> m = new HashMap<>();
+		Set<String> s = new HashSet<>();
+
+		for (int i = 0; i < len; i++) {
+			String tmp = sort(strs[i]);
+			List<Integer> list = m.get(tmp);
+			if (list == null) {
+				list = new ArrayList<Integer>();
+				list.add(i);
+				m.put(tmp, list);
+			} else {
+				list.add(i);
+				s.add(tmp);
+			}
+		}
+		for (String str : s) {
+			for (int i : m.get(str)) {
+				l.add(strs[i]);
+			}
+		}
+		return l;
+	}
+
+	private String sort(String s) {
+		char[] c = s.toCharArray();
+		Arrays.sort(c);
+		return new String(c);
+	}
+
+}

My Solutions/BalancedPartition.java

@@ -0,0 +1,36 @@
+public class BalancedPartition {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		BalancedPartition bp = new BalancedPartition();
+		System.out.println(bp.partition(new int[] { 3, 1, 5, 9, 12 }));
+
+	}
+
+	public boolean partition(int[] nums) {
+
+		int sum = 0;
+		for (int n : nums)
+			sum += n;
+
+		boolean[][] dp = new boolean[nums.length][sum / 2 + 1];
+
+		for (int i = 0; i < nums.length; i++) {
+			dp[i][nums[i]] = true;
+			dp[i][0] = true;
+			if (i == 0)
+				continue;
+			for (int j = nums[i]; j <= sum / 2; j++) {
+				dp[i][j] = (dp[i - 1][j] || dp[i][j - nums[i]]);
+			}
+		}
+
+		for (int i = 0; i < nums.length; i++) {
+			if (dp[i][sum / 2])
+				return true;
+		}
+		return false;
+	}
+}

My Solutions/BestTimetoBuyandSellStockIII.java

@@ -0,0 +1,37 @@
+public class BestTimetoBuyandSellStockIII {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+	
+	
+
+	private int[] prices;
+
+	public int maxProfit(int[] prices) {
+
+		int p = 0;
+		this.prices = prices;
+		for (int i = 2; i < prices.length - 2; i++) {
+			p = Math.max(p, maxProfit(0, i) + maxProfit(i, prices.length));
+		}
+
+		return p;
+	}
+
+	private int maxProfit(int start, int end) {
+		int p = 0;
+		for (int i = start; i < end - 1; i++) {
+			if (prices[i + 1] > prices[i]) {
+				p += prices[i + 1] - prices[i];
+			}
+		}
+
+		return p;
+	}
+
+}

My Solutions/BinaryTreeTraversal.java

@@ -0,0 +1,58 @@
+import java.util.*;
+
+public class BinaryTreeTraversal {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		TreeNode t = new TreeNode(0);
+		t.left = new TreeNode(1);
+		t.right = new TreeNode(2);
+		inorderTraversal(t);
+
+	}
+
+	public static List<Integer> inorderTraversal(TreeNode root) {
+		List<Integer> res = new ArrayList<>();
+		if (root == null)
+			return res;
+
+		Deque<TreeNode> s = new ArrayDeque<>();
+		s.push(root);
+
+		while (!s.isEmpty()) {
+			TreeNode n = s.pop();
+			while (n.left != null) {
+				s.push(n);
+				n = n.left;
+			}
+			res.add(n.val);
+			if (n.right != null)
+				s.push(n.right);
+		}
+		return res;
+	}
+
+	public static List<Integer> preorderTraversal(TreeNode root) {
+		List<Integer> res = new LinkedList<>();
+		if (root == null)
+			return res;
+		// recursive(res, root);
+		Stack<TreeNode> s = new Stack<>();
+		s.push(root);
+		TreeNode n;
+		while (!s.isEmpty()) {
+			n = s.pop();
+			res.add(n.val);
+			if (n.right != null)
+				s.push(n.right);
+			if (n.left != null)
+				s.push(n.left);
+		}
+
+		return res;
+	}
+
+}

My Solutions/BinaryTreeZigzagLevelOrderTraversal.java

@@ -0,0 +1,82 @@
+import java.util.*;
+
+public class BinaryTreeZigzagLevelOrderTraversal {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+		List<List<Integer>> levelOrder = new LinkedList<>();
+		recursive(root, levelOrder, 0);
+		adjust(levelOrder);
+		return levelOrder;
+	}
+
+	private void recursive(TreeNode root, List<List<Integer>> levelOrder,
+			int level) {
+		if (root == null)
+			return;
+		if (level > levelOrder.size()) {
+			levelOrder.add(new LinkedList<Integer>());
+		}
+		levelOrder.get(level).add(root.val);
+		recursive(root.left, levelOrder, level + 1);
+		recursive(root.right, levelOrder, level + 1);
+	}
+
+	private void adjust(List<List<Integer>> levelOrder) {
+		for (int i = 0; i < levelOrder.size(); i++) {
+			if ((i & 1) == 1) {
+				Collections.reverse(levelOrder.get(i));
+			}
+		}
+		return;
+	}
+
+	private List<List<Integer>> naive(TreeNode root) {
+		List<List<Integer>> ret = new LinkedList<>();
+		if (root == null)
+			return ret;
+
+		List<Integer> levelList = new LinkedList<>();
+		levelList.add(root.val);
+		ret.add(levelList);
+
+		Deque<TreeNode> q = new ArrayDeque<>();
+
+		q.add(root);
+		int level = 0;
+		while (q.size() > 0) {
+			level++;
+			levelList = new LinkedList<>();
+			Deque<TreeNode> newQ = new ArrayDeque<>();
+			while (q.size() > 0) {
+				TreeNode n = q.remove();
+				if (n.left != null) {
+					newQ.add(n.left);
+					if (level % 2 == 1)
+						levelList.add(0, n.left.val);
+					else
+						levelList.add(n.left.val);
+				}
+				if (n.right != null) {
+					newQ.add(n.right);
+					if (level % 2 == 1)
+						levelList.add(0, n.right.val);
+					else
+						levelList.add(n.right.val);
+				}
+			}
+			if (levelList.size() > 0)
+				ret.add(levelList);
+			q = newQ;
+		}
+		return ret;
+	}
+
+}

My Solutions/Candy.java

@@ -0,0 +1,52 @@
+import java.util.*;
+
+public class Candy {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		int[] test = { 1, 2, 2};
+		Candy c = new Candy();
+		System.out.print(c.candy(test));
+	}
+
+	public int candy(int[] ratings) {
+		int len = ratings.length;
+		if (len < 2)
+			return len; // 0 -> 0, 1 -> 1;
+
+		int[] candies = new int[len];
+		Arrays.fill(candies, 1);
+
+		Map<Integer, List<Integer>> m = new HashMap<>();
+
+		for (int i = 0; i < len; i++) {
+			if (m.containsKey(ratings[i])) {
+				m.get(ratings[i]).add(i);
+			} else {
+				List<Integer> l = new ArrayList<>();
+				l.add(i);
+				m.put(ratings[i], l);
+			}
+		}
+
+		Integer[] rs = m.keySet().toArray(new Integer[0]);
+		Arrays.sort(rs);
+
+		for (int i = 1; i < rs.length; i++) { //skip the lowest rating
+			List<Integer> l = m.get(rs[i]);
+			for (int j : l) {
+				if (j - 1 >= 0 && candies[j] <= candies[j - 1])
+					candies[j] = candies[j - 1] + 1;
+				if (j + 1 < len && candies[j] <= candies[j + 1])
+					candies[j] = candies[j + 1] + 1;
+			}
+		}
+
+		int sum = 0;
+		for (int i : candies)
+			sum += i;
+		return sum;
+	}
+}

My Solutions/CatchThief.java

@@ -0,0 +1,31 @@
+import java.util.Arrays;
+
+public class CatchThief {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		CatchThief ct = new CatchThief();
+		System.out.println(ct.canCatch(
+				new int[] { 1, 2, 3, 4, 5, 5, 4, 3, 2, 1 }, 5));
+	}
+
+	public boolean canCatch(int[] seq, int n) {
+
+		boolean[] dp = new boolean[n + 2];
+		Arrays.fill(dp, true);
+
+		dp[0] = dp[seq[0]] = dp[n + 1] = false;
+
+		for (int i = 0; i < seq.length; i++)
+			for (int j = 1; j <= n; j++)
+				dp[j] = ((dp[j - 1] || dp[j + 1]) && j != seq[i]);
+
+		for (int i = 1; i <= n; i++)
+			if (dp[i])
+				return false;
+
+		return true;
+	}
+}