【力扣 leetcode】1239：串联字符串的最大长度

妖狐艹你老母 2023-10-09 14:51 8阅读 0赞

#### 文章目录 ####

*  每日进步
 *  题目
 *  题解

## 每日进步 ##

*  **列表操作：**
    
     *  取元素：`list.get(i)`
     *  增加元素：`list.add(x)`
 *  **String操作：**
    
     *  求长度：`str.length()`
     *  转换为字符串：`String.valueOf()`
     *  是否包含子串：`str.contains(son)`
     *  子串第一次出现的位置：`str.indexOf(son)`
     *  子串最后一次出现的位置：`str.lastIndexOf(son)`

## 题目 ##

给定一个字符串数组 arr，字符串 s 是将 arr 的含有 不同字母 的 子序列 字符串 连接 所得的字符串。

请返回所有可行解 s 中最长长度。

子序列 是一种可以从另一个数组派生而来的数组，通过删除某些元素或不删除元素而不改变其余元素的顺序。

*  **示例 1：**
    
     *  输入：arr = \[“un”,“iq”,“ue”\]
     *  输出：4
     *  解释：所有可能的串联组合是：
        
         *  “”
         *  “un”
         *  “iq”
         *  “ue”
         *  “uniq” (“un” + “iq”)
         *  “ique” (“iq” + “ue”)
         *  最大长度为 4。
 *  **示例 2：**
    
     *  输入：arr = \[“cha”,“r”,“act”,“ers”\]
     *  输出：6
     *  解释：可能的解答有 “chaers” 和 “acters”。
 *  **示例 3：**
    
     *  输入：arr = \[“abcdefghijklmnopqrstuvwxyz”\]
     *  输出：26
 *  **提示：**
    
     *  1 <= arr.length <= 16
     *  1 <= arr\[i\].length <= 26
     *  arr\[i\] 中只含有小写英文字母

> 来源：力扣（LeetCode）  
> 链接：https://leetcode.cn/problems/maximum-length-of-a-concatenated-string-with-unique-characters  
> 著作权归领扣网络所有。本文仅供个人学习，非商用。

## 题解 ##

思想很简单：

1.  **第一轮**，假设最长的字符串一定包含列表中的**第一个元素**，我们从第2个元素开始判断能否和第1个元素合并。若能，我们可以合并得到一个新的字符串，但我们仍需要分别从合并该元素与不合并该元素两种情况出发查找满足合并规则的字符串；若不能，则不作操作。之后，再去判断第3个元素能否继续合并进来……依次对每个元素进行判断后，我们可以得到包含**第一个元素**的所有字符串。
2.  之后，从每一个元素开始分别进行上述过程，我们就可以得到所有符合题目要求的字符串。
3.  最后，从得到的字符串中找到最大的长度即可

class Solution {
        
        public int maxLength(List<String> arr) {
        
            String weget = arr.get(0);
            int max = 0;
    
            List<String> anses = new ArrayList<String>();
            for (int i = 0; i < arr.size(); i++){
        
                if (ifSame(arr.get(i)))
                    search(arr, arr.get(i), i+1, anses);
            }
    
            for (int i = 0; i < anses.size(); i++){
        
                if (max < anses.get(i).length())
                    max = anses.get(i).length();
            }
    
            return max;
        }
    
        // 判断两个字符串是否有相同的字符
        // 有相同字符，则返回false
        public boolean ifCat(String s1, String s2){
        
            char[] arr1 = s1.toCharArray();
            char[] arr2 = s2.toCharArray();
    
            for (int i = 0; i < arr2.length; i++){
        
                if (s1.contains(String.valueOf(arr2[i])))
                    return false;
            }
    
            return true;
        }
    
        // 判断一个字符串中是否有相同的字符
        // 有相同字符，则返回false
        public boolean ifSame(String str){
        
            for (int i = 0; i < str.length(); i++){
        
                String parti = String.valueOf(str.toCharArray()[i]);
                if (str.indexOf(parti) != str.lastIndexOf(parti))
                    return false;
            }
            return true;
        }
    
        // 采用回溯算法寻找可行的字符串
        public void search(List<String> arr, String weget, int i, List<String> anses){
        
            if (i >= arr.size()){
        
                anses.add(weget);
                return;
            }
            
            for (int j = i; j < arr.size(); j++){
        
                if (ifCat(weget, arr.get(j)) && ifSame(arr.get(j))){
        
                    String newget = weget + arr.get(j);
                    search(arr, newget, j+1, anses);
                }else{
        
                    continue;
                }
            }
            
            search(arr, weget, i+1, anses);
        }
    }