Improved 3486

Author: javadev

src/main/java/g3401_3500/s3486_longest_special_path_ii/Solution.java

@@ -1,145 +1,67 @@
 package g3401_3500.s3486_longest_special_path_ii;
 
-// #Hard #2025_03_16_Time_1831_ms_(_%)_Space_87.71_MB_(_%)
+// #Hard #2025_03_16_Time_178_ms_(_%)_Space_102.66_MB_(_%)
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class Solution {
-    private static final int MAX_VAL = 50000;
-    private int dupCount;
-    private int overCount;
-    private long ansLength;
-    private int ansNodes;
-    private int[] nums;
-    private List<List<int[]>> adj;
-    private int[] path;
-    private long[] dist;
-    private int[] freq;
-
     public int[] longestSpecialPath(int[][] edges, int[] nums) {
-        int n = nums.length;
-        this.nums = nums;
-        adj = new ArrayList<>();
-        for (int i = 0; i < n; i++) {
-            adj.add(new ArrayList<>());
-        }
-        // Build the undirected tree (rooted at 0)
-        for (int[] e : edges) {
-            int u = e[0];
-            int v = e[1];
-            int w = e[2];
-            adj.get(u).add(new int[] {v, w});
-            adj.get(v).add(new int[] {u, w});
+        int[] ans = {0, 1};
+        Map<Integer, List<int[]>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            int a = edge[0];
+            int b = edge[1];
+            int c = edge[2];
+            graph.computeIfAbsent(a, k -> new ArrayList<>()).add(new int[] {b, c});
+            graph.computeIfAbsent(b, k -> new ArrayList<>()).add(new int[] {a, c});
         }
-        // Preallocate DFS chain arrays
-        path = new int[n];
-        dist = new long[n];
-        freq = new int[MAX_VAL + 1];
-        ansLength = 0;
-        ansNodes = Integer.MAX_VALUE;
-        dupCount = 0;
-        overCount = 0;
-        // Start DFS from root, with left pointer L = 0 and current depth = 0.
-        dfs(0, -1, 0, 0, 0);
-        return new int[] {(int) ansLength, ansNodes};
+        List<Integer> costs = new ArrayList<>();
+        Map<Integer, Integer> last = new HashMap<>();
+        dfs(0, 0, -1, new ArrayList<>(Arrays.asList(0, 0)), nums, graph, costs, last, ans);
+        return ans;
     }
 
-    // The window [L, depth] (indices into the DFS chain) is valid if:
-    //   – overCount == 0 (no value appears 3+ times)
-    //   – dupCount <= 1 (at most one value appears exactly twice)
-    private boolean valid() {
-        return overCount == 0 && dupCount <= 1;
-    }
-
-    // DFS parameters:
-    //   node: current node,
-    //   parent: parent in DFS tree,
-    //   curDist: cumulative distance from root to current node,
-    //   L: left pointer index of the valid window (in the DFS chain),
-    //   depth: current index in the DFS chain.
-    private void dfs(int node, int parent, long curDist, int l, int depth) {
-        path[depth] = node;
-        dist[depth] = curDist;
-        // Update frequency for current node's value.
-        int v = nums[node];
-        int old = freq[v];
-        if (old == 0) {
-            freq[v] = 1;
-        } else if (old == 1) {
-            freq[v] = 2;
-            dupCount++;
-        } else if (old == 2) {
-            freq[v] = 3;
-            overCount++;
-            dupCount--;
-        }
-        // Save original left pointer.
-        int origL = l;
-        // We'll slide newL forward as needed.
-        int newL = l;
-        // Slide the window [newL, depth] until it is valid.
-        while (!valid() && newL < depth) {
-            int remNode = path[newL];
-            int remVal = nums[remNode];
-            if (freq[remVal] == 1) {
-                freq[remVal] = 0;
-            } else if (freq[remVal] == 2) {
-                freq[remVal] = 1;
-                dupCount--;
-            } else if (freq[remVal] == 3) {
-                freq[remVal] = 2;
-                overCount--;
-                // now this value counts as a duplicate.
-                dupCount++;
-            }
-            newL++;
-        }
-        // Now window [newL, depth] is valid.
-        // Compute current path length: difference of cumulative distances.
-        long curPathLength = newL == depth ? 0L : dist[depth] - dist[newL];
-        int nodeCount = depth - newL + 1;
-        if (curPathLength > ansLength) {
-            ansLength = curPathLength;
-            ansNodes = nodeCount;
-        } else if (curPathLength == ansLength && nodeCount < ansNodes) {
-            ansNodes = nodeCount;
+    private void dfs(
+            int node,
+            int currCost,
+            int prev,
+            List<Integer> left,
+            int[] nums,
+            Map<Integer, List<int[]>> graph,
+            List<Integer> costs,
+            Map<Integer, Integer> last,
+            int[] ans) {
+        int nodeColorIndexPrev = last.getOrDefault(nums[node], -1);
+        last.put(nums[node], costs.size());
+        costs.add(currCost);
+        int diff = currCost - costs.get(left.get(0));
+        int length = costs.size() - left.get(0);
+        if (diff > ans[0] || (diff == ans[0] && length < ans[1])) {
+            ans[0] = diff;
+            ans[1] = length;
         }
-        // Recurse for children using the updated left pointer newL.
-        for (int[] p : adj.get(node)) {
-            int child = p[0];
-            int w = p[1];
-            if (child == parent) {
+        for (int[] next : graph.getOrDefault(node, new ArrayList<>())) {
+            int nextNode = next[0];
+            int nextCost = next[1];
+            if (nextNode == prev) {
                 continue;
             }
-            dfs(child, node, curDist + w, newL, depth + 1);
-        }
-        // Backtracking: Restore frequency values for nodes removed from the window.
-        // That is, for indices i from newL-1 downto origL, undo the removal.
-        for (int i = newL - 1; i >= origL; i--) {
-            int remNode = path[i];
-            int remVal = nums[remNode];
-            if (freq[remVal] == 0) {
-                freq[remVal] = 1;
-            } else if (freq[remVal] == 1) {
-                freq[remVal] = 2;
-                dupCount++;
-            } else if (freq[remVal] == 2) {
-                freq[remVal] = 3;
-                overCount++;
-                dupCount--;
+            List<Integer> nextLeft = new ArrayList<>(left);
+            if (last.containsKey(nums[nextNode])) {
+                nextLeft.add(last.get(nums[nextNode]) + 1);
             }
+            nextLeft.sort(Comparator.naturalOrder());
+            while (nextLeft.size() > 2) {
+                nextLeft.remove(0);
+            }
+            dfs(nextNode, currCost + nextCost, node, nextLeft, nums, graph, costs, last, ans);
         }
-        // Finally, remove current node's contribution.
-        if (freq[v] == 1) {
-            freq[v] = 0;
-        } else if (freq[v] == 2) {
-            freq[v] = 1;
-            dupCount--;
-        } else if (freq[v] == 3) {
-            freq[v] = 2;
-            overCount--;
-            dupCount++;
-        }
+        last.put(nums[node], nodeColorIndexPrev);
+        costs.remove(costs.size() - 1);
     }
 }

src/test/java/g3401_3500/s3486_longest_special_path_ii/SolutionTest.java

@@ -28,4 +28,14 @@ void longestSpecialPath2() {
                                 new int[] {1, 1, 0, 2}),
                 equalTo(new int[] {5, 2}));
     }
+
+    @Test
+    void longestSpecialPath3() {
+        assertThat(
+                new Solution()
+                        .longestSpecialPath(
+                                new int[][] {{0, 2, 4}, {1, 2, 10}, {3, 1, 5}},
+                                new int[] {4, 5, 4, 5}),
+                equalTo(new int[] {15, 3}));
+    }
 }