LeetCode每日一题(2193. Minimum Number of Moves to Make Palindrome)

You are given a string s consisting only of lowercase English letters.

In one move, you can select any two adjacent characters of s and swap them.

Return the minimum number of moves needed to make s a palindrome.

Note that the input will be generated such that s can always be converted to a palindrome.

Example 1:

Input: s = “aabb”
Output: 2

Explanation:
We can obtain two palindromes from s, “abba” and “baab”.

• We can obtain “abba” from s in 2 moves: “aabb” -> “abab” -> “abba”.
• We can obtain “baab” from s in 2 moves: “aabb” -> “abab” -> “baab”.
  Thus, the minimum number of moves needed to make s a palindrome is 2.

Example 2:

Input: s = “letelt”
Output: 2

Explanation:
One of the palindromes we can obtain from s in 2 moves is “lettel”.
One of the ways we can obtain it is “letelt” -> “letetl” -> “lettel”.
Other palindromes such as “tleelt” can also be obtained in 2 moves.
It can be shown that it is not possible to obtain a palindrome in less than 2 moves.

Constraints:

• 1 <= s.length <= 2000
• s consists only of lowercase English letters.
• s can be converted to a palindrome using a finite number of moves.

---

用双指针法， 至于为什么这种方法会奏效， 请看这里。

---

impl Solution {
    pub fn min_moves_to_make_palindrome(s: String) -> i32 {
        let mut chars: Vec<char> = s.chars().collect();
        let mut i = 0;
        let mut j = chars.len() - 1;
        let mut ans = 0;
        while i < j {
            if chars[i] == chars[j] {
                i += 1;
                j -= 1;
                continue;
            }
            let mut ii = i;
            while ii < j {
                if chars[ii] == chars[j] {
                    break;
                }
                ii += 1;
            }
            if ii == j {
                ans += ((chars.len() / 2) as i32 - j as i32).abs();
                j -= 1;
                continue;
            }
            let mut jj = j;
            while jj > i {
                if chars[jj] == chars[i] {
                    break;
                }
                jj -= 1;
            }
            if jj == i {
                ans += ((chars.len() / 2) as i32 - i as i32).abs();
                i += 1;
                continue;
            }
            if (ii - i) < (j - jj) {
                let mut m = ii;
                while m > i {
                    chars[m] = chars[m - 1];
                    m -= 1;
                }
                ans += (ii - i) as i32;
            } else {
                let mut m = jj;
                while m < j {
                    chars[m] = chars[m + 1];
                    m += 1;
                }
                ans += (j - jj) as i32;
            }
            i += 1;
            j -= 1;
        }
        ans
    }
}