940. Distinct Subsequences II

LeetCode hard original: C# #array #csharp #dynamic-programming #hard #leetcode #matrix #string

El texto de la tarea se traduce del ruso para el idioma seleccionado. El código no cambia.

LeetCode Static

Поскольку ответ может быть очень большим, return его по модулю 10^9 + 7. subsequence строки - это новая cadena, которая образуется из исходной строки путем удаления некоторых (можно ни одного) символов без нарушения взаимного расположения оставшихся символов. (НаEjemplo, "ace" является subsequenceю "abcde", а "aec" - нет.

Ejemplo:

Input: s = "abc"

Output: 7

C# solución

coincidente/original

public class Solution {
    private const int MOD = 1000000007;
    
    public int CountSubsequences(string s) {
        int[] dp = new int[26];
        foreach (char c in s) {
            int index = c - 'a';
            dp[index] = (dp.Sum() + 1) % MOD;
        }
        return dp.Sum() % MOD;
    }
}

C++ solución

borrador automático, revisar antes de enviar

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    private const int MOD = 1000000007;
    
    public int CountSubsequences(string s) {
        vector<int>& dp = new int[26];
        foreach (char c in s) {
            int index = c - 'a';
            dp[index] = (dp.Sum() + 1) % MOD;
        }
        return dp.Sum() % MOD;
    }
}

Java solución

coincidente/original

class Solution {
    private static final int MOD = 1000000007;
    
    public int countSubsequences(String s) {
        int[] dp = new int[26];
        for (char c : s.toCharArray()) {
            int index = c - 'a';
            dp[index] = (int)(((long)sum(dp) + 1) % MOD);
        }
        return sum(dp);
    }
    
    private int sum(int[] dp) {
        int result = 0;
        for (int val : dp) {
            result = (result + val) % MOD;
        }
        return result;
    }
}

Python solución

coincidente/original

MOD = 10**9 + 7

def countSubsequences(s):
    dp = [0] * 26
    for c in s:
        index = ord(c) - ord('a')
        dp[index] = (sum(dp) + 1) % MOD
    return sum(dp) % MOD

Go solución

coincidente/original

package main

const MOD = 1000000007

func countSubsequences(s string) int {
    dp := make([]int, 26)
    for _, c := range s {
        index := c - 'a'
        sum := 0
        for _, val := range dp {
            sum = (sum + val) % MOD
        }
        dp[index] = (sum + 1) % MOD
    }
    result := 0
    for _, val := range dp {
        result = (result + val) % MOD
    }
    return result
}

Algorithm

Определить матрицу DP, где dp[i][j] будет хранить количество подпоследовательностей строки s с длиной i, оканчивающихся символом j.

Инициализировать матрицу DP нулями.

Пройти по каждому символу строки:

Если символ еще не был встречен, все подпоследовательности до текущего символа + текущий символ.

Если символ уже был встречен, учет всех подпоследовательностей, включающих текущий символ, с учетом предыдущих вхождений.

Вернуть сумму всех значений в DP по модулю 10^9 + 7.

😎

Vacantes para esta tarea

Se muestran vacantes activas con etiquetas coincidentes.

Todas las vacantes

Todavía no hay vacantes activas.