514. Freedom Trail

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 in order to open the door.

Given a string ring, which represents the code engraved on the outer ring and another string key, which represents the keyword needs to be spelled. You need to find the minimum number of steps in order to spell all the characters in the keyword.

Initially, the first character of the  ring  is aligned at 12:00 direction. You need to spell all the characters in the string  key  one by one by rotating the ring clockwise or anticlockwise to make each character of the string  key  aligned at 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 one place, which counts as 1 step. The final purpose of the rotation is to align one of the string ring's characters at the 12:00 direction, where this character must equal to the character key[i].
2. If the character key[i] has been aligned at the 12:00 direction, you need to press the center button to spell, which also counts as 1 step. After the pressing, you could begin to spell the next character in the key (next stage), otherwise, you've finished all the spelling.

Example:

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.

Note:

1. Length of both ring and key will be in range 1 to 100.
2. There are only lowercase letters in both strings and might be some duplcate characters in both strings.
3. It's guaranteed that string key could always be spelled by rotating the string ring.

Subscribe to see which companies asked this question.

题目说的挺玄乎的，其实就相当于按照key字符串的字符走，求最少的步数，不过是能往两边走。用动态规划的方法，用一个表记录下每一个字母出现的地方。每一次要走到下一个字符，这个字符可能对应若干个位置，对于每一个位置，可以根据上一个字符的位置（可能有多个）和该位置的最少步数求出到现在这个位置的最少步数（要考虑往两边走的情况）。然后下一个字符也是这样的套路。直到最后求到了最后一个字符的所有位置的最少步数。求其中的最小值即可，注意最后返回的值要加上key字符串的长度，因为“读”字符也算一步。

代码：

class Solution {
public:
    int findRotateSteps(string ring, string key) {
        int rlen = ring.size(), klen = key.size();
        if(rlen == 0 || klen == 0) return 0;
        
        vector<vector<int> >mp(26, vector<int>());
        for(int i = 0; i < rlen; ++i)
        {
        	mp[ring[i]-'a'].push_back(i);
		}
		
		vector<int> prev(1, 0);
		vector<int> best(rlen, INT_MAX);
		best[0] = 0;
		for(int i = 0; i < klen; ++i)
		{
			vector<int> tmp_best(rlen, INT_MAX);
			vector<int> next;
			for(auto p:prev)
			{
				for(auto c:mp[key[i]-'a']) 
				{
					int cost = min((c-p+rlen)%rlen, (p-c+rlen)%rlen) + best[p];
					tmp_best[c] = min(tmp_best[c], cost);
				}
			}
			best = tmp_best;
			prev = mp[key[i]-'a'];
		}
		
		int res = INT_MAX;
		for(auto b:best)
		{
			res = min(res, b);
		}
		return res + klen;
    }
};