Java 如何获得字符串中最长的递增子序列？

我对我的Java技能非常生疏，但我正试图编写一个程序，提示用户输入字符串并显示最大长度递增的有序字符子序列。例如，如果用户输入了

Welcome

，程序将输出

Welo

。如果用户输入了

wwellllcommeee

，程序仍将输出

Welo

。我已经做了这么多，但它没有做它应该做的，我真的不知道为什么

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

public class Stuff {

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.println("Please enter a string. ");
    String userString = input.next();
    ArrayList charList = new ArrayList();
    ArrayList finalList = new ArrayList();
    int currentLength = 0;
    int max = 0;

    for(int i = 0; i < userString.length(); i++){
        charList.add(userString.charAt(i));

        for(int j = i; j < userString.length(); j++){
            int k=j+1;
            if(k < userString.length() && userString.charAt(k) > userString.charAt(j)){
                charList.add(userString.charAt(j));
                currentLength++;
            }
        }
    }

    if(max < currentLength){
        max = currentLength;
        finalList.addAll(charList);
    }

    for (int i = 0; i < finalList.size(); i++){
        char item = (char) finalList.get(i);
        System.out.print(item);
    }

    int size1 = charList.size();
    int size2 = finalList.size();
    System.out.println("");
    System.out.println("Size 1 is: " + size1 + " Size 2 is : " + size2);    
  }
 }

import java.util.ArrayList；
导入java.util.Scanner；
公共类的东西{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（System.in）；
System.out.println（“请输入字符串”）；
String userString=input.next（）；
ArrayList charList=新的ArrayList（）；
ArrayList finalList=新的ArrayList（）；
int currentLength=0；
int max=0；
对于（int i=0；iuserString.charAt（j））{
add（userString.charAt（j））；
currentLength++；
}
}
}
如果（最大<当前长度）{
最大值=当前长度；
finalList.addAll（charList）；
}
对于（int i=0；i

我的代码，如果我输入

Welcome

，则输出

wweececlccome

---

有人知道我做错了什么吗？

在这种情况下，远离键盘，思考一下你试图实现的算法会有帮助。试着先用语言来解释它

通过在输入字符串中添加每个字符，然后在其右侧添加与其后续字符按正确字母顺序排列的字符，可以构建单个字符的列表。对于输入“欢迎”，这意味着累计输出将为，在垂直方向上显示外环，在水平方向上显示内环：

W W e c
e e c
l c
c c
o
m
e

---

总之：WWECECCCOME

我看不出这个实现的逻辑。这是一个在O（nlogn）时间内运行的更快的解决方案

import java.util.Scanner；
公共类的东西
{   
//返回不小于目标元素的第一个元素的索引
公共静态int-b搜索（字符[]arr，int-size，int-key）
{
int左=0；
int right=大小-1；
int mid；
while（左maxArr[len-1]）
{
maxArr[len]=userString.charAt（i）；
先例[len]=userString.charAt（i）；
len++；
}
其他的
maxArr[b搜索（maxArr，len，userString.charAt（i））]=userString.charAt（i）；
}
//系统输出打印项次（len）；
对于（int i=0；i

在词典编纂顺序中使用动态规划O（N^2）意味着如果i/p是abcccd，则O/p可以是abcccd、abbbcd、abbccd，但根据词典编纂顺序，O/p将是abbbcd

public static String longestIncreasingSubsequence(String input1) {
    int dp[] = new int[input1.length()];
    int i,j,max = 0;
    StringBuilder str = new StringBuilder();

    /* Initialize LIS values for all indexes */
     for ( i = 0; i < input1.length(); i++ )
        dp[i] = 1;

     /* Compute optimized LIS values in bottom up manner */
     for ( i = 1; i < input1.length(); i++ )
        for ( j = 0; j < i; j++ ) 
              if (input1.charAt(i) >= input1.charAt(j) && dp[i] < dp[j]+1)
                  dp[i] = dp[j] + 1;

     /* Pick maximum of all LIS values */
     for ( i = 0; i < input1.length(); i++ ) {
        if ( max < dp[i] ) {
             max = dp[i];
             if (i + 1 < input1.length() && max == dp[i+1] && input1.charAt(i+1) < input1.charAt(i)) {
                 str.append(input1.charAt(i+1));
                 i++;
             } else {
                 str.append(input1.charAt(i)); 
             }
        }
     }
     return str.toString();
}

publicstaticstringlongestincreasingsubsequence（stringinput1）{
int dp[]=new int[input1.length（）]；
int i，j，max=0；
StringBuilder str=新的StringBuilder（）；
/*初始化所有索引的LIS值*/
对于（i=0；i=input1.charAt（j）&dp[i]

您应该学习如何调试以找到自己的错误。使用集成在IDE中的调试功能，或者使用旧但功能强大的“system.out.print”来记录并查看代码出错的地方。祝你好运。加1表示远离键盘会有帮助。像这样的问题，在你实现之前，你应该知道你想要实现什么算法。算法在第一次尝试时不一定是正确的，但至少你有一个参考点。看看你的算法哪里有缺陷，或者看看你的实现与你的设计有什么不同。这个程序在

“banana”

上运行时返回的bn不正确。

public static String longestIncreasingSubsequence(String input1) {
    int dp[] = new int[input1.length()];
    int i,j,max = 0;
    StringBuilder str = new StringBuilder();

    /* Initialize LIS values for all indexes */
     for ( i = 0; i < input1.length(); i++ )
        dp[i] = 1;

     /* Compute optimized LIS values in bottom up manner */
     for ( i = 1; i < input1.length(); i++ )
        for ( j = 0; j < i; j++ ) 
              if (input1.charAt(i) >= input1.charAt(j) && dp[i] < dp[j]+1)
                  dp[i] = dp[j] + 1;

     /* Pick maximum of all LIS values */
     for ( i = 0; i < input1.length(); i++ ) {
        if ( max < dp[i] ) {
             max = dp[i];
             if (i + 1 < input1.length() && max == dp[i+1] && input1.charAt(i+1) < input1.charAt(i)) {
                 str.append(input1.charAt(i+1));
                 i++;
             } else {
                 str.append(input1.charAt(i)); 
             }
        }
     }
     return str.toString();
}