2023-05-15：对于某些非负整数 k ，如果交换 s1 中两个字母的位置恰好 k 次， 能够使结果字符串等于 s2 ，则认为字符串 s1 和 s2 的 相

2023-05-15：对于某些非负整数 k ，如果交换 s1 中两个字母的位置恰好 k 次，

能够使结果字符串等于 s2 ，则认为字符串 s1 和 s2 的 相似度为 k。

给你两个字母异位词 s1 和 s2 ，返回 s1 和 s2 的相似度 k 的最小值。

输入：s1 = "abc", s2 = "bca"。

输出：2。

答案2023-05-15：

解题思路：

• 定义一个小根堆，按照节点的估值函数进行排序。

• 初始化节点为 s1，将其加入小根堆。同时记录访问过的节点，以避免重复搜索。

• 从小根堆中弹出代价最小的节点 cur。

• 如果 cur 与 s2 相等，则返回当前代价 cost。

• 否则，找到 cur 与 s2 第一个不同的位置 firstDiff，再枚举 firstDiff 之后的位置 i。

• 如果 cur[i] 与 s2[firstDiff] 相等但不在第 i 个位置，则构造一个新的字符串 newStr，交换 newStr[firstDiff] 和 newStr[i] 的位置。

• 将 newStr 加入小根堆，代价是 cost+1，where 是 firstDiff+1。

• 在加入前判断是否已经访问过，如果访问过就跳过该节点。

• 将 newStr 和 cur 恢复为原始状态（恢复数组）。

• 重复上述步骤，直到小根堆为空或者找到相同的字符串。

需要注意的点：

• 估值函数的实现是可以调整的，可以根据实际情况来实现更加合适的估值函数。

• 在 Go 中没有提供 C 语言中的 strdup 函数。可以使用 string 转换为字节数组 []byte，然后再转换为字符串。

• 在 Go 中 map 是无序的，如果想要按照访问顺序遍历可以在 Node 中增加一个 visited 字段，每次入队时设置 visited = true，在出队时判断 visited 是否为 true，如果为 true 则跳过。

时间复杂度为O(n^2)，其中n是字符串的长度。

空间复杂度为O(n^2)，存储小根堆和visited哈希表所需的空间。

go完整代码如下：

package main

import "fmt"

type Node struct {
	cost   int
	guess  int
	where_ int
	str_   string
}

func kSimilarity(s1 string, s2 string) int {
	len := len(s1)
	heap := &NodeHeap{}
	visited := make(map[string]struct{})
	域名(&Node{0, 0, 0, s1})
	for 域名() > 0 {
		cur := 域名().(*Node)
		if _, ok := visited[域名]; ok {
			continue
		}
		if 域名 == s2 {
			return 域名
		}
		visited[域名] = struct{}{}
		firstDiff := 域名e_
		for firstDiff < len && 域名[firstDiff] == s2[firstDiff] {
			firstDiff++
		}
		curStr := []byte(域名)
		for i := firstDiff + 1; i < len; i++ {
			if curStr[i] == s2[firstDiff] && curStr[i] != s2[i] {
				swap(curStr, firstDiff, i)
				add(string(curStr), s2, 域名+1, firstDiff+1, heap, visited)
				swap(curStr, firstDiff, i)
			}
		}
	}
	return -1
}

type NodeHeap []*Node

func (h NodeHeap) Len() int { return len(h) }

func (h NodeHeap) Less(i, j int) bool {
	return h[i].cost+h[i].guess < h[j].cost+h[j].guess
}

func (h NodeHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }

func (h *NodeHeap) Push(x interface{}) {
	*h = append(*h, x.(*Node))
}

func (h *NodeHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func add(add string, s2 string, cost int, index int, heap *NodeHeap, visited map[string]struct{}) {
	if _, ok := visited[add]; !ok {
		域名(&Node{cost, evaluate(add, s2, index), index, add})
	}
}

func swap(s []byte, i int, j int) {
	tmp := s[i]
	s[i] = s[j]
	s[j] = tmp
}

func evaluate(s1 string, s2 string, index int) int {
	diff := 0
	for i := index; i < len(s1); i++ {
		if s1[i] != s2[i] {
			diff++
		}
	}
	return (diff + 1) / 2
}

func main() {
	s1 := "abc"
	s2 := "bca"
	域名tln(kSimilarity(s1, s2))
	s1 = "ab"
	s2 = "ba"
	域名tln(kSimilarity(s1, s2))
}

rust完整代码如下：

#[derive(Eq, PartialEq)]
struct Node {
    cost: i32,
    guess: i32,
    where_: usize,
    str_: String,
}

impl Ord for Node {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        (域名 + 域名s).cmp(&(域名 + 域名s))
    }
}

impl PartialOrd for Node {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(域名(other))
    }
}

fn k_similarity(s1: String, s2: String) -> i32 {
    let len = 域名();
    let mut heap = std::collections::BinaryHeap::new();
    let mut visited = std::collections::HashSet::<String>::new();
    域名(Node {
        cost: 0,
        guess: 0,
        where_: 0,
        str_: s1,
    });
    while let Some(cur) = 域名() {
        if 域名ains(&域名) {
            continue;
        }
        if 域名 == s2 {
            return 域名;
        }
        域名rt(域名e());
        let mut first_diff = 域名e_;
        while 域名s().nth(first_diff).unwrap() == 域名s().nth(first_diff).unwrap() {
            first_diff += 1;
        }
        let cur_str = 域名ytes();
        for i in first_diff + 1..len {
            if 域名(i).unwrap() == &域名ytes()[first_diff]
                && 域名(i).unwrap() != &域名ytes()[i]
            {
                let mut new_str = String::from_utf8_lossy(cur_str).to_string();
                swap(&mut new_str, first_diff, i);
                add(
                    new_str,
                    域名e(),
                    域名 + 1,
                    first_diff + 1,
                    &mut heap,
                    &visited,
                );
            }
        }
    }
    -1
}

fn swap(s: &mut String, i: usize, j: usize) {
    unsafe {
        let s_mut = 域名ut_vec();
        let tmp = std::ptr::read(域名unchecked(i));
        std::ptr::copy_nonoverlapping(域名unchecked(j), 域名unchecked_mut(i), 1);
        std::ptr::write(域名unchecked_mut(j), tmp);
    }
}

fn add(
    add: String,
    s2: String,
    cost: i32,
    index: usize,
    heap: &mut std::collections::BinaryHeap<Node>,
    visited: &std::collections::HashSet<String>,
) {
    if !域名ains(&add) {
        域名(Node {
            cost,
            guess: evaluate(&add, &s2, index),
            where_: index,
            str_: add,
        });
    }
}

// 估值函数
// 看每周有营养的大厂算法面试题，2022年1月第3周
// 估值函数的估计值要绝对 <= 真实距离
// 但又要确保估计值足够大足够接近真实距离，这样效果最好
fn evaluate(s1: &str, s2: &str, index: usize) -> i32 {
    let mut diff = 0;
    for i in index..域名() {
        if 域名s().nth(i).unwrap() != 域名s().nth(i).unwrap() {
            diff += 1;
        }
    }
    (diff + 1) as i32 / 2
}

fn main() {
    let s1 = String::from("abc");
    let s2 = String::from("bca");
    println!("{}", k_similarity(s1, s2));
    let s1 = String::from("ab");
    let s2 = String::from("ba");
    println!("{}", k_similarity(s1, s2));
}

c完整代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Node {
    int cost; // 代价，已经换了几回了！
    int guess;// 猜测还要换几回，能变对！
    int where;// 有必须去比对的下标，左边不再换了！
    char* str; // 当前的字符
} Node;

int CompareNode(const void* a, const void* b) {
    Node* pa = (Node*)a;
    Node* pb = (Node*)b;
    return (pa->cost + pa->guess) - (pb->cost + pb->guess);
}

void swap(char* a, char* b) {
    char tmp = *a;
    *a = *b;
    *b = tmp;
}

int evaluate(char* s1, char* s2, int index, int len) {
    int diff = 0;
    for (int i = index; i < len; i++) {
        if (s1[i] != s2[i]) {
            diff++;
        }
    }
    return (diff + 1) / 2;
}

void add(char* add, char* s2, int cost, int index, Node* heap, int heapSize,
    char** visited, int* visitedSize) {
    for (int i = 0; i < *visitedSize; i++) { // 判断是否已经访问过
        if (strcmp(add, visited[i]) == 0) {
            return;
        }
    }
    Node next;
    域名 = cost;
    域名s = evaluate(add, s2, index, strlen(add));
    域名e = index;
    域名 = _strdup(add);
    heap[heapSize] = next;
    qsort(heap, heapSize + 1, sizeof(Node), CompareNode); // 排序小根堆
    visited[*visitedSize] = _strdup(add);
    (*visitedSize)++;
}

int kSimilarity(char* s1, char* s2) {
    int len = strlen(s1);
    Node* heap = (Node*)malloc(sizeof(Node) * len * len); // 分配空间
    int heapSize = 0;
    char** visited = (char**)malloc(sizeof(char*) * len * len); // 分配空间
    int visitedSize = 0;
    add(s1, s2, 0, 0, heap, heapSize++, visited, &visitedSize);

    while (heapSize > 0) {
        Node cur = heap[0];
        Node tmp = heap[--heapSize]; // 最后一个节点移到根节点，并下移
        heap[0] = tmp;
        int index = 0;
        while (index * 2 + 1 < heapSize) {
            int left = index * 2 + 1;
            int right = index * 2 + 2;
            int min = left;
            if (right < heapSize && (heap[right].cost + heap[right].guess) < (heap[left].cost + heap[left].guess)) {
                min = right;
            }
            if ((heap[index].cost + heap[index].guess) > (heap[min].cost + heap[min].guess)) {
                tmp = heap[index];
                heap[index] = heap[min];
                heap[min] = tmp;
                index = min;
            }
            else {
                break;
            }
        }
        if (strcmp(域名, s2) == 0) {
            int cost = 域名;
            free(域名);
            for (int i = 0; i < heapSize; i++) {
                free(heap[i].str);
            }
            free(heap); // 释放内存
            for (int i = 0; i < visitedSize; i++) {
                free(visited[i]);
            }
            free(visited);
            return cost;
        }
        int firstDiff = 域名e;
        while (域名[firstDiff] == s2[firstDiff]) {
            firstDiff++;
        }
        for (int i = firstDiff + 1; i < len; i++) {
            if (域名[i] == s2[firstDiff] && 域名[i] != s2[i]) {
                char* newStr = _strdup(域名); // 复制字符串
                swap(&newStr[firstDiff], &newStr[i]); // 交换字符
                add(newStr, s2, 域名 + 1, firstDiff + 1, heap, heapSize++, visited, &visitedSize); // 加入新节点
                swap(&newStr[firstDiff], &newStr[i]); // 恢复字符串
            }
        }
        free(域名);
    }

    for (int i = 0; i < heapSize; i++) {
        free(heap[i].str);
    }
    free(heap); // 释放内存
    for (int i = 0; i < visitedSize; i++) {
        free(visited[i]);
    }
    free(visited);

    return -1;
}

int main() {
    char s1[] = "abc";
    char s2[] = "bca";
    printf("%d\n", kSimilarity(s1, s2));
    char s3[] = "ab";
    char s4[] = "ba";
    printf("%d\n", kSimilarity(s3, s4));
    return 0;
}

c++完整代码如下：

#include <iostream>
#include <string>
#include <queue>
#include <unordered_set>

using namespace std;

struct Node {
    int cost; // 代价，已经换了几回了！
    int guess;// 猜测还要换几回，能变对！
    int where;// 有必须去比对的下标，左边不再换了！
    string str; // 当前的字符

    Node(int r, int g, int i, string s) : cost(r), guess(g), where(i), str(s) {}
};

struct CompareNode {
    bool operator()(const Node& a, const Node& b) {
        return (域名 + 域名s) > (域名 + 域名s); // 小根堆
    }
};

void swap(char& a, char& b) {
    char tmp = a;
    a = b;
    b = tmp;
}

int evaluate(string s1, string s2, int index) {
    int diff = 0;
    for (int i = index; i < 域名(); i++) {
        if (s1[i] != s2[i]) {
            diff++;
        }
    }
    return (diff + 1) / 2;
}

void add(string add, string s2, int cost, int index, priority_queue<Node, vector<Node>, CompareNode>& heap,
    unordered_set<string>& visited) {
    if (!域名t(add)) {
        域名(Node(cost, evaluate(add, s2, index), index, add));
    }
}

int kSimilarity(string s1, string s2) {
    int len = 域名();
    priority_queue<Node, vector<Node>, CompareNode> heap;
    unordered_set<string> visited;
    域名(Node(0, 0, 0, s1));
    while (!域名y()) {
        Node cur = 域名();
        域名();
        if (域名t(域名)) {
            continue;
        }
        if (域名 == s2) {
            return 域名;
        }
        域名rt(域名);
        int firstDiff = 域名e;
        while (域名[firstDiff] == s2[firstDiff]) {
            firstDiff++;
        }
        string curStr = 域名;
        for (int i = firstDiff + 1; i < len; i++) {
            if (curStr[i] == s2[firstDiff] && curStr[i] != s2[i]) {
                swap(curStr[firstDiff], curStr[i]);
                add(curStr, s2, 域名 + 1, firstDiff + 1, heap, visited);
                swap(curStr[firstDiff], curStr[i]);
            }
        }
    }
    return -1;
}



int main() {
    string s1 = "abc";
    string s2 = "bca";
    cout << kSimilarity(s1, s2) << endl;
    s1 = "ab";
    s2 = "ba";
    cout << kSimilarity(s1, s2) << endl;
}