[Leetcode]2014. 重复 K 次的最长子序列

【题目描述如下】

给你一个长度为 n 的字符串 s ，和一个整数 k 。请你找出字符串 s 中 重复 k 次的 最长子序列 。

子序列 是由其他字符串删除某些（或不删除）字符派生而来的一个字符串。

如果 seq * k 是 s 的一个子序列，其中 seq * k 表示一个由 seq 串联 k 次构造的字符串，那么就称 seq 是字符串 s 中一个 重复 k 次 的子序列。

• 举个例子，"bba" 是字符串 "bababcba" 中的一个重复 2 次的子序列，因为字符串 "bbabba" 是由 "bba" 串联 2 次构造的，而 "bbabba" 是字符串 "bababcba" 的一个子序列。

返回字符串 s 中 重复 k 次的最长子序列  。如果存在多个满足的子序列，则返回 字典序最大 的那个。如果不存在这样的子序列，返回一个 空 字符串。

 【分析】

 刚开始看这题目时，感觉场景很多，搜索空间很大；但是看了提示的数据量，觉得可以从暴力的角度尝试一下遍历字符串s的子集空间，从中选出符合要求的子字符串；

子集空间如何获取呢？首先，子集中的字符串必定满足以下两个条件：

1、组成子字符串的字符的频率大于等于k;

2、每个字符在子字符串出现的最大次数为freq/k;

其次，有了字符的范围，就可以求取所有字符的排列组合了；

清楚以上两点，此题的求解就可以分为以下三个步骤了：

1、挑出频率大于等于k的字符，注意有些字符在子字符串中可能出现freq/k次，所以这种字符填加freq/k个；

2、求出上面字符的所有排列组合；这里一开始用了回溯，发现不对，回溯对排列的顺序没有要求，但是此题对顺序是有要求的，所以可以用DFS或者BFS；

为了去除重复，可以用set存储，set的查找是Ologn，对性能有益；

3、遍历符合条件(属于s的子集，且重复k次依然属于s的子集)的排列，并取最长且字典序最大的排列；

【代码如下】

class Solution {
public:
    void DFS(set<string>& vs, string base, int len, string tmp, vector<bool> visited)
    {
        if (vs.count(tmp) > 0) {
            return;
        }
        // cout<<tmp<<endl;
        vs.insert(tmp);
        for (int i = 0; i < len; i++) {
            if (visited[i]) {
                continue;
            }
            tmp.push_back(base[i]);
            visited[i] = true;
            DFS(vs, base, len, tmp, visited);
            tmp.pop_back();
            visited[i] = false;
        }
    }
    bool Check(string& s, string& t, int k)
    {
        int j = 0;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == t[j]) {
                j++;
                if (j == t.size()) {
                    k--;
                    j = 0;
                }
            }
        }
        if (k <= 0) {
            return true;
        }
        return false;
    }
    string longestSubsequenceRepeatedK(string s, int k) {
        string res;
        map<char, int> mc;
        for (auto& c : s) {
            mc[c]++;
        }
        string base;
        for (auto [c, count] : mc) {
            if (count >= k) {
                int i = 0;
                while (i < count / k) {
                    base += c;
                    i++;
                }
            }
        }
        set<string> vs;
        string tmp;

        vector<bool> visited(base.size(), false);
        DFS(vs, base, base.size(), tmp, visited);

        int len = 0;
        for (auto str : vs) {
            if ((str.size() > len || str.size() == len && str > res) && Check(s, str, k)) {
                res = str;
                len = str.size();
            }
        }
        return res;
    }
};