Making an array equal by decreasing elements adjacent to each other - c++

Question

I was doing this exercise in my computer science class for a warm up earlier, which was to find the minimum number of moves to make all the elements in an array equal to each other, where the only operation is to subtract one from an element in an array.
This made me curious about extensions to the problem; for example I immediately thought of an extension, how many moves will it take to make all the elements in an array equal to each other, where the only operation is to subtract one from two elements that are adjacent to each other.
For example:
Given array [4, 6, 4], we can decrease elements in index 0 and 1 to get [3, 5, 4], then [3, 4, 3], then [2, 3, 3], and then decrease elements in index 1 and 2 to get [2, 2, 2]. This would take 4 moves. However, how would we extend this kind of thinking to larger arrays, where we cannot trace this out by hand like I just did above?

Answer 1

You can find whether this is possible (and minimum number of moves) in O(n) time, in a way that should generalize to larger array decreases.
The first step is to convert our array A to the first-difference array D, whose elements are D = [A[1]-A[0], A[2]-A[1], ..., A[n-1]-A[n-2]]. We are done when D is the all-zero array. Now, think about how the operations on A translate to changes in D. It's different when n is even and odd, too, so focus on one case at a time.
Odd length
When A has odd length, there are more cases where no solution is possible.
Suppose 'A' has 7 elements. There's 6 possible moves, so let's calculate what effect each has on D.
A = [a_0, a_1, a_2, a_3, a_4, a_5, a_6]
D = [d_0, d_1, d_2, d_3, d_4, d_5]
Moves available:
d_1 += 1
(d_0 -= 1, d_2 += 1)
(d_1 -= 1, d_3 += 1)
(d_2 -= 1, d_4 += 1)
(d_3 -= 1, d_5 += 1)
d_4 -= 1
Some observations:
The interactions between even and odd indices of D are completely disjoint (this is true for the even-length case too).
d_5 can only increase, d_0 can only decrease.
I found it helpful to think of this as a 'flow' from left to right in D:
d_0 --> d_2 --> d_4 --> SINK
SOURCE --> d_1 --> d_3 --> d_5
this makes things easier: there's only one way to try to make D all zero, so we can just try that.
If D[0] is negative, this is impossible. If it's positive, add D[0] moves to our counter, and add D[0] to D[2]
If D[2] is negative, this is impossible. If it's positive, add D[2] moves to our counter, and add D[2] to D[4]
If D[4] is negative, this is impossible. Otherwise, add D[4] to our counter. D[4] points to a sink, so we are done.
I haven't explained the process for the odd vertices, but it's the same logic-- there's at most one way to make D all zero, following the flow.
Even-length
The even-length array case is similar, except the flow-network has different endpoints.
A = [a_0, a_1, a_2, a_3, a_4, a_5, a_6, a_7]
D = [d_0, d_1, d_2, d_3, d_4, d_5, d_6]
Moves available:
d_1 += 1
(d_0 -= 1, d_2 += 1)
(d_1 -= 1, d_3 += 1)
(d_2 -= 1, d_4 += 1)
(d_3 -= 1, d_5 += 1)
(d_4 -= 1, d_6 += 1)
d_5 -= 1
d_0 --> d_2 --> d_4 --> d_6
SOURCE --> d_1 --> d_3 --> d_5 --> SINK
This means that the odd-indices can have any values without changing the solvability, while the even indices must become all zero with only positive transfers from left to right. Positive flow still moves in exactly one direction in both cases.
I've written a Python solution implementing the logic above. There's one caveat-- I haven't been able to rigorously test it against random input. There's no obviously correct brute-force solution to this problem, so there may be failing testcases that I missed.
def min_decreases_to_get_equal(nums: List[int]) -> Optional[int]:
"""Given an array of integers, returns the number of moves
to make all elements equal, or None if impossible.
A move is selecting two adjacent elements and dec. both by 1."""
n = len(nums)
assert n >= 2
if n == 2:
return 0 if nums[0] == nums[1] else None
differences = [nums[i] - nums[i - 1] for i in range(1, n)]
evens = differences[0::2]
odds = differences[1::2]
if n % 2 == 0: # Even length case
total_cost = 0
m1 = len(evens)
for i, x in enumerate(evens):
if x < 0:
return None
elif x > 0:
# Last element can't be decreased
if i == m1 - 1:
return None
total_cost += abs(x)
evens[i + 1] += abs(x)
m2 = len(odds)
for i, x in enumerate(odds):
if x < 0:
total_cost += abs(x) * (i + 1)
elif x > 0:
total_cost += abs(x)
if i < m2 - 1:
odds[i + 1] += x
return total_cost
else: # Odd length case
total_cost = 0
m1 = len(evens)
for i, x in enumerate(evens):
if x < 0:
return None
elif x > 0:
if i < m1 - 1:
evens[i + 1] += abs(x)
total_cost += abs(x)
m2 = len(odds)
for i in reversed(range(m2)):
x = odds[i]
if x < 0:
if i != 0:
odds[i - 1] -= abs(x)
total_cost += abs(x)
elif x > 0:
return None
return total_cost
Example tests:
[4, 6, 4] --> 4,
[3, 2, 3] --> None,
[0, 8, 8, 14, 8] --> 34,
[2, 5, 1, 6, 12, 11, 7, 0, 1, 1] --> 33

Answer 2

Let's start with the problem that we want to find out what is the smallest number of operations. If we know what is the largest number that equalizes all arrays? We can subtract that number from each other in the array to get the answer. Naively, you can solve this problem by searching for the smallest number in the array and loop checking from 0 to min(a[i]) then find the minimum operations.
My code in C++
// print -1 if not possible to equalize array
void solve() {
int N;
scanf("%d", &N);
vector<int> a(N);
int minimum=INT_MAX;
for(int i=0; i<N; ++i) {
scanf("%d", &a[i]);
minimum=min(minimum, a[i]);
}
if(N==1) { // Initially check when N=1 or N=2
printf("0\n");
return;
}
else if(N==2) {
printf("%d\n", (a[0]==a[1] ? 0 : -1));
return;
}
vector<int> temp=a; // temporary array for storing array before operation
for(int target=minimum; target>=0; --target) {
a=temp;
bool check=true; // check array equal?
int operation=0; // count number operations
for(int j=0; j<N-1; ++j) {
int subtract=a[j]-target;
operation+=2*subtract;
a[j]-=subtract;
a[j+1]-=subtract;
if(a[j]<target || a[j+1]<target) { // all element should equal to target
check=false;
break;
}
}
if(check==true) {
printf("%d\n", operation);
return;
}
}
printf("-1\n"); // not possible
}
But the above method will be slow when N is large.
For this problem, the Greedy Algorithm can be used to solve it. Now let's look at the situations when this array can't be equalized. If you want to make an array with a[i-1] != a[i] to be equal, what do you have to do? Assume we're iterating over an array and come into the following cases.
First, if a[i-1] > a[i] , then we have to perform operation at the left-hand in order to equal make it to the right-hand side, that is, a[i-2] and a[i-1] must be executed. For example 8 8 7 to 7 7 7.
Please note that if i equals 1, it needs the initial element of an array. It will be unable to operate.
Second, if a[i-1] < a[i] , then we have to perform operation at the right-hand in order to make it equal to the left-hand side, that is, a[i] and a[i+1] must be executed. For example 5 6 6 to 5 5 5.
Please note that if i equals N-1, it is the last element of an array. It will be unable to operate. Naturally, the prior ones have been equalized.
After that, we can use Greedy to keep the array equal. We'll traverse over the array one by one, checking for the conditions listed above. If it can do it, it ought to. Continue until you are unable to do so or discover that this array is stuck at the very first or final position. This one will be quicker than the previous one.
Here is my code.
// print -1 if not possible to equalize array
void solve() {
int N;
scanf("%d", &N);
vector<int> a(N);
for(int i=0; i<N; ++i) {
scanf("%d", &a[i]);
}
if(N==1) {
printf("0\n");
return;
}
else if(N==2) {
printf("%d\n", (a[0]==a[1] ? 0 : -1));
return;
}
if(a[N-2]<a[N-1] || a[0]>a[1]) {
printf("-1\n");
return;
}
long long operation=0;
bool check=true; // check if the array has changed
while(check) {
check=false;
for(int i=1; i<N; ++i) {
if(a[i-1]<a[i]) {
if(i==N-1) {
printf("-1\n");
return;
}
check=true;
int subtract=a[i]-a[i-1];
operation+=2*subtract;
a[i]-=subtract;
a[i+1]-=subtract;
if(a[i]<0 || a[i+1]<0) {
printf("-1\n");
return;
}
}
else if(a[i-1]>a[i]) {
if(i==1) {
printf("-1\n");
return;
}
check=true;
int subtract=a[i-1]-a[i];
operation+=2*subtract;
a[i-2]-=subtract;
a[i-1]-=subtract;
if(a[i-2]<0 || a[i-1]<0) {
printf("-1\n");
return;
}
}
}
}
printf("%lld\n", (a[N-1]>=0 ? operation : -1)); // array already equal but may less than zero
}
This may be accomplished in a variety of ways, and there is a better approach than the one I've presented. However, I believe that this is sufficient to go through test cases 1 <= N <= 105 and 0 <= a[i] <= 109.