某笔试：一道动态规划

LeetCode514. 自由之路

https://leetcode-cn.com/problems/freedom-trail/

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

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

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

旋转 ring 拼出 key 字符 key[i] 的阶段中：

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

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

思路

本题的难点在于ring字符数组是一个环形数组。求解本题的一个基本步骤是计算ring字符数组中一个字符到达另一个字符所需的步数。假设ring字符数组的长度为rSize计算ring[i] 到达 ring[j] 所需的步数，那么在环形数组中，

该步数 = min((j - i + rSize) % rSize, (i - j + rSize) % rSize)

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i] [j] 表示key[0 … i]用ring[0 … j] 表示所需要的操作次数

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

如果key[i]可以用ring[j]表示(即key[i] == ring[j])，那么就要去遍历一遍dp[i - 1] [k]，找到key[i - 1]可以用ring[k]表示的情况，这里0 <= k < rSize，最后计算ring[k] 到达 ring[j] 所需的步数 + 1

if (key[i] == ring[j]): dp[i] [j] = min(dp[i] [j], dp[i - 1] [k] + min((j - k + rSize) % rSize), (k - j + rSize) % rSize) + 1)，其中0 <= k < rSize

3.思考初始状态

ring字符数组的起始位置为0，如果key[0]可以用ring[j]表示(即key[0] == ring[j])，那么dp[0] [j]的值就是ring[0] 到达 ring[j] 所需的步数 + 1 。

if (key[0] == ring[j]): dp[0] [j] = min(j, rSize - j) + 1

4.自底向上计算得到最优解
5.思考是否可以进行空间的优化

代码

class Solution {
public:
    int findRotateSteps(string ring, string key) 
    {
        int kSize = key.size();
        int rSize = ring.size();

        vector<vector<int>> dp(kSize, vector<int>(rSize, INT_MAX));
        for (int j = 0; j < rSize; ++j)
        {
            if (key[0] == ring[j])
            {
                dp[0][j] = min(j, rSize - j) + 1;
            }
        }

        for (int i = 1; i < kSize; ++i)
        {
            for (int j = 0; j < rSize; ++j)
            {
                if (key[i] == ring[j])
                {
                    for (int k = 0; k < rSize; ++k)
                    {
                        if (dp[i - 1][k] != INT_MAX)
                        {
                            dp[i][j] = min(dp[i][j], dp[i - 1][k] + min((j - k + rSize) % rSize, (k - j +rSize) % rSize) + 1);
                        }
                    }
                }
            }
        }

        return *min_element(dp[kSize - 1].begin(), dp[kSize - 1].end());
    }
};