diff --git a/Competitive Coding/Backtrack/N-Queen.py b/Competitive Coding/Backtrack/N-Queen.py
new file mode 100644
index 000000000..215c7b698
--- /dev/null
+++ b/Competitive Coding/Backtrack/N-Queen.py
@@ -0,0 +1,89 @@
+# Python 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],
+ 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 queen can not be place 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 program to test above function
+solveNQ()
diff --git a/Competitive Coding/Backtrack/sudoku.py b/Competitive Coding/Backtrack/sudoku.py
new file mode 100644
index 000000000..7e64cce73
--- /dev/null
+++ b/Competitive Coding/Backtrack/sudoku.py
@@ -0,0 +1,119 @@
+# A Backtracking program in Pyhton to solve Sudoku problem
+
+
+# A Utility Function to print the Grid
+def print_grid(arr):
+ for i in range(9):
+ for j in range(9):
+ print arr[i][j],
+ print ('n')
+
+
+# Function to Find the entry in the Grid that is still not used
+# Searches the grid to find an entry that is still unassigned. If
+# found, the reference parameters row, col will be set the location
+# that is unassigned, and true is returned. If no unassigned entries
+# remain, false is returned.
+# 'l' is a list variable that has been passed from the solve_sudoku function
+# to keep track of incrementation of Rows and Columns
+def find_empty_location(arr,l):
+ for row in range(9):
+ for col in range(9):
+ if(arr[row][col]==0):
+ l[0]=row
+ l[1]=col
+ return True
+ return False
+
+# Returns a boolean which indicates whether any assigned entry
+# in the specified row matches the given number.
+def used_in_row(arr,row,num):
+ for i in range(9):
+ if(arr[row][i] == num):
+ return True
+ return False
+
+# Returns a boolean which indicates whether any assigned entry
+# in the specified column matches the given number.
+def used_in_col(arr,col,num):
+ for i in range(9):
+ if(arr[i][col] == num):
+ return True
+ return False
+
+# Returns a boolean which indicates whether any assigned entry
+# within the specified 3x3 box matches the given number
+def used_in_box(arr,row,col,num):
+ for i in range(3):
+ for j in range(3):
+ if(arr[i+row][j+col] == num):
+ return True
+ return False
+
+# Checks whether it will be legal to assign num to the given row,col
+# Returns a boolean which indicates whether it will be legal to assign
+# num to the given row,col location.
+def check_location_is_safe(arr,row,col,num):
+
+ # Check if 'num' is not already placed in current row,
+ # current column and current 3x3 box
+ return not used_in_row(arr,row,num) and not used_in_col(arr,col,num) and not used_in_box(arr,row - row%3,col - col%3,num)
+
+# Takes a partially filled-in grid and attempts to assign values to
+# all unassigned locations in such a way to meet the requirements
+# for Sudoku solution (non-duplication across rows, columns, and boxes)
+def solve_sudoku(arr):
+
+ # 'l' is a list variable that keeps the record of row and col in find_empty_location Function
+ l=[0,0]
+
+ # If there is no unassigned location, we are done
+ if(not find_empty_location(arr,l)):
+ return True
+
+ # Assigning list values to row and col that we got from the above Function
+ row=l[0]
+ col=l[1]
+
+ # consider digits 1 to 9
+ for num in range(1,10):
+
+ # if looks promising
+ if(check_location_is_safe(arr,row,col,num)):
+
+ # make tentative assignment
+ arr[row][col]=num
+
+ # return, if sucess, ya!
+ if(solve_sudoku(arr)):
+ return True
+
+ # failure, unmake & try again
+ arr[row][col] = 0
+
+ # this triggers backtracking
+ return False
+
+# Driver main function to test above functions
+if __name__=="__main__":
+
+ # creating a 2D array for the grid
+ grid=[[0 for x in range(9)]for y in range(9)]
+
+ # assigning values to the grid
+ grid=[[3,0,6,5,0,8,4,0,0],
+ [5,2,0,0,0,0,0,0,0],
+ [0,8,7,0,0,0,0,3,1],
+ [0,0,3,0,1,0,0,8,0],
+ [9,0,0,8,6,3,0,0,5],
+ [0,5,0,0,9,0,6,0,0],
+ [1,3,0,0,0,0,2,5,0],
+ [0,0,0,0,0,0,0,7,4],
+ [0,0,5,2,0,6,3,0,0]]
+
+ # if sucess print the grid
+ if(solve_sudoku(grid)):
+ print_grid(grid)
+ else:
+ print "No solution exists"
+
diff --git a/Competitive Coding/Dynamic Programming/Longest Common Subsequence/lcs.py b/Competitive Coding/Dynamic Programming/Longest Common Subsequence/lcs.py
new file mode 100644
index 000000000..16a31b8fc
--- /dev/null
+++ b/Competitive Coding/Dynamic Programming/Longest Common Subsequence/lcs.py
@@ -0,0 +1,18 @@
+def lcs(X , Y):
+ m = len(X)
+ n = len(Y)
+
+ L = [[None]*(n+1) for i in xrange(m+1)]
+
+ for i in range(m+1):
+ for j in range(n+1):
+ if i == 0 or j == 0 :
+ L[i][j] = 0
+ elif X[i-1] == Y[j-1]:
+ L[i][j] = L[i-1][j-1]+1
+ else:
+ L[i][j] = max(L[i-1][j] , L[i][j-1])
+ return L[m][n]
+X = "AGGTAB"
+Y = "GXTXAYB"
+print "Length of LCS is ", lcs(X, Y)
diff --git a/Competitive Coding/Dynamic Programming/minCostPath/Mincostpath.py b/Competitive Coding/Dynamic Programming/minCostPath/Mincostpath.py
new file mode 100644
index 000000000..6f3370233
--- /dev/null
+++ b/Competitive Coding/Dynamic Programming/minCostPath/Mincostpath.py
@@ -0,0 +1,22 @@
+R = 3
+C = 3
+
+def minCost(cost, m, n):
+ tc = [[0 for x in range(C)] for x in range(R)]
+
+ tc[0][0] = cost[0][0]
+
+
+ for i in range(1, m+1):
+ tc[i][0] = tc[i-1][0] + cost[i][0]
+ for j in range(1, n+1):
+ tc[0][j] = tc[0][j-1] + cost[0][j]
+ for i in range(1, m+1):
+ for j in range(1, n+1):
+ tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
+
+ return tc[m][n]
+cost = [[1, 2, 3],
+ [4, 8, 2],
+ [1, 5, 3]]
+print(minCost(cost, 2, 2))
diff --git a/Competitive Coding/Dynamic Programming/minCostPath/Readme.md b/Competitive Coding/Dynamic Programming/minCostPath/Readme.md
index 2e52ecbe2..61695a206 100644
--- a/Competitive Coding/Dynamic Programming/minCostPath/Readme.md
+++ b/Competitive Coding/Dynamic Programming/minCostPath/Readme.md
@@ -1,13 +1,25 @@
-Given a cost matrix cost[][] and a position (m, n) in cost[][], write a function that returns cost of minimum cost path to reach (m, n) from (0, 0). Each cell of the matrix represents a cost to traverse through that cell. Total cost of a path to reach (m, n) is sum of all the costs on that path (including both source and destination). You can only traverse down, right and diagonally lower cells from a given cell, i.e., from a given cell (i, j), cells (i+1, j), (i, j+1) and (i+1, j+1) can be traversed.
+Given a cost matrix cost[ ][ ] and position (m, n) in cost[ ][ ].
-1) Optimal Substructure
+Write a function that returns cost of minimum cost path to reach (m, n) from (0, 0).
+
+Each cell of the matrix represents a cost to traverse through that cell.
+
+Total cost of a path to reach (m, n) is sum of all the costs on that path (including both source and destination).
+
+You can only traverse down, right and diagonally lower cells from a given cell, i.e., from a given cell (i, j), cells (i+1, j), (i, j+1) and (i+1, j+1) can be traversed.
+
+
+
+1. Optimal Substructure
The path to reach (m, n) must be through one of the 3 cells: (m-1, n-1) or (m-1, n) or (m, n-1). So minimum cost to reach (m, n) can be written as “minimum of the 3 cells plus cost[m][n]”.
minCost(m, n) = min (minCost(m-1, n-1), minCost(m-1, n), minCost(m, n-1)) + cost[m][n]
-2) Overlapping Subproblems
+
+
+2. Overlapping Subproblems
Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems can be
-avoided by constructing a temporary array tc[][] in bottom up manner.
+avoided by constructing a temporary array tc[ ][ ] in bottom up manner.
Example:
diff --git a/Competitive Coding/Dynamic Programming/subsetSum/Readme.md b/Competitive Coding/Dynamic Programming/subsetSum/Readme.md
index 2c02c2e7d..6bfff12f5 100644
--- a/Competitive Coding/Dynamic Programming/subsetSum/Readme.md
+++ b/Competitive Coding/Dynamic Programming/subsetSum/Readme.md
@@ -1,16 +1,19 @@
Given a set of non-negative integers, and a value sum, determine if there is a subset of the given set with sum equal to given sum.
-Examples: set[] = {3, 34, 4, 12, 5, 2}, sum = 9
+Examples: set[ ] = {3, 34, 4, 12, 5, 2}, sum = 9
+
Output: True //There is a subset (4, 5) with sum 9.
-Let isSubSetSum(int set[], int n, int sum) be the function to find whether there is a subset of set[] with sum equal to sum. n is the number of elements in set[].
+Let isSubSetSum(int set[ ], int n, int sum) be the function to find whether there is a subset of set[] with sum equal to sum. n is the number of elements in set[ ].
+
+The isSubsetSum problem can be divided into two subproblems:-
+
+a) Include the last element, recur for n = n-1, sum = sum – set[n-1]
+b) Exclude the last element, recur for n = n-1.
-The isSubsetSum problem can be divided into two subproblems
-…a) Include the last element, recur for n = n-1, sum = sum – set[n-1]
-…b) Exclude the last element, recur for n = n-1.
If any of the above the above subproblems return true, then return true.
-Following is the recursive formula for isSubsetSum() problem.
+Following is the recursive formula for isSubsetSum() problem:-
isSubsetSum(set, n, sum) = isSubsetSum(set, n-1, sum) ||
isSubsetSum(set, n-1, sum-set[n-1])
@@ -18,4 +21,4 @@ Base Cases:
isSubsetSum(set, n, sum) = false, if sum > 0 and n == 0
isSubsetSum(set, n, sum) = true, if sum == 0
-We can solve the problem in Pseudo-polynomial time using Dynamic programming. We create a boolean 2D table subset[][] and fill it in bottom up manner. The value of subset[i][j] will be true if there is a subset of set[0..j-1] with sum equal to i., otherwise false. Finally, we return subset[sum][n]
+We can solve the problem in Pseudo-polynomial time using Dynamic programming. We create a boolean 2D table subset[ ][ ] and fill it in bottom up manner. The value of subset[i][j] will be true if there is a subset of set[0..j-1] with sum equal to i., otherwise false. Finally, we return subset[sum][n]
diff --git a/Competitive Coding/Dynamic Programming/subsetSum/subsetsum.py b/Competitive Coding/Dynamic Programming/subsetSum/subsetsum.py
new file mode 100644
index 000000000..15ea5b923
--- /dev/null
+++ b/Competitive Coding/Dynamic Programming/subsetSum/subsetsum.py
@@ -0,0 +1,24 @@
+def isSubsetSum(st, n, sm) :
+ subset=[[True] * (sm+1)] * (n+1)
+
+ for i in range(0, n+1) :
+ subset[i][0] = True
+
+ for i in range(1, sm + 1) :
+ subset[0][i] = False
+
+ for i in range(1, n+1) :
+ for j in range(1, sm+1) :
+ if(j < st[i-1]) :
+ subset[i][j] = subset[i-1][j]
+ if (j >= st[i-1]) :
+ subset[i][j] = subset[i-1][j] or subset[i - 1][j-st[i-1]]
+ return subset[n][sm];
+
+st = [1, 2, 3]
+sm = 7
+n = len(st)
+if (isSubsetSum(st, n, sm) == True) :
+ print("Found a subset with given sum")
+else :
+ print("No subset with given sum")
diff --git a/README.md b/README.md
index 2f4643d21..b5e5e8b54 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,11 @@
### About the Project
-This repository contains some of the most **intriguing and awesome algorithms** of daily life implemented in languages primarily in C/C++/Java/Python.
+This repository contains some of the most **intriguing and awesome algorithms** of daily life implemented in languages primarily in
+* C
+* C++
+* Java
+* Python
--------------------------------------------------------------