检查是否可以通过对数组的任何排列执行算术运算来获得K

给定一个由N个整数和整数K组成的数组arr [] ，任务是检查在分配算术运算运算符( +，-，/，* )后为给定数组的任何排列形成的表达式是否给出值K。如果发现为真，则打印执行的操作顺序。否则，打印“ -1” 。
注意：应用除法运算符“ /”后，结果可以是浮点数。

例子：

Input: arr[] = {2, 0, 0, 2}, K = 4
Output: 2 + 0 => 2 + 2 => 4 + 0 => 4

Input: arr[] = {1, 2, 4, 7}, K = 50
Output: -1

方法：想法是使用回溯并通过生成分配运算符的所有可能组合来找到结果方程的值。步骤如下：

1. 遍历数组并选择前两个元素并应用所有可能的操作。让上述操作的结果为X。
2. 现在，对X和数组的下一个元素执行所有可能的操作，依此类推。
3. 重复上述所有步骤，直到执行了所有可能的操作组合。
4. 现在，如果任何操作组合生成结果K ，则打印该组合。
5. 否则，打印“ -1” 。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function that finds the string of
// possible combination of operations
bool find(vector& v, int n,
          double dest, string s)
{
    // If only one number left then
    // check for result
    if (n == 1) {
 
        // If resultant value is K
        if (abs(v[0] - dest) <= 0.0000001) {
 
            cout << s + to_string(int(dest))
                 << " ";
            return 1;
        }
 
        // Else return 0
        return 0;
    }
 
    // Choose all combination of numbers
    // and operators and operate them
    for (int i = 0; i < n; i++) {
 
        for (int j = i + 1; j < n; j++) {
 
            double a = v[i], b = v[j];
 
            // Choose the first two and
            // operate it with '+'
            string p = s;
            v[i] = a + b;
 
            // Place it to 0th position
            v[j] = v[n - 1];
 
            // Place (n-1)th element on
            // 1st position
            s = (s + to_string(int(a)) + '+'
                 + to_string(int(b))
                 + " => ");
 
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return 1;
 
            // Now, we have N - 1 elements
            s = p;
 
            v[i] = a - b;
 
            // Try '-' operation
            v[j] = v[n - 1];
 
            s = (s + to_string(int(a)) + '-'
                 + to_string(int(b))
                 + " => ");
 
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return 1;
            s = p;
 
            v[i] = b - a;
 
            // Try reverse '-'
            v[j] = v[n - 1];
 
            s = (s + to_string(int(b)) + '-'
                 + to_string(int(a))
                 + " => ");
 
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return 1;
            s = p;
 
            v[i] = a * b;
 
            // Try '*' operation
            v[j] = v[n - 1];
            s = (s + to_string(int(a))
                 + '*'
                 + to_string(int(b))
                 + " => ");
 
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return 1;
 
            s = p;
 
            if (b != 0) {
 
                v[i] = a / b;
 
                // Try '/'
                v[j] = v[n - 1];
 
                s = (s + to_string(int(a))
                     + '/'
                     + to_string(int(b))
                     + " => ");
 
                // Evaluate the expression
                // with current combination
                if (find(v, n - 1, dest, s))
                    return 1;
            }
 
            s = p;
 
            if (a != 0) {
 
                v[i] = b / a;
 
                // Try reverse '/'
                v[j] = v[n - 1];
                s = (s + to_string(int(b))
                     + '/'
                     + to_string(int(a))
                     + " => ");
 
                // Evaluate the expression
                // with current combination
                if (find(v, n - 1, dest, s))
                    return 1;
            }
 
            s = p;
 
            // Backtracking Step
            v[i] = a;
            v[j] = b;
        }
    }
 
    // Return 0 if there doesnt exist
    // any combination that gives K
    return 0;
}
 
// Function that finds the possible
// combination of operation to get the
// resultant value K
void checkPossibleOperation(
    vector& arr, double K)
{
    // Store the resultant operation
    string s = "";
 
    // Function Call
    if (!find(arr, arr.size(), K, s)) {
        cout << "-1";
    }
}
 
// Driver Code
int main()
{
    // Given array arr[]
    vector arr = { 2, 0, 0, 2 };
 
    // Resultant value K
    double K = 4;
 
    // Function Call
    checkPossibleOperation(arr, K);
 
    return 0;
}

Java

// Java program for above approach
class GFG{
     
// Function that finds the string of
// possible combination of operations
static boolean find(double[] v, int n,
                    double dest, String s)
{
     
    // If only one number left then
    // check for result
    if (n == 1)
    {
         
        // If resultant value is K
        if (Math.abs(v[0] - dest) <= 0.0000001)
        {
            System.out.println(s +
            String.valueOf((int)dest) + " ");
                     
            return true;
        }
 
    // Else return 0
    return false;
    }
     
    // Choose all combination of numbers
    // and operators and operate them
    for(int i = 0; i < n; i++)
    {
        for(int j = i + 1; j < n; j++)
        {
            double a = v[i], b = v[j];
             
            // Choose the first two and
            // operate it with '+'
            String p = s;
            v[i] = a + b;
 
            // Place it to 0th position
            v[j] = v[n - 1];
 
            // Place (n-1)th element on
            // 1st position
            s = (s + String.valueOf((int)a) +
               '+' + String.valueOf((int)b) +
                " => ");
             
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return true;
 
            // Now, we have N - 1 elements
            s = p;
 
            v[i] = a - b;
 
            // Try '-' operation
            v[j] = v[n - 1];
 
            s = (s + String.valueOf((int)a) +
               '-' + String.valueOf((int)b) +
                " => ");
 
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return true;
                 
            s = p;
            v[i] = b - a;
 
            // Try reverse '-'
            v[j] = v[n - 1];
 
            s = (s + String.valueOf((int)b) +
               '-' + String.valueOf((int)a) +
                " => ");
 
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return true;
                 
            s = p;
            v[i] = a * b;
 
            // Try '*' operation
            v[j] = v[n - 1];
            s = (s + String.valueOf((int)a) +
               '*' + String.valueOf((int)b) +
                " => ");
 
            // Evaluate the expression
            // with current combination
            if (find(v, n - 1, dest, s))
                return true;
 
            s = p;
 
            if (b != 0)
            {
                v[i] = a / b;
 
                // Try '/'
                v[j] = v[n - 1];
 
                s = (s + String.valueOf((int)a) +
                   '/' + String.valueOf((int)b) +
                    " => ");
 
                // Evaluate the expression
                // with current combination
                if (find(v, n - 1, dest, s))
                    return true;
            }
            s = p;
 
            if (a != 0)
            {
                v[i] = b / a;
 
                // Try reverse '/'
                v[j] = v[n - 1];
                s = (s + String.valueOf((int)b) +
                   '/' + String.valueOf((int)a) +
                    " => ");
 
                // Evaluate the expression
                // with current combination
                if (find(v, n - 1, dest, s))
                    return true;
            }
            s = p;
 
            // Backtracking Step
            v[i] = a;
            v[j] = b;
        }
    }
     
    // Return 0 if there doesnt exist
    // any combination that gives K
    return false;
}
 
// Function that finds the possible
// combination of operation to get the
// resultant value K
static void checkPossibleOperation(double[] arr,
                                   double K)
{
     
    // Store the resultant operation
    String s = "";
 
    // Function call
    if (!find(arr, arr.length, K, s))
    {
        System.out.println("-1");
    }
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array arr[]
    double[] arr = { 2, 0, 0, 2 };
     
    // Resultant value K
    double K = 4;
 
    // Function call
    checkPossibleOperation(arr, K);
}
}
 
// This code is contributed by Dadi Madhav

Python3

# Python3 program for the above approach
# Function that finds the string of
# possible combination of operations
def find(v, n, dest, s):
   
    # If only one number left then
    # check for result
    if (n == 1):
 
        # If resultant value is K
        if (abs(v[0] - dest) <= 0.0000001):
            print (s + str(int(dest)) ,end = " ")
            return 1
 
        #;Else return 0
        return 0
 
    # Choose all combination of numbers
    # and operators and operate them
    for i in range (n):
        for j in range (i + 1,  n):
            a = v[i]
            b = v[j]
 
            # Choose the first two and
            # operate it with '+'
            p = s
            v[i] = a + b
 
            # Place it to 0th position
            v[j] = v[n - 1]
 
            # Place (n-1)th element on
            # 1st position
            s = (s + str(int(a)) + '+' +
                 str(int(b)) + " => ")
 
            # Evaluate the expression
            # with current combination
            if (find(v, n - 1, dest, s)):
                return 1
 
            # Now, we have N - 1 elements
            s = p
 
            v[i] = a - b
 
            # Try '-' operation
            v[j] = v[n - 1]
 
            s = (s + str(int(a)) + '-' +
                 str(int(b)) +" => ")
 
            # Evaluate the expression
            # with current combination
            if (find(v, n - 1, dest, s)):
                return 1
            s = p
            v[i] = b - a
 
            # Try reverse '-'
            v[j] = v[n - 1]
 
            s = (s + str(int(b)) + '-' +
                 str(int(a)) + " => ")
 
            # Evaluate the expression
            # with current combination
            if (find(v, n - 1, dest, s)):
                return 1
            s = p
            v[i] = a * b
 
            # Try '*' operation
            v[j] = v[n - 1]
            s = (s + str(int(a)) + '*' +
                 str(int(b)) + " => ");
 
            # Evaluate the expression
            # with current combination
            if (find(v, n - 1, dest, s)):
                return 1
            s = p
             
            if (b != 0):
                v[i] = a // b
 
                # Try '/'
                v[j] = v[n - 1]
 
                s = (s + str(int(a)) + '/' +
                     str(int(b)) + " => ")
 
                # Evaluate the expression
                # with current combination
                if (find(v, n - 1, dest, s)):
                    return 1
            s = p
 
            if (a != 0):
                v[i] = b // a
 
                # Try reverse '/'
                v[j] = v[n - 1]
                s = (s + str(int(b)) + '/' +
                     str(int(a)) + " => ")
 
                # Evaluate the expression
                # with current combination
                if (find(v, n - 1, dest, s)):
                    return 1         
            s = p
 
            # Backtracking Step
            v[i] = a
            v[j] = b
 
    # Return 0 if there doesnt exist
    # any combination that gives K
    return 0
 
# Function that finds the possible
# combination of operation to get the
# resultant value K
def checkPossibleOperation(arr, K):
 
    # Store the resultant operation
    s = ""
   
    # Function Call
    if (not find(arr, len(arr), K, s)):
        print ("-1")
 
# Driver Code
if __name__ == "__main__":
 
    # Given array arr[]
    arr = [2, 0, 0, 2]
 
    # Resultant value K
    K = 4
 
    # Function Call
    checkPossibleOperation(arr, K)
 
#This code is contributed by Chitranayal

C#

// C# program for
// the above approach
using System;
class GFG{
     
// Function that finds the string of
// possible combination of operations
static bool find(double[] v, int n,
                 double dest, String s)
{
  // If only one number left then
  // check for result
  if (n == 1)
  {
    // If resultant value is K
    if (Math.Abs(v[0] - dest) <= 0.0000001)
    {
      Console.WriteLine(s + String.Join("",
                                        (int)dest) + " ");
      return true;
    }
 
    // Else return 0
    return false;
  }
 
  // Choose all combination of numbers
  // and operators and operate them
  for(int i = 0; i < n; i++)
  {
    for(int j = i + 1; j < n; j++)
    {
      double a = v[i], b = v[j];
 
      // Choose the first two and
      // operate it with '+'
      String p = s;
      v[i] = a + b;
 
      // Place it to 0th position
      v[j] = v[n - 1];
 
      // Place (n-1)th element on
      // 1st position
      s = (s + String.Join("", (int)a) +
           '+' + String.Join("", (int)b) +
           " => ");
 
      // Evaluate the expression
      // with current combination
      if (find(v, n - 1, dest, s))
        return true;
 
      // Now, we have N - 1 elements
      s = p;
 
      v[i] = a - b;
 
      // Try '-' operation
      v[j] = v[n - 1];
 
      s = (s + String.Join("", (int)a) +
           '-' + String.Join("", (int)b) +
           " => ");
 
      // Evaluate the expression
      // with current combination
      if (find(v, n - 1, dest, s))
        return true;
 
      s = p;
      v[i] = b - a;
 
      // Try reverse '-'
      v[j] = v[n - 1];
 
      s = (s + String.Join("", (int)b) +
           '-' + String.Join("", (int)a) +
           " => ");
 
      // Evaluate the expression
      // with current combination
      if (find(v, n - 1, dest, s))
        return true;
 
      s = p;
      v[i] = a * b;
 
      // Try '*' operation
      v[j] = v[n - 1];
      s = (s + String.Join("", (int)a) +
           '*' + String.Join("", (int)b) +
           " => ");
 
      // Evaluate the expression
      // with current combination
      if (find(v, n - 1, dest, s))
        return true;
 
      s = p;
 
      if (b != 0)
      {
        v[i] = a / b;
 
        // Try '/'
        v[j] = v[n - 1];
 
        s = (s + String.Join("", (int)a) +
             '/' + String.Join("", (int)b) +
             " => ");
 
        // Evaluate the expression
        // with current combination
        if (find(v, n - 1, dest, s))
          return true;
      }
      s = p;
 
      if (a != 0)
      {
        v[i] = b / a;
 
        // Try reverse '/'
        v[j] = v[n - 1];
        s = (s + String.Join("", (int)b) +
             '/' + String.Join("", (int)a) +
             " => ");
 
        // Evaluate the expression
        // with current combination
        if (find(v, n - 1, dest, s))
          return true;
      }
      s = p;
 
      // Backtracking Step
      v[i] = a;
      v[j] = b;
    }
  }
 
  // Return 0 if there doesnt exist
  // any combination that gives K
  return false;
}
 
// Function that finds the possible
// combination of operation to get the
// resultant value K
static void checkPossibleOperation(double[] arr,
                                   double K)
{
  // Store the resultant operation
  String s = "";
 
  // Function call
  if (!find(arr, arr.Length, K, s))
  {
    Console.WriteLine("-1");
  }
}
 
// Driver Code
public static void Main(String[] args)
{   
  // Given array []arr
  double[] arr = {2, 0, 0, 2};
 
  // Resultant value K
  double K = 4;
 
  // Function call
  checkPossibleOperation(arr, K);
}
}
 
// This code is contributed by Princi Singh

输出：

2+0 => 2+2 => 4+0 => 4

时间复杂度： O(N！* 4 ^N )
辅助空间： O(N)