diff --git a/dsa-problems/leetcode-problems/0700-0799.md b/dsa-problems/leetcode-problems/0700-0799.md
index c82f100e0..2eb8ca074 100644
--- a/dsa-problems/leetcode-problems/0700-0799.md
+++ b/dsa-problems/leetcode-problems/0700-0799.md
@@ -92,7 +92,7 @@ export const problems = [
"problemName": "713. Subarray Product Less Than K",
"difficulty": "Medium",
"leetCodeLink": "https://leetcode.com/problems/subarray-product-less-than-k",
- "solutionLink": "#"
+ "solutionLink": "/dsa-solutions/lc-solutions/0700-0799/subarray-product-less-than-k"
},
{
"problemName": "714. Best Time to Buy and Sell Stock with Transaction Fee",
diff --git a/dsa-problems/leetcode-problems/1100-1199.md b/dsa-problems/leetcode-problems/1100-1199.md
index d68e6facd..470af0b85 100644
--- a/dsa-problems/leetcode-problems/1100-1199.md
+++ b/dsa-problems/leetcode-problems/1100-1199.md
@@ -320,7 +320,7 @@ export const problems = [
"problemName": "1161. Maximum Level Sum of a Binary Tree",
"difficulty": "Medium",
"leetCodeLink": "https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree",
- "solutionLink": "#"
+ "solutionLink": "/dsa-solutions/lc-solutions/1100-1199/maximum-level-sum-of-a-binary-tree"
},
{
"problemName": "1162. As Far from Land as Possible",
diff --git a/dsa-solutions/lc-solutions/0700-0799/0713-subarray-product-less-than-k.md b/dsa-solutions/lc-solutions/0700-0799/0713-subarray-product-less-than-k.md
new file mode 100644
index 000000000..7b305d7f2
--- /dev/null
+++ b/dsa-solutions/lc-solutions/0700-0799/0713-subarray-product-less-than-k.md
@@ -0,0 +1,281 @@
+---
+id: subarray-product-less-than-k
+title: Subarray Product Less Than K
+sidebar_label: 713. Subarray Product Less Than K
+
+tags:
+- Array
+- Sliding Window
+
+description: "This is a solution to the Subarray Product Less Than K problem on LeetCode."
+---
+
+## Problem Description
+Given an array of integers nums and an integer k, return the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than k.
+### Examples
+
+**Example 1:**
+```
+Input: nums = [10,5,2,6], k = 100
+Output: 8
+Explanation: The 8 subarrays that have product less than 100 are:
+[10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6]
+Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.
+```
+
+**Example 2:**
+```
+Input: nums = [1,2,3], k = 0
+Output: 0
+
+```
+
+
+### Constraints
+- `1 <= nums.length <= 3 * 10^4`
+- `1 <= nums[i] <= 1000`
+- `0 <= k <= 10^6`
+
+## Solution for Path With Minimum Effort Problem
+### Approach
+#### Brute Force
+- Generate All the Subarray and Check whether the which subarray has product less than K.
+
+#### Optimized Approach - Sliding Window
+##### Initialize Pointers and Variables:
+
+- Use two pointers, i and j, to represent the start and end of the current subarray, respectively.
+- Initialize prod to 1 to keep track of the product of elements in the current window.
+- Initialize cnt to 0 to count the number of valid subarrays.
+##### Expand the Window:
+
+- Start with both pointers at the beginning of the array. Expand the window by moving the j pointer to the right, multiplying the product prod by the new element nums[j].
+##### Check the Product:
+
+- If the product prod is less than k, all subarrays ending at j and starting from any position between i and j are valid. Therefore, add j - i + 1 to cnt.
+Shrink the Window:
+
+- If the product prod is greater than or equal to k, move the i pointer to the right until the product is less than k. Each time you move i, divide prod by nums[i].
+##### Repeat:
+
+- Continue expanding the window with j and adjusting i as needed until j reaches the end of the array.
+##### Return the Result:
+
+- The total count cnt is the number of subarrays with a product less than k.
+
+
+
+
+
+ #### Implementation
+ ```jsx live
+ function Solution(arr) {
+ var numSubarrayProductLessThanK = function(nums, k) {
+ let i = 0;
+ let j = 0;
+ let cnt = 0;
+ let prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return cnt;
+ };
+
+ const input =[10,5,2,6]
+ const k = 100
+ const output = numSubarrayProductLessThanK(input , k)
+ return (
+
+
+ Input:
+ {JSON.stringify(input)}
+
+
+ Output: {output.toString()}
+
+
+ );
+ }
+ ```
+
+ #### Complexity Analysis
+
+ - Time Complexity: $ O(N) $
+ - Space Complexity: $ O(1)$
+
+ ## Code in Different Languages
+
+
+
+ ```javascript
+ var numSubarrayProductLessThanK = function(nums, k) {
+ let i = 0;
+ let j = 0;
+ let cnt = 0;
+ let prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return cnt;
+};
+
+ ```
+
+
+
+
+ ```typescript
+ function numSubarrayProductLessThanK(nums: number[], k: number): number {
+ let i = 0;
+ let j = 0;
+ let cnt = 0;
+ let prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return cnt;
+}
+
+ ```
+
+
+
+ ```python
+ class Solution:
+ def numSubarrayProductLessThanK(self, nums, k):
+ i = 0
+ j = 0
+ cnt = 0
+ prod = 1
+ while j < len(nums):
+ prod *= nums[j]
+ if prod < k:
+ cnt += j - i + 1
+ else:
+ while prod >= k and i <= j:
+ prod /= nums[i]
+ i += 1
+ if prod < k:
+ cnt += j - i + 1
+ j += 1
+ return cnt
+
+ ```
+
+
+
+
+ ```java
+ class Solution {
+ public int numSubarrayProductLessThanK(int[] nums, int k) {
+ int i = 0;
+ int j = 0;
+ long cnt = 0;
+ long prod = 1;
+ while (j < nums.length) {
+ prod *= nums[j];
+ if (prod < k) {
+ cnt += j - i + 1;
+ } else {
+ while (prod >= k && i <= j) {
+ prod /= nums[i];
+ i++;
+ }
+ if (prod < k) {
+ cnt += j - i + 1;
+ }
+ }
+ j++;
+ }
+ return (int) cnt;
+ }
+}
+
+ ```
+
+
+
+
+ ```cpp
+ class Solution {
+public:
+ int numSubarrayProductLessThanK(vector& nums, int k) {
+ int i=0;
+ int j=0;
+ long long cnt = 0;
+ long long prod = 1;
+ while(j=k)
+ {
+ while(prod>=k && i<=j)
+ {
+ prod/=nums[i];
+ i++;
+ }
+
+ if(prod
+
+
+
+
+
+## References
+
+- **LeetCode Problem**: [Subarray Product Less Than K](https://leetcode.com/problems/subarray-product-less-than-k/description/)
+
+- **Solution Link**: [LeetCode Solution](https://leetcode.com/problems/subarray-product-less-than-k/solutions)
+
diff --git a/dsa-solutions/lc-solutions/1100-1199/1161-maximum-level-sum-of-a-binary-tree.md b/dsa-solutions/lc-solutions/1100-1199/1161-maximum-level-sum-of-a-binary-tree.md
new file mode 100644
index 000000000..21e09c8f6
--- /dev/null
+++ b/dsa-solutions/lc-solutions/1100-1199/1161-maximum-level-sum-of-a-binary-tree.md
@@ -0,0 +1,385 @@
+---
+id: maximum-level-sum-of-a-binary-tree
+title: Maximum Level Sum of a Binary Tree
+sidebar_label: 1161. Maximum Level Sum of a Binary Tree
+tags:
+- Tree
+- Breadth-First Search
+- Binary Tree
+description: "This is a solution to the Maximum Level Sum of a Binary Tree problem on LeetCode."
+---
+
+## Problem Description
+Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.
+
+Return the smallest level x such that the sum of all the values of nodes at level x is maximal.
+### Examples
+
+**Example 1:**
+
+```
+Input: root = [1,7,0,7,-8,null,null]
+Output: 2
+Explanation:
+Level 1 sum = 1.
+Level 2 sum = 7 + 0 = 7.
+Level 3 sum = 7 + -8 = -1.
+So we return the level with the maximum sum which is level 2.
+```
+
+**Example 2:**
+```
+Input: root = [989,null,10250,98693,-89388,null,null,null,-32127]
+Output: 2
+```
+
+### Constraints
+- `The number of nodes in the tree is in the range [1, 10^4]`
+- `-10^5 <= Node.val <= 10^5`
+
+## Solution for Maximum Level Sum of a Binary
+
+### Approach
+The problem is to find the level in a binary tree that has the maximum sum of node values. To solve this, we use a breadth-first search (BFS) approach, which is well-suited for level-order traversal of a tree. BFS allows us to process nodes level by level, making it easy to calculate the sum of values at each level.
+
+#### Initial Checks and Setup:
+
+- If the root is null, return -1 as there are no levels in the tree.
+- Initialize a queue and add the root node to it. This queue will help us traverse the tree level by level.
+- Initialize variables to keep track of the maximum sum (maxSum), the level with the maximum sum (ans), and the current level (level). Set maxSum to a very small value to ensure any level sum will be larger initially.
+#### Level-Order Traversal Using BFS:
+
+- Use a while loop to process nodes until the queue is empty.
+- Increment the level variable at the start of each iteration of the while loop to represent the current level.
+- Determine the number of nodes at the current level (size), which is the current length of the queue.
+- Initialize a temporary sum variable (tempSum) to zero for storing the sum of values at the current level.
+#### Processing Each Level:
+
+- Use a for loop to iterate over all nodes at the current level. The loop runs size times.
+- For each node, dequeue it from the queue, add its value to tempSum, and enqueue its left and right children (if they exist).
+#### Update Maximum Sum and Level:
+
+- After processing all nodes at the current level, compare tempSum with maxSum.
+- If tempSum is greater than maxSum, update maxSum to tempSum and set ans to the current level.
+#### Return the Result:
+
+- Once all levels have been processed and the queue is empty, return ans, which holds the level number with the maximum sum.
+
+
+
+#### Implementation
+
+```jsx live
+function Solution() {
+class TreeNode {
+ constructor(val = 0, left = null, right = null) {
+ this.val = val;
+ this.left = left;
+ this.right = right;
+ }
+}
+
+var maxLevelSum = function(root) {
+ if (!root) return -1;
+
+ let ans = -1;
+ let level = 0;
+ let maxSum = Number.MIN_SAFE_INTEGER;
+ const queue = [root];
+
+ while (queue.length > 0) {
+ level++;
+ const size = queue.length;
+ let tempSum = 0;
+ for (let i = 0; i < size; i++) {
+ const curr = queue.shift();
+ tempSum += curr.val;
+ if (curr.left) queue.push(curr.left);
+ if (curr.right) queue.push(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+};
+function constructTreeFromArray(array) {
+ if (!array.length) return null;
+
+ let root = new TreeNode(array[0]);
+ let queue = [root];
+ let i = 1;
+
+ while (i < array.length) {
+ let currentNode = queue.shift();
+
+ if (array[i] !== null) {
+ currentNode.left = new TreeNode(array[i]);
+ queue.push(currentNode.left);
+ }
+ i++;
+
+ if (i < array.length && array[i] !== null) {
+ currentNode.right = new TreeNode(array[i]);
+ queue.push(currentNode.right);
+ }
+ i++;
+ }
+ return root;
+}
+const array = [1,7,0,7,-8,null,null]
+const root = constructTreeFromArray(array)
+const input = root
+const output = maxLevelSum(root)
+ return (
+
+
+ Input: {JSON.stringify(array)}
+
+
+ Output: {output.toString()}
+
+
+ );
+}
+```
+
+### Code in Different Languages
+
+
+
+
+ ```javascript
+ var maxLevelSum = function(root) {
+ if (!root) return -1;
+
+ let ans = -1;
+ let level = 0;
+ let maxSum = Number.MIN_SAFE_INTEGER;
+ const queue = [root];
+
+ while (queue.length > 0) {
+ level++;
+ const size = queue.length;
+ let tempSum = 0;
+ for (let i = 0; i < size; i++) {
+ const curr = queue.shift();
+ tempSum += curr.val;
+ if (curr.left) queue.push(curr.left);
+ if (curr.right) queue.push(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+};
+```
+
+
+
+ ```typescript
+ class TreeNode {
+ val: number;
+ left: TreeNode | null;
+ right: TreeNode | null;
+ constructor(val: number = 0, left: TreeNode | null = null, right: TreeNode | null = null) {
+ this.val = val;
+ this.left = left;
+ this.right = right;
+ }
+}
+
+function maxLevelSum(root: TreeNode | null): number {
+ if (!root) return -1;
+
+ let ans = -1;
+ let level = 0;
+ let maxSum = Number.MIN_SAFE_INTEGER;
+ const queue: TreeNode[] = [root];
+
+ while (queue.length > 0) {
+ level++;
+ const size = queue.length;
+ let tempSum = 0;
+ for (let i = 0; i < size; i++) {
+ const curr = queue.shift()!;
+ tempSum += curr.val;
+ if (curr.left) queue.push(curr.left);
+ if (curr.right) queue.push(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+}
+
+ ```
+
+
+
+ ```python
+ # Definition for a binary tree node.
+class TreeNode:
+ def __init__(self, val=0, left=None, right=None):
+ self.val = val
+ self.left = left
+ self.right = right
+
+class Solution:
+ def maxLevelSum(self, root: TreeNode) -> int:
+ if not root:
+ return -1
+
+ from collections import deque
+
+ ans = -1
+ level = 0
+ max_sum = float('-inf')
+ queue = deque([root])
+
+ while queue:
+ level += 1
+ size = len(queue)
+ temp_sum = 0
+ for _ in range(size):
+ curr = queue.popleft()
+ temp_sum += curr.val
+ if curr.left:
+ queue.append(curr.left)
+ if curr.right:
+ queue.append(curr.right)
+ if temp_sum > max_sum:
+ ans = level
+ max_sum = temp_sum
+
+ return ans
+
+ ```
+
+
+
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode() {}
+ * TreeNode(int val) { this.val = val; }
+ * TreeNode(int val, TreeNode left, TreeNode right) {
+ * this.val = val;
+ * this.left = left;
+ * this.right = right;
+ * }
+ * }
+ */
+import java.util.*;
+
+class Solution {
+ public int maxLevelSum(TreeNode root) {
+ if (root == null) return -1;
+
+ int ans = -1;
+ int level = 0;
+ int maxSum = Integer.MIN_VALUE;
+ Queue queue = new LinkedList<>();
+ queue.add(root);
+
+ while (!queue.isEmpty()) {
+ level++;
+ int size = queue.size();
+ int tempSum = 0;
+ for (int i = 0; i < size; i++) {
+ TreeNode curr = queue.poll();
+ tempSum += curr.val;
+ if (curr.left != null) queue.add(curr.left);
+ if (curr.right != null) queue.add(curr.right);
+ }
+ if (tempSum > maxSum) {
+ ans = level;
+ maxSum = tempSum;
+ }
+ }
+
+ return ans;
+ }
+}
+
+```
+
+
+
+```cpp
+/**
+ * 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 maxLevelSum(TreeNode* root) {
+ int ans=-1;
+ int level=0;
+ int sum=INT_MIN;
+ queue q;
+ if(!root) return ans;
+
+ q.push(root);
+
+ while(!q.empty()){
+
+ level++;
+ int size = q.size();
+ int temp=0;
+ while(size--){
+ TreeNode *curr = q.front();
+ q.pop();
+ temp+=curr->val;
+
+ if(curr->left) q.push(curr->left);
+ if(curr->right) q.push(curr->right);
+
+ }
+ if(temp>sum)
+ {
+ ans=level;
+ sum=temp;
+ }
+ }
+
+ return ans;
+ }
+};
+```
+
+
+
+#### Complexity Analysis
+ ##### Time Complexity: $O(N)$ , because of tree traversal
+
+ ##### Space Complexity: $O(1)$
+
+
+
+## References
+
+- **LeetCode Problem**: [Maximum Level Sum of a Binary Tree](https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/description/)
+
+- **Solution Link**: [LeetCode Solution](https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/description/)
+