✨ feat: backup answer

Author: 李钊

1074.cpp

@@ -0,0 +1,35 @@
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution
+{
+public:
+    int numSubmatrixSumTarget(vector<vector<int>> &matrix, int target) {
+        int m = matrix.size(), n = matrix[0].size(), ret = 0;
+        vector<vector<int>> sum(m + 1, vector<int>(n + 1, 0));
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                sum[i + 1][j + 1] = matrix[i][j] + sum[i + 1][j] + sum[i][j + 1] - sum[i][j];
+            }
+        }
+
+        unordered_map<int, int> hash;
+        for (int i = 0; i < m; ++i) {
+            for (int j = i + 1; j <= m; ++j) {
+                hash.clear();
+                hash.insert({0, 1});
+                for (int k = 0; k < n; ++k) {
+                    int s = sum[j][k + 1] - sum[i][k + 1];
+                    ret += hash.find(s - target) == hash.end() ? 0 : hash[s - target];
+                    hash[s]++;
+                }
+            }
+        }
+
+        return ret;
+    }
+};

1310.cpp

@@ -0,0 +1,23 @@
+#include <vector>
+#include <iostream>
+
+using namespace std;
+
+class Solution
+{
+public:
+    vector<int> xorQueries(vector<int> &arr, vector<vector<int>> &queries) {
+        int n = arr.size(), m = queries.size();
+        vector<int> x(n + 1, 0), ret;
+
+        for (int i = 0; i < n; ++i) {
+            x[i + 1] = x[i] ^ arr[i];
+        }
+
+        for (int i = 0; i < m; ++i) {
+            ret.push_back(x[queries[i][1] + 1] ^ x[queries[i][0]]);
+        }
+
+        return ret;
+    }
+};

370.cpp

@@ -0,0 +1,35 @@
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution
+{
+public:
+    vector<int> getModifiedArray(int n, vector<vector<int>> &range) {
+        vector<int> sum(n, 0);
+        vector<int> diff(n + 1, 0);
+
+        for (auto i : range) {
+            diff[i[0]] += i[2];
+            diff[i[1] + 1] -= i[2];
+        }
+
+        int acc = 0;
+        for (int i = 0; i < n; ++i) {
+            acc += diff[i];
+            sum[i] = acc;
+        }
+
+        return sum;
+    }
+};
+
+int main(int argc, char const *argv[]) {
+    Solution s;
+    vector<vector<int>> v = {{1, 3, 2}, {2, 4, 3}, {0, 2, -2}};
+    s.getModifiedArray(5, v);
+    return 0;
+}

560.cpp

@@ -0,0 +1,23 @@
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution
+{
+public:
+    int subarraySum(vector<int> &nums, int k) {
+        int n = nums.size(), sum = 0, ret = 0;
+        unordered_map<int, int> hash = {{0, 1}};
+
+        for (int i = 0; i < n; ++i) {
+            sum = sum + nums[i];
+            ret += hash.find(sum - k) == hash.end() ? 0 : hash[sum - k];
+            hash[sum]++;
+        }
+
+        return ret;
+    }
+};

README.md

@@ -12,6 +12,9 @@
 ## Prefix Sum
 
 
+## Subarray Target Sum
+
+See Problem 560, very useful.
 
 
 # C++ Weapons
@@ -26,3 +29,34 @@
 | Find string/characterin string      | std::string.find |       |
 |                                     |                  |       |
 
+# Problem
+
+## 370. Range Addition
+
+
+### Intuition
+
+- The value in the result only changes at range boundaries
+- The left boundary will contribute +inc
+- The right boundary will contribute -inc
+
+### Approach
+
+1. Scan the ranges and calculate the contribution
+2. Scan the array and calculate the running sum
+
+### Complexity
+
+- Time complexity: $O(M+N)$
+- Space complexity: $O(N)$
+
+
+## 1310. XOR Queries of a Subarray
+
+Simple prefix XOR;
+
+## 1074. Number of Submatrices That Sum to Target
+
+- 2D prefix sum & subarray sum to target problem
+- Time complexity $O(M^2N)$
+