Question

1940. 排序数组之间的最长公共子序列

English Version

题目描述

给定一个由整数数组组成的数组arrays，其中arrays[i]是严格递增排序的，返回一个表示所有数组之间的最长公共子序列的整数数组。

子序列是从另一个序列派生出来的序列，删除一些元素或不删除任何元素，而不改变其余元素的顺序。

示例1:

输入: arrays = [[_1_,3,_4_],
         [_1_,_4_,7,9]]
输出: [1,4]
解释: 这两个数组中的最长子序列是[1,4]。

示例 2:

输入: arrays = [[_2_,_3_,_6_,8],
         [1,_2_,_3_,5,_6_,7,10],
         [_2_,_3_,4,_6_,9]]
输出: [2,3,6]
解释: 这三个数组中的最长子序列是[2,3,6]。

示例 3:

输入: arrays = [[1,2,3,4,5],
         [6,7,8]]
输出: []
解释: 这两个数组之间没有公共子序列。

 

限制条件:

• 2 <= arrays.length <= 100
• 1 <= arrays[i].length <= 100
• 1 <= arrays[i][j] <= 100
• arrays[i] 是严格递增排序.

解法

方法一

class Solution:
  def longestCommomSubsequence(self, arrays: List[List[int]]) -> List[int]:
    n = len(arrays)
    counter = defaultdict(int)
    for array in arrays:
      for e in array:
        counter[e] += 1
    return [e for e, count in counter.items() if count == n]

class Solution {
  public List<Integer> longestCommomSubsequence(int[][] arrays) {
    Map<Integer, Integer> counter = new HashMap<>();
    for (int[] array : arrays) {
      for (int e : array) {
        counter.put(e, counter.getOrDefault(e, 0) + 1);
      }
    }
    int n = arrays.length;
    List<Integer> res = new ArrayList<>();
    for (Map.Entry<Integer, Integer> entry : counter.entrySet()) {
      if (entry.getValue() == n) {
        res.add(entry.getKey());
      }
    }
    return res;
  }
}

class Solution {
public:
  vector<int> longestCommomSubsequence(vector<vector<int>>& arrays) {
    unordered_map<int, int> counter;
    vector<int> res;
    int n = arrays.size();
    for (auto array : arrays) {
      for (auto e : array) {
        counter[e] += 1;
        if (counter[e] == n) {
          res.push_back(e);
        }
      }
    }
    return res;
  }
};

func longestCommomSubsequence(arrays [][]int) []int {
  counter := make(map[int]int)
  n := len(arrays)
  var res []int
  for _, array := range arrays {
    for _, e := range array {
      counter[e]++
      if counter[e] == n {
        res = append(res, e)
      }
    }
  }
  return res
}

/**
 * @param {number[][]} arrays
 * @return {number[]}
 */
var longestCommonSubsequence = function (arrays) {
  const m = new Map();
  const rs = [];
  const len = arrays.length;
  for (let i = 0; i < len; i++) {
    for (let j = 0; j < arrays[i].length; j++) {
      m.set(arrays[i][j], (m.get(arrays[i][j]) || 0) + 1);
      if (m.get(arrays[i][j]) === len) rs.push(arrays[i][j]);
    }
  }
  return rs;
};

方法二

class Solution:
  def longestCommomSubsequence(self, arrays: List[List[int]]) -> List[int]:
    def common(l1, l2):
      i, j, n1, n2 = 0, 0, len(l1), len(l2)
      res = []
      while i < n1 and j < n2:
        if l1[i] == l2[j]:
          res.append(l1[i])
          i += 1
          j += 1
        elif l1[i] > l2[j]:
          j += 1
        else:
          i += 1
      return res

    n = len(arrays)
    for i in range(1, n):
      arrays[i] = common(arrays[i - 1], arrays[i])
    return arrays[n - 1]