Add April Week 3

Author: thepushkarp

April30DayChallenge/Week3/15:ProductOfArrayExceptSelf.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+ vector<int> productExceptSelf(vector<int>& nums) {
+ vector<int> ans;
+ int prod = 1;
+ for (int i = 0; i < nums.size(); i++) {
+ ans.push_back(prod);
+ prod*=nums[i];
+ }
+ prod = 1;
+ for (int i = nums.size() - 1; i >= 0; i--) {
+ ans[i]*=prod;
+ prod*=nums[i];
+ }
+ return ans;
+ }
+};

April30DayChallenge/Week3/16:ValidParenthesisString.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+ bool checkValidString(string s) {
+ int lo = 0, hi = 0;
+ for (int i = 0; i < s.size(); i++) {
+ if (s[i] == ')') {
+ hi--;
+ if (lo > 0) lo--;
+ }
+ if (s[i] == '(') {
+ lo++;
+ hi++;
+ }
+ if (s[i] == '*') {
+ hi++;
+ if (lo > 0) {
+ lo--;
+ }
+ }
+ if (hi < 0) return false;
+ }
+ if (lo == 0) return true;
+ else return false;
+ }
+};

April30DayChallenge/Week3/17:NumberofIslands.cpp

@@ -0,0 +1,50 @@
+class Solution {
+public:
+ int numIslands(vector<vector<char>>& grid) {
+ int r = grid.size();
+ if (r == 0) return 0;
+ int c = grid[0].size();
+ vector<vector<int>> visited(r, vector<int>(c, 0));
+ int islands = 0;
+ queue<pair<int, int>> q;
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j < c; j++) {
+ if (grid[i][j] == '1' and !visited[i][j]) {
+ q.push(make_pair(i, j));
+ visited[i][j] = 1;
+ islands++;
+ while (!q.empty()) {
+ int cr = q.front().first;
+ int cc = q.front().second;
+ if (cr > 0) {
+ if (grid[cr - 1][cc] == '1' and !visited[cr - 1][cc]) {
+ q.push(make_pair(cr - 1, cc));
+ visited[cr - 1][cc] = 1;
+ }
+ }
+ if (cc > 0) {
+ if (grid[cr][cc - 1] == '1' and !visited[cr][cc - 1]) {
+ q.push(make_pair(cr, cc - 1));
+ visited[cr][cc - 1] = 1;
+ }
+ }
+ if (cr < r - 1) {
+ if (grid[cr + 1][cc] == '1' and !visited[cr + 1][cc]) {
+ q.push(make_pair(cr + 1, cc));
+ visited[cr + 1][cc] = 1;
+ }
+ }
+ if (cc < c - 1) {
+ if (grid[cr][cc + 1] == '1' and !visited[cr][cc + 1]) {
+ q.push(make_pair(cr, cc + 1));
+ visited[cr][cc + 1] = 1;
+ }
+ }
+ q.pop();
+ }
+ }
+ }
+ }
+ return islands;
+ }
+};

April30DayChallenge/Week3/18:MinimumPathSum.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+ int minPathSum(vector<vector<int>>& grid) {
+ int r = grid.size();
+ if (r == 0) return 0;
+ int c = grid[0].size();
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j < c; j++) {
+ if (i or j) {
+ int mini = INT_MAX;
+ if (i > 0) mini = grid[i - 1][j];
+ if (j > 0) mini = min(mini, grid[i][j - 1]);
+ grid[i][j] = mini + grid[i][j];
+ }
+ }
+ }
+ return grid[r - 1][c - 1];
+ }
+};

April30DayChallenge/Week3/19:SearchinRotatedSortedArray.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+ int search(vector<int>& nums, int target) {
+ int n = nums.size();
+ if (n == 0) return -1;
+ if (n == 1) return target==nums[0]?0:-1;
+ int lo = 0, hi = n - 1;
+ while (lo <= hi) {
+ int mid = (lo + hi)/2;
+ if (target == nums[mid]) return mid;
+ if (nums[lo] <= nums[mid]) {
+ if (target >= nums[lo] and target <= nums[mid]) {
+ hi = mid - 1;
+ }
+ else lo = mid + 1;
+ }
+ else {
+ if (target >= nums[mid] and target <= nums[hi]) {
+ lo = mid + 1;
+ }
+ else hi = mid - 1;
+ }
+ }
+ return -1;
+ }
+};

April30DayChallenge/Week3/20:ConstructBinarySearchTreefrom

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+ int index = 0;
+ TreeNode* constructTree(vector<int>& preorder, int mini, int maxi, int size) {
+ if( index >= size )
+ return nullptr;
+ TreeNode* curr = nullptr;
+ int currData = preorder[index];
+ if ((currData > mini) and (currData < maxi))
+ {
+ curr = new TreeNode(currData);
+ index++;
+ curr -> left = constructTree(preorder, mini, currData, size );
+ curr -> right = constructTree(preorder, currData, maxi, size );
+ }
+ return curr;
+ }
+ TreeNode* bstFromPreorder(vector<int>& preorder) {
+ int size = preorder.size();
+ return constructTree(preorder, INT_MIN, INT_MAX, size);
+ }
+};