SkylineWebZ

Min cost path by means of memoizing DP: We utilize a 2D array for memorizing since the recursive solution changes two parameters.To signify that no values are computed initially, we start the 2D array as -1.First we check in the memo table in the recursion. Should we detect value as -1, we only call recursively. In this sense, we avoid recommendations of the same sub-problems. C++ Java Python JavaScript Time Complexity: O(M * N)Auxiliary Space: O(M * N)

Write a function returning cost of minimum cost path to reach (M, N) from (0, 0) considering a cost matrix cost[][ and a position (M, N) in cost[][]. Every matrix cell stands for a cost to be crossed through. Including both source and destination, a path’s total cost to reach (M, N) is the sum of all the expenses on that path. From a given cell, i.e., from a given i, j, cells (i+1, j), and (i, j+1) can be navigated only down, right and diagonally lower cells. Note: You might suppose that every expense is a positive integer. Input The path with minimum cost is highlighted in the following figure. The path is (0, 0) –> (0, 1) –> (1, 2) –> (2, 2). The cost of the path is 8 (1 + 2 + 2 + 3).   Output Table of Content Recursion allows a minimum cost path. Use the below concept to address the issue: The optimal substructure property of this issue exists. One of the three cells—either (m-1, n-1) or (m-1, n) or (m, n-1)—must be the route of reach (m, n). Minimum cost to reach (m, n) can thus be expressed as “minimum of the 3 cells plus cost[m][n]”.min (minCost(m-1, n-1), minCost(m-1, n), minCost(m, n-1)) + cost[m][n] minCost(m, n) C++ C Java Python C# JavaScript Output 8 Time Complexity: O((M * N)3)Auxiliary Space: O(M + N), for recursive stack space

Using Space Optimised DP – O(m*n) Time and O(n) Space We can maximize space by utilizing a single 1D array dp of size c (number of columns), since every dp[i][j] depends just on the left cell of the current row and the previous row. C++ Java Python C# JavaScript

Using Bottom-Up DP (Tabulation) – O(m*n) Time and O(m*n) Space Here the challenge is to determine the count of distinct paths in a grid including obstacles. The state dp[i][j] will show the count of different paths to go to the cell (i, j). Relation in Dynamic Programming: C++ Java Python C# Output 2

Using Top-Down DP(Memoization) – O(m*n) Time and O(m*n) Space C++ Java Python C# JS

Assume we are starting at (1, 1) and want to reach (m, n), given a grid[][] of size m * n. At any moment, should we be on (x, y, we can either proceed to (x, y + 1) or (x + 1, y). The goal is to determine the count of distinct paths should certain grid obstacles be introduced.The grid marks space and an obstruction as 1 and 0 correspondingly. Table of Content Using Recursion – O(2^(m*n)) Time and O(m+n) Space We have covered the issue of counting the distinct paths in a Grid when the grid lacked any obstruction. But here the circumstances are somewhat different. We can come across some barriers in the grid that we cannot leap beyond, hence the path to the bottom right corner is blocked. This method will investigate two primary examples from every cell in both directions: C++ Java Python C# JavaScript Output 2

Problem Statement: Generate Parentheses Given an integer n, generate all combinations of well-formed parentheses of length 2n. A valid combination of parentheses is one where each opening parenthesis ( is properly closed with a closing parenthesis ). Example: Input: n = 3 Output: [“((()))”, “(()())”, “(())()”, “()(())”, “()()()”] Input: n = 1 Output: [“()”] Approach: The problem can be approached using backtracking, which allows us to explore all possible combinations of parentheses while ensuring that at each step, the number of opening parentheses ( is never less than the number of closing parentheses ). Time Complexity: Code Implementation C Code: #include <stdio.h>#include <stdlib.h>#include <string.h>void generateParenthesisRecursive(int n, int open_count, int close_count, char* current, char** result, int* returnSize) { if (open_count == n && close_count == n) { result[*returnSize] = (char*)malloc(strlen(current) + 1); strcpy(result[*returnSize], current); (*returnSize)++; return; } if (open_count < n) { current[open_count + close_count] = ‘(‘; generateParenthesisRecursive(n, open_count + 1, close_count, current, result, returnSize); } if (close_count < open_count) { current[open_count + close_count] = ‘)’; generateParenthesisRecursive(n, open_count, close_count + 1, current, result, returnSize); }}char** generateParenthesis(int n, int* returnSize) { char** result = (char**)malloc(100 * sizeof(char*)); // Assumption: max result size char* current = (char*)malloc(2 * n + 1); *returnSize = 0; generateParenthesisRecursive(n, 0, 0, current, result, returnSize); free(current); return result;}int main() { int returnSize; char** result = generateParenthesis(3, &returnSize); for (int i = 0; i < returnSize; i++) { printf(“%s\n”, result[i]); free(result[i]); } free(result); return 0;} C++ Code: #include <iostream>#include <vector>#include <string>using namespace std;class Solution {public: vector<string> generateParenthesis(int n) { vector<string> result; backtrack(n, 0, 0, “”, result); return result; }private: void backtrack(int n, int open_count, int close_count, string current, vector<string>& result) { if (open_count == n && close_count == n) { result.push_back(current); return; } if (open_count < n) { backtrack(n, open_count + 1, close_count, current + “(“, result); } if (close_count < open_count) { backtrack(n, open_count, close_count + 1, current + “)”, result); } }};int main() { Solution solution; vector<string> result = solution.generateParenthesis(3); for (const string& combination : result) { cout << combination << endl; } return 0;} Java Code: import java.util.ArrayList;import java.util.List;public class Solution { public List<String> generateParenthesis(int n) { List<String> result = new ArrayList<>(); backtrack(n, 0, 0, “”, result); return result; } private void backtrack(int n, int open_count, int close_count, String current, List<String> result) { if (open_count == n && close_count == n) { result.add(current); return; } if (open_count < n) { backtrack(n, open_count + 1, close_count, current + “(“, result); } if (close_count < open_count) { backtrack(n, open_count, close_count + 1, current + “)”, result); } } public static void main(String[] args) { Solution solution = new Solution(); List<String> result = solution.generateParenthesis(3); for (String combination : result) { System.out.println(combination); } }} Python Code: class Solution: def generateParenthesis(self, n: int): result = [] self._backtrack(n, 0, 0, “”, result) return result def _backtrack(self, n: int, open_count: int, close_count: int, current: str, result: list): if open_count == n and close_count == n: result.append(current) return if open_count < n: self._backtrack(n, open_count + 1, close_count, current + “(“, result) if close_count < open_count: self._backtrack(n, open_count, close_count + 1, current + “)”, result)# Example usagesolution = Solution()print(solution.generateParenthesis(3)) # Output: [‘((()))’, ‘(()())’, ‘(())()’, ‘()(())’, ‘()()()’] C# Code: using System;using System.Collections.Generic;public class Solution { public IList<string> GenerateParenthesis(int n) { List<string> result = new List<string>(); Backtrack(n, 0, 0, “”, result); return result; } private void Backtrack(int n, int open_count, int close_count, string current, List<string> result) { if (open_count == n && close_count == n) { result.Add(current); return; } if (open_count < n) { Backtrack(n, open_count + 1, close_count, current + “(“, result); } if (close_count < open_count) { Backtrack(n, open_count, close_count + 1, current + “)”, result); } } public static void Main() { Solution solution = new Solution(); var result = solution.GenerateParenthesis(3); foreach (var combination in result) { Console.WriteLine(combination); } }} JavaScript Code: javascriptCopy codevar generateParenthesis = function(n) { const result = []; function backtrack(current, open_count, close_count) { if (open_count === n && close_count === n) { result.push(current); return; } if (open_count < n) { backtrack(current + “(“, open_count + 1, close_count); } if (close_count < open_count) { backtrack(current + “)”, open_count, close_count + 1); } } backtrack(“”, 0, 0); return result; }; console.log(generateParenthesis(3)); // Output: [“((()))”, “(()())”, “(())()”, “()(())”, “()()()”] Explanation: Time Complexity: Summary: This problem can be efficiently solved using backtracking, where we explore all possible combinations of parentheses while ensuring that each combination is valid. This method generates all valid parentheses combinations for a given n in an optimal way.

Problem Statement: Valid Parentheses Given a string containing just the characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[‘, and ‘]’, determine if the input string is valid. An input string is valid if: Note: Example: Input: “()” Output: True Input: “()[]{}” Output: True Input: “(]” Output: False Input: pythonCopy code”([)]” Output: pythonCopy codeFalse Input: “{[]}” Output: True Approach: The problem is best solved using a stack data structure. The stack allows us to keep track of opening parentheses, and we can check whether the most recent opening parenthesis matches the closing parenthesis as we iterate through the string. Time Complexity: Code Implementation C Code: #include <stdio.h>#include <stdbool.h>#include <string.h>bool isValid(char* s) { int len = strlen(s); char stack[len]; int top = -1; for (int i = 0; i < len; i++) { char ch = s[i]; if (ch == ‘(‘ || ch == ‘{‘ || ch == ‘[‘) { stack[++top] = ch; } else { if (top == -1) return false; // Stack is empty, unmatched closing bracket char topElement = stack[top–]; if ((ch == ‘)’ && topElement != ‘(‘) || (ch == ‘}’ && topElement != ‘{‘) || (ch == ‘]’ && topElement != ‘[‘)) { return false; // Mismatched parentheses } } } return top == -1; // If the stack is empty, it’s a valid string}int main() { char s[] = “()[]{}”; printf(“Is valid: %s\n”, isValid(s) ? “True” : “False”); // Output: True return 0;} C++ Code: #include <iostream>#include <stack>#include <string>using namespace std;class Solution {public: bool isValid(string s) { stack<char> stack; for (char ch : s) { if (ch == ‘(‘ || ch == ‘{‘ || ch == ‘[‘) { stack.push(ch); } else { if (stack.empty()) return false; // If stack is empty, no matching opening parenthesis char top = stack.top(); stack.pop(); if ((ch == ‘)’ && top != ‘(‘) || (ch == ‘}’ && top != ‘{‘) || (ch == ‘]’ && top != ‘[‘)) { return false; // Mismatched parentheses } } } return stack.empty(); // If stack is empty, all parentheses matched }};int main() { Solution solution; cout << (solution.isValid(“()[]{}”) ? “True” : “False”) << endl; // Output: True return 0;} Java Code: import java.util.Stack;public class Solution { public boolean isValid(String s) { Stack<Character> stack = new Stack<>(); for (char ch : s.toCharArray()) { if (ch == ‘(‘ || ch == ‘{‘ || ch == ‘[‘) { stack.push(ch); } else { if (stack.isEmpty()) return false; // Stack is empty, no matching opening parenthesis char top = stack.pop(); if ((ch == ‘)’ && top != ‘(‘) || (ch == ‘}’ && top != ‘{‘) || (ch == ‘]’ && top != ‘[‘)) { return false; // Mismatched parentheses } } } return stack.isEmpty(); // If stack is empty, all parentheses matched } public static void main(String[] args) { Solution solution = new Solution(); System.out.println(solution.isValid(“()[]{}”)); // Output: true }} Python Code: class Solution: def isValid(self, s: str) -> bool: stack = [] mapping = {‘)’: ‘(‘, ‘}’: ‘{‘, ‘]’: ‘[‘} for char in s: if char in mapping: top_element = stack.pop() if stack else ‘#’ if mapping[char] != top_element: return False else: stack.append(char) return not stack # If stack is empty, all parentheses matched# Example Usagesolution = Solution()print(solution.isValid(“()[]{}”)) # Output: True C# Code: using System;using System.Collections.Generic;public class Solution { public bool IsValid(string s) { Stack<char> stack = new Stack<char>(); foreach (char ch in s) { if (ch == ‘(‘ || ch == ‘{‘ || ch == ‘[‘) { stack.Push(ch); } else { if (stack.Count == 0) return false; // Stack is empty, no matching opening parenthesis char top = stack.Pop(); if ((ch == ‘)’ && top != ‘(‘) || (ch == ‘}’ && top != ‘{‘) || (ch == ‘]’ && top != ‘[‘)) { return false; // Mismatched parentheses } } } return stack.Count == 0; // If stack is empty, all parentheses matched } public static void Main() { Solution solution = new Solution(); Console.WriteLine(solution.IsValid(“()[]{}”)); // Output: True }} JavaScript Code: var isValid = function(s) { const stack = []; const mapping = {‘)’: ‘(‘, ‘}’: ‘{‘, ‘]’: ‘[‘}; for (let char of s) { if (char in mapping) { let top = stack.pop() || ‘#’; if (mapping[char] !== top) return false; } else { stack.push(char); } } return stack.length === 0;};console.log(isValid(“()[]{}”)); // Output: true Explanation: Edge Cases: Time Complexity: Summary: The problem is efficiently solved using a stack, which allows us to track the opening brackets and check if they match the closing brackets in the correct order. This ensures that the string is valid if and only if all opening parentheses are properly closed and nested.