Accepted

Author: gouthampradhan

problems/src/BoundaryOfBinaryTree.java

@@ -0,0 +1,120 @@
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 27/03/2017.
+ * Accepted
+ */
+public class BoundaryOfBinaryTree
+{
+    public static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+
+    private Set<TreeNode> done = new HashSet<>();
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception
+    {
+        TreeNode root = new TreeNode(1);
+        /*root.right = new TreeNode(2);
+        root.right.right = new TreeNode(3);
+        root.right.right.right = new TreeNode(4);
+        root.right.right.right.left = new TreeNode(5);
+        root.right.right.right.left.right = new TreeNode(6);
+        /*root.left = new TreeNode(2);
+        root.left.left = new TreeNode(4);
+        root.left.right = new TreeNode(5);
+        root.left.right.left = new TreeNode(7);
+        root.left.right.right = new TreeNode(8);
+        root.right = new TreeNode(3);
+        root.right.left = new TreeNode(6);
+        root.right.left.left = new TreeNode(9);
+        root.right.left.right = new TreeNode(10);*/
+        System.out.println(new BoundaryOfBinaryTree().boundaryOfBinaryTree(root));
+    }
+
+    public List<Integer> boundaryOfBinaryTree(TreeNode root)
+    {
+        if(root == null) return new ArrayList<>();
+        List<Integer> antiClockwiseCollection = new ArrayList<>();
+        List<Integer> collection = new ArrayList<>();
+
+        if(root.left != null)
+            leftShoulder(root, collection);
+        else
+        {
+            if(!done.contains(root))
+            {
+                done.add(root);
+                collection.add(root.val);
+            }
+        }
+
+        antiClockwiseCollection.addAll(collection);
+        collection.clear();
+        leafNode(root, collection);
+        antiClockwiseCollection.addAll(collection);
+        collection.clear();
+
+        if(root.right != null)
+            rightShoulder(root, collection);
+        else
+        {
+            if(!done.contains(root))
+            {
+                done.add(root);
+                collection.add(root.val);
+            }
+        }
+
+        Stack<Integer> stack = new Stack<>();
+        stack.addAll(collection);
+        while(!stack.isEmpty())
+            antiClockwiseCollection.add(stack.pop());
+        return new ArrayList<>(antiClockwiseCollection);
+    }
+
+    private void leftShoulder(TreeNode node, List<Integer> list)
+    {
+        if(node == null) return;
+        if(!done.contains(node))
+        {
+            list.add(node.val);
+            done.add(node);
+        }
+
+        if(node.left != null) leftShoulder(node.left, list);
+        else if(node.right != null) leftShoulder(node.right, list);
+    }
+
+    private void rightShoulder(TreeNode node, List<Integer> list)
+    {
+        if(node == null) return;
+        if(!done.contains(node))
+        {
+            list.add(node.val);
+            done.add(node);
+        }
+        if(node.right != null) rightShoulder(node.right, list);
+        else if(node.left != null) rightShoulder(node.left, list);
+    }
+
+    private void leafNode(TreeNode node, List<Integer> list)
+    {
+        if(node == null) return;
+        if(node.left == null && node.right == null)
+            if(!done.contains(node))
+            {
+                list.add(node.val);
+                done.add(node);
+            }
+        leafNode(node.left, list);
+        leafNode(node.right, list);
+    }
+}

problems/src/KdiffPairsInanArray.java

@@ -0,0 +1,44 @@
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 28/03/2017.
+ */
+public class KdiffPairsInanArray
+{
+    private Map<Integer, Integer> map = new HashMap<>();
+    private int count = 0;
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception
+    {
+        int[] nums = {1,2,3,4,5};
+        System.out.println(new KdiffPairsInanArray().findPairs(nums, -1));
+    }
+
+    public int findPairs(int[] nums, int k)
+    {
+        if(nums.length == 0 || k < 0) return 0;
+        for(int i : nums)
+        {
+            map.put(i, map.getOrDefault(i, 0) + 1);
+        }
+        for(Map.Entry<Integer, Integer> entry : map.entrySet())
+        {
+            if(k == 0)
+            {
+                if(entry.getValue() > 1)
+                    count ++;
+            }
+            else
+            {
+                if(map.containsKey(entry.getKey() + k))
+                    count ++;
+            }
+        }
+        return count;
+    }
+
+}

problems/src/LongestPalindromicSubsequence.java

@@ -0,0 +1,29 @@
+/**
+ * Created by gouthamvidyapradhan on 27/03/2017.
+ */
+public class LongestPalindromicSubsequence
+{
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception
+    {
+        System.out.println(new LongestPalindromicSubsequence().longestPalindromeSubseq("bbbab"));
+    }
+
+    public int longestPalindromeSubseq(String s)
+    {
+        int[][] dp = new int[s.length() + 1][s.length() + 1];
+        String sI = new StringBuilder(s).reverse().toString();
+        for(int i = 1, l = s.length(); i <= l; i++)
+            for(int j = 1; j <= l; j++)
+            {
+                dp[i][j] = (s.charAt(i - 1) == sI.charAt(j - 1)) ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+
+        return dp[s.length()][s.length()];
+    }
+
+}