group anagram,validanagram,NumbersofIsland

Author: jiangyong07

src/main/java/joshua/leetcode/array/unionfind/NumberOfIslands.java

@@ -0,0 +1,127 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.array.unionfind;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import joshua.leetcode.solutiontag.UnionFind;
+
+/**
+ * 200. Number of Islands<br/>
+ * <p/>
+ * <a href="https://leetcode.com/problems/number-of-islands/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class NumberOfIslands {
+
+    /**
+     * Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+     * <p/>
+     * Example 1:
+     * <p/>
+     * 11110
+     * 11010
+     * 11000
+     * 00000
+     * Answer: 1
+     * <p/>
+     * Example 2:
+     * <p/>
+     * 11000
+     * 11000
+     * 00100
+     * 00011
+     * Answer: 3
+     *
+     * @param grid
+     * @return
+     */
+    public abstract int numIslands(char[][] grid);
+
+    @UnionFind
+    public static class Solution1 extends NumberOfIslands {
+
+        @Override
+        public int numIslands(char[][] grid) {
+            if (grid == null || grid.length == 0 || grid[0] == null || grid[0].length == 0)
+                return 0;
+            int height = grid.length;
+            int width = grid[0].length;
+            int[] roots = new int[height * width];
+            for (int i = 0; i < roots.length; i++) {
+                int h = i / width;
+                int j = i % width;
+                if (grid[h][j] == '1') {
+                    roots[i] = i;
+                }
+            }
+            for (int i = 0; i < roots.length; i++) {
+                int h = i / width;
+                int w = i % width;
+                if (grid[h][w] == '0') continue;
+                // up
+                if (h > 0 && grid[h - 1][w] == '1') {
+                    connect(i, i - width, roots);
+                }
+                // left
+                if (w > 0 && grid[h][w - 1] == '1') {
+                    connect(i, i - 1, roots);
+                }
+            }
+            Set<Integer> distinctRoots = new HashSet<Integer>();
+            for (int i = 0; i < roots.length; i++) {
+                int h = i / width;
+                int w = i % width;
+                if (grid[h][w] == '0') continue;
+                int topRoot = findParent(roots, i);
+                distinctRoots.add(topRoot);
+            }
+            return distinctRoots.size();
+        }
+
+        private int findParent(int[] roots, int x) {
+            while (roots[x] != x) x = roots[x];
+            return x;
+        }
+
+        private void connect(int x, int y, int[] roots) {
+            int rootX = findParent(roots, x);
+            int rootY = findParent(roots, y);
+            if (rootX != rootY)
+                roots[rootX] = rootY;
+        }
+    }
+
+    public static class Solution2 extends NumberOfIslands {
+
+        @Override
+        public int numIslands(char[][] grid) {
+            if (grid == null || grid.length == 0 || grid[0] == null || grid[0].length == 0)
+                return 0;
+            int height = grid.length;
+            int width = grid[0].length;
+            int count = 0;
+            for (int i = 0; i < height; i++) {
+                for (int j = 0; j < width; j++) {
+                    if (grid[i][j] != '0') {
+                        markAsDrown(grid, i , j);
+                        count ++;
+                    }
+                }
+            }
+            return count;
+        }
+
+        private void markAsDrown(char[][] grid, int i, int j) {
+            if( i < 0 || i > grid.length -1 || j < 0 || j > grid[0].length -1 || grid[i][j] == '0')
+                return;
+            grid[i][j] = '0';
+            markAsDrown(grid, i - 1, j);
+            markAsDrown(grid, i + 1, j);
+            markAsDrown(grid, i, j-1);
+            markAsDrown(grid, i, j+1);
+        }
+    }
+}

src/main/java/joshua/leetcode/hashtable/GroupAnagrams.java

@@ -0,0 +1,76 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.hashtable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * 49. Group Anagrams<br/>
+ * <a href="https://leetcode.com/problems/anagrams/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class GroupAnagrams {
+
+    /**
+     * Given an array of strings, group anagrams together.
+     * <p/>
+     * For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"],
+     * Return:
+     * <p/>
+     * [<br/>
+     * ["ate", "eat","tea"],<br/>
+     * ["nat","tan"],<br/>
+     * ["bat"]<br/>
+     * ]<br/>
+     * Note:<br/>
+     * <ul>
+     * <li>For the return value, each inner list's elements must follow the lexicographic order.</li>
+     * <li>All inputs will be in lower-case.</li>
+     * </ul>
+     *
+     * @param strs
+     * @return
+     */
+    public abstract List<List<String>> groupAnagrams(String[] strs);
+
+    public static class Solution1 extends GroupAnagrams{
+
+        @Override
+        public List<List<String>> groupAnagrams(String[] strs) {
+            Map<String, List<String>> anagrams = new HashMap<String, List<String>>();
+            for (String str : strs) {
+                int[] flags = new int[26];
+                for(char ch : str.toCharArray()) {
+                    flags[ch - 'a']++;
+                }
+                StringBuilder stringBuilder = new StringBuilder();
+                for (int flag : flags) {
+                    stringBuilder.append(flag);
+                }
+                String key = stringBuilder.toString();
+                if (!anagrams.containsKey(key)) {
+                    List<String> group = new LinkedList<String>();
+                    group.add(str);
+                    anagrams.put(key, group);
+                } else {
+                    List<String> group = anagrams.get(key);
+                    group.add(str);
+                }
+            }
+            List<List<String>> result = new ArrayList<List<String>>();
+            for(List<String> group : anagrams.values()) {
+                Collections.sort(group);
+                result.add(group);
+            }
+            return result;
+        }
+    }
+}

src/main/java/joshua/leetcode/hashtable/ValidAnagram.java

@@ -0,0 +1,48 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.hashtable;
+
+/**
+ * 242. Valid Anagram<br/>
+ * <p/>
+ * <a href="https://leetcode.com/problems/valid-anagram/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class ValidAnagram {
+
+    /**
+     * Given two strings s and t, write a function to determine if t is an anagram of s.
+     * <p/>
+     * For example,
+     * s = "anagram", t = "nagaram", return true.
+     * s = "rat", t = "car", return false.
+     * <p/>
+     * Note:<br/>
+     * You may assume the string contains only lowercase alphabets.
+     * <p/>
+     * Follow up:<br/>
+     * What if the inputs contain unicode characters? How would you adapt your solution to such case?
+     *
+     * @param s
+     * @param t
+     * @return
+     */
+    public abstract boolean isAnagram(String s, String t);
+
+
+    public static class Solution1 extends ValidAnagram {
+
+        @Override
+        public boolean isAnagram(String s, String t) {
+            int[] flags = new int[26];
+            for(char ch : s.toCharArray()) flags[ch - 'a'] ++;
+            for(char ch : t.toCharArray()) flags[ch - 'a'] --;
+            for(int flag : flags)
+            {
+                if (flag != 0) return false;
+            }
+            return true;
+        }
+    }
+}

src/test/java/joshua/leetcode/array/unionfind/NumberOfIslandsTest.java

@@ -0,0 +1,44 @@
+package joshua.leetcode.array.unionfind;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.Maps;
+
+public class NumberOfIslandsTest {
+
+    private Map<char[][], Integer> cases = Maps.newHashMap();
+
+    @Before
+    public void setUp() {
+        char[][] islands = new char[][]{
+                {'1' ,'1','1'},
+                {'0' ,'1','0'},
+                {'1' ,'1','1'}
+        };
+        cases.put(islands, 1);
+    }
+
+    @Test
+    public void testSolution2() {
+        NumberOfIslands solution = new NumberOfIslands.Solution2();
+        for(char[][] islands : cases.keySet()) {
+            int num = solution.numIslands(islands);
+            assertEquals((int)cases.get(islands), num);
+        }
+    }
+
+    @Test
+    public void testSolution1() {
+        NumberOfIslands solution = new NumberOfIslands.Solution1();
+        for(char[][] islands : cases.keySet()) {
+            int num = solution.numIslands(islands);
+            assertEquals((int)cases.get(islands), num);
+        }
+    }
+
+}

src/test/java/joshua/leetcode/hashtable/GroupAnagramsTest.java

@@ -0,0 +1,40 @@
+package joshua.leetcode.hashtable;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+public class GroupAnagramsTest {
+
+    private Map<String[], List<List<String>>> cases = Maps.newHashMap();
+
+    @Before
+    public void setUp() {
+        String[] strings = new String[]{"eat", "tea", "tan", "ate", "nat", "bat"};
+        List<List<String>> results = new ArrayList<List<String>>();
+        results.add(Lists.newArrayList("ate", "eat","tea"));
+        results.add(Lists.newArrayList("nat","tan"));
+        results.add(Lists.newArrayList("bat"));
+        cases.put(strings, results);
+    }
+
+    @Test
+    public void testSolution1() {
+        GroupAnagrams solution = new GroupAnagrams.Solution1();
+        for(String[] testcase: cases.keySet()) {
+            List<List<String>> result = solution.groupAnagrams(testcase);
+            for(List<String> res :result) {
+                System.out.println(res);
+            }
+        }
+    }
+
+}

src/test/java/joshua/leetcode/hashtable/ValidAnagramTest.java

@@ -0,0 +1,29 @@
+package joshua.leetcode.hashtable;
+
+import static org.junit.Assert.*;
+
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.Maps;
+
+public class ValidAnagramTest {
+
+    private Map<String, String> postiveCases = Maps.newHashMap();
+    private Map<String, String> negativeCases = Maps.newHashMap();
+
+    @Before
+    public void setUp() {
+        postiveCases.put("nagaram", "anagram");
+    }
+
+    @Test
+    public void testSolution1() {
+        ValidAnagram solution = new ValidAnagram.Solution1();
+        for(String key : postiveCases.keySet()) {
+            assertTrue(solution.isAnagram(key, postiveCases.get(key)));
+        }
+    }
+}