Question

DP问题如下：给定一个非负数列表和一个目标整数k，编写一个函数以检查该数组是否具有大小至少为2的连续子数组，其总和为k的倍数，也就是说，总和为n * k，其中n也是一个整数。

示例1：

输入：[23、2、4、6、7]，k = 6 输出：真说明：因为[2，4]是大小为2的连续子数组，总和为6。

示例2：

输入：[23、2、6、4、7]，k = 6 输出：真说明：因为[23、2、6、4、7]是大小为5的连续子数组，总和为42。

我已经花了很多时间来了解以下解决此问题的方法：

typedef struct e_s {
    int mod;
    int idx;
    struct e_s *shadow;
} e_t;
#define SZ 1024
e_t *lookup(e_t **set, int mod) {
    e_t *e = set[mod % SZ];
    while (e && e->mod != mod) {
        e = e->shadow;
    }
    return e;
}
void put(e_t **set, e_t *e, int mod, int idx) {
    e->mod = mod;
    e->idx = idx;
    e->shadow = set[mod % SZ];
    set[mod % SZ] = e;
}
bool checkSubarraySum(int* nums, int numsSize, int k) {
    int i, s, found = 0;

    e_t buff[10000];
    int n;

    e_t *set[SZ] = { 0 }, *e;

    put(set, &buff[n ++], 0, -1);

    s = 0;
    for (i = 0; i < numsSize; i ++) {
        s += nums[i];
        if (k) s = s % k;
        e = lookup(set, s);
        if (e) {
            if (i - e->idx >= 2) {
                found = 1;
                break;
            }
        } else {
            put(set, &buff[n ++], s, i);
        }
    }

    return found;
}

我什至在这里追踪了一个花了很长时间的示例，但是我想不出为什么mod值在这个问题中很重要，甚至我追踪正确也是如此。

Example:
Input = 23, 2, 6, 4, 7
k = 6

buff = [e_t, e_t, ...] (size = 10000)
SZ = 1024
set = [NULL, NULL, ...] (size = 1024)

put(set, &buff[0], 0, -1);
Now n = 1

buff = [(0, -1, NULL), e_t, e_t...]
set = [(0, -1, NULL), NULL, NULL...]

i = 0
s = 0
s = 23
s = 5
e = NULL
put(set, &buff[1], 5, 0);
Now n = 2

buff = [(0, -1, NULL), (5, 0, NULL), e_t...]
set = [(0, -1, NULL), NULL, NULL, NULL, NULL, (5, 0, NULL), ...]

i = 1
s = 7
s = 1
e = NULL
put(set, &buff[2], 1, 1);
Now n = 3

buff = [(0, -1, NULL), (5, 0, NULL), (1, 1, NULL), e_t...]
set = [(0, -1, NULL), (1, 1, NULL), NULL, NULL, NULL, (5, 0, NULL), ...]

i = 2
s = 7
s = 1
e = (1, 1, NULL)

i = 3
s = 5
e = (5, 0, NULL)

Since i = 3, and e->idx = 0, (i - e->idx >= 2) evaluates to True. The function returns true. Why though...?

最终，我的问题归结为这里使用的是哪种算法？链接列表怎么了？我能正确追踪到这个吗？

Answer 1

该算法从索引0开始遍历整个数组。它保持到目前为止所看到的数组元素的求和模k。此总和为s。为当前元素更新s后，将在哈希表中查找值s，以获取总和A[0]+...+A[i] % k等于{{1 }}。如果找到此索引并且到当前位置的距离大于或等于2，则算法返回。如果没有索引，则当前索引存储在哈希表中，值为s。这个想法是，如果s，那么(A[0]+...+A[i] % k) = (A[0]+...+A[i]+...+A[j] %k)。

代码中有两种模，一种是A[i+1]+...+A[j] % k = 0的模，并且是基于k的倍数等于k的事实得出的。第二个模是0 % k的模，用于寻址hash-table（此处称为SZ）。此哈希表使用链接列表（使用set字段）来解决冲突。

哈希表节点的内存在shadow数组中静态分配。

作者buff的值是任意选择的，以确保平均冲突率。

鉴于SZ的最大值，我们可以完全摆脱哈希表和节点，而只需使用大小为10000的数组存储每个k的索引。

mod在这个DP问题中神秘地有用吗？底层的算法是什么？

1 个答案: