Given two positive integer arrays X[] and Y[] of size N, Where all elements of X[] are distinct. Considering all the elements of X[] are lying side by side initially on a line, the task is to find the minimum number of operations required such that elements in X[] becomes in increasing order where in one operation you can increase each element of X[] by their respective values index in Y[] (first element of X[] element can be incremented by the first element of Y[] or position of the second element of X[] can be incremented by the second element of Y[] or so on….).
Examples:
Input: N = 3, X[] = {3, 2, 1}, Y[] = {1, 1, 1}
Output: 6
Explanation: According to the problem statement:
- X[1] = 3, It’s position can be incremented by Y[1] = 1.
- X[2] = 2, It’s position can be incremented by Y[2] = 1.
- X[3] = 1, It’s position can be incremented by Y[3] = 1.
- Operations:
- In two operations, X[2] = 2, incremented its position by Y[2] = 1 in each operation from position 1 to 2 and then 2 to 3 by using operations one by one.
- In four operations, X[1] = 3, incremented its position by Y[1] = 1 in each operation from position 0 to 1, 1 to 2, 2 to 3 and then 3 to 4 in last operation. Each operation is performed one by one.
- Now, It can be verified that all the elements of X[] are in sorted order of their values, for this case Minimum number of operations are=2 + 4 = 6, Which is minimum possible.
Input: N = 4, X[] = {2, 1, 4, 3}, Y[] = {4, 1, 2, 4}
Output: 5
Explanation: According to the problem statement:
- X[1] = 2, It’s position can be incremented by Y[1] = 4.
- X[2] = 1, It’s position can be incremented by Y[2] = 1.
- X[3] = 4, It’s position can be incremented by Y[3] = 2.
- X[4] = 3, It’s position can be incremented by Y[4] = 4.
- Operations:
- In one operation, X[4] = 3, incremented its position by Y[4] = 4, in each operation from position 3 to 7.
- In one operation, X[1] = 2, incremented its position by Y[1] = 4 in each operation from position 0 to 3.
- In three operations, X[3] = 4, incremented its position by Y[3] = 2 in each operation from position 2 to 4, 4 to 6 and then 6 to 8 in each operation one by one.
- Therefore, Total minimum number of operations for this case are= 1 + 1 + 3 = 5. It can be verified that all the elements of X[] are in sorted order of their values after performing above operations.
Approach: Implement the idea below to solve the problem
The problem is observation based and can be solve by using Greedy Technique. The basic idea of the problem is that, we have to choose optimal element to increment it’s position in ach operation.
Steps were taken to solve the problem:
- Create two arrays positions[] and temp_length[] of length N for storing positions and temporary lengths of elements of X[].
- Create integer variable operations and initialize it equal to 0.
- Initialize positions[] with positions[X[i] – 1] = i, by using a loop from i=0 to less than N.
- Initialize temp_length[] with temp_lengthX[i] – 1] = Y[i], by using a loop from i=0 to less than N.
- Iterate from i = 1 to less than N using loops and follow the below-mentioned steps under the scope of the loop:
- While(position[i] ? position[i-1]), till then position[i] += temp_length[i] and operations++.
- Return operations.
Below is the code to implement the approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function for returning minimum // number of operations int min_operations( int N, int X[], int Y[])
{ // Array to store positions
// of elements
int position[N];
// Array to store temp_length
int temp_length[N];
// Variable to hold minimum number
// of operations
int operations = 0;
// Loop for initializing positions
for ( int i = 0; i < N; i++) {
position[X[i] - 1] = i;
}
// Loop for initializing
// temp_length
for ( int i = 0; i < N; i++) {
temp_length[X[i] - 1] = Y[i];
}
// Loop for calculating number
// of operations
for ( int i = 1; i < N; i++) {
while (position[i] <= position[i - 1]) {
position[i] += temp_length[i];
operations++;
}
}
// Returning number of operations
return operations;
} int main() {
// Input value of N
int N = 4;
// Input array X[]
int X[] = { 2, 1, 4, 3 };
// Input array Y[]
int Y[] = { 4, 1, 2, 4 };
// Function call
cout << min_operations(N, X, Y) << endl;
} |
// Java code to implement the approach import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
// Driver Function
public static void main(String[] args)
throws java.lang.Exception
{
// Input value of N
int N = 4 ;
// Input array X[]
int X[] = { 2 , 1 , 4 , 3 };
// Input array Y[]
int Y[] = { 4 , 1 , 2 , 4 };
// Function call
System.out.println(min_operations(N, X, Y));
}
// Function for returning minimum
// number of operations
static int min_operations( int N, int [] X, int [] Y)
{
// Array to store positions
// of elements
int [] position = new int [N];
// Array to store temp_length
int [] temp_length = new int [N];
// Variable to hold minimum number
// of operations
int operations = 0 ;
// Loop for initializing positions
for ( int i = 0 ; i < N; i++) {
position[X[i] - 1 ] = i;
}
// Loop for initializing
// temp_length
for ( int i = 0 ; i < N; i++) {
temp_length[X[i] - 1 ] = Y[i];
}
// Loop for calculating number
// of operations
for ( int i = 1 ; i < N; i++) {
while (position[i] <= position[i - 1 ]) {
position[i] += temp_length[i];
operations++;
}
}
// Returning number of operations
return operations;
}
} |
#Python3 code to implement the approach # Function for returning minimum # number of operations def min_operations(N, X, Y):
# Array to store positions
# of elements
position = [ 0 ] * N
#Array to store temp_length
temp_length = [ 0 ] * N
# Variable to hold minimum number
# of operations
operations = 0
#Loop for initializing positions
for i in range ( 0 , N):
position[X[i] - 1 ] = i
# Loop for initializing
# temp_length
for i in range ( 0 , N):
temp_length[X[i] - 1 ] = Y[i]
# Loop for calculating number
# of operations
for i in range ( 1 , N):
while position[i] < = position[i - 1 ]:
position[i] + = temp_length[i]
operations + = 1
# Returning number of operations
return operations
if __name__ = = "__main__" :
# Input value of N
N = 4
#Input array X[]
X = [ 2 , 1 , 4 , 3 ]
# Input array Y[]
Y = [ 4 , 1 , 2 , 4 ]
# Function call
print (min_operations(N, X, Y))
|
// C# code to implement the approach using System;
public class GFG {
static public void Main()
{
// Code
// Input value of N
int N = 4;
// Input array X[]
int [] X = { 2, 1, 4, 3 };
// Input array Y[]
int [] Y = { 4, 1, 2, 4 };
// Function call
Console.WriteLine(min_operations(N, X, Y));
}
// Function for returning minimum
// number of operations
static int min_operations( int N, int [] X, int [] Y)
{
// Array to store positions
// of elements
int [] position = new int [N];
// Array to store temp_length
int [] temp_length = new int [N];
// Variable to hold minimum number
// of operations
int operations = 0;
// Loop for initializing positions
for ( int i = 0; i < N; i++) {
position[X[i] - 1] = i;
}
// Loop for initializing
// temp_length
for ( int i = 0; i < N; i++) {
temp_length[X[i] - 1] = Y[i];
}
// Loop for calculating number
// of operations
for ( int i = 1; i < N; i++) {
while (position[i] <= position[i - 1]) {
position[i] += temp_length[i];
operations++;
}
}
// Returning number of operations
return operations;
}
} // This code is contributed by karthik. |
// Javascript code to implement the approach // Function for returning minimum // number of operations function min_operations( N, X, Y)
{ // Array to store positions
// of elements
let position= new Array(N);
// Array to store temp_length
let temp_length= new Array(N);
// Variable to hold minimum number
// of operations
let operations = 0;
// Loop for initializing positions
for (let i = 0; i < N; i++) {
position[X[i] - 1] = i;
}
// Loop for initializing
// temp_length
for (let i = 0; i < N; i++) {
temp_length[X[i] - 1] = Y[i];
}
// Loop for calculating number
// of operations
for (let i = 1; i < N; i++) {
while (position[i] <= position[i - 1]) {
position[i] += temp_length[i];
operations++;
}
}
// Returning number of operations
return operations;
} // Input value of N let N = 4; // Input array X[] let X = [ 2, 1, 4, 3 ]; // Input array Y[] let Y = [ 4, 1, 2, 4 ]; // Function call console.log(min_operations(N, X, Y)); // This code is contributed by ratiagrawal. |
5
Time Complexity: O(N)
Auxiliary Space: O(N)