solves #124: Binary Tree Maximum Path Sum in java

Author: anishLearnsToCode

README.md

@@ -121,6 +121,7 @@
 | 120  | [Triangle](https://leetcode.com/problems/triangle)                                                                                                                     |                                                                                          [![Java](assets/java.png)](src/Triangle.java)                                                                                           |                                                                                                                                   |
 | 121  | [Best Time to Buy and Sell Stocks](https://leetcode.com/problems/best-time-to-buy-and-sell-stock)                                                                      |                                             [![Java](assets/java.png)](src/BestTimeToBuyAndSellStock.java) [![Python](assets/python.png)](python/best_time_to_buy_and_sell_stock.py)                                             |                                                                                                                                   |
 | 122  | [Best Time to Buy and Sell Stocks II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii)                                                                |                                          [![Java](assets/java.png)](src/BestTimeToBuyAndSellStockII.java) [![Python](assets/python.png)](python/best_time_to_buy_and_sell_stock_ii.py)                                           |                                                                                                                                   |
+| 123  | [Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum)                                                                             |                                                                                  [![Java](assets/java.png)](src/BinaryTreeMaximumPathSum.java)                                                                                   |                                                                                                                                   |
 | 125  | [Valid Palindrome](https://leetcode.com/problems/valid-palindrome)                                                                                                     |                                                         [![Java](assets/java.png)](src/ValidPalindrome.java) [![Python](assets/python.png)](python/valid_palindrome.py)                                                          |                                                                                                                                   |
 | 128  | [Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence)                                                                             |                                                                                 [![Java](assets/java.png)](src/LongestConsecutiveSequence.java)                                                                                  |                                                                                                                                   |
 | 129  | [Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers)                                                                                     |                                                                                    [![Java](assets/java.png)](src/SumRootToLeafNumbers.java)                                                                                     |                                                                                                                                   |

src/BinaryTreeMaximumPathSum.java

@@ -0,0 +1,29 @@
+// https://leetcode.com/problems/binary-tree-maximum-path-sum
+// T: O(N)
+// S: O(logN)
+
+public class BinaryTreeMaximumPathSum {
+    private static int result = Integer.MIN_VALUE;
+
+    public int maxPathSum(TreeNode root) {
+        result = Integer.MIN_VALUE;
+        if (root == null) {
+            return 0;
+        }
+        maxSum(root);
+        return result;
+    }
+
+    private static int maxSum(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        final int maxSumLeftSubtree = Math.max(maxSum(root.left), 0);
+        final int maxSumRightSubtree = Math.max(maxSum(root.right), 0);
+        final int maxPathSum = root.val + maxSumLeftSubtree + maxSumRightSubtree;
+        result = Math.max(result, maxPathSum);
+
+        return Math.max(root.val + maxSumLeftSubtree, root.val + maxSumRightSubtree);
+    }
+}

src/HelloWorld.java

@@ -1,35 +1,25 @@
 public class HelloWorld {
-    public ListNode reverseBetween(ListNode head, int left, int right) {
-        if (head == null) {
-            return null;
-        }
-
-        ListNode result = new ListNode(0);
-        result.next = head;
+    private static int result = Integer.MIN_VALUE;
 
-        ListNode start = result;
-        for (int i = 1 ; i < left ; i++) {
-            start = start.next;
+    public static int maxPathSum(TreeNode root) {
+        result = Integer.MIN_VALUE;
+        if (root == null) {
+            return 0;
         }
+        maxSum(root);
+        return result;
+    }
 
-        ListNode startNext = start.next, a = startNext, b = start.next.next;
-        for (int count = left ; b != null && count < right ; count++) {
-            ListNode c = b.next;
-            b.next = a;
-            a = b;
-            b = c;
+    private static int maxSum(TreeNode root) {
+        if (root == null) {
+            return 0;
         }
 
-        start.next = a;
-        startNext.next = b;
-
-        return result.next;
-    }
+        final int maxGainLeftSubtree = Math.max(maxSum(root.left), 0);
+        final int maxGainRightSubtree = Math.max(maxSum(root.right), 0);
+        final int maxPathSum = root.val + maxGainLeftSubtree + maxGainRightSubtree;
+        result = Math.max(result, maxPathSum);
 
-    public static void main(String[] args) {
-        ListNode node = new ListNode(1);
-        node.next = new ListNode(2);
-        node.next.next = new ListNode(3);
-        node.next.next.next = new ListNode(4);
+        return Math.max(root.val + maxGainLeftSubtree, root.val + maxGainRightSubtree);
     }
 }

src/LRUCache.java

@@ -8,77 +8,82 @@ public class LRUCache {
     private static class Node {
         int key;
         int value;
-        Node next;
         Node previous;
+        Node next;
 
-        Node() { }
-        Node(int key, int value) {
+        public Node(int key, int value) {
             this.key = key;
             this.value = value;
         }
     }
 
-    private final int capacity;
     private final Map<Integer, Node> cache = new HashMap<>();
+    private final int capacity;
     private Node head, tail;
 
     public LRUCache(int capacity) {
         this.capacity = capacity;
-        head = new Node();
-        tail = new Node();
-        head.next = tail;
-        tail.previous = head;
     }
 
     public int get(int key) {
-        Node node = cache.get(key);
-        if(node == null) {
+        if (!cache.containsKey(key)) {
             return -1;
         }
-        moveToHead(node);
+        final Node node = cache.get(key);
+        moveNodeToTail(node);
         return node.value;
     }
 
     public void put(int key, int value) {
-        Node node = cache.get(key);
-
-        if(node == null) {
-            Node newNode = new Node(key, value);
-            this.cache.put(key, newNode);
-            this.addNode(newNode);
+        if (cache.containsKey(key)) {
+            Node node = cache.get(key);
+            node.value = value;
+            moveNodeToTail(node);
+        } else if (cache.size() == capacity) {
+            Node node = new Node(key, value);
+            cache.put(key, node);
+            cache.remove(head.key);
+            appendToTail(node);
+            popHead();
+        } else {
+            Node node = new Node(key, value);
+            cache.put(key, node);
 
-            if(cache.size() > capacity){
-                Node tail = popTail();
-                this.cache.remove(tail.key);
+            if (cache.size() == 1) {
+                head = node;
+                tail = node;
+            } else {
+                appendToTail(node);
             }
-        } else {
-            node.value = value;
-            moveToHead(node);
         }
     }
 
-    private Node popTail(){
-        Node res = tail.previous;
-        this.removeNode(res);
-        return res;
-    }
+    private void moveNodeToTail(Node node) {
+        if (node == tail) {
+            return;
+        }
+
+        if (node == head) {
+            appendToTail(node);
+            popHead();
+            return;
+        }
+
+        Node previous = node.previous, next = node.next;
+        previous.next = next;
+        next.previous = previous;
 
-    private void addNode(Node node) {
-        node.previous = head;
-        node.next = head.next;
-        head.next.previous = node;
-        head.next = node;
+        appendToTail(node);
     }
 
-    private void removeNode(Node node){
-        Node pre = node.previous;
-        Node post = node.next;
-        pre.next = post;
-        post.previous = pre;
+    private void appendToTail(Node node) {
+        tail.next = node;
+        node.previous = tail;
+        tail = node;
     }
 
-    private void moveToHead(Node node){
-        this.removeNode(node);
-        this.addNode(node);
+    private void popHead() {
+        head = head.next;
+        head.previous = null;
     }
-}
+}