给定两个长度相同的数组A[]和B[] ，任务是通过用数组 B 中相应元素的差异替换元素来找到使数组中的所有元素相等所需的最少步数。
注意：如果这是不可能的，则打印 -1。
例子：
Input: A[] = {5, 7, 10, 5, 15} B[] = {2, 2, 1, 3, 5}
Output: 8
Explanation:
Steps to convert Array elements equal –
Index 0: 5 is not changed, Steps Taken = 0
Index 1: 7 – (2 * 1) = 5, Steps Taken = 1
Index 2: 10 – (1 * 5) = 5, Steps Taken = 5
Index 3: 5 is not changed, Steps Taken = 0
Index 4: 15 – (5 * 2) = 5, Steps Taken = 2
Therefore, total steps required = 0 + 1 + 5 + 0 + 2 = 8
Input: A[] = {5, 6}, B[] = {4, 3}
Output: -1
Explanation:
It’s not possible to make all elements of array equal.
方法：思路是找到数组元素可以收敛的值，这个值肯定会在0到数组的最小值之间。下面是该方法的说明：
- 最初，将标志标记为 False，以检查数组是否可转换。
- 运行 while 循环，直到数组的最小值大于 -1。
- 迭代数组的索引，即从 0 到 length – 1
- 对于每个索引，检查数组 A 中该索引处的元素是否大于数组的最小值，如果是，则将数组元素 A[i] 更新为 A[i] – B[i]。
- 将步数增加 1。
- 如果是，检查所有数组元素是否相等，然后将标志标记为 True 并中断 while 循环
- 否则，重复上述步骤以计算所需的总步数。
- 最后，检查标志是否为 True，如果是，则数组是可转换的。
举例说明：
给定数组是 – A[] = {5, 7, 10, 5, 15}, B[] = {2, 2, 1, 3, 5}
| Array A | Current Index | Minimum of Array A | Steps | Comments |
|---|---|---|---|---|
| {5, 7, 10, 5, 15} | 0 | 5 | 0 | No operation ! |
| {5, 5, 10, 5, 15} | 1 | 5 | 1 | Array element is subtracted once. 7 – 2 = 5 |
| {5, 5, 9, 5, 15} | 2 | 5 | 2 | Array element is subtracted once. 10 – 1 = 9 |
| {5, 5, 8, 5, 15} | 2 | 5 | 3 | Array element is subtracted once. 9 – 1 = 8 |
| {5, 5, 7, 5, 15} | 2 | 5 | 4 | Array element is subtracted once. 8 – 1 = 7 |
| {5, 5, 6, 5, 15} | 2 | 5 | 5 | Array element is subtracted once. 7 – 1 = 6 |
| {5, 5, 5, 5, 15} | 2 | 5 | 6 | Array element is subtracted once. 6 – 1 = 5 |
| {5, 5, 5, 5, 10} | 4 | 5 | 7 | Array element is subtracted once. 15 – 5 = 10 |
| {5, 5, 5, 5, 5} | 4 | 5 | 8 | Array element is subtracted once. 10 – 5 = 5 |
下面是上述方法的实现：
C++
// C++ implementation to find the
// minimum number of steps to convert
// array by subtracting the corresponding
// element from array B
#include
using namespace std;
// Function to find the minimum steps
void minimumSteps(int ar1[], int ar2[], int n)
{
// Counter to store the steps
int ans = 0;
// Flag to check that
// array is converted
bool flag = true;
// Loop until the minimum of the
// array is greater than -1
while (*min_element(ar1, ar1 + n) > -1)
{
int a = *min_element(ar1, ar1 + n);
// Loop to convert the array
// elements by substraction
for(int i = 0; i < n; i++)
{
if (ar1[i] != a)
{
ar1[i] -= ar2[i];
ans += 1;
}
}
set s1(ar1, ar1 + n);
// If the array is converted
if (s1.size() == 1)
{
flag = false;
cout << ans << endl;
break;
}
}
if (flag)
{
cout << -1 << endl;
}
}
// Driver Code
int main()
{
int n = 5;
int ar1[] = { 5, 7, 10, 5, 15 };
int ar2[] = { 1, 2, 1, 5, 5 };
// Function call
minimumSteps(ar1, ar2, n);
return 0;
}
// This code is contributed by rutvik_56 Java
// Java implementation to find the
// minimum number of steps to convert
// array by subtracting the corresponding
// element from array B
import java.util.*;
class GFG{
// Function to find the
// minimum steps
static void minimumSteps(int ar1[],
int ar2[],
int n)
{
// Counter to store the steps
int ans = 0;
// Flag to check that
// array is converted
boolean flag = true;
// Loop until the minimum of the
// array is greater than -1
while (Arrays.stream(ar1).min().getAsInt() > -1)
{
int a = Arrays.stream(ar1).min().getAsInt();
// Loop to convert the array
// elements by substraction
for(int i = 0; i < n; i++)
{
if (ar1[i] != a)
{
ar1[i] -= ar2[i];
ans += 1;
}
}
HashSet s1 = new HashSet<>();
for(int i = 0; i < n; i++)
{
s1.add(ar1[i]);
}
// If the array is converted
if (s1.size() == 1)
{
flag = false;
System.out.print(ans + "\n");
break;
}
}
if (flag)
{
System.out.print(-1 + "\n");
}
}
// Driver Code
public static void main(String[] args)
{
int n = 5;
int ar1[] = {5, 7, 10, 5, 15};
int ar2[] = {1, 2, 1, 5, 5};
// Function call
minimumSteps(ar1, ar2, n);
}
}
// This code is contributed by Princi Singh Python3
# Python3 implementation to find the
# minimum number of steps to convert
# array by subtracting the corresponding
# element from array B
# Function to find the minimum steps
def minimumSteps(ar1, ar2, n):
# Counter to store the steps
ans = 0
# Flag to check that
# array is converted
flag = True
# Loop until the minimum of the
# array is greater than -1
while min(ar1)>-1:
a = min(ar1)
# Loop to convert the array
# elements by substraction
for i in range(n):
if ar1[i]!= a:
ar1[i]-= ar2[i]
ans+= 1
# If the array is converted
if len(set(ar1))== 1:
flag = False
print(ans)
break
if flag:
print(-1)
# Driver Code
if __name__ == "__main__":
n = 5
ar1 = [5, 7, 10, 5, 15]
ar2 = [1, 2, 1, 5, 5]
# Function Call
minimumSteps(ar1, ar2, n)C#
// C# implementation to
// find the minimum number
// of steps to convert array
// by subtracting the
// corresponding element from
// array B
using System;
using System.Linq;
using System.Collections.Generic;
class GFG{
// Function to find the
// minimum steps
static void minimumSteps(int []ar1,
int []ar2,
int n)
{
// Counter to store the steps
int ans = 0;
// Flag to check that
// array is converted
bool flag = true;
// Loop until the minimum of the
// array is greater than -1
while (ar1.Min() > -1)
{
int a = ar1.Min();
// Loop to convert the array
// elements by substraction
for(int i = 0; i < n; i++)
{
if (ar1[i] != a)
{
ar1[i] -= ar2[i];
ans += 1;
}
}
HashSet s1 = new HashSet();
for(int i = 0; i < n; i++)
{
s1.Add(ar1[i]);
}
// If the array is converted
if (s1.Count == 1)
{
flag = false;
Console.Write(ans + "\n");
break;
}
}
if (flag)
{
Console.Write(-1 + "\n");
}
}
// Driver Code
public static void Main(String[] args)
{
int n = 5;
int []ar1 = {5, 7, 10, 5, 15};
int []ar2 = {1, 2, 1, 5, 5};
// Function call
minimumSteps(ar1, ar2, n);
}
}
// This code is contributed by 29AjayKumar 输出：
8
性能分析：
- 时间复杂度：与上述方法一样，有两个循环来转换在最坏情况下需要 O(N 2 ) 的数组，因此时间复杂度将为O(N 2 ) 。
- 空间复杂度：与上述方法一样，没有使用额外的空间，因此空间复杂度为O(1) 。
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live