1416. Restore The Array

LeetCode hard original: C# #array #csharp #dynamic-programming #graph #hard #leetcode #recursion #string #tree

Văn bản bài toán được dịch từ tiếng Nga theo ngôn ngữ giao diện. Mã không thay đổi.

LeetCode Static

Программа должна была напечатать mảng целых чисел. Программа забыла напечатать пробелы, и mảng напечатан как chuỗi цифр s, и всё, что мы знаем, это что все числа в mảngе были в диапазоне [1, k] и в mảngе нет ведущих нулей.

given строку s и số nguyên k, return количество возможных mảngов, которые могут быть напечатаны как s с использованием упомянутой программы. Так как ответ может быть очень большим, return его по модулю 10^9 + 7.

Ví dụ:

Input: s = "1000", k = 10000

Output: 1

Explanation: The only possible array is [1000]

C# lời giải

đã khớp/gốc

public class Solution {
    private int mod = 1_000_000_007;
    private int Dfs(int[] dp, int start, string s, int k) {
        if (dp[start] != 0) return dp[start];
        if (start == s.Length) return 1;
        if (s[start] == '0') return 0;
        long count = 0;
        for (int end = start; end < s.Length; ++end) {
            string currNumber = s.Substring(start, end - start + 1);
            if (long.Parse(currNumber) > k) break;
            count = (count + Dfs(dp, end + 1, s, k)) % mod;
        }
        dp[start] = (int)count;
        return (int)count;
    }
    public int NumberOfArrays(string s, int k) {
        int[] dp = new int[s.Length + 1];
        return Dfs(dp, 0, s, k);
    }
}

C++ lời giải

bản nháp tự động, xem lại trước khi gửi

#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 int mod = 1_000_000_007;
    private int Dfs(vector<int>& dp, int start, string s, int k) {
        if (dp[start] != 0) return dp[start];
        if (start == s.size()) return 1;
        if (s[start] == '0') return 0;
        long count = 0;
        for (int end = start; end < s.size(); ++end) {
            string currNumber = s.Substring(start, end - start + 1);
            if (long.Parse(currNumber) > k) break;
            count = (count + Dfs(dp, end + 1, s, k)) % mod;
        }
        dp[start] = (int)count;
        return (int)count;
    }
    public int NumberOfArrays(string s, int k) {
        vector<int>& dp = new int[s.size() + 1];
        return Dfs(dp, 0, s, k);
    }
}

Java lời giải

đã khớp/gốc

class Solution {
    int mod = 1_000_000_007;

    private int dfs(int[] dp, int start, String s, int k) {
        if (dp[start] != 0)
            return dp[start];

        if (start == s.length())
            return 1;

        if (s.charAt(start) == '0')
            return 0;

        int count = 0;
        for (int end = start; end < s.length(); ++end) {
            String currNumber = s.substring(start, end + 1);
            if (Long.parseLong(currNumber) > k)
                break;
            count = (count + dfs(dp, end + 1, s, k)) % mod;
        }

        dp[start] = count;
        return count;
    }
    
    public int numberOfArrays(String s, int k) {
        int m = s.length();
        int[] dp = new int[m + 1];
        return dfs(dp, 0, s, k);
    }
}

JavaScript lời giải

đã khớp/gốc

var Solution = function() {
    this.mod = 1_000_000_007;
};

Solution.prototype.dfs = function(dp, start, s, k) {
    if (dp[start] !== 0) return dp[start];
    if (start === s.length) return 1;
    if (s[start] === '0') return 0;

    let count = 0;
    for (let end = start; end < s.length; end++) {
        let currNumber = parseInt(s.slice(start, end + 1));
        if (currNumber > k) break;
        count = (count + this.dfs(dp, end + 1, s, k)) % this.mod;
    }

    dp[start] = count;
    return count;
};

Solution.prototype.numberOfArrays = function(s, k) {
    let dp = Array(s.length + 1).fill(0);
    return this.dfs(dp, 0, s, k);
};

Go lời giải

đã khớp/gốc

func dfs(dp []int, start int, s string, k int) int {
    if dp[start] != 0 {
        return dp[start]
    }
    if start == len(s) {
        return 1
    }
    if s[start] == '0' {
        return 0
    }

    mod := 1_000_000_007
    count := 0
    for end := start; end < len(s); end++ {
        currNumber, _ := strconv.Atoi(s[start : end+1])
        if currNumber > k {
            break
        }
        count = (count + dfs(dp, end+1, s, k)) % mod
    }

    dp[start] = count
    return count
}

func numberOfArrays(s string, k int) int {
    dp := make([]int, len(s)+1)
    return dfs(dp, 0, s, k)
}

Algorithm

Создать mảng dp размера m + 1, чтобы хранить значения dfs(x).

Для получения значения dfs(start), если dp[start] не равно нулю, вернуть его значение. Иначе:

Если s[start] == 0, вернуть 0.

Если start = m, вернуть 1.

Инициализировать count = 0, чтобы считать количество возможных mảngов.

Перебрать все возможные конечные индексы end, и если s[start ~ end] представляет допустимое number, продолжить рекурсивный вызов dfs(end + 1) и обновить count как count += dfs(end + 1).

Обновить dp[start] значением dfs(start).

Вернуть dfs(0).

😎

Vacancies for this task

việc làm đang hoạt động with overlapping task tags are đã hiển thị.

Tất cả việc làm

Chưa có việc làm đang hoạt động.