exec_outcome stringclasses 1
value | code_uid stringlengths 32 32 | file_name stringclasses 111
values | prob_desc_created_at stringlengths 10 10 | prob_desc_description stringlengths 63 3.8k | prob_desc_memory_limit stringclasses 18
values | source_code stringlengths 117 65.5k | lang_cluster stringclasses 1
value | prob_desc_sample_inputs stringlengths 2 802 | prob_desc_time_limit stringclasses 27
values | prob_desc_sample_outputs stringlengths 2 796 | prob_desc_notes stringlengths 4 3k ⌀ | lang stringclasses 5
values | prob_desc_input_from stringclasses 3
values | tags listlengths 0 11 | src_uid stringlengths 32 32 | prob_desc_input_spec stringlengths 28 2.37k ⌀ | difficulty int64 -1 3.5k ⌀ | prob_desc_output_spec stringlengths 17 1.47k ⌀ | prob_desc_output_to stringclasses 3
values | hidden_unit_tests stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PASSED | 89f3d903fb2cab55fc43f4d38e79baed | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
import java.lang.Math;
public final class Solution {
static int ret_ans(ArrayList<Integer> ones, ArrayList<Integer> zeroes, int dp[][], int i, int j) {
if (i == ones.size()) {
return 0;
} else if (j == zeroes.size()) {
return -1;
} else if (dp[i... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | de65e656650d7d28ca47b55bde038ca9 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
public class cf {
static Reader sc = new Reader();
// static PrintWriter out = new PrintWriter(System.out);
static int mod = (int) 1e9 + 7;
public static void main(String[] args) throws FileNotFoundException {
int n = sc.ni();
int[] arr = sc.nai(n);
Array... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 964c302bd1f01afac728ead80360f82d | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class CodeForces {
public static void main(String[] args) throws IOException {
reader input = new reader();
PrintWriter output = new PrintWriter(Syste... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ec2ac690f14b2d3a03e90a3d350763d2 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class First {
public static void main(String[] args) {
InputStream inputStream = System.in... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | efb85d61dde780c59873c0e1f600e0e3 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | /**
* Created by Himanshu
**/
import java.util.*;
import java.io.*;
import java.math.*;
public class D1525 {
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(System.out);
Reader s = new Reader();
int n = s.i();
int [] ar... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | f4bc75d2656bd4dfe737faed51a4e4e9 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | /*input
5
0 0 0 0 0
*/
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
static PrintWriter out;
static int MOD = 1000000007;
static FastReader scan;
/*-------- I/O usaing short named function ---------*/
public static String ns(){return scan.next();}
public stat... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 0d1489f77da09935052806034879190b | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
// import java.lang.*;
import java.io.*;
// THIS TEMPLATE MADE BY AKSH BANSAL.
public class Solution {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 3febb07191f52888768378216dfde6b6 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.math.*;
import java.io.*;
public class A{
static FastReader scan=new FastReader();
public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
static LinkedList<Integer>edges[];
// static LinkedList<Pair>edges[];
static boolean stdin = true;... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 08619dd694ae5c2708e22f5446fdeb8e | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.io.*;
import java.util.*;
public class CodeForces extends Functions {
/*
--> we have some index having 1 in it which are stored in ones.
--> we have some index having 0 on it which are stored in ones.
--> we need to select exactly one 0index for one 1index.
--> so in to... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 3b3d5fed3a81dd88e8e88296517d4079 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Codeforces
{
public static void main(String args[])throws Exception
{
BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb=new StringBuilder();
int n=Integer.parseInt(bu.readLine());
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | f6d17a808ff74e93d06705c0aae7cb82 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | //package com.wissamfawaz;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class D {
static final long MOD = 1000000007L;
//static final long MOD2 = 1000000009... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | b1e514b18446693bdb065f4cfa1e1e50 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
public class D {
// *** ++
// +=-==+ +++=-
// +-:---==+ *+=----=
// +-:---... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | e10ffe6d32cef74d79e4c66ee6555e16 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
im... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 3f69a9f4a090902828080178cbb1e8da | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
im... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 42ff15d0afc46694a45219d66b6f4c95 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class App {
public String getGreeting() {
return "Hello World!";
}
st... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 7f9426b23d7bc43a8f1d0f42955809c1 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class D {
static int n;
static int[] arr;
public static void main(String[] args) throws IOException{
FastIO file = new FastIO();
n = file.nextInt();
arr = new int[n];
for (int i=0; i<n; i++){
arr[i] = file.nextInt();
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 0b4c1ef6edac40c5d44a5ce960d237da | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;
/*
-> Give your 100%, that's it!
-> Rules To Solve Any Problem:
1. Read the problem.
2. Think About It.
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 29eb44657929ebf4574eb2c24078ea50 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
public class Solution
{
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 9d091bb42c9f520d783b5aac277ea144 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
public class Main {
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
StringTo... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 17b66fc80de588aaffdd63af626dafd7 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class Main {
static int[] a=new int[5010];
static int[] b=new int[5010];
static int[][] f=new int[5010][5010];
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int l=1,r=1;
for(int i=1;i<=n;i++)
{
int x=sc.nextInt()... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 9fa632a1c78372f2d807a1587be50152 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codeforces {
public static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 6fe326c2ced852356a2244a529433561 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
public class b1 {
public static final int inf = 100000000;
public static void main(String[] args){
FastReader scan = new... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 94fa82af259d56d03c6b789f301efbdc | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class b1 {
public static final int inf = 100000000;
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] a = new int[n];
Vector<Vector<Integer> > v = new Vector<Vector<Integer> >();
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 5e468332de77a43263095933873bad90 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.io.*;
import java.util.*;
public class D implements Runnable {
List<Integer> seats = new ArrayList<>(), empty = new ArrayList<>();
long[][] dp;
void solve() throws IOException {
int n = ri();
dp = new long[n + 1][n + 1];
for (int i = 0; i < n; i++) {
int ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 8aea25fb6657c3f48dd506c7a151090e | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
public class chair{
static int INF = 10000000;
static ArrayList<Integer> ar = new ArrayList<Integer>();
static ArrayList<Integer> aar = new ArrayList<Integer>();
static int[][] dp = new int[5005][5005];
static int helper(int i ,int j,int n,int... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ca3d817bb5485a2e8723a7b390bbe4b9 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class ArmChairs {
public static int solution(int n, int[] arr) {
ArrayList<Integer> one = new ArrayList<Integer>();
ArrayList<Integer> zero = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
if (arr[i] == 1)... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ea5aba233b765a5bafa2bcf62e71eb14 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class Main {
static int[] a=new int[5010];
static int[] b=new int[5010];
static int[][] f=new int[5010][5010];
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int l=1,r=1;
for(int i=1;i<=n;i++)
{
int x=sc.nextInt()... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ba46f584431064e7f14311d8ee5c9f45 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class D {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int t = 1;... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ffe5311b79ca8220186f793b18286256 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | /*
Author: Aman Patel
Date: 16-05-2021
*/
import java.io.*;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Ed109 {
static int N = 5000;
static long[][] dp_arr = new long[N + 5][N + 5];
//static int _count = 0;
public static void main(String[] arg... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 6ea7af959ed50654701eb47b23a5961a | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
import java.util.stream.IntStream;
public class Main {
static long startTime = System.currentTimeMillis();
// for global initializations and methods starts here
// global initialisations and methods end here
static void run(){
boolean tc = fals... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | b83ea6932d6a2a46b774cb5fd6cb61b7 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class D {
public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
readInput();
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 13012935babe450c1ae5e79a7512ab2c | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | f3fe29f99bcad6f83502d5207d9f4d31 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
/**
* @author Mubtasim Shahriar
*/
public class Armcharis {
public static void main(String[] args) {
InputStream inputStream ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 7bdf01cd092b8143ac9abbf2e1eb9f04 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class SeparateRough {
static Scanner scn = new Scanner(System.in);
public static void main(String args[]) {
int n = scn.nextInt();
int[] chair = new int[n];
for (int i = 0; i < chair.length; i++) {
chair[i] = scn.nextInt();
}
int[][] dp = new int[n + 1][n + 1];
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 44cc485c16c898bc4908af7bdb32f5c1 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.Arrays;
import java.util.Scanner;
public class P1525D {
public static int[] ones, zeros;
public static int[][] memo;
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int[] arr = new int[n];
int oneCount = ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 9ab3423e07fdec39f323adac0ee83b49 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | // package com.company;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main{
public static void main(String args[]){
InputReader in=new InputReader(System.in);
TASK solver = new TASK();
int t=1;
// t = in.nextInt();
for(int i=1;i<=t;i++)
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 243dd9023eb45ea9f159b9b75f97cfcb | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import static java.lang.Math.max;
import static java.lang.Math.min;
import... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 7a25c2b0360039c3110146529f5483a5 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.io.*;
import java.util.*;
public class A
{
static int n;
static int[] arr;
static char[] s;
public static void main(String[] args) throws IOException
{
f = new Flas... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 6796e7641148b969543d73a7a32cf92b | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
public class Armchairs
{
public static int val(int b[],int m,int c[],int n,int dp[][])
{
if(dp[m][n]>-1)
{
return dp[m][n];
}
else
if(m==0)
{
return 0;
}
else
if(n==0)
{
return 2099999999;
}
else
{
return dp[m][... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | d0b0de212191bed12caf13d18ce79bd8 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.function.BiConsumer;
import javax.sound.midi.SysexMessage;
import java.io.IOException;
impo... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 4573d3ee088283323242fee3c1e0dcd5 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
imp... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | add6b05c4136016392c37735f971d8ea | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
imp... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 28e0236db84a6fa6113ccaeb68329884 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class Armchairs {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] seats = new int[n];
ArrayList<Integer> occupied = new ArrayList<>();
for (int i=0;i<n;i++) {
int temp = scan.nextInt();
seats[i] = temp;
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 20a27f04ad3742d1dc0dbf9056b24eca | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.lang.*;
public class Codeforces {
static int t[][]=new int[5005][5005];
static Scanner sr=new Scanner(System.in);
static int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
public static int dp(int i,int j,A... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | d26f0b29bfdd5ee186f983e00cf0b66f | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
public class Main {
private static void run() throws IOException {
int n = in.nextInt();
int[] a = read_int_array(n);
int count_0 = 0;
for (int i = 0; i < n; i... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | f497f28cf618649f634b68c469ac1faa | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
public class Armchairs {
static ArrayList<Integer> f;
static ArrayList<Integer> u;
static int dp[][];
static int fun(int i, int j){
if(i... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 4041de6eb2b09d6a7b9ad6d3b0463f2d | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.io.*;
import java.util.*;
public class D {
static int[][] dp;
static int solve(int i,int j,ArrayList<Integer> A,ArrayList<Integer> B) {
if(i==A.size()) {
return 0;
}
if(j==B.size()) {
return 1000000009;
}
if(dp[i][j]!=-1) {
return dp[i][j];
}
int ans=10000000... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | e9c1c45188a4d1fb3287dfdb216e5330 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | //Some of the methods are copied from GeeksforGeeks Website
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
static Reader sc=new Reader();
// static FastReader sc=new FastReader(System.in);
static ArrayList<Integer> one;
static ArrayList<Integer> zero;
static long d... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | b1317adb0a6e000d9078b0e00fbb5008 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
/*
*/
public class P2 {
static FastReader sc=null;
public static void main(String[] args) {
sc=new FastReader();
//int t=sc.nextInt();
//while(t-->0) {
int n=sc.nextInt();
int a[]=sc.readArray(n);
ArrayList<Integer> ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 184ac3250e47ef250d617b7b9d53cae1 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Main {
static ArrayList<Integer> one,zero;
static int[][] dp;
static int func(int i,int j,int n,int m) {
if(dp[i][j]!=-1) return dp[i][j];
if(i==n) return 0;
int present=m-j;
int required=n-i;
if(required>present) return Integer.MAX_VALUE/2;
i... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | f273748a3152074923b5ef06e665b595 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;
public class ArmChairs {
static final Random random = new Random();
static class FastReader {
BufferedReader br;
StringTokenizer st;
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 23c894823119f25bb60b56837f658280 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Main {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader(... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 22aec2b55a4804cab4c5cc59ea448b8c | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
public class Solution {
static int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | d162f1c10672c04f64de4f1bbffd37c5 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
public class Main {
static long mod = 1000000007;
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
FastReader sc = new FastReader();
int t = 1;
while( t-- > 0) {
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ac6bdbda8ebb59ddd2a7360bb1b99ca6 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | //package com.example.practice.codeforces;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
public clas... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 7461a4430f0422d60bebb4a1e06f814c | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class Main {
public static int[][] dp;
public static List<Integer> ones, zeros;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 7dc2b60c20452779abd8ebc8ed2cf99f | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | //some updates in import stuff
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;
//key points learned
//max space ever that could be alloted in a program to pass in cf
//int[][] prefixSum = new int[... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 57702034c047224aa43431285ca30890 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.util.Map.Entry;
import java.math.*;
import java.sql.Array;
public class Simple{
public static class Pair implements Comparable<Pair>{
int x;
int y;
public Pair(int x,int y){
this.x = x;
this.y = y;
}
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 27b17337c0326cf3dea8c345c1163a4f | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
public class Main {
private static void run() throws IOException {
int n = in.nextInt();
int[] a = read_int_array(n);
int count_0 = 0;
for (int i = ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 7a7e0693470563d452641d13c637da3d | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Armchairs {
static final int INF = 1000000000;
public static void main(String[] args) {
InputReader reader = new InputReader(System.in);
PrintWriter writer = new PrintWriter(System.out, false);
int N = reader.nextInt();
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | b2cfa554be736d52789b9b967913b597 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | //package edu109div2;
import java.util.LinkedList;
import java.util.Scanner;
public class D_Armchairs {
public static void main(String[] args) {
int maxCost = 5000;
Scanner in = new Scanner(System.in);
int n = in.nextInt();
boolean[] occ = new boolean[n];
i... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 46d585b8156bf9a2d7e45d3c2ddea631 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class taskd {
public static void main(String[] args) {
FastScanner in = new FastScanner();
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | a14ae9a83f99202c16a447e42c37ad14 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Main {
public static void main(String args[])
{
FastReader input=new FastReader();
PrintWriter out=new PrintWriter(System.out);
int T=1;
while(T-->0)
{
int n=input.nextInt();
int a[]=new... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 66ebb7526cd959ba80334ab9d5fa86ee | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.Scanner;
public class Armchairs {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int[] chairs = new int[num];
int numOne = 0;
for (int i = 0; i < num; i++) {
chairs[i] = sc... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 75f7bf92cbd9cba997cb65a506a6fdce | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class E1525D {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
int n = scn.nextInt();
int[] arr = new int[n];
ArrayList<Integer> occupied = new ArrayList<>()... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 38971ad27ba66930a93bb56622e25b9f | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class Main {
static final long MOD=1000000007;
static final long MOD1=998244353;
static long ans=0;
//static ArrayList<Integer> ans=n... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 12f9582122bbed99c84cc485653569c7 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
public class D_1525 {
static int INF = (int)1e9;
static int n, m;
static int[] full, free;
static int[][] memo;
public static int dp(int i, int j) {
if(i == n)
return 0;
if(j == m)
return INF;
if(memo[i][j] != -1)
return memo[i][j];
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 1483738b9da1a3cdab1b6cb384057d63 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scn = new Scanner(System.in);
OutputWriter out = new OutputWriter(System.out);
// Always print a trailing "\n" and close the OutputWriter as shown at th... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | c29d7fe314e892d3d60df2a857db6f49 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
try (BufferedInputStream ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ac6ef1be75bb7db620d0eb780739bec0 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | //package Div_2B_Problems;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.ArrayList;
public class Armchairs {
static ArrayList<Integer> one;
static ArrayList<I... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | db837e4dd7dc6bbc789313aa6acd4a50 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class Solution {
public static int minMoves(int[] input) {
List<Integer> people = new ArrayList<Integer>();
List<Integer> chairs = new ArrayList<Integer>();
for (int i = 0; i < input.length; i++) {
if (input[i] == 1) {
people.add(i);
} else {
chairs.add(... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 75a5d5b1951d91e0588c0da825f11948 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Codeforces {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//int cases = Integer.parseInt(br.readLine());
//while(cases-- > 0) {
int n = Integer.parseInt(br.... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 2e8fc58f89b415073ed324b4b6cf5b78 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | /* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
public static int solve(int dp[][],int i,int j,ArrayList<Integer> al1,ArrayList<Integer> al2) {
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 0e8038093f0b39f492a4bb21db6a6d7f | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 202a098f6b0f58834fc22f5d59c1d81c | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
public class B{
static int n;
static int m;
static long[][] dp;
static int[] pos;
static int[] emp;
static long make(int i, int j)
{
if(i>=n)return 0;
if(j>=m)return (long)(1e12);
if(dp[i][j] != -1)return dp[i][j];
long ans = Math.abs(pos[i]-emp[j]) +... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 7c5ccb46736e0c9370aa75b4a8045a9d | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class E {
public static void main(String[] args) throws NumberFormatException, IOException {
// TODO Auto-generated method stub
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
int cn... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 34205452c0b443641a884304a66b63ec | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
import java.awt.*;
/*AUTHOR - SHIVAM GUPTA */
// U KNOW THAT IF THIS DAY WILL BE URS THEN NO ONE CAN DEFEAT U HERE ,JUst keep faith in ur strengths ..................................................
// ASCII = 48 + i ;// 2^28 = 268,435,456 > 2* 10^8 ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 61a7efcd70b10b74fc62c86698f75da1 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
public class Solution {
public static boolean sorted(int[] array) {
for(int i=0; i<array.length-1; i++) {
if(array[i] > array[i+1]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.n... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | e7b0e90a40436c83afc5249e81f8e16e | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
static long dp[][];
static long recurse(int arr0[],int arr1[],int i,int j){
if(i==arr1.length) return 0;
if(j==arr0.length) return 100000000000l;
if(dp[i][j]>=0) return dp[i][j];
long min;
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 11 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | aeb0c0a7eb71d061e6b46ca045eafea2 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class TaskD {
public static void main(String[] arg) {
final FastScanner in = new FastScann... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | fbbe686fef47ca6fd11c5b7030989be4 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class TaskD {
public static void main(String[] arg) {
final FastScanner in = new FastScann... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | a6f2cac593b2a7aee13e361b79097f22 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class TaskD {
public static void main(String[] arg) {
final FastScanner in = new FastScann... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 183812edac67e5e829a1da285602b607 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class TaskD {
public static void main(String[] arg) {
final FastScanner in = new FastScann... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 8b166b22a16907a7d3ffb3e3d1452b97 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.ObjectInputStream.GetField;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
imp... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 13cf95c2db95b9447d6996585aa25c89 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
/*
Challenge 1: Newbie to CM in 1year (Dec 2021 - Nov 2022) 5* Codechef
Challenge 2: CM to IM in 1 year (Dec 2022 - Nov 2023) 6* Codechef
Challenge 3: IM to GM in 1 year (Dec 2023 - Nov 2024) 7* Codechef
Goal: Become better in CP!... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 2d4cf76f93173ab5ec0107e325ff3dc1 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class _109D {
static BufferedReader br;
public static void main(String[] args) throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | ecad1a87d23cc5a16a1accc202b624ee | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Main {
//--------------------------INPUT READER---------------------------------//
static class fs {
public BufferedReader br;
StringTokenizer st = new StringTokenizer("");
public fs() { this(System.in); }
public fs(I... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | bc7a71482c8098e4f87b2e3ad4a56b7c | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 79412d4a04502b039351991099fe3483 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
public static long gdc(long a, long b) {
if (b > a) {
long t = a;
a = b;
b = t;
}
while (a % b != 0) {
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | d112bc8d254fb72e32b5e57175a02f00 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Bit... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 311ce6aa03125d78b9f997e46dee785f | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Bit... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 671b0a5c8f9e9f25f7ad4c153a6a820f | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Main {
static ArrayList<Integer> one=new ArrayList<>();
static ArrayList<Integer> zero=new ArrayList<>();
static long dp[][]= new long[5001][5001];
static long solve(int i,int j){
if (i==one.size())return 0;
if (j==zero.size())re... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 59a047ed9cbe1fd4e221d9316d4d972e | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class D {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
List<Integer> a1 = new ArrayList<>();
List<Integer> a0 = new ArrayList<>();
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 438edb5cd33253fb9b5baeaad0ae1a49 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | /*
* HI THERE! (:
*
* CREATED BY : NAITIK V
*
* JAI HIND
*
*/
import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
static FastReader sc=new FastReader();
static long dp[][];
static int mod=1000000007;
static int max;
public static void ... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | cb601b0db13248995683cd4948b9d8b9 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.math.BigInteger;
import java.util.*;
/*long startTime = System.currentTimeMillis(); //获取开始时间
* long endTime = System.currentTimeMillis(); //获取结束时间
* System.out.println("程序运行时间：" + (endTime - startTime) + "ms"); //输出程序运行时间
*/
public class Main{
static final... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 63fc8740d9ed783b13c216f86422b0c6 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.*;
public class Ishu
{
static Scanner scan = new Scanner(System.in);
static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
static void tc() throws Exception
{
int n = scan.nextInt();
int[] a = new int[n];
int one = 0;
i... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 9f2e5e4098d25a027e4dd52f0bfd1048 | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
public class codeforcesD{
static class FastReader
{
BufferedReader br;
StringTokenizer st;
pub... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | c6b22a02371df3842a2e8bbea3f460ac | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.StringJoiner;
public class D {
private static List<Long> chairs;
privat... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | d57f9e9cd796126538ae3805ed51856a | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import java.io.*;
import java.util.ArrayList;
import java.util.StringTokenizer;
import static java.lang.Double.parseDouble;
import static java.lang.Integer.compare;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.in;
import static java.lang.Syst... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output | |
PASSED | 5afdc6d3f250fb698a48530a4f7f7daf | train_110.jsonl | 1621152000 | There are $$$n$$$ armchairs, numbered from $$$1$$$ to $$$n$$$ from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than $$$\frac{n}{2}$$$.For some reason, you would like to tell people to move from their armchairs to... | 512 megabytes | import javafx.beans.NamedArg;
import java.io.*;
import java.util.Comparator;
import java.util.*;
/**
* @author Yuxuan Wu
*/
public class Main {
public static final int RANGE = 1000000;
static int MAX = Integer.MAX_VALUE;
static int MIN = Integer.MIN_VALUE;
static int MODULO = 1000000007;
... | Java | ["7\n1 0 0 1 0 0 1", "6\n1 1 1 0 0 0", "5\n0 0 0 0 0"] | 2 seconds | ["3", "9", "0"] | NoteIn the first test, you can perform the following sequence: ask a person to move from armchair $$$1$$$ to armchair $$$2$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$7$$$ to armchair $$$6$$$, it takes $$$1$$$ minute; ask a person to move from armchair $$$4$$$ to armchair $$$5$$$, it takes $$$... | Java 8 | standard input | [
"dp",
"flows",
"graph matchings",
"greedy"
] | ff5abd7dfd6234ddaf0ee7d24e02c404 | The first line contains one integer $$$n$$$ ($$$2 \le n \le 5000$$$) — the number of armchairs. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i \le 1$$$). $$$a_i = 1$$$ means that the $$$i$$$-th armchair is initially occupied, $$$a_i = 0$$$ means that it is initially free. The number ... | 1,800 | Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free. | standard output |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.