19-06-2024

Author: Hasheditz

Daily Solution Leetcode/19-16-2024.md

@@ -0,0 +1,102 @@
+### Editorial for the Problem: [Minimum Number of Days to Make m Bouquets](https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/)
+
+## **Date**: June 19, 2024
+
+**Difficulty**: ![Medium](https://img.shields.io/badge/Medium-yellow)  
+**Related Topics**: ![Array](https://img.shields.io/badge/Array-blue) ![Binary Search](https://img.shields.io/badge/Binary%20Search-blue)
+
+<p>
+  <a href="https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/">
+    <img src="https://img.shields.io/badge/Link%20To%20The%20Question-blue" alt="Link To The Question">
+  </a>
+</p>
+
+## Editorial
+
+The problem is to determine the minimum number of days required to make \( m \) bouquets from an array of days, where each bouquet consists of \( k \) consecutive flowers. If it's not possible to make \( m \) bouquets, return -1.
+
+### Approach
+
+This problem can be efficiently solved using a binary search on the number of days. The idea is to find the minimum day such that we can make \( m \) bouquets using the given flowers blooming days.
+
+#### Key Steps:
+
+1. **Binary Search Initialization**:
+    - Set `low` to the minimum day in the array.
+    - Set `high` to the maximum day in the array.
+
+2. **Binary Search Loop**:
+    - Calculate `mid` as the average of `low` and `high`.
+    - Use a helper function `sets` to count the number of bouquets that can be made if the flowers bloom by day `mid`.
+    - If the number of bouquets is greater than or equal to \( m \), update the result and adjust the search to find a potentially smaller day by setting `high` to `mid - 1`.
+    - If the number of bouquets is less than \( m \), adjust the search to find a larger day by setting `low` to `mid + 1`.
+
+3. **Helper Function `sets`**:
+    - This function counts the number of bouquets that can be made by day `mid`.
+    - It iterates through the array and counts the number of consecutive flowers that bloom by `mid`.
+    - When a non-blooming flower is encountered, it calculates the number of bouquets from the consecutive blooming flowers and resets the counter.
+
+### Code
+
+```cpp
+class Solution {
+    int sets(vector<int> &day, int k, int mid) {
+        int curr = 0, n = day.size(), cnt = 0;
+        for (int i = 0; i < n; i++) {
+            if (day[i] <= mid) curr++;
+            else {cnt += curr / k; curr = 0;}
+        }
+        cnt += curr / k;
+        return cnt;
+    }
+
+public:
+    int minDays(vector<int>& day, int m, int k) {
+        int n = day.size();
+        if (n < 1LL * m * k) return -1;
+
+        int low = *min_element(day.begin(), day.end());
+        int high = *max_element(day.begin(), day.end());
+        int res = INT_MAX;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+            int curr = sets(day, k, mid);
+
+            if (curr >= m) {
+                res = min(res, mid);
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return res;
+    }
+};
+```
+### Explanation of Code
+
+**Helper Function `sets`**:
+
+- It initializes `curr` to count consecutive blooming flowers and `cnt` to count bouquets.
+- Iterates through the `day` array and increments `curr` if the flower blooms by `mid`.
+- If a flower does not bloom by `mid`, it calculates the number of bouquets from `curr` and resets `curr`.
+
+**Main Function `minDays`**:
+
+- Checks if the total number of flowers is less than ( m times k ). If true, returns -1.
+- Initializes `low` to the smallest day and `high` to the largest day.
+- Uses binary search to find the minimum day where \( m \) bouquets can be made.
+- Updates the result and adjusts the search range based on the number of bouquets that can be made by the current `mid` day.
+
+**Efficiency**:
+
+- The binary search approach ensures a time complexity of O(N log (Max-Min)), making it efficient for large inputs.
+
+### Like and Upvote
+
+If you found this solution helpful, please consider liking 👍 and upvoting ⬆️. Your support helps in continuing to provide high-quality solutions.
+
+<p align="center">
+  <img src="https://preview.redd.it/petition-to-change-the-upvote-and-downvote-button-to-like-v0-jbrdq402054c1.jpg?width=640&crop=smart&auto=webp&s=8225d21c98a245f44fd6c1f74a4c6c67f0061f25" width="280">
+</p>

LeetCode/1482. Minimum Number of Days to Make m Bouquets.cpp

@@ -0,0 +1,41 @@
+class Solution {
+
+    int sets(vector<int> &day , int k , int mid)
+    {
+        int curr = 0, n = day.size(), j = 0, cnt = 0;
+
+        for(int i = 0 ; i < n ; i++)
+        {
+            if(day[i] <= mid) curr++;
+
+            else {cnt += curr/k; curr = 0;}
+        }
+
+        cnt += curr/k;
+        return cnt;
+    }
+
+public:
+    int minDays(vector<int>& day, int m, int k) {
+
+        int n = day.size();
+
+        if(n < 1LL*m*k) return -1;
+        
+        int res = INT_MAX;
+        int low = *min_element(day.begin() , day.end());
+        int high = *max_element(day.begin() , day.end());
+
+        while(low <= high)
+        {
+            int mid = (low + high)/2;
+
+            int curr = sets(day,k,mid);
+
+            if(curr >= m) {res = min(res, mid); high = mid - 1; }
+            else low = mid + 1;
+        }
+
+        return res;
+    }
+};

readme.md

@@ -1,74 +1,99 @@
-### Editorial for the Problem: [Most Profit Assigning Work](https://leetcode.com/problems/most-profit-assigning-work/)
+### Editorial for the Problem: [Minimum Number of Days to Make m Bouquets](https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/)
 
-## **Date**: June 18, 2024
+## **Date**: June 19, 2024
 
 **Difficulty**: ![Medium](https://img.shields.io/badge/Medium-yellow)  
-**Related Topics**: ![Array](https://img.shields.io/badge/Array-blue) ![Binary Search](https://img.shields.io/badge/Binary%20Search-blue) ![Sorting](https://img.shields.io/badge/Sorting-blue)
+**Related Topics**: ![Array](https://img.shields.io/badge/Array-blue) ![Binary Search](https://img.shields.io/badge/Binary%20Search-blue)
 
 <p>
-  <a href="https://leetcode.com/problems/most-profit-assigning-work/">
+  <a href="https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/">
     <img src="https://img.shields.io/badge/Link%20To%20The%20Question-blue" alt="Link To The Question">
   </a>
 </p>
 
 ## Editorial
 
-Given the difficulty of tasks and the corresponding profits, along with the abilities of workers, the task is to assign workers to tasks in a way that maximizes the total profit.
+The problem is to determine the minimum number of days required to make \( m \) bouquets from an array of days, where each bouquet consists of \( k \) consecutive flowers. If it's not possible to make \( m \) bouquets, return -1.
 
 ### Approach
 
-We can solve this problem using a brute-force approach by iterating through each worker and finding the most profitable task they can perform.
+This problem can be efficiently solved using a binary search on the number of days. The idea is to find the minimum day such that we can make \( m \) bouquets using the given flowers blooming days.
 
 #### Key Steps:
-1. **Initialization**: Calculate the number of workers (`n`) and the number of tasks (`m`).
-2. **Iterate Through Workers**: For each worker, check each task they can perform based on their ability.
-3. **Update Profit**: Keep track of the maximum profit a worker can achieve and add it to the total profit.
+
+1. **Binary Search Initialization**:
+    - Set `low` to the minimum day in the array.
+    - Set `high` to the maximum day in the array.
+
+2. **Binary Search Loop**:
+    - Calculate `mid` as the average of `low` and `high`.
+    - Use a helper function `sets` to count the number of bouquets that can be made if the flowers bloom by day `mid`.
+    - If the number of bouquets is greater than or equal to \( m \), update the result and adjust the search to find a potentially smaller day by setting `high` to `mid - 1`.
+    - If the number of bouquets is less than \( m \), adjust the search to find a larger day by setting `low` to `mid + 1`.
+
+3. **Helper Function `sets`**:
+    - This function counts the number of bouquets that can be made by day `mid`.
+    - It iterates through the array and counts the number of consecutive flowers that bloom by `mid`.
+    - When a non-blooming flower is encountered, it calculates the number of bouquets from the consecutive blooming flowers and resets the counter.
 
 ### Code
 
 ```cpp
 class Solution {
-public:
-    int maxProfitAssignment(vector<int>& diff, vector<int>& profit, vector<int>& worker) {
-        int n = worker.size();
-        int m = profit.size();
-        int ans = 0;
+    int sets(vector<int> &day, int k, int mid) {
+        int curr = 0, n = day.size(), cnt = 0;
         for (int i = 0; i < n; i++) {
-            int curr = 0;
-            for (int j = 0; j < m; j++) {
-                if (worker[i] >= diff[j]) curr = max(curr, profit[j]);
+            if (day[i] <= mid) curr++;
+            else {cnt += curr / k; curr = 0;}
+        }
+        cnt += curr / k;
+        return cnt;
+    }
+
+public:
+    int minDays(vector<int>& day, int m, int k) {
+        int n = day.size();
+        if (n < 1LL * m * k) return -1;
+
+        int low = *min_element(day.begin(), day.end());
+        int high = *max_element(day.begin(), day.end());
+        int res = INT_MAX;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+            int curr = sets(day, k, mid);
+
+            if (curr >= m) {
+                res = min(res, mid);
+                high = mid - 1;
+            } else {
+                low = mid + 1;
             }
-            ans += curr;
         }
-        return ans;
+        return res;
     }
 };
 ```
-
 ### Explanation of Code
 
-#### Initialization:
-
-- Calculate the number of workers `n` and the number of tasks `m`.
-- Initialize `ans` to store the total profit.
-
-#### Iteration:
+**Helper Function `sets`**:
 
-1. Loop through each worker.
-   - For each worker, initialize `curr` to 0.
-   - Loop through each task to check if the worker can perform the task (i.e., their ability is greater than or equal to the difficulty of the task).
-     - If the worker can perform the task, update `curr` to be the maximum of `curr` and the profit of the task.
-   - Add the maximum profit the worker can achieve (`curr`) to the total profit (`ans`).
+- It initializes `curr` to count consecutive blooming flowers and `cnt` to count bouquets.
+- Iterates through the `day` array and increments `curr` if the flower blooms by `mid`.
+- If a flower does not bloom by `mid`, it calculates the number of bouquets from `curr` and resets `curr`.
 
-#### Return Value:
+**Main Function `minDays`**:
 
-- After processing all workers, return the total profit (`ans`).
+- Checks if the total number of flowers is less than ( m times k ). If true, returns -1.
+- Initializes `low` to the smallest day and `high` to the largest day.
+- Uses binary search to find the minimum day where \( m \) bouquets can be made.
+- Updates the result and adjusts the search range based on the number of bouquets that can be made by the current `mid` day.
 
-#### Efficiency:
+**Efficiency**:
 
-- This approach has a time complexity of \( O(n \times m) \), which might not be optimal for large inputs but provides a clear and straightforward solution to the problem.
+- The binary search approach ensures a time complexity of O(N log (Max-Min)), making it efficient for large inputs.
 
-## Like and Upvote
+### Like and Upvote
 
 If you found this solution helpful, please consider liking 👍 and upvoting ⬆️. Your support helps in continuing to provide high-quality solutions.