Add solution and test cases to problem 68, 124 (#191)

* ✨ Add solution and test-cases for Problem 51

* ✨ Add solution and test cases to problem 68

* ✨ Add solution and test cses to problem 124

Co-authored-by: S Sathish Babu <[email protected]>

Author: Cori1109

leetcode/1-100/0068.Text-Justification/Solution.go

@@ -1,5 +1,29 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+import "strings"
+
+func Solution(words []string, k int) []string {
+	result := make([]string, 0);
+	currWords := make([]string, 0);
+	currWordsLen := 0;
+	for _, word := range words {
+		if currWordsLen + len(currWords) + len(word) > k {
+			if len(currWords) == 1 {
+				result = append(result, currWords[0] + strings.Repeat(" ", k - currWordsLen));
+			} else {
+				spaces := k - currWordsLen
+				spacesBetween, extras := spaces / (len(currWords) - 1), spaces % (len(currWords) - 1);
+				for i := 0; i < extras; i++ {
+					currWords[i] += " ";
+				}
+				result = append(result, strings.Join(currWords, strings.Repeat(" ", spacesBetween)));
+			}
+			currWords = make([]string, 0);
+			currWordsLen = 0;
+		}
+		currWords = append(currWords, word);
+		currWordsLen += len(word);
+	}
+	result = append(result, strings.Join(currWords, " ") + strings.Repeat(" ", k - currWordsLen - len(currWords) + 1));
+	return result;
 }

leetcode/1-100/0068.Text-Justification/Solution_test.go

@@ -9,21 +9,38 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		words []string
+		k int
+		expect []string
 	}{
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", false, false},
+		{"TestCase", []string{"This", "is", "an", "example", "of", "text", "justification."}, 16, []string{
+			"This    is    an",
+			"example  of text",
+			"justification.  ",
+		}},
+		{"TestCase", []string{"What","must","be","acknowledgment","shall","be"}, 16, []string{
+			"What   must   be",
+			"acknowledgment  ",
+			"shall be        ",
+		}},
+		{"TestCase", []string{"Science","is","what","we","understand","well","enough","to","explain","to","a","computer.","Art","is","everything","else","we","do"}, 20, 
+		[]string{
+			"Science  is  what we",
+			"understand      well",
+			"enough to explain to",
+			"a  computer.  Art is",
+			"everything  else  we",
+			"do                  ",
+		}},
 	}
 
 	//	开始测试
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			ret := Solution(c.inputs)
+			ret := Solution(c.words, c.k)
 			if !reflect.DeepEqual(ret, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, ret, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v",
+					c.expect, ret, c.words, c.k)
 			}
 		})
 	}

leetcode/1-100/0068.text-justification.md

@@ -2,25 +2,54 @@
 
 ## Description
 
-Given two binary strings, return their sum \(also a binary string\).
+Given an array of words and a width _maxWidth_, format the text such that each line has exactly _maxWidth_ characters and is fully (left and right) justified.
 
-The input strings are both **non-empty** and contains only characters `1` or `0`.
+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 _maxWidth_ 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.
 
 **Example 1:**
 
 ```text
-Input: a = "11", b = "1"
-Output: "100"
+Input: words = ["This", "is", "an", "example", "of", "text", "justification."], maxWidth = 16
+Output:
+[
+   "This    is    an",
+   "example  of text",
+   "justification.  "
+]
 ```
 
 **Example 2:**
 
 ```text
-Input: a = "1010", b = "1011"
-Output: "10101"
+Input: words = ["What","must","be","acknowledgment","shall","be"], maxWidth = 16
+Output:
+[
+  "What   must   be",
+  "acknowledgment  ",
+  "shall be        "
+]
+```
+
+**Example 3:**
+
+```text
+Input: words = ["Science","is","what","we","understand","well","enough","to","explain","to","a","computer.","Art","is","everything","else","we","do"], maxWidth = 20
+Output:
+[
+  "Science  is  what we",
+  "understand      well",
+  "enough to explain to",
+  "a  computer.  Art is",
+  "everything  else  we",
+  "do                  "
+]
 ```
 
-**Tags:** Math, String
+**Tags:** String, Simulation
 
 ## 题意
 

leetcode/101-200/0124.Binary-Tree-Maximum-Path-Sum/Solution.go

@@ -1,5 +1,29 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+import "math"
+
+func Solution(root *TreeNode) int {
+    res := math.MinInt32;
+    helper(root, &res);
+    return res
+}
+
+func helper(root *TreeNode, res *int) int {
+    if root == nil {
+        return 0;
+    }
+    left := helper(root.Left, res);
+    right := helper(root.Right, res);
+    *res = max(*res, root.Val, left + root.Val, root.Val + right, left + root.Val + right);
+    return max(left + root.Val, root.Val + right, root.Val);
 }
+
+func max(nums ...int) int {
+    maxVal := nums[0];
+    for i := 1; i < len(nums); i++ {
+        if nums[i] > maxVal {
+            maxVal = nums[i];
+        }
+    }
+    return maxVal;
+}

leetcode/101-200/0124.Binary-Tree-Maximum-Path-Sum/Solution_test.go

@@ -10,21 +10,32 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		root *TreeNode
+		expect int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase", &TreeNode{
+			Val: 1, 
+			Left: &TreeNode{Val: 2}, 
+			Right: &TreeNode{Val: 3},
+		}, 6},
+		{"TestCase", &TreeNode{
+			-10,
+			&TreeNode{Val: 9},
+			&TreeNode{
+				20,
+				&TreeNode{Val: 15},
+				&TreeNode{Val: 7},
+			},
+		}, 42},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.root)
 			if !reflect.DeepEqual(got, c.expect) {
 				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+					c.expect, got, c.root)
 			}
 		})
 	}

leetcode/101-200/0124.Binary-Tree-Maximum-Path-Sum/TreeNode.go

@@ -0,0 +1,7 @@
+package Solution
+
+type TreeNode struct {
+    Val int
+    Left *TreeNode
+    Right *TreeNode
+}

leetcode/101-200/0124.binary-tree-maximum-path-sum.md

@@ -1,16 +1,37 @@
 # 0124.Binary-Tree-Maximum-Path-Sum
 
-> \[!WARNING\|style:flat\] This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
 
+A **path** in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence **at most once**. Note that the path does not need to pass through the root.
+
+The **path sum** of a path is the sum of the node's values in the path.
+
+Given the `root` of a binary tree, return _the maximum **path sum** of any path_.
+
+**Example 1:**
+
+```text
+     1
+    / \
+   2   3
+Input: root = [1,2,3]
+Output: 6
+```
+
 **Example 1:**
 
 ```text
-Input: a = "11", b = "1"
-Output: "100"
+     -10
+     /  \
+    9   20
+       /  \
+      15   7
+Input: root = [-10,9,20,null,null,15,7]
+Output: 42
 ```
 
+**Tags:** Dynamic-Programming, Tree, DFS, BinaryTree
+
 ## 题意
 
 > ...