Java 查找长度在x和y之间的最长重复子字符串

给定一个字符串：“blafblafblafbla”和2个限制：x=3，y=5 我想找到长度在x和y之间的最长重复子串。如果有很多，第一个 在我的例子中，那将是“废话” 几个问题： 1.使用正则表达式更容易吗？ 2.我知道如何找到最长的子串，但我必须把它的条件放在x和y之间的什么地方

public static String longestDuplicate(String text)
{
    String longest = "";
    for (int i = 0; i < text.length() - 2 * longest.length() * 2; i++)
    {
        OUTER: for (int j = longest.length() + 1; j * 2 < text.length() - i; j++)
        {
            String find = text.substring(i, i + j);
            for (int k = i + j; k <= text.length() - j; k++)
            {
                if (text.substring(k, k + j).equals(find))
                {
                    longest = find;
                    continue OUTER;
                }
            }
            break;
        }
    }
    return longest;
}

公共静态字符串最长重复（字符串文本）
{
字符串最长=”；
对于（int i=0；i对于（int k=i+j；k您提供的代码对于解决您的问题来说是一种极为低效的方法。我将使用或其他滚动哈希算法实现解决方案，这将使您能够以复杂性
O（（y-x）*L）
解决您的问题

这里不能使用正则表达式——它们用于解决完全不同的任务

<关于如何使用<强>您的解决方案< /强>找到长度在<代码> x和<代码> y>代码>之间的最长子串，只需修改循环<代码> j>代码>，只考虑区间<代码> [x，y] < /代码>中的值。
for (int j = Math.max(longest.length() + 1, x) ; j * 2 < text.length() - i && j < y; j++)

公共静态int commonPrefix（字符串、int x、int y）
{
intl=string.length（）；
int n=0；
int-oy=y；
而（x=maxLength）
返回string.substring（x，x+maxLength）；
如果（n>fl）
{
found=string.substring（x，x+n）；
fl=n；
}
}
发现退货；
}
公共静态void main（字符串[]args）{
System.out.println（longestrepreatingsubstring（“blafblafblafblaf”，3,5））；
}
下面是一个使用正则表达式的笨拙实现：

//import java.util.regex.*;

public static String longestRepeatingSubstring (String string, int min, int max)
{
  for (int i=max; i>=min; i--){
    for (int j=0; j<string.length()-i+1; j++){

      String substr = string.substring(j,j+i);
      Pattern pattern = Pattern.compile(substr);
      Matcher matcher = pattern.matcher(string);

      int count = 0;
      while (matcher.find()) count++;

      if (count > 1) return substr;
    }
  }

  return null;
}

public static void main(String[] args) {
  System.out.println (longestRepeatingSubstring ("blablafblafbla", 3, 5));
}

//导入java.util.regex.*；
公共静态字符串longestreatingsubstring（字符串字符串，int-min，int-max）
{
对于（int i=max；i>=min；i--）{
对于（int j=0；j 1）返回substr；
}
}
返回null；
}
公共静态void main（字符串[]args）{
System.out.println（longestrepreatingsubstring（“blafblafblafbla”，3,5））；
}
公共静态int getCount（字符串、字符串子字符串）{
整数计数=0；
int fromIndex=0；
做{
if（string.indexOf（subString，fromIndex）！=-1）{
计数++；
fromIndex=string.indexOf（子字符串，fromIndex）；
}
}while（fromIndex==string.length（）-1）；
返回计数；
}
公共静态字符串longestreatingsubstring（int-min、int-max、String-String）{
向量子向量=新向量（）；
向量SUBSTR_长度=新向量（）；
对于（int i=min；我很抱歉，您的控制语句不好。我强烈建议您在编写代码时学习更好的做法。为什么要使用标签？是否真的需要一个“continue”语句，或者循环的设计是否有所不同？它是什么意思？@LuciC:这段代码存在多个问题。几乎每当你必须使用定向
中断
或
继续
时，你都会想退一步说“嗯，也许我在这里遇到了麻烦。”特别是如果你发现自己编写的循环实际上永远不会循环，除非一个内部循环向它抛出一个定向的
continue
，就像你标记为
OUTER
的循环一样。在循环的终端条件下进行重要的计算是另一个危险信号。但这是所有的东西，不是这样的。：-）@卢西克：哇，那个代码不起作用。它找到的是
“bla”
，而不是
“blaf”
对于给定的输入。你是对的……我现在已经更正了。@T.J.Crowder你为什么这么认为？我回答了关于如何有效解决问题的问题-使用Rabin Karp。我还添加了一些注释，可以是注释，但也适合这里。我知道这是低效的，但这将进一步集成到一些套接字算法、jms、rmi、jsp和我只需要使用基本的things@T.J.Crowder正如你写这篇文章时，我添加了最后一句关于在当前解决方案中应用限制的内容。@LuciC：一般来说，你会更幸运地集成干净的代码。如果你有一个循环，除非内部循环抛出一个
continue
，否则它不会循环，你知道你的代码有问题。：-）@IvayloStrandjev：好了。：-）
public static int commonPrefix (String string, int x, int y)
{
    int l = string.length ();
    int n = 0;
    int oy = y;
    while (x < oy && y < l && string.charAt (x) == string.charAt (y))
    {
        n++; x++; y++;
    }
    return n;
}

public static String longestRepeatingSubstring (
    String string, int minLength, int maxLength)
{
    String found = null; 

    int l = string.length ();
    int fl = minLength; 
    for (int x = 0; x < l - fl * 2; x++)
        for (int y = x + 1; y < l - fl; y++)
        {
            int n = commonPrefix(string, x, y);

            if (n >= maxLength)
                return string.substring(x, x + maxLength);

            if (n > fl)
            {
                found = string.substring (x, x + n);
                fl = n;
            }
        }

    return found;
}

public static void main(String[] args) {
    System.out.println (longestRepeatingSubstring ("blablafblafblafblaf", 3, 5));
}

//import java.util.regex.*;

public static String longestRepeatingSubstring (String string, int min, int max)
{
  for (int i=max; i>=min; i--){
    for (int j=0; j<string.length()-i+1; j++){

      String substr = string.substring(j,j+i);
      Pattern pattern = Pattern.compile(substr);
      Matcher matcher = pattern.matcher(string);

      int count = 0;
      while (matcher.find()) count++;

      if (count > 1) return substr;
    }
  }

  return null;
}

public static void main(String[] args) {
  System.out.println (longestRepeatingSubstring ("blablafblafbla", 3, 5));
}

    public static int getCount(String string , String subString){

    int count = 0;
    int fromIndex = 0;
    do{
    if(string.indexOf(subString, fromIndex) != -1){
        count++;
        fromIndex = string.indexOf(subString, fromIndex);
    }
    }while(fromIndex == string.length()-1);
    return count;
}
public static String longestRepeatingSubstring (int min,int max , String string){
    Vector substrs = new Vector();
    Vector substrs_length = new Vector();
    for (int i=min; i<=max; i++){
        for (int j=0; j<string.length()-i+1; j++){
            String substr=string.substring(j, i+j);
            System.out.println(substr);
            if (substrs.indexOf(substr) == -1){
                int count =getCount(string, substr);
                if (count != 0) {
                    substrs.addElement(substr);
                    substrs_length.addElement(count);
                }
            }
        }
    }
    int maxLength = 0;
    int index = -1;
    for(int i = 0 ;  i < substrs_length.size() ; i++){
        int length = (int) substrs_length.elementAt(i);
        if(length > maxLength){
            maxLength = length;
            index = i;
        }
    }
    return (String) substrs.elementAt(index);
}
public static void main(String [] arg){
    System.out.print(longestRepeatingSubstring(3, 5, "blablafblafbla"));
}