【LeetCode每日一题】——854.相似度为K的字符串

一【题目类别】

• 广度优先搜索

二【题目难度】

• 困难

三【题目编号】

• 854.相似度为K的字符串

四【题目描述】

• 如果可以通过将 A 中的两个小写字母精确地交换位置 K 次得到与 B 相等的字符串，我们称字符串 A 和 B 的相似度为 K（K 为非负整数）。
• 给定两个字母异位词 A 和 B ，返回 A 和 B 的相似度 K 的最小值。

五【题目示例】

• 示例 1：
  输入：A = “ab”, B = “ba”
  输出：1
• 示例 2：
  输入：A = “abc”, B = “bca”
  输出：2
• 示例 3：
  输入：A = “abac”, B = “baca”
  输出：2
• 示例 4：
  输入：A = “aabc”, B = “abca”
  输出：2

六【题目提示】

• 1 <= A.length == B.length <= 20
• A 和 B 只包含集合 {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’} 中的小写字母。

七【解题思路】

• 使用队列存放每一次修改的状态，找A离得最近的和B一样的位置交换，退出条件是A和B修改为相等的字符串

八【时间频度】

• 时间复杂度：没分析出来，看题解的也没看太懂，反正复杂度包括状态的数量和字符串的长度，具体什么样暂时没分析出来`(>﹏<)′

九【代码实现】

1. Java语言版

package BFS;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;

public class p854_KSimilarStrings {

    public static void main(String[] args) {
        String A = "abac";
        String B = "baca";
        int res = kSimilarity(A, B);
        System.out.println("交换了" + res + "次");
    }

    public static int kSimilarity(String A, String B) {
        // 定义存储队列
        Queue<String> q = new LinkedList<>();
        // 定义HashSet，利用其不存放重复元素的性质，通过不断地更新，不断地判断是否到达最后的状态
        Set<String> visit = new HashSet();
        // 将A加入队列，这个就是初始字符串，通过不断地和B判断是否到达最终状态
        q.add(A);
        // 把A也加入HashSet，因为我们要不断地更新这个值
        visit.add(A);
        // step就是最终的k
        int step = 0;
        while (!q.isEmpty()) {
            // 通过遍历每一个队列中的每个状态，来判断是否到达最终状态
            for (int k = q.size(); k > 0; k--) {
                String cur = q.poll();
                // 如果已经达到最终状态，返回step
                if (cur.equals(B)) {
                    return step;
                }
                int i = 0;
                // 找出A和B不相等的那个字符的index
                while (i < A.length() && cur.charAt(i) == B.charAt(i)) {
                    i++;
                }
                // 从不相等的字符index的下一个开始遍历
                for (int j = i + 1; j < A.length(); j++) {
                    // 假设i，j是A要交换的index，那么当A和B中第i，j个字符相等时，不需要交换，同时要确保B的第j个字符不等于A的第i个字符
                    if (cur.charAt(j) == B.charAt(j) || B.charAt(j) != cur.charAt(i)) {
                        continue;
                    }
                    StringBuilder sb = new StringBuilder(cur);
                    // 交换不相等的字符，更新状态
                    sb.setCharAt(i, cur.charAt(j));
                    sb.setCharAt(j, cur.charAt(i));
                    // 转换成String字符串
                    String next = sb.toString();
                    // 如果状态队列中没有当前这个状态才加入队列
                    if (!visit.contains(next)) {
                        visit.add(next);
                        q.add(next);
                    }
                }
            }
            // 每循环一次说明进行了一次交换，最终返回step
            step++;
        }
        return -1;
    }

}

2. C语言版

#define _CRT_SECURE_NO_WARNINGS
#include<stdint.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<uthash.h>

typedef struct myStruct
{
	char val[21];
	UT_hash_handle hh;
}Node;

Node *map;
char que[20000][21];
int cnt, head, tail;

void Swap(char *a, char *b)
{
	char c = *a;
	*a = *b;
	*b = c;
}

void Enque(char *a)
{
	strcpy(que[head], a);
	head++;
	head %= 20000;
	cnt++;
}

void Deque(char *a)
{
	strcpy(a, que[tail]);
	tail++;
	tail %= 20000;
	cnt--;
}

void ClearHash()
{
	Node *s, *tmp;
	HASH_ITER(hh, map, s, tmp);
	{
		HASH_DEL(map, s);
		free(s);
	}
}

int kSimilarity(char * A, char * B)
{
	if (strcmp(A, B) == 0)
	{
		return 0;
	}
	cnt = 0;
	head = 0;
	tail = 0;
	map = NULL;
	int wordLen = strlen(A);
	char *c = calloc(wordLen + 1, sizeof(char));
	char *c1 = calloc(wordLen + 1, sizeof(char));
	int res = 0;
	Node *s = calloc(1, sizeof(Node));
	strcpy(s->val, A);
	HASH_ADD_STR(map, val, s);
	Enque(A);
	while (cnt > 0)
	{
		int queLen = cnt;
		for (int i = 0; i < queLen; i++)
		{
			Deque(c);
			int k = 0;
			while (c[k] == B[k])
			{
				k++;
			}
			for (int j = k + 1; j < wordLen; j++)
			{
				if (c[j] == B[k])
				{
					strcpy(c1, c);
					Swap(&c1[j], &c1[k]);
				}
				if (strcmp(c1, B) == 0)
				{
					free(c);
					free(c1);
					ClearHash();
					return res + 1;
				}
				HASH_FIND_STR(map, c1, s);
				if (s == NULL)
				{
					s = calloc(1, sizeof(Node));
					strcpy(s->val, c1);
					HASH_ADD_STR(map, val, s);
					Enque(c1);
				}
			}
		}
		res++;
	}
	free(c);
	free(c1);
	ClearHash();
	return 0;
}

/*主函数内容省略，上面的算法是核心*/

十【提交结果】

1. Java语言版
   
2. C语言版