Continuous Subarray Sum (LeetCode Algorithm Problem)

本题主要做的是判断一组序列里面是否有这样一组连续的子序列，他们的和正好能够整除k。

  我们逐步分析，一个直观的做法是暴力搜索每一个连续的字串，然后把他们相加，看看能否整除k。我们接上述Example1展开，然后我们发现：

  包含第一个元素的子序列有【23，2】，【23，2，4】，【23，2，4，6】，【23，2，4，6，7】

  包含第二个元素的子序列有【2，4】，【2，4，6】，【2，4，6，7】

  包含第三个元素的子序列有【4，6】，【4，6，7】

  包含第四个元素的子序列有【6，7】

  观察上述的子序列，我们发现，如果每一个子序列都求和的话，明显会有一些重复计算，打个比方，包含第四个元素的序列【6，7】计算完毕之后，我们计算上一层的【4，6，7】就没必要再次求6和7的加法和了，因为它在上一次已经被计算过。按照这个思路，我们还可以看到，从下往上，每一次层都是在原来的基础上加多一个数。我们在有【6，7】的基础上，加多一个【4】，结果就变成【4，6】，【4，6，7】。在往上走，加多一个【2】结果就变成【2，4】，【2，4，6】，【2，4，6，7】。上式可以递推成：

  

  包含第一个元素的子序列有 a1 =【23 + a2】

  包含第二个元素的子序列有 a2 =【2 + a3】

  包含第三个元素的子序列有 a3 =【4 + a4】

  包含第四个元素的子序列有 a4 =【6，7】

  a1~a4就是计算中的状态，所以这道题加入了动态规划的思想。

  附上源代码：

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        if (nums.size() == 0 || nums.size() == 1) {
			return false;
		}
		vector<int> status;
		status.resize(nums.size() - 1);
		int num_of_status = 0;
		status[0] = nums[nums.size() - 1] + nums[nums.size() - 2];
		num_of_status = 1;
		if (k == 0) {
			if (status[0] == 0) {
				return true;
			}
		}
		else {
			if (status[0] % k == 0) {
				return true;
			}
		}

		for (int i = nums.size() - 3; i >= 0; i--) {
			num_of_status ++;
			for (int j = num_of_status - 1; j > 0; j--) {
				status[j] = nums[i] + status[j - 1];
				if (k == 0) {
					if (status[j] == 0) {
						return true;
					}
				}
				else {
					if (status[j] % k == 0) {
						return true;
					}
				}
			}
			status[0] = nums[i] + nums[i + 1];
			if (k == 0) {
				if (status[0] == 0) {
					return true;
				}
			}
			else {
				if (status[0] % k == 0) {
					return true;
				}
			}
		}
		return false;
    }
};