g2701_2800.s2746_decremental_string_concatenation.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g2701_2800.s2746_decremental_string_concatenation;

// #Medium #Array #String #Dynamic_Programming
// #2023_09_24_Time_34_ms_(85.89%)_Space_50.1_MB_(44.78%)

/**
 * 2746 - Decremental String Concatenation\.
 *
 * Medium
 *
 * You are given a **0-indexed** array `words` containing `n` strings.
 *
 * Let's define a **join** operation `join(x, y)` between two strings `x` and `y` as concatenating them into `xy`. However, if the last character of `x` is equal to the first character of `y`, one of them is **deleted**.
 *
 * For example `join("ab", "ba") = "aba"` and `join("ab", "cde") = "abcde"`.
 *
 * You are to perform `n - 1` **join** operations. Let str₀ = words[0]. Starting from `i = 1` up to `i = n - 1`, for the i^th operation, you can do one of the following:
 *
 * *   Make str_i = join(str_{i - 1}, words[i])
 * *   Make str_i = join(words[i], str_{i - 1})
 *
 * Your task is to **minimize** the length of str_{n - 1}.
 *
 * Return _an integer denoting the minimum possible length of_ str_{n - 1}.
 *
 * **Example 1:**
 *
 * **Input:** words = ["aa","ab","bc"]
 *
 * **Output:** 4
 *
 * **Explanation:** In this example, we can perform join operations in the following order to minimize the length of str₂: 
 *
 * str₀ = "aa" 
 *
 * str₁ = join(str₀, "ab") = "aab" 
 *
 * str₂ = join(str₁, "bc") = "aabc" 
 *
 * It can be shown that the minimum possible length of str₂ is 4.
 *
 * **Example 2:**
 *
 * **Input:** words = ["ab","b"]
 *
 * **Output:** 2
 *
 * **Explanation:** In this example, str₀ = "ab", there are two ways to get str₁: join(str₀, "b") = "ab" or join("b", str₀) = "bab". The first string, "ab", has the minimum length. Hence, the answer is 2.
 *
 * **Example 3:**
 *
 * **Input:** words = ["aaa","c","aba"]
 *
 * **Output:** 6
 *
 * **Explanation:** In this example, we can perform join operations in the following order to minimize the length of str₂: 
 *
 * str₀ = "aaa" 
 *
 * str₁ = join(str₀, "c") = "aaac" 
 *
 * str₂ = join("aba", str₁) = "abaaac" 
 *
 * It can be shown that the minimum possible length of str₂ is 6.
 *
 * **Constraints:**
 *
 * *   `1 <= words.length <= 1000`
 * *   `1 <= words[i].length <= 50`
 * *   Each character in `words[i]` is an English lowercase letter
**/
public class Solution {
    private Integer[][][] dp;

    public int minimizeConcatenatedLength(String[] words) {
        int n = words.length;
        dp = new Integer[n][26][26];
        String curWord = words[0];
        int curLen = curWord.length();
        char curFirst = curWord.charAt(0);
        char curLast = curWord.charAt(curLen - 1);
        return curLen + solve(1, curFirst, curLast, n, words);
    }

    private int solve(int idx, char prevFirst, char prevLast, int n, String[] words) {
        if (idx == n) {
            return 0;
        }
        if (dp[idx][prevFirst - 'a'][prevLast - 'a'] != null) {
            return dp[idx][prevFirst - 'a'][prevLast - 'a'];
        }
        String curWord = words[idx];
        int curLen = curWord.length();
        char curFirst = curWord.charAt(0);
        char curLast = curWord.charAt(curLen - 1);
        int ans = (int) 1e9;
        if (prevFirst == curLast) {
            ans = Math.min(ans, curLen - 1 + solve(idx + 1, curFirst, prevLast, n, words));
        } else {
            ans = Math.min(ans, curLen + solve(idx + 1, curFirst, prevLast, n, words));
        }
        if (prevLast == curFirst) {
            ans = Math.min(ans, curLen - 1 + solve(idx + 1, prevFirst, curLast, n, words));
        } else {
            ans = Math.min(ans, curLen + solve(idx + 1, prevFirst, curLast, n, words));
        }
        dp[idx][prevFirst - 'a'][prevLast - 'a'] = ans;
        return ans;
    }
}