Solutions added for LeetCode problems #71, #417, #2007

Author: rayworks

src/main/java/org/sean/array/ArrayFinder.java

@@ -0,0 +1,113 @@
+package org.sean.array;
+
+import java.util.*;
+
+/***
+ * 2007. Find Original Array From Doubled Array
+ */
+public class ArrayFinder {
+    // O(N)
+    public int[] findOriginalArray(int[] changed) {
+        int[] emptyArray = new int[0];
+        int len = changed.length;
+        if (len % 2 != 0) {
+            return emptyArray;
+        }
+
+        int max = Arrays.stream(changed).max().getAsInt();
+        int[] freq = new int[max + 1];
+        int[] out = new int[len / 2];
+
+        for (int e : changed) {
+            freq[e] += 1;
+        }
+
+        int j = 0;
+        for (int i = 0; i <= max; i++) {
+            while (freq[i] > 0) {
+                if (2 * i <= max && freq[i + i] > 0) {
+                    freq[i] -= 1;
+                    freq[i + i] -= 1;
+
+                    if (freq[i] < 0 || freq[i + i] < 0)
+                        return emptyArray;
+
+                    out[j++] = i;
+                } else {
+                    return emptyArray;
+                }
+            }
+        }
+        return out;
+    }
+
+    // O(N*lgN)
+    public int[] findOriginalArray0(int[] changed) {
+        int[] emptyArray = new int[0];
+        if (changed.length % 2 != 0) {
+            return emptyArray;
+        }
+
+        Arrays.sort(changed);
+
+        int len = changed.length;
+
+        // {k, [v]s}
+        HashMap<Integer, List<Integer>> map = new HashMap<>();
+
+        for (int i = 0; i < len; i++) {
+            List<Integer> positions = map.getOrDefault(changed[i], new ArrayList<>());
+            positions.add(i);
+
+            map.put(changed[i], positions);
+        }
+
+        List<Integer> out = new ArrayList<>();
+        int mid = len / 2;
+
+        int cnt = 0;
+        Set<Integer> visitedPos = new HashSet<>();
+
+        for (int i = len - 1; i >= 0; i--) {
+            if (visitedPos.contains(i))
+                continue;
+
+            int elem = changed[i];
+            visitedPos.add(i);
+
+            List<Integer> list = map.get(elem);
+            list.remove(list.size() - 1);
+            if (list.size() == 0) {
+                map.remove(elem);
+            }
+
+            if (elem % 2 == 0 && map.get(elem / 2) != null) {
+                int n = elem / 2;
+                if (map.containsKey(n)) {
+                    List<Integer> posList = map.get(n);
+
+                    visitedPos.add(posList.get(posList.size() - 1));
+                    posList.remove(posList.size() - 1);
+
+                    if (posList.size() == 0)
+                        map.remove(n);
+
+                    out.add(n);
+
+                    if (out.size() >= mid) {
+                        break;
+                    }
+                } else {
+                    //System.out.println("not found in map : " + n);
+                    return emptyArray;
+                }
+            } else {
+                //System.out.println("not found in map : " + n);
+                return emptyArray;
+            }
+        }
+
+        int[] array = out.stream().mapToInt(v -> v).toArray();
+        return array.length == len / 2 ? array : emptyArray;
+    }
+}

src/main/java/org/sean/graph/OceanWaterFlow.java

@@ -0,0 +1,80 @@
+package org.sean.graph;
+
+import java.util.*;
+
+/***
+ * 417. Pacific Atlantic Water Flow
+ */
+public class OceanWaterFlow {
+    private int[][] moves = new int[][]{
+            {1, 0}, {0, 1}, {-1, 0}, {0, -1}
+    };
+    private Set<Integer> visited = new HashSet<>();
+    private int[][] matrix;
+
+    public List<List<Integer>> pacificAtlantic(int[][] heights) {
+        int rowCnt = heights.length;
+        int colCnt = heights[0].length;
+
+        Queue<Integer> queue = new LinkedList<>();
+        matrix = new int[rowCnt][colCnt];
+
+        // pacific
+        for (int i = 0; i < rowCnt; i++) {
+            queue.add(i * colCnt);
+            visited.add(i * colCnt);
+        }
+        for (int i = 0; i < colCnt; i++) {
+            queue.add(i);
+            visited.add(i);
+        }
+        traverse(heights, rowCnt, colCnt, queue, 1);
+
+        // atlantic
+        visited.clear();
+        queue.clear();
+        for (int i = 0; i < rowCnt; i++) {
+            queue.add(colCnt * (i + 1) - 1);
+        }
+        for (int j = 0; j < colCnt; j++) {
+            queue.add((rowCnt - 1) * colCnt + j);
+        }
+        traverse(heights, rowCnt, colCnt, queue, 2);
+
+        ArrayList<List<Integer>> out = new ArrayList<>();
+        for (int i = 0; i < rowCnt; i++) {
+            for (int j = 0; j < colCnt; j++) {
+                if (matrix[i][j] == 3) {
+                    out.add(Arrays.asList(i, j));
+                }
+            }
+        }
+
+        return out;
+    }
+
+    private void traverse(int[][] heights, int rowCnt, int colCnt, Queue<Integer> queue, int dlt) {
+        while (!queue.isEmpty()) {
+            int sz = queue.size();
+            for (int i = 0; i < sz; i++) {
+                int loc = queue.poll();
+                int row = loc / colCnt;
+                int col = loc % colCnt;
+
+                if (matrix[row][col] < dlt)
+                    matrix[row][col] += dlt;
+
+                for (int[] diff : moves) {
+                    int nR = row + diff[0];
+                    int nC = col + diff[1];
+                    int newLoc = nR * colCnt + nC;
+                    if (nR >= 0 && nR < rowCnt && nC >= 0 && nC < colCnt && heights[row][col] <= heights[nR][nC]
+                            && !visited.contains(newLoc)) {
+                        queue.add(newLoc);
+                        visited.add(loc);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/org/sean/stack/PathHelper.java

@@ -0,0 +1,42 @@
+package org.sean.stack;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/***
+ * 71. Simplify Path
+ */
+public class PathHelper {
+    public String simplifyPath(String path) {
+        if (path.equals("/"))
+            return path;
+
+        String[] segments = path.split("\\/+");
+
+        Deque<String> stack = new ArrayDeque<>();
+        for (String segment : segments) {
+            if (segment.equals(".")) {
+                // No-Op
+            } else if (segment.equals("..")) {
+                if (!stack.isEmpty()) {
+                    stack.pop();
+                }
+            } else {
+                if (!segment.isEmpty())
+                    stack.push(segment);
+            }
+        }
+
+        StringBuilder builder = new StringBuilder();
+        while (!stack.isEmpty()) {
+            builder.insert(0, '/');
+            builder.insert(1, stack.pop());
+        }
+
+        if (builder.length() == 0) {
+            builder.append('/');
+        }
+
+        return builder.toString();
+    }
+}

src/test/java/org/sean/array/ArrayFinderTest.java

@@ -0,0 +1,28 @@
+package org.sean.array;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ArrayFinderTest {
+
+    private ArrayFinder finder;
+
+    @Before
+    public void setUp() throws Exception {
+        finder = new ArrayFinder();
+
+    }
+
+    @Test
+    public void findOriginalArray() {
+        int[] array = finder.findOriginalArray(new int[]{1, 3, 4, 2, 6, 8});
+        assertArrayEquals(new int[]{1, 3, 4}, array);
+    }
+
+    @Test
+    public void findInvalidArray() {
+        assertArrayEquals(new int[0], finder.findOriginalArray(new int[]{6, 3, 0, 1}));
+    }
+}

src/test/java/org/sean/graph/OceanWaterFlowTest.java

@@ -0,0 +1,35 @@
+package org.sean.graph;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class OceanWaterFlowTest {
+
+    private OceanWaterFlow waterFlow;
+
+    @Before
+    public void setUp() throws Exception {
+        waterFlow = new OceanWaterFlow();
+    }
+
+    @Test
+    public void pacificAtlantic() {
+        List<List<Integer>> lists = waterFlow.pacificAtlantic(new int[][]{
+                {1, 2, 2, 3, 5}, {3, 2, 3, 4, 4}, {2, 4, 5, 3, 1}, {6, 7, 1, 4, 5}, {5, 1, 1, 2, 4}
+        });
+
+        int[][] expected = new int[][]{{0, 4}, {1, 3}, {1, 4}, {2, 2}, {3, 0}, {3, 1}, {4, 0}};
+        List<List<Integer>> expectedList = new ArrayList<>();
+        for (int[] grp : expected) {
+            expectedList.add(Arrays.asList(grp[0], grp[1]));
+        }
+
+        assertEquals(expectedList, lists);
+    }
+}

src/test/java/org/sean/stack/PathHelperTest.java

@@ -0,0 +1,22 @@
+package org.sean.stack;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class PathHelperTest {
+
+    private PathHelper helper;
+
+    @Before
+    public void setUp() throws Exception {
+        helper = new PathHelper();
+    }
+
+    @Test
+    public void simplifyPath() {
+        assertEquals("/TJbrd/owxdG", helper.simplifyPath("///TJbrd/owxdG//"));
+        assertEquals("/c", helper.simplifyPath("/a/./b/../../c/"));
+    }
+}