LeetCode 514题----自由之路

电子游戏“辐射4”中，任务“通向自由”要求玩家到达名为“Freedom Trail Ring”的金属表盘，并使用表盘拼写特定关键词才能开门。

给定一个字符串 ring，表示刻在外环上的编码；给定另一个字符串 key，表示需要拼写的关键词。您需要算出能够拼写关键词中所有字符的最少步数。

最初，ring 的第一个字符与12:00方向对齐。您需要顺时针或逆时针旋转 ring 以使 key 的一个字符在 12:00 方向对齐，然后按下中心按钮，以此逐个拼写完 key 中的所有字符。

旋转 ring 拼出 key 字符 key[i] 的阶段中：您可以将 ring 顺时针或逆时针旋转一个位置，计为1步。旋转的最终目的是将字符串 ring 的一个字符与 12:00 方向对齐，并且这个字符必须等于字符 key[i] 。
如果字符 key[i] 已经对齐到12:00方向，您需要按下中心按钮进行拼写，这也将算作 1 步。按完之后，您可以开始拼写 key 的下一个字符（下一阶段）, 直至完成所有拼写。
示例：

输入: ring = “godding”, key = “gd”
输出: 4
解释:
对于 key 的第一个字符 ‘g’，已经在正确的位置, 我们只需要1步来拼写这个字符。
对于 key 的第二个字符 ‘d’，我们需要逆时针旋转 ring “godding” 2步使它变成 “ddinggo”。
当然, 我们还需要1步进行拼写。
因此最终的输出是 4。

提示：
ring 和 key 的字符串长度取值范围均为 1 至 100；
两个字符串中都只有小写字符，并且均可能存在重复字符；
字符串 key 一定可以由字符串 ring 旋转拼出。

**解题思路：**这个题的难点就在于你每次旋转，字符串就不一样了，所以第一感觉就是暴力递归，递归遍历出所有的结果，然后在结果中取较小的。

   
class Solution {
    public int findRotateSteps(String ring, String key) {
        char[] kcs=key.toCharArray();
        ArrayList<Integer> list=new ArrayList<>();
        def(kcs,ring,0,list,0);
        int res=list.get(0);
        for(int i=1;i<list.size();i++){
            res=Math.min(res,list.get(i));
        }
        return res;

    }

    public void def(char[] kcs,String key,int index,ArrayList<Integer> list,int count){
    //当key遍历完了就结束了
        if(index==kcs.length){
            list.add(count);
            return;
        }
        //逆时针选出所有可能的结果
        for(int i=0;i<key.length();i++){
            if(key.charAt(i)==kcs[index]){
                //key.substring(i,key.length())+key.substring(0,i)是逆时针之后所生成的新的字符串
                def(kcs,key.substring(i,key.length())+key.substring(0,i),index+1,list,count+i+1);
            }
        }
        //顺时针选出所有可能的结果
         for(int i=key.length()-1;i>=0;i--){
            if(key.charAt(i)==kcs[index]){
                def(kcs,key.substring(i,key.length())+key.substring(0,i),index+1,list,count+key.length()-i+1);
            }
        }
    }
}

暴力递归我尝试了很多测试用例是没有错的，假设ring.length()=n,key.length()=m，则暴力递归的时间复杂度为O(2mn*n)，超时。但是所有的递归都可以转化成动态规划。

动态规划解题思路：
动态规划最终要的就是要找到动态转移方程，对于一个从前一个字符f[i-1][j]跳转过来的f[i][k]，其中i表示key的第i个字符，k表示选择了ring里面的第k个字符，要走的步数有两种，一种是顺时针，一种逆时针

如图：从t---->h有两种走法：
1 t–>a–>f–>h 此时 步数为|a-b|，其中a、b分别为t和h的下标
2 t–>g–>a–>k–>h 此时步数为length-|a-b|，其中length为ring的长度
所以，f[i][k]=Math.min(f[i-1][j]+Math.min(Math.abs(a-b),length-Math.abs(a-b))+1,f[i][k])；
最后再遍历f[key.length()-1]找到最大值就可以啦。

```java
class Solution {
    public int findRotateSteps(String ring, String key) {
         //用一个列表数组来记录，因为有26个字符，但是不知道每个字符有多少个，所以数组里面是个列表
        ArrayList<Integer>[] points=new ArrayList[26];
        int n=ring.length(),m=key.length();
         //需要先统计每个字符的下标
        for (int i = 0; i < 26; ++i) {
            points[i] = new ArrayList<Integer>();
        }
        for(int i=0;i<n;i++){
            points[ring.charAt(i)-'a'].add(i);
        }
        int[][] f=new int[m][n];
        //给初始值赋值最大
        for(int i=0;i<m;i++){
            Arrays.fill(f[i],Integer.MAX_VALUE);
        }
        for(int i:points[key.charAt(0)-'a']){
            f[0][i]=Math.min(i,n-i)+1;
        }
        for(int i=1;i<m;i++){
        //前一个取到值下标进行遍历
            for(int temp:points[key.charAt(i-1)-'a']){
            //对当前相等字符的下标进行遍历
                for(int k:points[key.charAt(i)-'a']){
                    f[i][k]=Math.min(f[i-1][temp]+Math.min(Math.abs(temp-k)+1,n-Math.abs(temp-k)+1),f[i][k]);
                }
            }
        }
        int res=Integer.MAX_VALUE;
         //最后找到最大值
        for(int i=0;i<n;i++){
            res=Math.min(res,f[m-1][i]);
        }
        return res;

    }
}