Added Dynamic Programming solution for Minimum cost to reach the destination

C++/2Sum.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target)
+     {
+        unordered_map<int,int> mp;
+        for(int i=0;i<nums.size();i++)
+        {
+            if(mp.find(target -nums[i]) != mp.end())
+            {
+                return {mp[target- nums[i]],i};
+            }
+            else
+            mp[nums[i]]=i;
+        }
+         return  {};
+    }
+};

C++/4Sum.cpp

@@ -0,0 +1,36 @@
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) 
+    {
+        vector<vector<int>> res;
+        if(nums.size() < 4) return res;
+        set<vector<int>> hash;
+        sort(nums.begin(), nums.end());
+        for(int i = 0; i < nums.size() - 2; i++) {
+            for(int j = i + 1; j < nums.size() - 1; j++)
+             {
+                int left = j + 1;
+                int right = nums.size() - 1;
+                while(left < right) 
+                {
+                    int sum = nums[i] + nums[left] + nums[right] + nums[j];
+                    if(sum == target && !hash.count({nums[i], nums[j], nums[left], nums[right]})) {
+                        hash.insert({nums[i], nums[j], nums[left], nums[right]});
+                        res.push_back({nums[i], nums[j], nums[left], nums[right]});
+                        left++;
+                        right--;
+                        while(left < right && nums[left] == nums[left - 1])
+                            left++;
+                        while(left < right && nums[right] == nums[right + 1])
+                            right--;
+                    }
+                    else if(target > sum) 
+                        left++;
+                    else
+                        right--;
+                }
+            }
+        }
+        return res;
+    }
+};

C++/Check_string_is_k_palindrome.cpp

@@ -0,0 +1,24 @@
+#include <bits/stdc++.h>
+using namespace std;
+int isKPalindrome(string X, int m, string Y, int n)
+{
+	if (m == 0 || n == 0)
+		return n + m;
+	if (X[m - 1] == Y[n - 1])
+		return isKPalindrome(X, m - 1, Y, n - 1);
+	int x = isKPalindrome(X, m - 1, Y, n);
+	int y = isKPalindrome(X, m, Y, n - 1);
+	return 1 + min(x, y);
+}
+int main()
+{
+	string str = "CABCBC";
+	int K = 2;
+	string rev = str;
+	reverse(rev.begin(), rev.end());
+	if (isKPalindrome(str, str.length(), rev, str.length()) <= 2 * K)
+		cout << "String is K-Palindrome";
+	else
+		cout << "String is not a K-Palindrome";
+	return 0;
+}

C++/Copy_Linkedlist_with_Random_Pointers.cpp

@@ -0,0 +1,36 @@
+class Node {
+public:
+    int val;
+    Node* next;
+    Node* random;
+
+    Node(int _val) {
+        val = _val;
+        next = NULL;
+        random = NULL;
+    }
+};
+class Solution {
+public:
+    Node* copyRandomList(Node* head)
+     {
+        unordered_map<Node*,Node*> mp;
+        Node* copy = nullptr;
+        Node* original = head;
+        while(original != NULL)
+        {
+            copy = new Node(original->val);
+            mp[original] = copy;
+            original= original->next;
+        }
+        original = head;
+        while(original != NULL)
+        {
+            copy = mp[original];
+            copy->next = mp[original->next];
+            copy->random = mp[original->random];
+            original = original->next;  
+        }
+        return mp[head];
+    }
+};

C++/Minimum_cost_to_reach_destination.cpp

@@ -0,0 +1,36 @@
+#include <bits/stdc++.h>
+using namespace std;
+#define N 5
+int findMinCost(int cost[][N])
+{
+	int lookup[N];
+	for (int i = 0; i < N; i++)
+		lookup[i] = cost[0][i];
+	bool is_filled = false;
+	while (!is_filled)
+	{
+		is_filled = true;
+		for (int i = 0; i < N; i++) {
+			for (int j = 0; j < N; j++) {
+				if (lookup[i] > lookup[j] + cost[j][i]) {
+					lookup[i] = lookup[j] + cost[j][i];
+					is_filled = false;
+				}
+			}
+		}
+	}
+	return lookup[N-1];
+}
+int main()
+{
+	int cost[N][N] =
+	{
+		{ 0, 25, 20, 10, 105 },
+		{ 20, 0, 15, 80, 80 },
+		{ 30, 15, 0, 70, 90 },
+		{ 10, 10, 50, 0, 100 },
+		{ 40, 50, 5, 10, 0 }
+	};
+	cout << "The minimum cost is " << findMinCost(cost) << "$";
+    return 0;
+}