Sri Hari: Batch-3/Neetcode-150: Added Golang, Kotlin (#3720)

* Added Golang, Kotlin

* Added Go & Kt, added best solution for LC:215

* Added Golang, Kotlin

* Added Golang, Kotlin

* Added Golang, Kotlin

Author: Srihari2222

articles/binary-tree-maximum-path-sum.md

@@ -205,6 +205,91 @@ public class Solution {
 }
 ```
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func maxPathSum(root *TreeNode) int {
+    res := -1 << 31 
+    dfs(root, &res)
+    return res
+}
+
+func dfs(root *TreeNode, res *int) {
+    if root == nil {
+        return
+    }
+    left := getMax(root.Left)
+    right := getMax(root.Right)
+    *res = max(*res, root.Val + left + right)
+    dfs(root.Left, res)
+    dfs(root.Right, res)
+}
+
+func getMax(root *TreeNode) int {
+    if root == nil {
+        return 0
+    }
+    left := getMax(root.Left)
+    right := getMax(root.Right)
+    path := root.Val + max(left, right)
+    return max(0, path)
+}
+
+func max(a, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
+```kotlin
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var res = Int.MIN_VALUE
+
+    fun maxPathSum(root: TreeNode?): Int {
+        dfs(root)
+        return res
+    }
+
+    private fun dfs(root: TreeNode?) {
+        if (root == null) return
+
+        val left = getMax(root.left)
+        val right = getMax(root.right)
+        res = maxOf(res, root.`val` + left + right)
+
+        dfs(root.left)
+        dfs(root.right)
+    }
+
+    private fun getMax(root: TreeNode?): Int {
+        if (root == null) return 0
+
+        val left = getMax(root.left)
+        val right = getMax(root.right)
+        val path = root.`val` + maxOf(left, right)
+        return maxOf(0, path)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -400,6 +485,81 @@ public class Solution {
 }
 ```
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func maxPathSum(root *TreeNode) int {
+    res := []int{root.Val}
+    
+    var dfs func(node *TreeNode) int
+    dfs = func(node *TreeNode) int {
+        if node == nil {
+            return 0
+        }
+        
+        leftMax := dfs(node.Left)
+        rightMax := dfs(node.Right)
+        
+        leftMax = max(leftMax, 0)
+        rightMax = max(rightMax, 0)
+        
+        res[0] = max(res[0], node.Val+leftMax+rightMax)
+        
+        return node.Val + max(leftMax, rightMax)
+    }
+    
+    dfs(root)
+    return res[0]
+}
+
+func max(a, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
+```kotlin
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var res = Int.MIN_VALUE
+    
+    fun maxPathSum(root: TreeNode?): Int {
+        dfs(root)
+        return res
+    }
+    
+    private fun dfs(node: TreeNode?): Int {
+        if (node == null) {
+            return 0
+        }
+        
+        val leftMax = maxOf(dfs(node.left), 0)
+        val rightMax = maxOf(dfs(node.right), 0)
+        
+        res = maxOf(res, node.`val` + leftMax + rightMax)
+        
+        return node.`val` + maxOf(leftMax, rightMax)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity

articles/clone-graph.md

@@ -222,6 +222,74 @@ public class Solution {
 }
 ```
 
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Neighbors []*Node
+ * }
+ */
+
+func cloneGraph(node *Node) *Node {
+    oldToNew := make(map[*Node]*Node)
+
+    var dfs func(*Node) *Node
+    dfs = func(node *Node) *Node {
+        if node == nil {
+            return nil
+        }
+
+        if _, found := oldToNew[node]; found {
+            return oldToNew[node]
+        }
+
+        copy := &Node{Val: node.Val}
+        oldToNew[node] = copy
+        for _, nei := range node.Neighbors {
+            copy.Neighbors = append(copy.Neighbors, dfs(nei))
+        }
+        return copy
+    }
+
+    return dfs(node)
+}
+```
+
+```kotlin
+/**
+ * Definition for a Node.
+ * class Node(var `val`: Int) {
+ *     var neighbors: ArrayList<Node?> = ArrayList<Node?>()
+ * }
+ */
+
+class Solution {
+    fun cloneGraph(node: Node?): Node? {
+        if (node == null) return null
+        
+        val oldToNew = HashMap<Node, Node>()
+        
+        fun dfs(node: Node): Node {
+            if (node in oldToNew) {
+                return oldToNew[node]!!
+            }
+            
+            val copy = Node(node.`val`)
+            oldToNew[node] = copy
+            
+            for (nei in node.neighbors) {
+                nei?.let { copy.neighbors.add(dfs(it)) }
+            }
+            
+            return copy
+        }
+        
+        return dfs(node)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -442,6 +510,78 @@ public class Solution {
 }
 ```
 
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Neighbors []*Node
+ * }
+ */
+
+func cloneGraph(node *Node) *Node {
+    if node == nil {
+        return nil
+    }
+    
+    oldToNew := make(map[*Node]*Node)
+    oldToNew[node] = &Node{Val: node.Val, Neighbors: make([]*Node, 0)}
+    queue := make([]*Node, 0)
+    queue = append(queue, node)
+    
+    for len(queue) > 0 {
+        cur := queue[0]
+        queue = queue[1:]
+        
+        for _, nei := range cur.Neighbors {
+            if _, exists := oldToNew[nei]; !exists {
+                oldToNew[nei] = &Node{Val: nei.Val, Neighbors: make([]*Node, 0)}
+                queue = append(queue, nei)
+            }
+            oldToNew[cur].Neighbors = append(oldToNew[cur].Neighbors, oldToNew[nei])
+        }
+    }
+    
+    return oldToNew[node]
+}
+```
+
+```kotlin
+/**
+ * Definition for a Node.
+ * class Node(var `val`: Int) {
+ *     var neighbors: ArrayList<Node?> = ArrayList<Node?>()
+ * }
+ */
+
+class Solution {
+    fun cloneGraph(node: Node?): Node? {
+        if (node == null) return null
+        
+        val oldToNew = HashMap<Node, Node>()
+        oldToNew[node] = Node(node.`val`)
+        val queue = ArrayDeque<Node>()
+        queue.add(node)
+        
+        while (queue.isNotEmpty()) {
+            val cur = queue.removeFirst()
+            
+            for (nei in cur.neighbors) {
+                nei?.let { neighbor ->
+                    if (neighbor !in oldToNew) {
+                        oldToNew[neighbor] = Node(neighbor.`val`)
+                        queue.add(neighbor)
+                    }
+                    oldToNew[cur]?.neighbors?.add(oldToNew[neighbor])
+                }
+            }
+        }
+        
+        return oldToNew[node]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity