通过合并元素和添加元素来修改数组，使其仅包含素数。

给定一个由正整数组成的数组arr [] ，任务是检查是否可以通过添加数组的任何元素以使其仅由质数组成来修改数组。

例子：

Input: arr[] = {3, 5, 7, 21} 
Output: YES 
Explanation: 
Add the following elements, 3+5+21 
So the array becomes {7, 29} which consists of only primes.

Input: {2, 5, 12, 16} 
Output: NO 
Explanation: 
There is no possible combination among elements which will make the array containing all primes

Input: {3, 5, 13, 22} 
Output: YES 
Explanation: 
Only one combination is possible, 
Add all elements – 3+5+13+22 = {43} which is only prime

先决条件： Bitmasking-DP
方法：

• 我们可以使用带位掩码的动态编程来解决此问题。我们可以将DP状态表示为元素的子集的掩码。
• 因此，让我们的dp数组为DP [mask] ，它表示直到此掩码(所选元素)所形成的子集将仅是素数的元素。
• 掩码中的最大位数将是数组中元素的数量。
• 我们继续在掩码中标记编码为序列的元素(如果选择了第i个索引元素，则在掩码中设置了第i个位)，并继续检查当前选择的元素(当前和)是否为质数(如果为素数)是素数，并且访问了所有其他元素，然后返回true ，我们得到了答案。
• 否则，如果没有访问其他元素，则由于当前总和是素数，我们只需要搜索可以单独或通过求和形成一些素数的其他元素，因此我们可以安全地将当前总和再次标记为0。
• 如果掩码已满(访问了所有元素)并且当前的总和不是素数，则返回false ，因为至少有一个总和不是素数。
• 复发：

DP[mask] = solve(curr + arr[i], mask | 1<

下面是上述方法的实现。

C++

// C++ program to find the
// array of primes
#include 
using namespace std;
 
// DP array to store the
// ans for max 20 elements
bool dp[1 << 20];
 
// To check whether the
// number is prime or not
bool isprime(int n)
{
    if (n == 1)
        return false;
    for (int i = 2; i * i <= n; i++)
    {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}
 
// Function to check whether the
// array can be modify so that
// there are only primes
int solve(int arr[], int curr,
          int mask, int n)
{
 
    // If curr is prime and all
    // elements are visited,
    // return true
    if (isprime(curr))
    {
        if (mask == (1 << n) - 1)
        {
            return true;
        }
 
        // If all elements are not
        // visited, set curr=0, to
        // search for new prime sum
        curr = 0;
    }
 
    // If all elements are visited
    if (mask == (1 << n) - 1)
    {
 
        // If the current sum is
        // not prime return false
        if (!isprime(curr))
        {
            return false;
        }
    }
 
    // If this state is already
    // calculated, return the
    // answer directly
    if (dp[mask])
        return dp[mask];
 
    // Try all state of mask
    for (int i = 0; i < n; i++)
    {
        // If ith index is not set
        if (!(mask & 1 << i))
        {
            // Add the current element
            // and set ith index and recur
            if (solve(arr, curr + arr[i]
                      , mask | 1 << i, n))
            {
                // If subset can be formed
                // then return true
                return true;
            }
        }
    }
     
    // After every possibility of mask,
    // if the subset is not formed,
    // return false by memoizing.
    return dp[mask] = false;
}
 
// Driver code
int main()
{
 
    int arr[] = { 3, 6, 7, 13 };
    int n = sizeof(arr) / sizeof(arr[0]);
     
    if(solve(arr, 0, 0, n))
    {
        cout << "YES";
    }
    else
    {
         cout << "NO";
    }
    return 0;
    
}

Java

// Java program to find the array of primes
import java.util.*;
 
class GFG{
 
// dp array to store the
// ans for max 20 elements
static boolean []dp = new boolean[1 << 20];
 
// To check whether the
// number is prime or not
static boolean isprime(int n)
{
    if (n == 1)
        return false;
 
    for(int i = 2; i * i <= n; i++)
    {
       if (n % i == 0)
       {
           return false;
       }
    }
    return true;
}
 
// Function to check whether the
// array can be modify so that
// there are only primes
static boolean solve(int arr[], int curr,
                     int mask, int n)
{
 
    // If curr is prime and all
    // elements are visited,
    // return true
    if (isprime(curr))
    {
        if (mask == (1 << n) - 1)
        {
            return true;
        }
 
        // If all elements are not
        // visited, set curr=0, to
        // search for new prime sum
        curr = 0;
    }
 
    // If all elements are visited
    if (mask == (1 << n) - 1)
    {
 
        // If the current sum is
        // not prime return false
        if (!isprime(curr))
        {
            return false;
        }
    }
 
    // If this state is already
    // calculated, return the
    // answer directly
    if (dp[mask])
        return dp[mask];
 
    // Try all state of mask
    for(int i = 0; i < n; i++)
    {
        
       // If ith index is not set
       if ((mask & (1 << i)) == 0)
       {
            
           // Add the current element
           // and set ith index and recur
           if (solve(arr, curr + arr[i],
                     mask | 1 << i, n))
           {
                
               // If subset can be formed
               // then return true
               return true;
           }
       }
    }
     
    // After every possibility of mask,
    // if the subset is not formed,
    // return false by memoizing.
    return dp[mask] = false;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 3, 6, 7, 13 };
    int n = arr.length;
     
    if(solve(arr, 0, 0, n))
    {
        System.out.print("YES");
    }
    else
    {
        System.out.print("NO");
    }
}
}
 
// This code is contributed by Rohit_ranjan

Python3

# Python3 program to find the array
# of primes
 
# DP array to store the
# ans for max 20 elements
dp = [0] * (1 << 20)
 
# To check whether the
# number is prime or not
def isprime(n):
     
    if (n == 1):
        return False
    for i in range(2, n + 1):
        if (n % i == 0):
            return False
     
    return True
 
# Function to check whether the
# array can be modify so that
# there are only primes
def solve(arr, curr, mask, n):
 
    # If curr is prime and all
    # elements are visited,
    # return true
    if (isprime(curr)):
        if (mask == (1 << n) - 1):
            return True
         
        # If all elements are not
        # visited, set curr=0, to
        # search for new prime sum
        curr = 0
     
    # If all elements are visited
    if (mask == (1 << n) - 1):
 
        # If the current sum is
        # not prime return false
        if (isprime(curr) == False):
            return False
         
    # If this state is already
    # calculated, return the
    # answer directly
    if (dp[mask] != False):
        return dp[mask]
 
    # Try all state of mask
    for i in range(n):
         
        # If ith index is not set
        if ((mask & 1 << i) == False):
             
            # Add the current element
            # and set ith index and recur
            if (solve(arr, curr + arr[i],
                           mask | 1 << i, n)):
                                
                # If subset can be formed
                # then return true
                return True
                 
    # After every possibility of mask,
    # if the subset is not formed,
    # return false by memoizing.
    return (dp[mask] == False)
 
# Driver code
arr = [ 3, 6, 7, 13 ]
 
n = len(arr)
     
if (solve(arr, 0, 0, n)):
    print("YES")
else:
    print("NO")
     
# This code is contributed by code_hunt

C#

// C# program to find the array of primes
using System;
 
class GFG{
 
// dp array to store the
// ans for max 20 elements
static bool []dp = new bool[1 << 20];
 
// To check whether the
// number is prime or not
static bool isprime(int n)
{
    if (n == 1)
        return false;
 
    for(int i = 2; i * i <= n; i++)
    {
       if (n % i == 0)
       {
           return false;
       }
    }
    return true;
}
 
// Function to check whether the
// array can be modify so that
// there are only primes
static bool solve(int []arr, int curr,
                  int mask, int n)
{
 
    // If curr is prime and all
    // elements are visited,
    // return true
    if (isprime(curr))
    {
        if (mask == (1 << n) - 1)
        {
            return true;
        }
 
        // If all elements are not
        // visited, set curr=0, to
        // search for new prime sum
        curr = 0;
    }
 
    // If all elements are visited
    if (mask == (1 << n) - 1)
    {
 
        // If the current sum is
        // not prime return false
        if (!isprime(curr))
        {
            return false;
        }
    }
 
    // If this state is already
    // calculated, return the
    // answer directly
    if (dp[mask])
        return dp[mask];
 
    // Try all state of mask
    for(int i = 0; i < n; i++)
    {
        
       // If ith index is not set
       if ((mask & (1 << i)) == 0)
       {
            
           // Add the current element
           // and set ith index and recur
           if (solve(arr, curr + arr[i],
                     mask | 1 << i, n))
           {
                
               // If subset can be formed
               // then return true
               return true;
           }
       }
    }
     
    // After every possibility of mask,
    // if the subset is not formed,
    // return false by memoizing.
    return dp[mask] = false;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 3, 6, 7, 13 };
    int n = arr.Length;
     
    if(solve(arr, 0, 0, n))
    {
        Console.Write("YES");
    }
    else
    {
        Console.Write("NO");
    }
}
}
 
// This code is contributed by Rohit_ranjan

Javascript

 
// Javascript program to find the
// array of primes
 
// DP array to store the
// ans for max 20 elements
dp = Array(1 << 20).fill(0);
 
// To check whether the
// number is prime or not
function isprime(n)
{
    if (n == 1)
        return false;
         
    for(var i = 2; i * i <= n; i++)
    {
        if (n % i == 0)
        {
            return false;
        }
    }
    return true;
}
 
// Function to check whether the
// array can be modify so that
// there are only primes
function solve(arr, curr, mask, n)
{
 
    // If curr is prime and all
    // elements are visited,
    // return true
    if (isprime(curr))
    {
        if (mask == (1 << n) - 1)
        {
            return true;
        }
 
        // If all elements are not
        // visited, set curr=0, to
        // search for new prime sum
        curr = 0;
    }
 
    // If all elements are visited
    if (mask == (1 << n) - 1)
    {
 
        // If the current sum is
        // not prime return false
        if (!isprime(curr))
        {
            return false;
        }
    }
 
    // If this state is already
    // calculated, return the
    // answer directly
    if (dp[mask])
        return dp[mask];
 
    // Try all state of mask
    for(var i = 0; i < n; i++)
    {
         
        // If ith index is not set
        if (!(mask & 1 << i))
        {
             
            // Add the current element
            // and set ith index and recur
            if (solve(arr, curr + arr[i],
                       mask | 1 << i, n))
            {
                 
                // If subset can be formed
                // then return true
                return true;
            }
        }
    }
     
    // After every possibility of mask,
    // if the subset is not formed,
    // return false by memoizing.
    return dp[mask] = false;
}
 
// Driver code
var arr = [ 3, 6, 7, 13 ]
var n = arr.length
 
if (solve(arr, 0, 0, n))
{
    document.write("YES");
}
else
{
    document.write("NO");
}
 
// This code is contributed by rutvik_56
     

输出：

YES