Initial

Author: iam-abbas

Backtracking/N-Queen/Python/N-Queen.py

@@ -0,0 +1,90 @@
+# Python3 program to solve N Queen  
+# Problem using backtracking 
+global N 
+N = 4
+  
+def printSolution(board): 
+    for i in range(N): 
+        for j in range(N): 
+            print (board[i][j], end = " ") 
+        print() 
+  
+# A utility function to check if a queen can 
+# be placed on board[row][col]. Note that this 
+# function is called when "col" queens are 
+# already placed in columns from 0 to col -1. 
+# So we need to check only left side for 
+# attacking queens 
+def isSafe(board, row, col): 
+  
+    # Check this row on left side 
+    for i in range(col): 
+        if board[row][i] == 1: 
+            return False
+  
+    # Check upper diagonal on left side 
+    for i, j in zip(range(row, -1, -1),  
+                    range(col, -1, -1)): 
+        if board[i][j] == 1: 
+            return False
+  
+    # Check lower diagonal on left side 
+    for i, j in zip(range(row, N, 1),  
+                    range(col, -1, -1)): 
+        if board[i][j] == 1: 
+            return False
+  
+    return True
+  
+def solveNQUtil(board, col): 
+      
+    # base case: If all queens are placed 
+    # then return true 
+    if col >= N: 
+        return True
+  
+    # Consider this column and try placing 
+    # this queen in all rows one by one 
+    for i in range(N): 
+  
+        if isSafe(board, i, col): 
+              
+            # Place this queen in board[i][col] 
+            board[i][col] = 1
+  
+            # recur to place rest of the queens 
+            if solveNQUtil(board, col + 1) == True: 
+                return True
+  
+            # If placing queen in board[i][col 
+            # doesn't lead to a solution, then 
+            # queen from board[i][col] 
+            board[i][col] = 0
+  
+    # if the queen can not be placed in any row in 
+    # this colum col then return false 
+    return False
+  
+# This function solves the N Queen problem using 
+# Backtracking. It mainly uses solveNQUtil() to 
+# solve the problem. It returns false if queens 
+# cannot be placed, otherwise return true and 
+# placement of queens in the form of 1s. 
+# note that there may be more than one 
+# solutions, this function prints one of the 
+# feasible solutions. 
+def solveNQ(): 
+    board = [ [0, 0, 0, 0], 
+              [0, 0, 0, 0], 
+              [0, 0, 0, 0], 
+              [0, 0, 0, 0] ] 
+  
+    if solveNQUtil(board, 0) == False: 
+        print ("Solution does not exist") 
+        return False
+  
+    printSolution(board) 
+    return True
+  
+# Driver Code 
+solveNQ() 

Branch and Bound/Traveling Salesman/Cpp/Traveling Salesman.cpp

@@ -0,0 +1,193 @@
+// C++ program to solve Traveling Salesman Problem 
+// using Branch and Bound. 
+#include <bits/stdc++.h> 
+using namespace std; 
+const int N = 4; 
+  
+// final_path[] stores the final solution ie, the 
+// path of the salesman. 
+int final_path[N+1]; 
+  
+// visited[] keeps track of the already visited nodes 
+// in a particular path 
+bool visited[N]; 
+  
+// Stores the final minimum weight of shortest tour. 
+int final_res = INT_MAX; 
+  
+// Function to copy temporary solution to 
+// the final solution 
+void copyToFinal(int curr_path[]) 
+{ 
+    for (int i=0; i<N; i++) 
+        final_path[i] = curr_path[i]; 
+    final_path[N] = curr_path[0]; 
+} 
+  
+// Function to find the minimum edge cost 
+// having an end at the vertex i 
+int firstMin(int adj[N][N], int i) 
+{ 
+    int min = INT_MAX; 
+    for (int k=0; k<N; k++) 
+        if (adj[i][k]<min && i != k) 
+            min = adj[i][k]; 
+    return min; 
+} 
+  
+// function to find the second minimum edge cost 
+// having an end at the vertex i 
+int secondMin(int adj[N][N], int i) 
+{ 
+    int first = INT_MAX, second = INT_MAX; 
+    for (int j=0; j<N; j++) 
+    { 
+        if (i == j) 
+            continue; 
+  
+        if (adj[i][j] <= first) 
+        { 
+            second = first; 
+            first = adj[i][j]; 
+        } 
+        else if (adj[i][j] <= second && 
+                 adj[i][j] != first) 
+            second = adj[i][j]; 
+    } 
+    return second; 
+} 
+  
+// function that takes as arguments: 
+// curr_bound -> lower bound of the root node 
+// curr_weight-> stores the weight of the path so far 
+// level-> current level while moving in the search 
+//         space tree 
+// curr_path[] -> where the solution is being stored which 
+//                would later be copied to final_path[] 
+void TSPRec(int adj[N][N], int curr_bound, int curr_weight, 
+            int level, int curr_path[]) 
+{ 
+    // base case is when we have reached level N which 
+    // means we have covered all the nodes once 
+    if (level==N) 
+    { 
+        // check if there is an edge from last vertex in 
+        // path back to the first vertex 
+        if (adj[curr_path[level-1]][curr_path[0]] != 0) 
+        { 
+            // curr_res has the total weight of the 
+            // solution we got 
+            int curr_res = curr_weight + 
+                    adj[curr_path[level-1]][curr_path[0]]; 
+  
+            // Update final result and final path if 
+            // current result is better. 
+            if (curr_res < final_res) 
+            { 
+                copyToFinal(curr_path); 
+                final_res = curr_res; 
+            } 
+        } 
+        return; 
+    } 
+  
+    // for any other level iterate for all vertices to 
+    // build the search space tree recursively 
+    for (int i=0; i<N; i++) 
+    { 
+        // Consider next vertex if it is not same (diagonal 
+        // entry in adjacency matrix and not visited 
+        // already) 
+        if (adj[curr_path[level-1]][i] != 0 && 
+            visited[i] == false) 
+        { 
+            int temp = curr_bound; 
+            curr_weight += adj[curr_path[level-1]][i]; 
+  
+            // different computation of curr_bound for 
+            // level 2 from the other levels 
+            if (level==1) 
+              curr_bound -= ((firstMin(adj, curr_path[level-1]) + 
+                             firstMin(adj, i))/2); 
+            else
+              curr_bound -= ((secondMin(adj, curr_path[level-1]) + 
+                             firstMin(adj, i))/2); 
+  
+            // curr_bound + curr_weight is the actual lower bound 
+            // for the node that we have arrived on 
+            // If current lower bound < final_res, we need to explore 
+            // the node further 
+            if (curr_bound + curr_weight < final_res) 
+            { 
+                curr_path[level] = i; 
+                visited[i] = true; 
+  
+                // call TSPRec for the next level 
+                TSPRec(adj, curr_bound, curr_weight, level+1, 
+                       curr_path); 
+            } 
+  
+            // Else we have to prune the node by resetting 
+            // all changes to curr_weight and curr_bound 
+            curr_weight -= adj[curr_path[level-1]][i]; 
+            curr_bound = temp; 
+  
+            // Also reset the visited array 
+            memset(visited, false, sizeof(visited)); 
+            for (int j=0; j<=level-1; j++) 
+                visited[curr_path[j]] = true; 
+        } 
+    } 
+} 
+  
+// This function sets up final_path[]  
+void TSP(int adj[N][N]) 
+{ 
+    int curr_path[N+1]; 
+  
+    // Calculate initial lower bound for the root node 
+    // using the formula 1/2 * (sum of first min + 
+    // second min) for all edges. 
+    // Also initialize the curr_path and visited array 
+    int curr_bound = 0; 
+    memset(curr_path, -1, sizeof(curr_path)); 
+    memset(visited, 0, sizeof(curr_path)); 
+  
+    // Compute initial bound 
+    for (int i=0; i<N; i++) 
+        curr_bound += (firstMin(adj, i) + 
+                       secondMin(adj, i)); 
+  
+    // Rounding off the lower bound to an integer 
+    curr_bound = (curr_bound&1)? curr_bound/2 + 1 : 
+                                 curr_bound/2; 
+  
+    // We start at vertex 1 so the first vertex 
+    // in curr_path[] is 0 
+    visited[0] = true; 
+    curr_path[0] = 0; 
+  
+    // Call to TSPRec for curr_weight equal to 
+    // 0 and level 1 
+    TSPRec(adj, curr_bound, 0, 1, curr_path); 
+} 
+  
+// Driver code 
+int main() 
+{ 
+    //Adjacency matrix for the given graph 
+    int adj[N][N] = { {0, 10, 15, 20}, 
+        {10, 0, 35, 25}, 
+        {15, 35, 0, 30}, 
+        {20, 25, 30, 0} 
+    }; 
+  
+    TSP(adj); 
+  
+    printf("Minimum cost : %d\n", final_res); 
+    printf("Path Taken : "); 
+    for (int i=0; i<=N; i++) 
+        printf("%d ", final_path[i]); 
+  
+    return 0; 
+} 

Divide and Conquer/Median of Arrays/Python/Median.py

@@ -0,0 +1,57 @@
+# A Simple Merge based O(n) Python 3 solution  
+# to find median of two sorted lists 
+  
+# This function returns median of ar1[] and ar2[]. 
+# Assumptions in this function: 
+# Both ar1[] and ar2[] are sorted arrays 
+# Both have n elements 
+def getMedian( ar1, ar2 , n): 
+    i = 0 # Current index of i/p list ar1[] 
+      
+    j = 0 # Current index of i/p list ar2[] 
+      
+    m1 = -1
+    m2 = -1
+      
+    # Since there are 2n elements, median 
+    # will be average of elements at index 
+    # n-1 and n in the array obtained after 
+    # merging ar1 and ar2 
+    count = 0
+    while count < n + 1: 
+        count += 1
+          
+        # Below is to handle case where all 
+        # elements of ar1[] are smaller than 
+        # smallest(or first) element of ar2[] 
+        if i == n: 
+            m1 = m2 
+            m2 = ar2[0] 
+            break
+          
+        # Below is to handle case where all  
+        # elements of ar2[] are smaller than 
+        # smallest(or first) element of ar1[] 
+        elif j == n: 
+            m1 = m2 
+            m2 = ar1[0] 
+            break
+        if ar1[i] < ar2[j]: 
+            m1 = m2 # Store the prev median 
+            m2 = ar1[i] 
+            i += 1
+        else: 
+            m1 = m2 # Store the prev median 
+            m2 = ar2[j] 
+            j += 1
+    return (m1 + m2)/2
+  
+# Driver code to test above function 
+ar1 = [1, 12, 15, 26, 38] 
+ar2 = [2, 13, 17, 30, 45] 
+n1 = len(ar1) 
+n2 = len(ar2) 
+if n1 == n2: 
+    print("Median is ", getMedian(ar1, ar2, n1)) 
+else: 
+    print("Doesn't work for arrays of unequal size") 

Dynamic Programming/0-1 Knapsack/Pyhton/0-1 Knapsack.py

@@ -0,0 +1,30 @@
+#A naive recursive implementation of 0-1 Knapsack Problem 
+  
+# Returns the maximum value that can be put in a knapsack of 
+# capacity W 
+def knapSack(W , wt , val , n): 
+  
+    # Base Case 
+    if n == 0 or W == 0 : 
+        return 0
+  
+    # If weight of the nth item is more than Knapsack of capacity 
+    # W, then this item cannot be included in the optimal solution 
+    if (wt[n-1] > W): 
+        return knapSack(W , wt , val , n-1) 
+  
+    # return the maximum of two cases: 
+    # (1) nth item included 
+    # (2) not included 
+    else: 
+        return max(val[n-1] + knapSack(W-wt[n-1] , wt , val , n-1), 
+                   knapSack(W , wt , val , n-1)) 
+  
+# end of function knapSack 
+  
+# To test above function 
+val = [60, 100, 120] 
+wt = [10, 20, 30] 
+W = 50
+n = len(val) 
+print(knapSack(W , wt , val , n))