LeetCode刷題 -- 20200607 前綴和篇

　　最近刷題卻是沒停，可是感受大部分遇到的不是很適合拿來水博客，畢竟方法套路比較類似。年兄推薦下作了兩道前綴和的題，感受這類題型的思路很棒，也能夠概括成一個方法，故再來水一篇。題目均來自力扣Leetcode，傳送門。

　　簡單來講，前綴和適合於解決 連續，求和 相關的問題。遇到的問題若是包含相關要求，能夠考慮嘗試一下前綴和的解法。諸如子數組的哈，連續幾個數字的和，等等。

 

974. 和可被 K 整除的子數組

示例：

輸入：A = [4,5,0,-2,-3,1], K = 5
輸出：7
解釋：
有 7 個子數組知足其元素之和可被 K = 5 整除：
[4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]
 

提示：

1 <= A.length <= 30000
-10000 <= A[i] <= 10000
2 <= K <= 10000

 

　　如題目描述，根據給定的數組咱們須要尋找到它的子數組知足條件 ==》子數組全部數字的和能夠被K整除。注意這裏有個隱含條件，子數組的每一項的索引是連續的。

　　假設一組數組每一項的值都和它的下標相同:

• • Sumx = 1 + 2 + 3 + ... + x
  • Sumy = 1 + 2 + 3 + ... + y

　　 這裏不妨假設y>x, 那麼 Sumy - Sumx = (x+1) + (x+2) + ... y 。這裏Sumy - Sumx 就是數組從x到y的和，咱們要尋找的就是 (Sumy - Sumx ) % K = 0的子數組。所以能夠轉化爲Sumy % K == Sumx % K的前綴和表達。而前綴和其實咱們是能夠經過一次遍歷就得到的，只須要一個變量輔助記錄上一個位置的前綴和便可。

　　如今咱們的題目轉化爲了求得Sumy % K == Sumx % K的子數組的個數，而且也知道了怎麼計算前綴和。如今只須要使用Hash表來記錄前綴和出現的次數便可。當hash表中出現了Key相同的元素，說明咱們遇到了前綴和相同，即符合條件的子數組。注意這裏同時也要更新一下Hash表中的數據。

　　注意對於這道題來講，負數須要特別處理一下。來看看代碼吧：

 1 public class Solution {
 2         public int SubarraysDivByK(int[] A, int K)
 3         {
 4             int result = 0;
 5             List<int> preSum = new List<int>();
 6             preSum.Add(0);
 7 
 8             Dictionary<int, int> dict = new Dictionary<int, int>();
 9             dict.Add(0, 1);
10 
11             for (int i = 0; i < A.Length; i++)
12             {
13                 preSum.Add(preSum[i] + A[i]);
14                 int temp = preSum[i + 1] % K;
15                 temp = temp < 0 ? temp + K : temp;
16 
17                 if (dict.Keys.Contains(temp))
18                 {
19                     result += dict[temp];
20                     dict[temp] = dict[temp] + 1;
21                 }
22                 else
23                 {
24                     dict.Add(temp, 1);
25                 }
26                 
27             }
28 
29             return result;
30         }
31 }

　　第15行，處理一下負數的狀況，將其轉爲對應的%操做取得的正整數。

 

560. 和爲K的子數組

給定一個整數數組和一個整數 k，你須要找到該數組中和爲 k 的連續的子數組的個數。

示例 1 :

輸入:nums = [1,1,1], k = 2
輸出: 2 , [1,1] 與 [1,1] 爲兩種不一樣的狀況。
說明 :

數組的長度爲 [1, 20,000]。
數組中元素的範圍是 [-1000, 1000] ，且整數 k 的範圍是 [-1e7, 1e7]。

 

　　這道題目的思路也是同樣，但我仍是把它記錄了下來，由於以爲對比本身的思路和官方思路的過程頗有意思。 解法和前面相似，咱們也須要利用前綴和來求解。只不過這類是Sumy - Sumx = K。先來看看筆者沒有經過的的提交吧:

 1 public class Solution {
 2         public int SubarraySum(int[] nums, int k)
 3         {
 4             Dictionary<int, int> dict = new Dictionary<int, int>();
 5 
 6             int sum = 0;
 7 
 8             for (int i = 0; i < nums.Length; i++)
 9             {
10                 sum += nums[i];
11                 int count = 0;
12                 dict.TryGetValue(sum, out count);
13                 dict[sum] = ++count;
14             }
15 
16             int result = 0;
17 
18             foreach (var item in dict)
19             {
20                 if (item.Key == k)
21                 {
22                     result += item.Value;
23                 }
24 
25                 int temp = item.Key + k;
26 
27                 if (dict.Keys.Contains(temp))
28                 {
29                     if (temp != item.Key)
30                     {
31                         result += item.Value * dict[temp];
32                     }
33                     else
34                     {
35                         result += (dict[temp] - 1) * (dict[temp] - 1);
36                     }
37                     
38                 }
39                 
40             }
41 
42             return result;
43         }
44 }

　　上面的代碼其實已經經過了大多數的測試用例，但在第56個用例失敗了。

　　case 56很簡單，輸入是[-1,-1,1] ，1。若是按照個人思路，那麼儲存前綴和的Dict中的結果應該是（-1，2），（-2，1）。即前綴和是-1的狀況出現了兩次，前綴和是-2的狀況出現了一次。此時咱們要求的結果K=1, 所以對於前綴和是-2的這種狀況，若是咱們能夠找到前綴和是-1的前綴是否是就知足了呢？我一開始是這麼想的，然鵝被現實打臉 (￣ε(#￣) 了。其實題目中知足要求的只有[1] 這種狀況。

　　再仔細思考，其實我遇到的問題是既須要利用Hash來實現O(1)的訪問，又須要知道順序，來過濾到不可能的狀況。

　　再來看看官方的解法吧：

 1 public class Solution {
 2         public int SubarraySum(int[] nums, int k)
 3         {
 4             Dictionary<int, int> dict = new Dictionary<int, int>();
 5 
 6             int sum = 0;
 7             int result = 0;
 8 
 9             for (int i = 0; i < nums.Length; i++)
10             {
11                 sum += nums[i];
12 
13                 int cha = sum - k;
14 
15                 if (cha == 0)
16                     result++;
17 
18                 if (dict.Keys.Contains(cha))
19                     result += dict[cha];
20 
21                 int count = 0;
22                 dict.TryGetValue(sum, out count);
23                 dict[sum] = ++count;
24             }
25 
26             return result;
27         }
28 }

　　仍是想法不夠成熟，人家直接放到一次循環裏搞定了，邊生成Hash集合，邊處理數據，同時也避免了上面提到的那種狀況。試着解釋一下上面那種狀況：實際上是用已生成的前綴和去減去未生成的前綴和，真實狀況下這是不合邏輯的，可是因爲先獨立的計算了一遍前綴和掩蓋了這個問題。

　　

　　PS: 即便我一開始的思路沒錯，時間複雜度也是O(2n), 雖然最終能夠計算爲O(n)。而官方的直接就是O(n)，當數據量不大時，因爲常數被官方完爆。ORZ