给定分别为长度N和M的两个数组arr1 []和arr2 [] ，任务是找到最长的公共质数子序列的长度 可以从两个给定的数组中获得。
例子：
Input: arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}, arr2[] = {2, 5, 6, 3, 7, 9, 8}
Output: 4
Explanation:
The longest common prime subsequence present in both the arrays is {2, 3, 5, 7}.
Input: arr1[] = {1, 3, 5, 7, 9}, arr2[] = {2, 4, 6, 8, 10}
Output: 0
Explanation:
In the above arrays, the prime subsequence of arr1[] is {1, 3, 5, 7} and arr2[] is {2}. Therefore, there is no common prime numbers which are present in both the arrays. Hence, the result is 0.
天真的方法：最简单的想法是考虑arr1 []的所有子序列，并检查该子序列中的所有数字是否都是质数并出现在arr2 []中。然后找到这些子序列的最长长度。
时间复杂度： O(M * 2 N )
辅助空间： O(N)
高效方法：想法是从两个数组中找到所有素数，然后使用动态编程从它们中找到最长的公共素数子序列。请按照以下步骤解决问题：
- 使用筛网筛选算法找到数组的最小元素和数组的最大元素之间的所有质数。
- 存储数组arr1 []和arr2 []的质数序列。
- 找到两个素数序列的LCS。
下面是上述方法的实现：
C++
// CPP implementation of the above approach
#include
using namespace std;
// Function to calculate the LCS
int recursion(vector arr1,
vector arr2, int i,
int j, map,
int> dp)
{
if (i >= arr1.size() or j >= arr2.size())
return 0;
pair key = { i, j };
if (arr1[i] == arr2[j])
return 1
+ recursion(arr1, arr2,
i + 1, j + 1,
dp);
if (dp.find(key) != dp.end())
return dp[key];
else
dp[key] = max(recursion(arr1, arr2,
i + 1, j, dp),
recursion(arr1, arr2, i,
j + 1, dp));
return dp[key];
}
// Function to generate
// all the possible
// prime numbers
vector primegenerator(int n)
{
int cnt = 0;
vector primes(n + 1, true);
int p = 2;
while (p * p <= n)
{
for (int i = p * p; i <= n; i += p)
primes[i] = false;
p += 1;
}
return primes;
}
// Function which returns the
// length of longest common
// prime subsequence
int longestCommonSubseq(vector arr1,
vector arr2)
{
// Minimum element of
// both arrays
int min1 = *min_element(arr1.begin(),
arr1.end());
int min2 = *min_element(arr2.begin(),
arr2.end());
// Maximum element of
// both arrays
int max1 = *max_element(arr1.begin(),
arr1.end());
int max2 = *max_element(arr2.begin(),
arr2.end());
// Generating all primes within
// the max range of arr1
vector a = primegenerator(max1);
// Generating all primes within
// the max range of arr2
vector b = primegenerator(max2);
vector finala;
vector finalb;
// Store precomputed values
map, int> dp;
// Store all primes in arr1[]
for (int i = min1; i <= max1; i++)
{
if (find(arr1.begin(), arr1.end(), i)
!= arr1.end()
and a[i] == true)
finala.push_back(i);
}
// Store all primes of arr2[]
for (int i = min2; i <= max2; i++)
{
if (find(arr2.begin(), arr2.end(), i)
!= arr2.end()
and b[i] == true)
finalb.push_back(i);
}
// Calculating the LCS
return recursion(finala, finalb, 0, 0, dp);
}
// Driver Code
int main()
{
vector arr1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vector arr2 = { 2, 5, 6, 3, 7, 9, 8 };
// Function Call
cout << longestCommonSubseq(arr1, arr2);
} Java
// JAVA implementation of the above approach
import java.util.*;
import java.io.*;
import java.math.*;
public class GFG
{
// Function to calculate the LCS
static int recursion(ArrayList arr1,
ArrayList arr2, int i,
int j, Map,
Integer> dp)
{
if (i >= arr1.size() || j >= arr2.size())
return 0;
ArrayList key = new ArrayList<>();
key.add(i);
key.add(j);
if (arr1.get(i) == arr2.get(j))
return 1 + recursion(arr1, arr2,
i + 1, j + 1,
dp);
if (dp.get(key) != dp.get(dp.size()-1))
return dp.get(key);
else
dp.put(key,Math.max(recursion(arr1, arr2,
i + 1, j, dp),
recursion(arr1, arr2, i,
j + 1, dp)));
return dp.get(key);
}
// Function to generate
// all the possible
// prime numbers
static ArrayList primegenerator(int n)
{
int cnt = 0;
ArrayList primes = new ArrayList<>();
for(int i = 0; i < n + 1; i++)
primes.add(true);
int p = 2;
while (p * p <= n)
{
for (int i = p * p; i <= n; i += p)
primes.set(i,false);
p += 1;
}
return primes;
}
// Function that returns the Minimum element of an ArrayList
static int min_element(ArrayList al)
{
int min = Integer.MAX_VALUE;
for(int i = 0; i < al.size(); i++)
{
min=Math.min(min, al.get(i));
}
return min;
}
// Function that returns the Minimum element of an ArrayList
static int max_element(ArrayList al)
{
int max = Integer.MIN_VALUE;
for(int i = 0; i < al.size(); i++)
{
max = Math.max(max, al.get(i));
}
return max;
}
// Function which returns the
// length of longest common
// prime subsequence
static int longestCommonSubseq(ArrayList arr1,
ArrayList arr2)
{
// Minimum element of
// both arrays
int min1 = min_element(arr1);
int min2 = min_element(arr2);
// Maximum element of
// both arrays
int max1 = max_element(arr1);
int max2 = max_element(arr2);
// Generating all primes within
// the max range of arr1
ArrayList a = primegenerator(max1);
// Generating all primes within
// the max range of arr2
ArrayList b = primegenerator(max2);
ArrayList finala = new ArrayList<>();
ArrayList finalb = new ArrayList<>();
// Store precomputed values
Map,Integer> dp =
new HashMap ,Integer> ();
// Store all primes in arr1[]
for (int i = min1; i <= max1; i++)
{
if (arr1.contains(i)
&& a.get(i) == true)
finala.add(i);
}
// Store all primes of arr2[]
for (int i = min2; i <= max2; i++)
{
if (arr2.contains(i)
&& b.get(i) == true)
finalb.add(i);
}
// Calculating the LCS
return recursion(finala, finalb, 0, 0, dp);
}
// Driver Code
public static void main(String args[])
{
int a1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int a2[] = { 2, 5, 6, 3, 7, 9, 8 };
// Converting into list
ArrayList arr1 = new ArrayList();
for(int i = 0; i < a1.length; i++)
arr1.add(a1[i]);
ArrayList arr2 = new ArrayList();
for(int i = 0; i < a2.length; i++)
arr2.add(a2[i]);
// Function Call
System.out.println(longestCommonSubseq(arr1, arr2));
}
}
// This code is contributed by jyoti369 Python3
# Python implementation of the above approach
# Function to calculate the LCS
def recursion(arr1, arr2, i, j, dp):
if i >= len(arr1) or j >= len(arr2):
return 0
key = (i, j)
if arr1[i] == arr2[j]:
return 1 + recursion(arr1, arr2,
i + 1, j + 1, dp)
if key in dp:
return dp[key]
else:
dp[key] = max(recursion(arr1, arr2,
i + 1, j, dp),
recursion(arr1, arr2,
i, j + 1, dp))
return dp[key]
# Function to generate
# all the possible
# prime numbers
def primegenerator(n):
cnt = 0
primes = [True for _ in range(n + 1)]
p = 2
while p * p <= n:
for i in range(p * p, n + 1, p):
primes[i] = False
p += 1
return primes
# Function which returns the
# length of longest common
# prime subsequence
def longestCommonSubseq(arr1, arr2):
# Minimum element of
# both arrays
min1 = min(arr1)
min2 = min(arr2)
# Maximum element of
# both arrays
max1 = max(arr1)
max2 = max(arr2)
# Generating all primes within
# the max range of arr1
a = primegenerator(max1)
# Generating all primes within
# the max range of arr2
b = primegenerator(max2)
finala = []
finalb = []
# Store precomputed values
dp = dict()
# Store all primes in arr1[]
for i in range(min1, max1 + 1):
if i in arr1 and a[i] == True:
finala.append(i)
# Store all primes of arr2[]
for i in range(min2, max2 + 1):
if i in arr2 and b[i] == True:
finalb.append(i)
# Calculating the LCS
return recursion(finala, finalb,
0, 0, dp)
# Driver Code
arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
arr2 = [2, 5, 6, 3, 7, 9, 8]
# Function Call
print(longestCommonSubseq(arr1, arr2))输出
4时间复杂度： O(N * M)
辅助空间： O(N * M)