Javascript 具有最长连续历史的问题

我遇到了这个难题，并试图解决它，但我无法让它运行

我很难确定存储用户点击的正确数据结构。

问题：

编写一个函数，将两个用户的浏览历史记录作为输入并 返回在两个URL中显示的最长连续URL序列

样本输入：

user0=[“/start”、“/pink”、“/register”、“/orange”、“/red”、“a”]

user1=[“/start”、“/green”、“/blue”、“/pink”、“/register”、“/orange”、“/one/two”]

样本输出：

[“/pink”、“/register”、“/orange”]

这是我的尝试：

函数findContactiguousHistory（u1，u2）{
常量res={}；//{1:['/start']，3:['/pink'，'/register'，'/orange']}
让计数=0；
设temp=[]；
对于（设i=0；i这是一个动态规划问题。在下面的解决方案中，我创建了2D数组以跟踪到每个点的最长匹配子序列。最后，结果将是2D数组右下角的值。下面是代码：



函数Create2DArray（行）{
var-arr=[]；
对于（var i=0；i这是一个动态规划问题。在下面的解决方案中，我创建了2D数组以跟踪到每个点的最长匹配子序列。最后，结果将是2D数组右下角的值。下面是代码：



函数Create2DArray（行）{
var-arr=[]；
对于（var i=0；i要解决此问题，您可以执行一系列步骤：

确定最小大小的阵列和最大大小的阵列
以递减的方式循环最小大小数组的长度。我们将使用此循环计数器作为可能匹配的最大大小数组的大小的指示器
嵌套在#2的循环中，创建另一个循环，该循环将用作起始索引，我们可以从最小大小的数组中进行切片
嵌套在从#3开始的循环中，创建另一个循环，循环遍历最大大小的数组，并从最小大小的数组中获取匹配数组
注意：使用
toString（）
比较两个数组仅有效
当这些数组中的值是基元值时


要解决此问题，您可以执行一系列步骤：

确定最小大小的阵列和最大大小的阵列
以递减的方式循环最小大小数组的长度。我们将使用此循环计数器作为可能匹配的最大大小数组的大小的指示器
嵌套在#2的循环中，创建另一个循环，该循环将用作起始索引，我们可以从最小大小的数组中进行切片
嵌套在从#3开始的循环中，创建另一个循环，循环遍历最大大小的数组，并从最小大小的数组中获取匹配数组
注意：使用
toString（）
比较两个数组仅有效
当这些数组中的值是基元值时


这是我的解决方案，希望能对你有所帮助

简单的解决方案

函数findContactiguousHistory（u1，u2）{
设max=0
设maxSolution={}
对于（让i=0；i这是我的解决方案。希望它能帮助您

简单的解决方案

函数findContactiguousHistory（u1，u2）{
设max=0
设maxSolution={}
对于（设i=0；i这里是另一个O（n^2）解

函数findContiguousHistory（u0，u1）{
让结果=[]
让历史=[]
设k=0；
for（设i=0；i result.length）{
结果=历史；
历史=[]；
}
控制台日志（结果）；
}
这里是另一个O（n^2）解决方案

函数findContiguousHistory（u0，u1）{
让结果=[]
让历史=[]
设k=0；
for（设i=0；i result.length）{
结果=历史；
历史=[]；
}
控制台日志（结果）；
}
这是（URL为“字符”，数组为“字符串”）这是（URL为“字符”，数组为“字符串”）非常感谢您的时间。我们可以让它比N^3解决方案更快吗？我刚刚使用
动态算法添加了性能解决方案
非常感谢您的时间。我们可以让它比N^3解决方案更快吗？我刚刚使用
动态算法添加了性能解决方案
@technoCorner上述解决方案对您有效吗有什么问题吗？@technoCorner上述解决方案对您有效吗？或者有什么问题吗？
function findContiguousHistory(a, b) {

  const [min, max] = a.length < b.length
    ? [a, b]
    : [b, c];

  const size = min.length;

  for(let i = size; i > 0; i--) {
    for(let j = 0; j <= size - i; j++) {
      const sliced = min.slice(j, j + i);
      for(let k = 0; k < max.length - i; k++) {
        if(sliced.toString() === max.slice(k, k + i).toString()) {
          return sliced;
        }
      }
    }
  }

  return null;

}

function findContiguousHistory(u0, u1) {
  let result = []
  let history = []
  let k = 0;
  for(let i=0; i<u0.length; i++) {
    for(let j=k; j<u1.length; j++) {
      if(u0[i] === u1[j]) {
        history.push(u0[i]);
        k = j+1;
        break;
      }
      // reset for starting over the search
      k = 0;
      if(history.length > result.length) {
        result = history;
        history = [];
      }
    }    
  }
  // if last index was truthy in above loop.
  if(history.length > result.length) {
    result = history;
    history = [];
  }
  console.log(result);
}