31. Min. Number of Taps to Open to Water a Garden

Author: rishabhv12

08-August/31-Minimum Number of Taps to Open to Water a Garden.md

@@ -0,0 +1,66 @@
+## 31. Minimum Number of Taps to Open to Water a Garden
+
+
+The problem can be found at the following link: [Question Link](https://leetcode.com/problems/minimum-number-of-taps-to-open-to-water-a-garden/description/)
+
+
+### My Approach
+
+This is a question on greedy approch, as we have given how to find the range of the given taps . We can calculate the range of each tap and check if we can manage to find a tap which have largest current range. we can do it as :
+
+1. Initialize variables:
+   - `minRange` and `maxRange` to keep track of the minimum and maximum positions that can be covered by the currently selected taps (both initially set to 0).
+   - `taps` to keep track of the number of taps used (initialized to 0).
+   - `curindex` to keep track of the index of the last selected tap (initialized to 0).
+
+2. Create a while loop that continues until `maxRange` is greater than or equal to `n`. This loop is used to extend the covered range step by step.
+
+3. Inside the while loop, iterate through the taps (represented by the `ranges` vector) starting from the `curindex`. For each tap `i`:
+   - Check if the tap can cover the current position (`i - ranges[i]`) and if it can extend the range further (`i + ranges[i] > maxRange`).
+   - If both conditions are met, update `maxRange` to `i + ranges[i]` and update `curindex` to `i`. This tap is chosen as it extends the maximum coverage.
+
+4. After examining all taps within the current range, if `minRange` is equal to `maxRange`, it means that no tap can be selected to extend the coverage further. In this case, return -1 to indicate that it's impossible to cover the entire range.
+
+5. Increment `taps` to count the tap that has been used to extend the coverage.
+
+6. Update `minRange` to `maxRange` to indicate that the current range has been fully covered.
+
+7. Repeat steps 3-6 until `maxRange` is greater than or equal to `n`.
+
+
+### Time and Auxiliary Space Complexity
+
+- **Time Complexity**: `O(n)` 
+- **Auxiliary Space Complexity**: `O(1)` because we used an extra queue..
+
+
+### Code (C++)
+
+```cpp
+class Solution {
+public:
+    int minTaps(int n, vector<int>& ranges) {
+        int minRange =0, maxRange =0;
+        int taps =0; int curindex =0;
+
+        while(maxRange < n){
+            for(int i=curindex;i<ranges.size();i++){
+                if(i-ranges[i]<=minRange && i+ranges[i]>maxRange){
+                    maxRange = i+ranges[i];
+                    curindex = i;
+                }
+            }
+            if(minRange == maxRange) return -1;
+            taps++;
+            minRange = maxRange;
+        }
+        return taps;
+    }
+};
+```
+
+### Contribution and Support
+
+For discussions, questions, or doubts related to this solution, please visit our [discussion section](https://leetcode.com/discuss/general-discussion). We welcome your input and aim to foster a collaborative learning environment.
+
+If you find this solution helpful, consider supporting us by giving a `⭐ star` to the [rishabhv12/Daily-Leetcode-Solution](https://github.com/rishabhv12/Daily-Leetcode-Solution) repository.

README.md

@@ -1,25 +1,31 @@
-##  30. Minimum Replacements to Sort the Array
+## 31. Minimum Number of Taps to Open to Water a Garden
 
-The problem can be found at the following link: [Question Link](https://leetcode.com/problems/minimum-replacements-to-sort-the-array/description/)
+
+The problem can be found at the following link: [Question Link](https://leetcode.com/problems/minimum-number-of-taps-to-open-to-water-a-garden/description/)
 
 
 ### My Approach
 
-The intution to solve this question is we can make all the element in the vector eqaul and also try to keep the replacement number as small as possible , we can achive this as :
+This is a question on greedy approch, as we have given how to find the range of the given taps . We can calculate the range of each tap and check if we can manage to find a tap which have largest current range. we can do it as :
 
 1. Initialize variables:
-   - `curmax` to keep track of the current maximum value (initialized to `INT_MAX`).
-   - `ans` to keep track of the minimum number of replacements (initialized to 0).
+   - `minRange` and `maxRange` to keep track of the minimum and maximum positions that can be covered by the currently selected taps (both initially set to 0).
+   - `taps` to keep track of the number of taps used (initialized to 0).
+   - `curindex` to keep track of the index of the last selected tap (initialized to 0).
+
+2. Create a while loop that continues until `maxRange` is greater than or equal to `n`. This loop is used to extend the covered range step by step.
 
-2. Start a loop from the last element (`i` initialized to `n-1`) and move backwards towards the first element.
+3. Inside the while loop, iterate through the taps (represented by the `ranges` vector) starting from the `curindex`. For each tap `i`:
+   - Check if the tap can cover the current position (`i - ranges[i]`) and if it can extend the range further (`i + ranges[i] > maxRange`).
+   - If both conditions are met, update `maxRange` to `i + ranges[i]` and update `curindex` to `i`. This tap is chosen as it extends the maximum coverage.
 
-3. Inside the loop, check if `nums[i]` is less than or equal to `curmax`. If it is, update `curmax` to `nums[i]`. This step ensures that `curmax` always represents the maximum value encountered so far.
+4. After examining all taps within the current range, if `minRange` is equal to `maxRange`, it means that no tap can be selected to extend the coverage further. In this case, return -1 to indicate that it's impossible to cover the entire range.
 
-4. If `nums[i]` is greater than `curmax`, it means a replacement is needed to make them equal. Calculate the number of replacements required as follows:
-   - If `nums[i]` is divisible by `curmax`, subtract 1 from the result and add it to `ans`.
-   - Otherwise, divide `nums[i]` by `curmax` to get `div`, then add `div` to `ans`. Update `curmax` by dividing `nums[i]` by `div`, which ensures that `curmax` represents the maximum value encountered after the replacement.
+5. Increment `taps` to count the tap that has been used to extend the coverage.
 
-5. Repeat steps 3-4 for all elements in the vector from right to left.
+6. Update `minRange` to `maxRange` to indicate that the current range has been fully covered.
+
+7. Repeat steps 3-6 until `maxRange` is greater than or equal to `n`.
 
 
 ### Time and Auxiliary Space Complexity
@@ -33,26 +39,22 @@ The intution to solve this question is we can make all the element in the vector
 ```cpp
 class Solution {
 public:
-    long long minimumReplacement(vector<int>& nums) {
-        int n=nums.size();
-        int curmax=INT_MAX;
-        long long ans=0;
-
-        for(int i=n-1; i>=0; i--){
-            if(nums[i]<=curmax){
-                curmax=nums[i];
-            }
-            else{
-                if(nums[i]%curmax==0){
-                    ans+=((nums[i]/curmax)-1);
-                }else{
-                    ans+=((nums[i]/curmax));
-                    int div=(nums[i]/curmax)+1;
-                    curmax=nums[i]/div;
+    int minTaps(int n, vector<int>& ranges) {
+        int minRange =0, maxRange =0;
+        int taps =0; int curindex =0;
+
+        while(maxRange < n){
+            for(int i=curindex;i<ranges.size();i++){
+                if(i-ranges[i]<=minRange && i+ranges[i]>maxRange){
+                    maxRange = i+ranges[i];
+                    curindex = i;
                 }
             }
+            if(minRange == maxRange) return -1;
+            taps++;
+            minRange = maxRange;
         }
-        return ans;
+        return taps;
     }
 };
 ```