Java 最短超弦

我已经编写了一些代码，可以从一组值中计算出最短的超弦

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;



public class ShortestCommonSuperstringAlgorithm {

private void createSuperString(Set<String> subStrings) {
    int totalStrings = subStrings.size();
    String[] match = new String[totalStrings];
    int i = 0;

    for(String superString : subStrings) {

        Set<String> temp = new HashSet<String>(subStrings);
        String maxSuperString = superString;
        while(temp.size() > 1) {

            String subString = "";
            String nextMaxSuperString = maxSuperString;

            for(String nextString : temp) {

                if(!nextString.equals(nextMaxSuperString)) {

                    String superTemp = getSuperString(maxSuperString, nextString);
                    if (nextMaxSuperString.equals(maxSuperString) || nextMaxSuperString.length() > superTemp.length()) {
                        nextMaxSuperString = superTemp;
                        subString = nextString;
                    }
                }
            }

            temp.remove(maxSuperString);
            temp.remove(subString);
            maxSuperString = nextMaxSuperString;
            temp.add(maxSuperString);
        }

        match[i] = maxSuperString;
        //System.out.println(match[i]);
        i++;
    }

    String bestAns = match[0];

    for(i = 1; i < match.length; i++) {
        if(bestAns.length() > match[i].length()) {
            bestAns = match[i];
        }
    }

    System.out.println("Shortest Common Super String => " + bestAns);
    System.out.println("With a Length of             => " + bestAns.length());

}

private String getSuperString(String superString, String someString) {
    String result = superString;

    int endIndex = someString.length() - 1;

    while(endIndex > 0 && !superString.endsWith(someString.substring(0, endIndex)))  {
        endIndex--;
    }

    if(endIndex > 0) {
        result += someString.substring(endIndex);
    }
    else {
        result += someString;
    }

    return result;
}

public static void main(String arg[]) {

    Set<String> fragments = new HashSet<String>();
    ShortestCommonSuperstringAlgorithm superStringCreator = new ShortestCommonSuperstringAlgorithm();

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String input = "";
    int noOfFragments = 0;      // noOfFragments = m 

    // read input string, no. of fragments and their length

    try{
        System.out.println("Enter the no of Fragments : ");
        noOfFragments = Integer.parseInt(br.readLine());

        int size = 1;
        do{
            System.out.println(size + ". Fragment String : ");
            input = br.readLine();
            fragments.add(input);
            size++;
        }while(size<=noOfFragments);

    }catch(Exception ex){
        System.out.println("Please give correct Inputs.");
        ex.printStackTrace();
        return;
    }

    // find the shortest superstring
    superStringCreator.createSuperString(fragments);
    }
}

我需要计算的额外输出位应该如下所示

Solution = s[3]+s[0]+s[5]

---

任何帮助都将不胜感激

正如我所评论的，您的算法只找到和逼近最短超弦。正确（但速度慢得多）的算法大致如下：

• 初始化最佳排列=空，最短排列=无限
• 计算子串序列的所有排列（例如，使用堆算法）
• 对于每个排列，尽可能多地“挤压”邻居
• 如果结果大小小于最短\u大小，请为最短\u大小和最佳\u排列指定新值

在这个算法的最后，您将有最好的排列来输出您想要打印的内容

对于近似算法，创建一个自定义类CombinedString可能是最容易的，它可以记住它“吞下”了哪些子字符串

像

然后您的方法签名将更改为

private CombinedString getSuperString(CombinedString superString, CombinedString someString)

---

您的最终结果将是一个组合字符串，您可以从中轻松生成所需的输出。

是否

createSuperString

正确？对于

{“12”，“2”}

而言，输出为

“122”

。

“12”

不是一个较短的超弦吗？连接起来以创建最短的超弦«。。。我认为concatenated是个错误的词

{aa”，“ab”}

具有最短的超弦

“ab”

，但无法将

“aa”

和

“ab”

连接起来，从而得到

“aab”

。我想你的意思基本上是清楚的，除了一点：一个子串可以被“连接”多次吗？如果可以，该子串的计数频率是多少？你的算法使用了已知的贪婪近似，总是合并两个与剩余片段重叠最大的字符串。它不保证返回最短的通用超弦，有关详细信息，请参阅。什么是超弦？

class CombinedString {
   final String combinedValue;
   final String[] substrings;
   final int[] substringPositions;

   public CombinedString(String initial) {
       combinedValue = initial;
       substrings = {initial};
       substringPositions = [0]; // first string inserted at position 0
   }

   public CombinedString(CombinedString left, CombinedString right) {
       // ...
   }

   // ...
}

private CombinedString getSuperString(CombinedString superString, CombinedString someString)