Notes de brossage du problème Leikou: 992. K sous-tableaux de différents entiers (méthode de fenêtre glissante, code facile à comprendre, code de solution complet et commentaires) (solution violente, résultat du timeout python ...)

sujet:

992, K sous-tableaux d'entiers différents

Étant donné un tableau d'entiers positifs A, si le nombre d'entiers différents dans un sous-tableau de A se trouve être K, alors ce sous-tableau continu, pas nécessairement indépendant de A est appelé un bon sous-tableau.

(Par exemple, il y a 3 entiers différents dans [1,2,3,1,2]: 1, 2 et 3.)

Renvoie le nombre de bons sous-tableaux dans A.

Exemple 1:

Entrée: A = [1,2,1,2,3], K = 2
Sortie: 7
Explication: Un sous-tableau composé d'exactement 2 entiers différents: [1,2], [2,1], [1, 2], [2,3], [1,2,1], [2,1,2], [1,2,1,2].

Exemple 2:

Entrée: A = [1,2,1,3,4], K = 3
Sortie: 3
Explication: Un sous-tableau composé d'exactement 3 entiers différents: [1,2,1,3], [2,1, 3], [1,3,4].

rapide:

1 <= A.length <= 20000
1 <= A [i] <= A.length
1 <= K <= A.length

Idées de solutions aux problèmes:

On peut faire la conversion suivante: Le nombre de sous-tableaux avec au moins K entiers différents - le nombre de sous-tableaux avec au moins K + 1 entiers différents

Résolvez les sous-problèmes:

(1) Énumérer i, trouver le nombre de sous-tableaux commençant par i et au moins K entiers différents
(2) Si nous trouvons un j qualifié tel que [i, j] est un sous-tableau qui remplit les conditions, Alors [ i, j], [i, j + 1], [i, j + 2], ..., [i, n-1] sont tous des sous-tableaux qui remplissent les conditions.
(3) Après cela, nous réduisons la fenêtre jusqu'à ce que le tableau dans la fenêtre ne remplisse pas les conditions, puis ré-agrandissons la fenêtre et revenons à l'étape précédente.

Code python de la solution du problème:

class Solution:
    def subarraysWithKDistinct(self, A: List[int], K: int) -> int:
        def helper(A,K):
            n = len(A)
            i = 0
            res = 0
            ########################## 
            # 窗口内需要维护的变量
            diff_nums = 0
            counter = collections.defaultdict(int)
            ##########################
            for j in range(n):
                # 扩大窗口
                counter[A[j]] += 1
                if counter[A[j]] == 1:
                    diff_nums += 1

                # 如果找到以i开头满足条件的子数组了，就更新答案并缩小窗口
                while diff_nums > K:
                    res += n-j
                    counter[A[i]] -= 1
                    if counter[A[i]] == 0:
                        diff_nums -= 1
                    i += 1
            return res
        
        return -helper(A,K) + helper(A,K-1)

Auteur: MiloMusiala
lien: https://leetcode-cn.com/problems/subarrays-with-k-different-integers/solution/python-dong-hua-tong-xiang-shuang-zhi-zh-57ym/
Source: force LeetCode (LeetCode) https://leetcode-cn.com/problems/subarrays-with-k-different-integers/

Idées de solutions violentes:

Obtenez tous les sous-tableaux de A, déterminez si ses différents entiers sont égaux à K lors de l'obtention de chaque sous-tableau, et enfin renvoyez le nombre de sous-tableaux qui remplissent les conditions.

Simple et grossier, mais malheureusement, c'était des heures supplémentaires. . .

Peut être utilisé dans des projets réels, à titre indicatif seulement

Code python de solution violente:

class Solution:
    def subarraysWithKDistinct(self, A: List[int], K: int) -> int:
        ans = 0
        n = len(A)
        # x + 1 表示子串的长度
        for x in range(n):
            # i 表示滑窗长度
            for i in range(x+1,n+1):
                # if len(set(A[x:i]))==K:
                #     ans += 1
                if len(set(A[x:i]))==K:
                    ans += 1
        return ans