Day 11 - 16 - Solutions

Author: suriyakrishna

src/main/java/com/kishan/java/leetcode/juneChallenges/RandomizedSet.java

@@ -0,0 +1,65 @@
+package com.kishan.java.leetcode.juneChallenges;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+public class RandomizedSet {
+
+    /**
+     * Initialize your data structure here.
+     */
+    private Map<Integer, Integer> valueMap;
+    private Map<Integer, Integer> indexMap;
+    private Random random = new Random();
+
+    public RandomizedSet() {
+        valueMap = new HashMap<Integer, Integer>();
+        indexMap = new HashMap<Integer, Integer>();
+    }
+
+    /**
+     * Inserts a value to the set. Returns true if the set did not already contain the specified element.
+     */
+    public boolean insert(int val) {
+        if (valueMap.containsKey(val)) {
+            return false;
+        }
+        valueMap.put(val, valueMap.size());
+        indexMap.put(indexMap.size(), val);
+        return true;
+    }
+
+    /**
+     * Removes a value from the set. Returns true if the set contained the specified element.
+     */
+    public boolean remove(int val) {
+        if (valueMap.containsKey(val)) {
+            int index = valueMap.get(val);
+            valueMap.remove(val);
+            indexMap.remove(index);
+            Integer tailElem = indexMap.get(indexMap.size());
+            if (tailElem != null) {
+                indexMap.put(index, tailElem);
+                valueMap.put(tailElem, index);
+                indexMap.remove(indexMap.size()-1);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get a random element from the set.
+     */
+    public int getRandom() {
+        if (valueMap.size() == 0) {
+            return -1;
+        }
+        if (valueMap.size() == 1) {
+            return indexMap.get(0);
+        }
+        int index = random.nextInt(valueMap.size());
+        return indexMap.get(index);
+    }
+}

src/main/java/com/kishan/java/leetcode/juneChallenges/Test.java

@@ -0,0 +1,4 @@
+package com.kishan.java.leetcode.juneChallenges;
+
+public class Test {
+}

src/main/scala/com/kishan/scala/leetcode/juneChallenges/CheapestFlightsWithinKStops.scala

@@ -0,0 +1,50 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+import java.util
+import java.util.PriorityQueue
+
+import scala.collection.JavaConverters._
+
+object CheapestFlightsWithinKStops {
+  def main(args: Array[String]): Unit = {
+    val n = 5 // Number of cities
+    val edges = Array(Array(1, 2, 10), Array(2, 0, 7), Array(1, 3, 8), Array(4, 0, 10), Array(3, 4, 2), Array(4, 2, 10), Array(0, 3, 3), Array(3, 1, 6), Array(2, 4, 5))
+    val src = 0
+    val dst = 4
+    val k = 1 // Number of Stops
+    val result = findCheapestPrice(n, edges, src, dst, k)
+    println(result, result == 5)
+
+  }
+
+  def findCheapestPrice(n: Int, flights: Array[Array[Int]], src: Int, dst: Int, K: Int): Int = {
+
+    if (flights.length == 0) {
+      return -1
+    }
+    //Building Graph
+    var map: java.util.Map[Int, util.Map[Int, Int]] = new util.HashMap[Int, util.Map[Int, Int]]()
+    flights.foreach(a => {
+      if (map.get(a(0)) == null) {
+        map.put(a(0), new util.HashMap[Int, Int]())
+      }
+      map.get(a(0)).put(a(1), a(2))
+    })
+
+    var q: PriorityQueue[Node] = new PriorityQueue[Node]((a, b) => a.cost - b.cost)
+    q.add(Node(src, 0, -1))
+    while (!q.isEmpty) {
+      val curr: Node = q.poll
+      if (curr.city == dst) return curr.cost
+      if (curr.stop < K) {
+        val nexts: util.Map[Int, Int] = map.getOrDefault(curr.city, new util.HashMap[Int, Int])
+        for (next <- nexts.asScala) {
+          q.add(Node(next._1, curr.cost + next._2, curr.stop + 1))
+        }
+      }
+    }
+    return -1
+  }
+}
+
+case class Node(city: Int, cost: Int, stop: Int)

src/main/scala/com/kishan/scala/leetcode/juneChallenges/LargestDivisibleSubset.scala

@@ -0,0 +1,79 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+
+/*
+* Given a set of distinct positive integers, find the largest subset such that
+* every pair (Si, Sj) of elements in this subset satisfies:
+* Si % Sj = 0 or Sj % Si = 0.
+* If there are multiple solutions, return any subset is fine.
+*
+* */
+
+/*
+* Input: [1,2,3]
+  Output: [1,2] (of course, [1,3] will also be ok)
+* Input: [1,2,4,8]
+  Output: [1,2,4,8]
+* */
+
+/*
+* Approach:
+*
+* We will check if the array is empty or it has only one element. If yes we will return the array as list.
+*
+* If array length is greater than 1.
+* 1. First, we will sort the elements in the array. [3,4,16,8] -> [3,4,8,16]
+* 2. We will create a empty Map for which the integer value will be the key and the possible integers will be stored as the list of integers.
+* 3. So for every Integer in the list it should need to have the self value in the temp_list of value. Because, the integer will be divisible by itself.
+* 4. We will iterate through the each element of the list and if we have any keys in the map we will try to divide the number by the key.
+*    If the number is divisible and if we have list of integer for the key we will assign this list to temp_list that we created.
+* 5. Next, we will add the current number to the temp list and we will put the (key, temp_list) to the map.
+* 6. Finally, we will get the values from the map and will return the list with maximum length.
+*
+* Explanation:
+* input = [3,4,16,8]
+*
+* Step 1: Sorting -> [3,4,8,16]
+* Step 2: Create empty Map[Int, List[Int]]
+* Step 3: Iterate through the the sorted list
+* Step 4: For every int in the list. We will have a key -> value in the Map.
+*
+* Iteration:
+* 3 -> [3]
+* 4 % 3 is not equal to 0. temp_list = [] and 4 is divisible by 4. So 4 -> [4]
+* 8 % 3 no, 8%4 equal to 0. temp_list = [4] and 8 will be divisible by it self. So 8 -> [4,8]
+* 16 % 3 no, 16 % 4. temp_list = [4] and 16 % 8. temp_list = [4,8] and 16 will be divisible by itself. So 16 -> [4,8,16]
+*
+* we will get values from the map. [[3], [4], [4,8], [4,8,16]] and we will return the list with maximum length.
+* */
+
+
+object LargestDivisibleSubset {
+  def main(args: Array[String]): Unit = {
+    val nums = Array(3, 4, 16, 8)
+
+    println(largestDivisibleSubset(nums).mkString(","))
+  }
+
+  def largestDivisibleSubset(nums: Array[Int]): List[Int] = {
+    if (nums.length <= 1) {
+      return nums.toList
+    }
+    val sortedNums = nums.sortBy(a => a)
+    var map: Map[Int, List[Int]] = Map()
+    for (num <- sortedNums) {
+      var list: List[Int] = List()
+      for (key <- map.keys) {
+        if (num % key == 0) {
+          if (map(key).length > list.length) {
+            list = map(key)
+          }
+        }
+      }
+      list = list :+ num
+      map += (num -> list)
+    }
+    return map.values.maxBy(_.length)
+  }
+
+}

src/main/scala/com/kishan/scala/leetcode/juneChallenges/RandomizedSet.scala

@@ -0,0 +1,117 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+import java.util
+
+import scala.util.Random
+
+/*
+* Design a data structure that supports all following operations in average O(1) time.
+    insert(val): Inserts an item val to the set if not already present.
+    remove(val): Removes an item val from the set if present.
+    getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.
+* */
+
+/*
+*
+// Init an empty set.
+RandomizedSet randomSet = new RandomizedSet();
+
+// Inserts 1 to the set. Returns true as 1 was inserted successfully.
+randomSet.insert(1);
+
+// Returns false as 2 does not exist in the set.
+randomSet.remove(2);
+
+// Inserts 2 to the set, returns true. Set now contains [1,2].
+randomSet.insert(2);
+
+// getRandom should return either 1 or 2 randomly.
+randomSet.getRandom();
+
+// Removes 1 from the set, returns true. Set now contains [2].
+randomSet.remove(1);
+
+// 2 was already in the set, so return false.
+randomSet.insert(2);
+
+// Since 2 is the only number in the set, getRandom always return 2.
+randomSet.getRandom();
+* */
+
+/*
+* Approach:
+*
+* 1. Using Map Type we can achieve 0(1) for inserting, accessing and removing item.
+* 2. For getting Random number we can create random object using Random and we can get the random integer number which will yield random integer number for the limit. We can use the random integer number to get item from the Map.
+*
+* First, we will create two map object -
+*   a. valueMap object will hold the value as key and index as value.
+*   b. indexMap object will hold the index as key and value as value.
+*
+* Insert Operation:
+* When ever we want a value to be inserted into the valueMap. First we will check if valueMap contains that value. If it doesn't have the value we will insert the element into valueMap with the index as value and we will insert value to the indexMap with index as key.
+*
+* Remove Operation:
+* 1. First, we will get the index of the value to be removed from the valueMap.
+* 2. We will remove the index from the valueMap and value from indexMap.
+* 3. Now we have to replace the index value that has been removed, with the last Index i.e If [0,1,2] are our Indices and we removed 1 so we will have [0,2]. Now, we have to replace 2 with 1. By doing so we will not have any discrepancy in the order of index values.
+* 4. For that we will get the tail element from the indexMap.
+* 5. We will replace the index of the tail element with the index of the value that we removed and we will create new entry for that index in the indexMap and we will remove the tailelem from the indexMap
+*
+* getRandom:
+* 1. If the size of value map is 0 we will return -1. If size of value map is 1 we will return tail or head of values from the indexMap.
+* 2. For other cases we have to get the random integer value for the length of valueMap.
+* 3. We will use the randomInteger value to get the item from the indexMap.
+* */
+
+
+class RandomizedSet() {
+
+  private val random = new Random()
+  /** Initialize your data structure here. */
+  private var valueMap: java.util.Map[Int, Int] = new util.HashMap[Int, Int]()
+  private var indexMap: java.util.Map[Int, Int] = new util.HashMap[Int, Int]()
+
+  /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+  def insert(`val`: Int): Boolean = {
+    if (valueMap.getOrDefault(`val`, Int.MinValue) != Int.MinValue) {
+      false
+    } else {
+      valueMap.put(`val`, valueMap.size())
+      indexMap.put(indexMap.size(), `val`)
+      true
+    }
+  }
+
+  /** Removes a value from the set. Returns true if the set contained the specified element. */
+  def remove(`val`: Int): Boolean = {
+    if (valueMap.getOrDefault(`val`, Int.MinValue) != Int.MinValue) {
+      val index = valueMap.get(`val`)
+      valueMap.remove(`val`)
+      indexMap.remove(index)
+      val tailElem = indexMap.getOrDefault(indexMap.size, Int.MinValue)
+      if (tailElem != Int.MinValue) {
+        indexMap.put(index, tailElem)
+        valueMap.put(tailElem, index)
+        indexMap.remove(indexMap.size()-1)
+      }
+      true
+    } else {
+      false
+    }
+  }
+
+  /** Get a random element from the set. */
+  def getRandom(): Int = {
+    if (valueMap.size == 0) {
+      return -1
+    }
+
+    if (valueMap.size == 1) {
+      return indexMap.get(0)
+    }
+    val index: Int = random.nextInt(valueMap.size)
+
+    indexMap.get(index)
+  }
+}

src/main/scala/com/kishan/scala/leetcode/juneChallenges/SearchInBST.scala

@@ -0,0 +1,60 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+import scala.annotation.tailrec
+
+/*
+* Given the root node of a binary search tree (BST) and a value. You need to find the node in the BST that the node's value equals the given value.
+* Return the subtree rooted with that node. If such node doesn't exist, you should return NULL.
+*
+* */
+
+/*
+* Given the tree:
+        4
+       / \
+      2   7
+     / \
+    1   3
+
+  And the value to search: 2
+*
+* Output:
+*     2
+     / \
+    1   3
+*
+* In the example above, if we want to search the value 5, since there is no node with value 5, we should return NULL.
+  Note that an empty tree is represented by NULL, therefore you would see the expected output (serialized tree format) as [], not null.
+* */
+
+
+/*
+* Approach: Tail Recursion
+* 1. We will check the root.value == val. If equal we will return the root.
+* 2. If val < root.value and root.left is not null then our val should be in the left side of the root. Now we will call the function recursively.
+* 3. Similarly if val > root.value and root.right is not null we will call the function recursively and our val will be in the right side of the tree.
+* 4. Finally, If our val is not found we are creating a value of Type TreeNode and assigning null value to it. We will return the Empty TreeNode.
+*
+* */
+
+object SearchInBST {
+  @tailrec
+  def searchBST(root: TreeNode, `val`: Int): TreeNode = {
+    if (root.value == `val`) {
+      root
+    } else if (`val` < root.value && root.left != null) {
+      searchBST(root.left, `val`)
+    } else if (`val` > root.value && root.right != null) {
+      searchBST(root.right, `val`)
+    } else {
+      val t: TreeNode = null
+      t
+    }
+  }
+
+  def main(args: Array[String]): Unit = {
+    val t: TreeNode = new TreeNode(4, new TreeNode(2, new TreeNode(1), new TreeNode(3)), new TreeNode(7))
+    println("Input Binary Tree: " + t)
+    println("Result Binary Tree: " + searchBST(t, 7))
+  }
+}