问题描述 给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。 你能求出数列中总共有多少个K倍区间吗？ 输入格式 第一行包含两个整数N和K。(1 <= N, K <= 100000) 以下N行每行包含一个整数Ai。(1 <= Ai <= 100000) 输出格式 输出一个整数，代表K倍区间的数目。 样例输入 5 2 1 2 3 4 5 样例输出 6用简单C语言

以下是用C语言实现的代码：

#include <stdio.h>
#include <string.h>

#define N 100010

int n, k;
int a[N], pre[N];
int cnt[N];

int main() {
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        pre[i] = pre[i-1] + a[i];
        pre[i] %= k;
    }

    long long ans = 0;
    cnt[0] = 1;
    for (int i = 1; i <= n; i++) {
        ans += cnt[pre[i]];
        cnt[pre[i]]++;
    }

    printf("%lld\n", ans);
    return 0;
}

其中，数组`pre`存储前缀和，数组`cnt`记录每个余数出现的次数，`ans`表示答案。

相关问题

给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。 你能求出数列中总共有多少个K倍区间吗？ 输入格式 第一行包含两个整数N和K。(1 <= N, K <= 100000) 以下N行每行包含一个整数Ai。(1 <= Ai <= 100000) 输出格式 输出一个整数，代表K倍区间的数目。

以下是C语言实现的代码：

#include <stdio.h>
#include <stdlib.h>

#define MAXN 100000

int N, K;
int A[MAXN + 1];
int S[MAXN + 1];
long long cnt[MAXN + 1];

struct node {
    int key;
    int value;
    struct node *next;
};

struct hashtable {
    int size;
    struct node **table;
};

struct node *node_new(int key, int value) {
    struct node *p = (struct node *)malloc(sizeof(struct node));
    p->key = key;
    p->value = value;
    p->next = NULL;
    return p;
}

struct hashtable *hash_new(int size) {
    struct hashtable *h = (struct hashtable *)malloc(sizeof(struct hashtable));
    h->size = size;
    h->table = (struct node **)calloc(size, sizeof(struct node *));
    return h;
}

void hash_put(struct hashtable *h, int key, int value) {
    int index = (key % h->size + h->size) % h->size;
    struct node *p = h->table[index];
    while (p != NULL) {
        if (p->key == key) {
            p->value += value;
            return;
        }
        p = p->next;
    }
    struct node *new_node = node_new(key, value);
    new_node->next = h->table[index];
    h->table[index] = new_node;
}

int hash_get(struct hashtable *h, int key) {
    int index = (key % h->size + h->size) % h->size;
    struct node *p = h->table[index];
    while (p != NULL) {
        if (p->key == key) {
            return p->value;
        }
        p = p->next;
    }
    return 0;
}

int main() {
    scanf("%d%d", &N, &K);
    for (int i = 1; i <= N; i++) {
        scanf("%d", &A[i]);
        S[i] = (S[i - 1] + A[i]) % K;
    }

    struct hashtable *h = hash_new(K);
    for (int i = 0; i < K; i++) {
        cnt[i] = 0;
    }
    cnt[0] = 1;
    for (int i = 1; i <= N; i++) {
        cnt[S[i]] += hash_get(h, S[i]);
        hash_put(h, S[i], 1);
    }

    long long ans = 0;
    for (int i = 0; i < K; i++) {
        ans += cnt[i] * (cnt[i] - 1) / 2;
    }

    printf("%lld\n", ans);
    return 0;
}

其中，node是哈希表中存储的节点，包含键值对和指向下一个节点的指针。hashtable是哈希表结构体，包含哈希表的大小和指向桶数组的指针。hash_new函数用于创建一个新的哈希表，hash_put函数用于在哈希表中插入一个键值对，hash_get函数用于获取指定键的值。在主函数中，我们先读入数列，并计算前缀和数组S。然后，我们使用哈希表来记录余数出现的次数，并根据公式计算答案。最后，输出答案即可。

用C语言实现给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。 你能求出数列中总共有多少个K倍区间吗？ 输入格式 第一行包含两个整数N和K。(1 <= N, K <= 100000) 以下N行每行包含一个整数Ai。(1 <= Ai <= 100000) 输出格式 输出一个整数，代表K倍区间的数目。

这是一个经典的问题，可以使用前缀和和哈希表来解决。具体步骤如下：

1. 使用前缀和算法求出每个位置的前缀和，即sum[i]表示前i个数的和。

2. 对前缀和数组进行模K运算，得到余数数组mod[i]，即mod[i] = sum[i] % K。

3. 使用哈希表记录每个余数第一次出现的位置，即hash[mod[i]] = min(hash[mod[i]], i)。

4. 遍历余数数组mod，如果mod[i]为0，则区间[1, i]是K倍区间。否则，如果hash[mod[i]]存在，则区间[hash[mod[i]]+1, i]是K倍区间。

5. 统计所有的K倍区间即可。

C语言代码如下：

#include <stdio.h>
#include <string.h>

#define MAXN 100005
#define INF 0x3f3f3f3f

int n, k;
int a[MAXN], sum[MAXN], mod[MAXN], hash[MAXN];

int main() {
    scanf("%d%d", &n, &k);
    memset(hash, INF, sizeof(hash));
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        sum[i] = sum[i-1] + a[i];
        mod[i] = sum[i] % k;
    }
    hash[0] = 0;
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        if (mod[i] == 0) {
            ans += 1;
        } else {
            if (hash[mod[i]] < INF) {
                ans += hash[mod[i]]+1;
            }
        }
        hash[mod[i]] = fmin(hash[mod[i]], i);
    }
    printf("%d\n", ans);
    return 0;
}