514. Freedom Trail 【Hard】 动态规划

问题：给定一个圆环（初始字符为第一个）和一个字符串，进行如下操作直至打印出此字符串——

操作一：打印出圆环的第一个字符

操作二：把圆环顺时针或逆时针转一个位置

问打印此字符串最少需要多少步操作？

思路：用动归解决。将字符串拆分为单个字符，每一轮只考虑当前要打印的字符（假设为X）——对圆环上的每个X，求出其从上一轮到这一轮的最小距离dist（X）。

距离指圆环上的顺时针or逆时针最短距离。

如果是第一轮，那么每个X的dist（X）为它的位置到0的距离再加一（加一是因为要打印）

如果是第N轮（N>1），假设上一轮要打印的字符为S（则每个S都在上一轮都已经有一个dist值了），那么每个X的dist（X）为：它的位置到圆环上各个S的距离分别加上dist（S）的最小值，再加一（加一是因为要打印）

最终动归出最后一个字符Z，在dist（Z）中找到最小值打印出来就可以了。

难度还可以，主要是明确了思路就好了，时间都花在了debug上面。

vector<int> max_vector_initializer(100, 9999999);

int min_num(int x, int y) {
if (x > y) return y;
else return x;
}

int abs(int d) {
if (d > 0) return d;
else return -d;
}

int C2I(char c) {
return (int)(c - 'a');
}

int dist(int p1, int p2, int lr) {
int abs_dis = abs(p1 - p2);
return min_num(abs_dis, lr - abs_dis);
}

class Solution {
public:
int findRotateSteps(string ring, string key) {

vector<int> mapping[26];
int lr = ring.size();
int lk = key.size();
int pos;
for (int i = 0; i < lr; ++i) {
pos = C2I(ring[i]);
mapping[pos].push_back(i);
}

vector<int> a(100, 9999999);
vector<int> b(100, 9999999);
for (int it = 0; it < lk; ++it) {
b = a; // b is the previous state
a = max_vector_initializer; // initialize a to a max vector

int prev, next, d;
int prev_c = (it == 0 ? -1 : C2I(key[it - 1]));
int next_c = C2I(key[it]);
if (prev_c == -1) {
for (int j = 0; j < mapping[next_c].size(); ++j) {
next = mapping[next_c][j];
a[next] = dist(0, next, lr) + 1;
}
} else {
for (int i = 0; i < mapping[prev_c].size(); ++i) {
for (int j = 0; j < mapping[next_c].size(); ++j) {
prev = mapping[prev_c][i];
next = mapping[next_c][j];
d = dist(prev, next, lr);
a[next] = min_num(a[next], b[prev] + 1 + d);
}
}
}
}

int pos_c = C2I(key[lk - 1]);
int _min_ = 9999999;
for (int i = 0; i < mapping[pos_c].size(); ++i) {
pos = mapping[pos_c][i];
if (_min_ > a[pos]) {
_min_ = a[pos];
}
}
return _min_;

}
};