diff --git a/c++/longest-palindromic-subseq.cpp b/c++/longest-palindromic-subseq.cpp
new file mode 100644
index 0000000..ade1a2f
--- /dev/null
+++ b/c++/longest-palindromic-subseq.cpp
@@ -0,0 +1,34 @@
+class Solution {
+public:
+
+int tabulation(string t1, string t2)
+{
+    vector<int>curr(t2.length()+19,0);
+    vector<int>next(t2.length()+19,0);
+ 
+    for(int i = t1.length()-1;i>=0;i--)
+    {
+        for(int j =t2.length()-1;j>=0;j--)
+        {
+            int ans =0;
+            if(t1[i]==t2[j])
+            {
+                ans=1+next[j+1];
+            }
+            else
+            {
+                ans=max(next[j],curr[j+1]);
+            }
+            curr[j]=ans;
+        } 
+        next=curr;
+    }
+    return curr[0];
+}
+
+    int longestPalindromeSubseq(string s) {
+        string str=s;
+        reverse(s.begin(),s.end());
+        return tabulation(s,str);
+    }
+};
diff --git a/c++/merge-sort.cpp b/c++/merge-sort.cpp
new file mode 100644
index 0000000..6f543bf
--- /dev/null
+++ b/c++/merge-sort.cpp
@@ -0,0 +1,104 @@
+// C++ program for Merge Sort
+#include <bits/stdc++.h>
+using namespace std;
+
+// Merges two subarrays of array[].
+// First subarray is arr[begin..mid]
+// Second subarray is arr[mid+1..end]
+void merge(int array[], int const left, int const mid,
+		int const right)
+{
+	int const subArrayOne = mid - left + 1;
+	int const subArrayTwo = right - mid;
+
+	// Create temp arrays
+	auto *leftArray = new int[subArrayOne],
+		*rightArray = new int[subArrayTwo];
+
+	// Copy data to temp arrays leftArray[] and rightArray[]
+	for (auto i = 0; i < subArrayOne; i++)
+		leftArray[i] = array[left + i];
+	for (auto j = 0; j < subArrayTwo; j++)
+		rightArray[j] = array[mid + 1 + j];
+
+	auto indexOfSubArrayOne = 0, indexOfSubArrayTwo = 0;
+	int indexOfMergedArray = left;
+
+	// Merge the temp arrays back into array[left..right]
+	while (indexOfSubArrayOne < subArrayOne
+		&& indexOfSubArrayTwo < subArrayTwo) {
+		if (leftArray[indexOfSubArrayOne]
+			<= rightArray[indexOfSubArrayTwo]) {
+			array[indexOfMergedArray]
+				= leftArray[indexOfSubArrayOne];
+			indexOfSubArrayOne++;
+		}
+		else {
+			array[indexOfMergedArray]
+				= rightArray[indexOfSubArrayTwo];
+			indexOfSubArrayTwo++;
+		}
+		indexOfMergedArray++;
+	}
+
+	// Copy the remaining elements of
+	// left[], if there are any
+	while (indexOfSubArrayOne < subArrayOne) {
+		array[indexOfMergedArray]
+			= leftArray[indexOfSubArrayOne];
+		indexOfSubArrayOne++;
+		indexOfMergedArray++;
+	}
+
+	// Copy the remaining elements of
+	// right[], if there are any
+	while (indexOfSubArrayTwo < subArrayTwo) {
+		array[indexOfMergedArray]
+			= rightArray[indexOfSubArrayTwo];
+		indexOfSubArrayTwo++;
+		indexOfMergedArray++;
+	}
+	delete[] leftArray;
+	delete[] rightArray;
+}
+
+// begin is for left index and end is right index
+// of the sub-array of arr to be sorted
+void mergeSort(int array[], int const begin, int const end)
+{
+	if (begin >= end)
+		return;
+
+	int mid = begin + (end - begin) / 2;
+	mergeSort(array, begin, mid);
+	mergeSort(array, mid + 1, end);
+	merge(array, begin, mid, end);
+}
+
+// UTILITY FUNCTIONS
+// Function to print an array
+void printArray(int A[], int size)
+{
+	for (int i = 0; i < size; i++)
+		cout << A[i] << " ";
+	cout << endl;
+}
+
+// Driver code
+int main()
+{
+	int arr[] = { 12, 11, 13, 5, 6, 7 };
+	int arr_size = sizeof(arr) / sizeof(arr[0]);
+
+	cout << "Given array is \n";
+	printArray(arr, arr_size);
+
+	mergeSort(arr, 0, arr_size - 1);
+
+	cout << "\nSorted array is \n";
+	printArray(arr, arr_size);
+	return 0;
+}
+
+// This code is contributed by Mayank Tyagi
+// This code was revised by Joshua Estes
diff --git a/c++/sudokusolver.cpp b/c++/sudokusolver.cpp
new file mode 100644
index 0000000..e3b7665
--- /dev/null
+++ b/c++/sudokusolver.cpp
@@ -0,0 +1,53 @@
+class Solution {
+private:
+    void ans(vector<vector<char>>& board, vector<vector<char>>& curr, int i, int j, vector<vector<bool>>& col, vector<vector<bool>>& row, vector<vector<bool>>& mat) {
+        while(i < 9 && board[i][j] != '.') {
+            if (j < 8) j++;
+            else {
+                j = 0;
+                i++;
+            }
+        }
+        if(i == 9) {
+            curr = board;
+            return;
+        }
+
+        for(int k = 1; k <= 9; k++) {
+            if(curr.size() > 0) break;
+            if(!col[j][k] && !row[i][k] && !mat[3*(i/3) + (j/3)][k]) {
+                col[j][k] = true;
+                row[i][k] = true;
+                mat[3*(i/3) + (j/3)][k] = true;
+                board[i][j] = (char)('0'+k);
+                ans(board, curr, i, j, col, row, mat);
+                col[j][k] = false;
+                row[i][k] = false;
+                mat[3*(i/3) + (j/3)][k] = false;
+                board[i][j] = '.';
+            }
+        }
+    }
+public:
+    void solveSudoku(vector<vector<char>>& board) {
+        vector<vector<bool>> col(9, vector<bool>(10, false));
+        vector<vector<bool>> row(9, vector<bool>(10, false));
+        vector<vector<bool>> mat(9, vector<bool>(10, false));
+        vector<vector<char>> curr;
+
+        for(int i = 0; i < 9; i++) {
+            for(int j = 0; j < 9; j++) {
+                if(board[i][j] != '.') {
+                    int x = board[i][j] - '0';
+                    row[i][x] = true;
+                    col[j][x] = true;
+                    mat[3*(i/3) + (j/3)][x] = true;
+                }
+            }
+        }
+
+        ans(board, curr, 0, 0, col, row, mat);
+        board = curr;
+        return;
+    }
+};