LeetCode每日一题(1639. Number of Ways to Form a Target String Given a Dictionary)

该文章介绍了一个编程问题,涉及将给定的相同长度字符串列表(words)按照特定规则组合成目标字符串(target)。通过动态规划计算不同组合方式的数量,同时考虑了字符频率矩阵。文章提供了算法实现示例和约束条件。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

You are given a list of strings of the same length words and a string target.

Your task is to form target using the given words under the following rules:

target should be formed from left to right.
To form the ith character (0-indexed) of target, you can choose the kth character of the jth string in words if target[i] = words[j][k].
Once you use the kth character of the jth string of words, you can no longer use the xth character of any string in words where x <= k. In other words, all characters to the left of or at index k become unusuable for every string.
Repeat the process until you form the string target.
Notice that you can use multiple characters from the same string in words provided the conditions above are met.

Return the number of ways to form target from words. Since the answer may be too large, return it modulo 109 + 7.

Example 1:

Input: words = [“acca”,“bbbb”,“caca”], target = “aba”
Output: 6

Explanation: There are 6 ways to form target.
“aba” -> index 0 (“acca”), index 1 (“bbbb”), index 3 (“caca”)
“aba” -> index 0 (“acca”), index 2 (“bbbb”), index 3 (“caca”)
“aba” -> index 0 (“acca”), index 1 (“bbbb”), index 3 (“acca”)
“aba” -> index 0 (“acca”), index 2 (“bbbb”), index 3 (“acca”)
“aba” -> index 1 (“caca”), index 2 (“bbbb”), index 3 (“acca”)
“aba” -> index 1 (“caca”), index 2 (“bbbb”), index 3 (“caca”)

Example 2:

Input: words = [“abba”,“baab”], target = “bab”
Output: 4

Explanation: There are 4 ways to form target.
“bab” -> index 0 (“baab”), index 1 (“baab”), index 2 (“abba”)
“bab” -> index 0 (“baab”), index 1 (“baab”), index 3 (“baab”)
“bab” -> index 0 (“baab”), index 2 (“baab”), index 3 (“baab”)
“bab” -> index 1 (“abba”), index 2 (“baab”), index 3 (“baab”)

Constraints:

  • 1 <= words.length <= 1000
  • 1 <= words[i].length <= 1000
  • All strings in words have the same length.
  • 1 <= target.length <= 1000
  • words[i] and target contain only lowercase English letters.

我们把 words 想象成一个 matrix, 假设 freqs_in_col[col][char]是 words 的每一列每一个字符的出现频率, dp[i][j]是用 words[…][j…]这部分来生成 target[i…]的路径数量, dp[i][j] = dp[i][j + 1] + freqs_in_col[j]target[i]] _ dp[i+1][j+1]。 其中 dp[i][j + 1]是指的不取 words[…][j]中的字符, 也就是跳过第 j 列的路径数量。freqs_in_col[j]target[i]] _ dp[i+1][j+1]是指的从第 j 列中取与 target[i]相同的字符的路径数量


use std::collections::HashMap;

const M: i64 = 1000000007;

impl Solution {
    fn dp(freqs_in_col: &Vec<Vec<i64>>, target: &Vec<char>, i: usize, j: usize, cache: &mut HashMap<(usize, usize), i64>) -> i64 {
        if i == target.len() {
            return 1;
        }
        if j == freqs_in_col.len() {
            return 0;
        }
        if let Some(&c) = cache.get(&(i, j)) {
            return c;
        }
        let mut ans = Solution::dp(freqs_in_col, target, i, j + 1, cache) % M;
        let freq = freqs_in_col[j][target[i] as usize - 97];
        if freq > 0 {
            ans += freq * Solution::dp(freqs_in_col, target, i + 1, j + 1, cache) % M;
        }
        ans %= M;
        cache.insert((i, j), ans);
        ans
    }
    pub fn num_ways(words: Vec<String>, target: String) -> i32 {
        let words: Vec<Vec<char>> = words.into_iter().map(|s| s.chars().collect()).collect();
        let mut freqs_in_col = vec![vec![0; 26]; words[0].len()];
        for r in 0..words.len() {
            for c in 0..words[0].len() {
                freqs_in_col[c][words[r][c] as usize - 97] += 1;
            }
        }

        Solution::dp(&freqs_in_col, &target.chars().collect(), 0, 0, &mut HashMap::new()) as i32
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值