Solutions added for LeetCode #289, #524

Author: rayworks

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

@@ -0,0 +1,70 @@
+package org.sean.array;
+
+/***
+ * 289. Game of Life
+ */
+public class LifeGame {
+    // follow up : in-place update
+    public void gameOfLife(int[][] board) {
+        update(board, 0);
+    }
+
+    // recursive
+    private void update(int[][] grid, int pos) {
+        int rCnt = grid.length;
+        int cCnt = grid[0].length;
+        if (pos >= rCnt * cCnt)
+            return;
+
+        int r = pos / cCnt;
+        int c = pos % cCnt;
+        int nVal = calc(grid, r, c);
+
+        update(grid, pos + 1);
+
+        grid[r][c] = nVal;
+    }
+
+    // basic idea
+    public void gameOfLife0(int[][] board) {
+        int rCnt = board.length;
+        int cCnt = board[0].length;
+
+        int[][] copy = new int[rCnt][cCnt];
+        for (int i = 0; i < rCnt; i++) {
+            for (int j = 0; j < cCnt; j++) {
+                copy[i][j] = calc(board, i, j);
+            }
+        }
+        for (int i = 0; i < board.length; i++) {
+            System.arraycopy(copy[i], 0, board[i], 0, cCnt);
+        }
+    }
+
+    private int calc(int[][] grid, int r, int c) {
+        int[][] dir = new int[][]{
+                {-1, -1}, {-1, 0}, {-1, 1},
+                {0, -1}, {0, 1},
+                {1, -1}, {1, 0}, {1, 1}
+        };
+        int cnt = 0;
+        int val = grid[r][c];
+        for (int[] offset : dir) {
+            int nr = r + offset[0];
+            int nc = c + offset[1];
+            if (nr >= 0 && nr < grid.length && nc >= 0 && nc < grid[0].length) {
+                if (grid[nr][nc] == 1) {
+                    cnt++;
+                }
+            }
+        }
+
+        int next;
+        if (val == 1)
+            next = cnt == 2 || cnt == 3 ? 1 : 0;
+        else
+            next = cnt == 3 ? 1 : 0;
+
+        return next;
+    }
+}

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

@@ -0,0 +1,87 @@
+package org.sean.array;
+
+import java.util.List;
+
+/***
+ * 524. Longest Word in Dictionary through Deleting
+ */
+public class LongestWordFinder {
+    // two pointers : O(m*n)
+    private boolean match(String text, String pat) {
+        if (text.length() < pat.length())
+            return false;
+
+        int i = 0;
+        int cnt = 0;
+        int startPos = 0;
+        int len = text.length();
+        while (i < pat.length()){
+            char ch = pat.charAt(i);
+            while (startPos < len) {
+                if(text.charAt(startPos) == ch) {
+                    break;
+                }
+                startPos++;
+            }
+
+            if(startPos == len) {
+                // not found
+                break;
+            }
+            startPos++;
+            cnt++;
+            i++;
+        }
+        return cnt == pat.length();
+    }
+
+    public String findLongestWord(String s, List<String> dictionary) {
+        dictionary.sort((o1, o2) -> {
+            if (o1.length() == o2.length())
+                return o1.compareTo(o2);
+            else
+                return Integer.compare(o2.length(), o1.length());
+        });
+
+        for (String word : dictionary) {
+            if(match(s, word))
+                return word;
+        }
+        return "";
+    }
+
+    // LCS O(m*k*n) TLE
+    private int lcs(String text, String pat) {
+        int rowLen = text.length();
+        int colLen = pat.length();
+        int[][] dp = new int[rowLen+1][colLen + 1];
+
+        for (int i = 1; i <= rowLen; i++) {
+            for (int j = 1; j <= colLen; j++) {
+                int adjacentMax = Math.max(dp[i][j - 1], dp[i - 1][j]);
+                if (text.charAt(i-1) == pat.charAt(j-1)) {
+                    dp[i][j] = Math.max(adjacentMax, dp[i - 1][j - 1] + 1);
+                }else {
+                    dp[i][j] = adjacentMax;
+                }
+            }
+        }
+        return dp[rowLen][colLen];
+    }
+
+    public String findLongestWord0(String s, List<String> dictionary) {
+        dictionary.sort((o1, o2) -> {
+            if (o1.length() == o2.length())
+                return o1.compareTo(o2);
+            else
+                return Integer.compare(o2.length(), o1.length());
+        });
+
+        for (String word : dictionary) {
+            int lcsLen = lcs(s, word);
+            if(lcsLen == word.length())
+                return word;
+        }
+        return "";
+    }
+}

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

@@ -0,0 +1,35 @@
+package org.sean.array;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class LifeGameTest {
+
+    private LifeGame game;
+
+    @Before
+    public void setUp() throws Exception {
+        game = new LifeGame();
+    }
+
+    @Test
+    public void gameOfLife() {
+        int[][] matrix = {
+                {0, 1, 0},
+                {0, 0, 1},
+                {1, 1, 1},
+                {0, 0, 0}
+        };
+        int[][] next = {
+                {0, 0, 0},
+                {1, 0, 1},
+                {0, 1, 1},
+                {0, 1, 0}
+        };
+
+        game.gameOfLife(matrix);
+        assertEquals(next, matrix);
+    }
+}

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

@@ -0,0 +1,30 @@
+package org.sean.array;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.*;
+
+public class LongestWordFinderTest {
+
+    private LongestWordFinder finder;
+
+    @Before
+    public void setUp() throws Exception {
+        finder = new LongestWordFinder();
+    }
+
+    @Test
+    public void findLongestWord() {
+        String longestWord = finder.findLongestWord("abpcplea", Arrays.asList("ale", "apple", "monkey", "plea"));
+        assertEquals("apple", longestWord);
+    }
+
+    @Test
+    public void testSingle() {
+        String longestWord = finder.findLongestWord("abpcplea", Arrays.asList("a", "b", "c"));
+        assertEquals("a", longestWord);
+    }
+}