两个字符串的排列差。用go语言，给定两个字符串 s 和 t，每个字符串中的字符都是唯一的，并且 t 是 s 的一种排列。
我们定义 排列差 为 s 和 t 中每个字符在两个字符串中位置的绝对差值的总和。
请计算并返回 s 和 t 之间的排列差。
1 <= s.length <= 26。
每个字符在 s 中最多出现一次。
t 是 s 的一个排列。
s 仅由小写英文字母组成。
输入：s = "abc", t = "bac"。
输出：2。
解释：
对于 s = "abc" 和 t = "bac"，排列差是：
1."a" 在 s 中的位置与在 t 中的位置之差的绝对值。
2."b" 在 s 中的位置与在 t 中的位置之差的绝对值。
3."c" 在 s 中的位置与在 t 中的位置之差的绝对值。
即，s 和 t 的排列差等于 |0 - 1| + |1 - 0| + |2 - 2| = 2。
大体步骤如下：
1.创建一个映射char2index，用来记录s字符串中每个字符对应的索引位置。
2.初始化排列差的总和sum为0。
3.遍历字符串t中的每个字符c，计算该字符在t中的索引位置i和在s中对应字符c在s中的索引位置char2index[c]之差的绝对值，加到sum中。
4.返回sum作为s和t之间的排列差。
时间复杂度分析：
- 遍历s字符串构建char2index映射的时间复杂度：O(s)，其中s是字符串s的长度。
- 遍历t字符串计算排列差总和的时间复杂度：O(t)，其中t是字符串t的长度。
总的时间复杂度：O(s + t)
空间复杂度分析：
- 使用一个char2index映射来存储字符到索引位置的映射，空间复杂度为O(26)，因为每个小写字母最多26个。
- 使用了常数级额外空间来存储sum和局部变量。
总的额外空间复杂度：O(1)
Go完整代码如下：
package main
import (
"fmt"
"math"
)
func findPermutationDifference(s string, t string) int {
char2index := make(map[rune]int)
for i, c := range s {
char2index[c] = i
}
sum := 0
for i, c := range t {
sum += int(math.Abs(float64(i - char2index[c])))
}
return sum
}
func main() {
s := "abc"
t := "bac"
fmt.Println(findPermutationDifference(s, t))
}
Rust完整代码如下：
use std::collections::HashMap;
fn find_permutation_difference(s: &str, t: &str) -> i32 {
let mut char_to_index: HashMap<char, usize> = HashMap::new();
for (i, c) in s.chars().enumerate() {
char_to_index.insert(c, i);
}
let mut sum = 0;
for (i, c) in t.chars().enumerate() {
if let Some(&index) = char_to_index.get(&c) {
sum += (i as i32 - index as i32).abs();
}
}
sum
}
fn main() {
let s = "abc";
let t = "bac";
println!("{}", find_permutation_difference(s, t));
}
