# Minimum Swaps to Make Strings Equal

You are given two strings `s1` and `s2` of equal length consisting of letters `"x"` and `"y"` **only**. Your task is to make these two strings equal to each other. You can swap any two characters that belong to **different** strings, which means: swap `s1[i]` and `s2[j]`.

Return the minimum number of swaps required to make `s1` and `s2` equal, or return `-1` if it is impossible to do so.

**Example 1:**

```
Input: s1 = "xx", s2 = "yy"
Output: 1
Explanation: 
Swap s1[0] and s2[1], s1 = "yx", s2 = "yx".
```

**Example 2:**&#x20;

```
Input: s1 = "xy", s2 = "yx"
Output: 2
Explanation: 
Swap s1[0] and s2[0], s1 = "yy", s2 = "xx".
Swap s1[0] and s2[1], s1 = "xy", s2 = "xy".
Note that you can't swap s1[0] and s1[1] to make s1 equal to "yx", cause we can only swap chars in different strings.
```

**Example 3:**

```
Input: s1 = "xx", s2 = "xy"
Output: -1
```

**Example 4:**

```
Input: s1 = "xxyyxyxyxx", s2 = "xyyxyxxxyx"
Output: 4
```

**Constraints:**

* `1 <= s1.length, s2.length <= 1000`
* `s1, s2` only contain `'x'` or `'y'`.

```java
class Solution {
    public int minimumSwap(String s1, String s2) {
        if (s1.length() != s2.length())
            return -1;
        int x1 = 0; // number of 'x' in s1 (skip equal chars at same index)
        int y1 = 0; // number of 'y' in s1 (skip equal chars at same index)
        int x2 = 0; // number of 'x' in s2 (skip equal chars at same index)
        int y2 = 0; // number of 'y' in s2 (skip equal chars at same index)

        for (int i = 0; i < s1.length(); i++) {
            char c1 = s1.charAt(i);
            char c2 = s2.charAt(i);
            if (c1 == c2) // skip chars that are equal at the same index in s1 and s2
                continue;
            if (c1 == 'x')
                x1++;
            else
                y1++;
            if (c2 == 'x')
                x2++;
            else
                y2++;
        }

        // After skip "c1 == c2", check the number of 'x' and 'y' left in s1 and s2.
        if ((x1 + x2) % 2 != 0 || (y1 + y2) % 2 != 0)
            return -1; // if number of 'x' or 'y' is odd, we can not make s1 equals to s2

        int swaps = x1 / 2 + y1 / 2 + (x1 % 2) * 2;
        // Cases to do 1 swap:
        // "xx" => x1 / 2 => how many pairs of 'x' we have ?
        // "yy" => y1 / 2 => how many pairs of 'y' we have ?
        //
        // Cases to do 2 swaps:
        // "xy" or "yx" => x1 % 2

        return swaps;
    }
}
```
