How to find the optimal strategy in this scenario? - algorithm

Question

The scenario looks something like this:
Given an array of 1's and 2's, we want to make it all ones. There are following constraints:
In every step, one of the 2's could exchange its position with the adjacent one.
1 2 1 2 1
could be transformed to:
2 1 1 2 1
in single step.
If a 2 appears at the edge, it could be broken down into 2 ones in a single step.
2 1 2 1
1 1 1 2 1
in single step
If two twos are adjacent they could be broken down into ones.
1 2 2 1
into
1 *1 1 1 1* 1
it costs us 2 steps.
So the problem is, given n steps can we make it all one?
I don't want the complete answers some small insight would also do.

Answer 1

Here is a constructive solution.
Lemma: It's never optimal to broke more than one 2 near the border (both left and right).
Proof: Assume in optimal solution we've broken the two leftmost 2s near the left border and their positions in array were x and y (x <= y). We used x + y + 2 operations to brake them up. But if we just move them in adjacent tiles and perform 3rd type of operation, we achieve only y - x + 1 operations. So previous solution wasn't optimal. Proved.
So there is just 4 cases:
Don't use 2nd operation at all (only if number of 2 is even).
Use 2nd operation only at left border (only if number of 2 is odd).
Use 2nd operation only at right border (only if number of 2 is odd).
Use 2nd operation at both borders (only if number of 2 is even).
After upper process we have even number of 2. So just pair them and brake via 3rd operation.
The complexity of solution is O(n), since we have O(n) input data it's the most optimal way to deal this problem.
Feel free to ask questions or code.

Answer 2

I tried to develop dynamic programming algorithm but could not find the optimal substructure.
This is the brute force, most time consuming, recursive solution.
We have to find whether we can reduce input to all 1's.
Input array has 1's and 2's and there are rules to convert 2's into 1's.
The naive approach is to apply the rule wherever possible and try to find out whether the output can be achieved
The pseudo-code-ey algorithm is :
boolean check(int[] input, int steps) {
if(steps == 0) {
return allOnes(input)
}
step--
boolean ans = false;
if(input[0] == 2) {
breakEdgeTwoIntoOne(input,0) // function for rule 2
revert(input) // convert input to original
ans = ans | check(input,steps)
}
if(input[input.length-1] == 2) {
breakEdgeTwoIntoOne(input,input.length - 1)
revert(input)
ans = ans | check(input,steps)
}
for(i=0;i<input.length-1;i++) {
if(input[i] == 2 && input[i+1] == 2) {
breakTowAdjecentTwosIntoOnes(input,i) // function for rule 3
revert(input)
ans = ans | check(input,steps)
}
}
for(i=0;i<input.length-1;i++) {
if( input[i] == 2 ) {
swapLeft(input, i) // function for rule 1
ans = ans | check(input,steps)
revert(input)
swapRight(input, i)
ans = ans | check(input,steps)
revert(input)
}
}
return ans;
}
The not-so-elegnet java implementation for all the functions :
static boolean check(int[] input, int steps) {
if (allOnes(input)) {
return true;
}
if (steps == 0) {
return allOnes(input);
}
steps--;
int original[] = new int[input.length];
System.arraycopy(input, 0, original, 0, input.length);
boolean ans = false;
if (input[0] == 2) {
ans = ans | check(breakEdgeTwoIntoOne(input, 0), steps);
System.arraycopy(original, 0, input, 0, input.length);
}
if (input[input.length - 1] == 2) {
ans = ans | check(breakEdgeTwoIntoOne(input, input.length - 1), steps);
System.arraycopy(original, 0, input, 0, input.length);
}
for (int i = 0; i < input.length - 1; i++) {
if (input[i] == 2 && input[i + 1] == 2) {
ans = ans | check(breakTowAdjecentTwosIntoOnes(input, i), steps);
System.arraycopy(original, 0, input, 0, input.length);
}
}
for (int i = 0; i < input.length - 1; i++) {
if (input[i] == 2) {
if (i != 0) {
ans = ans | check(swapTwoToLeft(input, i), steps);
System.arraycopy(original, 0, input, 0, input.length);
}
if (i != input.length - 1) {
ans = ans | check(swapTwoToRight(input, i), steps);
System.arraycopy(original, 0, input, 0, input.length);
}
}
}
return ans;
}
private static int[] breakTowAdjecentTwosIntoOnes(int[] input, int i) {
int op[] = new int[input.length + 2];
int k = 0;
for (int j = 0; j < input.length; j++) {
if (j == i || j == i + 1) {
op[k++] = 1;
op[k++] = 1;
// j++;
} else {
op[k++] = input[j];
}
}
return op;
}
private static int[] breakEdgeTwoIntoOne(int[] input, int i) {
int op[] = new int[input.length + 1];
if (i == 0) {
op[0] = 1;
op[1] = 1;
System.arraycopy(input, 1, op, 2, input.length - 1);
} else {
op[op.length - 2] = 1;
op[op.length - 1] = 1;
System.arraycopy(input, 0, op, 0, input.length - 1);
}
return op;
}
private static int[] swapTwoToRight(int[] input, int i) {
if (i != input.length - 1) {
int k = input[i + 1];
input[i + 1] = input[i];
input[i] = k;
}
return input;
}
private static int[] swapTwoToLeft(int[] input, int i) {
if (i != 0) {
int k = input[i - 1];
input[i - 1] = input[i];
input[i] = k;
}
return input;
}
private static boolean allOnes(int[] input) {
for (int x : input) {
if (x != 1)
return false;
}
return true;
}
Some of test cases
[1,2,1,2,1],1 => false
[1,2,1,2,1],2 => true
[1,2,1,2,1],3 => true
[2,2,2],1 => false
[2,2,2],2 => true
[2,2,2],3 => true
[2,2,2],4 => true