用于计算字符串的最大可能长度的算法

如何解决用于计算字符串的最大可能长度的算法

问题：

给出一个字符串数组arr。字符串s是具有唯一字符的arr子序列的串联。

返回s的最大可能长度

示例：

Input: arr = ["un","iq","ue"]
Output: 4
Explanation: All possible concatenations are "","un","ue","uniq" and "ique".
Maximum length is 4.

Input: arr = ["cha","r","act","ers"]
Output: 6
Explanation: Possible solutions are "chaers" and "acters".

我的解决方案：

var maxLength = function(arr) {
    if(!arr || arr.length === 0)    return 0;
    
    let word = "";
    arr.sort((a,b) => b.length - a.length);
    let set = new Set();
    
    const removeFromSet = (str) => {
        for(let i=0; i<str.length; i++) {
            set.delete(str[i]);
        }
    }
    
    const isInSet = (str) => {
        for(let i=0; i<str.length; i++) {
            if(set.has(str[i])) {
                removeFromSet(str.substring(0,i));
                return true;
            }
            else 
                set.add(str[i]);
        }
        return false
    }
    
    for(let i=0; i<arr.length; i++) {
        if(!isInSet(arr[i])) {
            word += arr[i];
        }
    }
    
    return word.length;
};

输入失败：["ab","cd","cde","cdef","efg","fgh","abxyz"] 它应该返回11，但是我的解决方案返回9。

我知道我的解决方案正在计算：“ abxyzcdef”，它应该是：“ abxyzfghcde”。有人知道我在做什么错吗？

谢谢

解决方法

Hole算法是递归的，仅从字符串数组开始。如果未定义第二个参数str，则将其设置为空strin（仅在开始时）。
遍历字符串数组外观是否存在构建的字符串。如果是这样，则将新的测试字符串拆分为char，然后查看是否在构建的字符串中包含至少一个char（带有Array#some）。如果此条件正确，那么字符串将不包含唯一字符，因此我们可以继续。否则，这可能是迄今为止的解决方案。
现在取出数组，并删除所有已尝试过的测试字符串（包括实际测试的字符串），因为使用它们进行测试没有用。使用缩短的字符串数组递归调用算法本身，并使用实际的teststring扩展字符串。
查看acual测试字符串的长度加上recursiv调用的返回值是否大于最大值，而不是实际实现。
遍历数组中的所有测试环后，返回允许的字符串的最大长度。

扩展：我一开始会使用Array.filter检查所有字符串是否包含多个相同字符的单词，例如'abba'不会被测试。

function maxLength(array,str) {
       if (str === undefined) {
           str = '';
           array = array.filter(elem => elem.split('').every((char,key) => !(elem.slice(key+1)).includes(char)));
    };
    array = array.filter(elem => elem.split('').every((char,key) => !(elem.slice(key+1)).includes(char)));
    let max=0;
    for (let i=0; i<array.length; i++) {
        let test= array[i];
        if (str.length && test.split('').some(char => str.includes(char))) {
             continue;
        } else {
            let len = test.length + maxLength(array.slice(i),str + test);
            if (len>max) max=len;
        }
    }
    return max;
}

console.log( maxLength(["un","iq","ue"]) );
console.log( maxLength(["cha","r","act","ers"]) );
console.log( maxLength(["ab","cd","cde","cdef","efg","fgh","abxyz"]) );
console.log( maxLength(["yy","bkhwmpbiisbldzknpm"]) );

,

我发现了您的 逻辑故障：您只是直截了当，如果一个字符串不匹配，则将其遗漏并测试下一个，然后继续进行下去。 但是，如果一个字符串与您匹配从不，那么看是否有可能更好。

说明：
我会再解释一下。这些是您排序后的测试字符串：

["abxyz","ab","cd"]

您尝试了以下组合（首先是经过测试的好字符串，其次是您的实际候选人），然后是测试结果：

abxyz => ok
abxyz cdef => ok
abxyz cdef cde => false
abxyz cdef efg => false
abxyz cdef fgh => false
abxyz cdef ab => false
abxyz cdef cd => false

因此，您的最大长度为9（选择第一个和第二个字符串）。但是解决方案abxyz cde fgh不用关注。为此，您必须寻找较短的cdef而不是cde，将其与解决方案fgh结合使用。

这只是解释为何不起作用，但不您如何解决它；）。