Add solution and test-cases for problem 514

Author: 0xff-dev

leetcode/501-600/0514.Freedom-Trail/README.md

@@ -1,28 +1,37 @@
 # [514.Freedom Trail][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
+In the video game Fallout 4, the quest **"Road to Freedom"** requires players to reach a metal dial called the **"Freedom Trail Ring"** and use the dial to spell a specific keyword to open the door.
 
-**Example 1:**
+Given a string `ring` that represents the code engraved on the outer ring and another string `key` that represents the keyword that needs to be spelled, return the minimum number of steps to spell all the characters in the keyword.
 
-```
-Input: a = "11", b = "1"
-Output: "100"
-```
+Initially, the first character of the ring is aligned at the `"12:00"` direction. You should spell all the characters in `key` one by one by rotating `ring` clockwise or anticlockwise to make each character of the string key aligned at the `"12:00"` direction and then by pressing the center button.
+
+At the stage of rotating the ring to spell the key character `key[i]`:
+
+1. You can rotate the ring clockwise or anticlockwise by **one place**, which counts as one step. The final purpose of the rotation is to align one of `ring`'s characters at the `"12:00"` direction, where this character must equal `key[i]`.
+2. If the character `key[i]` has been aligned at the `"12:00"` direction, press the center button to spell, which also counts as **one step**. After the pressing, you could begin to spell the next character in the key (next stage). Otherwise, you have finished all the spelling.
 
-## 题意
-> ...
+**Example 1:**  
 
-## 题解
+![1](./ring.jpeg)
 
-### 思路1
-> ...
-Freedom Trail
-```go
 ```
+Input: ring = "godding", key = "gd"
+Output: 4
+Explanation:
+For the first key character 'g', since it is already in place, we just need 1 step to spell this character. 
+For the second key character 'd', we need to rotate the ring "godding" anticlockwise by two steps to make it become "ddinggo".
+Also, we need 1 more step for spelling.
+So the final output is 4.
+```
+
+**Example 2:**
 
+```
+Input: ring = "godding", key = "godding"
+Output: 13
+```
 
 ## 结语
 

leetcode/501-600/0514.Freedom-Trail/Solution.go

@@ -1,5 +1,46 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(ring string, key string) int {
+	// 感觉是dfs+cache实现
+	pos := [26][]int{}
+	for i := 0; i < 26; i++ {
+		pos[i] = make([]int, 0)
+	}
+	for i, r := range ring {
+		pos[r-'a'] = append(pos[r-'a'], i)
+	}
+	lr := len(ring)
+	lk := len(key)
+	cache := make([][]int, lr)
+	for i := 0; i < lr; i++ {
+		cache[i] = make([]int, lk)
+	}
+
+	var dfs func(int, int) int
+	dfs = func(keyIndex, ringIndex int) int {
+		if keyIndex == len(key) {
+			return 0
+		}
+		if cache[ringIndex][keyIndex] != 0 {
+			return cache[ringIndex][keyIndex]
+		}
+
+		curByte := key[keyIndex]
+		ans := -1
+		for _, idx := range pos[curByte-'a'] {
+			diff := ringIndex - idx
+			if diff < 0 {
+				diff = -diff
+			}
+			diff = min(lr-diff, diff)
+			diff++
+			steps := dfs(keyIndex+1, idx)
+			if ans == -1 || diff+steps < ans {
+				ans = diff + steps
+			}
+		}
+		cache[ringIndex][keyIndex] = ans
+		return ans
+	}
+	return dfs(0, 0)
 }

leetcode/501-600/0514.Freedom-Trail/Solution_test.go

@@ -9,31 +9,32 @@ import (
 func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
-		name   string
-		inputs bool
-		expect bool
+		name      string
+		ring, key string
+		expect    int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", "godding", "gd", 4},
+		{"TestCase2", "godding", "godding", 13},
+		{"TestCase3", "pqwcx", "cpqwx", 13},
+		{"TestCase4", "caotmcaataijjxi", "oatjiioicitatajtijciocjcaaxaaatmctxamacaamjjx", 137},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.ring, c.key)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v",
+					c.expect, got, c.ring, c.key)
 			}
 		})
 	}
 }
 
-//	压力测试
+// 压力测试
 func BenchmarkSolution(b *testing.B) {
 }
 
-//	使用案列
+// 使用案列
 func ExampleSolution() {
 }