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

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
    }
}