README_EN.md

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 then "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 then "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

BFS.

Python3

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 s < ans:
                ans = s
            nxt1 = ''.join(
                [str((int(c) + a) % 10) if i & 1 else c for i, c in enumerate(s)]
            )
            nxt2 = s[-b:] + s[:-b]
            for nxt in (nxt1, nxt2):
                if nxt not in vis:
                    vis.add(nxt)
                    q.append(nxt)
        return ans

Java

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

C++

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

Go

func findLexSmallestString(s string, a int, b int) string {
	q := []string{s}
	vis := map[string]bool{s: true}
	ans := s
	for len(q) > 0 {
		s = q[0]
		q = q[1:]
		if s < ans {
			ans = s
		}
		for _, nxt := range []string{op1(s, a), op2(s, b)} {
			if !vis[nxt] {
				vis[nxt] = true
				q = append(q, nxt)
			}
		}
	}
	return ans
}

func op1(s string, a int) string {
	res := []byte(s)
	for i := 1; i < len(s); i += 2 {
		res[i] = byte((int(res[i]-'0')+a)%10 + '0')
	}
	return string(res)
}

func op2(s string, b int) string {
	return s[len(s)-b:] + s[:len(s)-b]
}

...