Merge pull request matthewsamuel95#366 from samarthsehgal97/br2

Added Activity Selection Greedy Algo

Author: matthewsamuel95

BackTracking/RatInAMaze/ratmaze.cpp

@@ -0,0 +1,100 @@
+
+/* C/C++ program to solve Rat in a Maze problem using 
+   backtracking */
+#include<stdio.h> 
+  
+// Maze size 
+#define N 4  
+  
+bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N]); 
+  
+/* A utility function to print solution matrix sol[N][N] */
+void printSolution(int sol[N][N]) 
+{ 
+    for (int i = 0; i < N; i++) 
+    { 
+        for (int j = 0; j < N; j++) 
+            printf(" %d ", sol[i][j]); 
+        printf("\n"); 
+    } 
+} 
+  
+/* A utility function to check if x,y is valid index for N*N maze */
+bool isSafe(int maze[N][N], int x, int y) 
+{ 
+    // if (x,y outside maze) return false 
+    if(x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1) 
+        return true; 
+  
+    return false; 
+} 
+  
+/* This function solves the Maze problem using Backtracking.  It mainly 
+   uses solveMazeUtil() to solve the problem. It returns false if no  
+   path is possible, otherwise return true and prints the path in the 
+   form of 1s. Please note that there may be more than one solutions,  
+   this function prints one of the feasible solutions.*/
+bool solveMaze(int maze[N][N]) 
+{ 
+    int sol[N][N] = { {0, 0, 0, 0}, 
+        {0, 0, 0, 0}, 
+        {0, 0, 0, 0}, 
+        {0, 0, 0, 0} 
+    }; 
+  
+    if(solveMazeUtil(maze, 0, 0, sol) == false) 
+    { 
+        printf("Solution doesn't exist"); 
+        return false; 
+    } 
+  
+    printSolution(sol); 
+    return true; 
+} 
+  
+/* A recursive utility function to solve Maze problem */
+bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N]) 
+{ 
+    // if (x,y is goal) return true 
+    if(x == N-1 && y == N-1) 
+    { 
+        sol[x][y] = 1; 
+        return true; 
+    } 
+  
+    // Check if maze[x][y] is valid 
+    if(isSafe(maze, x, y) == true) 
+    { 
+        // mark x,y as part of solution path 
+        sol[x][y] = 1; 
+  
+        /* Move forward in x direction */
+        if (solveMazeUtil(maze, x+1, y, sol) == true) 
+            return true; 
+  
+        /* If moving in x direction doesn't give solution then 
+           Move down in y direction  */
+        if (solveMazeUtil(maze, x, y+1, sol) == true) 
+            return true; 
+  
+        /* If none of the above movements work then BACKTRACK:  
+            unmark x,y as part of solution path */
+        sol[x][y] = 0; 
+        return false; 
+    }    
+  
+    return false; 
+} 
+  
+// driver program to test above function 
+int main() 
+{ 
+    int maze[N][N]  =  { {1, 0, 0, 0}, 
+        {1, 1, 0, 1}, 
+        {0, 1, 0, 0}, 
+        {1, 1, 1, 1} 
+    }; 
+  
+    solveMaze(maze); 
+    return 0; 
+}

BackTracking/RatInAMaze/ratmaze.py

@@ -0,0 +1,80 @@
+
+# Python3 program to solve Rat in a Maze  
+# problem using backracking  
+  
+# Maze size 
+N = 4
+  
+# A utility function to print solution matrix sol 
+def printSolution( sol ): 
+      
+    for i in sol: 
+        for j in i: 
+            print(str(j) + " ", end="") 
+        print("") 
+  
+# A utility function to check if x,y is valid 
+# index for N*N Maze 
+def isSafe( maze, x, y ): 
+      
+    if x >= 0 and x < N and y >= 0 and y < N and maze[x][y] == 1: 
+        return True
+      
+    return False
+  
+""" This function solves the Maze problem using Backtracking.  
+    It mainly uses solveMazeUtil() to solve the problem. It  
+    returns false if no path is possible, otherwise return  
+    true and prints the path in the form of 1s. Please note 
+    that there may be more than one solutions, this function 
+    prints one of the feasable solutions. """
+def solveMaze( maze ): 
+      
+    # Creating a 4 * 4 2-D list 
+    sol = [ [ 0 for j in range(4) ] for i in range(4) ] 
+      
+    if solveMazeUtil(maze, 0, 0, sol) == False: 
+        print("Solution doesn't exist"); 
+        return False
+      
+    printSolution(sol) 
+    return True
+      
+# A recursive utility function to solve Maze problem 
+def solveMazeUtil(maze, x, y, sol): 
+      
+    #if (x,y is goal) return True 
+    if x == N - 1 and y == N - 1: 
+        sol[x][y] = 1
+        return True
+          
+    # Check if maze[x][y] is valid 
+    if isSafe(maze, x, y) == True: 
+        # mark x, y as part of solution path 
+        sol[x][y] = 1
+          
+        # Move forward in x direction 
+        if solveMazeUtil(maze, x + 1, y, sol) == True: 
+            return True
+              
+        # If moving in x direction doesn't give solution  
+        # then Move down in y direction 
+        if solveMazeUtil(maze, x, y + 1, sol) == True: 
+            return True
+          
+        # If none of the above movements work then  
+        # BACKTRACK: unmark x,y as part of solution path 
+        sol[x][y] = 0
+        return False
+  
+# Driver program to test above function 
+if __name__ == "__main__": 
+    # Initialising the maze 
+    maze = [ [1, 0, 0, 0], 
+             [1, 1, 0, 1], 
+             [0, 1, 0, 0], 
+             [1, 1, 1, 1] ] 
+               
+    solveMaze(maze) 
+
+

Greedy/ActivitySelection/ActivitySel.cpp

@@ -0,0 +1,43 @@
+// C++ program for activity selection problem. 
+// The following implementation assumes that the activities 
+// are already sorted according to their finish time 
+#include<stdio.h> 
+  
+// Prints a maximum set of activities that can be done by a single 
+// person, one at a time. 
+//  n   -->  Total number of activities 
+//  s[] -->  An array that contains start time of all activities 
+//  f[] -->  An array that contains finish time of all activities 
+void printMaxActivities(int s[], int f[], int n) 
+{ 
+    int i, j; 
+  
+    printf ("Following activities are selected n"); 
+  
+    // The first activity always gets selected 
+    i = 0; 
+    printf("%d ", i); 
+  
+    // Consider rest of the activities 
+    for (j = 1; j < n; j++) 
+    { 
+      // If this activity has start time greater than or 
+      // equal to the finish time of previously selected 
+      // activity, then select it 
+      if (s[j] >= f[i]) 
+      { 
+          printf ("%d ", j); 
+          i = j; 
+      } 
+    } 
+} 
+  
+// driver program to test above function 
+int main() 
+{ 
+    int s[] =  {1, 3, 0, 5, 8, 5}; 
+    int f[] =  {2, 4, 6, 7, 9, 9}; 
+    int n = sizeof(s)/sizeof(s[0]); 
+    printMaxActivities(s, f, n); 
+    return 0; 
+}

Greedy/ActivitySelection/README.md

@@ -0,0 +1,31 @@
+Following is the problem statement.
+You are given n activities with their start and finish times. Select the maximum number of activities that can be performed by a single person, assuming that a person can only work on a single activity at a time.
+Example:
+
+Example 1 : Consider the following 3 activities sorted by
+by finish time.
+     start[]  =  {10, 12, 20};
+     finish[] =  {20, 25, 30};
+A person can perform at most two activities. The 
+maximum set of activities that can be executed 
+is {0, 2} [ These are indexes in start[] and 
+finish[] ]
+
+Example 2 : Consider the following 6 activities 
+sorted by by finish time.
+     start[]  =  {1, 3, 0, 5, 8, 5};
+     finish[] =  {2, 4, 6, 7, 9, 9};
+A person can perform at most four activities. The 
+maximum set of activities that can be executed 
+is {0, 1, 3, 4} [ These are indexes in start[] and 
+finish[] ]
+
+
+The greedy choice is to always pick the next activity whose finish time is least among the remaining activities and the start time is more than or equal to the finish time of previously selected activity. We can sort the activities according to their finishing time so that we always consider the next activity as minimum finishing time activity.
+
+1) Sort the activities according to their finishing time
+2) Select the first activity from the sorted array and print it.
+3) Do following for remaining activities in the sorted array.
+…….a) If the start time of this activity is greater than or equal to the finish time of previously selected activity then select this activity and print it.
+
+In the following C implementation, it is assumed that the activities are already sorted according to their finish time