public int numIslands(char[][] grid) {
int counter = 0;
int n = grid.length;
if (n == 0) return 0;
int m = grid[0].length;
if (m == 0) return 0;
int[][] direct = new int[][] {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '1') {
counter++;
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
grid[i][j] = 0;
q.add(i);
q.add(j);
while (!q.isEmpty()) {
int r = q.poll();
int c = q.poll();
for (int[] d : direct) {
int rr = d[0] + r;
int cc = d[1] + c;
if (rr >= 0 && rr < n && cc >= 0 && cc < m && grid[rr][cc] == '1') {
grid[rr][cc] = 0;
q.add(rr);
q.add(cc);
}
}
}
}
}
}
return counter;
}
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");
}
}
synchronized void removeUpTo(long l) {
long bytesFreed = 0;
while (!chunks.isEmpty()) {
Chunk c = chunks.getFirst();
if (c.getSeqID() > l) chunks.addFirst(c);
else bytesFreed += c.getData().length;
}
if (bytesFreed > 0) {
dataSizeBytes -= bytesFreed;
notifyAll();
}
}
private Collection<SchemaTypeInfo> gatherInheritors(XmlTagImpl xml) {
XmlAttribute name = getNameAttr(xml);
if (name == null || StringUtil.isEmptyOrSpaces(name.getValue())) return null;
String localName = name.getValue();
final boolean hasPrefix = localName.contains(":");
localName = hasPrefix ? localName.substring(localName.indexOf(':') + 1) : localName;
final String nsPrefix =
hasPrefix ? name.getValue().substring(0, name.getValue().indexOf(':')) : null;
final XmlFile file = XmlUtil.getContainingFile(xml);
if (file == null) return null;
final Project project = file.getProject();
if (project == null) return null;
final Set<SchemaTypeInfo> result = new HashSet<SchemaTypeInfo>();
final ArrayDeque<SchemaTypeInfo> queue = new ArrayDeque<SchemaTypeInfo>();
String nsUri;
if (!hasPrefix) {
nsUri = getDefaultNs(file);
} else {
nsUri = XmlUtil.findNamespaceByPrefix(nsPrefix, file.getRootTag());
}
if (nsUri == null) return null;
queue.add(new SchemaTypeInfo(localName, true, nsUri));
final PairConvertor<String, String, List<Set<SchemaTypeInfo>>> worker =
SchemaTypeInheritanceIndex.getWorker(project, file.getContainingFile().getVirtualFile());
while (!queue.isEmpty()) {
final SchemaTypeInfo info = queue.removeFirst();
final List<Set<SchemaTypeInfo>> childrenOfType =
worker.convert(info.getNamespaceUri(), info.getTagName());
for (Set<SchemaTypeInfo> infos : childrenOfType) {
for (SchemaTypeInfo typeInfo : infos) {
if (typeInfo.isIsTypeName()) {
queue.add(typeInfo);
}
result.add(typeInfo);
}
}
}
return result;
}
private static Record readRecord(ArrayDeque<String> stack) {
Record rec = new Record();
for (; ; ) {
if (stack.isEmpty()) {
return rec;
}
String line = stack.pop();
assert !line.isEmpty();
if ("%%".equals(line)) {
return rec;
}
if (line.charAt(0) == ' ') {
// continuation
continue;
}
int sep = line.indexOf(':');
String name = line.substring(0, sep).trim();
String value = line.substring(sep + 1).trim();
Field field = Field.forName(name);
assert field != null;
switch (field) {
case Deprecated:
case PreferredValue:
case Prefix:
case Subtag:
case Tag:
case Type:
rec.entries.put(field, value);
break;
case Added:
case Comments:
case Description:
case Macrolanguage:
case Scope:
case SupressScript:
default:
// ignore these
break;
}
}
}
static void solve() {
int r = in.nextInt();
int c = in.nextInt();
int sy = in.nextInt() - 1;
int sx = in.nextInt() - 1;
int gy = in.nextInt() - 1;
int gx = in.nextInt() - 1;
char[][] t = new char[r][c];
for (int i = 0; i < r; i++) {
t[i] = in.next().toCharArray();
}
ArrayDeque<int[]> que = new ArrayDeque<>();
BitSet visited = new BitSet();
que.add(new int[] {sy, sx, 0});
visited.set(sy * c + sx);
int[] dx = {0, 1, 0, -1};
int[] dy = {1, 0, -1, 0};
int[][] dist = new int[r][c];
while (!que.isEmpty()) {
int[] p = que.pollFirst();
int cy = p[0];
int cx = p[1];
int d = p[2];
dist[cy][cx] = d;
for (int i = 0; i < 4; i++) {
int ny = cy + dy[i];
int nx = cx + dx[i];
if (ny < 0 || nx < 0 || r <= ny || c <= nx) continue;
if (visited.get(ny * c + nx) || t[ny][nx] == '#') continue;
que.add(new int[] {ny, nx, d + 1});
visited.set(ny * c + nx);
}
}
out.println(dist[gy][gx]);
}
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;
}
private void processReferences(
JsonSchemaObject root,
Set<JsonSchemaObject> objects,
@Nullable JsonSchemaExportedDefinitions definitions) {
final ArrayDeque<JsonSchemaObject> queue = new ArrayDeque<>();
queue.addAll(objects);
int control = 10000;
while (!queue.isEmpty()) {
if (--control == 0) throw new RuntimeException("cyclic definitions search");
final JsonSchemaObject current = queue.removeFirst();
if ("#".equals(current.getRef())) continue;
if (current.getRef() != null) {
final JsonSchemaObject definition =
findDefinition(myKey, current.getRef(), root, definitions);
if (definition == null) {
if (definitions == null) {
// just skip current item
current.setRef(null);
continue;
}
throw new RuntimeException("Can not find definition: " + current.getRef());
}
if (definition.getRef() != null && !"#".equals(definition.getRef())) {
queue.addFirst(current);
queue.addFirst(definition);
continue;
}
final JsonSchemaObject copy = new JsonSchemaObject();
copy.setDefinitionAddress(current.getRef());
copy.mergeValues(definition);
copy.mergeValues(current);
current.copyValues(copy);
current.setRef(null);
}
}
}
public void dump() {
ArrayDeque<Integer> framePointersCopy = framePointers.clone();
ArrayList<Integer> framePointersList = new ArrayList<Integer>();
// Since ArrayDeque does not inherit from ArrayList like Stack
// inherits from Vector, we must copy the ArrayDeque's contents
// into an ArrayList.
while (!framePointersCopy.isEmpty()) {
framePointersList.add(framePointersCopy.removeLast());
}
int first = framePointersList.remove(0);
// Makes printing frames a lot easier by grouping each frame together by separating
// the frames in runStack using the subList method in List which ArrayList inherits
// from.
while (!framePointersList.isEmpty()) {
System.out.print(runStack.subList(first, framePointersList.get(0)) + " ");
first = framePointersList.remove(0);
}
System.out.println(runStack.subList(first, runStack.size()));
}
/**
* {@link LanguageSubtagRegistryData}
*
* @param langSubtagReg the language subtag registry file
* @throws IOException if an I/O error occurs
*/
static void languageSubtagRegistry(Path langSubtagReg) throws IOException {
List<String> lines = Files.readAllLines(langSubtagReg, StandardCharsets.UTF_8);
ArrayDeque<String> stack = new ArrayDeque<>(lines);
ArrayList<Record> language = new ArrayList<>();
ArrayList<Record> region = new ArrayList<>();
ArrayList<Record> grandfathered = new ArrayList<>();
ArrayList<Record> redundant = new ArrayList<>();
ArrayList<Record> extlang = new ArrayList<>();
ArrayList<Record> script = new ArrayList<>();
ArrayList<Record> variant = new ArrayList<>();
// skip first two lines (file date + %% separator)
stack.pop();
stack.pop();
while (!stack.isEmpty()) {
Record rec = readRecord(stack);
String type = rec.get(Field.Type);
assert type != null;
if ("language".equals(type)) {
if (rec.has(Field.PreferredValue)) {
language.add(rec);
}
}
if ("region".equals(type)) {
if (rec.has(Field.PreferredValue)) {
region.add(rec);
}
}
if ("grandfathered".equals(type)) {
grandfathered.add(rec);
}
if ("redundant".equals(type)) {
if (rec.has(Field.PreferredValue)) {
redundant.add(rec);
}
}
if ("extlang".equals(type)) {
if (rec.has(Field.PreferredValue)) {
extlang.add(rec);
}
}
if ("script".equals(type)) {
if (rec.has(Field.PreferredValue)) {
script.add(rec);
}
}
if ("variant".equals(type)) {
if (rec.has(Field.PreferredValue)) {
variant.add(rec);
}
}
}
/* Generate LanguageSubtagRegistryData#scriptData entries */
System.out.println("--- [LanguageSubtagRegistryData#scriptData] ---");
for (Record record : script) {
assert record.has(Field.Prefix);
System.out.printf(
"%s -> %s [%s]%n",
record.get(Field.Subtag), record.get(Field.PreferredValue), record.get(Field.Prefix));
}
System.out.println();
assert script.isEmpty() : "no preferred values for 'script' expected";
/* Generate LanguageSubtagRegistryData#extlangData entries */
System.out.println("--- [LanguageSubtagRegistryData#extlangData] ---");
for (Record record : extlang) {
assert record.has(Field.Prefix);
assert record.get(Field.Subtag).equals(record.get(Field.PreferredValue))
: record.get(Field.Subtag);
System.out.printf(
"map.put(\"%s\", \"%s\");%n", record.get(Field.Subtag), record.get(Field.Prefix));
}
System.out.println();
/* Generate LanguageSubtagRegistryData#variantData entries */
System.out.println("--- [LanguageSubtagRegistryData#variantData] ---");
for (Record record : variant) {
assert record.has(Field.Prefix);
System.out.printf(
"%s -> %s [%s]%n",
record.get(Field.Subtag), record.get(Field.PreferredValue), record.get(Field.Prefix));
System.out.printf(
"map.put(\"%s\", \"%s\");%n", record.get(Field.Subtag), record.get(Field.PreferredValue));
}
System.out.println();
assert variant.size() == 1 : "Only one variant entry expected";
assert variant.get(0).get(Field.Subtag).equals("heploc");
assert variant.get(0).get(Field.PreferredValue).equals("alalc97");
/* Generate LanguageSubtagRegistryData#regionData entries */
System.out.println("--- [LanguageSubtagRegistryData#regionData] ---");
for (Record record : region) {
assert !record.has(Field.Prefix);
System.out.printf(
"map.put(\"%s\", \"%s\");%n",
record.get(Field.Subtag).toLowerCase(Locale.ROOT), record.get(Field.PreferredValue));
}
System.out.println();
/* Generate LanguageSubtagRegistryData#languageData entries */
System.out.println("--- [LanguageSubtagRegistryData#languageData] ---");
for (Record record : language) {
assert !record.has(Field.Prefix);
System.out.printf(
"map.put(\"%s\", \"%s\");%n", record.get(Field.Subtag), record.get(Field.PreferredValue));
}
System.out.println();
/* Generate LanguageSubtagRegistryData#grandfatheredData entries */
System.out.println("--- [LanguageSubtagRegistryData#grandfatheredData] ---");
for (Record record : grandfathered) {
assert !record.has(Field.Prefix);
if (record.has(Field.PreferredValue)) {
System.out.printf(
"map.put(\"%s\", \"%s\");%n",
record.get(Field.Tag).toLowerCase(Locale.ROOT), record.get(Field.PreferredValue));
} else {
System.out.printf(
"map.put(\"%s\", \"%s\");%n",
record.get(Field.Tag).toLowerCase(Locale.ROOT), record.get(Field.Tag));
}
}
System.out.println();
/* Generate LanguageSubtagRegistryData#redundantData entries */
System.out.println("--- [LanguageSubtagRegistryData#redundantData] ---");
for (Record record : redundant) {
assert !record.has(Field.Prefix);
System.out.printf(
"map.put(\"%s\", \"%s\");%n",
record.get(Field.Tag).toLowerCase(Locale.ROOT), record.get(Field.PreferredValue));
}
System.out.println();
}
