Merge pull request #12 from sathiiii/master

Added new solutions to Hackerrank/Algorithms

Author: gihanjayatilaka

codeBase/HackerRank/Algorithms/Dynamic Programming/Bricks Game/Solution.cpp

@@ -0,0 +1,34 @@
+/*
+    Copyright (C) 2020, Sathira Silva.
+    
+    Problem Statement:  You and your friend decide to play a game using a stack consisting of N bricks. In this game, you can 
+                        alternatively remove 1, 2 or 3 bricks from the top, and the numbers etched on the removed bricks are 
+                        added to your score. You have to play so that you obtain the maximum possible score. It is given that your 
+                        friend will also play optimally and you make the first move.
+*/
+
+#include <bits/stdc++.h>
+#include <numeric>
+
+using namespace std;
+
+vector<string> split_string(string);
+
+long long bricksGame(vector<int> arr) {
+    int n = arr.size();
+    long long score[n];
+    if (arr.size() <= 3)
+        return accumulate(arr.begin(), arr.end(), 0);
+    // Base Cases:
+    score[n - 1] = arr[n - 1];
+    score[n - 2] = score[n - 1] + arr[n - 2];
+    score[n - 3] = score[n - 2] + arr[n - 3];
+    long long sum = score[n - 3];
+    // Build the optimal solution using the optimal solutions of it's subproblems.
+    // Traverse the array backwards and get the cumulative sum at each state.
+    for (int i = n - 4; i >= 0; i--) {
+        sum += arr[i];
+        score[i] = sum - min({score[i + 1], score[i + 2], score[i + 3]});
+    }
+    return score[0];
+}

codeBase/HackerRank/Algorithms/Dynamic Programming/Cut Tree/Solution.cpp

@@ -0,0 +1,46 @@
+/*
+    Problem Statement:  Given a tree T with n nodes, how many subtrees (T') of T have at most K edges connected to (T - T')?
+    
+    Approach:   The idea is to depth first traverse the tree and count the subtrees having number of edges connected to the complement 
+                of the current subtree upto k edges.
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+vector<string> split_string(string);
+
+vector<int> tree[51];
+long long dp[51][51];
+int k;
+
+void dfs(int u, int parent = -1) {
+    for (int v: tree[u]) {
+        if (v == parent)
+            continue;
+        dfs(v, u);
+        for (int j = k; j > 0; j--) {
+            for (int x = j; x > 0; x--)
+                dp[u][j] += dp[u][j - x] * dp[v][x];
+            dp[u][j] += dp[u][j - 1];
+        }
+    }
+    return;
+}
+
+long long cutTree(int n, vector<vector<int>> edges) {
+    for (auto e: edges) {
+        tree[e[0]].push_back(e[1]);
+        tree[e[1]].push_back(e[0]);
+    }
+    long long subtrees = 0;
+    memset(dp, 0, sizeof(dp));
+    for(int u = 1; u <= n; u++)
+        dp[u][0] = 1;   // Base case
+    dfs(1);
+    for(int i = 1; i <= n; i++)
+        for(int j = 0; j < k; j++)
+                subtrees += dp[i][j];
+    return subtrees + dp[1][k] + 1;
+}

codeBase/HackerRank/Algorithms/Dynamic Programming/Kingdom Division/solution.py

@@ -0,0 +1,49 @@
+'''
+    Copyright (C) 2020, Sathira Silva.
+    
+    Problem Statement:  King Arthur has a large kingdom that can be represented as a tree, where nodes correspond to cities and edges 
+    correspond to the roads between cities. The kingdom has a total of n cities numbered from 1 to n. The King wants to divide his kingdom 
+    between his two children, Reggie and Betty, by giving each of them 0 or more cities; however, they don't get along so he must divide 
+    the kingdom in such a way that they will not invade each other's cities. The first sibling will invade the second sibling's city if 
+    the second sibling has no other cities directly connected to it.
+    Given a map of the kingdom's n cities, find and print the number of ways King Arthur can divide it between his two children such that 
+    they will not invade each other. As this answer can be quite large, it must be modulo 7 + 10 ^ 9.
+    
+    Approach:   We have to find the number of ways of colouring subtrees such that its root node has the same colour as the subtree.
+                This can be easily done with Dynamic Programming and DFS traversal to find the subtrees.
+'''
+
+from collections import defaultdict
+sys.setrecursionlimit(10 ** 6)
+
+mod = 7 + 10 ** 9
+
+def dfs(city, kingdom, visited):
+    global dp
+    visited[city] = True
+    for neighbourCity in kingdom[city]:
+        if visited[neighbourCity]:
+            continue
+        dfs(neighbourCity, kingdom, visited)
+        dp[city][0] = (dp[city][0] * dp[neighbourCity][1]) % mod
+        dp[city][1] = (dp[city][1] * (2 * dp[neighbourCity][1] + dp[neighbourCity][0])) % mod
+    dp[city][1] -= dp[city][0]
+
+def kingdomDivision(n, roads):
+    global dp
+    visited = [False] * (n + 1)
+    kingdom = defaultdict(list)
+    for u, v in roads:
+        kingdom[u].append(v)
+        kingdom[v].append(u)
+    dfs(1, kingdom, visited)
+    return (2 * dp[1][1]) % mod
+
+if __name__ == '__main__':
+    n = int(stdin.readline())
+    roads = []
+    for _ in range(n-1):
+        roads.append(list(map(int, stdin.readline().rstrip().split())))
+    dp = [[1, 1] for _ in range(n + 1)]
+    result = kingdomDivision(n, roads)
+    stdout.write(str(result) + '\n')

codeBase/HackerRank/Algorithms/Dynamic Programming/Knapsack/solution.py

@@ -0,0 +1,32 @@
+'''
+    Copyright (C) 2020, Sathira Silva.  
+    
+    Problem Statement: Given an array of integers and a target sum, determine the sum nearest to but not exceeding 
+    the target that can be created. To create the sum, use any element of your array zero or more times.
+    
+    Approach: This's a variation of the 0-1 knapsack problem which can be solved easily using Dynamic Programming. Given the capacity of
+    the knapsack, we have to pack items from the given list of items (and there're infinitely many items from each item)
+    such that the total size doesn't exceed the capacity of the knapsack.
+    
+    (01). Subproblem: dp[capacity] for all 0 < capacity <= k
+                      Maximum capacity that can be packed from the items such that the total capacity doesn't exceed i.
+    (02). Guessing:   is item i included or not?
+    (03). Recurrence: dp[capacity] = max(dp[capacity], items[i] + dp[capacity - items[i]])
+    (04). Toplogical order: for capacity -> 0,...,k
+                                for item -> 0,...,n - 1
+    (05). Original problem: dp[k]
+    
+    Time Complexity: O(n(k + 1)) ~= O(mk) ; m <= n
+'''
+
+def unboundedKnapsack(k, items):
+    # Since the same item can be repeatedly appear in the given list, extract only the unique items. This makes the algorithm 
+    # more efficient.
+    items = list(set(items))
+    n = len(items)
+    dp = [0] * (k + 1)
+    for capacity in range(k + 1):
+        for i in range(n):
+            if items[i] <= capacity:
+                dp[capacity] = max(dp[capacity], items[i] + dp[capacity - items[i]])
+    return dp[k]

codeBase/HackerRank/Algorithms/Dynamic Programming/Red John Is Back/Solution.cpp

@@ -0,0 +1,48 @@
+/*
+    Problem Statement:    https://www.hackerrank.com/challenges/red-john-is-back/problem
+    
+    Approach:   This problem can be solved using Dynamic Programming and Sieve of Eratosthenes (Or any other algorithm for sieving
+    primes) easily. First we find the number of ways of covering a 4 x n wall with 4 x 1 and 1 x 4 bricks. Then we count the number of
+    primes less than or equal to that number.
+    
+    (01). Subproblem:    dp[i]
+                         (How many ways are there to cover a 4 x i wall)
+    (02). Guess:         dp[i - 1] and dp[i - 4]
+                         (Should we cover the remaining are with a 4 x 1 brick or a 1 x 4 brick?)
+    (03). Recurrence:    dp[i] = dp[i - 1] + dp[i - 4]
+                         (Base Cases: dp[0] = dp[1] = dp[2] = dp[3] = 1)
+    (04). Toplogical Order:   i from  4 to n
+    (05). Original Problem:   dp[n]
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int dp[61];
+bool prime[10000001];
+
+void sieveOfEratosthenes(int n) 
+{
+    memset(prime, true, sizeof(prime)); 
+    for (int p = 2; p * p <= n; p++) 
+    {
+        if (prime[p] == true) 
+        {
+            for (int i = p * p; i <= n; i += p) 
+                prime[i] = false;
+        } 
+    }
+} 
+
+int redJohn(int n) {
+    dp[0] = dp[1] = dp[2] = dp[3] = 1;
+    for (int i = 4; i <= n; i++)
+        dp[i] = dp[i - 1] + dp[i - 4];
+    int count = 0;
+    for (int i = 2; i <= dp[n]; i++) {
+        if (prime[i])
+            count++;
+    }
+    return count;
+}

codeBase/HackerRank/Algorithms/Dynamic Programming/Sherlock And Cost/solution.py

@@ -0,0 +1,31 @@
+  
+'''
+    Copyright (C) 2020, Sathira Silva.
+    
+    Problem Statement: In this challenge, you will be given an array B and must determine an array A. There is a special rule: For all i,
+    A[i] <= B[i]. That is, A[i] can be any number you choose such that 1 <= A[i] <= B[i]. Your task is to select a series of A[i] given B[i]
+    such that the sum of the absolute difference of consecutive pairs of A is maximized. This will be the array's cost, and will be 
+    represented by the variable S below.
+    
+    S = Sum(|A[i] - A[i - 1]) from i = 2 to N
+    
+    Approach:  To obtain the maximum sum S, there're only two possibilities: A[i] is 1 or B[i]. We don't have to check any number between
+    1 and B[i]. Therefore, this's sort of a 0-1 Knapsack problem. It can be solved by 4 lines of code using Dynamic Programming.
+    
+    (01). Subproblem:  Optimal sum of the absolute difference of consecutive pairs of prefix A[:i + 1].
+                       max(dp)
+                       Base Case: Initially, dp = [0, 0]. Because When A is empty, maximum sum is 0.
+    (02). Guessing:    Is the maximum sum obtained when A[i] = 1 or A[i] = B[i]?
+    (03). Recurrence:  dp = [max(dp[1] + B[i - 1] - 1, dp[0]), max(dp[1] + abs(B[i] - B[i - 1]), dp[0] + B[i] - 1)]
+    (04). Topological Order: i from 1 to len(B) - 1
+    (05). Original Probblem: max(dp) of A[:len(B)]
+    
+    Time Complexity:    O(|B| - 1)
+'''
+
+def cost(B):
+    # Base Case
+    dp = [0, 0]
+    for i in range(1,len(B)):
+        dp = [max(dp[1] + B[i - 1] - 1, dp[0]), max(dp[1] + abs(B[i] - B[i - 1]), dp[0] + B[i] - 1)]
+    return max(dp)

codeBase/HackerRank/Algorithms/Dynamic Programming/The Coin Change Problem/solution.py

@@ -0,0 +1,32 @@
+'''
+    Copyright (C) 2020, Sathira Silva
+    
+    Problem Statement: You are working at the cash counter at a fun-fair, and you have different types of coins available to you in 
+    infinite quantities. The value of each coin is already given. Can you determine the number of ways of making change for a particular 
+    number of units using the given types of coins?
+    
+    Approach: This another variant of 0-1 Knapsack problem. Given different types of coins in infinite amounts, we have to find how many 
+    number of subsets of coins are there such that the sum of the values of the coins in the subset is equal to the given amount. This
+    can be easily solved by Dynamic Programming.
+    
+    (01). Subproblem: dp[change]
+                      Number of ways of making change for 'change' units.
+    (02). Guessing:   Include the current coin or not?
+    (03). Recurrence: dp[change] += dp[change - coin] for all changes that can be made upto n and values of the coins.
+                      dp[change] is dp[change] + number of ways of making change when coin 'coin' is included(for change-coin units).
+                      Base Case: dp[0] - Number of ways of making change for 0 units is 1 i.e. doing nothing.
+    (04). Topological Order: for coins, the order doesn't matter. for change in coin,...,(n + 1)
+    (05). Original Problem: dp[n]
+                            Number of ways of making change for n units.
+                            
+    Time Complexity: Less than O(nm); m = number of different coin types
+'''
+
+def getWays(n, coins):
+    dp = [0] * (n + 1)
+    # Base Case: Number of ways of making change for 0 units is 1 i.e. doing nothing.
+    dp[0] = 1
+    for coin in coins:
+        for change in range(coin, n + 1):
+            dp[change] += dp[change - coin]
+    return dp[n]

codeBase/HackerRank/Algorithms/Game Theory/Deforestation/Solution.cpp

@@ -0,0 +1,27 @@
+/*
+    Copyright (C) 2020, Sathira Silva.
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int grundy[501];
+
+int dfs(int u, int p, vector<vector<int>>& G){
+    for(auto ch : G[u]){
+        if(ch != p) grundy[u] ^= dfs(ch,u,G);
+    }
+    return u == 1 ? grundy[u] : ++grundy[u];
+}
+
+
+string deforestation(int n, vector<vector<int>> tree) {
+    memset(gr, 0, sizeof(gr));
+    vector<vector<int>> graph(n+1);
+    for(auto p : tree){
+        graph[p[0]].push_back(p[1]);
+        graph[p[1]].push_back(p[0]);
+    }
+    return dfs(1, -1, graph) ? "Alice" : "Bob";
+}

codeBase/HackerRank/Algorithms/Game Theory/Tower Breakers Again/Solution.cpp

@@ -0,0 +1,31 @@
+/*
+        Copyright (C) 2020, Sathira Silva.
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int oddPrime(int num) {
+        int count = 0;
+        if (num % 2 == 0)
+            count++;
+        while (num % 2 == 0)
+            num /= 2;
+        for (int i = 3; i <= sqrt(num); i++) {
+            while (num % i == 0) {
+                num /= i;
+                if (i % 2 != 0) count++;
+            }
+        }
+        if (num > 2)
+            count++;
+        return count;
+    }
+
+int towerBreakers(vector<int> arr) {
+    int nim = 0;
+    for (int i = 0; i < arr.size(); i++)
+        nim ^= oddPrime(arr[i]);
+    return (nim) ? 1 : 2;
+}

codeBase/HackerRank/Algorithms/Game Theory/Tower Breakers Revisited/solution.cpp

@@ -0,0 +1,36 @@
+'''
+    Problem Statement:  https://www.hackerrank.com/challenges/tower-breakers-revisited-1/problem
+    
+    Approach:   In this problem, Grundy Number for each pile is the number of prime factors with multiplicity included.
+                More about Grundy Numbers:  https://www.hackerrank.com/topics/game-theory-and-grundy-numbers
+                                            http://web.mit.edu/sp.268/www/nim.pdf
+'''
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int primeFactors(int n) {
+    int count = 0;
+    while (n % 2 == 0) {
+        n = n / 2;
+        count += 1;
+    }
+    for (int i = 3; i <= sqrt(n); i += 2) {
+        while (n % i == 0) {
+            n = n / i;
+            count += 1;
+        }  
+    }
+    if (n > 2)  
+        count += 1;
+    return count;
+}
+
+int towerBreakers(vector<int> arr) {
+    int grundy = 0;
+    for (int i = 0; i < arr.size(); i++) {
+        grundy ^= primeFactors(arr[i]);
+    }
+    return grundy? 1 : 2;
+}