leetCode刷题归纳-Dynamic Programming(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]:
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].
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.

输出样例

---

这个锁的形状是这样的。。。

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.

解题思路

---

大概的说就是一个转锁的游戏，可以正向转，也可以反向转，那么怎么转才能次数最少呢？（话说这个转锁的也真是懒哭了。。。）很明显这里是一个求最优路径的题目，我们采取动态规划的思想：

//比较清晰的动态规划解法，可以有效解决递归次数太多时空复杂度高的问题


class Solution {
public:
    int findRotateSteps(string ring, string key) {
        int size = ring.size();
        int ksize = key.size();
        unordered_map<char,vector<int>> mp;//stored index of each characters in ring,pay attention to duplcate characters.
        for(int i=0;i<size;++i){
            mp[ring[i]].push_back(i);
        }

        vector<vector<int>> dp(ksize+1,vector<int> (size,INT_MAX));// initializing dp vector 
        fill(dp[0].begin(),dp[0].end(),0);

        vector<int> tmp(1,0);// starting index

        int res = INT_MAX;
        for(int i=1;i<=ksize;++i){
            for(auto it:mp[key[i-1]]){  //
                for(int j=0;j<tmp.size();++j){  //Search The shortest distance key[i-1] in ring
                    int minDist = min((tmp[j] + size -it)%size,(it + size - tmp[j])%size) + dp[i-1][tmp[j]];// Look at the above explanation//设置0状态的意义在于在开始的第一个点没有先前的状态
                    dp[i][it] =min(dp[i][it],minDist);
                    res = (i!=ksize?res:min(res,dp[i][it])); //Can we optimize it?
                }
            }
            tmp = mp[key[i-1]]; //next start is the characters we search in this time
        }
        return res + ksize;
    }
};

基于递归的解法，但是数据量太大的时候会超时，很难Ac。。。
public:
    int getClkLen(int pt,string ring,char curKey){
        int cnt=0;
        while(ring[pt]!=curKey){
            pt=(pt+1==rs)?0:pt+1;
            cnt++;
        }
        return cnt;
    }
    int getAtClkLen(int pt,string ring,char curKey){
        int cnt=0;
        while(ring[pt]!=curKey){
            pt=(pt==0)?rs-1:pt-1;
            cnt++;
        }
        return cnt;
    }

    void findMin(int pt,string ring,string key,int idx,int sol){
         if(idx==ks)    {res=min(res,sol); return; }//搜完了对比结果
         int cl=getClkLen(pt,ring,key[idx]);
         int acl=getAtClkLen(pt,ring,key[idx]);
         int ptClk=(pt+cl+rs)%rs,ptAtClk=(pt-acl+rs)%rs;
         findMin(ptClk,ring,key,idx+1,sol+cl+1);//正向搜
         findMin(ptAtClk,ring,key,idx+1,sol+acl+1);//反向搜
    }

    int findRotateSteps(string ring, string key) {
        ks=key.size();rs=ring.size();
        res=INT_MAX;
        findMin(0,ring,key,0,0);
        return res;
    }
private:
    int ks,rs,res;