【LeetCode】936. Stamping The Sequence 字符串敲章

0.概述

给你一个印章，上面印着一个字符串stamp，有一个目标字符串target，问能否用stamp敲出target，若两次敲stamp有字符重叠，那么后一个会覆盖前一个。

1.分析

我想了半天，最后发掘出来几个细节：
stamp的首尾元素一定和target相同。
target里面一定至少有一个与stamp相同的子串（子串要求是连续的，子序列则不要求），这个字串一定是最后盖的。
根据上面的思路，如果我找出那个完全相同的子串，然后以这个子串为根，向左右蔓延，能得到target，就说明能盖出来。
我这种方法可以过162个case，剩下的过不去，因为我这个没法处理有多个子串的情况。如下：
target=ddeddeddee
stamp=de
那么我的算法会以第一个de为根向左右蔓延，遇到ddee我会认为是无法盖出来的：
de
dee
无法盖出来ddee，所以我返回错误。
实际上倒数第一个de也可以作为根，那么就可以造出ddee了。
所以说我就没考虑这种情况，然后我发现了，但是我的代码太繁琐了，我都要改吐了，不改了。直接去看正确思路。
正确思路是首先把相同子串全变为*，将*视作任意字符参与匹配，匹配成功的再变成*，最后要是都是*，那么就算成功。
这个顺序怎么看呢？
就把匹配的过程reverse就好。

d d e d d e d d e e
d * * d * * d * * e -> 1 4 7
* * * d * * d * * e -> 0
* * * * * * d * * e -> 3
* * * * * * * * * e -> 6
* * * * * * * * * * -> 8

现在结果中是1，4，7，0，3，6，8
reverse一下是8，6，3，0，7，4，1

2.总结

我没有触及到问题的本质，本质上应该是倒着找，我只把最后一步的一部分倒过来了，没有抓住精髓，很是遗憾。
PS：代码如下：

// @lc code=start
class Solution {
public:
    vector<int> movesToStamp(string stamp, string target) {
        const int N = target.length(), M = stamp.length();
        vector<int> res;
        vector<bool> visited(N);
        int total = 0;
        const auto un_stamp = [&](int s) {
            int l = M;
            for (int i = 0; i < M; ++i) {
                if (target[s + i] == '*') --l;
                else if (target[s + i] != stamp[i]) return 0;
            } 
            if (l != 0) fill(begin(target) + s, begin(target) + s + M, '*');
            return l;
        };
        while (total < N) {
            bool found = false;
            for (int i = 0; i <= N - M; ++i) {
                if (visited[i]) continue;
                int l = un_stamp(i);
                if (l == 0) continue;
                visited[i] = true;
                total += l;
                res.push_back(i);
                found = true;
            }
            if (!found) return {};
        }
        reverse(begin(res), end(res));
        return res;
    }
};