给定一个最初仅由1 s组成的数组input []和大小为N的数组target [] ，任务是检查是否可以通过将input [i]替换为的总和来将数组input []转换为target [] 。每个步骤中的数组元素。如果发现是真的，则打印“是” 。否则，打印“否” 。
例子：
Input: input[] = { 1, 1, 1 }, target[] = { 9, 3, 5 }
Output: YES
Explanation:
Replacing input[1] with (input[0] + input[1] + input[2]) modifies input[] to { 1, 3, 1 }
Replacing input[2] with (input[0] + input[1] + input[2]) modifies input[] to { 1, 3, 5 }
Replacing input[0] with (input[0] + input[1] + input[2]) modifies input[] to { 9, 3, 5 }
Since the array input[] equal to the target[] array, the required output is “YES”.
Input: input[] = { 1, 1, 1, 1 }, target[] = { 1, 1, 1, 2 }
Output: NO
方法：可以使用贪婪技术解决问题。这个想法是始终将target []数组的最大元素减去其余数组元素的总和，并检查一下target []的最大元素是否存在。如果发现是真的，则打印“是” 。否则，打印“否” 。以下是观察结果：
If target[] = { 9, 3, 5 } and input[] = { 1, 1, 1 }
Decrementing target[0] by (target[1] + target[2]) modifies target[] to { 1, 3, 5 }
Decrementing target[2] by (target[0] + target[1]) modifies target[] to { 1, 3, 1 }
Decrementing target[1] by (target[0] + target[2]) modifies target[] to { 1, 1, 1 }
Since input[] array and target[] equal, the required output is YES.
- 如果数组target []中最大的元素小于1 ，则打印“ NO” 。
- 如果数组target []中最大的元素等于1 ，则打印“ YES” 。
- 否则，由存在于阵列目标的剩余元素的总和可以减小阵列目标[]中的最大元素[]而阵列的最大元素大于1。
下面是上述方法的实现：
C++
// CPP program to implement
// the above approach
#include
using namespace std;
// Function to check if the arr[] can be
// converted to target[] by replacing
// any element in arr[] by the sum of arr[]
bool isPossible(int target[], int n)
{
// Store the maximum element
int max = 0;
// Store the index of
// the maximum element
int index = 0;
// Traverse the array target[]
for (int i = 0; i < n; i++) {
// If current element is
// greater than max
if (max < target[i]) {
max = target[i];
index = i;
}
}
// If max element is 1
if (max == 1)
return true;
// Traverse the array, target[]
for (int i = 0; i < n; i++) {
// If current index is not equal to
// maximum element index
if (i != index) {
// Update max
max -= target[i];
// If max is less than
// or equal to 0,
if (max <= 0)
return false;
}
}
// Update the maximum element
target[index] = max;
// Recursively call the function
return isPossible(target,n);
}
// Driver Code
int main()
{
int target[] = { 9, 3, 5 };
// Size of the array
int n = sizeof(target) / sizeof(target[0]);
bool res = isPossible(target,n);
if (res)
{
cout << "YES";
}
else
{
cout << "NO";
}
return 0;
}
// This code is contributed by 29AjayKumar Java
// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
class GFG {
// Function to check if the arr[] can be
// converted to target[] by replacing
// any element in arr[] by the sum of arr[]
public static boolean isPossible(int[] target)
{
// Store the maximum element
int max = 0;
// Store the index of
// the maximum element
int index = 0;
// Traverse the array target[]
for (int i = 0; i < target.length; i++) {
// If current element is
// greater than max
if (max < target[i]) {
max = target[i];
index = i;
}
}
// If max element is 1
if (max == 1)
return true;
// Traverse the array, target[]
for (int i = 0; i < target.length; i++) {
// If current index is not equal to
// maximum element index
if (i != index) {
// Update max
max -= target[i];
// If max is less than
// or equal to 0,
if (max <= 0)
return false;
}
}
// Update the maximum element
target[index] = max;
// Recursively call the function
return isPossible(target);
}
// Driver Code
public static void main(String[] args)
{
int[] target = { 9, 3, 5 };
boolean res = isPossible(target);
if (res) {
System.out.println("YES");
}
else {
System.out.println("NO");
}
}
}Python3
# Python program to implement the above approach
# Function to check if the arr[] can be
# converted to target[] by replacing
# any element in arr[] by the sum of arr[]
def isPossible(target):
# Store the maximum element
max = 0
# Store the index of
# the maximum element
index = 0
# Traverse the array target[]
for i in range(len(target)):
# If current element is
# greater than max
if (max < target[i]):
max = target[i]
index = i
# If max element is 1
if (max == 1):
return True
# Traverse the array, target[]
for i in range(len(target)):
# If current index is not equal to
# maximum element index
if (i != index):
# Update max
max -= target[i]
# If max is less than
# or equal to 0,
if (max <= 0):
return False
# Update the maximum element
target[index] = max
# Recursively call the function
return isPossible(target)
# Driver Code
target = [ 9, 3, 5 ]
res = isPossible(target)
if (res):
print("YES")
else:
print("NO")
# This code is contributed by RohitSingh07052.C#
// C# program for the above approach
using System;
class GFG
{
// Function to check if the arr[] can be
// converted to target[] by replacing
// any element in arr[] by the sum of arr[]
public static bool isPossible(int[] target)
{
// Store the maximum element
int max = 0;
// Store the index of
// the maximum element
int index = 0;
// Traverse the array target[]
for (int i = 0; i < target.Length; i++) {
// If current element is
// greater than max
if (max < target[i])
{
max = target[i];
index = i;
}
}
// If max element is 1
if (max == 1)
return true;
// Traverse the array, target[]
for (int i = 0; i < target.Length; i++) {
// If current index is not equal to
// maximum element index
if (i != index) {
// Update max
max -= target[i];
// If max is less than
// or equal to 0,
if (max <= 0)
return false;
}
}
// Update the maximum element
target[index] = max;
// Recursively call the function
return isPossible(target);
}
// Driver Code
static public void Main()
{
int[] target = { 9, 3, 5 };
bool res = isPossible(target);
if (res)
{
Console.WriteLine("YES");
}
else
{
Console.WriteLine("NO");
}
}
}
// This code is contributed by jana_sayantan.输出：
YES时间复杂度： O(N 2 )
辅助空间： O(1)