Question

我正在尝试两个数组共享的最长数字序列的长度。给出以下两个数组：

int [] a = {1, 2, 3, 4, 6, 8,};
int [] b = {2, 1, 2, 3, 5, 6,};

结果应该是3，因为两者之间最长的公共序列是{1, 2, 3}。这些数字必须按顺序排列，程序才能考虑对其进行计数。我已经考虑过并写了一个小小的开头但是，我不知道如何处理这个

 public static int longestSharedSequence(int[] arr, int[] arr2){
    int start = 0;
    for(int i = 0; i < arr.length; i++){
        for(int j = 0; j < arr2.length; j++){
            int n = 0;
            while(arr[i + n] == arr2[j + n]){
                n++;
                if(((i + n) >= arr.length) || ((j + n) >= arr2.length)){ 
                    break;
                }
            }
        }

Answer 1

这是一个非常好的开始。您需要做的就是有一些方法来跟踪您遇到的最佳n值。所以在方法开始时，声明int maxN = 0。然后，在两个while循环中的for循环之后，检查n（当前匹配的序列长度）是否大于maxN（遇到的最长匹配序列长度）远）。如果是，请将maxN更新为n。

的值

由于您还希望匹配元素按顺序排列，因此您需要检查两个数组中的元素不仅匹配，而且它们也比每个数组中的前一个元素大1。将这些放在一起会得到以下代码：

public static int longestSharedSequence(int[] arr, int[] arr2) {
    int maxN = 0;
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr2.length; j++) {
            int n = 0;
            // Check that elements match and that they are either the
            // first element in the sequence that is currently being
            // compared or that they are 1 greater than the previous
            // element
            while (arr[i + n] == arr2[j + n]
                    && (n == 0 || arr[i + n] == arr[i + n - 1] + 1)) {
                n++;
                if (i + n >= arr.length || j + n >= arr2.length) {
                    break;
                }
            }

            // If we found a longer sequence than the previous longest,
            // update maxN
            if (n > maxN) {
                maxN = n;
            }
        }
    }
    return maxN;
}

Answer 2

我没有想到比你已经走过的道路更聪明的东西：

import java.util.Arrays;
import java.util.Random;

public class MaxSeq {
  public static void main(String... args) {
    int[] a = new int[10000];
    int[] b = new int[10000];
    final Random r = new Random();
    Arrays.parallelSetAll(a, i -> r.nextInt(100));
    Arrays.parallelSetAll(b, i -> r.nextInt(100));
    System.out.println(longestSharedSequence(a, b));
  }

  private static int longestSharedSequence(final int[] arr, final int[] arr2) {
    int max = 0;
    for (int i = 0; i < arr.length; i++) {
      for (int j = 0; j < arr2.length; j++) {
        int n = 0;
        while ((i + n) < arr.length
            && (j + n) < arr2.length
            && arr[i + n] == arr2[j + n]) {
          n++;
        }
        max = Math.max(max, n);
      }
    }
    return max;
  }
}

请参阅：https://en.wikipedia.org/wiki/Longest_common_subsequence_problem

查找公共阵列序列的计数

2 个答案: