add 623 and change names

fishercoder1534 · fishercoder1534 · commit 4a9739158969 · 2017-06-19T14:31:14.000+09:00
diff --git a/README.md b/README.md
diff --git a/src/main/java/com/fishercoder/solutions/Contest.java b/src/main/java/com/fishercoder/solutions/Contest.java
@@ -0,0 +1,72 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Created by stevesun on 6/17/17.
+ */
+public class Contest {
+
+
+    public TreeNode addOneRow(TreeNode root, int v, int d) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        Queue<TreeNode> prevQueue = new LinkedList<>();
+        queue.offer(root);
+        int depth = 1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                TreeNode curr = queue.poll();
+                if (curr.left != null && depth == (d-1)) {
+                    prevQueue.offer(curr.left);
+                    queue.offer(curr.left);
+                } else if (curr.left == null && depth == d) {
+                    queue.offer(new TreeNode(Integer.MIN_VALUE));
+                } else if (curr.left != null) {
+                    queue.offer(curr.left);
+                }
+
+                if (curr.right != null && depth == (d-1)) {
+                    prevQueue.offer(curr.right);
+                    queue.offer(curr.right);
+                } else if (curr.right == null && depth == d) {
+                    queue.offer(new TreeNode(Integer.MIN_VALUE));
+                } else if (curr.right != null) {
+                    queue.offer(curr.right);
+                }
+            }
+            if (depth == d) {
+                break;
+            }
+            depth++;
+        }
+        Queue<TreeNode> secondQueue = new LinkedList<>();
+        secondQueue.offer(root);
+        depth = 0;
+        while (!secondQueue.isEmpty()) {
+            depth++;
+            int size = secondQueue.size();
+            for (int i = 0; i < size; i++) {
+                TreeNode curr = queue.poll();
+                if (curr.left != null) {
+                    queue.offer(curr.left);
+                }
+            }
+        }
+        return root;
+    }
+
+
+    public static void main(String... args) {
+        Contest contest = new Contest();
+        System.out.println("hello world!");
+//        int[][] arrays = new int[][]{
+//                {1,2,3},
+//                {4,5},
+//                {1,2,3},
+//        };
+    }
+}
diff --git a/src/main/java/com/fishercoder/solutions/_110.java b/src/main/java/com/fishercoder/solutions/_110.java
@@ -7,7 +7,7 @@
 
  For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.*/
 
-public class BalancedBinaryTree {
+public class _110 {
     
     class Solution_1 {
         //recursively get the height of each subtree of each node, compare their difference, if greater than 1, then return false
diff --git a/src/main/java/com/fishercoder/solutions/_122.java b/src/main/java/com/fishercoder/solutions/_122.java
@@ -3,7 +3,7 @@
 /**Say you have an array for which the ith element is the price of a given stock on day i.
 
  Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).*/
-public class BestTimeToBuyAndSellStockII {
+public class _122 {
 
     /**It turns out to be a super simple one, it's really a greedy one! Just keep being greedy if it's possible.*/
     public int maxProfit(int[] prices) {
diff --git a/src/main/java/com/fishercoder/solutions/_123.java b/src/main/java/com/fishercoder/solutions/_123.java
@@ -8,7 +8,7 @@
 
 Note:
 You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).*/
-public class BestTimeToBuyAndSellStockIII {
+public class _123 {
     
     //this is a very clear solution and very highly upvoted in Discuss, but not extensibel to K solution.
     public int maxProfit(int[] prices) {
@@ -87,7 +87,7 @@ public static void main(String...strings){
 //        int[] prices = new int[]{6,1,3,2,4,7};
 //        int[] prices = new int[]{1,2,4,2,5,7,2,4,9,0};//(7-2)+(9-2) = 5+7 = 12 is wrong, it should be (7-1)+(9-2) = 6+7 = 13
         int[] prices = new int[]{2,5,7,1,4,3,1,3};
-        BestTimeToBuyAndSellStockIII test = new BestTimeToBuyAndSellStockIII();
+        _123 test = new _123();
         System.out.println(test.maxProfit(prices));
     }
     
diff --git a/src/main/java/com/fishercoder/solutions/_133.java b/src/main/java/com/fishercoder/solutions/_133.java
@@ -32,7 +32,7 @@
       \_/
 
  */
-public class CloneGraph {
+public class _133 {
 
     public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
         if(node == null) return node;
diff --git a/src/main/java/com/fishercoder/solutions/_135.java b/src/main/java/com/fishercoder/solutions/_135.java
@@ -9,7 +9,7 @@
  Children with a higher rating get more candies than their neighbors.
  What is the minimum candies you must give?
  */
-public class Candy {
+public class _135 {
 
     public int candy(int[] ratings) {
         int[] candy = new int[ratings.length];
diff --git a/src/main/java/com/fishercoder/solutions/_137.java b/src/main/java/com/fishercoder/solutions/_137.java
@@ -10,7 +10,7 @@
 Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
 
 */
-public class SingleNumberII {
+public class _137 {
 
     public int singleNumber(int[] nums) {
         Map<Integer, Integer> map = new HashMap();
@@ -25,7 +25,7 @@ public int singleNumber(int[] nums) {
     
     public static void main(String...strings){
         int[] nums = new int[]{2,2,3,2};
-        SingleNumberII test = new SingleNumberII();
+        _137 test = new _137();
         System.out.println(test.singleNumber(nums));
     }
 
diff --git a/src/main/java/com/fishercoder/solutions/_217.java b/src/main/java/com/fishercoder/solutions/_217.java
@@ -9,7 +9,7 @@
  * duplicates. Your function should return true if any value appears at least twice in the array,
  * and it should return false if every element is distinct.
  */
-public class ContainsDuplicate {
+public class _217 {
     public boolean containsDuplicate(int[] nums) {
         if(nums == null || nums.length == 0) return false;
         Set<Integer> set = new HashSet();
@@ -21,7 +21,7 @@ public boolean containsDuplicate(int[] nums) {
     
     public static void main(String...strings){
         int[] nums = new int[]{1,2,3,4, 3};
-        ContainsDuplicate test = new ContainsDuplicate();
+        _217 test = new _217();
         System.out.println(test.containsDuplicate(nums));
     }
 }
diff --git a/src/main/java/com/fishercoder/solutions/_243.java b/src/main/java/com/fishercoder/solutions/_243.java
@@ -10,7 +10,7 @@
 
  Note:
  You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.*/
-public class ShortestWordDistance {
+public class _243 {
 
     public int shortestDistance(String[] words, String word1, String word2) {
         
diff --git a/src/main/java/com/fishercoder/solutions/_296.java b/src/main/java/com/fishercoder/solutions/_296.java
@@ -16,7 +16,7 @@ For example, given three people living at (0,0), (0,4), and (2,2):
  0 - 0 - 1 - 0 - 0
  The point (0,2) is an ideal meeting point, as the total travel distance of 2+2+2=6 is minimal. So return 6.
  */
-public class BestMeetingPoint {
+public class _296 {
 	public int minTotalDistance(int[][] grid) {
 		int m = grid.length;
 		int n = grid[0].length;
diff --git a/src/main/java/com/fishercoder/solutions/_302.java b/src/main/java/com/fishercoder/solutions/_302.java
@@ -13,7 +13,7 @@
  and x = 0, y = 2,
  Return 6.
  */
-public class SmallestRectangleEnclosingBlackPixels {
+public class _302 {
     class Solution {
         private char[][] image;
         public int minArea(char[][] iImage, int x, int y) {
diff --git a/src/main/java/com/fishercoder/solutions/_309.java b/src/main/java/com/fishercoder/solutions/_309.java
@@ -11,7 +11,7 @@ You may not engage in multiple transactions at the same time (ie, you must sell
  prices = [1, 2, 3, 0, 2]
  maxProfit = 3
  transactions = [buy, sell, cooldown, buy, sell]*/
-public class BestTimeToBuyAndSellStockWithCooldown {
+public class _309 {
     static class solutionFromProblemAuthor {
         /**
          * The series of problems are typical dp. The key for dp is to find the variables to
diff --git a/src/main/java/com/fishercoder/solutions/_311.java b/src/main/java/com/fishercoder/solutions/_311.java
@@ -21,7 +21,7 @@
       |  1 0 0 |   | 7 0 0 |   |  7 0 0 |
  AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 |
                    | 0 0 1 |*/
-public class SparseMatrixMultiplication {
+public class _311 {
 
     public int[][] multiply(int[][] A, int[][] B) {
         int m = A.length, n = A[0].length, p = B[0].length;
diff --git a/src/main/java/com/fishercoder/solutions/_322.java b/src/main/java/com/fishercoder/solutions/_322.java
@@ -14,7 +14,7 @@
  Note:
  You may assume that you have an infinite number of each kind of coin.
  */
-public class CoinChange {
+public class _322 {
 
     public int coinChange(int[] coins, int amount) {
         if(amount < 1) return 0;
diff --git a/src/main/java/com/fishercoder/solutions/_441.java b/src/main/java/com/fishercoder/solutions/_441.java
@@ -30,7 +30,7 @@
  ¤ ¤
 
  Because the 4th row is incomplete, we return 3.*/
-public class ArrangingCoins {
+public class _441 {
 
     public static int arrangeCoins(int n) {
         if(n < 2) return n;
diff --git a/src/main/java/com/fishercoder/solutions/_455.java b/src/main/java/com/fishercoder/solutions/_455.java
@@ -26,7 +26,7 @@
  You have 3 cookies and their sizes are big enough to gratify all of the children,
  You need to output 2.*/
 
-public class AssignCookies {
+public class _455 {
 
     public int findContentChildren(int[] g, int[] s) {
         Arrays.sort(g);
@@ -44,7 +44,7 @@ public int findContentChildren(int[] g, int[] s) {
     }
     
     public static void main(String...args){
-        AssignCookies test = new AssignCookies();
+        _455 test = new _455();
         int[] g = new int[]{1,2,3};
         int[] s = new int[]{1,1};
         System.out.println(test.findContentChildren(g, s));
diff --git a/src/main/java/com/fishercoder/solutions/_477.java b/src/main/java/com/fishercoder/solutions/_477.java
@@ -17,7 +17,7 @@
  Elements of the given array are in the range of 0 to 10^9
  Length of the array will not exceed 10^4.
  */
-public class TotalHammingDistance {
+public class _477 {
 
 	public int totalHammingDistance(int[] nums) {
 		int r = 0;
diff --git a/src/main/java/com/fishercoder/solutions/_499.java b/src/main/java/com/fishercoder/solutions/_499.java
@@ -48,7 +48,7 @@ Given the ball position, the hole position and the maze, find out how the ball c
  Both the ball and hole exist on an empty space, and they will not be at the same position initially.
  The given maze does not contain border (like the red rectangle in the example pictures), but you could assume the border of the maze are all walls.
  The maze contains at least 2 empty spaces, and the width and the height of the maze won't exceed 30.*/
-public class TheMazeIII {
+public class _499 {
 //credit: https://discuss.leetcode.com/topic/77474/similar-to-the-maze-ii-easy-understanding-java-bfs-solution
 
     public String findShortestWay(int[][] maze, int[] ball, int[] hole) {
diff --git a/src/main/java/com/fishercoder/solutions/_500.java b/src/main/java/com/fishercoder/solutions/_500.java
@@ -16,7 +16,7 @@
  * You may use one character in the keyboard more than once.
  * You may assume the input string will only contain letters of alphabet.
  */
-public class KeyboardRow {
+public class _500 {
 
     public String[] findWords(String[] words) {
         final Set<Character> row1 = new HashSet<>(Arrays.asList('q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'));
diff --git a/src/main/java/com/fishercoder/solutions/_505.java b/src/main/java/com/fishercoder/solutions/_505.java
@@ -49,7 +49,7 @@
  The given maze does not contain border (like the red rectangle in the example pictures), but you could assume the border of the maze are all walls.
  The maze contains at least 2 empty spaces, and both the width and height of the maze won't exceed 100.
  */
-public class TheMazeII {
+public class _505 {
 
     /**The difference between II and I of this problem:
      * the extra array is not boolean type any more, but int type, and it's recording the length of each point to start point.*/
diff --git a/src/main/java/com/fishercoder/solutions/_526.java b/src/main/java/com/fishercoder/solutions/_526.java
@@ -29,7 +29,7 @@
  Note:
  N is a positive integer and will not exceed 15.
  */
-public class BeautifulArrangement {
+public class _526 {
     //A good post to look at: https://discuss.leetcode.com/topic/79916/java-solution-backtracking and it's generic template afterwards for backtracking problems
 
     int count = 0;
diff --git a/src/main/java/com/fishercoder/solutions/_548.java b/src/main/java/com/fishercoder/solutions/_548.java
@@ -23,7 +23,7 @@ where we define that subarray (L, R) represents a slice of the original array st
  1 <= n <= 2000.
  Elements in the given array will be in range [-1,000,000, 1,000,000].
  */
-public class SplitArraywithEqualSum {
+public class _548 {
 
     public boolean splitArray_O_N_3(int[] nums) {//TODO: this one is failed by test4, probably some index wrong
         if (nums == null || nums.length == 0) return false;
diff --git a/src/main/java/com/fishercoder/solutions/_623.java b/src/main/java/com/fishercoder/solutions/_623.java
@@ -0,0 +1,99 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 623. Add One Row to Tree
+ *
+ * Given the root of a binary tree,
+ * then value v and depth d,
+ * you need to add a row of nodes with value v at the given depth d.
+ * The root node is at depth 1.
+
+ The adding rule is: given a positive integer depth d,
+ for each NOT null tree nodes N in depth d-1,
+ create two tree nodes with value v as N's left subtree root and right subtree root.
+ And N's original left subtree should be the left subtree of the new left subtree root,
+ its original right subtree should be the right subtree of the new right subtree root.
+ If depth d is 1 that means there is no depth d-1 at all,
+ then create a tree node with value v as the new root of the whole
+ original tree, and the original tree is the new root's left subtree.
+
+ Example 1:
+ Input:
+ A binary tree as following:
+      4
+    /   \
+   2     6
+  / \   /
+ 3   1 5
+
+ v = 1
+
+ d = 2
+
+ Output:
+       4
+      / \
+     1   1
+    /     \
+   2       6
+  / \     /
+ 3   1   5
+
+
+ Example 2:
+ Input:
+ A binary tree as following:
+    4
+    /
+   2
+  / \
+ 3   1
+
+ v = 1
+
+ d = 3
+
+ Output:
+        4
+       /
+      2
+     / \
+    1   1
+   /     \
+  3       1
+
+ Note:
+ The given d is in range [1, maximum depth of the given tree + 1].
+ The given binary tree has at least one tree node.
+ */
+public class _623 {
+
+    public TreeNode addOneRow(TreeNode root, int v, int d) {
+        if (d == 1) {
+            TreeNode newRoot = new TreeNode(v);
+            newRoot.left = root;
+            return newRoot;
+        } else {
+            dfs(root, v, d);
+            return root;
+        }
+    }
+
+    private void dfs(TreeNode root, int v, int d) {
+        if (root == null) return;;
+        if (d == 2) {
+            TreeNode newLeft = new TreeNode(v);
+            TreeNode newRight = new TreeNode(v);
+            newLeft.left = root.left;
+            newRight.right = root.right;
+            root.left = newLeft;
+            root.right = newRight;
+        } else {
+            dfs(root.left, v, d-1);
+            dfs(root.right, v, d-1);
+        }
+    }
+
+}
diff --git a/src/main/java/com/fishercoder/solutions/_78.java b/src/main/java/com/fishercoder/solutions/_78.java
diff --git a/src/main/java/com/fishercoder/solutions/_95.java b/src/main/java/com/fishercoder/solutions/_95.java
diff --git a/src/main/java/com/fishercoder/solutions/_96.java b/src/main/java/com/fishercoder/solutions/_96.java
diff --git a/src/test/java/com/fishercoder/SplitArraywithEqualSumTest.java b/src/test/java/com/fishercoder/SplitArraywithEqualSumTest.java
diff --git a/src/test/java/com/fishercoder/TheMazeIIITest.java b/src/test/java/com/fishercoder/TheMazeIIITest.java
diff --git a/src/test/java/com/fishercoder/_133Test.java b/src/test/java/com/fishercoder/_133Test.java
diff --git a/src/test/java/com/fishercoder/_499Test.java b/src/test/java/com/fishercoder/_499Test.java
diff --git a/src/test/java/com/fishercoder/_500Test.java b/src/test/java/com/fishercoder/_500Test.java
