问题是在给定字符串s的情况下生成按字典顺序排列的最大字符串。 因此，目标是从s中找到字典上最大的，唯一的（无重复）子串s1。 我们说如果s1的字符多于s2，则某些子序列s1大于另一个子序列s2，或者如果s1的字典长度大于s2，则s1大于s2。
I / O如下：
输入是： ba bab
输出是：ba
第二个输入是：nlhthgrfdnnlprjtecpdr t higjoqdejsfka soc tjijaoebql r gaiakfsbljm p ib k ID Ĵ srtk的克 [R的 d 名词 q SK的 nb的的ARP 一 bgokbsr的 FHM eklr的文件
第二个输出是： 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);
}
}
答案 0 :(得分：2)
在以多种方式思考这个问题之后，我已经确定了一种分而治之的算法，可以得到正确的结果：
假设有一些输入字符串，S定义为两个子串A + B的串联，我们递归地计算按字典顺序排列的字符串：
LexMax(S) = Merge(LexMax(A),LexMax(B))
其中
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
在两个子字符串中，左侧子字符串中的e右侧找到更大的值，从左侧删除
f: fcda bcfed
在两个子字符串中，左子字符串中没有更大的值，从右侧删除
c: fcda bced
在两个子字符串中，左侧子字符串中的c右侧找到更大的值，从左侧删除
d: fda bced
在两个子字符串中，左子字符串中没有更大的值，从右侧删除
a: fda bce
不在两个子串中，什么都不做
最终结果：
LexMax(cefcfdabbcfed) = fdabce
答案 1 :(得分：1)
这不是一个直接的答案，但是这个代码是否符合您在上面的讨论中解释的要求？
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);
答案 2 :(得分：1)
词典顺序是一种顺序，其中单词使用单词中字母的外观按字母顺序显示。它也被称为字典顺序或字母顺序。例如： - ＆＃34; Africa＆＃34;小于＆＃34;孟加拉国＆＃34; ＆＃34;他＆＃34;小于＆＃34;他＆＃34;。
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));
}
}
供参考，请参阅此链接http://techno-terminal.blogspot.in/2015/09/java-program-to-find-lexicographically.html
答案 3 :(得分：0)
“tsrqponmlkjihgfedcba”不是答案，因为它不是输入的子序列。子序列的定义要求子序列的字符以原始序列以相同的顺序出现。例如，“abc”是“apbqcr”的子序列，而“cba”则不是。
至于解决方案，我认为一个简单的贪婪算法就足够了。首先，必须理解输出的最大可能长度是输入中唯一符号（例如，N）的数量。由于任何短于此的输出都不是最大的输出，因此它必须是N个符号长。其余的过程很简单，时间复杂度至多是二次方：一个必须通过输入字符串，并在每一步选择字典上最高的符号，使其左侧的字符串部分仍然包含所有“未使用的“符号。
举个例子，考虑一个字符串“bacb”。第一个符号可以是'a'或'b'，因为在两种情况下，余数都包含其他两个字母。 'b'更大，所以我们选择它。现在对于“acb”我们只能根据那个条件选择'a'而不是'c'，所以我们最终输出“bac”。
答案 4 :(得分：0)
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<>();
}
}