[数组][简单]985.查询后的偶数和

---

tags:

• 简单
• 完成超时
• 数组
  flag: green
  style: summer
  data: ‘2019-6-14’

---

985.查询后的偶数和

一、题目

给出一个整数数组 A 和一个查询数组 queries。

对于第 i 次查询，有 val = queries[i][0], index = queries[i][1]，我们会把 val 加到 A[index] 上。然后，第 i 次查询的答案是 A 中偶数值的和。

（此处给定的 index = queries[i][1] 是从 0 开始的索引，每次查询都会永久修改数组 A。）

返回所有查询的答案。你的答案应当以数组 answer 给出，answer[i] 为第 i 次查询的答案。

• 示例：
  输入：A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]
  输出：[8,6,2,4]
• 解释：
  开始时，数组为 [1,2,3,4]。
  将 1 加到 A[0] 上之后，数组为 [2,2,3,4]，偶数值之和为 2 + 2 + 4 = 8。
  将 -3 加到 A[1] 上之后，数组为 [2,-1,3,4]，偶数值之和为 2 + 4 = 6。
  将 -4 加到 A[0] 上之后，数组为 [-2,-1,3,4]，偶数值之和为 -2 + 4 = 2。
  将 2 加到 A[3] 上之后，数组为 [-2,-1,3,6]，偶数值之和为 -2 + 6 = 4。

提示：

1 <= A.length <= 10000
-10000 <= A[i] <= 10000
1 <= queries.length <= 10000
-10000 <= queries[i][0] <= 10000
0 <= queries[i][1] < A.length

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sum-of-even-numbers-after-queries
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解答

• 方法：调整数组和

思路与算法

让我们尝试不断调整数组和S，即每一步操作之后整个数组的偶数和。

我们操作数组中的某一个元素 A[index] 的时候，数组 A 其他位置的元素都应保持不变。如果 A[index] 是偶数，我们就从 S 中减去它，然后计算 A[index] + val 对 S 的影响（如果是偶数则在 S 中加上它）。

这里有一些例子：

如果当前情况为 A = [2,2,2,2,2]、S = 10，并且需要执行 A[0] += 4 操作：我们应该先令 S -= 2，然后令 S += 6。最后得到 A = [6,2,2,2,2] 与 S = 14。

如果当前情况为 A = [1,2,2,2,2]、S = 8，同时需要执行 A[0] += 3 操作：我们会跳过第一次更新 S 的步骤（因为 A[0] 是奇数），然后令 S += 4。 最后得到 A = [4,2,2,2,2] 与 S = 12。

如果当前情况为 A = [2,2,2,2,2]、S = 10，同时需要执行 A[0] += 1 操作：我们先令 S -= 2，然后跳过第二次更新 S 的操作（因为 A[0] + 1 是奇数）。最后得到 A = [3,2,2,2,2] 与 S = 8。

如果当前情况为 A = [1,2,2,2,2]、S = 8，同时需要执行 A[0] += 2 操作：我们跳过第一次更新 S 的操作（因为 A[0] 是奇数），然后再跳过第二次更新 S 的操作（因为 A[0] + 2 是奇数）。最后得到 A = [3,2,2,2,2] 与 S = 8。

这些例子充分展现了我们的算法在每一次询问操作之后应该如何调整 S 。

class Solution {
    public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
        int S = 0;
        for (int x: A)
            if (x % 2 == 0)
                S += x;

        int[] ans = new int[queries.length];

        for (int i = 0; i < queries.length; ++i) {
            int val = queries[i][0], index = queries[i][1];
            if (A[index] % 2 == 0) S -= A[index];
            A[index] += val;
            if (A[index] % 2 == 0) S += A[index];
            ans[i] = S;
        }

        return ans;
    }
}

• 复杂度分析

  • 时间复杂度：O(N+Q)，其中 N 是数组 A 的长度， Q 是询问 queries 的数量。
  • 空间复杂度：O(N+Q)，事实上我们只使用了 O(1) 的额外空间。

作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/cha-xun-hou-de-ou-shu-he-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

• 思路同上，但是优化了

执行
执行用时 : 5 ms, 在Sum of Even Numbers After Queries的Java提交中击败了99.90% 的用户
内存消耗 : 57.7 MB, 在Sum of Even Numbers After Queries的Java提交中击败了92.42% 的用户
思路
思路和官方题解的一致，不过优化了if语句的执行时间。 之前本来是用的%2的操作来判断是否为偶数，但是遇到个问题就是数字为负数，%2操作之后为-1，进行乘法运算答案是错误的。碰巧在评论去看到有人判断偶数用的是&1操作，恍然大悟，所以就改成了&1。

实现

class Solution {
	public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
		int sum = 0;
		int[] result = new int[queries.length];
		for (int i = 0; i < A.length; i++) {
			sum += (((A[i]+1) & 1) * A[i]);
		}
		for (int i = 0; i < queries.length; i++) {
			sum -= (((A[queries[i][1]]+1)&1) * A[queries[i][1]]);
                        A[queries[i][1]] = (A[queries[i][1]] + queries[i][0]);
			sum += (((A[queries[i][1]]+1)&1) * A[queries[i][1]]);
			result[i] = sum;
		}
		return result;
	}
}

作者：VioletKiss
链接：https://leetcode-cn.com/problems/two-sum/solution/java-ti-jie-985cha-xun-hou-de-ou-shu-he-by-1331635/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

• 自我解答：超时

class Solution {
    public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
        
         //求queries的长和宽
        int cows = queries.length;
        int colume = 2;

        //新建一个数组放置结果
        int[] ans = new int[cows];

        //合法性判断
        int ans1 = 0;
        if (queries == null ) {
            for (int i = 0;i < A.length ;i++ ) {
                if (A[i] % 2 == 0) {
                    ans[0] += A[i];
                }
            }
        }



        //对queries进行遍历
        for (int i = 0 ;i < cows;i++ ) {
            A[queries[i][1]] += queries[i][0];
            for (int j = 0;j < cows ;j++ ) {
                  if (A[j] % 2 == 0) {
                      ans1 += A[j];
                  }
              } 
              ans[i] = ans1; 
              ans1 = 0;
        }

         return ans;
    }
}