Solutions

Author: trinhminhtriet

solutions/1200-1299/1290.convert-binary-number-in-a-linked-list-to-integer/Solution.cs

@@ -0,0 +1,20 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public int GetDecimalValue(ListNode head) {
+        int ans = 0;
+        for (; head != null; head = head.next) {
+            ans = ans << 1 | head.val;
+        }
+        return ans;
+    }
+}

solutions/1600-1699/1695.maximum-erasure-value/Solution.rs

@@ -0,0 +1,22 @@
+impl Solution {
+    pub fn maximum_unique_subarray(nums: Vec<i32>) -> i32 {
+        let m = *nums.iter().max().unwrap() as usize;
+        let mut d = vec![0; m + 1];
+        let n = nums.len();
+
+        let mut s = vec![0; n + 1];
+        for i in 0..n {
+            s[i + 1] = s[i] + nums[i];
+        }
+
+        let mut ans = 0;
+        let mut j = 0;
+        for (i, &v) in nums.iter().enumerate().map(|(i, v)| (i + 1, v)) {
+            j = j.max(d[v as usize]);
+            ans = ans.max(s[i] - s[j]);
+            d[v as usize] = i;
+        }
+
+        ans
+    }
+}

solutions/1600-1699/1695.maximum-erasure-value/Solution2.rs

@@ -0,0 +1,22 @@
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn maximum_unique_subarray(nums: Vec<i32>) -> i32 {
+        let mut vis = HashSet::new();
+        let (mut ans, mut s, mut i) = (0, 0, 0);
+
+        for &x in &nums {
+            while vis.contains(&x) {
+                let y = nums[i];
+                s -= y;
+                vis.remove(&y);
+                i += 1;
+            }
+            vis.insert(x);
+            s += x;
+            ans = ans.max(s);
+        }
+
+        ans
+    }
+}

solutions/1700-1799/1717.maximum-score-from-removing-substrings/Solution.cs

@@ -0,0 +1,30 @@
+public class Solution {
+    public int MaximumGain(string s, int x, int y) {
+        char a = 'a', b = 'b';
+        if (x < y) {
+            (x, y) = (y, x);
+            (a, b) = (b, a);
+        }
+
+        int ans = 0, cnt1 = 0, cnt2 = 0;
+        foreach (char c in s) {
+            if (c == a) {
+                cnt1++;
+            } else if (c == b) {
+                if (cnt1 > 0) {
+                    ans += x;
+                    cnt1--;
+                } else {
+                    cnt2++;
+                }
+            } else {
+                ans += Math.Min(cnt1, cnt2) * y;
+                cnt1 = 0;
+                cnt2 = 0;
+            }
+        }
+
+        ans += Math.Min(cnt1, cnt2) * y;
+        return ans;
+    }
+}

solutions/1700-1799/1717.maximum-score-from-removing-substrings/Solution.rs

@@ -0,0 +1,33 @@
+impl Solution {
+    pub fn maximum_gain(s: String, mut x: i32, mut y: i32) -> i32 {
+        let (mut a, mut b) = ('a', 'b');
+        if x < y {
+            std::mem::swap(&mut x, &mut y);
+            std::mem::swap(&mut a, &mut b);
+        }
+
+        let mut ans = 0;
+        let mut cnt1 = 0;
+        let mut cnt2 = 0;
+
+        for c in s.chars() {
+            if c == a {
+                cnt1 += 1;
+            } else if c == b {
+                if cnt1 > 0 {
+                    ans += x;
+                    cnt1 -= 1;
+                } else {
+                    cnt2 += 1;
+                }
+            } else {
+                ans += cnt1.min(cnt2) * y;
+                cnt1 = 0;
+                cnt2 = 0;
+            }
+        }
+
+        ans += cnt1.min(cnt2) * y;
+        ans
+    }
+}

solutions/1900-1999/1948.delete-duplicate-folders-in-system/Solution.go

@@ -0,0 +1,62 @@
+type Trie struct {
+	children map[string]*Trie
+	deleted  bool
+}
+
+func NewTrie() *Trie {
+	return &Trie{
+		children: make(map[string]*Trie),
+	}
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+	root := NewTrie()
+	for _, path := range paths {
+		cur := root
+		for _, name := range path {
+			if _, exists := cur.children[name]; !exists {
+				cur.children[name] = NewTrie()
+			}
+			cur = cur.children[name]
+		}
+	}
+
+	g := make(map[string]*Trie)
+
+	var dfs func(*Trie) string
+	dfs = func(node *Trie) string {
+		if len(node.children) == 0 {
+			return ""
+		}
+		var subs []string
+		for name, child := range node.children {
+			subs = append(subs, name+"("+dfs(child)+")")
+		}
+		sort.Strings(subs)
+		s := strings.Join(subs, "")
+		if existingNode, exists := g[s]; exists {
+			node.deleted = true
+			existingNode.deleted = true
+		} else {
+			g[s] = node
+		}
+		return s
+	}
+
+	var dfs2 func(*Trie, []string)
+	dfs2 = func(node *Trie, path []string) {
+		if node.deleted {
+			return
+		}
+		if len(path) > 0 {
+			ans = append(ans, append([]string{}, path...))
+		}
+		for name, child := range node.children {
+			dfs2(child, append(path, name))
+		}
+	}
+
+	dfs(root)
+	dfs2(root, []string{})
+	return ans
+}

solutions/1900-1999/1948.delete-duplicate-folders-in-system/Solution.java

@@ -0,0 +1,75 @@
+class Trie {
+    Map<String, Trie> children;
+    boolean deleted;
+
+    public Trie() {
+        children = new HashMap<>();
+        deleted = false;
+    }
+}
+
+class Solution {
+    public List<List<String>> deleteDuplicateFolder(List<List<String>> paths) {
+        Trie root = new Trie();
+        for (List<String> path : paths) {
+            Trie cur = root;
+            for (String name : path) {
+                if (!cur.children.containsKey(name)) {
+                    cur.children.put(name, new Trie());
+                }
+                cur = cur.children.get(name);
+            }
+        }
+
+        Map<String, Trie> g = new HashMap<>();
+
+        var dfs = new Function<Trie, String>() {
+            @Override
+            public String apply(Trie node) {
+                if (node.children.isEmpty()) {
+                    return "";
+                }
+                List<String> subs = new ArrayList<>();
+                for (var entry : node.children.entrySet()) {
+                    subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")");
+                }
+                Collections.sort(subs);
+                String s = String.join("", subs);
+                if (g.containsKey(s)) {
+                    node.deleted = true;
+                    g.get(s).deleted = true;
+                } else {
+                    g.put(s, node);
+                }
+                return s;
+            }
+        };
+
+        dfs.apply(root);
+
+        List<List<String>> ans = new ArrayList<>();
+        List<String> path = new ArrayList<>();
+
+        var dfs2 = new Function<Trie, Void>() {
+            @Override
+            public Void apply(Trie node) {
+                if (node.deleted) {
+                    return null;
+                }
+                if (!path.isEmpty()) {
+                    ans.add(new ArrayList<>(path));
+                }
+                for (Map.Entry<String, Trie> entry : node.children.entrySet()) {
+                    path.add(entry.getKey());
+                    apply(entry.getValue());
+                    path.remove(path.size() - 1);
+                }
+                return null;
+            }
+        };
+
+        dfs2.apply(root);
+
+        return ans;
+    }
+}

solutions/1900-1999/1948.delete-duplicate-folders-in-system/Solution.py

@@ -0,0 +1,46 @@
+class Trie:
+    def __init__(self):
+        self.children: Dict[str, "Trie"] = defaultdict(Trie)
+        self.deleted: bool = False
+
+
+class Solution:
+    def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+        root = Trie()
+        for path in paths:
+            cur = root
+            for name in path:
+                if cur.children[name] is None:
+                    cur.children[name] = Trie()
+                cur = cur.children[name]
+
+        g: Dict[str, Trie] = {}
+
+        def dfs(node: Trie) -> str:
+            if not node.children:
+                return ""
+            subs: List[str] = []
+            for name, child in node.children.items():
+                subs.append(f"{name}({dfs(child)})")
+            s = "".join(sorted(subs))
+            if s in g:
+                node.deleted = g[s].deleted = True
+            else:
+                g[s] = node
+            return s
+
+        def dfs2(node: Trie) -> None:
+            if node.deleted:
+                return
+            if path:
+                ans.append(path[:])
+            for name, child in node.children.items():
+                path.append(name)
+                dfs2(child)
+                path.pop()
+
+        dfs(root)
+        ans: List[List[str]] = []
+        path: List[str] = []
+        dfs2(root)
+        return ans

solutions/1900-1999/1948.delete-duplicate-folders-in-system/Solution.ts

@@ -0,0 +1,60 @@
+function deleteDuplicateFolder(paths: string[][]): string[][] {
+    class Trie {
+        children: { [key: string]: Trie } = {};
+        deleted: boolean = false;
+    }
+
+    const root = new Trie();
+
+    for (const path of paths) {
+        let cur = root;
+        for (const name of path) {
+            if (!cur.children[name]) {
+                cur.children[name] = new Trie();
+            }
+            cur = cur.children[name];
+        }
+    }
+
+    const g: { [key: string]: Trie } = {};
+
+    const dfs = (node: Trie): string => {
+        if (Object.keys(node.children).length === 0) return '';
+
+        const subs: string[] = [];
+        for (const [name, child] of Object.entries(node.children)) {
+            subs.push(`${name}(${dfs(child)})`);
+        }
+        subs.sort();
+        const s = subs.join('');
+
+        if (g[s]) {
+            node.deleted = true;
+            g[s].deleted = true;
+        } else {
+            g[s] = node;
+        }
+        return s;
+    };
+
+    dfs(root);
+
+    const ans: string[][] = [];
+    const path: string[] = [];
+
+    const dfs2 = (node: Trie): void => {
+        if (node.deleted) return;
+        if (path.length > 0) {
+            ans.push([...path]);
+        }
+        for (const [name, child] of Object.entries(node.children)) {
+            path.push(name);
+            dfs2(child);
+            path.pop();
+        }
+    };
+
+    dfs2(root);
+
+    return ans;
+}