LeetCode.859-伙伴字符串（Buddy Strings）

最新推荐文章于 2020-02-14 09:51:30 发布

程序员小川

最新推荐文章于 2020-02-14 09:51:30 发布

阅读量157

点赞数

CC 4.0 BY-SA版权

分类专栏：【算法】---LeetCode 文章标签： LeetCode 算法题面试题

本文链接：https://blog.youkuaiyun.com/codeMas/article/details/90051321

【算法】---LeetCode 专栏收录该内容

274 篇文章

订阅专栏

本文深入解析LeetCode第200题，探讨如何判断通过交换两个字符能使两个字符串相等。提供了三种Java解法，包括使用HashSet、List和优化后的固定长度数组策略，分析了每种解法的时间和空间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是悦乐书的第330次更新，第354篇原创

01 看题和准备

今天介绍的是LeetCode算法题中Easy级别的第200题（顺位题号是859）。给定两个字母A和B的小写字母，当且仅当我们可以在A中交换两个字母以使结果等于B时返回true。例如：

输入：A =“ab”，B =“ba”
输出：true

输入：A =“ab”，B =“ab”
输出：false

输入：A =“aa”，B =“aa”
输出：true

输入：A =“aaaaaaabc”，B =“aaaaaaacb”
输出：true

输入：A =“”，B =“aa”
输出：false

注意：

0 <= A.length <= 20000
0 <= B.length <= 20000
A和B仅由小写字母组成。

本次解题使用的开发工具是eclipse，jdk使用的版本是1.8，环境是win7 64位系统，使用Java语言编写和测试。

02 错误的尝试

一次错误的提交，原因是理解题目出现偏差，我以为是相邻的两个字符进行替换，但是不然，是任意两个字符进行替换能够和B相等，就可以返回true。例如：A=“abab”，B=“abab”，下面的方法计算的结果是false，但其实应该是true，因为只要将A中的第一个a换到第三个位置，将第三个位置的a换到第一个位置，就能保证A和B相等，交换b也是一样的。再例如A=“aaabac”，B=“aaacab”，也是一样的情况。

public boolean buddyStrings(String A, String B) {
    if (A.length() != B.length()) {
        return false;
    }
    boolean result = false;
    char[] arr = A.toCharArray();
    int n = arr.length;
    for (int i=0; i<n-1; i++) {
        char temp = arr[i];
        arr[i] = arr[i+1];
        arr[i+1] = temp;
        if (B.equals(String.valueOf(arr))) {
            return true;
        } else {
            char temp2 = arr[i];
            arr[i] = arr[i+1];
            arr[i+1] = temp2;
        }
    }
    return result;
}

03 第一种解法

我们再来好好分析下题目，既然不是交换相邻的两个字母，那么就需要分三种情况来具体分析：

A和B的长度不相等。两者的长度不相等，无论A怎么换字母，都不可能变成B，直接返回false。
A和B的长度相等，并且A和B相等。要想满足A换两字母后能够等于B，A就必须至少要有一个字母出现两次以上，因为只有交换重复出现的字母，A才不会变，也就可以和B相等了。例如，A=“aa”，B=“aa”，或者A=“afag”，B=“afag”，这两组都是满足条件。再例如，A=“abc”，B=“abc”，虽然A等于B，但是A无论交换哪两个字母，交换后的新A都不会等于B。
A和B的长度相等，但是A和B不相等。同样，要想A交换两个字母后等于B，前提条件就是在对应索引位置上A不等于B的字母的个数，只能是2个，多于2个或少于2个都不行。同时还要满足：A中第一个不等于B的字母要等于B中不等于A的第二个字母，A中第二个不等于B的字母要等于B中不等于A的第一个字母。换成伪代码就是A[i] == B[j] and A[j] == B[i]，i和j是A和B两个不同字母的索引。

在处理第二种情况时，使用了HashSet，将A变成字符数组存入其中，只要HashSet的size小于A的长度，就说明A中包含重复出现的字母，符合条件。

在处理第三种情况时，使用了两个List，分别存储了A中、B中对应索引位置不相等的字母，最后判断存储A中字母List的长度、两个List中的元素是否交叉相等这两个条件。

此解法的时间复杂度是O(N)，空间复杂度是O(N)。

public boolean buddyStrings2(String A, String B) {
    if (A.length() != B.length()) {
        return false;
    }
    if (A.equals(B)) {
        Set<Character> set = new HashSet<Character>();
        for (char ch : A.toCharArray()) {
            set.add(ch);
        }
        return set.size() < A.length();
    } else {
        List<Character> list = new ArrayList<Character>();
        List<Character> list2 = new ArrayList<Character>();
        int n = A.length();
        for (int i=0; i<n; i++) {
            char c = A.charAt(i);
            char c2 = B.charAt(i);
            if (c != c2) {
                list.add(c);
                list2.add(c2);
            }
        }
        return list.size() == 2 && 
            list.get(0) == list2.get(1) && 
            list.get(1) == list2.get(0);
    }
}

04 第二种解法

对于上面的解法，还可以再优化下，在处理第三种情况的时候，只是用一个List，改为存储A和B对应位置不相等字母的索引，最后判断List的长度是否等于2，以及A和B在List中的索引位置上对应的字母是否交叉相等。

此解法的时间复杂度是O(N)，空间复杂度是O(N)。

public boolean buddyStrings3(String A, String B) {
    if (A.length() != B.length()) {
        return false;
    }
    if (A.equals(B)) {
        Set<Character> set = new HashSet<Character>();
        for (char ch : A.toCharArray()) {
            set.add(ch);
        }
        return set.size() < A.length();
    } else {
        List<Integer> diffIndex = new ArrayList<Integer>();
        int n = A.length();
        for (int i=0; i<n; i++) {
            if (A.charAt(i) != B.charAt(i)) {
                diffIndex.add(i);
            }
        }
        return diffIndex.size() == 2 && 
            A.charAt(diffIndex.get(0)) == B.charAt(diffIndex.get(1)) &&  
            A.charAt(diffIndex.get(1)) == B.charAt(diffIndex.get(0));
    }
}

05 第三种解法

对于前一种解法，我们还可以再优化下。

在第二种情况中，使用一个长度为26的整数数组，来判断A中是否有重复出现的字母。

在第三种情况中，使用两个临时变量存储A和B中对应位置字母不相等的索引值，如果字母不相等的个数多于2个就直接返回false，最后判断两个索引位置上对应的字母是否交叉相等。

此解法的时间复杂度是O(N)，空间复杂度是O(1)。

public boolean buddyStrings4(String A, String B) {
    if (A.length() != B.length()) {
        return false;
    }
    if (A.equals(B)) {
        int[] arr = new int[26];
        for (char ch : A.toCharArray()) {
            if (++arr[ch-'a'] >= 2) {
                return true;
            }
        }
        return false;
    } else {
        int index = -1;
        int index2 = -1;
        int n = A.length();
        for (int i=0; i<n; i++) {
            if (A.charAt(i) != B.charAt(i)) {
                if (index == -1) {
                    index = i;
                } else if (index2 == -1) {
                    index2 = i;
                } else {
                    return false;
                }
            }
        }
        return A.charAt(index) == B.charAt(index2) &&  
            A.charAt(index2) == B.charAt(index);
    }
}