Arrays 计算不同子阵列的数目

我最近在一次编码采访中遇到了这个问题。问题如下:

给定一个由n个数字和k个数字组成的数组A[]，计算不同子数组的总数，使每个子数组最多包含k个奇数元素

1 <= n <= 1000
1 <= A[i] <= 250
1 <= k <= n

我的解决方案在O（nk）时间和空间中工作

我该如何处理清晰性？有解决这个问题的数学公式吗？

编辑：

例1：

例2：

例3：

---

我们可以迭代所有子数组并存储有效子数组的散列。时间复杂度为

O（（n^2）*log（n））

和内存复杂度

O（n^2）

int distinctsubraryswithatmostkodelements（向量a，int k）
{
设置散列；
int素数=163；
对于（int i=0；iif（oddNow）每个子数组是否需要连续？例如，对于数组
[1,2,3,4]
，子数组
[1,3,4]
无效？@Gilles PhilippePaillé：yaa子数组必须是连续的。子数组的定义就是必须是连续的。另一方面，子序列不必是连续的。如果
distinct
意味着子数组的不同内容从不同的索引开始-这个问题对于访谈来说似乎有些过头了。但也许is只是表示“不同的开始/结束”索引？@MBo:
distinct
表示子数组的不同内容。我已经添加了示例。请看。如果没有不同的子数组，问题可以在O（n）时间内解决。
public int distinctSubArraysWithAtmostKOddElements(int[] a, int k) {
        int l = a.length;
        int[][] dp = new int[k + 1][l];

        for (int j = 0; j < l; j++) {
            dp[0][j] = a[j] % 2 == 0 ? 1 : 0;
        }

        for (int i = 1; i <= k; i++) {
            dp[i][0] = 1;
        }

        for (int j = 1; j <= k; j++) {
            for (int i = 1; i < l; i++) {
                if (a[i] % 2 == 0) {
                    dp[j][i] = Math.max(dp[j - 1][i], 1 + Math.max(dp[j - 1][i - 1], dp[j][i - 1]));
                } else {
                    dp[j][i] = Math.max(dp[j - 1][i], 1 + dp[j - 1][i - 1]);
                }
            }
        }

        int tot = 0;
        for (int i = 0; i < l; i++) {
            tot += dp[k][i];
        }

        return tot;
    }

A[] = {2,1,2,3} and k = 1
Distinct Subarrays are: {2}, {2,1}, {1}, {1,2}, {2,1,2}, {3}, {2,3}
So answer is 7.

A[] = {1,1,1} and k = 2
Distinct Subarrays are: {1}, {1,1}
So answer is 2.

A[] = {1,2,3} and k = 1
Distinct Subarrays are: {1}, {2}, {3}, {1,2}, {2,3}
So answer is 5.