public Main() {
try {
BufferedReader in;
in = new BufferedReader(new InputStreamReader(System.in)); // Used for CCC
int numLights = Integer.parseInt(in.readLine());
int[] states = new int[numLights];
for (int i = 0; i < numLights; i++) {
states[i] = Integer.parseInt(in.readLine());
}
ArrayDeque<Scenario> Q = new ArrayDeque<Scenario>();
HashMap<String, Integer> dp = new HashMap<String, Integer>();
int moves = 0;
Q.addLast(new Scenario(states));
while (!Q.isEmpty()) {
int size = Q.size();
for (int q = 0; q < size; q++) {
Scenario temp = Q.removeFirst();
if (isEmpty(temp.states)) {
System.out.println(moves);
return;
} else {
for (int i = 0; i < temp.states.length; i++) {
if (temp.states[i] == 0) {
int[] newArr = Arrays.copyOf(temp.states, temp.states.length);
newArr[i] = 1;
newArr = fixArray(newArr);
String arr = "";
for (int p = 0; p < newArr.length; p++) arr += newArr[p];
if (dp.get(arr) == null) {
dp.put(arr, moves);
Q.addLast(new Scenario(newArr));
} else {
int val = dp.get(arr);
if (val != 0 && moves < val) {
dp.put(arr, moves);
Q.addLast(new Scenario(newArr));
}
}
// outputArr(newArr);
}
}
}
}
moves++;
}
} catch (IOException e) {
System.out.println("IO: General");
}
}
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
List<List<Integer>> r = new ArrayList<List<Integer>>();
ArrayDeque<TreeNode> q = new ArrayDeque<TreeNode>();
if (root == null) return r;
q.offer(root);
boolean reversedOrder = false;
while (!q.isEmpty()) {
int len = q.size();
List<Integer> level = new LinkedList<Integer>();
for (int i = 0; i < len; i++) {
TreeNode n = q.poll();
if (reversedOrder) level.add(0, n.val);
else level.add(n.val);
if (n.left != null) q.offer(n.left);
if (n.right != null) q.offer(n.right);
}
r.add(level);
reversedOrder = !reversedOrder;
}
return r;
}
/**
* Return the root hash of a binary tree with leaves at the given depths and with the given hash
* val in each leaf.
*/
byte[] hashed(byte[] val, Integer... depths) {
ArrayDeque<Integer> dstack = new ArrayDeque<Integer>();
ArrayDeque<byte[]> hstack = new ArrayDeque<byte[]>();
Iterator<Integer> depthiter = Arrays.asList(depths).iterator();
if (depthiter.hasNext()) {
dstack.push(depthiter.next());
hstack.push(val);
}
while (depthiter.hasNext()) {
Integer depth = depthiter.next();
byte[] hash = val;
while (depth.equals(dstack.peek())) {
// consume the stack
hash = Hashable.binaryHash(hstack.pop(), hash);
depth = dstack.pop() - 1;
}
dstack.push(depth);
hstack.push(hash);
}
assert hstack.size() == 1;
return hstack.pop();
}
