# 899. Orderly Queue

## Description

You are given a string s and an integer k. You can choose one of the first k letters of s and append it at the end of the string.

Return the lexicographically smallest string you could have after applying the mentioned step any number of moves.

Example 1:

Input: s = "cba", k = 1
Output: "acb"
Explanation:
In the first move, we move the 1st character 'c' to the end, obtaining the string "bac".
In the second move, we move the 1st character 'b' to the end, obtaining the final result "acb".


Example 2:

Input: s = "baaca", k = 3
Output: "aaabc"
Explanation:
In the first move, we move the 1st character 'b' to the end, obtaining the string "aacab".
In the second move, we move the 3rd character 'c' to the end, obtaining the final result "aaabc".


Constraints:

• 1 <= k <= s.length <= 1000
• s consist of lowercase English letters.

## Solutions

Preface

For any string, if any adjacent characters can be swapped, we can perform a bubble sort-like operation on the characters in the string, eventually obtaining a string sorted in ascending order.

Solution 1: Case-by-case Judgment

 If $k = 1$, we can only move the first character of the string to the end of the string each time, resulting in $s$ different states. We return the string with the smallest lexicographic order.

If $k > 1$, for a string like $abc[xy]def$, we can move $a$, $b$, and $c$ to the end in order, resulting in $[xy]defabc$. Then we move $y$ and $x$ to the end, resulting in $defabc[yx]$. Finally, we move $d$, $e$, and $f$ to the end, resulting in $abc[yx]def$. This way, we have swapped $y$ and $x$.

Therefore, as long as $k > 1$, we can swap any two adjacent characters in the string, eventually obtaining a string sorted in ascending order.

The time complexity is $O(n^2)$, and the space complexity is $O(n)$. Here, $n$ is the length of the string.

• class Solution {
public:
string orderlyQueue(string s, int k) {
if (k == 1) {
string ans = s;
for (int i = 0; i < s.size() - 1; ++i) {
s = s.substr(1) + s[0];
if (s < ans) ans = s;
}
return ans;
}
sort(s.begin(), s.end());
return s;
}
};

• class Solution:
def orderlyQueue(self, s: str, k: int) -> str:
if k == 1:
ans = s
for _ in range(len(s) - 1):
s = s[1:] + s[0]
ans = min(ans, s)
return ans
return "".join(sorted(s))


• func orderlyQueue(s string, k int) string {
if k == 1 {
ans := s
for i := 0; i < len(s)-1; i++ {
s = s[1:] + s[:1]
if s < ans {
ans = s
}
}
return ans
}
t := []byte(s)
sort.Slice(t, func(i, j int) bool { return t[i] < t[j] })
return string(t)
}

• function orderlyQueue(s: string, k: number): string {
if (k > 1) {
return [...s].sort().join('');
}
const n = s.length;
let min = s;
for (let i = 1; i < n; i++) {
const t = s.slice(i) + s.slice(0, i);
if (t < min) {
min = t;
}
}
return min;
}


• class Solution {
public String orderlyQueue(String s, int k) {
if (k == 1) {
String ans = s;
StringBuilder sb = new StringBuilder(s);
for (int i = 0; i < s.length() - 1; ++i) {
sb.append(sb.charAt(0)).deleteCharAt(0);
if (sb.toString().compareTo(ans) < 0) {
ans = sb.toString();
}
}
return ans;
}
char[] cs = s.toCharArray();
Arrays.sort(cs);
return String.valueOf(cs);
}
}