📃 docs: backup

Author: 李钊

1414.cpp

@@ -0,0 +1,22 @@
+#include <climits>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution
+{
+public:
+    int minStartValue(vector<int> &nums) {
+        int n = nums.size();
+        int mn = INT_MAX;
+        int sum = 0;
+        for (int i = 0; i < n; ++i) {
+            sum += nums[i];
+            mn = min(sum, mn);
+        }
+        return 1 - mn < 1 ? 1 : 1 - mn;
+    }
+};

1788.cpp

@@ -0,0 +1,68 @@
+#include <vector>
+#include <algorithm>
+#include <climits>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution
+{
+public:
+    struct range
+    {
+        int value;
+        int start;
+        mutable int end;
+        mutable int sum;
+        bool operator<(const range &b) {
+            return this->sum > b.sum;
+        }
+
+        bool operator==(int b) {
+            return this->value == b;
+        }
+    };
+
+    int maximumBeauty(vector<int> &flowers) {
+        int n = flowers.size();
+        vector<range> ranges;
+        vector<int> sum(n + 1, 0);
+
+        for (int i = 0; i < n; ++i) {
+            int beauty = flowers[i];
+            sum[i + 1] = sum[i] + beauty;
+            auto r = find(ranges.begin(), ranges.end(), beauty);
+            if (r == ranges.end()) {
+                ranges.push_back({beauty, i, -1});
+            } else {
+                r->end = i;
+                r->sum = sum[i + 1] - sum[r->start];
+            }
+        }
+
+        sort(ranges.begin(), ranges.end());
+
+        int mx = INT_MIN;
+        for (auto r : ranges) {
+            if (r.end == -1)
+                continue;
+            int local = r.sum;
+            for (auto i = r.start + 1; i <= r.end - 1; ++i) {
+                if (flowers[i] < 0) {
+                    local = local - flowers[i];
+                }
+            }
+            mx = max(local, mx);
+        }
+
+        return mx;
+    }
+};
+
+int main(int argc, char const *argv[]) {
+    Solution s;
+    vector<int> flowers = {-1, -2, 0, -1};
+    cout << s.maximumBeauty(flowers) << endl;
+    return 0;
+}

1991.cpp

@@ -0,0 +1,25 @@
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution
+{
+public:
+    int findMiddleIndex(vector<int> &nums) {
+        int n = nums.size();
+        vector<int> sum(n + 1, 0);
+        for (int i = 0; i < n; ++i) {
+            sum[i + 1] = sum[i] + nums[i];
+        }
+
+        for (int i = 0; i < n; ++i) {
+            if (sum[i] == sum[n] - sum[i + 1])
+                return i;
+        }
+
+        return -1;
+    }
+};

2083.cpp

@@ -0,0 +1,23 @@
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution
+{
+public:
+    long long numberOfSubstrings(string s) {
+        int n = s.size();
+        long long ret = 0;
+        long long hash[26] = {0};
+
+        for (int i = 0; i < n; ++i) {
+            ret += hash[s[i] - 'a'];
+            hash[s[i] - 'a']++;
+        }
+
+        return ret + n;
+    }
+};

README.md

@@ -60,3 +60,40 @@ Simple prefix XOR;
 - 2D prefix sum & subarray sum to target problem
 - Time complexity $O(M^2N)$
 
+## 1788. Maximize the Beauty of the Garden
+
+- Negative flowers affect the total beauty
+- Iterate over valid pairs
+
+## 2083. Substrings That Begin and End With the Same Letter
+
+
+### Intuition
+
+- Similar to [560. Subarray Sum Equals K](https://leetcode.com/problems/subarray-sum-equals-k/)
+
+
+### Complexity
+
+- Time complexity: $O(n)$
+- Space complexity: $O(1)$
+
+### Code
+
+```c++
+class Solution {
+public:
+    long long numberOfSubstrings(string s) {
+        int n = s.size();
+        long long ret = 0;
+        long long hash[26] = {0};
+        
+        for(int i = 0;i < n;++i){
+            ret += hash[s[i] - 'a'];
+            hash[s[i] - 'a']++;
+        }
+
+        return ret + n;
+    }
+};
+```