Added task 432.

Author: javadev

src/main/java/g0401_0500/s0432_all_oone_data_structure/AllOne.java

@@ -0,0 +1,150 @@
+package g0401_0500.s0432_all_oone_data_structure;
+
+// #Hard #Hash_Table #Design #Linked_List #Doubly_Linked_List
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class AllOne {
+    private static class Node {
+        String key;
+        int val;
+        Node prev;
+        Node next;
+
+        Node(String key, int val) {
+            this.key = key;
+            this.val = val;
+        }
+    }
+
+    private static class DoubleLinkedList {
+        Node head;
+        Node tail;
+
+        DoubleLinkedList() {}
+
+        // Swap adjacent nodes till the node fits to its position
+        Node fixOrder(Node node) {
+            while (node.next != null && node.val > node.next.val) {
+                swapAdjacentNodes(node, node.next);
+            }
+            while (node.prev != null && node.val < node.prev.val) {
+                swapAdjacentNodes(node.prev, node);
+            }
+            return node;
+        }
+
+        // Swap two adjacent nodes, where node1 -> node2
+        void swapAdjacentNodes(Node node1, Node node2) {
+            node1.next = node2.next;
+            node2.prev = node1.prev;
+            if (node1.next != null) {
+                node1.next.prev = node1;
+            }
+            if (node2.prev != null) {
+                node2.prev.next = node2;
+            }
+            node1.prev = node2;
+            node2.next = node1;
+            // node0 -> node2 -> node1 -> node3
+            if (node1 == head) {
+                head = node2;
+            }
+            if (node2 == tail) {
+                tail = node1;
+            }
+        }
+        // New node has counter 1 and should be at the head of the list
+        Node add(Node node) {
+            node.next = head;
+            if (head != null) {
+                head.prev = node;
+            }
+            head = node;
+            // is it is the first node
+            if (tail == null) {
+                tail = head;
+            }
+            return node;
+        }
+
+        void remove(Node node) {
+            if (node.prev != null) {
+                node.prev.next = node.next;
+            } else {
+                head = node.next;
+            }
+            if (node.next != null) {
+                node.next.prev = node.prev;
+            } else {
+                tail = node.prev;
+            }
+        }
+    }
+
+    private DoubleLinkedList dll = new DoubleLinkedList();
+    private Map<String, Node> counter = new HashMap<>();
+
+    /* Initialize your data structure here. */
+    public AllOne() {
+        // empty
+    }
+
+    /* Inserts a new key <Key> with value 1. Or increments an existing key by 1. */
+    public void inc(String key) {
+        Node node = counter.get(key);
+        if (node == null) {
+            node = new Node(key, 1);
+            counter.put(key, node);
+            // add first
+            dll.add(node);
+        } else {
+            node.val++;
+            // after increment/decrement node may have incorrect position.
+            dll.fixOrder(node);
+        }
+    }
+
+    /* Decrements an existing key by 1. If Key's value is 1, remove it from the data structure. */
+    public void dec(String key) {
+        Node node = counter.get(key);
+        if (node == null) {
+            return;
+        }
+        node.val--;
+        if (node.val == 0) {
+            counter.remove(key);
+            // completely remove node from list
+            dll.remove(node);
+        } else {
+            // after increment/decrement node may have incorrect position.
+            dll.fixOrder(node);
+        }
+    }
+
+    /* Returns one of the keys with maximal value. */
+    public String getMaxKey() {
+        if (dll.tail == null) {
+            return "";
+        }
+        return dll.tail.key;
+    }
+
+    /* Returns one of the keys with Minimal value. */
+    public String getMinKey() {
+        if (dll.head == null) {
+            return "";
+        }
+        return dll.head.key;
+    }
+}
+
+/*
+ * Your AllOne object will be instantiated and called as such:
+ * AllOne obj = new AllOne();
+ * obj.inc(key);
+ * obj.dec(key);
+ * String param_3 = obj.getMaxKey();
+ * String param_4 = obj.getMinKey();
+ */

src/main/java/g0401_0500/s0432_all_oone_data_structure/readme.md

@@ -0,0 +1,40 @@
+432\. All O\`one Data Structure
+
+Hard
+
+Design a data structure to store the strings' count with the ability to return the strings with minimum and maximum counts.
+
+Implement the `AllOne` class:
+
+*   `AllOne()` Initializes the object of the data structure.
+*   `inc(String key)` Increments the count of the string `key` by `1`. If `key` does not exist in the data structure, insert it with count `1`.
+*   `dec(String key)` Decrements the count of the string `key` by `1`. If the count of `key` is `0` after the decrement, remove it from the data structure. It is guaranteed that `key` exists in the data structure before the decrement.
+*   `getMaxKey()` Returns one of the keys with the maximal count. If no element exists, return an empty string `""`.
+*   `getMinKey()` Returns one of the keys with the minimum count. If no element exists, return an empty string `""`.
+
+**Example 1:**
+
+**Input**
+
+    ["AllOne", "inc", "inc", "getMaxKey", "getMinKey", "inc", "getMaxKey", "getMinKey"]
+    [[], ["hello"], ["hello"], [], [], ["leet"], [], []]
+
+**Output:** [null, null, null, "hello", "hello", null, "hello", "leet"]
+
+**Explanation:**
+
+    AllOne allOne = new AllOne();
+    allOne.inc("hello");
+    allOne.inc("hello");
+    allOne.getMaxKey(); // return "hello"
+    allOne.getMinKey(); // return "hello"
+    allOne.inc("leet");
+    allOne.getMaxKey(); // return "hello"
+    allOne.getMinKey(); // return "leet" 
+
+**Constraints:**
+
+*   `1 <= key.length <= 10`
+*   `key` consists of lowercase English letters.
+*   It is guaranteed that for each call to `dec`, `key` is existing in the data structure.
+*   At most <code>5 * 10<sup>4</sup></code> calls will be made to `inc`, `dec`, `getMaxKey`, and `getMinKey`.

src/test/java/g0401_0500/s0432_all_oone_data_structure/AllOneTest.java

@@ -0,0 +1,25 @@
+package g0401_0500.s0432_all_oone_data_structure;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class AllOneTest {
+    @Test
+    void allOne() {
+        AllOne allOne = new AllOne();
+        allOne.inc("hello");
+        allOne.inc("hello");
+        // return "hello"
+        assertThat(allOne.getMaxKey(), equalTo("hello"));
+        // return "hello"
+        assertThat(allOne.getMinKey(), equalTo("hello"));
+        allOne.inc("leet");
+        // return "hello"
+        assertThat(allOne.getMaxKey(), equalTo("hello"));
+        // return "leet"
+        assertThat(allOne.getMinKey(), equalTo("leet"));
+        allOne.dec("leet");
+    }
+}