Java 生成按字典顺序排列的最大字符串

问题是在给定一些字符串s的情况下，生成按字典顺序排列的最大字符串。 因此，我们的目标是从s中找到词典学上最大、唯一（无重复）的子串s1。 我们说，如果s1的字符数大于s2，则某些子序列s1大于另一个子序列s2；如果长度相等，则s1在词典学上大于s2

输入输出如下：

输入为：babab

输出为：ba

第二个输入是：NLHTHGRFDNNLPRJTECPDRTHIGJOQDEJSFKASCOCTJIJAOEBQLRGAIAKFSBLJMPIBKIDJSRTKGRNDQSKNBARPABGOKBSRFHMEKLRLE

第二个输出是： tsocrpkijgdqnbafhmle

这是我为java代码编写的，但是我的代码在第二个测试用例中失败了。我也很难理解为什么第二个输出不是tsrqponmlkjihgfedcba。 有人能为修复甚至java代码提供建议吗

我认为该算法必须比生成所有可能的唯一字符串、对它们进行排序并找到按字典顺序排列的最大字符串更有效

为了让问题更清楚，如果输入是babab，那么所有可能的唯一组合将是b，a，ba，ab。输出将是ba，因为它是最长的，并且在字典上比ab大

注意：这不是家庭作业。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class mostBeautiful {
final static int MAX = 1000000;
static String[] permute;
static void permutation(String prefix, String str, int counter) {
    int n = str.length();
    //System.out.println("n is: "+ n);
    if (n == 0) {
        permute[counter] = prefix;
    } else {
        for (int i = 0; i < n; i++) {
            //System.out.println("str is: "+ str);
            permutation(prefix + str.charAt(i), str.substring(0, i) + str.substring(i+1, n), counter++);
        }
    }
}
public static void main(String[] args) throws IOException {
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    String s = bf.readLine();
    char[] unique = new char[26];
    int counter = 0;
    String answer = "";
    //System.out.println("s is: " + s);
    int ascii = 0;
    final int asciiAVal = 97;
    final int asciiZVal = 122;
    for (int i = 0; i < s.length(); i++) {
        ascii = (int)s.charAt(i);
        if (ascii < asciiAVal || ascii > asciiZVal) {
            continue;
        }
        char ch = s.charAt(i);
        unique[ch - 'a'] = ch;
    }
    String result = "";
    for (int j = 25; j >= 0; j--) {
        result += unique[j];
    }
    result = result.trim();
    System.out.println(result);
    int size = result.length() * (result.length() - 1);
    permute = new String[size];
    permutation("", result, counter);
    for (int i = 1; i < size; i++) {
        if (permute[i].compareTo(permute[i - 1]) > 0){
            answer = permute[i];
        }  else {
            answer = permute[i - 1];
        }

    }
    System.out.println("answer is: " + answer);
}

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
公共类最漂亮{
最终静态整数最大值=1000000；
静态字符串[]排列；
静态无效置换（字符串前缀、字符串str、int计数器）{
int n=str.length（）；
//System.out.println（“n为：+n”）；
如果（n==0）{
排列[计数器]=前缀；
}否则{
对于（int i=0；iasciiZVal）{
持续
}
char ch=s.charAt（i）；
唯一[ch-'a']=ch；
}
字符串结果=”；
对于（int j=25；j>=0；j--）{
结果+=唯一[j]；
}
result=result.trim（）；
系统输出打印项次（结果）；
int size=result.length（）*（result.length（）-1）；
排列=新字符串[大小]；
排列（“”，结果，计数器）；
对于（int i=1；i0{
答案=排列[i]；
}否则{
答案=排列[i-1]；
}
}
System.out.println（“答案是：“+答案”）；
}

---

}

这不是一个直接的答案，但这段代码不符合您在上面讨论中解释的要求吗

final String x = "saontehusanoethusnaoteusnaoetuh";
final SortedSet<Character> chars = 
   new TreeSet<Character>(Collections.reverseOrder());
for (char c : x.toCharArray()) chars.add(c);
System.out.println(chars);

final String x=“saontehusaneothusnaoteusnaotetuh”；
最终分拣集字符=
新树集（Collections.reverseOrder（））；
对于（char c:x.toCharArray（））chars.add（c）；
系统输出打印项次（字符）；

这不是一个直接的答案，但该代码是否符合您在上面讨论中解释的要求

final String x = "saontehusanoethusnaoteusnaoetuh";
final SortedSet<Character> chars = 
   new TreeSet<Character>(Collections.reverseOrder());
for (char c : x.toCharArray()) chars.add(c);
System.out.println(chars);

final String x=“saontehusaneothusnaoteusnaotetuh”；
最终分拣集字符=
新树集（Collections.reverseOrder（））；
对于（char c:x.toCharArray（））chars.add（c）；
系统输出打印项次（字符）；

“tsrqponmlkjihgfedcba”不是答案，因为它不是输入的子序列。子序列的定义要求子序列的字符以相同的顺序出现在原始序列中。例如，“abc”是“apbqcr”的子序列，而“cba”不是

至于解决方案，我认为一个简单的贪婪算法就足够了。首先，必须了解输出的最大可能长度是输入中唯一符号的数量（例如，N）。因为任何比这个短的输出都不是最大的输出，所以它必须正好有N个符号长。程序的其余部分很简单，时间复杂度最多是二次的：必须遍历输入字符串，并在每一步选择按字典顺序排列的最高符号，以便字符串左侧的部分仍然包含所有“未使用”的符号

作为一个例子，考虑一个字符串“BACB”。第一个符号可以是“a”或“b”，因为在这两种情况下，其余符号都包含其他两个字母。”b'更大，所以我们选择它。现在，对于“acb”，我们只能根据该条件选择“a”而不是“c”，因此我们以“bac”作为输出。

“TSRQPONLKJIHGFEDCBA”不是答案，因为它不是输入的子序列。子序列的定义要求子序列的字符以相同的顺序出现在原始序列中。例如，“abc”是“apbqcr”的子序列，而“cba”不是

至于解决方案，我认为一个简单的贪婪算法就足够了。首先，必须了解输出的最大可能长度是输入中唯一符号的数量（例如，N）。因为任何比这个短的输出都不是最大的输出，所以它必须正好有N个符号长。程序的其余部分很简单，时间复杂度最多是二次的：必须遍历输入字符串，并在每一步选择按字典顺序排列的最高符号，以便字符串左侧的部分仍然包含所有“未使用”的符号

作为一个例子，考虑一个字符串“BACB”。第一个符号可以是“a”或“b”，因为在这两种情况下，其余符号都包含其他两个字母。”b'更大，所以我们选择它。现在，对于“acb”，我们只能选择“a”而不是“c”

LexMax(S)
{
    if Length(S) = 1
        return S
    else
    {
        LMA = LexMax(S[0:Length/2])
        LMB = LexMax(S[Length/2:end])
        return Merge(LMA,LMB)
    }
}

Merge(A,B)
{
    Sa = A
    Sb = B

    for n = 0:Length(A)
    {
        if Sb contains A[n]
        {
            if A[n+1:end] contains character > A[n]
                Remove A[n] from Sa
            else
                Remove A[n] from Sb
        }
    }

    return Sa + Sb
}

cefcfdabbcfed

cefcfda
bbcfed

LexMax("cefcfda") = "efcda"
LexMax("bbcfed") = "bcfed"

e: efcda bcfed

f: fcda bcfed

c: fcda bced

d: fda bced

a: fda bce

LexMax(cefcfdabbcfed) = fdabce

 public class LexicographicExample {  
      public static void main(String a[]) {  
           Scanner sc = new Scanner(System.in);  
           System.out.println("Enter the String:-");  
           String str = sc.nextLine();  
           System.out.println("Enter the length");  
           int count = sc.nextInt();  
           List<String> list = new ArrayList<String>();  
           for (int i = 0; i < str.length(); i = i + 1) {  
                if (str.length() - i >= count) {  
                     list.add(str.substring(i, count + i));  
                }  
           }  
           Collections.sort(list);  
           System.out.println("Smallest subString:-" + list.get(0));  
           System.out.println("Largest subString:-" + list.get(list.size() - 1));  
      }  
 }  

        import java.util.ArrayList;
        import java.util.HashMap;
        import java.util.Scanner;

        class aaa {
            public static void main(String args[]) throws Exception {
                Scanner scan = new Scanner(System.in);

                // int n = scan.nextInt();
                String s = scan.next();

                HashMap<Character, Node5> map = new HashMap<>();

                for (int i = 0; i < s.length(); i++) {
                    if (!map.containsKey(s.charAt(i))) {
                        Node5 node = new Node5();
                        node.nl.add(i);
                        node.li = i;
                        map.put(s.charAt(i), node);
                    } else {
                        Node5 rn = map.get(s.charAt(i));
                        rn.nl.add(i);
                        rn.li = i;
                        map.put(s.charAt(i), rn);
                    }
                }

                String s1 = "";
                int index = -1;
                for (int i = 25; i >= 0; i--) {
                    if (map.containsKey((char) (97 + i))) {
                        if (map.get((char) (97 + i)).li > index) {
                            for (int j = 0; j < map.get((char) (97 + i)).nl.size(); j++) {
                                if (map.get((char) (97 + i)).nl.get(j) > index) {
                                    s1 += (char) (97 + i);
                                    index = map.get((char) (97 + i)).nl.get(j);
                                }
                            }
                        }
                    }

                }
                System.out.println(s1);
                scan.close();
            }


        }

        class Node5 {
            int li;
            ArrayList<Integer> nl;

            public Node5() {
                this.nl = new ArrayList<>();
            }
        }