[前端]_一起刷leetcode 剑指 Offer II 095. 最长公共子序列「这是我参与11月更文挑战的第2天，活

「这是我参与11月更文挑战的第2天，活动详情查看：2021最后一次更文挑战」

题目：

剑指 Offer II 095. 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 **是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入： text1 = "abcde", text2 = "ace" 
输出： 3  
解释： 最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：

输入： text1 = "abc", text2 = "abc"
输出： 3
解释： 最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：

输入： text1 = "abc", text2 = "def"
输出： 0
解释： 两个字符串没有公共子序列，返回 0 。

提示：

1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。

方法1-动态规划思路：

创建数组dp,记录text2中的每个元素在指定位置的最长公共子序列
遍历数组，求出每个位置的最长公共子序列，并于上一轮的结果进行比较
执行count次翻转，每次翻转完拼接到已经整理好的链表中
剩余不足k的链表直接添加到已经整理好的链表中

方法1-动态规划实现：

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
function reverseKGroup(head, k) {
  let total = 0;
  let cur = head;
  // 统计链表的总长度
  while (cur) {
    cur = cur.next;
    total++;
  }

  // 计算需要经过多少次翻转
  const count = Math.floor(total / k);
  let result, temp;

  // 遍历进行翻转
  for (let i = 0; i < count; i++) {
    let { prev, next } = reverseNode(head, k);
    head = next;

    // 第一次翻转完作为头节点
    if (i === 0) {
      result = prev;
      temp = result;
    } else {
      // 链接后的数据走到最后，等待接下一组翻转后的节点
      while (temp.next) {
        temp = temp.next;
      }
      temp.next = prev;
    }
  }

  // 链接后的数据走到最后，等待接下一组翻转后的节点
  while (temp.next) {
    temp = temp.next;
  }
  temp.next = head;
  return result;
}

// 翻转链表前K个元素
function reverseNode(cur, k) {
  let prev = null;
  let next = null;

  while (k) {
    next = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next;
    k--;
  }

  return {
    prev,
    next,
  };
}

方法2-贪心思路：

回顾上面代码发现写了很多冗余代码，比如说每次你拿到整理好的链表后，你还得对链表进行k轮的向后取值操作 temp = temp.next; 而且一开始还得先经过一轮统计total，相当于遍历了链表三次。所以做了如下的调整：

取消第一次先求total的操作，改成用index在每次翻转前计数，满足index === k执行翻转
每次翻转结束不返回整段链表了，只返回头节点和尾节点
把已经整理好的节点的next指向当前翻转后的头节点，当前翻转后的尾节点指向下一轮的头节点

方法2-贪心实现：

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
function reverseKGroup(head, k) {
  // 一个一组就不用旋转了
  if (k === 1) {
    return head;
  }
  // 创建一个空节点， 待会儿就不用每次循环都要判断是否头节点了。结果返回result.next即可
  let result = { val: 0, next: null };
  let cur = head;

  let prev = result; // 缓存上一个末尾节点
  
  while (cur) {
    let index = 1;
    let temp = cur;
    while (index < k && temp.next) {
      temp = temp.next;
      index++;
    }

    const next = temp && temp.next;

    // 满足k个一组，做旋转操作， 不满足则游戏结束
    if (index === k) {
      let { first, last } = reverseNode(cur, k);
      prev.next = first; // 上一轮的尾节点指向这一轮的头节点
      prev = last;
    } else {
      prev.next = cur;
    }

    cur = next;
  }

  return result.next;
}

// 翻转链表前K个元素
function reverseNode(cur, k) {
  let last = cur; // 当前的头节点翻转后就是尾节点

  let prev = null;
  let next = null;

  while (k) {
    next = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next;
    k--;
  }

  return {
    first: prev,
    last,
  };
}

看懂了的小伙伴可以点个关注、咱们下道题目见。如无意外以后文章都会以这种形式，有好的建议欢迎评论区留言。