Added Greedy, Graph, SlidingWindow, BFS, Backtracking, DynamicProgramming

Author: Prashant Jain

.gitignore

@@ -25,3 +25,4 @@ hs_err_pid*
 .idea/
 *.iml
 build/
+out/

src/in/knowledgegate/dsa/backtracking/NQueen.java

@@ -0,0 +1,102 @@
+package in.knowledgegate.dsa.backtracking;
+
+import java.util.Scanner;
+
+/**
+ * The n-queens puzzle is the problem of placing
+ * n queens on an n x n chessboard such that no
+ * two queens attack each other.
+ *
+ * Given an integer n, return any one solution
+ * to the n-queens puzzle. You may
+ * return the answer in any order.
+ *
+ * Each solution contains a distinct board
+ * configuration of the n-queens' placement,
+ * where 'Q' and '.' both indicate a queen and
+ * an empty space, respectively.
+ *
+ * Example 1:
+ * Input: n = 4
+ * Output: [["..Q.","Q...","...Q",".Q.."]]
+ *
+ * Example 2:
+ * Input: n = 1
+ * Output: [["Q"]]
+ *
+ * Constraints:
+ * 1 <= n <= 30
+ */
+public class NQueen {
+  private void printBoard(int[][] board) {
+    for (int i = 0; i < board.length; i++) {
+      for (int j = 0; j < board[i].length; j++) {
+        char out = board[i][j] == 1 ? 'Q' : '.';
+        System.out.print(" " + out + " ");
+      }
+      System.out.println();
+    }
+  }
+
+  private boolean isMoveSafe(int[][] board,
+          int row, int col) {
+
+    for (int j = 0; j < col; j++) {
+      if (board[row][j] == 1) {
+        return false;
+      }
+    }
+
+    for (int i = row, j = col; i >= 0 && j >=0; i--, j--) {
+      if (board[i][j] == 1) {
+        return false;
+      }
+    }
+
+    for (int i = row, j = col; j >= 0 && i < board.length; j--, i++) {
+      if (board[i][j] == 1) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * This method is only responsible to put queen
+   * in a specific column.
+   */
+  private boolean nQueen(int[][] board, int col) {
+    if (col >= board.length) {
+      return true;
+    }
+
+    for (int i = 0;i < board.length; i++) {
+      if (isMoveSafe(board, i, col)) {
+        board[i][col] = 1;
+        if (nQueen(board, col + 1)) return true;
+        board[i][col] = 0;
+      }
+    }
+
+    return false;
+  }
+
+  private void nQueen(int size) {
+    int[][] board = new int[size][size];
+    if (!nQueen(board, 0)) {
+      System.out.println("Solution does not " +
+          "exist");
+    } else {
+      printBoard(board);
+    }
+  }
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    NQueen nQueen = new NQueen();
+    System.out.print("Enter size of board: ");
+    int size = scanner.nextInt();
+    nQueen.nQueen(size);
+  }
+}

src/in/knowledgegate/dsa/bfs/InvertBinaryTree.java

@@ -0,0 +1,36 @@
+package in.knowledgegate.dsa.bfs;
+
+import in.knowledgegate.dsa.binarytree.model.TreeNode;
+
+/**
+ * Given the root of a binary tree, invert the
+ * tree, and return its root.
+ *
+ * Example 1:
+ *         4          4
+ *       2   7      7   2
+ *     1  3 6 9    9 6 3 1
+ *
+ * Input: root = [4,2,7,1,3,6,9]
+ * Output: [4,7,2,9,6,3,1]
+ *
+ * Example 2:
+ * Input: root = []
+ * Output: []
+ *
+ * Constraints:
+ * The number of nodes in the tree is in the
+ * range [0, 100].
+ * -100 <= Node.val <= 100
+ */
+public class InvertBinaryTree {
+  public TreeNode invertTree(TreeNode root) {
+    if (root == null) return null;
+    TreeNode temp = root.left;
+    root.left = root.right;
+    root.right = temp;
+    invertTree(root.left);
+    invertTree(root.right);
+    return root;
+  }
+}

src/in/knowledgegate/dsa/dynamicprogramming/RodCutting.java

@@ -0,0 +1,61 @@
+package in.knowledgegate.dsa.dynamicprogramming;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Given a rod of length n inches and an array
+ * of prices that includes prices of all pieces of
+ * size smaller than n. Determine the maximum
+ * value obtainable by cutting up the rod and
+ * selling the pieces. For example, if the length
+ * of the rod is 8 and the values of different pieces
+ * are given as the following, then the maximum
+ * obtainable value is 22 (by cutting in two
+ * pieces of lengths 2 and 6)
+ *
+ * Example:
+ * length   | 1   2   3   4   5   6   7   8
+ * --------------------------------------------
+ * price    | 1   5   8   9  10  17  17  20
+ * And if the prices are as following, then the
+ * maximum obtainable value is 24 (by cutting in
+ * eight pieces of length 1)
+ *
+ */
+public class RodCutting {
+  static int count = 0;
+
+  public static void main(String[] args) {
+    RodCutting rodCutting = new RodCutting();
+    int price[]
+        = new int[] { 1, 5, 8, 9, 10, 17, 17,
+        20, 24 };
+    int n = price.length;
+    Map<Integer, Integer> maxProfit =
+        new HashMap<>();
+    System.out.println(
+        "Maximum obtained value is "
+            + rodCutting.cutRod(price, n, maxProfit));
+    System.out.println("count is:" + count);
+  }
+
+  public int cutRod(int prices[], int length,
+      Map<Integer, Integer> maxProfit) {
+    if (length <= 0) return 0;
+    if (maxProfit.containsKey(length)) {
+      return maxProfit.get(length);
+    }
+    count++;
+    int maxVal = Integer.MIN_VALUE;
+
+    for (int i = 0; i < length; i++) {
+      maxVal = Math.max(maxVal,
+          prices[i] + cutRod(prices,
+              length - i - 1, maxProfit));
+    }
+
+    maxProfit.put(length, maxVal);
+    return maxVal;
+  }
+}

src/in/knowledgegate/dsa/graph/FindTheTownJudge.java

@@ -0,0 +1,60 @@
+package in.knowledgegate.dsa.graph;
+
+/**
+ * In a town, there are n people labeled from
+ * 1 to n. There is a rumor that one of these
+ * people is secretly the town judge.
+ *
+ * If the town judge exists, then:
+ *
+ * The town judge trusts nobody.
+ * Everybody (except for the town judge) trusts
+ * the town judge.
+ * There is exactly one person that satisfies
+ * properties 1 and 2.
+ * You are given an array trust where
+ * trust[i] = [ai, bi] representing that the
+ * person labeled ai trusts the person labeled bi.
+ *
+ * Return the label of the town judge if the town
+ * judge exists and can be identified, or
+ * return -1 otherwise.
+ *
+ * Example 1:
+ * Input: n = 2, trust = [[1,2]]
+ * Output: 2
+ *
+ * Example 2:
+ * Input: n = 3, trust = [[1,3],[2,3]]
+ * Output: 3
+ *
+ * Example 3:
+ * Input: n = 3, trust = [[1,3],[2,3],[3,1]]
+ * Output: -1
+ *
+ *
+ * Constraints:
+ * 1 <= n <= 1000
+ * 0 <= trust.length <= 104
+ * trust[i].length == 2
+ * All the pairs of trust are unique.
+ * ai != bi
+ * 1 <= ai, bi <= n
+ */
+public class FindTheTownJudge {
+  public int findJudge(int n, int[][] trust) {
+    int[] count = new int[n + 1];
+    for (int[] trustRow: trust) {
+      count[trustRow[0]]--;
+      count[trustRow[1]]++;
+    }
+
+    for (int i = 1; i < count.length; i++) {
+      if (count[i] == n-1) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+}

src/in/knowledgegate/dsa/greedy/BestTimeToBuyAndSellStock.java

@@ -0,0 +1,50 @@
+package in.knowledgegate.dsa.greedy;
+
+/**
+ * You are given an array prices where prices[i]
+ * is the price of a given stock on the ith day.
+ *
+ * You want to maximize your profit by choosing
+ * a single day to buy one stock and choosing a
+ * different day in the future to sell that stock.
+ *
+ * Return the maximum profit you can achieve from
+ * this transaction. If you cannot achieve any
+ * profit, return 0.
+ *
+ * Example 1:
+ * Input: prices = [7,1,5,3,6,4]
+ * Output: 5
+ * Explanation: Buy on day 2 (price = 1) and sell
+ * on day 5 (price = 6), profit = 6-1 = 5.
+ * Note that buying on day 2 and selling on day 1
+ * is not allowed because you must buy before you
+ * sell.
+ *
+ * Example 2:
+ * Input: prices = [7,6,4,3,1]
+ * Output: 0
+ * Explanation: In this case, no transactions
+ * are done and the max profit = 0.
+ *
+ *
+ * Constraints:
+ * 1 <= prices.length <= 105
+ * 0 <= prices[i] <= 104
+ */
+public class BestTimeToBuyAndSellStock {
+  public int maxProfit(int[] prices) {
+    int buy = prices[0], maxProfit = 0;
+    for (int i = 1; i < prices.length; i++) {
+      if (buy > prices[i]) {
+        buy = prices[i];
+      } else {
+        int currProfit = prices[i] - buy;
+        if (currProfit > maxProfit) {
+          maxProfit = currProfit;
+        }
+      }
+    }
+    return maxProfit;
+  }
+}

src/in/knowledgegate/dsa/maps/img.png

@@ -0,0 +1,40 @@
+package in.knowledgegate.dsa.slidingwindow;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Given an integer array nums and an integer k,
+ * return true if there are two distinct indices
+ * i and j in the array such that nums[i] == nums[j]
+ * and abs(i - j) <= k.
+ *
+ * Example 1:
+ * Input: nums = [1,2,3,1], k = 3
+ * Output: true
+ *
+ * Example 2:
+ * Input: nums = [1,0,1,1], k = 1
+ * Output: true
+ *
+ * Example 3:
+ * Input: nums = [1,2,3,1,2,3], k = 2
+ * Output: false
+ *
+ * Constraints:
+ * 1 <= nums.length <= 105
+ * -109 <= nums[i] <= 109
+ * 0 <= k <= 105
+ */
+public class ContainsDuplicate2 {
+  public boolean containsNearbyDuplicate(int[] nums, int k) {
+    Set<Integer> window = new HashSet<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (i > k) {
+        window.remove(nums[i - k - 1]);
+      }
+      if (!window.add(nums[i])) return true;
+    }
+    return false;
+  }
+}