1625. Lexicographically Smallest String After Applying Operations

Description

You are given a string s of even length consisting of digits from 0 to 9, and two integers a and b.

You can apply either of the following two operations any number of times and in any order on s:

• Add a to all odd indices of s (0-indexed). Digits post 9 are cycled back to 0. For example, if s = "3456" and a = 5, s becomes "3951".
• Rotate s to the right by b positions. For example, if s = "3456" and b = 1, s becomes "6345".

Return the lexicographically smallest string you can obtain by applying the above operations any number of times on s.

A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, string a has a letter that appears earlier in the alphabet than the corresponding letter in b. For example, "0158" is lexicographically smaller than "0190" because the first position they differ is at the third letter, and '5' comes before '9'.

 

Example 1:

Input: s = "5525", a = 9, b = 2
Output: "2050"
Explanation: We can apply the following operations:
Start:  "5525"
Rotate: "2555"
Add:    "2454"
Add:    "2353"
Rotate: "5323"
Add:    "5222"
Add:    "5121"
Rotate: "2151"
Add:    "2050"​​​​​
There is no way to obtain a string that is lexicographically smaller than "2050".

Example 2:

Input: s = "74", a = 5, b = 1
Output: "24"
Explanation: We can apply the following operations:
Start:  "74"
Rotate: "47"
​​​​​​​Add:    "42"
​​​​​​​Rotate: "24"​​​​​​​​​​​​
There is no way to obtain a string that is lexicographically smaller than "24".

Example 3:

Input: s = "0011", a = 4, b = 2
Output: "0011"
Explanation: There are no sequence of operations that will give us a lexicographically smaller string than "0011".

 

Constraints:

• 2 <= s.length <= 100
• s.length is even.
• s consists of digits from 0 to 9 only.
• 1 <= a <= 9
• 1 <= b <= s.length - 1

Solutions

Solution 1: BFS

Since the data scale of this problem is relatively small, we can use BFS to brute-force search all possible states and then take the lexicographically smallest state.

Python3JavaC++GoTypeScript

class Solution:
    def findLexSmallestString(self, s: str, a: int, b: int) -> str:
        q = deque([s])
        vis = {s}
        ans = s
        while q:
            s = q.popleft()
            if ans > s:
                ans = s
            t1 = ''.join(
                [str((int(c) + a) % 10) if i & 1 else c for i, c in enumerate(s)]
            )
            t2 = s[-b:] + s[:-b]
            for t in (t1, t2):
                if t not in vis:
                    vis.add(t)
                    q.append(t)
        return ans

class Solution {
    public String findLexSmallestString(String s, int a, int b) {
        Deque<String> q = new ArrayDeque<>();
        q.offer(s);
        Set<String> vis = new HashSet<>();
        vis.add(s);
        String ans = s;
        int n = s.length();
        while (!q.isEmpty()) {
            s = q.poll();
            if (ans.compareTo(s) > 0) {
                ans = s;
            }
            char[] cs = s.toCharArray();
            for (int i = 1; i < n; i += 2) {
                cs[i] = (char) (((cs[i] - '0' + a) % 10) + '0');
            }
            String t1 = String.valueOf(cs);
            String t2 = s.substring(n - b) + s.substring(0, n - b);
            for (String t : List.of(t1, t2)) {
                if (vis.add(t)) {
                    q.offer(t);
                }
            }
        }
        return ans;
    }
}

class Solution {
public:
    string findLexSmallestString(string s, int a, int b) {
        queue<string> q{{s}};
        unordered_set<string> vis{{s}};
        string ans = s;
        int n = s.size();
        while (!q.empty()) {
            s = q.front();
            q.pop();
            ans = min(ans, s);
            string t1 = s;
            for (int i = 1; i < n; i += 2) {
                t1[i] = (t1[i] - '0' + a) % 10 + '0';
            }
            string t2 = s.substr(n - b) + s.substr(0, n - b);
            for (auto& t : {t1, t2}) {
                if (!vis.count(t)) {
                    vis.insert(t);
                    q.emplace(t);
                }
            }
        }
        return ans;
    }
};

func findLexSmallestString(s string, a int, b int) string {
    q := []string{s}
    vis := map[string]bool{s: true}
    ans := s
    n := len(s)
    for len(q) > 0 {
        s = q[0]
        q = q[1:]
        if ans > s {
            ans = s
        }
        t1 := []byte(s)
        for i := 1; i < n; i += 2 {
            t1[i] = byte((int(t1[i]-'0')+a)%10 + '0')
        }
        t2 := s[n-b:] + s[:n-b]
        for _, t := range []string{string(t1), t2} {
            if !vis[t] {
                vis[t] = true
                q = append(q, t)
            }
        }
    }
    return ans
}

function findLexSmallestString(s: string, a: number, b: number): string {
    const q: string[] = [s];
    const vis = new Set<string>([s]);
    let ans = s;
    let i = 0;
    while (i < q.length) {
        s = q[i++];
        if (ans > s) {
            ans = s;
        }
        const t1 = s
            .split('')
            .map((c, j) => (j & 1 ? String((Number(c) + a) % 10) : c))
            .join('');
        const t2 = s.slice(-b) + s.slice(0, -b);
        for (const t of [t1, t2]) {
            if (!vis.has(t)) {
                vis.add(t);
                q.push(t);
            }
        }
    }
    return ans;
}

Solution 2: Enumeration

We observe that for the addition operation, a digit will return to its original state after at most \(10\) additions; for the rotation operation, the string will also return to its original state after at most \(n\) rotations.

Therefore, the rotation operation produces at most \(n\) states. If the rotation count \(b\) is even, the addition operation only affects digits at odd indices, resulting in a total of \(n \times 10\) states; if the rotation count \(b\) is odd, the addition operation affects both odd and even index digits, resulting in a total of \(n \times 10 \times 10\) states.

Thus, we can directly enumerate all possible string states and take the lexicographically smallest one.

The time complexity is \(O(n^2 \times 10^2)\) and the space complexity is \(O(n)\), where \(n\) is the length of string \(s\).

Python3JavaC++GoTypeScript

class Solution:
    def findLexSmallestString(self, s: str, a: int, b: int) -> str:
        ans = s
        n = len(s)
        s = list(s)
        for _ in range(n):
            s = s[-b:] + s[:-b]
            for j in range(10):
                for k in range(1, n, 2):
                    s[k] = str((int(s[k]) + a) % 10)
                if b & 1:
                    for p in range(10):
                        for k in range(0, n, 2):
                            s[k] = str((int(s[k]) + a) % 10)
                        t = ''.join(s)
                        if ans > t:
                            ans = t
                else:
                    t = ''.join(s)
                    if ans > t:
                        ans = t
        return ans

class Solution {
    public String findLexSmallestString(String s, int a, int b) {
        int n = s.length();
        String ans = s;
        for (int i = 0; i < n; ++i) {
            s = s.substring(b) + s.substring(0, b);
            char[] cs = s.toCharArray();
            for (int j = 0; j < 10; ++j) {
                for (int k = 1; k < n; k += 2) {
                    cs[k] = (char) (((cs[k] - '0' + a) % 10) + '0');
                }
                if ((b & 1) == 1) {
                    for (int p = 0; p < 10; ++p) {
                        for (int k = 0; k < n; k += 2) {
                            cs[k] = (char) (((cs[k] - '0' + a) % 10) + '0');
                        }
                        s = String.valueOf(cs);
                        if (ans.compareTo(s) > 0) {
                            ans = s;
                        }
                    }
                } else {
                    s = String.valueOf(cs);
                    if (ans.compareTo(s) > 0) {
                        ans = s;
                    }
                }
            }
        }
        return ans;
    }
}

class Solution {
public:
    string findLexSmallestString(string s, int a, int b) {
        int n = s.size();
        string ans = s;
        for (int i = 0; i < n; ++i) {
            s = s.substr(n - b) + s.substr(0, n - b);
            for (int j = 0; j < 10; ++j) {
                for (int k = 1; k < n; k += 2) {
                    s[k] = (s[k] - '0' + a) % 10 + '0';
                }
                if (b & 1) {
                    for (int p = 0; p < 10; ++p) {
                        for (int k = 0; k < n; k += 2) {
                            s[k] = (s[k] - '0' + a) % 10 + '0';
                        }
                        ans = min(ans, s);
                    }
                } else {
                    ans = min(ans, s);
                }
            }
        }
        return ans;
    }
};

func findLexSmallestString(s string, a int, b int) string {
    n := len(s)
    ans := s
    for _ = range s {
        s = s[n-b:] + s[:n-b]
        cs := []byte(s)
        for j := 0; j < 10; j++ {
            for k := 1; k < n; k += 2 {
                cs[k] = byte((int(cs[k]-'0')+a)%10 + '0')
            }
            if b&1 == 1 {
                for p := 0; p < 10; p++ {
                    for k := 0; k < n; k += 2 {
                        cs[k] = byte((int(cs[k]-'0')+a)%10 + '0')
                    }
                    s = string(cs)
                    if ans > s {
                        ans = s
                    }
                }
            } else {
                s = string(cs)
                if ans > s {
                    ans = s
                }
            }
        }
    }
    return ans
}

function findLexSmallestString(s: string, a: number, b: number): string {
    let ans = s;
    const n = s.length;
    let arr = s.split('');
    for (let _ = 0; _ < n; _++) {
        arr = arr.slice(-b).concat(arr.slice(0, -b));
        for (let j = 0; j < 10; j++) {
            for (let k = 1; k < n; k += 2) {
                arr[k] = String((Number(arr[k]) + a) % 10);
            }
            if (b & 1) {
                for (let p = 0; p < 10; p++) {
                    for (let k = 0; k < n; k += 2) {
                        arr[k] = String((Number(arr[k]) + a) % 10);
                    }
                    const t = arr.join('');
                    if (ans > t) {
                        ans = t;
                    }
                }
            } else {
                const t = arr.join('');
                if (ans > t) {
                    ans = t;
                }
            }
        }
    }
    return ans;
}

Comments