检查给定数组是否可以通过给定次数执行给定操作而减少为零

这个题目要求我们查询一个数组能否通过限制次数的操作将其元素都变为0。在这篇文章中，我们将讨论这个问题，包括算法和实现。

算法

思路

我们可以使用深度优先搜索（DFS）来解决这个问题。具体地，我们定义递归函数 dfs(v, k) 表示当前在访问第 v 个元素，剩余操作次数为 k 时能否将数组修改为全 0。在 dfs(v, k) 中，我们考虑遍历当前节点 v 所能够到达的下一个节点 u。如果此时 k > 0 且修改 nums[u] 前后数组元素之和不变化，我们就递归到 dfs(u, k - 1) 中，此时如果搜索到起点并且恰好用完 k 次操作我们就说明可以将数组修改为全 0。

伪代码

dfs(v, k):
    if k == 0:
        # 操作次数用尽
        return sum(nums) == 0
    if v == 0:
        # 已经回到起点并且还有剩余操作次数
        return False
    for u in next_node_on_graph(v):
        if nums[u] <= nums[v]:
            # 修改 nums[u] 不会使得数组元素之和增加
            nums[u] -= nums[v]
            if dfs(u, k - 1):
                return True
            nums[u] += nums[v]
    return False

实现

Python 实现

from typing import List

class Solution:
    def canBeEqualAfterOperations(self, nums: List[int], target: int, k: int) -> bool:
        def dfs(v: int, k: int) -> bool:
            if k == 0:
                # 操作次数用尽
                return sum(nums) == 0
            if v == 0:
                # 已经回到起点并且还有剩余操作次数
                return False
            for u in next_node_on_graph(v):
                if nums[u] <= nums[v]:
                    # 修改 nums[u] 不会使得数组元素之和增加
                    nums[u] -= nums[v]
                    if dfs(u, k - 1):
                        return True
                    nums[u] += nums[v]
            return False
        
        # 构造邻接表
        n = len(nums)
        graph = [[] for i in range(n)]
        for i in range(n):
            for j in range(i+1, n):
                if nums[i] + nums[j] == target:
                    graph[i].append(j)
                    graph[j].append(i)
        
        # 从 n-1 开始搜索
        nums.append(target)
        return dfs(n, k)

C++ 实现

#include <vector>

using namespace std;

class Solution {
public:
    bool canBeEqualAfterOperations(vector<int>& nums, int target, int k) {
        int n = nums.size();
        vector<vector<int>> graph(n);
        for (int i = 0; i < n; ++i) {
            for (int j = i+1; j < n; ++j) {
                if (nums[i] + nums[j] == target) {
                    graph[i].push_back(j);
                    graph[j].push_back(i);
                }
            }
        }
        vector<int> visited(n, false);
        visited[n-1] = true;
        return dfs(graph, nums, visited, n-1, k);
    }
    
    bool dfs(vector<vector<int>>& graph, vector<int>& nums, vector<int>& visited, int v, int k) {
        if (k == 0) {
            return accumulate(nums.begin(), nums.end(), 0) == 0;
        }
        if (v == n-1) {
            return false;
        }
        for (int u : graph[v]) {
            if (nums[u] <= nums[v]) {
                nums[u] -= nums[v];
                if (!visited[u] && dfs(graph, nums, visited, u, k-1)) {
                    return true;
                }
                nums[u] += nums[v];
            }
        }
        return false;
    }
};

总结

深度优先搜索是解决本题的一种常见方法，时间复杂度为 $O(nk)$，其中 $n$ 是数组的长度，$k$ 是操作次数。如果我们能够找到更好的算法解决本题我们也可以将其应用在其他具有类似性质的问题中，例如某些简单图的搜索问题。