LeetCode in Kotlin

3302. Find the Lexicographically Smallest Valid Sequence

Medium

You are given two strings word1 and word2.

A string x is called almost equal to y if you can change at most one character in x to make it identical to y.

A sequence of indices seq is called valid if:

Return an array of size word2.length representing the lexicographically smallest valid sequence of indices. If no such sequence of indices exists, return an empty array.

Note that the answer must represent the lexicographically smallest array, not the corresponding string formed by those indices.

Example 1:

Input: word1 = “vbcca”, word2 = “abc”

Output: [0,1,2]

Explanation:

The lexicographically smallest valid sequence of indices is [0, 1, 2]:

Example 2:

Input: word1 = “bacdc”, word2 = “abc”

Output: [1,2,4]

Explanation:

The lexicographically smallest valid sequence of indices is [1, 2, 4]:

Example 3:

Input: word1 = “aaaaaa”, word2 = “aaabc”

Output: []

Explanation:

There is no valid sequence of indices.

Example 4:

Input: word1 = “abc”, word2 = “ab”

Output: [0,1]

Constraints:

Solution

class Solution {
    fun validSequence(word1: String, word2: String): IntArray? {
        val c1 = word1.toCharArray()
        val c2 = word2.toCharArray()
        val dp = IntArray(c1.size + 1)
        var j = c2.size - 1
        for (i in c1.indices.reversed()) {
            if (j >= 0 && c1[i] == c2[j]) {
                dp[i] = dp[i + 1] + 1
                j--
            } else {
                dp[i] = dp[i + 1]
            }
        }
        val ans = IntArray(c2.size)
        var i = 0
        j = 0
        while (i < c1.size && j < c2.size) {
            if (c1[i] == c2[j]) {
                ans[j] = i
                j++
            } else {
                if (dp[i + 1] >= c2.size - 1 - j) {
                    ans[j] = i
                    j++
                    i++
                    break
                }
            }
            i++
        }
        if (j < c2.size && i == c1.size) {
            return IntArray(0)
        }
        while (j < c2.size && i < c1.size) {
            if (c2[j] == c1[i]) {
                ans[j] = i
                j++
            }
            i++
        }
        return ans
    }
}