added new solution to DP, Array, Linked List, String and Matrix

Author: aryaveer

04. Arrays/12_Find First and Last Position of Element in Sorted Array.cpp

@@ -0,0 +1,131 @@
+/*
+Problem statement:
+Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value.
+
+If target is not found in the array, return [-1, -1].
+
+You must write an algorithm with O(log n) runtime complexity.
+
+
+
+Example 1:
+
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
+Example 2:
+
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
+Example 3:
+
+Input: nums = [], target = 0
+Output: [-1,-1]
+
+
+Constraints:
+
+0 <= nums.length <= 105
+-109 <= nums[i] <= 109
+nums is a non-decreasing array.
+-109 <= target <= 109
+
+
+*/
+#include "bits/stdc++.h"
+#define endl "\n"
+
+using namespace std;
+
+
+vector<int> searchRange(vector<int>& nums, int target) {
+	int start = -1;
+	int end = -1;
+	int low = 0, high = int(nums.size()) - 1;
+	while (low <= high) {
+
+		int mid = (high + low) / 2;
+
+		if (nums[mid] == target) {
+			// intially consider the mid is the starting and end position
+			start = mid;
+			end = mid;
+
+			// now we will search in left and right search for new start and end positions
+			int tempLow = low;
+			int tempHigh = mid - 1;
+
+			// find " new START " in left subarray
+			while (tempLow <= tempHigh) {
+
+				int tempMid = (tempLow + tempHigh) / 2;
+
+				if (nums[tempMid] == target) {
+
+					start = tempMid;
+					tempHigh = tempMid - 1;
+
+				} else {
+
+					tempLow = tempMid + 1;
+
+				}
+			}
+
+			// find " new END " in right subarray
+			tempLow = mid + 1;
+			tempHigh = high;
+			while (tempLow <= tempHigh) {
+				int tempMid = (tempLow + tempHigh) / 2;
+				if (nums[tempMid] == target) {
+					end = tempMid;
+					tempLow = tempMid + 1;
+				} else {
+					tempHigh = tempMid - 1;
+				}
+			}
+
+			// important step to follow
+			// =========
+			break;
+			// =========
+		}
+
+		if (nums[mid] < target) {
+			low = mid + 1;
+		} else {
+			high = mid - 1;
+		}
+	}
+
+	nums.clear();
+
+	return {start, end};
+}
+
+
+// { Driver Code Starts.
+int main()
+{
+	int t;
+	cin >> t;
+	while (t--)
+	{
+		int N;
+		cin >> N;
+		vector<int> nums(N);
+		for (int i = 0; i < N; i++) {
+			int x;
+			cin >> x;
+			nums.push_back(x);
+		}
+		int target;
+		cin >> target;
+		vector<int> ans = searchRange(nums, target);
+		cout << "[";
+		for (auto x : ans) {
+			cout << x << ", ";
+		}
+		cout << "]" << endl;
+
+	}
+}  // } Driver Code Ends

04. Arrays/13_Combination Sum.cpp

@@ -0,0 +1,110 @@
+/*
+Problem statement:
+
+Find all valid combinations of k numbers that sum up to n such that the following conditions are true:
+
+Only numbers 1 through 9 are used.
+Each number is used at most once.
+Return a list of all possible valid combinations.
+The list must not contain the same combination twice, and the combinations may be returned in any order.
+
+
+Example 1:
+
+Input: k = 3, n = 7
+Output: [[1,2,4]]
+Explanation:
+1 + 2 + 4 = 7
+There are no other valid combinations.
+Example 2:
+
+Input: k = 3, n = 9
+Output: [[1,2,6],[1,3,5],[2,3,4]]
+Explanation:
+1 + 2 + 6 = 9
+1 + 3 + 5 = 9
+2 + 3 + 4 = 9
+There are no other valid combinations.
+Example 3:
+
+Input: k = 4, n = 1
+Output: []
+Explanation: There are no valid combinations.
+Using 4 different numbers in the range [1,9], the smallest sum we can get is 1+2+3+4 = 10 and since 10 > 1, there are no valid combination.
+Example 4:
+
+Input: k = 3, n = 2
+Output: []
+Explanation: There are no valid combinations.
+Example 5:
+
+Input: k = 9, n = 45
+Output: [[1,2,3,4,5,6,7,8,9]]
+Explanation:
+1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 = 45
+There are no other valid combinations.
+
+
+Constraints:
+
+2 <= k <= 9
+1 <= n <= 60
+
+*/
+
+
+#include <iostream>
+#include <vector>
+
+
+vector<vector<int>> ans; // declared globally
+
+void makesum(vector<int>& v, int tar, int ssf, vector<int> &temp, int idx, int cnt) {
+	if (ssf > tar) {
+		return;
+	}
+	if (ssf == tar) {
+		if (cnt == 0) {
+			ans.push_back(temp);
+		}
+		return;
+	}
+
+	for (int i = idx; i < v.size(); i++) {
+		temp.push_back(v[i]);
+		makesum(v, tar, ssf + v[i], temp, i + 1, cnt - 1);
+		temp.pop_back();
+	}
+}
+
+
+vector<vector<int>> combinationSum3(int k, int n) {
+	vector<int> temp;
+	vector<int> candidates;
+	for (int i = 0; i < 9; i++) {
+		candidates.push_back(i + 1);
+	}
+	makesum(candidates, n, 0, temp, 0, k);
+	return ans;
+}
+
+int main()
+{
+	std::ios::sync_with_stdio(false);
+	int T;
+	cin >> T;
+	while (T--)
+	{
+		int n, k;
+		cin >> n, k;
+
+		combinationSum3(n, k);
+
+		for (auto x : ans) {
+			cout << x << " ";
+		}
+
+		cout << endl;
+	}
+	return 0;
+}

04. Arrays/14_Russian Doll Envelopes.cpp

@@ -0,0 +1,78 @@
+/*
+
+Problem Statement:
+
+You are given a 2D array of integers envelopes where envelopes[i] = [wi, hi] represents the width and the height of an envelope.
+
+One envelope can fit into another if and only if both the width and height of one envelope are greater than the other envelope's width and height.
+
+Return the maximum number of envelopes you can Russian doll (i.e., put one inside the other).
+
+Note: You cannot rotate an envelope.
+
+
+
+Example 1:
+
+Input: envelopes = [[5,4],[6,4],[6,7],[2,3]]
+Output: 3
+Explanation: The maximum number of envelopes you can Russian doll is 3 ([2,3] => [5,4] => [6,7]).
+Example 2:
+
+Input: envelopes = [[1,1],[1,1],[1,1]]
+Output: 1
+
+
+Constraints:
+
+1 <= envelopes.length <= 5000
+envelopes[i].length == 2
+1 <= wi, hi <= 104
+
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+
+static bool compare(vector<int>&a , vector<int>& b)
+{
+	return a[0] == b[0] ? a[1] > b[1] : a[0] < b[0];
+}
+
+int maxEnvelopes(vector<vector<int>>&a) {
+	sort(a.begin(), a.end(), compare);
+	vector<int>dp;
+	for (auto i : a)
+	{
+		auto it = lower_bound(dp.begin(), dp.end(), i[1]);
+		if (it == dp.end())
+			dp.push_back(i[1]);
+		else
+			*it = i[1];
+	}
+	return dp.size();
+}
+
+int main()
+{
+	std::ios::sync_with_stdio(false);
+	int T;
+	cin >> T;
+	// cin.ignore(); must be there when using getline(cin, s)
+	while (T--)
+	{
+		int n, m;
+		vector<vector<int> > nums(n, vector<int>(m));
+
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				cin >> nums[i][j];
+			}
+		}
+
+		cout << maxEnvelopes(nums) << endl;
+	}
+	return 0;
+}