LCS-最长公共子序列scala实现

最新推荐文章于 2022-07-29 08:14:45 发布

mannnn__

最新推荐文章于 2022-07-29 08:14:45 发布

阅读量301

点赞数

分类专栏：算法文章标签： scala lcs

本文链接：https://blog.csdn.net/mannnn__/article/details/95453954

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

def main(args: Array[String]): Unit = {

    //    val var1 = "在两个字符串中，有些字符会一样"
    //    val var2 = "两串字符会"
    //
    //    println(LCS(var1, var2))


    val var1 = Array(1, 3, 4, 5, 6, 7, 7, 8)

    val var2 = Array(3, 5, 7, 4, 8, 6, 7, 8, 2)

    val storeArr: Array[Array[Int]] = Array.ofDim[Int](var1.length + 1, var2.length + 1)

    // 从上到下进行推导
    for (i <- 1 until var1.length + 1) {
      for (j <- 1 until var2.length + 1) {
        if (var1(i - 1) == var2(j - 1)) {
          storeArr(i)(j) = storeArr(i - 1)(j - 1) + 1
        } else {
          storeArr(i)(j) = Math.max(storeArr(i - 1)(j), storeArr(i)(j - 1))
        }
      }
    }

    println(storeArr.map(_.mkString(",")).mkString("\n"))

    // 反推获得最优解
    var var3 = new util.ArrayList[Int]()

    /**
      * index_a row index
      * index_b column index
      * 
      * 最长公共子串只向斜上方移动
      */
    def rec_left(index_a: Int, index_b: Int): Unit = {
      // 限定条件
      if (storeArr(index_a)(index_b) == 0) {
        return None
      }

      if (storeArr(index_a)(index_b) > 0) {
        if (var1(index_a - 1) == var2(index_b - 1)) {
          var3.add(var1(index_a - 1))
          //向斜上方移动
          rec_left(index_a - 1, index_b - 1)
        } else {
          // 判断是向左移 还是右移
          //左移动
          if (storeArr(index_a - 1)(index_b) > storeArr(index_a)(index_b - 1)) {
            rec_left(index_a - 1, index_b)
          } else if (storeArr(index_a - 1)(index_b) == storeArr(index_a)(index_b - 1)) {
            // 当完整序列中索引对应元素不相等，二维数组中该索引位置的左边位置的值 与 二维数组中该索引位置的右边位置的值相等 ：向左移
            rec_left(index_a - 1, index_b)
          } else {
            rec_left(index_a, index_b - 1)
          }
        }
      }
      return
    }

    // 反推获得最优解
    var var4 = new util.ArrayList[Int]()
    def rec_right(index_a: Int, index_b: Int): Unit = {
      // 限定条件
      if (storeArr(index_a)(index_b) == 0) {
        return None
      }

      if (storeArr(index_a)(index_b) > 0) {
        if (var1(index_a - 1) == var2(index_b - 1)) {
          var4.add(var1(index_a - 1))
          //向斜上方移动
          rec_right(index_a - 1, index_b - 1)
        } else {
          // 判断是向左移 还是右移
          //左移动
          if (storeArr(index_a - 1)(index_b) > storeArr(index_a)(index_b - 1)) {
            rec_right(index_a - 1, index_b)
          } else if (storeArr(index_a - 1)(index_b) == storeArr(index_a)(index_b - 1)) {
            // 当完整序列中索引对应元素不相等，二维数组中该索引位置的左边位置的值 与 二维数组中该索引位置的右边位置的值相等 ：向左移
            rec_right(index_a, index_b - 1)
          } else {
            rec_right(index_a, index_b - 1)
          }
        }
      }
      return
    }


    rec_left(var1.length, var2.length)

    println("----------------打印结果---------------------")
    val array: Array[AnyRef] = var3.toArray

    for (k <- 0 until array.length reverse) {

      print(array(k))

    }

    println("----------------打印结果---------------------")
    rec_right(var1.length, var2.length)

    val array2: Array[AnyRef] = var4.toArray()

    for (k <- 0 until array2.length reverse) {

      print(array2(k))

    }
  }