[LEET-0000] add problem descriptions

fishercoder1534 · fishercoder1534 · commit bc3896bd544e · 2017-02-02T16:18:48.000-08:00
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/CloneGraph.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/CloneGraph.java
@@ -1,7 +1,5 @@
 package com.stevesun.solutions;
 
-
-
 import com.stevesun.common.classes.UndirectedGraphNode;
 
 import java.util.HashMap;
@@ -10,7 +8,29 @@
 import java.util.Queue;
 
 /**
- * Created by fishercoder1534 on 9/30/16.
+ * Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.
+
+
+ OJ's undirected graph serialization:
+ Nodes are labeled uniquely.
+
+ We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.
+ As an example, consider the serialized graph {0,1,2#1,2#2,2}.
+
+ The graph has a total of three nodes, and therefore contains three parts as separated by #.
+
+ First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
+ Second node is labeled as 1. Connect node 1 to node 2.
+ Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.
+ Visually, the graph looks like the following:
+
+    1
+   / \
+  /   \
+ 0 --- 2
+      / \
+      \_/
+
  */
 public class CloneGraph {
 
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/SymmetricTree.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/SymmetricTree.java
@@ -4,10 +4,6 @@
 
 /**101. Symmetric Tree
 
-    Total Accepted: 121737
-    Total Submissions: 346738
-    Difficulty: Easy
-
 Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
 
 For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/TextJustification.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/TextJustification.java
@@ -1,7 +1,31 @@
 package com.stevesun.solutions;
 import java.util.*;
 /**
- * Created by fishercoder1534 on 10/9/16.
+ * Given an array of words and a length L, format the text such that each line has exactly L characters and is fully (left and right) justified.
+
+ You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces ' ' when necessary so that each line has exactly L characters.
+
+ Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.
+
+ For the last line of text, it should be left justified and no extra space is inserted between words.
+
+ For example,
+ words: ["This", "is", "an", "example", "of", "text", "justification."]
+ L: 16.
+
+ Return the formatted lines as:
+ [
+ "This    is    an",
+ "example  of text",
+ "justification.  "
+ ]
+ Note: Each word is guaranteed not to exceed L in length.
+
+ click to show corner cases.
+
+ Corner Cases:
+ A line other than the last line might contain only one word. What should you do in this case?
+ In this case, that line should be left-justified.
  */
 public class TextJustification {
 
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/Triangle.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/Triangle.java
@@ -1,9 +1,11 @@
 package com.stevesun.solutions;
+
 import java.util.*;
+
 public class Triangle {
 
     public static int minimumTotal(List<List<Integer>> triangle) {
-        /**Looked at this post: https://discuss.leetcode.com/topic/1669/dp-solution-for-triangle, @stellari has a very excellent explanation.
+        /**https://discuss.leetcode.com/topic/1669/dp-solution-for-triangle, @stellari has a very excellent explanation.
          * Basically, we use the bottom-up approach, starting from the bottom row of this triangle, and we only need to store the shortest path of each node
          * from its last row, and keep overwriting it until we reach the top.*/
         int n = triangle.size();
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/ValidPalindrome.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/ValidPalindrome.java
@@ -1,5 +1,15 @@
 package com.stevesun.solutions;
 
+/**Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
+
+ For example,
+ "A man, a plan, a canal: Panama" is a palindrome.
+ "race a car" is not a palindrome.
+
+ Note:
+ Have you consider that the string might be empty? This is a good question to ask during an interview.
+
+ For the purpose of this problem, we define empty string as valid palindrome.*/
 public class ValidPalindrome {
 
     public boolean isPalindrome(String s) {
