LeetCode.859-伙伴字符串(Buddy Strings)

Posted xiaochuan94

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode.859-伙伴字符串(Buddy Strings)相关的知识,希望对你有一定的参考价值。

这是悦乐书的第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 第一种解法

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

  1. A和B的长度不相等。两者的长度不相等,无论A怎么换字母,都不可能变成B,直接返回false。

  2. 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。

  3. 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);
    }
}


06 小结

算法专题目前已连续日更超过五个月,算法题文章200+篇,公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词,获取系列文章合集。

以上就是全部内容,如果大家有什么好的解法思路、建议或者其他问题,可以下方留言交流,点赞、留言、转发就是对我最大的回报和支持!

以上是关于LeetCode.859-伙伴字符串(Buddy Strings)的主要内容,如果未能解决你的问题,请参考以下文章

Leetcode_easy859. Buddy Strings

leetcode 859. Buddy Strings

LeetCode 859 亲密字符串[模拟] HERODING的LeetCode之路

内存管理算法--Buddy伙伴算法

Buddy(伙伴)系统分配器之分配page

Buddy(伙伴)系统分配器之分配page