给定一个由N 个整数组成的数组arr[]和一个整数K ，任务是检查在分配算术运算运算符( +、-、/、* )后为给定数组的任何排列形成的表达式是否给出值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
方法：想法是使用回溯并通过生成分配运算符的所有可能组合来找到结果方程的值。以下是步骤：
- 遍历数组并选择前两个元素并应用所有可能的操作。令上述操作的结果为X 。
- 现在，对X和数组的下一个元素执行所有可能的操作，依此类推。
- 重复上述所有步骤，直到执行所有可能的操作组合。
- 现在，如果任何操作组合生成结果K ，则打印该组合。
- 否则，打印“ -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 MadhavPython3
# 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 ChitranayalC#
// 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)
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live