filename_1
stringlengths 8
15
| filename_2
stringlengths 8
12
| code_1
stringlengths 591
24.4k
| code_2
stringlengths 591
35.2k
| labels
int64 0
1
| notes
stringclasses 2
values |
|---|---|---|---|---|---|
2c7a0000
|
69b2fd22
|
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.readLine());
String[] str = br.readLine().split(" ");
int[] a = new int[n];
int k = 0;
ArrayList<Integer> pos = new ArrayList<>();
for(int i=0; i<n; i++) {
a[i] = Integer.parseInt(str[i]);
if(a[i] == 1) {
k++;
pos.add(i);
}
}
int[][] dp = new int[n+1][k+1];
for(int i=0; i<=n; i++) {
Arrays.fill(dp[i], Integer.MAX_VALUE);
}
dp[0][0] = 0;
for(int i=0; i<n; i++) {
for(int j=0; j<=k; j++) {
if(dp[i][j] == Integer.MAX_VALUE) {
continue;
}
dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
if(j < k && a[i] == 0) {
dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
}
}
}
System.out.println(dp[n][k]);
//}
}
}
|
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 int[n];
ArrayList<Integer> list=new ArrayList<>();
ArrayList<Integer> space=new ArrayList<>();
for(int i=0;i<n;i++)
{
a[i]=input.nextInt();
if(a[i]==1)
{
list.add(i);
}
else
{
space.add(i);
}
}
int pre[]=new int[space.size()];
for(int i=0;i<list.size();i++)
{
if(i==0)
{
int min=Integer.MAX_VALUE;
for(int j=0;j<space.size();j++)
{
pre[j]=Math.abs(list.get(i)-space.get(j));
min=Math.min(min,pre[j]);
pre[j]=min;
}
}
else
{
int arr[]=new int[space.size()];
for(int j=0;j<i;j++)
{
arr[j]=Integer.MAX_VALUE;
}
int min=Integer.MAX_VALUE;
for(int j=i;j<space.size();j++)
{
int v=Math.abs(list.get(i)-space.get(j));
v+=pre[j-1];
arr[j]=v;
min=Math.min(min,v);
arr[j]=min;
}
for(int j=0;j<space.size();j++)
{
pre[j]=arr[j];
}
}
}
out.println(pre[space.size()-1]);
}
out.close();
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str="";
try
{
str=br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
18d20d2e
|
d8a171a3
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
public class C {
public static void main(String[] args) {
FastScanner scanner = new FastScanner();
int t = scanner.nextInt();
for (int i=0; i < t;i++) {
int n = scanner.nextInt();
String start = scanner.nextLine().trim();
String finish = scanner.nextLine().trim();
int ans = solve(start, finish, n);
System.out.println(ans);
}
}
public static int solve(String start, String finish, int n) {
int nOnesInA = 0;
for (char c : start.toCharArray()) {
if (c == '1') {
nOnesInA++;
}
}
int nOnesInB = 0;
for (char c : finish.toCharArray()) {
if (c == '1') {
nOnesInB++;
}
}
int ans = Integer.MAX_VALUE;
if (nOnesInA == nOnesInB) {
ans = simpleSolve(start, finish, n);
}
if ((n - nOnesInA) + 1 == nOnesInB) {
int newAns = simpleSolve(flip(start, n), finish, n) + 1;
if (newAns < ans) {
ans = newAns;
}
}
if (ans == Integer.MAX_VALUE) {
return -1;
}
return ans;
}
public static int simpleSolve(String start, String finish, int n) {
int ans = 0;
for (int i=0; i < n; i++) {
if ((start.charAt(i) == '1') && (finish.charAt(i) == '0')) {
ans+=2;
}
}
return ans;
}
public static String flip(String start, int n) {
char[] flipped = new char[n];
for(int i=0; i<n; i++) {
if (start.charAt(i) == '1') {
flipped[i] = '0';
} else {
flipped[i] = '1';
}
}
return String.valueOf(flipped);
}
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
import java.io.*;
import java.util.*;
public class B {
public static void main(String[] args)throws IOException {
FastScanner scan = new FastScanner();
PrintWriter output = new PrintWriter(System.out);
int t = scan.nextInt();
for(int tt = 0;tt<t;tt++) {
int n = scan.nextInt();
char initial[] = scan.next().toCharArray();
char desired[] = scan.next().toCharArray();
int lit1 = 0, lit2 = 0;
int ans = Integer.MAX_VALUE;
for(int i = 0;i<n;i++) {
if(initial[i]=='1') lit1++;
if(desired[i]=='1') lit2++;
}
if(lit1==lit2) {
int count = 0;
for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
ans = Math.min(ans, count);
}
if(lit2==(n-lit1+1)) {
int count = 0;
for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
ans = Math.min(ans, count);
}
if(ans == Integer.MAX_VALUE) ans = -1;
output.println(ans);
}
output.flush();
}
public static int[] sort(int arr[]) {
List<Integer> list = new ArrayList<>();
for(int i:arr) list.add(i);
Collections.sort(list);
for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
return arr;
}
public static int gcd(int a, int b) {
if(a == 0) return b;
return gcd(b%a, a);
}
public static void printArray(int arr[]) {
for(int i:arr) System.out.print(i+" ");
System.out.println();
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
}
| 0 |
Non-plagiarised
|
9862c742
|
cf27732e
|
/******************************************************************************
Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.
*******************************************************************************/
import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-- > 0){
int n = s.nextInt();
int[] arr = new int[n];
for(int i=0;i<n;i++)
arr[i] = s.nextInt();
String str = s.next();
List<Integer> left = new ArrayList<>();
List<Integer> right = new ArrayList<>();
for(int i=0;i<arr.length;i++){
if(str.charAt(i) == 'B')
left.add(arr[i]);
else right.add(arr[i]);
}
Collections.sort(left);
Collections.sort(right);
boolean flag = false;
for(int i=0;i<left.size();i++)
if(left.get(i) < i+1){
flag = true;
break;
}
if(!flag){
for(int i=0;i<right.size();i++)
if(right.get(i) > left.size()+i+1){
flag = true;
break;
}
}
if(flag)
System.out.println("NO");
else System.out.println("YES");
}
}
}
|
import java.util.*;
import java.io.*;
public class code {
// remember long, to reformat ctrl + shift +f
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
public static void main(String[] args) throws Exception {
int t=sc.nextInt();
while(t-->0) {
int n=sc.nextInt();
int []vals=new int[n];
boolean numLine[]=new boolean[n+1];
for(int i=0;i<n;i++)vals[i]=sc.nextInt();
String s=sc.nextLine();
ArrayList<Integer>b=new ArrayList<Integer>();
ArrayList<Integer>r=new ArrayList<Integer>();
for(int i=0;i<n;i++) {
if(s.charAt(i)=='B' && vals[i]>0 )b.add(vals[i]);
else if( s.charAt(i)=='R' && vals[i]<=n)r.add(vals[i]);
}
Collections.sort(b);
Collections.sort(r);
int small=1;
for(int i=0;i<b.size();i++) {
int y=b.get(i);
if(y<small)continue;
numLine[small]=true;
small++;
}
// pw.println(Arrays.toString(numLine));
int large=n;
for(int i=r.size()-1;i>=0;i--) {
int y=r.get(i);
if(y>large)continue;
// y=Math.max(large, y);
numLine[large]=true;
large--;
}
//pw.print(Arrays.toString(numLine));
boolean can=true;
for(int i=1;i<=n;i++) {
if(numLine[i]==false) {
pw.println("no");
can=false;
break;
}
}
if(can)pw.println("yes");
}
pw.close();
}
// --------------------stuff ----------------------
static class pair implements Comparable<pair> {
int v;
int w;
public pair(int v,int w) {
this.v = v;
this.w = w;
}
public int compareTo(pair p) {
return this.w- p.w;// increasing order!!
//return Double.compare(v*w, p.w*p.v);
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public long[] nextlongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public Long[] nextLongArray(int n) throws IOException {
Long[] a = new Long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextIntArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public Integer[] nextIntegerArray(int n) throws IOException {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| 0 |
Non-plagiarised
|
4.4428E+067
|
9debf95c
|
import java.util.*;
import java.io.*;
public class C_Minimum_Grid_Path{
public static void main(String[] args) {
FastScanner s= new FastScanner();
StringBuilder res = new StringBuilder();
int t=s.nextInt();
int p=0;
while(p<t){
int n=s.nextInt();
int array[]= new int[n];
long sumodd[]= new long[n];
long sumeven []= new long[n];
long minodd[]= new long[n];
long mineven[]= new long[n];
long sume=0;
long sumo=0;
for(int i=0;i<n;i++){
array[i]=s.nextInt();
if(i%2==0){
sume+=array[i];
sumeven[i]=sume;
if(i==0){
mineven[i]=array[i];
}
else{
mineven[i]=Math.min(array[i],mineven[i-2]);
}
}
else{
sumo+=array[i];
sumodd[i]=sumo;
if(i==1){
minodd[i]=array[i];
}
else{
minodd[i]=Math.min(array[i],minodd[i-2]);
}
}
}
long ans=Long.MAX_VALUE;
for(int i=1;i<n;i++){
long temp=0;
if(i%2==0){
int num=i/2;
temp=(mineven[i]*(n-num))+(sumeven[i]-mineven[i])+(minodd[i-1]*(n-(num-1)))+(sumodd[i-1]-minodd[i-1]);
ans=Math.min(ans,temp);
}
else{
int num=i/2;
temp=(minodd[i]*(n-num))+(sumodd[i]-minodd[i])+(mineven[i-1]*(n-num))+(sumeven[i-1]-mineven[i-1]);
ans=Math.min(ans,temp);
}
}
res.append(ans+"\n");
p++;
}
System.out.println(res);
}
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(String s) {
try {
br = new BufferedReader(new FileReader(s));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String nextToken() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(nextToken());
}
long nextLong() {
return Long.parseLong(nextToken());
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
}
}
|
// A Computer is Like a mischievous genie.
// It will give you exactly what you ask for,
// but not always what you want
// A code by Rahul Verma
import java.io.BufferedOutputStream;
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.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
public class Main {
static class Clock {
protected long start, stop;
public void start() {
start = System.currentTimeMillis();
}
public void stop() {
stop = System.currentTimeMillis();
}
public String getTime() {
return ((stop - start) + " ms");
}
}
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String[] nextSArray() {
String sr[] = null;
try {
sr = br.readLine().trim().split(" ");
} catch (IOException e) {
e.printStackTrace();
}
return sr;
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static long powmodulo(long a, long p) {
if (p == 0) {
return 1 % mod;
}
if (p == 1) {
return a % mod;
}
long ans = 1;
while (p > 0) {
if ((p & 1) > 0) {
ans = (ans * a) % mod;
}
a = (a * a) % mod;
p = p >> 1;
}
return ans % mod;
}
static long mod = 1000000007;
static long gcd(long a, long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
static long fast_powerNumbers(long a, long n) {
if (n == 1) {
return a;
}
long ans = fast_powerNumbers(a, n / 2);
if (n % 2 == 0) {
return (ans * ans);
} else {
return ((ans * ans) * (a));
}
}
static void dfs_helper(int[][] arr, int i, int j, int team, int n, int m) {
arr[i][j] = team;
if (i - 1 >= 0 && arr[i - 1][j] == 1) {
dfs(arr, i - 1, j, team, n, m);
}
if (j - 1 >= 0 && arr[i][j - 1] == 1) {
dfs(arr, i, j - 1, team, n, m);
}
if (i + 1 < n && arr[i + 1][j] == 1) {
dfs(arr, i + 1, j, team, n, m);
}
if (j + 1 < m && arr[i][j + 1] == 1) {
dfs(arr, i, j + 1, team, n, m);
}
}
static void dfs(int[][] arr, int i, int j, int team, int n, int m) {
dfs_helper(arr, i, j, team, n, m);
}
static int parent[];
static int rank[];
static int find(int i) {
if (parent[i] == -1) {
parent[i] = i;
return i;
}
if (parent[i] == i) {
return i;
} else {
parent[i] = find(parent[i]);
}
return parent[i];
}
static void unite(int s1, int s2) {
if (rank[s1] > rank[s2]) {
parent[s2] = s1;
rank[s1] += rank[s2];
} else {
parent[s1] = s2;
rank[s2] += rank[s1];
}
}
public static long arr[];
public static int arr1[];
// static void seive(int n) {
// arr = new int[n + 1];
// arr[0] = arr[1] = 1;
// for (int i = 4; i <= n; i = i + 2) {
// arr[i] = 1;
// }
// for (int i = 3; i * i <= n; i = i + 2) {
// if (arr[i] == 0) {
// for (int j = i * i; j <= n; j = j + i) {
// arr[j] = 1;
// }
//
// }
// }
// }
static void seive(int n)
{
arr1=new int[n+1];
arr1[0]=arr1[1]=1;
for (int i = 4; i <=n ; i+=2) {
arr1[i]=1;
}
for (int i = 3; i*i <=n ; i+=2) {
if (arr1[i] == 0)
{
for (int j = i*i; j <=n ; j+=i) {
arr1[j]=1;
}
}
}
}
public static boolean ccw(Point a,Point b,Point c)
{
long s1=(c.x-b.x)*(b.y-a.y) ;
long s2 = (c.y-b.y)*(b.x-a.x);
if(s1<s2)
return true;
else
return false;
}
public static boolean col(Point a,Point b,Point c)
{
long s1=(c.x-b.x)*(b.y-a.y) ;
long s2 = (c.y-b.y)*(b.x-a.x);
if(s1==s2)
return true;
else
return false;
}
static class Point
{
long x,y;
Point(long x,long y)
{
this.x=x;
this.y=y;
}
}
public static void main(String[] args) throws Exception {
FastReader sc = new FastReader();
Clock clock = new Clock();
clock.start();
int t1=sc.nextInt();
for (int t = 0; t <t1 ; t++) {
int n=sc.nextInt();
long arr[]=new long[n];
for (int i = 0; i < n; i++) {
arr[i]=sc.nextLong();
}
long sum1=0;
long sum2=0;
long min1 =Long.MAX_VALUE;
long min2 =Long.MAX_VALUE;
long brr[]=new long[n];
for (int i = 0; i <n ; i+=2) {
int nn =i/2;
min1=Math.min(arr[i],min1);
sum1+=arr[i];
long x =(sum1-min1) + min1*(n-nn);
// System.out.println(x);
brr[i]=x;
}
for (int i = 1; i <n ; i+=2) {
int nn =i/2;
//System.out.println(x);
min2=Math.min(arr[i],min2);
sum2+=arr[i];
long x =(sum2-min2) + min2*(n-nn);
brr[i]=x;
}
long min=Long.MAX_VALUE;
for (int i = 1; i < n; i++) {
min=Math.min(brr[i]+brr[i-1],min);
}
out.println(min);
//out.println(Arrays.toString(brr));
// System.out.println(min1+" "+min2);
}
out.close();
}
}
class Trio{
int a,i1,i2;
Trio(int a,int i1,int i2)
{
this.a=a;
this.i1=i1;
this.i2=i2;
}
}
class Pair{
int a,b;
Pair(int a,int b)
{
this.a=a;
this.b=b;
}
}
class DSU
{
int parent[];
int rank[];
long arr[] = Main.arr;
long sum[] ;
DSU(int n)
{
this.parent=new int[n];
this.rank=new int[n];
sum=new long[n];
Arrays.fill(parent,-1);
Arrays.fill(rank,1);
for (int i = 0; i <n ; i++) {
sum[i]=arr[i];
}
}
int find(int s1)
{
if(parent[s1]==-1)
return s1;
return parent[s1]=find(parent[s1]);
}
void unite(int s1,int s2)
{
int p1=this.find(s1);
int p2=this.find(s2);
if(p1==p2)
return;
if(rank[p1]>rank[p2])
{
parent[p2]=p1;
rank[p1]+=rank[p2];
// System.out.println(arr[p2]);
sum[p1]+=sum[p2];
//sum[p2]+=sum[p1];
}
else
{
parent[p1]=p2;
rank[p2]+=rank[p1];
//System.out.println(arr[p1]);
sum[p2]+=sum[p1];
//sum[p1]+=sum[p2];
}
}
}
class Gaph {
HashMap<Integer, ArrayList<Integer>> hm;
Gaph() {
hm = new HashMap<>();
}
Gaph(int n) {
hm = new HashMap<>();
for (int i = 0; i < n; i++) {
hm.put(i, new ArrayList<Integer>());
}
}
// function for adding an edge.................................................
public void addEdge(int a, int b, boolean isDir) {
if (isDir) {
if (hm.containsKey(a)) {
hm.get(a).add(b);
} else {
hm.put(a, new ArrayList<>(Arrays.asList(b)));
}
} else {
if (hm.containsKey(a)) {
hm.get(a).add(b);
} else if (!hm.containsKey(a)) {
hm.put(a, new ArrayList<>(Arrays.asList(b)));
}
if (hm.containsKey(b)) {
hm.get(b).add(a);
} else if (!hm.containsKey(b)) {
hm.put(b, new ArrayList<>(Arrays.asList(a)));
}
}
}
}
// out.println(al.toString().replaceAll("[\\[|\\]|,]",""));
| 0 |
Non-plagiarised
|
d221162a
|
ee4f7b06
|
import java.util.*;
import java.io.*;
public class Main2 {
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}
catch (IOException e){e.printStackTrace();}}return st.nextToken();}
int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
String nextLine(){String str = ""; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; }
}
static long mod = 998244353;
// static Scanner sc = new Scanner(System.in);
static FastReader sc = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
public static void main (String[] args) {
int t = 1;
// t = sc.nextInt();
z : while(t-->0) {
int n = sc.nextInt();
int a[] = new int[n];
for(int i=0;i<n;i++) a[i] = sc.nextInt();
List<Integer> a1 = new ArrayList<>();
ArrayList<Integer> a2 = new ArrayList<>();
for (int i = 0; i < n; i++) {
if(a[i] == 0) a1.add(i);
else a2.add(i);
}
long dp[][] = new long[n+1][n+1];
for (int i = 0; i <= n; i++) {
Arrays.fill(dp[i],-1);
}
out.write(find(0,0,a1,a2,dp)+"\n");
}
out.close();
}
private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
if(j == a2.size()) return 0;
int req = a2.size()-j;
int ava = a1.size()-i;
if(ava<req) return Integer.MAX_VALUE/2;
if(dp[i][j] != -1) return dp[i][j];
long ans1 = find(i+1,j,a1,a2,dp);
long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
return dp[i][j] = Math.min(ans1, ans2);
}
}
|
import java.io.*;
import java.util.*;
import java.lang.Math;
public class Main {
static PrintWriter pw;
static Scanner sc;
static StringBuilder ans;
static long mod = 1000000000+7;
static void pn(final Object arg) {
pw.print(arg);
pw.flush();
}
/*-------------- for input in an value ---------------------*/
static int ni() { return sc.nextInt(); }
static long nl() { return sc.nextLong(); }
static double nd() { return sc.nextDouble(); }
static String ns() { return sc.next(); }
static void ap(int arg) { ans.append(arg); }
static void ap(long arg) { ans.append(arg); }
static void ap(String arg) { ans.append(arg); }
static void ap(StringBuilder arg) { ans.append(arg); }
/*-------------- for input in an array ---------------------*/
static void inputIntegerArray(int arr[]){
for(int i=0; i<arr.length; i++)arr[i] = ni();
}
static void inputLongArray(long arr[]){
for(int i=0; i<arr.length; i++)arr[i] = nl();
}
static void inputStringArray(String arr[]){
for(int i=0; i<arr.length; i++)arr[i] = ns();
}
static void inputDoubleArray(double arr[]){
for(int i=0; i<arr.length; i++)arr[i] = nd();
}
/*-------------- File vs Input ---------------------*/
static void runFile() throws Exception {
sc = new Scanner(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
}
static void runIo() throws Exception {
pw =new PrintWriter(System.out);
sc = new Scanner(System.in);
}
static void swap(int a, int b) {
int t = a;
a = b;
b = t;
}
static boolean isPowerOfTwo (long x) { return x!=0 && ((x&(x-1)) == 0);}
static int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b); }
static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);}
static boolean isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
static boolean sv[] = new boolean[1000002];
static void seive() {
//true -> not prime
// false->prime
sv[0] = sv[1] = true;
sv[2] = false;
for(int i = 0; i< sv.length; i++) {
if( !sv[i] && (long)i*(long)i < sv.length ) {
for ( int j = i*i; j<sv.length ; j += i ) {
sv[j] = true;
}
}
}
}
static long binpow( long a, long b) {
long res = 1;
while (b > 0) {
if ( (b & 1) > 0){
res = (res * a)%mod;
}
a = (a * a)%mod;
b >>= 1;
}
return res;
}
static long factorial(long n) {
long res = 1, i;
for (i = 2; i <= n; i++){
res = ((res%mod) * (i%mod))%mod;
}
return res;
}
static class Pair {
int idx;
int v;
Pair(int idx, int v){
this.idx = idx;
this.v = v;
}
}
public static void main(String[] args) throws Exception {
// runFile();
runIo();
int t;
t = 1;
// t = sc.nextInt();
ans = new StringBuilder();
while( t-- > 0 ) {
solve();
}
pn(ans+"");
}
static int N ;
static int M ;
static ArrayList<Integer> f;
static ArrayList<Integer> e;
static long dp[][];
static long find(int i, int j ) {
if( i == N ) return 0;
if( j == M ) return Integer.MAX_VALUE;
if (dp[i][j] != -1 )
return dp[i][j];
return dp[i][j] = Math.min( find(i, j+1), Math.abs(f.get(i)-e.get(j)) + find(i+1, j+1) );
}
public static void solve() {
int n = ni();
f = new ArrayList();
e = new ArrayList();
for(int i = 0; i<n; i++) {
int v = ni();
if( v == 0 ) {
e.add(i);
}
else
f.add(i);
}
N = f.size();
M = e.size();
dp = new long[N][M];
for(int i = 0; i<N; i++)
Arrays.fill(dp[i], -1);
ap(find(0, 0)+"\n");
}
}
// 0 1 2 3 4 5 6 7
// 1 1 0 0 0 1 0 0
// 1s -> { 0, 1, 5 }
// 0s -> { 2, 3, 6, 7 }
| 0 |
Non-plagiarised
|
317a209c
|
921b6e4a
|
import java.io.*;
import java.util.*;
public class D_Java {
public static final int MOD = 998244353;
public static int mul(int a, int b) {
return (int)((long)a * (long)b % MOD);
}
int[] f;
int[] rf;
public int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
}
public static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static void shuffleArray(int[] a) {
Random rnd = new Random();
for (int i = a.length-1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
int tmp = a[index];
a[index] = a[i];
a[i] = tmp;
}
}
public static int inv(int a) {
return pow(a, MOD-2);
}
public void doIt() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int k = Integer.parseInt(tok.nextToken());
f = new int[n+42];
rf = new int[n+42];
f[0] = rf[0] = 1;
for (int i = 1; i < f.length; ++i) {
f[i] = mul(f[i-1], i);
rf[i] = mul(rf[i-1], inv(i));
}
int[] events = new int[2*n];
for (int i = 0; i < n; ++i) {
tok = new StringTokenizer(in.readLine());
int le = Integer.parseInt(tok.nextToken());
int ri = Integer.parseInt(tok.nextToken());
events[i] = le*2;
events[i + n] = ri*2 + 1;
}
shuffleArray(events);
Arrays.sort(events);
int ans = 0;
int balance = 0;
for (int r = 0; r < 2*n;) {
int l = r;
while (r < 2*n && events[l] == events[r]) {
++r;
}
int added = r - l;
if (events[l] % 2 == 0) {
// Open event
ans += C(balance + added, k);
if (ans >= MOD) ans -= MOD;
ans += MOD - C(balance, k);
if (ans >= MOD) ans -= MOD;
balance += added;
} else {
// Close event
balance -= added;
}
}
in.close();
System.out.println(ans);
}
public static void main(String[] args) throws IOException {
(new D_Java()).doIt();
}
}
|
import java.io.*;
import java.util.*;
public class D_Java {
public static final int MOD = 998244353;
public static int mul(int a, int b) {
return (int)((long)a * (long)b % MOD);
}
int[] f;
int[] rf;
public int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
}
public static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static void shuffleArray(int[] a) {
Random rnd = new Random();
for (int i = a.length-1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
int tmp = a[index];
a[index] = a[i];
a[i] = tmp;
}
}
public static int inv(int a) {
return pow(a, MOD-2);
}
public void doIt() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int k = Integer.parseInt(tok.nextToken());
f = new int[n+42];
rf = new int[n+42];
f[0] = rf[0] = 1;
for (int i = 1; i < f.length; ++i) {
f[i] = mul(f[i-1], i);
rf[i] = mul(rf[i-1], inv(i));
}
int[] events = new int[2*n];
for (int i = 0; i < n; ++i) {
tok = new StringTokenizer(in.readLine());
int le = Integer.parseInt(tok.nextToken());
int ri = Integer.parseInt(tok.nextToken());
events[i] = le*2;
events[i + n] = ri*2 + 1;
}
shuffleArray(events);
Arrays.sort(events);
int ans = 0;
int balance = 0;
for (int r = 0; r < 2*n;) {
int l = r;
while (r < 2*n && events[l] == events[r]) {
++r;
}
int added = r - l;
if (events[l] % 2 == 0) {
// Open event
ans += C(balance + added, k);
if (ans >= MOD) ans -= MOD;
ans += MOD - C(balance, k);
if (ans >= MOD) ans -= MOD;
balance += added;
} else {
// Close event
balance -= added;
}
}
in.close();
System.out.println(ans);
}
public static void main(String[] args) throws IOException {
(new D_Java()).doIt();
}
}
| 1 |
Plagiarised
|
ec607ca1
|
ed37ba7d
|
/*
TO LEARN
1-segment trees
2-euler tour
3-fenwick tree and interval tree
*/
/*
TO SOLVE
uva 1103
program codeforces edu 102 D
*/
/*
bit manipulation shit
1-Computer Systems: A Programmer's Perspective
2-hacker's delight
3-(02-03-bits-ints)
4-machine-basics
5-Bits Manipulation tutorialspoint
*/
/*
TO WATCH
1-what is bitmasking by kartik arora youtube
*/
import java.util.*;
import java.math.*;
import java.io.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
public class A{
static InputStream inputStream = System.in;
static FastScanner scan=new FastScanner();
public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
static boolean vis[]=new boolean[26];
static LinkedList<Integer>edges[];
static int cnt=0;
static ArrayList<Integer>arr=new ArrayList();
static void dfs(int c,boolean vis2[])
{
vis[c]=true;
// vis2[c]=true;
arr.add(c);
for(int v:edges[c])
{
if(!vis[v])
{
dfs(v,vis2);
}
}
}
public static void main(String[] args) throws Exception
{
// scan=new FastScanner("lifeguards.in");
//out = new PrintWriter("lifeguards.out");
/*
currently doing
1-digit dp
2-ds like fenwick and interval tree and sparse table
*/
/*
READING
1-Everything About Dynamic Programming codeforces
2-DYNAMIC PROGRAMMING: FROM NOVICE TO ADVANCED topcoder
3-Introduction to DP with Bitmasking codefoces
4-Bit Manipulation hackerearth
*/
int tt=1;
//System.out.println(2&0);
/*for(int i=0;i<=70;i++)
for(int j=0;j<=70;j++){
if((i&j)==i)
System.out.println(i+" "+j+" "+(i&j));
}*/
//System.out.println(1^14);
//System.out.println(15&6);
tt=scan.nextInt();
outer:while(tt-->0)
{
int l=scan.nextInt(),n=scan.nextInt();
int arr[]=new int[n];
long t[]=new long[n];
int pos[]=new int[l+1];
Arrays.fill(pos,-1);
TreeSet<Integer>tree=new TreeSet<Integer>();
for(int i=0;i<n;i++){
arr[i]=scan.nextInt();
tree.add(arr[i]);
pos[arr[i]]=i;
}
for(int i=0;i<n;i++)
t[i]=scan.nextLong();
long L[]=new long[l+5];
long R[]=new long[l+5];
Arrays.fill(L,Integer.MAX_VALUE);
Arrays.fill(R,Integer.MAX_VALUE);
for(int i=1;i<=l;i++)
{
if(pos[i]!=-1)
{
L[i]=t[pos[i]];
}
L[i]=Math.min(L[i],L[i-1]+1);
}
for(int i=l;i>=1;i--)
{
if(pos[i]!=-1)
{
R[i]=t[pos[i]];
}
R[i]=Math.min(R[i],R[i+1]+1);
}
for(int i=1;i<=l;i++)
out.print(Math.min(L[i],R[i])+" ");
out.println();
}
out.close();
}
static class special{
long x1,y1,x2,y2;
//int id;
special(long x1,long y1,long x2,long y2)
{
this.x1=x1;
this.y1=y1;
this.x2=x2;
this.y2=y2;
//this.id=id;
}
@Override
public int hashCode() {
int hash = 7;
hash = 31 * hash + (int) x1;
hash = 31 * hash + (int)x2;
hash = 31 * hash + (int)y1;
hash = 31 * hash + (int)y2;
return hash;
}
@Override
public boolean equals(Object o){
if (o == this) return true;
if (o.getClass() != getClass()) return false;
special t = (special)o;
return t.x1 == x1 && t.y1 == y1&&t.x2==x2&&t.y2==y2;
}
}
static long binexp(long a,long n)
{
if(n==0)
return 1;
long res=binexp(a,n/2);
if(n%2==1)
return res*res*a;
else
return res*res;
}
static long powMod(long base, long exp, long mod) {
if (base == 0 || base == 1) return base;
if (exp == 0) return 1;
if (exp == 1) return (base % mod+mod)%mod;
long R = (powMod(base, exp/2, mod) % mod+mod)%mod;
R *= R;
R %= mod;
if ((exp & 1) == 1) {
return (base * R % mod+mod)%mod;
}
else return (R %mod+mod)%mod;
}
static double dis(double x1,double y1,double x2,double y2)
{
return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}
static long mod(long x,long y)
{
if(x<0)
x=x+(-x/y+1)*y;
return x%y;
}
public static long pow(long b, long e) {
long r = 1;
while (e > 0) {
if (e % 2 == 1) r = r * b ;
b = b * b;
e >>= 1;
}
return r;
}
private static void sort(long[] arr) {
List<Long> list = new ArrayList<>();
for (long object : arr) list.add(object);
Collections.sort(list);
//Collections.reverse(list);
for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
}
private static void sort2(long[] arr) {
List<Long> list = new ArrayList<>();
for (Long object : arr) list.add(object);
Collections.sort(list);
Collections.reverse(list);
for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
}
static class FastScanner
{
private int BS = 1 << 16;
private char NC = (char) 0;
private byte[] buf = new byte[BS];
private int bId = 0, size = 0;
private char c = NC;
private double cnt = 1;
private BufferedInputStream in;
public FastScanner() {
in = new BufferedInputStream(System.in, BS);
}
public FastScanner(String s) {
try {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
} catch (Exception e) {
in = new BufferedInputStream(System.in, BS);
}
}
private char getChar() {
while (bId == size) {
try {
size = in.read(buf);
} catch (Exception e) {
return NC;
}
if (size == -1) return NC;
bId = 0;
}
return (char) buf[bId++];
}
public int nextInt() {
return (int) nextLong();
}
public int[] nextInts(int N) {
int[] res = new int[N];
for (int i = 0; i < N; i++) {
res[i] = (int) nextLong();
}
return res;
}
public long[] nextLongs(int N) {
long[] res = new long[N];
for (int i = 0; i < N; i++) {
res[i] = nextLong();
}
return res;
}
public long nextLong() {
cnt = 1;
boolean neg = false;
if (c == NC) c = getChar();
for (; (c < '0' || c > '9'); c = getChar()) {
if (c == '-') neg = true;
}
long res = 0;
for (; c >= '0' && c <= '9'; c = getChar()) {
res = (res << 3) + (res << 1) + c - '0';
cnt *= 10;
}
return neg ? -res : res;
}
public double nextDouble() {
double cur = nextLong();
return c != '.' ? cur : cur + nextLong() / cnt;
}
public double[] nextDoubles(int N) {
double[] res = new double[N];
for (int i = 0; i < N; i++) {
res[i] = nextDouble();
}
return res;
}
public String next() {
StringBuilder res = new StringBuilder();
while (c <= 32) c = getChar();
while (c > 32) {
res.append(c);
c = getChar();
}
return res.toString();
}
public String nextLine() {
StringBuilder res = new StringBuilder();
while (c <= 32) c = getChar();
while (c != '\n') {
res.append(c);
c = getChar();
}
return res.toString();
}
public boolean hasNext() {
if (c > 32) return true;
while (true) {
c = getChar();
if (c == NC) return false;
else if (c > 32) return true;
}
}
}
static class Pair implements Comparable<Pair>{
public long x, y,z;
public Pair(long x1, long y1,long z1) {
x=x1;
y=y1;
z=z1;
}
public Pair(long x1, long y1) {
x=x1;
y=y1;
}
@Override
public int hashCode() {
return (int)(x + 31 * y);
}
public String toString() {
return x + " " + y+" "+z;
}
@Override
public boolean equals(Object o){
if (o == this) return true;
if (o.getClass() != getClass()) return false;
Pair t = (Pair)o;
return t.x == x && t.y == y&&t.z==z;
}
public int compareTo(Pair o)
{
return (int)(x-o.x);
}
}
}
|
import java.io.*;
import java.util.*;
import java.lang.*;
public class codeforces {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
if (System.getProperty("ONLINE_JUDGE") == null) {
long startTime = System.currentTimeMillis();
try {
sc = new InputReader(new FileInputStream("input.txt"));
out = new PrintWriter(new FileOutputStream("output.txt"));
pr = new PrintWriter(new FileOutputStream("error.txt"));
} catch (Exception ignored) {
}
int t = 1;
int tt = t;
t = sc.nextInt();
while (t-- > 0) {
solve();
}
long endTime = System.currentTimeMillis();
System.out.println("Time: " + (endTime - startTime) / tt + " ms");
out.flush();
pr.flush();
} else {
sc = new InputReader(inputStream);
out = new PrintWriter(outputStream);
pr = new PrintWriter(outputStream);
int t = 1;
t = sc.nextInt();
while (t-- > 0) {
solve();
}
out.flush();
}
}
public static void solve() {
n = sc.nextInt();
for (int i = 0; i < n; i++) {
dp[i] = inf;
ans[i] = inf;
}
m = sc.nextInt();
for (int i = 0; i < m; i++)
arr[i] = sc.nextInt() - 1;
for (int i = 0; i < m; i++) {
arr2[i] = sc.nextInt();
dp[(int)arr[i]] = arr2[i];
}
temp = inf;
for (int i = 0; i < n; i++) {
temp = Math.min(temp, dp[i]);
ans[i] = Math.min(ans[i], temp);
temp++;
}
temp = inf;
for (int i = (int)n - 1; i > -1; i--) {
temp = Math.min(temp, dp[i]);
ans[i] = Math.min(ans[i], temp);
temp++;
}
for (int i = 0; i < n; i++)
out.print(ans[i] + " ");
out.println("");
}
/*
* Set Iterator Iterator value = set.iterator(); Displaying the values after
* iterating through the iterator
* System.out.println("The iterator values are: "); while (value.hasNext()) {
* System.out.println(value.next()); }
*/
/*
* Map Iterator: for (Map.Entry<Integer, Integer> entry : map.entrySet()){
* System.out.println("Key => " + entry.getKey() + ", Value => " +
* entry.getValue());}
*/
// Globals
public static long n, m, temp;
public static int template_array_size = (int) 1e6 + 16813;
public static long[] arr = new long[template_array_size];
public static long[] arr2 = new long[template_array_size];
public static long[] dp = new long[template_array_size];
public static long[] ans = new long[template_array_size];
public static int inf = Integer.MAX_VALUE;
public static int minf = Integer.MIN_VALUE;
public static int mod = 1000000007;
public static int ml = (int) 1e9;
public static String s = "";
public static InputReader sc;
public static PrintWriter out;
public static PrintWriter pr;
// Pair
static class Pair {
int first, second;
Pair(int x, int y) {
this.first = x;
this.second = y;
}
}
// FastReader Class
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
// Req Functions
public static void fill(int[][] dp, int x) {
for (int i = 0; i < dp.length; ++i) {
for (int j = 0; j < dp[0].length; ++j) {
dp[i][j] = x;
}
}
}
public static int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
public static int lcm(int a, int b) {
return (a / gcd(a, b)) * b;
}
public static long gcd(long a, long b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
public static long lcm(long a, long b) {
return (a / gcd(a, b)) * b;
}
public static long nCr(int n, int k) {
long ans = 1L;
k = k > n - k ? n - k : k;
int j = 1;
for (; j <= k; j++, n--) {
if (n % j == 0) {
ans *= n / j;
} else if (ans % j == 0) {
ans = ans / j * n;
} else {
ans = (ans * n) / j;
}
}
return ans;
}
public static String reverseString(String input) {
StringBuilder str = new StringBuilder("");
for (int i = input.length() - 1; i >= 0; i--) {
str.append(input.charAt(i));
}
return str.toString();
}
public static int maxOf3(int x, int y, int z) {
return Math.max(x, Math.max(y, z));
}
public static int minof3(int x, int y, int z) {
return Math.min(x, Math.min(y, z));
}
public static long maxOf3(long x, long y, long z) {
return Math.max(x, Math.max(y, z));
}
public static long minof3(long x, long y, long z) {
return Math.min(x, Math.min(y, z));
}
public static void arrInput(int[] arr, int n) {
for (int i = 0; i < n; i++)
arr[i] = sc.nextInt();
}
public static void arrInput(long[] arr, int n) {
for (int i = 0; i < n; i++)
arr[i] = sc.nextLong();
}
public static void arrInput(Pair[] pair, int n) {
for (int i = 0; i < n; i++)
pair[i] = new Pair(sc.nextInt(), sc.nextInt());
}
public static int maxarrInput(int[] arr, int n) {
int max = minf;
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
max = Math.max(max, arr[i]);
}
return max;
}
public static long maxarrInput(long[] arr, int n) {
long max = minf;
for (int i = 0; i < n; i++) {
arr[i] = sc.nextLong();
max = Math.max(max, arr[i]);
}
return max;
}
public static int minarrInput(int[] arr, int n) {
int min = inf;
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
min = Math.max(min, arr[i]);
}
return min;
}
public static long minarrInput(long[] arr, int n) {
long min = inf;
for (int i = 0; i < n; i++) {
arr[i] = sc.nextLong();
min = Math.max(min, arr[i]);
}
return min;
}
public static int lowerBound(int[] arr, int x) {
int l = -1, r = arr.length;
while (l + 1 < r) {
int m = (l + r) >>> 1;
if (arr[m] >= x)
r = m;
else
l = m;
}
return r;
}
public static int upperBound(int[] arr, int x) {
int l = -1, r = arr.length;
while (l + 1 < r) {
int m = (l + r) >>> 1;
if (arr[m] <= x)
l = m;
else
r = m;
}
return l + 1;
}
public static void merge(int arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
int L[] = new int[n1];
int R[] = new int[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] >= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
public static void reversesort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
reversesort(arr, l, m);
reversesort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
public static void merge(long arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
long L[] = new long[n1];
long R[] = new long[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] >= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
public static void reversesort(long arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
reversesort(arr, l, m);
reversesort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
// debug
public static boolean sysFlag = System.getProperty("ONLINE_JUDGE") == null;
public static void debug(int[][] dp) {
if (sysFlag) {
for (int i = 0; i < dp.length; ++i) {
pr.print(i + "--> ");
for (int j = 0; j < dp[0].length; ++j) {
pr.print(dp[i][j] + " ");
}
pr.println("");
}
}
}
public static void debug(long[][] dp) {
if (sysFlag) {
for (int i = 0; i < dp.length; ++i) {
pr.print(i + "--> ");
for (int j = 0; j < dp[0].length; ++j) {
pr.print(dp[i][j] + " ");
}
pr.println("");
}
}
}
public static void debug(int x) {
if (sysFlag)
pr.println("Int-Ele: " + x);
}
public static void debug(String x) {
if (sysFlag)
pr.println("String: " + x);
}
public static void debug(char x) {
if (sysFlag)
pr.println("Char: " + x);
}
public static void debug(long x) {
if (sysFlag)
pr.println("Long-Ele: " + x);
}
public static void debug(int[] arr, int n) {
if (sysFlag) {
for (int i = 0; i < n; ++i) {
pr.println(i + " -> " + arr[i]);
}
}
}
public static void debug(char[] arr) {
if (sysFlag) {
for (int i = 0; i < arr.length; ++i) {
pr.println(i + " -> " + arr[i]);
}
}
}
public static void debug(long[] arr, int n) {
if (sysFlag) {
for (int i = 0; i < n; ++i) {
pr.println(i + " -> " + arr[i]);
}
}
}
public static void debug(ArrayList<Integer> list) {
if (sysFlag) {
for (int i = 0; i < list.size(); ++i) {
pr.println(i + " -> " + list.get(i));
}
}
}
public static void Ldebug(ArrayList<Long> list) {
if (sysFlag) {
for (int i = 0; i < list.size(); ++i) {
pr.println(i + " -> " + list.get(i));
}
}
}
public static void debugmapII(HashMap<Integer, Integer> map) {
if (sysFlag) {
for (Map.Entry<Integer, Integer> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debugmapLI(HashMap<Long, Integer> map) {
if (sysFlag) {
for (Map.Entry<Long, Integer> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debugmapLL(HashMap<Long, Long> map) {
if (sysFlag) {
for (Map.Entry<Long, Long> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debugmapIL(HashMap<Integer, Long> map) {
if (sysFlag) {
for (Map.Entry<Integer, Long> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debugmapSL(HashMap<String, Long> map) {
if (sysFlag) {
for (Map.Entry<String, Long> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debugmapCL(HashMap<Character, Long> map) {
if (sysFlag) {
for (Map.Entry<Character, Long> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debugmapSI(HashMap<String, Integer> map) {
if (sysFlag) {
for (Map.Entry<String, Integer> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debugmapCI(HashMap<Character, Integer> map) {
if (sysFlag) {
for (Map.Entry<Character, Integer> entry : map.entrySet())
pr.println("Key => " + entry.getKey() + ", Value => " + entry.getValue());
}
}
public static void debug(Set<Integer> set) {
if (sysFlag) {
Iterator value = set.iterator();
int i = 1;
while (value.hasNext()) {
pr.println((i++) + "-> " + value.next());
}
}
}
}
| 0 |
Non-plagiarised
|
d9199dfd
|
ff1fc018
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;
public class Simple{
public static void main(String args[]){
//System.out.println("Hello Java");
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while (t>0){
int n = s.nextInt();
int arr[] = new int[n];
for(int i=0;i<n;i++){
arr[i] = s.nextInt();
}
String str = s.next();
//Arrays.sort(arr);
ArrayList<Integer> blue = new ArrayList<>();
ArrayList<Integer> red = new ArrayList<>();
for(int i=0;i<n;i++){
if(str.charAt(i)=='R'){
red.add(arr[i]);
}
else{
blue.add(arr[i]);
}
}
Collections.sort(red);
Collections.sort(blue);
int start =1;
boolean bool =true;
for(int i=0;i<blue.size();i++){
if(blue.get(i)<start){
bool = false;
break;
}
start++;
}
if(!bool){
System.out.println("NO");
}
else{
for(int i=0;i<red.size();i++){
if(red.get(i)>start){
bool = false;
break;
}
start++;
}
if(bool){
System.out.println("YES");
}
else{
System.out.println("NO");
}
}
t--;
}
s.close();
}
}
|
import java.util.*;
public class mentor1 {
public static boolean solve(int n, String color, int[] arr){
List<Integer> Barr = new ArrayList<Integer>();
List<Integer> Rarr = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
if(color.charAt(i) == 'B')Barr.add(arr[i]);
else Rarr.add(arr[i]);
}
Barr.sort(Comparator.naturalOrder());
Rarr.sort(Comparator.reverseOrder());
for (int i = 0; i < Barr.size(); i++) {
if(Barr.get(i)< i + 1)return false;
}
for (int i = 0; i < Rarr.size(); i++) {
int expect = n-i;
if(Rarr.get(i) > expect)return false;
}
return true;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
for (int i = 0; i < n; i++) {
int m = input.nextInt();
int[] arr = new int[m];
for(int j = 0;j<m; j++)arr[j] = input.nextInt();
String color = input.next();
if(solve(m,color,arr)) System.out.println("YES");
else System.out.println("NO");
}
}
}
| 0 |
Non-plagiarised
|
595f5d6c
|
ae775964
|
import java.math.BigInteger;
//import static java.lang.Math.max;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Vector;
import java.util.Scanner;
public class ahh {
//trihund
static Scanner scn = new Scanner(System.in);
static boolean vis[][];
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static FastReader s = new FastReader();
static int MOD = 1000000007;
public static void main(String[] args) {
int n=scn.nextInt(),count=0;
int arr[]=new int[n];
for(int i=0;i<n;i++)
{
arr[i]=scn.nextInt();
}
ArrayList<Integer>zer=new ArrayList<Integer>(),one=new ArrayList<Integer>();
for(int i=0;i<n;i++)
{
if(arr[i]==0)
zer.add(i);
else
one.add(i);
}
count=one.size();
long memo[][]=new long[one.size()+1][zer.size()+1];
for(int i=0;i<=one.size();i++)
{
for(int j=0;j<=zer.size();j++)
memo[i][j]=-1;
}
System.out.println(arm(one, zer, 0, 0, count,memo));
}
public static long arm(ArrayList<Integer>one,ArrayList<Integer>zer,int i,int j,int count,long memo[][])
{ if(count==0)
return 0;
if(i==one.size()||j==zer.size())
return Integer.MAX_VALUE;
if(memo[i][j]!=-1)
return memo[i][j];
long a=Integer.MAX_VALUE,b=Integer.MAX_VALUE;
a=arm(one, zer, i+1, j+1,count-1,memo)+Math.abs(one.get(i)-zer.get(j));
b=arm(one, zer, i, j+1,count,memo);
memo[i][j]=Math.min(a, b);
return Math.min(a, b);
}
public static void fac(int n) {
BigInteger b = new BigInteger("1");
for (int i = 1; i <= n; i++) {
b = b.multiply(BigInteger.valueOf(i));
}
System.out.println(b);
}
static void ruffleSort(long[] a) {
int n = a.length;
Random r = new Random();
for (int i = 0; i < a.length; i++) {
int oi = r.nextInt(n);
long temp = a[i];
a[i] = a[oi];
a[oi] = temp;
}
Arrays.sort(a);
}
public static int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
}
class pm {
int ini, fin;
pm(int a, int b) {
this.ini = a;
this.fin = b;
}
}
class surt implements Comparator<pm> {
@Override
public int compare(pm o1, pm o2) {
// TODO Auto-generated method stub
int a = o1.ini - o2.ini, b = o1.fin - o2.fin;
if (a < 0)
return -1;
if (a == 0) {
if (b < 0)
return -1;
else
return 1;
} else
return 1;
}
}
class pair {
int x, y;
pair(int a, int b) {
this.x = a;
this.y = b;
}
public int hashCode() {
return x * 31 + y * 31;
}
public boolean equals(Object other) {
if (this == other)
return true;
if (other instanceof pair) {
pair pt = (pair) other;
return pt.x == this.x && pt.y == this.y;
} else
return false;
}
}
class sort implements Comparator<pair> {
@Override
public int compare(pair o1, pair o2) {
// TODO Auto-generated method stub
long a = o1.x - o2.x, b = o1.y - o2.y;
if (b < 0)
return -1;
else if (a == 0) {
if (a < 0)
return -1;
else
return 1;
} else
return 1;
}
}
|
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;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import javax.sound.sampled.ReverbType;
public class Edu109 {
static PrintWriter out;
static Scanner sc;
static ArrayList<int[]>q,w,x;
static ArrayList<Integer>adj[];
static HashSet<Integer>primesH;
static boolean prime[];
//static ArrayList<Integer>a;
static HashSet<Long>tmp;
static int[][][]dist;
static boolean[]v;
static int[]a,b,c,d;
static Boolean[][]dp;
static char[][]mp;
static int A,B,n,m,h,ans,sum;
//static String a,b;
static long oo=(long)1e9+7;
public static void main(String[]args) throws IOException {
sc=new Scanner(System.in);
out=new PrintWriter(System.out);
//A();
//B();
//C();
D();
//E();
//F();
//G();
out.close();
}
private static void A() throws IOException {
int t=ni();
while(t-->0) {
int k=ni();
int ans=0;
for(int i=1;i<=100;i++) {
if((i*100)%k==0) {
ans=i*100/k;break;
}
}
ol(ans);
}
}
static void B() throws IOException {
int t=ni();
while(t-->0) {
int n=ni();
a=nai(n);
boolean isSorted=true,one=a[0]==1;
int pos=0;
for(int i=1;i<n;i++) {
if(a[i]<a[i-1])isSorted=false;
if(a[i]==1)pos=i;
}
boolean ok=true;
for(int i=pos+1;i<n;i++) {
if(a[i]<a[i-1])ok=false;
}
boolean lst=a[0]==n;
boolean fir=a[n-1]==1;
if(isSorted)ol(0);
else if(lst&&fir)ol(3);
else if(lst||fir)ol(2);
else if(a[0]==1||a[n-1]==n)ol(1);
else ol(2);
// if(isSorted)ol(0);
// else out.println(fl&&lst?3:((one?1:2)-(ok?1:0)+(lst?1:0)));
}
}
static void C() throws IOException{
int t=ni();
while(t-->0) {
int n=ni();
int m=ni();
a=nai(n);
TreeMap<Integer, Integer>tr=new TreeMap<Integer, Integer>();
for(int i=0;i<n;i++)tr.put(a[i], i);
char[]mv=new char[n];
for(int i=0;i<n;i++) {
String s=ns();
mv[i]=s.charAt(0);
}
long[]ans=new long[n];
Arrays.fill(ans, -1);
PriorityQueue<Integer>lodd=new PriorityQueue<Integer>();
PriorityQueue<Integer>lev=new PriorityQueue<Integer>();
PriorityQueue<Integer>rodd=new PriorityQueue<Integer>();
PriorityQueue<Integer>rev=new PriorityQueue<Integer>();
for(int i=0;i<n;i++) {
if(a[i]%2==0) {
if(mv[i]=='L')lev.add(a[i]);
else rev.add(a[i]);
}else {
if(mv[i]=='L')lodd.add(a[i]);
else rodd.add(a[i]);
}
}
PriorityQueue<Integer>par[]=new PriorityQueue[4];
par[0]=rev;par[1]=rodd;par[2]=lev;par[3]=lodd;
for(int i=0;i<2;i++){
while(par[i].size()>=1&&par[i+2].size()>=1) {
int r=par[i].poll(),l=par[i+2].poll();
int d1=(l-r)/2;
if(l<r) {
d1=clc(l,r,m);
}
int dr=Integer.MAX_VALUE,dl=Integer.MAX_VALUE;
if(par[i].size()==1) {
dr=m-par[i].peek()+(par[i].peek()-r)/2;
}
if(!par[i+2].isEmpty()) {
dl=(par[i+2].peek()+l)/2;
}
int cur=Math.min(d1, Math.min(dl, dr));
if(cur==d1) {
ans[tr.get(r)]=ans[tr.get(l)]=cur;
}
else if(cur==dr) {
ans[tr.get(r)]=ans[tr.get(par[i].poll())]=cur;
par[i+2].add(l);
}else {
ans[tr.get(l)]=ans[tr.get(par[i+2].poll())]=cur;
par[i].add(r);
}
}
}
for(int i=0;i<4;i++) {
if(i<2&&par[i].size()%2==1)par[i].poll();
while(par[i].size()>1) {
int x=par[i].poll(),y=par[i].poll();
int val=0;
if(i<2) {
val=m-y+(y-x)/2;
}else {
val=(x+y)/2;
}
ans[tr.get(x)]=ans[tr.get(y)]=val;
}
}
for(int i=0;i<n;i++) {
out.print(ans[i]+" ");
}ol("");
}
}
private static int clc(int l, int r, int m) {
int b1=0,b2=m;
int ans=0;
if(l>m-r) {
ans+=l;
b2=2*m - l -r;// m-(l-m+r) -> m-l+m-r
}else {
ans+=m-r;
b1=m-r-l;
}
return ans+(b2-b1)/2;
}
private static Boolean dp(int i, int j) {
if(j>sum/2)return false;
if(i==x.size()) {
return sum/2==j;
}
if(dp[i][j]!=null)return dp[i][j];
return dp[i][j]=dp(i+1,j+x.get(i)[0])||dp(i+1,j);
}
static boolean isPrime(long n) {
if(n==2)return true;
if(n<2||n%2==0)return false;
for(long i=3L;i*i<n;i+=2l) {
long rem=(n%i);
if(rem==0)return false;
}
return true;
}
static long[][]mem;
static int ones;
static ArrayList<Integer>pos;
static void D() throws IOException {
int t=1;
while(t-->0) {
n=ni();
a=nai(n);
mem=new long[n][n];
ones=0;
pos=new ArrayList<Integer>();
for(int i=0;i<n;i++) {
Arrays.fill(mem[i], -1);
if(a[i]==1)pos.add(i);
}
ones=pos.size();
long ans=solve(0,0);
out.println(ans);
}
}
private static long solve(int i, int j) {
if(i==n||j>=ones)return j==ones?0:(long)1e14;
if(mem[i][j]!=-1)return mem[i][j];
long lv=solve(i+1,j);
if(a[i]==0) {
int pr=Math.abs(i-pos.get(j));
lv=Math.min(lv, pr+solve(i+1,j+1));
}
return mem[i][j]=lv;
}
private static int bfs(int i, int j,int k) {
boolean [][]vis=new boolean[dist.length][dist[0].length];
Queue<int[]>q=new LinkedList<int[]>();
int mn=Integer.MAX_VALUE;
q.add(new int[] {i,j,0,0});
int[]dx=new int[] {-1,1,0,0};
int[]dy=new int[] {0,0,1,-1};
while(!q.isEmpty()) {
int []x=q.poll();
vis[x[0]][x[1]]=true;
int c=x[2];
if(c>k/2)continue;
if(c>0&&k%c==0&&(k/c)%2==0) {
mn=Math.min(mn,x[3]*k/c );
}
for(int a=0;a<4;a++) {
int nx=x[0]+dx[a];
int ny=x[1]+dy[a];
if(valid(nx,ny)&&!vis[nx][ny]) {
q.add(new int[] {nx,ny,c+1,x[3]+dist[x[0]][x[1]][a]});
}
}
}
return mn;
}
private static boolean valid(int nx, int ny) {
return nx>=0&&nx<dist.length&&ny>=0&&ny<dist[0].length;
}
static int gcd (int a, int b) {
return b==0?a:gcd (b, a % b);
}
static void E() throws IOException {
int t=ni();
while(t-->0) {
}
}
static void F() throws IOException {
int t=ni();
while(t-->0) {
}
}
static void CC() throws IOException {
for(int kk=2;kk<21;kk++) {
ol(kk+" -------");
int n=kk;
int k=n-2;
int msk=1<<k;
int[]a=new int[k];
for(int i=0;i<a.length;i++)a[i]=i+2;
int mx=1;
int ms=0;
for(int i=1;i<msk;i++) {
long prod=1;
int cnt=0;
for(int j=0;j<a.length;j++) {
if(((i>>j)&1)!=0) {
prod*=a[j];
cnt++;
}
}
if(cnt>=mx&&prod%n==1) {
mx=cnt;
ms=i;
}
}
ol(mx==1?mx:mx+1);
out.print(1+" ");
long pr=1;
for(int j=0;j<a.length;j++) {
if(((ms>>j)&1)!=0) {
out.print(a[j]+" ");
pr*=a[j];
}
}
ol("");
ol("Prod: "+pr);
ol(n+"*"+((pr-1)/n)+" + "+1);
}
}
static int ni() throws IOException {
return sc.nextInt();
}
static double nd() throws IOException {
return sc.nextDouble();
}
static long nl() throws IOException {
return sc.nextLong();
}
static String ns() throws IOException {
return sc.next();
}
static int[] nai(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = sc.nextInt();
return a;
}
static long[] nal(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = sc.nextLong();
return a;
}
static int[][] nmi(int n,int m) throws IOException{
int[][]a=new int[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
a[i][j]=sc.nextInt();
}
}
return a;
}
static long[][] nml(int n,int m) throws IOException{
long[][]a=new long[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
a[i][j]=sc.nextLong();
}
}
return a;
}
static void o(String x) {
out.print(x);
}
static void ol(String x) {
out.println(x);
}
static void ol(int x) {
out.println(x);
}
static void disp1(int []a) {
for(int i=0;i<a.length;i++) {
out.print(a[i]+" ");
}
out.println();
}
static class Scanner
{
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s){ br = new BufferedReader(new InputStreamReader(s));}
public String next() throws IOException
{
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public boolean hasNext() {return st.hasMoreTokens();}
public int nextInt() throws IOException {return Integer.parseInt(next());}
public double nextDouble() throws IOException {return Double.parseDouble(next());}
public long nextLong() throws IOException {return Long.parseLong(next());}
public String nextLine() throws IOException {return br.readLine();}
public boolean ready() throws IOException {return br.ready(); }
}
}
| 0 |
Non-plagiarised
|
1ea771ea
|
3c667d4f
|
import java.io.*;
import java.util.*;
public class CODECHEF {
static class FastReader {
byte[] buf = new byte[2048];
int index, total;
InputStream in;
FastReader(InputStream is) {
in = is;
}
int scan() throws IOException {
if (index >= total) {
index = 0;
total = in.read(buf);
if (total <= 0) {
return -1;
}
}
return buf[index++];
}
String next() throws IOException {
int c;
for (c = scan(); c <= 32; c = scan())
;
StringBuilder sb = new StringBuilder();
for (; c > 32; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
String nextLine() throws IOException {
int c;
for (c = scan(); c <= 32; c = scan())
;
StringBuilder sb = new StringBuilder();
for (; c != 10 && c != 13; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
char nextChar() throws IOException {
int c;
for (c = scan(); c <= 32; c = scan())
;
return (char) c;
}
int nextInt() throws IOException {
int c, val = 0;
for (c = scan(); c <= 32; c = scan())
;
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
long nextLong() throws IOException {
int c;
long val = 0;
for (c = scan(); c <= 32; c = scan())
;
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
}
static long MOD=1000000000;
static class Pair{
long a;
int b;
Pair(long i,int j){
a=i;
b=j;
}
}
static long[] solve(int[] pos,long[] arr,int n,int k){
long[] ans=new long[n];
long[] left=new long[n];
long[] right=new long[n];
long min=Integer.MAX_VALUE;
for(int i=0;i<n;i++){
min=Math.min(min+1,arr[i]);
left[i]=min;
}
min=Integer.MAX_VALUE;
for(int i=n-1;i>=0;i--){
min=Math.min(min+1,arr[i]);
right[i]=min;
}
for(int i=0;i<n;i++){
ans[i]=Math.min(left[i],right[i]);
}
return ans;
}
public static void main(String[] args) throws java.lang.Exception {
FastReader fs=new FastReader(System.in);
// StringBuilder sb=new StringBuilder();
// PrintWriter out=new PrintWriter(System.out);
int t=fs.nextInt();
while (t-->0){
int n=fs.nextInt();
int k=fs.nextInt();
int[] pos=new int[k];
for(int i=0;i<k;i++)
pos[i]=fs.nextInt()-1;
long[] temp=new long[n];
int ptr=0;
Arrays.fill(temp,Integer.MAX_VALUE);
for(int i=0;i<k;i++)
temp[pos[ptr++]]=fs.nextLong();
long[] ans=solve(pos,temp,n,k);
for(int i=0;i<n;i++)
System.out.print(ans[i]+" ");
System.out.println();
}
//out.close;
}
}
|
import java.util.*;
public class j
{
public static void main(String args[])
{
Scanner in=new Scanner(System.in);
int n=in.nextInt();
while(n-->0)
{
int len=in.nextInt();
int t=in.nextInt();
int pos[]=new int[t];
int temp[]=new int[t];
for(int i=0;i<t;i++)
pos[i]=in.nextInt();
for(int i=0;i<t;i++)
temp[i]=in.nextInt();
long range[]=new long[len];
Arrays.fill(range,Long.MAX_VALUE-10000);
for(int i=0;i<t;i++)
range[pos[i]-1]=temp[i];
for(int i=1;i<len;i++)
{
range[i]=Math.min(range[i],1+range[i-1]);
}
for(int i=len-2;i>=0;i--)
{
range[i]=Math.min(range[i+1]+1,range[i]);
}
for(int i=0;i<len;i++)
{
System.out.print(range[i]+" ");
}System.out.println();
}
}
}
| 0 |
Non-plagiarised
|
39073790
|
d735b078
|
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class DisJump {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader sc = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Solver solver = new Solver();
// int t = sc.nextInt();
int t = 1;
while (t-- != 0) {
solver.solve(sc, out);
}
out.close();
}
static class Node {
int v, dis;
public Node(int v, int dis) {
this.v = v;
this.dis = dis;
}
}
static class Solver {
public void solve(InputReader sc, PrintWriter out) {
int n = sc.nextInt();
int[] h = sc.nextIntArray(n);
ArrayList<Integer>[] g = new ArrayList[n];
for(int i = 0; i < n; i++) g[i] = new ArrayList<>();
for(int rot = 0; rot < 2; rot++) {
int[] stk = new int[n];
int at = -1;
for(int i = 0; i < n; i++) {
while (at!=-1 && h[stk[at]]<h[i]) g[stk[at--]].add(i);
if(at!=-1) {
g[stk[at]].add(i);
if(h[stk[at]]==h[i]) at--;
}
stk[++at] = i;
}
for(int i = 0; i < n; i++) h[i] = -h[i];
}
int[] qu = new int[n];
int[] dist = new int[n];
Arrays.fill(dist,-1);
int qTop = 0;
int qEnd = 1;
qu[0] = 0;
dist[0] = 0;
while (qTop<qEnd) {
int front = qu[qTop];
for(int v : g[front]) {
if(dist[v]==-1) {
qu[qEnd] = v;
dist[v] = dist[front]+1;
qEnd++;
}
}
qTop++;
}
out.println(dist[n-1]);
}
}
static void sort(int[] arr) {
Random rand = new Random();
int n = arr.length;
for (int i = 0; i < n; i++) {
int idx = rand.nextInt(n);
if (idx == i) continue;
arr[i] ^= arr[idx];
arr[idx] ^= arr[i];
arr[i] ^= arr[idx];
}
Arrays.sort(arr);
}
static void sort(long[] arr) {
Random rand = new Random();
int n = arr.length;
for (int i = 0; i < n; i++) {
int idx = rand.nextInt(n);
if (idx == i) continue;
arr[i] ^= arr[idx];
arr[idx] ^= arr[i];
arr[i] ^= arr[idx];
}
Arrays.sort(arr);
}
static void sortDec(int[] arr) {
Random rand = new Random();
int n = arr.length;
for (int i = 0; i < n; i++) {
int idx = rand.nextInt(n);
if (idx == i) continue;
arr[i] ^= arr[idx];
arr[idx] ^= arr[i];
arr[i] ^= arr[idx];
}
Arrays.sort(arr);
int l = 0;
int r = n - 1;
while (l < r) {
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
static void sortDec(long[] arr) {
Random rand = new Random();
int n = arr.length;
for (int i = 0; i < n; i++) {
int idx = rand.nextInt(n);
if (idx == i) continue;
arr[i] ^= arr[idx];
arr[idx] ^= arr[i];
arr[i] ^= arr[idx];
}
Arrays.sort(arr);
int l = 0;
int r = n - 1;
while (l < r) {
long tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
l++;
r--;
}
}
static class InputReader {
private boolean finished = false;
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int peek() {
if (numChars == -1) {
return -1;
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
return -1;
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private String readLine0() {
StringBuilder buf = new StringBuilder();
int c = read();
while (c != '\n' && c != -1) {
if (c != '\r') {
buf.appendCodePoint(c);
}
c = read();
}
return buf.toString();
}
public String readLine() {
String s = readLine0();
while (s.trim().length() == 0) {
s = readLine0();
}
return s;
}
public String readLine(boolean ignoreEmptyLines) {
if (ignoreEmptyLines) {
return readLine();
} else {
return readLine0();
}
}
public BigInteger readBigInteger() {
try {
return new BigInteger(nextString());
} catch (NumberFormatException e) {
throw new InputMismatchException();
}
}
public char nextCharacter() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
return (char) c;
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1) {
read();
}
return value == -1;
}
public String next() {
return nextString();
}
public SpaceCharFilter getFilter() {
return filter;
}
public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; ++i) array[i] = nextInt();
return array;
}
public int[] nextSortedIntArray(int n) {
int array[] = nextIntArray(n);
Arrays.sort(array);
return array;
}
public int[] nextSumIntArray(int n) {
int[] array = new int[n];
array[0] = nextInt();
for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
return array;
}
public long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; ++i) array[i] = nextLong();
return array;
}
public long[] nextSumLongArray(int n) {
long[] array = new long[n];
array[0] = nextInt();
for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
return array;
}
public long[] nextSortedLongArray(int n) {
long array[] = nextLongArray(n);
Arrays.sort(array);
return array;
}
}
}
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;
import java.util.StringTokenizer;
// 1 0 1 0 0
public class D {
// Right side greater
public static int[] rightGreaterEle(long[] a) {
int n = a.length;
int ans[] = new int[n];
ans[n - 1] = -1;
Stack<Integer> st = new Stack<>();
st.add(n - 1);
for (int i = n - 2; i >= 0; i--) {
if (st.isEmpty() || a[st.peek()] >= a[i]) {
ans[i] = st.peek();
st.push(i);
} else {
while (!st.isEmpty() && a[st.peek()] < a[i]) {
st.pop();
}
if (st.isEmpty())
ans[i] = -1;
else
ans[i] = st.peek();
st.push(i);
}
}
return ans;
}
// Right side smaller
public static int[] rightSideSmaller(long[] a) {
int n = a.length;
int ans[] = new int[n];
ans[n - 1] = -1;
Stack<Integer> st = new Stack<>();
st.add(n - 1);
for (int i = n - 2; i >= 0; i--) {
if (st.isEmpty() || a[st.peek()] <= a[i]) {
ans[i] = st.peek();
st.push(i);
} else {
while (!st.isEmpty() && a[st.peek()] > a[i]) {
st.pop();
}
if (st.isEmpty())
ans[i] = -1;
else
ans[i] = st.peek();
st.push(i);
}
}
return ans;
}
// Left side greater
public static int[] leftSideGreater(long[] a) {
int n = a.length;
int ans[] = new int[n];
ans[0] = -1;
Stack<Integer> st = new Stack<>();
st.push(0);
for (int i = 1; i < n; i++) {
if (st.isEmpty() || a[st.peek()] >= a[i]) {
ans[i] = st.peek();
st.push(i);
} else {
while (!st.isEmpty() && a[st.peek()] < a[i]) {
st.pop();
}
if (st.isEmpty())
ans[i] = -1;
else
ans[i] = st.peek();
st.push(i);
}
}
return ans;
}
// Left side smaller
public static int[] leftSideSmaller(long[] a) {
int n = a.length;
int ans[] = new int[n];
ans[0] = -1;
Stack<Integer> st = new Stack<>();
st.push(0);
for (int i = 1; i < n; i++) {
if (st.isEmpty() || a[st.peek()] <= a[i]) {
ans[i] = st.peek();
st.push(i);
} else {
while (!st.isEmpty() && a[st.peek()] > a[i]) {
st.pop();
}
if (st.isEmpty())
ans[i] = -1;
else
ans[i] = st.peek();
st.push(i);
}
}
return ans;
}
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int n = sc.nextInt();
long a[] = new long[n];
for (int i = 0; i < n; i++)
a[i] = sc.nextLong();
int rg[] = rightGreaterEle(a);
int rs[] = rightSideSmaller(a);
int lg[] = leftSideGreater(a);
int ls[] = leftSideSmaller(a);
int dp[] = new int[n];
Arrays.fill(dp, Integer.MAX_VALUE);
dp[0] = 0;
for(int i=1;i<n;i++) dp[i]=dp[i-1]+1;
for (int i = 0; i < n; i++) {
// Where from we can reach at ith index
//System.out.println(l1+" "+l2+" "+r1+" "+r2);
int l1 = ls[i], l2 = lg[i];
if (l1 != -1)
dp[i] = Math.min(dp[i], dp[l1] + 1);
if (l2 != -1)
dp[i] = Math.min(dp[i], dp[l2] + 1);
//System.out.println("from left "+dp[i]);
int r1 = rs[i], r2 = rg[i];
if (r1 != -1)
dp[r1] = Math.min(dp[r1], dp[i] + 1);
if (r2 != -1)
dp[r2] = Math.min(dp[r2], dp[i] + 1);
// if(i==4)
// System.out.println(dp[l1]+" "+dp[l2]+" "+dp[r1]+" "+dp[r2]);
// System.out.println((i+1)+" "+dp[i]);
}
System.out.println(dp[n-1]);
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
long[] readLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
}
| 0 |
Non-plagiarised
|
9028caf7
|
d221162a
|
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 int[n];
ArrayList<Integer> list=new ArrayList<>();
ArrayList<Integer> space=new ArrayList<>();
for(int i=0;i<n;i++)
{
a[i]=input.nextInt();
if(a[i]==1)
{
list.add(i);
}
else
{
space.add(i);
}
}
int pre[]=new int[space.size()];
for(int i=0;i<list.size();i++)
{
if(i==0)
{
int min=Integer.MAX_VALUE;
for(int j=0;j<space.size();j++)
{
pre[j]=Math.abs(list.get(i)-space.get(j));
min=Math.min(min,pre[j]);
pre[j]=min;
}
}
else
{
int arr[]=new int[space.size()];
for(int j=0;j<i;j++)
{
arr[j]=Integer.MAX_VALUE;
}
int min=Integer.MAX_VALUE;
for(int j=i;j<space.size();j++)
{
int v=Math.abs(list.get(i)-space.get(j));
v+=pre[j-1];
arr[j]=v;
min=Math.min(min,v);
arr[j]=min;
}
for(int j=0;j<space.size();j++)
{
pre[j]=arr[j];
}
}
}
out.println(pre[space.size()-1]);
}
out.close();
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str="";
try
{
str=br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
|
import java.util.*;
import java.io.*;
public class Main2 {
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}
catch (IOException e){e.printStackTrace();}}return st.nextToken();}
int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
String nextLine(){String str = ""; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; }
}
static long mod = 998244353;
// static Scanner sc = new Scanner(System.in);
static FastReader sc = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
public static void main (String[] args) {
int t = 1;
// t = sc.nextInt();
z : while(t-->0) {
int n = sc.nextInt();
int a[] = new int[n];
for(int i=0;i<n;i++) a[i] = sc.nextInt();
List<Integer> a1 = new ArrayList<>();
ArrayList<Integer> a2 = new ArrayList<>();
for (int i = 0; i < n; i++) {
if(a[i] == 0) a1.add(i);
else a2.add(i);
}
long dp[][] = new long[n+1][n+1];
for (int i = 0; i <= n; i++) {
Arrays.fill(dp[i],-1);
}
out.write(find(0,0,a1,a2,dp)+"\n");
}
out.close();
}
private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
if(j == a2.size()) return 0;
int req = a2.size()-j;
int ava = a1.size()-i;
if(ava<req) return Integer.MAX_VALUE/2;
if(dp[i][j] != -1) return dp[i][j];
long ans1 = find(i+1,j,a1,a2,dp);
long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
return dp[i][j] = Math.min(ans1, ans2);
}
}
| 0 |
Non-plagiarised
|
2470b521
|
f6ca6fc8
|
// package com.company;
import com.sun.security.jgss.GSSUtil;
import javax.swing.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
//ankit singh
public class Main {
static int inf=Integer.MAX_VALUE/2;
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int nn=input.nextInt();
int a[]=new int[nn];
ArrayList<Integer> one=new ArrayList<>();
ArrayList<Integer> zero=new ArrayList<>();
for (int i = 0; i <nn ; i++) {
a[i]=input.nextInt();
if(a[i]==1){
one.add(i);
}else zero.add(i);
}
if (one.size()==0) {
System.out.println(0);
return;
}
int n=one.size();
int m=zero.size();
int dp[][]=new int[n+1][m+1];
int ans=0;
for (int i = 1; i <=n ; i++) {
dp[i][0]=inf;
for (int j = 1; j <=m ; j++) {
dp[i][j]=inf;
//take the current
dp[i][j]=Math.min(dp[i][j],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
//take previos
dp[i][j]=Math.min(dp[i][j],dp[i][j-1]);
}
}
ans=inf;
for (int i = 1; i <=m ; i++) {
ans=Math.min(ans,dp[n][i]);
}
System.out.println(ans);
}
}
|
import java.util.*;
import java.io.*;
public class D {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n = sc.nextInt();
ArrayList<Integer> o=new ArrayList<Integer>();
ArrayList<Integer> e=new ArrayList<Integer>();
for(int i=1;i<=n;i++){
int x=sc.nextInt();
if(x==1)o.add(i);
else e.add(i);
}
int dp[][]=new int[o.size()+1][e.size()+1];
for(int i=1;i<=o.size();i++){
dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
for(int j=i+1;j<=e.size();j++){
dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
}
}
System.out.println(dp[o.size()][e.size()]);
}
}
| 0 |
Non-plagiarised
|
4eac0eea
|
f4d6d28d
|
import java.util.*;
import java.io.*;
import java.lang.*;
import static java.lang.Math.*;
// import java.math.*;
public class cp{
static BufferedReader br;
static StringTokenizer st;
public static void main(String[] args)throws IOException{
br = new BufferedReader(new InputStreamReader(System.in));
List<Integer> answer = new ArrayList<Integer>();
for(int t=Integer.parseInt(br.readLine()); t>0; t--){
st = readLine();
int n = tokenInt();
String[] words = new String[n];
int i=0;
while(n-- >0){
words[i] = br.readLine();
i++;
}
answer.add(new Solver().solve(words));
}
for (int ans : answer ) System.out.println(ans);
}
static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
static int tokenInt() { return Integer.parseInt(st.nextToken()); }
static long tokenLong(){ return Long.parseLong(st.nextToken()); }
static double tokenDouble(){ return Double.parseDouble(st.nextToken()); }
static char[] tokenChar(){ return st.nextToken().toCharArray(); }
static int[] readIntArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=tokenInt();
return a;
}
static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b);}
static int lcm(int a, int b) { return (a * b) / gcd(a,b);}
static void printArr(int[] arr){
for (int i=0; i<arr.length; i++) System.out.print(arr[i] + " ");
System.out.println();
return;
}
static void printArr(char[] arr){
for (int i=0; i<arr.length; i++) System.out.print(arr[i] + " ");
System.out.println();
return;
}
}
class Solver{
public int solve(String[] words) throws IOException{
char[] alphabets = {'a', 'b', 'c', 'd', 'e'};
// char[] alphabets = {'a'};
int[][] arr = new int[5][words.length];
int i=0;
for(String s : words) {
char[] wordArr = s.toCharArray();
int j=0;
for (char alpha : alphabets) {
int counter = 0;
for(char letter : wordArr){
if(alpha == letter){
counter++;
}
}
arr[j][i] = 2*counter - s.length();
// System.out.println( alpha + " " + (2*counter - s.length()));
j++;
}
// System.out.println("********");
i++;
}
int[] ans = new int[5];
int m=0;
for (int[] ar : arr) {
// Arrays.sort(ar, Collections.reverseOrder());
Arrays.sort(ar);
int val=0;
int counter = 0;
for(i=ar.length-1; i>=0; i--){
val += ar[i];
if(val>0){
counter++;
} else break;
}
ans[m] = counter;
m++;
// cp.printArr(ar);
}
// cp.printArr(ans);
return Arrays.stream(ans).max().getAsInt();
}
}
/*
bac
aaada
e
*/
|
import java.util.*;
import java.io.*;
import java.lang.*;
import static java.lang.Math.*;
public class cp{
static BufferedReader br;
static StringTokenizer st;
public static void main(String[] args)throws IOException{
br = new BufferedReader(new InputStreamReader(System.in));
List<Integer> answer = new ArrayList<Integer>();
for(int t=Integer.parseInt(br.readLine()); t>0; t--){
st = readLine();
int n = tokenInt();
String[] words = new String[n];
int i=0;
while(n-- >0){
words[i] = br.readLine();
i++;
}
answer.add(new Solver().solve(words));
}
for (int ans : answer ) System.out.println(ans);
}
static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
static int tokenInt() { return Integer.parseInt(st.nextToken()); }
static long tokenLong(){ return Long.parseLong(st.nextToken()); }
static double tokenDouble(){ return Double.parseDouble(st.nextToken()); }
static char[] tokenChar(){ return st.nextToken().toCharArray(); }
static int[] readIntArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=tokenInt();
return a;
}
static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b);}
static int lcm(int a, int b) { return (a * b) / gcd(a,b);}
static void printArr(int[] arr){
for (int i=0; i<arr.length; i++) System.out.print(arr[i] + " ");
System.out.println();
return;
}
static void printArr(char[] arr){
for (int i=0; i<arr.length; i++) System.out.print(arr[i] + " ");
System.out.println();
return;
}
}
class Solver{
public int solve(String[] words) throws IOException{
char[] alphabets = {'a', 'b', 'c', 'd', 'e'};
int[][] arr = new int[5][words.length];
int i=0;
for(String s : words) {
char[] wordArr = s.toCharArray();
int j=0;
for (char alpha : alphabets) {
int counter = 0;
for(char letter : wordArr){
if(alpha == letter)
counter++;
}
arr[j][i] = 2*counter - s.length();
j++;
}
i++;
}
int[] ans = new int[5];
int m=0;
for (int[] ar : arr) {
Arrays.sort(ar);
int val=0;
int counter=0;
for(i=ar.length-1; i>=0; i--){
val += ar[i];
if(val>0) counter++;
else break;
}
ans[m] = counter;
m++;
}
return Arrays.stream(ans).max().getAsInt();
}
}
/*
bac
aaada
e
*/
| 1 |
Plagiarised
|
aa8091b0
|
eec856c0
|
import java.util.*;
import java.io.*;
public class AiseHi {
static Scanner sc = new Scanner(System.in);
static int mod = (int)(1e9+7);
public static void main (String[] args) {
PrintWriter out = new PrintWriter(System.out);
int t = 1;
t = sc.nextInt();
z : while(t-->0) {
int n = sc.nextInt();
int m = sc.nextInt();
int x = sc.nextInt();
PriorityQueue<twoval> myQueue = new PriorityQueue<>();
for(int i=1;i<=m;i++) {
myQueue.add(new twoval(0,i));
}
List<twoval> arrayList = new ArrayList<>();
int myArray[] = new int[n];
for(int i=0;i<n;i++) {
int aasjd = sc.nextInt();
arrayList.add(new twoval(aasjd,i));
myArray[i] = aasjd;
}
Collections.sort(arrayList);
int ans[] = new int[n];
for(int i=n-1;i>=0;i--) {
twoval p = myQueue.poll();
long aasjd = p.myArray;
int idx = p.b;
aasjd += arrayList.get(i).myArray;
ans[arrayList.get(i).b] = idx;
myQueue.add(new twoval(aasjd,idx));
}
long dasdaknw[] = new long[m];
long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
for(int i=0;i<n;i++) {
dasdaknw[ans[i]-1] += myArray[i];
}
for(int i=0;i<m;i++) {
min = Math.min(min, dasdaknw[ans[i]-1]);
max = Math.max(max, dasdaknw[ans[i]-1]);
}
if(max-min>x) {
out.write("NO\n");
continue;
}
out.write("YES\n");
for(int aasjd : ans) out.write(aasjd+" ");
out.write("\n");
}
out.close();
}
static int ceil(int myArray,int b) {
return myArray/b + (myArray%b==0?0:1);
}
static boolean prime[] = new boolean[2000009];
static int fac[] = new int[2000009];
static void sieve() {
prime[0] = true;
prime[1] = true;
int max = 1000000;
for(int i=2;i*i<=max;i++) {
if(!prime[i]) {
for(int j=i*i;j<=max;j+=i) {
prime[j] = true;
fac[j] = i;
}
}
}
}
static int gcd(int myArray,int b) { if(b==0) return myArray; return gcd(b,myArray%b); }
}
class twoval implements Comparable<twoval>{
long myArray;
int b;
twoval(long aasjd,int r){
this.myArray = aasjd;
this.b = r;
}
public int compareTo(twoval o) {
return (int) (this.myArray - o.myArray);
}
}
|
import java.io.*;
import java.util.*;
public class Main {
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}
catch (IOException e){e.printStackTrace();}}return st.nextToken();}
int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
String nextLine(){String str = ""; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; }
}
static FastReader sc = new FastReader();
static long mod = (long) (1e9+7);
static boolean spe[];
static int spen[];
static int dep[];
static List<Integer> tre[];
static int par[][];
public static void main (String[] args){
PrintWriter out = new PrintWriter(System.out);
int t = 1;
t = sc.nextInt();
z :for(int tc=1;tc<=t;tc++){
int n = sc.nextInt();
int m = sc.nextInt();
int x = sc.nextInt();
PriorityQueue<pairClass> priority = new PriorityQueue<>();
for(int i=1;i<=m;i++) {
priority.add(new pairClass(0,i));
}
List<pairClass> list = new ArrayList<>();
int a[] = new int[n];
for(int i=0;i<n;i++) {
int value = sc.nextInt();
list.add(new pairClass(value,i));
a[i] = value;
}
Collections.sort(list);
int answer[] = new int[n];
for(int i=n-1;i>=0;i--) {
pairClass p = priority.poll();
long value = p.a;
int idx = p.b;
value += list.get(i).a;
answer[list.get(i).b] = idx;
priority.add(new pairClass(value,idx));
}
long totalSum[] = new long[m];
long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
for(int i=0;i<n;i++) {
totalSum[answer[i]-1] += a[i];
}
for(int i=0;i<m;i++) {
min = Math.min(min, totalSum[answer[i]-1]);
max = Math.max(max, totalSum[answer[i]-1]);
}
if(max-min>x) {
out.write("NO\n");
continue;
}
out.write("YES\n");
for(int value : answer) out.write(value+" ");
out.write("\n");
}
out.close();
}
}
class pairClass implements Comparable<pairClass>{
long a;
int b;
pairClass(long value,int r){
this.a = value;
this.b = r;
}
@Override
public int compareTo(pairClass o) {
return (int) (this.a - o.a);
}
}
| 1 |
Plagiarised
|
1410e423
|
e90a198b
|
import java.io.*;
import java.util.*;
public class C {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
int t = Integer.parseInt(br.readLine());
while(t --> 0) {
int n = Integer.parseInt(br.readLine());
char[] lineA = br.readLine().toCharArray();
char[] lineB = br.readLine().toCharArray();
boolean[] a = new boolean[n];
boolean[] b = new boolean[n];
int ac = 0;
int aic = 0;
int bc = 0;
int stay = 0;
int flip = 0;
for(int i = 0; i < n; i++) {
if(lineA[i] == '1') {
ac++;
a[i] = true;
}else
aic++;
if(lineB[i] == '1') {
bc++;
b[i] = true;
}
if(a[i] == b[i])
stay++;
else
flip++;
}
if(ac != bc && aic + 1 != bc) {
pw.println(-1);
}else {
if(ac == aic+1)
pw.println(Math.min(stay, flip));
else if(ac == bc)
pw.println(flip);
else
pw.println(stay);
}
}
pw.close();
}
}
|
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.*;
public class Template {
static int mod = 1000000007;
public static void main(String[] args){
FastScanner sc = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int yo = sc.nextInt();
while (yo-- > 0) {
int n = sc.nextInt();
String s = sc.next();
String t = sc.next();
int op1 = cal(s,t,n);
int op2 = helper(s,t,n,'0');
int op3 = helper(s,t,n,'1');
int ans = min(min(op1,op2),op3);
if(ans == Integer.MAX_VALUE){
out.println("-1");
}
else {
out.println(ans);
}
}
out.close();
}
static int helper(String str1, String str2, int n, int ch){
char[] s = str1.toCharArray();
char[] t = str2.toCharArray();
int idx = -1;
for(int i = 0; i < n; i++){
if(s[i] == '1' && t[i] == ch){
idx = i;
break;
}
}
if(idx == -1){
return Integer.MAX_VALUE;
}
for(int i = 0; i < n; i++){
if(i == idx) continue;
if(s[i] == '1') s[i] = '0';
else s[i] = '1';
}
int ans = cal(String.valueOf(s),String.valueOf(t),n);
if(ans == Integer.MAX_VALUE) return ans;
return 1 + ans;
}
static int cal(String s, String t, int n){
int op01 = 0;
int op10 = 0;
for(int i = 0; i < n; i++){
if(s.charAt(i) != t.charAt(i)){
if(s.charAt(i) == '1') op10++;
else op01++;
}
}
if(op10 != op01){
return Integer.MAX_VALUE;
}
return op01 + op10;
}
/*
Source: hu_tao
Random stuff to try when stuck:
- use bruteforcer
- check for n = 1, n = 2, so on
-if it's 2C then it's dp
-for combo/probability problems, expand the given form we're interested in
-make everything the same then build an answer (constructive, make everything 0 then do something)
-something appears in parts of 2 --> model as graph
-assume a greedy then try to show why it works
-find way to simplify into one variable if multiple exist
-treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
-find lower and upper bounds on answer
-figure out what ur trying to find and isolate it
-see what observations you have and come up with more continuations
-work backwards (in constructive, go from the goal to the start)
-turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
-instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
-draw something
-simulate a process
-dont implement something unless if ur fairly confident its correct
-after 3 bad submissions move on to next problem if applicable
-do something instead of nothing and stay organized
-write stuff down
Random stuff to check when wa:
-if code is way too long/cancer then reassess
-switched N/M
-int overflow
-switched variables
-wrong MOD
-hardcoded edge case incorrectly
Random stuff to check when tle:
-continue instead of break
-condition in for/while loop bad
Random stuff to check when rte:
-switched N/M
-long to int/int overflow
-division by 0
-edge case for empty list/data structure/N=1
*/
public static class Pair {
int x;
int y;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
}
public static void sort(int[] arr) {
ArrayList<Integer> ls = new ArrayList<Integer>();
for (int x : arr)
ls.add(x);
Collections.sort(ls);
for (int i = 0; i < arr.length; i++)
arr[i] = ls.get(i);
}
public static long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
static boolean[] sieve(int N) {
boolean[] sieve = new boolean[N + 1];
for (int i = 2; i <= N; i++)
sieve[i] = true;
for (int i = 2; i <= N; i++) {
if (sieve[i]) {
for (int j = 2 * i; j <= N; j += i) {
sieve[j] = false;
}
}
}
return sieve;
}
public static long power(long x, long y, long p) {
long res = 1L;
x = x % p;
while (y > 0) {
if ((y & 1) == 1)
res = (res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res;
}
public static void print(int[] arr, PrintWriter out) {
//for debugging only
for (int x : arr)
out.print(x + " ");
out.println();
}
public static int log2(int a){
return (int)(Math.log(a)/Math.log(2));
}
public static long ceil(long x, long y){
return (x + 0l + y - 1) / y;
}
static class FastScanner {
private int BS = 1 << 16;
private char NC = (char) 0;
private byte[] buf = new byte[BS];
private int bId = 0, size = 0;
private char c = NC;
private double cnt = 1;
private BufferedInputStream in;
public FastScanner() {
in = new BufferedInputStream(System.in, BS);
}
public FastScanner(String s) {
try {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
} catch (Exception e) {
in = new BufferedInputStream(System.in, BS);
}
}
private char getChar() {
while (bId == size) {
try {
size = in.read(buf);
} catch (Exception e) {
return NC;
}
if (size == -1)
return NC;
bId = 0;
}
return (char) buf[bId++];
}
public int nextInt() {
return (int) nextLong();
}
public int[] readInts(int N) {
int[] res = new int[N];
for (int i = 0; i < N; i++) {
res[i] = (int) nextLong();
}
return res;
}
public long[] readLongs(int N) {
long[] res = new long[N];
for (int i = 0; i < N; i++) {
res[i] = nextLong();
}
return res;
}
public long nextLong() {
cnt = 1;
boolean neg = false;
if (c == NC)
c = getChar();
for (; (c < '0' || c > '9'); c = getChar()) {
if (c == '-')
neg = true;
}
long res = 0;
for (; c >= '0' && c <= '9'; c = getChar()) {
res = (res << 3) + (res << 1) + c - '0';
cnt *= 10;
}
return neg ? -res : res;
}
public double nextDouble() {
double cur = nextLong();
return c != '.' ? cur : cur + nextLong() / cnt;
}
public double[] readDoubles(int N) {
double[] res = new double[N];
for (int i = 0; i < N; i++) {
res[i] = nextDouble();
}
return res;
}
public String next() {
StringBuilder res = new StringBuilder();
while (c <= 32)
c = getChar();
while (c > 32) {
res.append(c);
c = getChar();
}
return res.toString();
}
public String nextLine() {
StringBuilder res = new StringBuilder();
while (c <= 32)
c = getChar();
while (c != '\n') {
res.append(c);
c = getChar();
}
return res.toString();
}
public boolean hasNext() {
if (c > 32)
return true;
while (true) {
c = getChar();
if (c == NC)
return false;
else if (c > 32)
return true;
}
}
}
// For Input.txt and Output.txt
// FileInputStream in = new FileInputStream("input.txt");
// FileOutputStream out = new FileOutputStream("output.txt");
// PrintWriter pw = new PrintWriter(out);
// Scanner sc = new Scanner(in);
}
| 0 |
Non-plagiarised
|
51cc7026
|
51d88c51
|
import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.*;
public class C_Balanced_Stone_Heaps {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = Integer.parseInt(next());
}
return a;
}
}
public static int t, n;
public static int H[];
private static long startTime = System.currentTimeMillis();
public static void main(String[] args) {
FastReader sc =new FastReader();
t = sc.nextInt();
while (t-->0) {
n = sc.nextInt();
H = new int[n];
int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
H[i] = sc.nextInt();
max = Math.max(H[i], max);
min = Math.min(H[i], min);
}
int mid = 0;
while (min < max) {
mid = min + (max-min+1)/2;
if(check(mid)) {
min = mid;
}
else max = mid-1;
}
System.out.println(min);
}
}
public static boolean check(int x){
int S[] = Arrays.copyOf(H, H.length);
for (int i = n-1; i >= 2; i--) {
if(S[i]<x) return false;
int move = Math.min(S[i]-x, H[i])/3;
if(i>=2){
// S[i]-=move*3;
S[i-1]+=(move);
S[i-2]+=2*(move);
}
}
return S[0]>= x && S[1] >= x;
}
}
|
import java.awt.Container;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class Main
{
public static boolean check(int a[],int value)
{
int b[]= new int[a.length];
for (int i = a.length-1; i >=2; i--) {
if(a[i]+b[i]<value)
{
return false;
}
int d = Math.min(a[i], (a[i]+b[i]-value));
b[i-1]+=d/3;
b[i-2]+=(2*(d/3));
}
if(a[0]+b[0]<value||a[1]+b[1]<value)
{
return false;
}
return true;
}
public static void main(String[] args)
{
FastScanner input = new FastScanner();
StringBuilder result = new StringBuilder();
int tc = input.nextInt();
work:
while (tc-- > 0) {
int n = input.nextInt();
int a[]= new int[n];
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
for (int i = 0; i < n; i++) {
a[i] = input.nextInt();
min = Math.min(min, a[i]);
max = Math.max(max, a[i]);
}
int low = min;
int high = max;
int ans = 0;
while(low<=high)
{
int mid = low+(high-low)/2;
if(check(a, mid))
{
ans = mid;
low = mid+1;
}
else
{
high = mid-1;
}
}
result.append(ans+"\n");
}
System.out.println(result);
}
static class FastScanner
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next()
{
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine() throws IOException
{
return br.readLine();
}
}
}
| 0 |
Non-plagiarised
|
67996c4c
|
9028caf7
|
import java.util.*;
import java.io.*;
public class code{
static class Reader
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException
{
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1)
{
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.')
{
while ((c = read()) >= '0' && c <= '9')
{
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
public static int GCD(int a, int b)
{
if (b == 0)
return a;
return GCD(b, a % b);
}
public static void main(String[] arg) throws IOException{
//Reader in=new Reader();
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int[] arr=new int[n];
ArrayList<Integer> zero=new ArrayList<Integer>();
ArrayList<Integer> one=new ArrayList<Integer>();
for(int i=0;i<n;i++){
arr[i]=in.nextInt();
if(arr[i]==0) zero.add(i);
else one.add(i);
}
if(one.size()==0) {
System.out.println(0);
}
else{
int[][] dp=new int[one.size()][zero.size()];
for(int i=0;i<one.size();i++){
for(int j=0;j<zero.size();j++){
if(i==0 && j==0) dp[i][j]=Math.abs(one.get(i)-zero.get(j));
else if(j==0) dp[i][j]=Integer.MAX_VALUE/2;
else if(i==0) dp[i][j]=Math.min(dp[i][j-1],Math.abs(one.get(i)-zero.get(j)));
else{
dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i)-zero.get(j)));
}
}
}
System.out.println(dp[one.size()-1][zero.size()-1]);
}
}
}
|
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 int[n];
ArrayList<Integer> list=new ArrayList<>();
ArrayList<Integer> space=new ArrayList<>();
for(int i=0;i<n;i++)
{
a[i]=input.nextInt();
if(a[i]==1)
{
list.add(i);
}
else
{
space.add(i);
}
}
int pre[]=new int[space.size()];
for(int i=0;i<list.size();i++)
{
if(i==0)
{
int min=Integer.MAX_VALUE;
for(int j=0;j<space.size();j++)
{
pre[j]=Math.abs(list.get(i)-space.get(j));
min=Math.min(min,pre[j]);
pre[j]=min;
}
}
else
{
int arr[]=new int[space.size()];
for(int j=0;j<i;j++)
{
arr[j]=Integer.MAX_VALUE;
}
int min=Integer.MAX_VALUE;
for(int j=i;j<space.size();j++)
{
int v=Math.abs(list.get(i)-space.get(j));
v+=pre[j-1];
arr[j]=v;
min=Math.min(min,v);
arr[j]=min;
}
for(int j=0;j<space.size();j++)
{
pre[j]=arr[j];
}
}
}
out.println(pre[space.size()-1]);
}
out.close();
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str="";
try
{
str=br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
b7de5c19
|
c022c315
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int t = scan.nextInt();
for (int i = 0; i < t; i++) {
int n = scan.nextInt();
ArrayList<ArrayList<Pair>> graph = new ArrayList<>();
for (int j = 0; j < n; j++) {
graph.add(new ArrayList<>());
}
for (int j = 0; j < n - 1; j++) {
int u;
int v;
u = scan.nextInt();
v = scan.nextInt();
u--;
v--;
graph.get(u).add(new Pair(v, j));
graph.get(v).add(new Pair(u, j));
}
boolean soluble = true;
int curV = 0;
int prevV = -1;
int[] ans = new int[n];
int prime = 2;
for (int j = 0; j < n; j++) {
ArrayList<Pair> list = graph.get(j);
if (list.size() > 2) {
soluble = false;
} else if (list.size() == 1) {
curV = j;
}
}
if (soluble) {
for (int j = 0; j < n - 1; j++) {
ArrayList<Pair> list = graph.get(curV);
for (int z = 0; z < list.size(); z++) {
if (list.get(z).vertex != prevV) {
ans[list.get(z).numberOfEdge] = prime;
prime = changePrime(prime);
prevV = curV;
curV = list.get(z).vertex;
break;
}
}
}
for (int j = 0; j < n - 1; j++) {
System.out.print(ans[j] + " ");
}
System.out.println();
} else {
System.out.println(-1);
}
}
}
public static int changePrime(int prime) {
if (prime == 2) {
prime = 3;
} else {
prime = 2;
}
return prime;
}
}
class Pair {
int vertex;
int numberOfEdge;
public Pair(int vertex, int numberOfEdge) {
this.vertex = vertex;
this.numberOfEdge = numberOfEdge;
}
}
|
import java.io.*;
import java.util.*;
public class Main {
// static boolean[] prime = new boolean[10000000];
final static long mod = 1000000007;
public static void main(String[] args) {
// sieve();
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
int t = in.nextInt();
while (t-- > 0) {
int n = in.nextInt();
int[][] a = new int[n - 1][2];
ArrayList<ArrayList<Data>> g = new ArrayList<>();
for (int i = 0; i < n - 1; i++) {
g.add(new ArrayList<>());
a[i][0] = in.nextInt() - 1;
a[i][1] = in.nextInt() - 1;
}
g.add(new ArrayList<>());
for (int i = 0; i < n - 1; i++) {
g.get(a[i][0]).add(new Data(a[i][1], i));
g.get(a[i][1]).add(new Data(a[i][0], i));
}
if (!check(g)) {
System.out.println(-1);
continue;
}
int[] ans = new int[n - 1];
ans[0] = 2;
for(int node: a[0]) {
for(Data d: g.get(node)) {
solve(g, d.a, d.ind, false, ans);
}
}
for (int i : ans)
System.out.print(i + " ");
System.out.println();
}
out.flush();
}
private static void solve(ArrayList<ArrayList<Data>> g, int node, int edge, boolean b, int[] ans) {
if (ans[edge] != 0)
return;
ans[edge] = b ? 2 : 3;
for (Data d : g.get(node)) {
solve(g, d.a, d.ind, !b, ans);
}
}
private static boolean check(ArrayList<ArrayList<Data>> g) {
for (ArrayList<Data> a : g)
if (a.size() > 2)
return false;
return true;
}
static boolean prime(long k) {
for (int i = 2; i * i <= k; i++) {
if (k % i == 0) {
return false;
}
}
return true;
}
static long gcd(long a, long b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
static void reverseArray(Integer[] a) {
for (int i = 0; i < (a.length >> 1); i++) {
Integer temp = a[i];
a[i] = a[a.length - 1 - i];
a[a.length - 1 - i] = temp;
}
}
static Integer[] intInput(int n, InputReader in) {
Integer[] a = new Integer[n];
for (int i = 0; i < a.length; i++)
a[i] = in.nextInt();
return a;
}
static Long[] longInput(int n, InputReader in) {
Long[] a = new Long[n];
for (int i = 0; i < a.length; i++)
a[i] = in.nextLong();
return a;
}
static String[] strInput(int n, InputReader in) {
String[] a = new String[n];
for (int i = 0; i < a.length; i++)
a[i] = in.next();
return a;
}
// static void sieve() {
// for (int i = 2; i * i < prime.length; i++) {
// if (prime[i])
// continue;
// for (int j = i * i; j < prime.length; j += i) {
// prime[j] = true;
// }
// }
// }
}
class Data {
int a;
int ind;
Data(int val, int ind) {
this.a = Math.abs(val);
this.ind = ind;
}
}
class compareVal implements Comparator<Data> {
@Override
public int compare(Data o1, Data o2) {
// return (o1.val - o2.val == 0 ? o1.ind - o2.ind : o1.val - o2.val);
return (o1.a - o2.a);
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
| 0 |
Non-plagiarised
|
9261620f
|
f0881ab5
|
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0){
int n =sc.nextInt();
long[] arr = new long[n];
for(int i=0;i<n;i++){
arr[i] =sc.nextLong();
}
Map<Long, Long> map = new HashMap<>();
List<Long> list = new ArrayList<>();
list.add((long)0);
for(int i=0;i<n;i++){
int s = list.size();
for(int j=0;j<s;j++){
list.add(list.get(j)+arr[i]);
}
}
int flag = 0;
for(int i=0;i<list.size();i++){
map.put(list.get(i), map.getOrDefault(list.get(i), (long)0)+1);
if(map.get(list.get(i))>1){
flag = 1;
break;
}
}
if(flag>0)
System.out.println("YES");
else
System.out.println("NO");
}
}
}
|
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0){
int n =sc.nextInt();
long[] arr = new long[n];
for(int i=0;i<n;i++){
arr[i] =sc.nextLong();
}
Map<Long, Long> map = new HashMap<>();
List<Long> list = new ArrayList<>();
list.add((long)0);
for(int i=0;i<n;i++){
int s = list.size();
for(int j=0;j<s;j++){
list.add(list.get(j)+arr[i]);
}
}
int flag = 0;
for(int i=0;i<list.size();i++){
map.put(list.get(i), map.getOrDefault(list.get(i), (long)0)+1);
if(map.get(list.get(i))>1){
flag = 1;
break;
}
}
if(flag>0)
System.out.println("YES");
else
System.out.println("NO");
}
}
}
| 1 |
Plagiarised
|
29d865c3
|
5cfa2861
|
import java.io.*;
import java.util.*;
public class C {
public static void main(String[] args) {
while (N-- > 0) {
solve();
}
out.close();
}
public static void solve() {
int M = sc.nextInt();
String a = sc.nextLine();
String b = sc.nextLine();
int d = 0;
int al = 0;
int bl = 0;
for (int i = 0; i < M; i++) {
if (a.charAt(i) != b.charAt(i)) {
d++;
}
if (a.charAt(i) == '1') {
al++;
}
if (b.charAt(i) == '1') {
bl++;
}
}
if ((al == bl && d % 2 == 0) || (M - al + 1 == bl && (M - d) % 2 == 1)) {
if ((al == bl && d % 2 == 0) && (M - al + 1 == bl && (M - d) % 2 == 1)) {
out.println(Math.min(d, M - d));
} else if (al == bl && d % 2 == 0) {
out.println(d);
} else {
out.println(M - d);
}
} else {
out.println(-1);
return;
}
}
private static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
private static MyScanner sc = new MyScanner();
private static int N = sc.nextInt();
@SuppressWarnings("unused")
private static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
/**
* check out my youtube channel sh0rkyboy
* https://tinyurl.com/zdxe2y4z
* I do screencasts, solutions, and other fun stuff in the future
*/
import java.util.*;
import java.io.*;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.Math.max;
public class EdB {
static long[] mods = {1000000007, 998244353, 1000000009};
static long mod = mods[0];
public static MyScanner sc;
public static PrintWriter out;
public static void main(String[] largewang) throws Exception{
// TODO Auto-generated method stub
sc = new MyScanner();
out = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-->0) {
int n = sc.nextInt();
char[] a = sc.next().toCharArray();
char[] b = sc.next().toCharArray();
int counta = 0;
int countb = 0;
for (char j : a) {
if (j == '1')
counta++;
}
for (char j : b) {
if (j == '1')
countb++;
}
long ans = 0;
if (counta == countb && n-counta+1 == countb){
for (int j = 0;j<n;j++){
if (b[j] == '1' && a[j] == '0') {
ans += 2;
}
}
long tempans = 0;
int j=0;
for(j = 0;j<n;j++){
if (a[j] == '1' && b[j] == '1')
break;
}
for(int i = 0;i<n;i++){
if (i == j)
continue;
if (a[i] == '1')
a[i] = '0';
else
a[i] = '1';
}
tempans += 1;
for (j = 0;j<n;j++){
if (b[j] == '1' && a[j] == '0') {
tempans += 2;
}
}
ans = min(ans, tempans);
} else if (counta == countb) {
for (int j = 0;j<n;j++){
if (b[j] == '1' && a[j] == '0') {
ans += 2;
}
}
} else if (n-counta+1 == countb) {
int j=0;
for(j = 0;j<n;j++){
if (a[j] == '1' && b[j] == '1')
break;
}
for(int i = 0;i<n;i++){
if (i == j)
continue;
if (a[i] == '1')
a[i] = '0';
else
a[i] = '1';
}
ans += 1;
for (j = 0;j<n;j++){
if (b[j] == '1' && a[j] == '0') {
ans += 2;
}
}
} else {
ans = -1;
}
out.println(ans);
}
out.close();
}
public static void sort(int[] array){
ArrayList<Integer> copy = new ArrayList<>();
for (int i : array)
copy.add(i);
Collections.sort(copy);
for(int i = 0;i<array.length;i++)
array[i] = copy.get(i);
}
static String[] readArrayString(int n){
String[] array = new String[n];
for(int j =0 ;j<n;j++)
array[j] = sc.next();
return array;
}
static int[] readArrayInt(int n){
int[] array = new int[n];
for(int j = 0;j<n;j++)
array[j] = sc.nextInt();
return array;
}
static int[] readArrayInt1(int n){
int[] array = new int[n+1];
for(int j = 1;j<=n;j++){
array[j] = sc.nextInt();
}
return array;
}
static long[] readArrayLong(int n){
long[] array = new long[n];
for(int j =0 ;j<n;j++)
array[j] = sc.nextLong();
return array;
}
static double[] readArrayDouble(int n){
double[] array = new double[n];
for(int j =0 ;j<n;j++)
array[j] = sc.nextDouble();
return array;
}
static int minIndex(int[] array){
int minValue = Integer.MAX_VALUE;
int minIndex = -1;
for(int j = 0;j<array.length;j++){
if (array[j] < minValue){
minValue = array[j];
minIndex = j;
}
}
return minIndex;
}
static int minIndex(long[] array){
long minValue = Long.MAX_VALUE;
int minIndex = -1;
for(int j = 0;j<array.length;j++){
if (array[j] < minValue){
minValue = array[j];
minIndex = j;
}
}
return minIndex;
}
static int minIndex(double[] array){
double minValue = Double.MAX_VALUE;
int minIndex = -1;
for(int j = 0;j<array.length;j++){
if (array[j] < minValue){
minValue = array[j];
minIndex = j;
}
}
return minIndex;
}
public static int power(long x, long y, long mod){
long ans = 1;
while(y>0){
if (y%2==1)
ans = (ans*x)%mod;
x = (x*x)%mod;
y/=2;
}
return (int)(ans);
}
static void verdict(boolean a){
out.println(a ? "YES" : "NO");
}
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try{
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
//StringJoiner sj = new StringJoiner(" ");
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is
| 0 |
Non-plagiarised
|
6f02c6d9
|
c2242c42
|
import java.io.*;
import java.util.*;
public class Main {
static long mod = 1000000007;
static long inv(long a, long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
static long mi(long a) {
return inv(a, mod);
}
static InputReader sc = new InputReader(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) throws IOException {
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
int[] A = new int[n];
for (int i = 0; i < A.length; i++) {
A[i] = sc.nextInt();
}
String word = sc.next();
ArrayList<Integer> blue = new ArrayList<>();
ArrayList<Integer> red = new ArrayList<>();
for (int i = 0; i < word.length(); i++) {
if (word.charAt(i) == 'R') {
red.add(A[i]);
} else {
blue.add(A[i]);
}
}
Collections.sort(blue);
Collections.sort(red);
boolean possible = true;
int a = 1;
for (int i = 0; i < blue.size(); i++, a++) {
if (blue.get(i) < a) {
possible = false;
break;
}
}
for (int i = 0; i < red.size(); i++, a++) {
if (red.get(i) > a) {
possible = false;
break;
}
}
if (possible) out.println("YES");
else out.println("NO");
}
out.flush();
out.close();
}
static class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
return str;
}
}
public static void shuffle(int[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
int temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
public static void shuffle(long[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
long temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
}
|
// package codechef;
import java.io.*;
import java.util.*;
public class cp_2 {
static int mod=998244353;
// static Reader sc=new Reader();
static FastReader sc=new FastReader(System.in);
static int[] sp;
static int size=(int)1e6;
public static void main(String[] args) throws IOException {
long tc=sc.nextLong();
// Scanner sc=new Scanner(System.in);
// int tc=1;
// primeSet=new HashSet<>();
// sieveOfEratosthenes((int)1e5);
while(tc-->0)
{
int n=sc.nextInt();
int arr[]=new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i]=sc.nextInt();
}
String s=sc.next();
ArrayList<Integer> blue=new ArrayList<>();
ArrayList<Integer> red=new ArrayList<>();
for(int i=0;i<n;i++)
{
if(s.charAt(i)=='B')
blue.add(arr[i]);
else {
red.add(arr[i]);
}
}
Collections.sort(blue);
Collections.sort(red,Collections.reverseOrder());
boolean flag=true;
for(int i=0;i<blue.size();i++)
{
if(blue.get(i)<i+1)
flag=false;
}
for(int i=0;i<red.size();i++)
{
if(red.get(i)>n-i)
flag=false;
}
printYesNo(flag);
}
out.flush();
out.close();
System.gc();
}
/*
...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
*/
static int N = 501;
// Array to store inverse of 1 to N
static long[] factorialNumInverse = new long[N + 1];
// Array to precompute inverse of 1! to N!
static long[] naturalNumInverse = new long[N + 1];
// Array to store factorial of first N numbers
static long[] fact = new long[N + 1];
// Function to precompute inverse of numbers
public static void InverseofNumber(int p)
{
naturalNumInverse[0] = naturalNumInverse[1] = 1;
for(int i = 2; i <= N; i++)
naturalNumInverse[i] = naturalNumInverse[p % i] *
(long)(p - p / i) % p;
}
// Function to precompute inverse of factorials
public static void InverseofFactorial(int p)
{
factorialNumInverse[0] = factorialNumInverse[1] = 1;
// Precompute inverse of natural numbers
for(int i = 2; i <= N; i++)
factorialNumInverse[i] = (naturalNumInverse[i] *
factorialNumInverse[i - 1]) % p;
}
// Function to calculate factorial of 1 to N
public static void factorial(int p)
{
fact[0] = 1;
// Precompute factorials
for(int i = 1; i <= N; i++)
{
fact[i] = (fact[i - 1] * (long)i) % p;
}
}
// Function to return nCr % p in O(1) time
public static long Binomial(int N, int R, int p)
{
// n C r = n!*inverse(r!)*inverse((n-r)!)
long ans = ((fact[N] * factorialNumInverse[R]) %
p * factorialNumInverse[N - R]) % p;
return ans;
}
static String tr(String s)
{
int now = 0;
while (now + 1 < s.length() && s.charAt(now)== '0')
++now;
return s.substring(now);
}
static ArrayList<Integer> ans;
static void dfs(int node,Graph gg,int cnt,int k,ArrayList<Integer> temp)
{
if(cnt==k)
return;
for(Integer each:gg.list[node])
{
if(each==0)
{
temp.add(each);
ans=new ArrayList<>(temp);
temp.remove(temp.size()-1);
continue;
}
temp.add(each);
dfs(each,gg,cnt+1,k,temp);
temp.remove(temp.size()-1);
}
return;
}
static HashSet<Integer> factors(int x)
{
HashSet<Integer> a=new HashSet<Integer>();
for(int i=2;i*i<=x;i++)
{
if(x%i==0)
{
a.add(i);
a.add(x/i);
}
}
return a;
}
static class Node
{
int vertex;
HashSet<Node> adj;
boolean rem;
Node(int ver)
{
vertex=ver;
rem=false;
adj=new HashSet<Node>();
}
@Override
public String toString()
{
return vertex+" ";
}
}
static class Tuple{
int a;
int b;
int c;
public Tuple(int a,int b,int c) {
this.a=a;
this.b=b;
this.c=c;
}
}
//function to find prime factors of n
static HashMap<Integer,Integer> findFactors(int n)
{
HashMap<Integer,Integer> ans=new HashMap<>();
if(n%2==0)
{
ans.put(2, 0);
while((n&1)==0)
{
n=n>>1;
ans.put(2, ans.get(2)+1);
}
}
for(int i=3;i*i<=n;i+=2)
{
if(n%i==0)
{
ans.put(i, 0);
while(n%i==0)
{
n=n/i;
ans.put(i, ans.get(i)+1);
}
}
}
if(n!=1)
ans.put(n, ans.getOrDefault(n, 0)+1);
return ans;
}
//fenwick tree implementaion
static class fwt
{
int n;
long BITree[];
fwt(int n)
{
this.n=n;
BITree=new long[n+1];
}
fwt(int arr[], int n)
{
this.n=n;
BITree=new long[n+1];
for(int i = 0; i < n; i++)
updateBIT(n, i, arr[i]);
}
long getSum(int index)
{
long sum = 0;
index = index + 1;
while(index>0)
{
sum += BITree[index];
index -= index & (-index);
}
return sum;
}
void updateBIT(int n, int index,int val)
{
index = index + 1;
while(index <= n)
{
BITree[index] += val;
index += index & (-index);
}
}
void print()
{
for(int i=0;i<n;i++)
out.print(getSum(i)+" ");
out.println();
}
}
//Function to find number of set bits
static int setBitNumber(long n)
{
if (n == 0)
return 0;
int msb = 0;
n = n / 2;
while (n != 0) {
n = n / 2;
msb++;
}
return msb;
}
static int getFirstSetBitPos(long n)
{
return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
}
static ArrayList<Integer> primes;
static HashSet<Integer> primeSet;
static boolean prime[];
static void sieveOfEratosthenes(int n)
{
// Create a boolean array
// "prime[0..n]" and
// initialize all entries
// it as true. A value in
// prime[i] will finally be
// false if i is Not a
// prime, else true.
prime= new boolean[n + 1];
for (int i = 2; i <= n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++)
{
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true)
{
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for (int i = 2; i <= n; i++)
{
if (prime[i] == true)
primeSet.add(i);
}
}
static long mod(long a, long b) {
long c = a % b;
return (c < 0) ? c + b : c;
}
static void swap(long arr[],int i,int j)
{
long temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
static boolean util(int a,int b,int c)
{
if(b>a)util(b, a, c);
while(c>=a)
{
c-=a;
if(c%b==0)
return true;
}
return (c%b==0);
}
static void flag(boolean flag)
{
out.println(flag ? "YES" : "NO");
out.flush();
}
static void print(int a[])
{
int n=a.length;
for(int i=0;i<n;i++)
{
out.print(a[i]+" ");
}
out.println();
out.flush();
}
static void print(long a[])
{
int n=a.length;
for(int i=0;i<n;i++)
{
out.print(a[i]+" ");
}
out.println();
out.flush();
}
static void print_int(ArrayList<Integer> al)
{
int si=al.size();
for(int i=0;i<si;i++)
{
out.print(al.get(i)+" ");
}
out.println();
out.flush();
}
static void print_long(ArrayList<Long> al)
{
int si=al.size();
for(int i=0;i<si;i++)
{
out.print(al.get(i)+" ");
}
out.println();
out.flush();
}
static void printYesNo(boolean condition)
{
if (condition) {
out.println("Yes");
}
else {
out.println("No");
}
}
static int LowerBound(int a[], int x)
{ // x is the target value or key
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]>=x) r=m;
else l=m;
}
return r;
}
static int lowerIndex(int arr[], int n, int x)
{
int l = 0, h = n - 1;
while (l <= h)
{
int mid = (l + h) / 2;
if (arr[mid] >= x)
h = mid - 1;
else
l = mid + 1;
}
return l;
}
// function to find last index <= y
static int upperIndex(int arr[], int n, int y)
{
int l = 0, h = n - 1;
while (l <= h)
{
int mid = (l + h) / 2;
if (arr[mid] <= y)
l = mid + 1;
else
h = mid - 1;
}
return h;
}
static int upperIndex(long arr[], int n, long y)
{
int l = 0, h = n - 1;
while (l <= h)
{
int mid = (l + h) / 2;
if (arr[mid] <= y)
l = mid + 1;
else
h = mid - 1;
}
return h;
}
static int UpperBound(int a[], int x)
{// x is the key or target value
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]<=x) l=m;
else r=m;
}
return l+1;
}
static int UpperBound(long a[], long x)
{// x is the key or target value
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]<=x) l=m;
else r=m;
}
return l+1;
}
static class DisjointUnionSets
{
int[] rank, parent;
int n;
// Constructor
public DisjointUnionSets(int n)
{
rank = new int[n];
parent = new int[n];
this.n = n;
makeSet();
}
// Creates n sets with single item in each
void makeSet()
{
for (int i = 0; i < n; i++)
parent[i] = i;
}
int find(int x)
{
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
// Unites the set that includes x and the set
// that includes x
void union(int x, int y)
{
int xRoot = find(x), yRoot = find(y);
if (xRoot == yRoot)
return;
if (rank[xRoot] < rank[yRoot])
parent[xRoot] = yRoot;
else if (rank[yRoot] < rank[xRoot])
parent[yRoot] = xRoot;
else // if ranks are the same
{
parent[yRoot] = xRoot;
rank[xRoot] = rank[xRoot] + 1;
}
// if(xRoot!=yRoot)
// parent[y]=x;
}
int connectedComponents()
{
int cnt=0;
for(int i=0;i<n;i++)
{
if(parent[i]==i)
cnt++;
}
return cnt;
}
}
static class Graph
{
int v;
ArrayList<Integer> list[];
Graph(int v)
{
this.v=v;
list=new ArrayList[v+1];
for(int i=1;i<=v;i++)
list[i]=new ArrayList<Integer>();
}
void addEdge(int a, int b)
{
this.list[a].add(b);
}
}
// static class GraphMap{
// Map<String,ArrayList<String>> graph;
// GraphMap() {
// // TODO Auto-generated constructor stub
// graph=new HashMap<String,ArrayList<String>>();
//
// }
// void addEdge(String a,String b)
// {
// if(graph.containsKey(a))
// this.graph.get(a).add(b);
// else {
// this.graph.put(a, new ArrayList<>());
// this.graph.get(a).add(b);
// }
// }
// }
// static void dfsMap(GraphMap g,HashSet<String> vis,String src,int ok)
// {
// vis.add(src);
//
// if(g.graph.get(src)!=null)
// {
// for(String each:g.graph.get(src))
// {
// if(!vis.contains(each))
// {
// dfsMap(g, vis, each, ok+1);
// }
// }
// }
//
// cnt=Math.max(cnt, ok);
// }
static double sum[];
static long cnt;
static void DFS(Graph g, boolean[] visited, int u)
{
visited[u]=true;
for(int i=0;i<g.list[u].size();i++)
{
int v=g.list[u].get(i);
if(!visited[v])
{
cnt=cnt*2;
DFS(g, visited, v);
}
}
}
static class Pair implements Comparable<Pair>
{
int x,y;
Pair(int x,int y)
{
this.x=x;
this.y=y;
}
@Override
public int compareTo(Pair o) {
// TODO Auto-generated method stub
return this.x-o.x;
}
}
static long sum_array(int a[])
{
int n=a.length;
long sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
return sum;
}
static long sum_array(long a[])
{
int n=a.length;
long sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
return sum;
}
static void sort(int[] a)
{
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void sort(long[] a)
{
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void reverse_array(int a[])
{
int n=a.length;
int i,t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
static void reverse_array(long a[])
{
int n=a.length;
int i; long t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
// static long modInverse(long a, long m)
// {
// long g = gcd(a, m);
//
// return power(a, m - 2, m);
//
// }
static long power(long x, long y)
{
long res = 1;
x = x % mod;
if (x == 0)
return 0;
while (y > 0)
{
if ((y & 1) != 0)
res = (res * x) % mod;
y = y >> 1; // y = y/2
x = (x * x) % mod;
}
return res;
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
//cnt+=a/b;
return gcd(b%a,a);
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
static class FastReader{
byte[] buf = new byte[2048];
int index, total;
InputStream in;
FastReader(InputStream is) {
in = is;
}
int scan() throws IOException {
if (index >= total) {
index = 0;
total = in.read(buf);
if (total <= 0) {
return -1;
}
}
return buf[index++];
}
String next() throws IOException {
int c;
for (c = scan(); c <= 32; c = scan());
StringBuilder sb = new StringBuilder();
for (; c > 32; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
int nextInt() throws IOException {
int c, val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
long nextLong() throws IOException {
int c;
long val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
}
static class Reader
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException
{
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1)
{
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.')
{
while ((c = read()) >= '0' && c <= '9')
{
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
static PrintWriter out=new PrintWriter(System.out);
static int int_max=Integer.MAX_VALUE;
static int int_min=Integer.MIN_VALUE;
static long long_max=Long.MAX_VALUE;
static long long_min=Long.MIN_VALUE;
}
| 1 |
Plagiarised
|
0c9d4def
|
f665e87b
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;
public class C{
private static int maxWords = 0;
private static int[][] words;
private static int n;
private static int[] netwrtchar(int index){
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<n; i++){
int sum = 0;
for(int j=0; j<words[i].length; j++){
if(j==index) continue;
sum += words[i][j];
}
list.add(words[i][index] - sum);
// f[i] = words[i][index] - sum;
}
Collections.sort(list, Collections.reverseOrder());
int[] f = new int[list.size()];
for(int i=0; i<list.size(); i++){
f[i] = list.get(i);
}
return f;
}
private static int maxWindow(int[] f){
int count = 0, sum = 0;
int index = 0;
while(index<f.length && sum+f[index]>0){
sum += f[index++];
count++;
}
return count;
}
public static void main(String[] args){
FS sc = new FS();
PrintWriter pw = new PrintWriter(System.out);
int t = sc.nextInt();
while(t-->0){
n = sc.nextInt();
words = new int[n][5];
maxWords = 0;
for(int i=0; i<n; i++){
String s = sc.next();
for(int j=0; j<s.length(); j++){
words[i][s.charAt(j)-'a']++;
}
}
int maxWindow = 0;
for(int i=0; i<5; i++){
int[] f = netwrtchar(i);
int current = maxWindow(f);
maxWindow = Math.max(maxWindow, current);
}
System.out.println(maxWindow);
}
pw.flush();
pw.close();
}
static class FS{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next(){
while(!st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
} catch(Exception ignored){
}
}
return st.nextToken();
}
int[] nextArray(int n){
int[] a = new int[n];
for(int i = 0; i < n; i++){
a[i] = nextInt();
}
return a;
}
long[] nextLongArray(int n){
long[] a = new long[n];
for(int i = 0; i < n; i++){
a[i] = nextLong();
}
return a;
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
}
}
|
/*
* 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.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import java.util.TreeMap;
public class C_CF {
public static void main(String[] args) {
FastScanner57 fs = new FastScanner57();
PrintWriter pw = new PrintWriter(System.out);
int t = fs.ni();
//int t = 1;
for (int tc = 0; tc < t; tc++) {
int n = fs.ni();
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = fs.next();
}
int res = c(0,s);
for (int i = 1; i < 5; i++) {
res = Math.max(res,c(i,s));
}
pw.println(res);
}
pw.close();
}
public static int c(int l, String[] s) {
List<Integer> list = new ArrayList();
for (int i = 0; i < s.length; i++) {
String t = s[i];
int ct = 0;
for (int j = 0; j < t.length(); j++) {
if (t.charAt(j)-'a'==l) {
ct++;
} else {
ct--;
}
}
list.add(ct);
}
Collections.sort(list);
Collections.reverse(list);
int sum = 0;
for (int i = 0; i < s.length; i++) {
sum += list.get(i);
if (sum<=0) return i;
}
return list.size();
}
public static int gcd(int n1, int n2) {
if (n2 == 0) {
return n1;
}
return gcd(n2, n1 % n2);
}
static class BIT18 {
int[] bit;
public BIT18(int size) {
bit = new int[size];
}
public void update(int ind, int delta) {
while (ind < bit.length) {
bit[ind] += delta;
ind = ind + (ind & (-1 * ind));
}
}
public int sum(int ind) {
int s = 0;
while (ind > 0) {
s += bit[ind];
ind = ind - (ind & (-1 * ind));
}
return s;
}
public int query(int l, int r) {
return sum(r) - sum(l);
}
}
// 0 -> left was chosen
// 1 -> right was chosen
public static void sort(long[] a) {
List<Long> list = new ArrayList();
for (int i = 0; i < a.length; i++) {
list.add(a[i]);
}
Collections.sort(list);
for (int i = 0; i < a.length; i++) {
a[i] = list.get(i);
}
}
public static long gcd(long n1, long n2) {
if (n2 == 0) {
return n1;
}
return gcd(n2, n1 % n2);
}
}
class UnionFind16 {
int[] id;
public UnionFind16(int size) {
id = new int[size];
for (int i = 0; i < size; i++) {
id[i] = i;
}
}
public int find(int p) {
int root = p;
while (root != id[root]) {
root = id[root];
}
while (p != root) {
int next = id[p];
id[p] = root;
p = next;
}
return root;
}
public void union(int p, int q) {
int a = find(p), b = find(q);
if (a == b) {
return;
}
id[b] = a;
}
}
class FastScanner57 {
BufferedReader br;
StringTokenizer st;
public FastScanner57() {
br = new BufferedReader(new InputStreamReader(System.in), 32768);
st = null;
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int ni() {
return Integer.parseInt(next());
}
int[] intArray(int N) {
int[] ret = new int[N];
for (int i = 0; i < N; i++) {
ret[i] = ni();
}
return ret;
}
long nl() {
return Long.parseLong(next());
}
long[] longArray(int N) {
long[] ret = new long[N];
for (int i = 0; i < N; i++) {
ret[i] = nl();
}
return ret;
}
double nd() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
| 0 |
Non-plagiarised
|
624b8db5
|
eacc407e
|
//created by Whiplash99
import java.io.*;
import java.util.*;
public class C
{
private static ArrayDeque<Integer>[] edge;
private static HashMap<String,Integer> map;
private static String getHash(int u, int v)
{
if(u>v)
{
int tmp=u;
u=v;
v=tmp;
}
return u+" "+v;
}
private static void DFS(int u, int p, int[] ans, int val)
{
for(int v:edge[u])
{
if(v==p) continue;
ans[map.get(getHash(u,v))]=val;
DFS(v,u,ans,5-val);
val=5-val;
}
}
public static void main(String[] args) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int i,N;
int T=Integer.parseInt(br.readLine().trim());
StringBuilder sb=new StringBuilder();
while (T-->0)
{
N=Integer.parseInt(br.readLine().trim());
edge=new ArrayDeque[N];
for(i=0;i<N;i++) edge[i]=new ArrayDeque<>();
map=new HashMap<>();
int[] ans=new int[N-1];
int[] deg=new int[N];
for(i=0;i<N-1;i++)
{
String[] s=br.readLine().trim().split(" ");
int u=Integer.parseInt(s[0])-1;
int v=Integer.parseInt(s[1])-1;
edge[u].add(v); edge[v].add(u);
deg[u]++; deg[v]++;
map.put(getHash(u,v),i);
}
for(i=0;i<N;i++) if(deg[i]>2) break;
if(i<N)
{
sb.append(-1).append("\n");
continue;
}
DFS(0,0,ans,2);
for(int x:ans) sb.append(x).append(" ");
sb.append("\n");
}
System.out.println(sb);
}
}
|
import java.io.*;
import java.util.*;
public class A {
static ArrayList<int[]>[] adj;
static int[] vals = { 2, 11 };
static int[] res;
static void dfs(int u, int p, int par) {
for (int[] nxt : adj[u]) {
int v = nxt[0];
int idx = nxt[1];
if (v != p) {
res[idx] = vals[par];
dfs(v, u, 1 ^ par);
}
}
}
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
res = new int[n - 1];
adj = new ArrayList[n];
for (int i = 0; i < n; i++) {
adj[i] = new ArrayList<int[]>();
}
for (int i = 0; i < n - 1; i++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
adj[u].add(new int[] { v, i });
adj[v].add(new int[] { u, i });
}
boolean valid = true;
int start = 0;
for (int i = 0; i < n; i++) {
if (adj[i].size() == 1)
start = i;
valid &= adj[i].size() <= 2;
}
dfs(start, -1, 0);
if (valid) {
for (int x : res)
pw.print(x + " ");
} else {
pw.print(-1);
}
pw.println();
}
pw.flush();
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader f) {
br = new BufferedReader(f);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public int[] nextIntArr(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(next());
}
return arr;
}
}
}
| 0 |
Non-plagiarised
|
7bcacc97
|
e431de28
|
/* 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 void main (String[] args) throws java.lang.Exception
{
// StringBuilder sb=new StringBuilder();
// BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
Scanner sc=new Scanner(System.in);
// int t=Integer.parseInt(bf.readLine());
int t=sc.nextInt();
while(t-->0)
{
// ArrayList<Integer> abcd=new ArrayList<>();
// HashMap<Integer,Integer> amd=new HashMap<>();
// int n=Integer.parseInt(bf.readLine());
// int a[]=new int[n];
// String s[]=bf.readLine().split(" ");
// for(int i=0;i<n;i++)
// {
// a[i]=Integer.parseInt(s[i]);
// }
int n=sc.nextInt();
long a[]=new long[n];
for(int i=0;i<n;i++)
{
a[i]=sc.nextLong();
}
long ans=Long.MAX_VALUE;
int count1=1;
int count2=1;
boolean san=true;
long sum1=a[0];
long sum2=a[1];
long min1=a[0];
long min2=a[1];
ans=((n*1L*sum1)+(n*1L*sum2));
// System.out.println("san "+ans);
for(int i=2;i<n;i++)
{
if(san)
{
count1++;
san=false;
sum1+=a[i];
min1=Math.min(min1,a[i]);
long z1=sum1+(n-count1)*min1;
long z2= sum2+(n-count2)*min2;
ans=Math.min(ans,z1+z2);
}
else
{
count2++;
san=true;
sum2+=a[i];
min2=Math.min(min2,a[i]);
long z1=sum1+(n-count1)*min1;
long z2= sum2+(n-count2)*min2;
ans=Math.min(ans,z1+z2);
}
// System.out.println(i+" "+ans);
}
System.out.println(ans);
}
}
static class Data
{
int first;
int sec;
Data(int z1,int z2)
{
first=z1;
sec=z2;
}
}
static class MINasc implements Comparator<Data>
{
public int compare (Data z1,Data z2)
{
if(z1.first>z2.first)
return 1;
else if(z1.first<z2.first)
return -1;
else
return 0;
}
}
static class MINdsc implements Comparator<Data>
{
public int compare (Data z1,Data z2)
{
if(z1.first>z2.first)
return -1;
else if(z1.first<z2.first)
return 1;
else
return 0;
}
}
}
|
import java.io.*;
import java.lang.*;
import java.util.*;
public class MinGridPath {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner s=new Scanner(System.in);
int t=s.nextInt();
while(t-->0){
int n = s.nextInt();
long[] aa =new long[n];
for(int i=0;i<n;i++)
aa[i]=s.nextLong();
long minEven = aa[0];
long minOdd = aa[1];
long sum = aa[0]+aa[1];
long best = n*minEven + n*minOdd;
int numOdd = 1;
int numEven = 1;
for(int i=2; i<n; ++i) {
if(i%2 == 0) {
minEven = Math.min(aa[i], minEven);
numEven++;
}else {
minOdd = Math.min(aa[i], minOdd);
numOdd++;
}
sum += aa[i];
long score = sum;
score += minEven*(n-numEven);
score += minOdd*(n-numOdd);
best = Math.min(best, score);
}
System.out.println(best);
}
}
}
| 0 |
Non-plagiarised
|
2bd5c798
|
317baeaf
|
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.*;
/**
*
* @Har_Har_Mahadev
*/
/**
* Main , Solution , Remove Public
*/
public class A {
public static void process() throws IOException {
int n = sc.nextInt();
String s = sc.next(),t = sc.next();
int zs = 0, zt = 0;
for(int i = 0; i<n; i++) {
if(s.charAt(i) == '0')zs++;
if(t.charAt(i) == '0')zt++;
}
int ans = n+1;
if(zs == zt) {
int min = 0;
for(int i = 0; i<n; i++)if(s.charAt(i) != t.charAt(i))min++;
ans = min(ans, min);
}
if(n-zs-1 == zt) {
int min = 0;
for(int i = 0; i<n; i++)if(s.charAt(i) == t.charAt(i))min++;
ans = min(ans, min);
}
if(ans == n+1)ans = -1;
System.out.println(ans);
}
//=============================================================================
//--------------------------The End---------------------------------
//=============================================================================
private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
private static int N = 0;
private static void google(int tt) {
System.out.print("Case #" + (tt) + ": ");
}
static FastScanner sc;
static FastWriter out;
public static void main(String[] args) throws IOException {
boolean oj = true;
if (oj) {
sc = new FastScanner();
out = new FastWriter(System.out);
} else {
sc = new FastScanner("input.txt");
out = new FastWriter("output.txt");
}
long s = System.currentTimeMillis();
int t = 1;
t = sc.nextInt();
int TTT = 1;
while (t-- > 0) {
// google(TTT++);
process();
}
out.flush();
// tr(System.currentTimeMillis()-s+"ms");
}
private static boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private static void tr(Object... o) {
if (!oj)
System.err.println(Arrays.deepToString(o));
}
static class Pair implements Comparable<Pair> {
int x, y;
Pair(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(Pair o) {
return Integer.compare(this.x, o.x);
}
/*
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Pair)) return false;
Pair key = (Pair) o;
return x == key.x && y == key.y;
}
@Override
public int hashCode() {
int result = x;
result = 31 * result + y;
return result;
}
*/
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
static int ceil(int x, int y) {
return (x % y == 0 ? x / y : (x / y + 1));
}
static long ceil(long x, long y) {
return (x % y == 0 ? x / y : (x / y + 1));
}
static long sqrt(long z) {
long sqz = (long) Math.sqrt(z);
while (sqz * 1L * sqz < z) {
sqz++;
}
while (sqz * 1L * sqz > z) {
sqz--;
}
return sqz;
}
static int log2(int N) {
int result = (int) (Math.log(N) / Math.log(2));
return result;
}
public static long gcd(long a, long b) {
if (a > b)
a = (a + b) - (b = a);
if (a == 0L)
return b;
return gcd(b % a, a);
}
public static long lcm(long a, long b) {
return (a * b) / gcd(a, b);
}
public static int lower_bound(int[] arr, int x) {
int low = 0, high = arr.length - 1, mid = -1;
int ans = -1;
while (low <= high) {
mid = (low + high) / 2;
if (arr[mid] > x) {
high = mid - 1;
} else {
ans = mid;
low = mid + 1;
}
}
return ans;
}
public static int upper_bound(int[] arr, int x) {
int low = 0, high = arr.length - 1, mid = -1;
int ans = arr.length;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= x) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
static void ruffleSort(int[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
int temp = a[i];
a[i] = a[r];
a[r] = temp;
}
Arrays.sort(a);
}
static void ruffleSort(long[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
long temp = a[i];
a[i] = a[r];
a[r] = temp;
}
Arrays.sort(a);
}
static void reverseArray(int[] a) {
int n = a.length;
int arr[] = new int[n];
for (int i = 0; i < n; i++)
arr[i] = a[n - i - 1];
for (int i = 0; i < n; i++)
a[i] = arr[i];
}
static void reverseArray(long[] a) {
int n = a.length;
long arr[] = new long[n];
for (int i = 0; i < n; i++)
arr[i] = a[n - i - 1];
for (int i = 0; i < n; i++)
a[i] = arr[i];
}
//custom multiset (replace with HashMap if needed)
public static void push(TreeMap<Integer, Integer> map, int k, int v) {
//map[k] += v;
if (!map.containsKey(k))
map.put(k, v);
else
map.put(k, map.get(k) + v);
}
public static void pull(TreeMap<Integer, Integer> map, int k, int v) {
//assumes map[k] >= v
//map[k] -= v
int lol = map.get(k);
if (lol == v)
map.remove(k);
else
map.put(k, lol - v);
}
// compress Big value to Time Limit
public static int[] compress(int[] arr) {
ArrayList<Integer> ls = new ArrayList<Integer>();
for (int x : arr)
ls.add(x);
Collections.sort(ls);
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
int boof = 1; //min value
for (int x : ls)
if (!map.containsKey(x))
map.put(x, boof++);
int[] brr = new int[arr.length];
for (int i = 0; i < arr.length; i++)
brr[i] = map.get(arr[i]);
return brr;
}
// Fast Writer
public static class FastWriter {
private static final int BUF_SIZE = 1 << 13;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastWriter() {
out = null;
}
public FastWriter(OutputStream os) {
this.out = os;
}
public FastWriter(String path) {
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastWriter write(byte b) {
buf[ptr++] = b;
if (ptr == BUF_SIZE)
innerflush();
return this;
}
public FastWriter write(char c) {
return write((byte) c);
}
public FastWriter write(char[] s) {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE)
innerflush();
}
return this;
}
public FastWriter write(String s) {
s.chars().forEach(c -> {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE)
innerflush();
});
return this;
}
private static int countDigits(int l) {
if (l >= 1000000000)
return 10;
if (l >= 100000000)
return 9;
if (l >= 10000000)
return 8;
if (l >= 1000000)
return 7;
if (l >= 100000)
return 6;
if (l >= 10000)
return 5;
if (l >= 1000)
return 4;
if (l >= 100)
return 3;
if (l >= 10)
return 2;
return 1;
}
public FastWriter write(int x) {
if (x == Integer.MIN_VALUE) {
return write((long) x);
}
if (ptr + 12 >= BUF_SIZE)
innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
private static int countDigits(long l) {
if (l >= 1000000000000000000L)
return 19;
if (l >= 100000000000000000L)
return 18;
if (l >= 10000000000000000L)
return 17;
if (l >= 1000000000000000L)
return 16;
if (l >= 100000000000000L)
return 15;
if (l >= 10000000000000L)
return 14;
if (l >= 1000000000000L)
return 13;
if (l >= 100000000000L)
return 12;
if (l >= 10000000000L)
return 11;
if (l >= 1000000000L)
return 10;
if (l >= 100000000L)
return 9;
if (l >= 10000000L)
return 8;
if (l >= 1000000L)
return 7;
if (l >= 100000L)
return 6;
if (l >= 10000L)
return 5;
if (l >= 1000L)
return 4;
if (l >= 100L)
return 3;
if (l >= 10L)
return 2;
return 1;
}
public FastWriter write(long x) {
if (x == Long.MIN_VALUE) {
return write("" + x);
}
if (ptr + 21 >= BUF_SIZE)
innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
public FastWriter write(double x, int precision) {
if (x < 0) {
write('-');
x = -x;
}
x += Math.pow(10, -precision) / 2;
// if(x < 0){ x = 0; }
write((long) x).write(".");
x -= (long) x;
for (int i = 0; i < precision; i++) {
x *= 10;
write((char) ('0' + (int) x));
x -= (int) x;
}
return this;
}
public FastWriter writeln(char c) {
return write(c).writeln();
}
public FastWriter writeln(int x) {
return write(x).writeln();
}
public FastWriter writeln(long x) {
return write(x).writeln();
}
public FastWriter writeln(double x, int precision) {
return write(x, precision).writeln();
}
public FastWriter write(int... xs) {
boolean first = true;
for (int x : xs) {
if (!first)
write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter write(long... xs) {
boolean first = true;
for (long x : xs) {
if (!first)
write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter writeln() {
return write((byte) '\n');
}
public FastWriter writeln(int... xs) {
return write(xs).writeln();
}
public FastWriter writeln(long... xs) {
return write(xs).writeln();
}
public FastWriter writeln(char[] line) {
return write(line).writeln();
}
public FastWriter writeln(char[]... map) {
for (char[] line : map)
write(line).writeln();
return this;
}
public FastWriter writeln(String s) {
return write(s).writeln();
}
private void innerflush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (IOException e) {
throw new RuntimeException("innerflush");
}
}
public void flush() {
innerflush();
try {
out.flush();
} catch (IOException e) {
throw new RuntimeException("flush");
}
}
public FastWriter print(byte b) {
return write(b);
}
public FastWriter print(char c) {
return write(c);
}
public FastWriter print(char[] s) {
return write(s);
}
public FastWriter print(String s) {
return write(s);
}
public FastWriter print(int x) {
return write(x);
}
public FastWriter print(long x) {
return write(x);
}
public FastWriter print(double x, int precision) {
return write(x, precision);
}
public FastWriter println(char c) {
return writeln(c);
}
public FastWriter println(int x) {
return writeln(x);
}
public FastWriter println(long x) {
return writeln(x);
}
public FastWriter println(double x, int precision) {
return writeln(x, precision);
}
public FastWriter print(int... xs) {
return write(xs);
}
public FastWriter print(long... xs) {
return write(xs);
}
public FastWriter println(int... xs) {
return writeln(xs);
}
public FastWriter println(long... xs) {
return writeln(xs);
}
public FastWriter println(char[] line) {
return writeln(line);
}
public FastWriter println(char[]... map) {
return writeln(map);
}
public FastWriter println(String s) {
return writeln(s);
}
public FastWriter println() {
return writeln();
}
}
// Fast Inputs
static class FastScanner {
//I don't understand how this works lmao
private int BS = 1 << 16;
private char NC = (char) 0;
private byte[] buf = new byte[BS];
private int bId = 0, size = 0;
private char c = NC;
private double cnt = 1;
private BufferedInputStream in;
public FastScanner() {
in = new BufferedInputStream(System.in, BS);
}
public FastScanner(String s) {
try {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
} catch (Exception e) {
in = new BufferedInputStream(System.in, BS);
}
}
private char getChar() {
while (bId == size) {
try {
size = in.read(buf);
} catch (Exception e) {
return NC;
}
if (size == -1)
return NC;
bId = 0;
}
return (char) buf[bId++];
}
public int nextInt() {
return (int) nextLong();
}
public int[] readArray(int N) {
int[] res = new int[N];
for (int i = 0; i < N; i++) {
res[i] = (int) nextLong();
}
return res;
}
public long[] readArrayLong(int N) {
long[] res = new long[N];
for (int i = 0; i < N; i++) {
res[i] = nextLong();
}
return res;
}
public int[][] readArrayMatrix(int N, int M, int Index) {
if (Index == 0) {
int[][] res = new int[N][M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++)
res[i][j] = (int) nextLong();
}
return res;
}
int[][] res = new int[N][M];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++)
res[i][j] = (int) nextLong();
}
return res;
}
public long[][] readArrayMatrixLong(int N, int M, int Index) {
if (Index == 0) {
long[][] res = new long[N][M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++)
res[i][j] = nextLong();
}
return res;
}
long[][] res = new long[N][M];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++)
res[i][j] = nextLong();
}
return res;
}
public long nextLong() {
cnt = 1;
boolean neg = false;
if (c == NC)
c = getChar();
for (; (c < '0' || c > '9'); c = getChar()) {
if (c == '-')
neg = true;
}
long res = 0;
for (; c >= '0' && c <= '9'; c = getChar()) {
res = (res << 3) + (res << 1) + c - '0';
cnt *= 10;
}
return neg ? -res : res;
}
public double nextDouble() {
double cur = nextLong();
return c != '.' ? cur : cur + nextLong() / cnt;
}
public double[] readArrayDouble(int N) {
double[] res = new double[N];
for (int i = 0; i < N; i++) {
res[i] = nextDouble();
}
return res;
}
public String next() {
StringBuilder res = new StringBuilder();
while (c <= 32)
c = getChar();
while (c > 32) {
res.append(c);
c = getChar();
}
return res.toString();
}
public String nextLine() {
StringBuilder res = new StringBuilder();
while (c <= 32)
c = getChar();
while (c != '\n') {
res.append(c);
c = getChar();
}
return res.toString();
}
public boolean hasNext() {
if (c > 32)
return true;
while (true) {
c = getChar();
if (c == NC)
return false;
else if (c > 32)
return true;
}
}
}
}
|
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
StringTokenizer st;
int t = Integer.parseInt(br.readLine());
while (t --> 0) {
int n = Integer.parseInt(br.readLine());
String a = br.readLine();
String b = br.readLine();
int alit = 0;
int blit = 0;
int ans = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
if (a.charAt(i) == '1') alit++;
if (b.charAt(i) == '1') blit++;
}
if (alit == blit) {
int count = 0;
for (int i = 0; i < n; i++)
if (a.charAt(i) != b.charAt(i)) count++;
ans = Math.min(count, ans);
}
if (alit == n - blit + 1) {
int count = 0;
for (int i = 0; i < n; i++)
if (a.charAt(i) == b.charAt(i)) count++;
ans = Math.min(ans, count);
}
if (ans == Integer.MAX_VALUE) {
pw.println("-1");
} else {
pw.println(ans);
}
}
pw.close();
}
}
| 1 |
Plagiarised
|
b2bae06a
|
d4779c71
|
import java.util.*;
import java.io.*;
public class D{
static class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int snext() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = snext();
while (isSpaceChar(c)) {
c = snext();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = snext();
while (isSpaceChar(c)) {
c = snext();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
public String readString() {
int c = snext();
while (isSpaceChar(c)) {
c = snext();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public String nextLine() {
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isEndOfLine(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object...objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(objects[i]);
}
}
public void printLine(Object...objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
public void flush() {
writer.flush();
}
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static int mod = (int)(1e9+7);
public static long pow(long a,long b)
{
long ans = 1;
while(b> 0)
{
if((b & 1)==1){
ans = (ans*a) % mod;
}
a = (a*a) % mod;
b = b>>1;
}
return ans;
}
public static void main(String[] args) {
InputReader in = new InputReader(System.in);
OutputWriter out = new OutputWriter(System.out);
int n = in.nextInt();
int[] arr = in.nextIntArray(n);
Stack<Integer> min = new Stack<>();
Stack<Integer> max = new Stack<>();
int[] dp = new int[n];
// Arrays.fill(dp,(int)1e9);
dp[0] = 0;
min.push(0);
max.push(0);
for(int i=1;i<n;i++)
{
int h=dp[i-1]+1;
while(!max.isEmpty() && arr[i]>arr[max.peek()])
{
int x = arr[max.peek()];
h = Math.min(h,1+dp[max.pop()]);
while(!max.isEmpty() && arr[max.peek()]==x)
{
max.pop();
}
}
if(!max.isEmpty())
{
h = Math.min(h,1+dp[max.peek()]);
}
while(!min.isEmpty() && arr[i]<arr[min.peek()])
{
int x = arr[min.peek()];
h = Math.min(h,1+dp[min.pop()]);
while(!min.isEmpty() && arr[min.peek()]==x)
{
min.pop();
}
}
if(!min.isEmpty())
{
h = Math.min(h,1+dp[min.peek()]);
}
dp[i] = h;
min.push(i);
max.push(i);
}
out.printLine(dp[n-1]);
out.flush();
out.close();
}
}
|
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;
public class D {
static Scanner sc = new Scanner(System.in);
static int[] height;
static int[] dp;
public static void main(String[] args) {
int n = sc.nextInt();
height = new int[n];
dp = new int[n];
dp[0] = 0;
for (int i = 0; i < n; i++) {
height[i] = sc.nextInt();
}
Stack<Integer> rise = new Stack<Integer>();
Stack<Integer> fail = new Stack<Integer>();
rise.push(0);
fail.push(0);
for (int i = 1; i < n; i++) {
dp[i] = dp[i-1]+1;
if (rise.isEmpty()) {
rise.push(i);
} else if (height[rise.peek()] < height[i]) {
rise.push(i);
} else {
while (!rise.isEmpty() && height[rise.peek()] > height[i]) {
rise.pop();
if (!rise.isEmpty()) {
dp[i] = Math.min(dp[i], dp[rise.peek()] + 1);
}
}
while (!rise.isEmpty() && height[rise.peek()] == height[i]) {
rise.pop();
}
rise.push(i);
}
if (fail.isEmpty()) {
fail.push(i);
} else if (height[fail.peek()] > height[i]) {
fail.push(i);
} else {
while (!fail.isEmpty() && height[fail.peek()] < height[i]) {
fail.pop();
if (!fail.isEmpty()){
dp[i] = Math.min(dp[i], dp[fail.peek()] + 1);
}
}
while (!fail.isEmpty() && height[fail.peek()] == height[i]) {
fail.pop();
}
fail.push(i);
}
}
System.out.println(dp[n - 1]);
}
}
// a[i]
//
//
// 6 7 6 2
//3 5 6 4 5 6 3
| 0 |
Non-plagiarised
|
1f257299
|
76b978c2
|
import java.lang.reflect.Array;
import java.util.*;
import java.io.*;
//import static com.sun.tools.javac.jvm.ByteCodes.swap;
public class fastTemp {
static FastScanner fs = null;
static int bit[][];
static int c1;
static int c2;
public static void main(String[] args) {
fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int t = fs.nextInt();
while (t-- > 0) {
int n = fs.nextInt();
int p[] = new int[n];
Arrays.fill(p,-1);
for(int i=0;i<n;i++){
if(p[i]!=-1){
continue;
}
System.out.println("? "+(i+1));
int ans = (i+1);
int x = fs.nextInt();
while(p[x-1]==-1){
System.out.println("? "+(i+1));
int last = fs.nextInt();
p[x-1] = last;
x = last;
}
}
System.out.print("! ");
for(int i=0;i<n;i++){
System.out.print(p[i]+" ");
}
System.out.flush();
}
}
public static boolean binary (int l,int h,long k ){
while(l<=h){
int m = (l+h)/2;
if(m*m==k){
return true;
}else if(m*m<k){
l = m+1;
}else{
h = m-1;
}
}
return false;
}
public static void solve1(int i,int c1){
for(int j=0;j < bit.length;j++){
if(j==c1){
bit[j][i] = 1;
}else{
bit[j][i] = 0;
}
}
}
public static void solve30(int i,int c2){
for(int j=0;j< bit.length;j++){
// if(j>=c2 || j>=bit.length-2){
// bit[j][i] = 1;
// }else{
bit[j][i] = 1;
// }
}}
public static void solve0(int i,int c2){
int val = bit.length/18;
for(int j=0;j< bit.length;j++){
if(j==c2 && j<bit.length-1){
bit[j][i] = 1;
bit[j+1][i] = 1;
j += 1;
}else{
bit[j][i] = 0;
}
}}
public static void union(int a,int b,int rank[],int [] p){
int x = get(a,rank,p);
int y = get(b,rank,p);
if(rank[x]==rank[y]){
rank[x]++;
}
if(rank[x]>rank[y]){
p[y] = x;
}else{
p[x] = y;
}
}
public static int get(int a,int [] rank,int []p){
return p[a] = (p[a]==a)? a : get(p[a],rank,p);
}
public static long[] sort(long arr[]) {
List<Long> list = new ArrayList<>();
for(long i:arr)
list.add(i);
Collections.sort(list);
for(int i = 0;i<list.size();i++) {
arr[i] = list.get(i);
}
return arr;
}
static class p {
int id;
int id1;
p(int id,int id1){
this.id=id;
this.id1=id1;
}
}
static long power(long x, long y, long p)
{
// Initialize result
long res = 1;
// Update x if it is more than or
// equal to p
x = x % p;
while (y > 0) {
// If y is odd, multiply x
// with result
if (y % 2 == 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
// Returns n^(-1) mod p
static long modInverse(long n, long p)
{
return power(n, p - 2, p);
}
// Returns nCr % p using Fermat's
// little theorem.
static long nCrModPFermat(long n, long r, long p)
{
if (n<r)
return 0;
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
long[] fac = new long[(int)n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % p;
return (fac[(int)n] * modInverse(fac[(int)r], p) % p * modInverse(fac[(int)n - (int)r], p) % p) % p;
}
//public static int dijkstra(int src , int dist[] ){
//
//PriorityQueue<Pair> q = new PriorityQueue<>();
//q.add(new Pair(1,0));
//
//while(q.size()>0){
//
// Pair rem = q.remove();
// for(Pair x:graph[rem.y]){
// if(dist[x.y]>dist[rem.y]+x.wt){
// dist[x.y] = dist[rem.y] + x.wt;
// q.add(new Pair(x.y,dist[x.y]));
// }
// }
//
//}
//
//return dist[dist.length-1];
//
//}
// T --> O(n) && S--> O(d)
public static int lower(long arr[], long key) {
int l = 0, r = arr.length-1;
long ans = -1;
while(l<=r) {
int mid = l +(r-l)/2;
if(arr[mid]<=key) {
ans = arr[mid];
l = mid+1;
}
else {
r = mid-1;
}
}
return l;
}
public static long upper(long arr[], long key) {
int l = 0, r = arr.length-1;
long ans = -1;
while(l<=r) {
int mid = l +(r-l)/2;
if(arr[mid] >= key) {
ans = arr[mid];
r = mid-1;
}
else {
l = mid+1;
}
}
return ans;
}
public static class String1 implements Comparable<String1>{
String str;
int id;
String1(String str , int id){
this.str = str;
this.id = id;
}
public int compareTo(String1 o){
int i=0;
while(i<str.length() && str.charAt(i)==o.str.charAt(i)){
i++;
}
if(i<str.length()){
if(i%2==1){
return o.str.compareTo(str); // descending order
}else{
return str.compareTo(o.str); // ascending order
}
}
return str.compareTo(o.str);
}
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
// ------------------------------------------swap----------------------------------------------------------------------
static void swap(int arr[],int i,int j)
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
//-------------------------------------------seiveOfEratosthenes----------------------------------------------------
static boolean prime[];
static void sieveOfEratosthenes(int n)
{
// Create a boolean array
// "prime[0..n]" and
// initialize all entries
// it as true. A value in
// prime[i] will finally be
// false if i is Not a
// prime, else true.
prime= new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++)
{
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true)
{
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
// for (int i = 2; i <= n; i++)
// {
// if (prime[i] == true)
// System.out.print(i + " ");
// }
}
//------------------------------------------- power------------------------------------------------------------------
public static long power(int a , int b) {
if (b == 0) {
return 1;
} else if (b == 1) {
return a;
} else {
long R = power(a, b / 2);
if (b % 2 != 0) {
return (((power(a, b / 2))) * a * ((power(a, b / 2))));
} else {
return ((power(a, b / 2))) * ((power(a, b / 2)));
}
}
}
public static int log2(int x) {
return (int) (Math.log(x) / Math.log(2));
}
//---------------------------------------EXTENDED EUCLID ALGO--------------------------------------------------------
// public static class Pair{
// int x;
// int y;
// public Pair(int x,int y){
// this.x = x;
// this.y = y ;
// }
// }
// public static Pair Euclid(int a,int b){
//
// if(b==0){
// return new Pair(1,0); // answer of x and y
// }
//
// Pair dash = Euclid(b,a%b);
//
// return new Pair(dash.y , dash.x - (a/b)*dash.y);
//
//
// }
//--------------------------------GCD------------------GCD-----------GCD--------------------------------------------
public static int gcd(int a,int b){
if(b==0){
return a;
}
return gcd(b,a%b);
}
public static void BFS(ArrayList<Integer>[] graph) {
}
// This is an extension of method 2. Instead of moving one by one, divide the array in different sets
//where number of sets is equal to GCD of n and d and move the elements within sets.
//If GCD is 1 as is for the above example array (n = 7 and d =2), then elements will be moved within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.
//Here is an example for n =12 and d = 3. GCD is 3 and
// void leftRotate(int arr[], int d, int n)
// {
// /* To handle if d >= n */
// d = d % n;
// int i, j, k, temp;
// int g_c_d = gcd(d, n);
// for (i = 0; i < g_c_d; i++) {
// /* move i-th values of blocks */
// temp = arr[i];
// j = i;
// while (true) {
// k = j + d;
// if (k >= n)
// k = k - n;
// if (k == i)
// break;
// arr[j] = arr[k];
// j = k;
// }
// arr[j] = temp;
// }
// }
}
// Fenwick / BinaryIndexed Tree USE IT - FenwickTree ft1=new FenwickTree(n);
|
import java.io.*;
import java.util.*;
public class check1 {
// public static void find(int n,int arr[])
// {
//
// }
// 2,1,3,4
public static void main(String[] args) throws IOException{
Reader sc=new Reader();
// PrintWriter out = new PrintWriter(System.out);
int t=sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
int p[]=new int[n];
System.out.println("? 1");
System.out.flush();
int t1 = sc.nextInt();
Set<Integer> hs = new HashSet<>();
int i=1;
int prev=1;
int cnt=1;
while(i<n && cnt<2*n)
{
if(p[prev-1]!=0)
{
i++;
if(i>=n || cnt>=2*n) break;
System.out.println("? "+i);
System.out.flush();
cnt++;
int t2 = sc.nextInt();
prev=t2;
continue;
}
String s1 = "? "+i;
System.out.println(s1);
System.out.flush();
int tt = sc.nextInt();
cnt++;
p[prev-1]=tt;
prev=tt;
}
long sum=0;
int ind=-1;
for(i=0;i<n;i++)
{
sum+=p[i];
if(p[i]==0) ind=i;
}
long diff = n*(n+1)-sum*2;
if(diff>0)
{
p[ind]=(int)(diff/2);
}
System.out.print("!");
for(i=0;i<n;i++)
{
System.out.print(" "+p[i]);
}
// out.println(Arrays.toString(p));
System.out.println();
System.out.flush();
}
System.out.flush();
}
public static long power(long x,long power)
{
if(power==0) return 1;
long ans1 = power(x,power/2);
ans1=ans1*ans1;
if(power%2==0) return ans1;
return x*ans1;
}
// (a*a_inverse) = 1(mod m)
// finding a_inverse
public static long modInverse(long a,long m)
{
// works only when m is prime
long g=gcd(a,m);
if(g==1) return power(a,m-2,m);
else return -1;
}
// (x^power)mod(m)
public static long power(long x,long power,long m)
{
if(power==0) return 1;
long p = power(x,power/2,m)%m;
p = (p*p)%m;
if(power%2==0) return p;
return (x*p)%m;
}
public static long gcd(long small,long large)
{
if(small==0) return large;
return gcd(large % small,small);
}
public static boolean isprime(long no)
{
if(no<=1) return false;
if(no<=3) return true;
if(no%2==0 || no%3==0) return false;
// 6k+1 6k+5 can be prime
for(long i=5;i*i<=no;i+=6)
{
if(no%(i)==0 || no%(i+2)==0)
return false;
}
return true;
}
// prime no smaller than or equal to n
public static boolean[] prime_nos_till_no(int no)
{
boolean prime[]=new boolean[no+1];
// prime[i]== true means prime
// prime[i]== false means not a prime
// initialize prime array as true
Arrays.fill(prime,true);
prime[0]=false;
for(int i=2;i*i<=no;i++)
{
if(prime[i]==true)
{
for(int j=i*i;j<=no;j+=i)
{
prime[j]=false;
}
}
}
return prime;
}
public static void shufflearray(long arr[])
{
int n=arr.length;
Random rand=new Random();
for(int i=0;i<n;i++)
{
long temp=arr[i];
int randomPos=i+rand.nextInt(n-i);
arr[i]=arr[randomPos];
arr[randomPos]=temp;
}
}
// Arrays.sort(arr, new Comparator<pair>() {
// //@Override
// public int compare(pair o1, pair o2) {
// long l1=o1.a-o2.a;
// if(l1<0L) return -1;
// if(l1==0) return 0;
// return 1;
// }
// });
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String nextLine() throws IOException {
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() throws IOException{
int c = read();
while (isSpaceChar(c)) c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null)
return;
din.close();
}
}
}
| 0 |
Non-plagiarised
|
3a12e509
|
c9159d9c
|
import java.io.*;
import java.util.*;
public class Practice
{
// static final long mod=7420738134811L;
static int mod=1000000007;
static final int size=501;
static FastReader sc=new FastReader(System.in);
// static Reader sc=new Reader();
static PrintWriter out=new PrintWriter(System.out);
static long[] factorialNumInverse;
static long[] naturalNumInverse;
static int[] sp;
static long[] fact;
static ArrayList<Integer> pr;
public static void main(String[] args) throws IOException
{
// System.setIn(new FileInputStream("input.txt"));
// System.setOut(new PrintStream("output.txt"));
// factorial(mod);
// InverseofNumber(mod);
// InverseofFactorial(mod);
// make_seive();
int t=1;
t=sc.nextInt();
while(t-->0)
solve();
out.close();
out.flush();
}
static void solve() throws IOException
{
int n=sc.nextInt();
int arr[]=new int[n];
for(int i=0;i<n;i++)
arr[i]=sc.nextInt();
String s=sc.next();
ArrayList<Integer> blue=new ArrayList<Integer>();
ArrayList<Integer> red=new ArrayList<Integer>();
for(int i=0;i<n;i++)
{
if(s.charAt(i)=='B')
blue.add(arr[i]);
else
red.add(arr[i]);
}
Collections.sort(blue);
Collections.sort(red);
for(int i=0;i<blue.size();i++)
{
if(blue.get(i)<i+1)
{
out.println("NO");
return;
}
}
for(int i=0;i<red.size();i++)
{
if(red.get(i)>i+1+blue.size())
{
out.println("NO");
return;
}
}
out.println("YES");
}
static class Pair implements Cloneable, Comparable<Pair>
{
int x,y;
Pair(int a,int b)
{
this.x=a;
this.y=b;
}
@Override
public boolean equals(Object obj)
{
if(obj instanceof Pair)
{
Pair p=(Pair)obj;
return p.x==this.x && p.y==this.y;
}
return false;
}
@Override
public int hashCode()
{
return Math.abs(x)+500*Math.abs(y);
}
@Override
public String toString()
{
return "("+x+" "+y+")";
}
@Override
protected Pair clone() throws CloneNotSupportedException {
return new Pair(this.x,this.y);
}
@Override
public int compareTo(Pair a)
{
int t= this.x-a.x;
if(t!=0)
return t;
else
return this.y-a.y;
}
public void swap()
{
this.y=this.y+this.x;
this.x=this.y-this.x;
this.y=this.y-this.x;
}
}
static class Tuple implements Cloneable, Comparable<Tuple>
{
int x,y,z;
Tuple(int a,int b,int c)
{
this.x=a;
this.y=b;
this.z=c;
}
public boolean equals(Object obj)
{
if(obj instanceof Tuple)
{
Tuple p=(Tuple)obj;
return p.x==this.x && p.y==this.y && p.z==this.z;
}
return false;
}
@Override
public int hashCode()
{
return (this.x+501*this.y);
}
@Override
public String toString()
{
return "("+x+","+y+","+z+")";
}
@Override
protected Tuple clone() throws CloneNotSupportedException {
return new Tuple(this.x,this.y,this.z);
}
@Override
public int compareTo(Tuple a)
{
int x=this.z-a.z;
if(x!=0)
return x;
int X= this.x-a.x;
if(X!=0)
return X;
return a.y-this.y;
}
}
static void arraySort(int arr[])
{
ArrayList<Integer> a=new ArrayList<Integer>();
for (int i = 0; i < arr.length; i++) {
a.add(arr[i]);
}
Collections.sort(a);
for (int i = 0; i < arr.length; i++) {
arr[i]=a.get(i);
}
}
static void arraySort(long arr[])
{
ArrayList<Long> a=new ArrayList<Long>();
for (int i = 0; i < arr.length; i++) {
a.add(arr[i]);
}
Collections.sort(a);
for (int i = 0; i < arr.length; i++) {
arr[i]=a.get(i);
}
}
static HashSet<Integer> primeFactors(int n)
{
HashSet<Integer> ans=new HashSet<Integer>();
if(n%2==0)
{
ans.add(2);
while((n&1)==0)
n=n>>1;
}
for(int i=3;i*i<=n;i+=2)
{
if(n%i==0)
{
ans.add(i);
while(n%i==0)
n=n/i;
}
}
if(n!=1)
ans.add(n);
return ans;
}
static void make_seive()
{
sp=new int[size];
pr=new ArrayList<Integer>();
for (int i=2; i<size; ++i) {
if (sp[i] == 0) {
sp[i] = i;
pr.add(i);
}
for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
sp[i * pr.get(j)] = pr.get(j);
}
}
public static void InverseofNumber(int p)
{
naturalNumInverse=new long[size];
naturalNumInverse[0] = naturalNumInverse[1] = 1;
for(int i = 2; i < size; i++)
naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
}
// Function to precompute inverse of factorials
public static void InverseofFactorial(int p)
{
factorialNumInverse=new long[size];
factorialNumInverse[0] = factorialNumInverse[1] = 1;
// pre-compute inverse of natural numbers
for(int i = 2; i < size; i++)
factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
// Function to calculate factorial of 1 to 200001
public static void factorial(int p)
{
fact=new long[size];
fact[0] = 1;
for(int i = 1; i < size; i++)
fact[i] = (fact[i - 1] * (long)i) % p;
}
// Function to return nCr % p in O(1) time
public static long Binomial(int N, int R)
{
if(R<0)
return 1;
// n C r = n!*inverse(r!)*inverse((n-r)!)
long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
return ans;
}
static int findXOR(int x) //from 0 to x
{
if(x<0)
return 0;
if(x%4==0)
return x;
if(x%4==1)
return 1;
if(x%4==2)
return x+1;
return 0;
}
static boolean isPrime(long x)
{
if(x==1)
return false;
if(x<=3)
return true;
if(x%2==0 || x%3==0)
return false;
for(int i=5;i<=Math.sqrt(x);i+=2)
if(x%i==0)
return false;
return true;
}
static long gcd(long a,long b)
{
return (b==0)?a:gcd(b,a%b);
}
static int gcd(int a,int b)
{
return (b==0)?a:gcd(b,a%b);
}
static class Node
{
int vertex;
HashSet<Edge> adj;
int taxC,taxD;
Node(int ver)
{
vertex=ver;
taxD=0;
taxC=0;
adj=new HashSet<Edge>();
}
@Override
public String toString()
{
return vertex+" ";
}
}
static class Edge
{
Node to;
int cost;
Edge(Node t,int c)
{
this.to=t;
this.cost=c;
}
@Override
public String toString() {
return "("+to.vertex+","+cost+") ";
}
}
static long power(long x, long y)
{
if(x<=0)
return 1;
long res = 1;
x = x % mod;
if (x == 0)
return 0;
while (y > 0)
{
if ((y & 1) != 0)
res = (res * x) % mod;
y = y >> 1; // y = y/2
x = (x * x) % mod;
}
return res;
}
static long binomialCoeff(long n, long k)
{
if(n<k)
return 0;
long res = 1;
// if(k>n)
// return 0;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of
// [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
static class FastReader
{
byte[] buf = new byte[2048];
int index, total;
InputStream in;
FastReader(InputStream is)
{
in = is;
}
int scan() throws IOException
{
if (index >= total) {
index = 0;
total = in.read(buf);
if (total <= 0) {
return -1;
}
}
return buf[index++];
}
String next() throws IOException
{
int c;
for (c = scan(); c <= 32; c = scan());
StringBuilder sb = new StringBuilder();
for (; c > 32; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
int nextInt() throws IOException
{
int c, val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
long nextLong() throws IOException
{
int c;
long val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
}
static class Reader
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException
{
din = new DataInputStream(
new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
if (cnt != 0) {
break;
}
else {
continue;
}
}
buf[cnt++] = (byte)c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
public void printarray(int arr[])
{
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i]+" ");
System.out.println();
}
}
}
|
import java.util.*;
public class SolutionB {
public static long gcd(long a, long b){
if(b==0){
return a;
}
return gcd(b, a%b);
}
public static long gcdSum(long b){
long a = 0;
long temp = b;
while(temp!=0){
a = a + temp%10;
temp = temp/10;
}
return gcd(a,b);
}
public static class Pair{
Long a;
Long b;
public Pair(Long a, Long b) {
this.a = a;
this.b = b;
}
}
public static long factorial (long n){
if(n==0)
return 1;
else if(n==1)
return n;
return n * factorial(n-1);
}
public static long lcm (long n){
if(n<3)
return n;
return lcmForBig(n,n-1);
}
private static long lcmForBig(long n, long l) {
if(l==1)
return n;
n = (n * l) / gcd(n, l);
return lcmForBig(n, l-1);
}
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int t = s.nextInt();
for(int i =0;i<t;i++) {
int n = s.nextInt();
int arr [] = new int[n];
ArrayList<Integer> blue = new ArrayList<>();
ArrayList<Integer> red = new ArrayList<>();
for(int j=0;j<n;j++){
int num = s.nextInt();
arr[j]=num;
}
String color = s.next();
for(int j=0;j<n;j++){
if(color.charAt(j)=='B'){
blue.add(arr[j]);
}
else{
red.add(arr[j]);
}
}
Collections.sort(blue);
String ans = "YES";
int counter = 0;
for(int j=0;j<blue.size();j++){
int current = blue.get(j);
if (current<1){
ans="NO";
break;
}
if(current>counter){
counter++;
}
else{
ans="NO";
break;
}
}
if(ans=="NO"){
System.out.println(ans);
}
else{
int tempCounter = n+1;
Collections.sort(red);
for(int j=red.size()-1;j>=0;j--){
int current = red.get(j);
if(current>=tempCounter){
ans="NO";
break;
}
else{
tempCounter--;
}
}
if(tempCounter-counter!=1)
System.out.println("NO");
else
System.out.println(ans);
}
}
return;
}
}
| 0 |
Non-plagiarised
|
29cb9b0e
|
c77654b8
|
import java.util.*;
public class Main
{
public static void solve (int ar[],int n)
{
if(n%2==1)
{
int c=ar[2];
int b=ar[1];
int a=ar[0];
if(a+b!=0)
{
ar[2]=-(a+b);
ar[1]=c;
ar[0]=c;
}
else if(b+c!=0)
{
ar[2]=a;
ar[1]=a;
ar[0]=-(b+c);
}
else
{
ar[2]=b;
ar[1]=-(a+c);
ar[0]=b;
}
System.out.print(ar[0]+" "+ar[1]+" "+ar[2]+" ");
for(int i=3;i<(n);i=i+2)
{
System.out.print((-ar[i+1])+" "+ar[i]+" ");
}
System.out.println();
}
// System.out.println(ans[n-1]+ " x"+ans[n-2]+" x"+ans[n-3]);
else
{
for(int i=0;i<(n);i=i+2)
{
System.out.print((-ar[i+1])+" "+ar[i]+" ");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
int ar[]=new int[n];
for(int i=0;i<n;i++)
ar[i]=sc.nextInt();
solve(ar,n);
}
}
}
|
import java.io.PrintWriter;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int tc = sc.nextInt();
while(tc-->0){
int n = sc.nextInt();
int[] arr = new int[n]; for(int i = 0; i<n; i++)arr[i] = sc.nextInt();
if(n % 2 == 0){
for(int i = 0; i<n; i+=2){
pw.print((-arr[i + 1]) + " " + arr[i] + " ");
}
pw.println();
}else{
if(arr[0] + arr[1] != 0) pw.print(arr[2] + " " + arr[2] + " " + (-(arr[0] + arr[1])) + " ");
else if(arr[0] + arr[2] != 0)pw.println(arr[1] + " " + (-(arr[0] + arr[2]))+" " + arr[1]);
else pw.println(-(arr[1] + arr[2]) + " " + arr[0]+" " + arr[0]);
for(int i = 3; i<n; i+=2){
pw.print((-arr[i + 1]) + " " + arr[i] + " ");
}
pw.println();
}
}
pw.flush();
}
}
| 0 |
Non-plagiarised
|
24afd00e
|
810fd282
|
/*
JAI MATA DI
*/
import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
public class CP {
static class FR{
BufferedReader br;
StringTokenizer st;
public FR() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
static int mod = 1000000007;
static int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static long gcd(long a, long b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static boolean[] prime(int num) {
boolean[] bool = new boolean[num];
for (int i = 0; i< bool.length; i++) {
bool[i] = true;
}
for (int i = 2; i< Math.sqrt(num); i++) {
if(bool[i] == true) {
for(int j = (i*i); j<num; j = j+i) {
bool[j] = false;
}
}
}
if(num >= 0) {
bool[0] = false;
bool[1] = false;
}
return bool;
}
/* ***************************************************************************************************************************************************/
static FR sc = new FR();
static StringBuilder sb = new StringBuilder();
public static void main(String args[]) {
int tc = sc.nextInt();
while(tc-- > 0) {
TEST_CASE();
}
System.out.println(sb);
}
static void TEST_CASE() {
int n = sc.nextInt();
lr = new long[n][2];
for(int i =0 ; i < n ; i ++) {
lr[i][0] = sc.nextLong();
lr[i][1] = sc.nextLong();
}
adj = new ArrayList<ArrayList<Integer>>();
for(int i = 0 ; i <n ; i++) adj.add(new ArrayList<Integer>());
for(int i = 0 ; i<n-1 ; i++) {
int u = sc.nextInt()-1 , v = sc.nextInt()-1;
adj.get(u).add(v);
adj.get(v).add(u);
}
min = new long[n];
max = new long[n];
dfs(0,-1);
sb.append(Math.max(min[0], max[0])).append("\n");
}
static long[] min , max , lr[];
static ArrayList<ArrayList<Integer>> adj;
static void dfs(int u , int p ) {
for(int child:adj.get(u)) {
if(child == p) continue;
dfs(child , u);
}
long left = lr[u][0] , right = lr[u][1];
long ansl = 0 , ansr = 0;
for(int child:adj.get(u)) {
if(child == p) continue;
long leftc = lr[child][0] , rightc = lr[child][1];
ansl += Math.max( min[child] + Math.abs(left - leftc) ,
max[child] +Math.abs(left - rightc) );
}
for(int child:adj.get(u)) {
if(child == p) continue;
long leftc = lr[child][0] , rightc = lr[child][1];
ansr += Math.max( min[child] + Math.abs(right - leftc) ,
max[child] +Math.abs(right - rightc) );
}
min[u] = ansl;
max[u] = ansr;
}
}
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Main
{
static int N=(int)2e5+10;
static long[][] dp=new long[2][N];
static int[][] A=new int[2][N];
static ArrayList<ArrayList<Integer>> adj=new ArrayList<>(N);
static
{
for(int i=0;i<N;i++)
adj.add(new ArrayList<>());
}
public static void dfs(int v,int p)
{
dp[0][v]=dp[1][v]=0;
for(Integer u:adj.get(v))
{
if(u==p)
continue;
dfs(u, v);
dp[0][v]+=Math.max(Math.abs(A[0][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[0][v]-A[0][u]));
dp[1][v]+=Math.max(Math.abs(A[1][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[1][v]-A[0][u]));
}
}
public static void main(String[] args) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine());
while(t-->0)
{
int n=Integer.parseInt(br.readLine());
for(int i=1;i<=n;i++)
{
String[] ss1=br.readLine().split(" ");
A[0][i]=Integer.parseInt(ss1[0]);
A[1][i]=Integer.parseInt(ss1[1]);
adj.set(i, new ArrayList<>());
}
for(int i=1;i<n;i++)
{
String[] ss2=br.readLine().split(" ");
int u=Integer.parseInt(ss2[0]);
int v=Integer.parseInt(ss2[1]);
adj.get(u).add(v);
adj.get(v).add(u);
}
dfs(1, -1);
System.out.println(Math.max(dp[0][1], dp[1][1]));
}
}
}
| 0 |
Non-plagiarised
|
63bfa731
|
7974ffba
|
import java.util.*;
import java.io.*;
public class D {
static ArrayList<Integer> adj[] = new ArrayList[(int)1e5+7];
static int diameter = 0;
static int[] depth = new int[(int)1e5 + 7];
public static void main(String[] args) {
FastReader in = new FastReader();
int t = in.nextInt();
while(t-- > 0){
int n = in.nextInt();
int a = in.nextInt(), b = in.nextInt(), da = in.nextInt(), db = in.nextInt();
for(int i = 1; i <= n; i++){
adj[i] = new ArrayList<>();
}
for(int i = 1; i <=n; i++){
adj[i].clear();
}
for(int i = 0; i < n- 1; i++){
int u = in.nextInt();
int v = in.nextInt();
adj[u].add(v);
adj[v].add(u);
}
diameter = 0;
depth[a] = 0;
dfs(a, -1);
System.out.println(2 * da >= Math.min(diameter, db) || depth[b] <= da ? "Alice" : "Bob");
}
}
static int dfs(int node, int parent){
int len = 0;
for(int x : adj[node]){
if(x != parent){
depth[x] = depth[node] + 1;
int cur = 1 + dfs(x, node);
diameter = Math.max(diameter, cur + len);
len = Math.max(len, cur);
// System.out.print("x " + x + " node " + node + " par " + parent);
// System.out.println(" cur " + cur + " len " + len + " diam " + diameter);
}
}
return len;
}
static long getDigitSum(long n)
{
long sum = 0;
while (n > 0)
{
sum = sum + n % 10;
n = n/10;
}
return sum;
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
int[] readArray(int n){
int[] a = new int[n];
for(int i = 0; i < n; i++){
a[i] = nextInt();
}
return a;
}
}
}
|
import java.util.*;
import java.io.*;
import java.math.*;
public class Euler {
static int N = (int)1e5 + 5;
static int n, a, b, da, db;
static int[] depth = new int[N];
static ArrayList<Integer>[] adj = new ArrayList[N];
static int diam;
public static int dfs(int x, int p) {
int len = 0;
for (int y : adj[x]) {
if (y != p) {
depth[y] = depth[x] + 1;
int cur = 1 + dfs(y, x);
diam = Math.max(diam, cur + len);
len = Math.max(len, cur);
}
}
return len;
}
public static void main(String[] args){
FastReader in = new FastReader();
PrintWriter o = new PrintWriter(System.out);
int t = in.nextInt();
while(t-- > 0) {
n = in.nextInt();
a = in.nextInt();
b = in.nextInt();
da = in.nextInt();
db = in.nextInt();
for (int i = 1; i <= n; i++) {
adj[i] = new ArrayList<>();
}
for (int i = 0; i < n - 1; i++) {
int u = in.nextInt();
int v = in.nextInt();
adj[u].add(v);
adj[v].add(u);
}
diam = 0;
depth[a] = 0;
dfs(a, -1);
boolean works = true;
if (depth[b] <= da) {
o.println("Alice");
continue;
}
if (2 * da >= diam) {
o.println("Alice");
continue;
}
if (db > 2 * da) {
o.println("Bob");
continue;
}
if (db <= 2 * da) {
o.println("Alice");
}
}
o.close();
o.flush();
return;
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| 1 |
Plagiarised
|
953ac418
|
ba9b94f7
|
import java.io.*;
import java.lang.*;
import java.util.*;
public class E1578 {
public static void main(String[] args) throws IOException{
StringBuffer ans = new StringBuffer();
StringTokenizer st;
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer(f.readLine());
int q = Integer.parseInt(st.nextToken());
for(; q > 0; q--){
st = new StringTokenizer(f.readLine());
st = new StringTokenizer(f.readLine());
int n = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
int[] a = new int[k];
st = new StringTokenizer(f.readLine());
for(int i = 0; i < k; i++){
a[i] = Integer.parseInt(st.nextToken()) - 1;
}
int[] arr = new int[n];
int[] b = new int[k];
st = new StringTokenizer(f.readLine());
Arrays.fill(arr, Integer.MAX_VALUE-1);
for(int i = 0; i < k; i++){
b[i] = Integer.parseInt(st.nextToken());
arr[a[i]] = b[i];
}
int[] l = new int[n];
int[] r = new int[n];
for(int i = 0; i < n; i++){
if(i == 0)
l[i] = arr[i];
else
l[i] = Math.min(l[i-1]+1, arr[i]);
}
for(int i = n-1; i > -1; i--){
if(i == n-1)
r[i] = arr[i];
else
r[i] = Math.min(r[i+1]+1, arr[i]);
}
for(int i = 0; i < n; i++)
ans.append(Math.min(l[i], r[i])).append(" ");
ans.append("\n");
}
f.close();
System.out.println(ans);
}
public static class point implements Comparable<point>{
int x;
int y;
public point(int x,int y){
this.x = x;
this.y = y;
}
public String toString(){
return(x + " " + y);
}
public boolean equals(Object x){
point y = ((point)(x));
if (this.x == y.x && this.y == y.y){
return true;
}
return false;
}
public int hashCode(){
return Objects.hash(x,y);
}
public int compareTo(point other){
if(this.x > other.x || (this.x == other.x && this.y > other.y)){
return 1;
}else if(this.x == other.x && other.y == this.y){
return 0;
}
return -1;
}
}
}
|
import java.util.*;
import java.io.*;
public class _1547_E {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int t = Integer.parseInt(in.readLine());
while(t-- > 0) {
in.readLine();
StringTokenizer line1 = new StringTokenizer(in.readLine());
int n = Integer.parseInt(line1.nextToken());
int k = Integer.parseInt(line1.nextToken());
int[] x = new int[n];
line1 = new StringTokenizer(in.readLine());
StringTokenizer line2 = new StringTokenizer(in.readLine());
TreeSet<AC> after = new TreeSet<AC>();
for(int i = 0; i < k; i++) {
int ai = Integer.parseInt(line1.nextToken()) - 1;
int ti = Integer.parseInt(line2.nextToken());
x[ai] = ti;
after.add(new AC(ti, ai));
}
TreeSet<AC> before = new TreeSet<AC>();
int[] res = new int[n];
for(int i = 0; i < n; i++) {
if(x[i] > 0) {
after.remove(new AC(x[i], i));
before.add(new AC(x[i], n - i));
}
AC be = before.size() == 0 ? null : before.first();
AC af = after.size() == 0 ? null : after.first();
if(be == null) {
res[i] = af.d + af.t - i;
}else if(af == null) {
res[i] = be.d + be.t - (n - i);
}else {
res[i] = Math.min(af.d + af.t - i, be.d + be.t - (n - i));
}
}
StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; i++) {
sb.append(res[i]);
sb.append(' ');
}
out.println(sb.toString());
}
in.close();
out.close();
}
static class AC implements Comparable<AC> {
int t, d;
AC(int tt, int dd) {
t = tt;
d = dd;
}
@Override
public int compareTo(AC o) {
if(t + d == o.t + o.d) {
return d - o.d;
}
return t + d - (o.t + o.d);
}
}
}
| 0 |
Non-plagiarised
|
9862c742
|
d9199dfd
|
/******************************************************************************
Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.
*******************************************************************************/
import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-- > 0){
int n = s.nextInt();
int[] arr = new int[n];
for(int i=0;i<n;i++)
arr[i] = s.nextInt();
String str = s.next();
List<Integer> left = new ArrayList<>();
List<Integer> right = new ArrayList<>();
for(int i=0;i<arr.length;i++){
if(str.charAt(i) == 'B')
left.add(arr[i]);
else right.add(arr[i]);
}
Collections.sort(left);
Collections.sort(right);
boolean flag = false;
for(int i=0;i<left.size();i++)
if(left.get(i) < i+1){
flag = true;
break;
}
if(!flag){
for(int i=0;i<right.size();i++)
if(right.get(i) > left.size()+i+1){
flag = true;
break;
}
}
if(flag)
System.out.println("NO");
else System.out.println("YES");
}
}
}
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;
public class Simple{
public static void main(String args[]){
//System.out.println("Hello Java");
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while (t>0){
int n = s.nextInt();
int arr[] = new int[n];
for(int i=0;i<n;i++){
arr[i] = s.nextInt();
}
String str = s.next();
//Arrays.sort(arr);
ArrayList<Integer> blue = new ArrayList<>();
ArrayList<Integer> red = new ArrayList<>();
for(int i=0;i<n;i++){
if(str.charAt(i)=='R'){
red.add(arr[i]);
}
else{
blue.add(arr[i]);
}
}
Collections.sort(red);
Collections.sort(blue);
int start =1;
boolean bool =true;
for(int i=0;i<blue.size();i++){
if(blue.get(i)<start){
bool = false;
break;
}
start++;
}
if(!bool){
System.out.println("NO");
}
else{
for(int i=0;i<red.size();i++){
if(red.get(i)>start){
bool = false;
break;
}
start++;
}
if(bool){
System.out.println("YES");
}
else{
System.out.println("NO");
}
}
t--;
}
s.close();
}
}
| 0 |
Non-plagiarised
|
646b3abc
|
8261bd1c
|
import java.util.*;
import java.io.*;
public class Main {
static FastScanner sc = new FastScanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static StringBuilder sb = new StringBuilder();
static long mod = (long) 1e9 + 7;
public static void main(String[] args) throws Exception {
int n = sc.nextInt();
for(int i = 0; i < n; i++) solve();
pw.flush();
}
public static void solve() {
int n = sc.nextInt();
char[] a = sc.next().toCharArray();
char[] b = sc.next().toCharArray();
boolean isFirst = false;
boolean allOk = true;
int a1 = 0;
int a0 = 0;
int b1 = 0;
int b0 = 0;
int[][] cnt1 = new int[2][2];
for(int i = 0; i < n; i++){
if(a[i] != b[i]){
allOk = false;
}
if(a[i] == '1'){
a1++;
isFirst = true;
}else{
a0++;
}
if(b[i] == '1'){
b1++;
}else{
b0++;
}
cnt1[a[i]-'0'][b[i]-'0']++;
}
if(allOk){
pw.println(0);
return;
}else if(!isFirst){
pw.println(-1);
return;
}else if(a1 != b1 && (a0+1) != b1){
pw.println(-1);
return;
}else{
int same = cnt1[1][1] - cnt1[0][0] == 1 ? cnt1[1][1] + cnt1[0][0] : Integer.MAX_VALUE;
int odd = cnt1[1][0] - cnt1[0][1] == 0 ? cnt1[1][0] + cnt1[0][1] : Integer.MAX_VALUE;
int min = Math.min(same,odd);
pw.println(min == Integer.MAX_VALUE ? -1 : min);
}
}
static class GeekInteger {
public static void save_sort(int[] array) {
shuffle(array);
Arrays.sort(array);
}
public static int[] shuffle(int[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
int randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
public static void save_sort(long[] array) {
shuffle(array);
Arrays.sort(array);
}
public static long[] shuffle(long[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
long randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
}
}
class FastScanner {
private BufferedReader reader = null;
private StringTokenizer tokenizer = null;
public FastScanner(InputStream in) {
reader = new BufferedReader(new InputStreamReader(in));
tokenizer = null;
}
public FastScanner(FileReader in) {
reader = new BufferedReader(in);
tokenizer = null;
}
public String next() {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
return reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken("\n");
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String[] nextArray(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++)
a[i] = next();
return a;
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
}
|
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class Cgr18A {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader sc = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Solver solver = new Solver();
int t = sc.nextInt();
// int t = 1;
while (t-- != 0) {
solver.solve(sc, out);
}
out.close();
}
static class Solver {
final int INF = (int) 1e9;
public void solve(InputReader sc, PrintWriter out) {
int n = sc.nextInt();
char[] a = sc.next().toCharArray();
char[] b = sc.next().toCharArray();
boolean isAllZeroA = isAllZero(a);
boolean isAllZeroB = isAllZero(b);
if(isAllZeroA && isAllZeroB) {
out.println(0);
return;
}
if(isAllZeroA || isAllZeroB) {
out.println(-1);
return;
}
int eq = 0;
for(int i = 0; i< n;i++) if(a[i]==b[i]) eq++;
int eqHasOne = 0;
int notEqHasOne = 0;
int noteq = n-eq;
for (int i = 0; i < n; i++) {
if(a[i]==b[i] && a[i]=='1') eqHasOne++;
if(a[i]!=b[i] && a[i]=='1') notEqHasOne++;
}
int l = solveIt(new int[] {eq,noteq},new int[] {eqHasOne,notEqHasOne},0);
int r = solveIt(new int[] {eq,noteq},new int[] {eqHasOne,notEqHasOne},1);
if(l==INF && r==INF) {
out.println(-1);
} else {
out.println(Math.min(l,r));
}
}
private boolean isAllZero(char[] a) {
for(char c : a) if(c=='1') return false;
return true;
}
private int solveIt(int[] arr,int[] hasOne, int minusPointer) {
if(arr[0]==0 && arr[1]==0) throw new RuntimeException();
int cnt = 0;
int max = arr[0] + arr[1];
while(arr[1]!=0) {
int minus = minusPointer;
int plus = 1-minus;
if(hasOne[minusPointer]<1) return INF;
int eqHasOne = hasOne[0];
int notEqHasOne = hasOne[1];
int eqHasZero = arr[0] - eqHasOne;
int notEqHasZero = arr[1] - notEqHasOne;
if(minusPointer==0) {
int newNotEqHasOne = eqHasZero;
int newEqHasOne = notEqHasZero + 1;
hasOne[0] = newEqHasOne;
hasOne[1] = newNotEqHasOne;
} else {
int newEqHasOne = notEqHasZero;
int newNotEqHasOne = eqHasZero + 1;
hasOne[0] = newEqHasOne;
hasOne[1] = newNotEqHasOne;
}
int minusValue = arr[minus]-1;
int plusValue = arr[plus]+1;
arr[minus] = plusValue;
arr[plus] = minusValue;
minusPointer = 1-minusPointer;
cnt++;
if(cnt>max+10) break;
}
if(arr[1]!=0) return INF;
return cnt;
}
}
static void sort(int[] arr) {
ArrayList<Integer> al = new ArrayList();
for (int i : arr) al.add(i);
Collections.sort(al);
int idx = 0;
for (int i : al) arr[idx++] = i;
}
static void sort(long[] arr) {
ArrayList<Long> al = new ArrayList();
for (long i : arr) al.add(i);
Collections.sort(al);
int idx = 0;
for (long i : al) arr[idx++] = i;
}
static void sortDec(int[] arr) {
ArrayList<Integer> al = new ArrayList();
for (int i : arr) al.add(i);
Collections.sort(al, Collections.reverseOrder());
int idx = 0;
for (int i : al) arr[idx++] = i;
}
static void sortDec(long[] arr) {
ArrayList<Long> al = new ArrayList();
for (long i : arr) al.add(i);
Collections.sort(al, Collections.reverseOrder());
int idx = 0;
for (long i : al) arr[idx++] = i;
}
static class InputReader {
private boolean finished = false;
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int peek() {
if (numChars == -1) {
return -1;
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
return -1;
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private String readLine0() {
StringBuilder buf = new StringBuilder();
int c = read();
while (c != '\n' && c != -1) {
if (c != '\r') {
buf.appendCodePoint(c);
}
c = read();
}
return buf.toString();
}
public String readLine() {
String s = readLine0();
while (s.trim().length() == 0) {
s = readLine0();
}
return s;
}
public String readLine(boolean ignoreEmptyLines) {
if (ignoreEmptyLines) {
return readLine();
} else {
return readLine0();
}
}
public BigInteger readBigInteger() {
try {
return new BigInteger(nextString());
} catch (NumberFormatException e) {
throw new InputMismatchException();
}
}
public char nextCharacter() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
return (char) c;
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1) {
read();
}
return value == -1;
}
public String next() {
return nextString();
}
public SpaceCharFilter getFilter() {
return filter;
}
public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; ++i) array[i] = nextInt();
return array;
}
public int[] nextSortedIntArray(int n) {
int array[] = nextIntArray(n);
Arrays.sort(array);
return array;
}
public int[] nextSumIntArray(int n) {
int[] array = new int[n];
array[0] = nextInt();
for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
return array;
}
public long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; ++i) array[i] = nextLong();
return array;
}
public long[] nextSumLongArray(int n) {
long[] array = new long[n];
array[0] = nextInt();
for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
return array;
}
public long[] nextSortedLongArray(int n) {
long array[] = nextLongArray(n);
Arrays.sort(array);
return array;
}
}
}
| 0 |
Non-plagiarised
|
83b44c9c
|
8d9871a9
|
import java.util.Scanner;
public class MinimumGridPath {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int test = scanner.nextInt();
StringBuilder sb = new StringBuilder();
for (int t = 0; t < test; t++) {
int n = scanner.nextInt();
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextLong();
}
long minx = arr[0];
long miny = arr[1];
long min = minx * n + miny * n;
long sumx = arr[0];
long sumy = arr[1];
for(int i=2; i<n; i++) {
int xc;
int yc;
if(i%2 == 0) {
xc = i/2 + 1;
yc = i/2;
sumx += arr[i];
minx = Math.min(minx, arr[i]);
} else {
xc = i/2 + 1;
yc = i/2 + 1;
sumy += arr[i];
miny = Math.min(miny, arr[i]);
}
min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
}
sb.append(min).append(System.lineSeparator());
}
System.out.println(sb);
}
}
/*
// yehara
import java.io.PrintWriter;
import java.util.*;
public class C {
static Scanner sc;
static PrintWriter out;
public static void main(String[] args) throws Exception {
sc = new Scanner(System.in);
out = new PrintWriter(System.out);
int t = sc.nextInt();
for(int i=0; i<t; i++) {
solve();
}
out.flush();
}
static void solve() {
int n = sc.nextInt();
int[] c = new int[n];
for(int i=0; i<n; i++) {
c[i] = Integer.parseInt(sc.next());
}
long minx = c[0];
long miny = c[1];
long min = minx * n + miny * n;
long sumx = c[0];
long sumy = c[1];
for(int i=2; i<n; i++) {
int xc;
int yc;
if(i%2 == 0) {
xc = i/2 + 1;
yc = i/2;
sumx += c[i];
minx = Math.min(minx, c[i]);
} else {
xc = i/2 + 1;
yc = i/2 + 1;
sumy += c[i];
miny = Math.min(miny, c[i]);
}
min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
}
out.println(min);
}
}
*/
|
import java.util.*;
public class Main {
static Scanner scan = new Scanner(System.in);
static int[] readArray(int[] x) {
for(int i=0; i<x.length; ++i) x[i] = scan.nextInt();
return x;
}
static long[] readArray(long[] x) {
for(int i=0; i<x.length; ++i) x[i] = scan.nextLong();
return x;
}
public static void go() {
}
public static void main(String[] args) {
int t = scan.nextInt();
for(int it=0; it<t; ++it) {
int n = scan.nextInt();
long[] aa = readArray(new long[n]);
long minEven = aa[0];
long minOdd = aa[1];
long sum = aa[0]+aa[1];
long best = n*minEven + n*minOdd;
int numOdd = 1;
int numEven = 1;
for(int i=2; i<n; ++i) {
if(i%2 == 0) {
minEven = Math.min(aa[i], minEven);
numEven++;
}else {
minOdd = Math.min(aa[i], minOdd);
numOdd++;
}
sum += aa[i];
long score = sum;
score += minEven*(n-numEven);
score += minOdd*(n-numOdd);
best = Math.min(best, score);
}
System.out.println(best);
}
}
}
| 0 |
Non-plagiarised
|
3412b353
|
528a6162
|
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 t=Integer.parseInt(bu.readLine());
while(t-->0)
{
int n=Integer.parseInt(bu.readLine());
int k[]=new int[n+1],h[]=new int[n+1],i;
String s[]=bu.readLine().split(" ");
for(i=1;i<=n;i++) k[i]=Integer.parseInt(s[i-1]);
s=bu.readLine().split(" ");
for(i=1;i<=n;i++) h[i]=Integer.parseInt(s[i-1]);
long max[]=new long[n+1];
for(i=1;i<=n;i++)
{
int j;
long here=h[i];
for(j=i-1;j>=0;j--)
{
long diff=here-(k[i]-k[j]);
if(diff<=0) {max[i]=max[j]+here*(here+1)/2; break;}
if(diff<h[j]) here+=h[j]-diff;
}
}
sb.append(max[n]+"\n");
}
System.out.print(sb);
}
}
|
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 t=Integer.parseInt(bu.readLine());
while(t-->0)
{
int n=Integer.parseInt(bu.readLine());
int k[]=new int[n+1],h[]=new int[n+1],i;
String s[]=bu.readLine().split(" ");
for(i=1;i<=n;i++) k[i]=Integer.parseInt(s[i-1]);
s=bu.readLine().split(" ");
for(i=1;i<=n;i++) h[i]=Integer.parseInt(s[i-1]);
long max[]=new long[n+1];
for(i=1;i<=n;i++)
{
int j;
long here=h[i];
for(j=i-1;j>=0;j--)
{
long diff=here-(k[i]-k[j]);
if(diff<=0) {max[i]=max[j]+here*(here+1)/2; break;}
if(diff<h[j]) here+=h[j]-diff;
}
}
sb.append(max[n]+"\n");
}
System.out.print(sb);
}
}
| 1 |
Plagiarised
|
0d11fb94
|
f9e08a46
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static int i, j, k, n, m, t, y, x, sum = 0;
static long mod = 1000000007;
static FastScanner fs = new FastScanner();
static PrintWriter out = new PrintWriter(System.out);
static String str;
static long ans;
static List<Integer> zeros = new ArrayList<>();
static List<Integer> ones = new ArrayList<>();
static int oneCount = 0;
static int[][] dp = new int[5005][5005];
public static void main(String[] args) {
t = 1;
while (t-- > 0) {
n = fs.nextInt();
for(int i = 0;i<n;i++){
x = fs.nextInt();
if(x==1){
ones.add(i);
oneCount++;
}
else
zeros.add(i);
}
for(int i=0;i<n;i++){
for(int j = 0; j<n;j++){
dp[i][j]=-1;
}
}
out.println(minCost(0,0));
}
out.close();
}
static int minCost(int zIndex, int oIndex){
if(oIndex == ones.size())
return 0;
if(zIndex == zeros.size())
return 1000000007;
if(dp[zIndex][oIndex]==-1)
dp[zIndex][oIndex]= Math.min(Math.abs(zeros.get(zIndex) - ones.get(oIndex))+minCost(zIndex+1, oIndex+1) , minCost(zIndex+1, oIndex));
return dp[zIndex][oIndex];
}
static int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static void ruffleSort(int[] a) {
//ruffle
int n = a.length;
Random r = new Random();
for (int i = 0; i < a.length; i++) {
int oi = r.nextInt(n), temp = a[i];
a[i] = a[oi];
a[oi] = temp;
}
//then sort
Arrays.sort(a);
}
static void ruffleSort(long[] a) {
//ruffle
int n = a.length;
Random r = new Random();
for (int i = 0; i < a.length; i++) {
int oi = r.nextInt(n);
long temp = a[i];
a[i] = a[oi];
a[oi] = temp;
}
//then sort
Arrays.sort(a);
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
}
static class Pair implements Comparable<Pair> {
long first, second;
public Pair(long first, long second) {
this.first = first;
this.second = second;
}
@Override
public int compareTo(Pair o) {
return Long.compare(first, o.first);
}
}
}
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Armchair {
public static void main(String args[]){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int arr[]=new int[n];
ArrayList<Integer> list1=new ArrayList<Integer>();
ArrayList<Integer> list2=new ArrayList<Integer>();
for(int i=0;i<n;i++)
{
int a=in.nextInt();
if(a==0)
list2.add(i);
else
list1.add(i);
}
long dp[][]=new long[list1.size()+1][list2.size()+1];
solve(list1,list2,dp);
System.out.println(dp[list1.size()][list2.size()]);
}
public static void solve( ArrayList<Integer> list1,ArrayList<Integer> list2,long dp[][]){
for(int i=1;i<=list1.size();i++)
dp[i][0]=Integer.MAX_VALUE;
for(int i=1;i<=list1.size();i++){
for(int j=1;j<=list2.size();j++){
dp[i][j]=Math.min(Math.abs(list1.get(i-1)-list2.get(j-1))+dp[i-1][j-1],dp[i][j-1]);
}
}
}
}
| 0 |
Non-plagiarised
|
548ffb07
|
e7dce35b
|
import java.io.*;
import java.util.*;
public class D_Java {
public static final int MOD = 998244353;
public static int mul(int a, int b) {
return (int)((long)a * (long)b % MOD);
}
int[] f;
int[] rf;
public int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
}
public static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static void shuffleArray(int[] a) {
Random rnd = new Random();
for (int i = a.length-1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
int tmp = a[index];
a[index] = a[i];
a[i] = tmp;
}
}
public static int inv(int a) {
return pow(a, MOD-2);
}
public void doIt() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int k = Integer.parseInt(tok.nextToken());
f = new int[n+42];
rf = new int[n+42];
f[0] = rf[0] = 1;
for (int i = 1; i < f.length; ++i) {
f[i] = mul(f[i-1], i);
rf[i] = mul(rf[i-1], inv(i));
}
int[] events = new int[2*n];
for (int i = 0; i < n; ++i) {
tok = new StringTokenizer(in.readLine());
int le = Integer.parseInt(tok.nextToken());
int ri = Integer.parseInt(tok.nextToken());
events[i] = le*2;
events[i + n] = ri*2 + 1;
}
shuffleArray(events);
Arrays.sort(events);
int ans = 0;
int balance = 0;
for (int r = 0; r < 2*n;) {
int l = r;
while (r < 2*n && events[l] == events[r]) {
++r;
}
int added = r - l;
if (events[l] % 2 == 0) {
// Open event
ans += C(balance + added, k);
if (ans >= MOD) ans -= MOD;
ans += MOD - C(balance, k);
if (ans >= MOD) ans -= MOD;
balance += added;
} else {
// Close event
balance -= added;
}
}
in.close();
System.out.println(ans);
}
public static void main(String[] args) throws IOException {
(new D_Java()).doIt();
}
}
|
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
int n = nextInt();
int k = nextInt();
f = new int[n + 42];
rf = new int[n + 42];
f[0] = 1;
rf[0] = 1;
for (int i = 1; i < f.length; i++) {
f[i] = mul(f[i - 1], i);
rf[i] = mul(rf[i - 1], inv(i));
}
int[] a = new int[n * 2];
for (int i = 0; i < n; i++) {
a[i] = nextInt() * 2;
a[i + n] = nextInt() * 2 + 1;
}
Arrays.sort(a);
int ans = 0;
int curOpen = 0;
for (int r = 0; r < 2 * n;) {
int l = r;
while (r < 2 * n && a[l] == a[r]) r++;
int intersections = r - l;
if (a[l] % 2 == 0) {
ans += C(curOpen + intersections, k);
if (ans >= mod) ans -= mod;
ans += mod - C(curOpen, k);
if (ans >= mod) ans -= mod;
curOpen += intersections;
} else {
curOpen -= intersections;
}
}
pw.println(ans);
pw.close();
}
static int mod = 998244353;
static int mul(int a, int b) {
return (int) ((long) a * (long) b % mod);
}
static int[] f;
static int[] rf;
static int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n - k], rf[k]));
}
static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static int inv(int a) {
return pow(a, mod - 2);
}
static StringTokenizer st = new StringTokenizer("");
static BufferedReader br;
static String next() throws IOException {
while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
return st.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static long nextLong() throws IOException {
return Long.parseLong(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
class Coordinates {
int l;
int r;
public Coordinates(int l, int r) {
this.l = l;
this.r = r;
}
}
class CoordinatesComparator implements Comparator<Coordinates> {
@Override
public int compare(Coordinates o1, Coordinates o2) {
if (o1.l == o2.l) return Integer.compare(o1.r, o2.r);
return Integer.compare(o1.l, o2.l);
}
}
| 1 |
Plagiarised
|
1013b392
|
5a340556
|
import java.io.*;
import java.util.*;
public class ddd {
//----------------------------START--------------------------------------//
public static void main(String[] args)
throws IOException {
ADMIN_MODE();
int t = sc.ni();while(t-->0)
solve();
w.close();
}
static boolean[] neg;
static void solve() throws IOException {
int n = sc.ni();
neg = new boolean[n];
pr[] arr = new pr[n];
for(int i = 0; i < n; i++) {
long curr = sc.nl();
if(curr < 0) neg[i] = true;
arr[i] = new pr(Math.abs(curr), i);
}
Arrays.sort(arr);
long[] res = new long[n];
for(int i = 0; i < n-1; i+=2) {
long lcm = lcm(arr[i].val, arr[i+1].val);
res[arr[i].idx] = lcm/arr[i].val * (neg[arr[i].idx] ? -1 :1) * -1;
res[arr[i+1].idx] = lcm/arr[i+1].val * (neg[arr[i+1].idx] ? -1 :1);
}
if(n%2==1) {
long aa = arr[n-3].val * (neg[arr[n-3].idx] ? -1 : 1);
long bb = arr[n-2].val * (neg[arr[n-2].idx] ? -1 : 1);
long cc = arr[n-1].val * (neg[arr[n-1].idx] ? -1 : 1);
if (aa == -1*bb) {
if(aa == cc) {
pr temp = arr[n-1];
arr[n-1] = arr[n-2];
arr[n-2] = temp;
} else {
pr temp = arr[n-3];
arr[n-3] = arr[n-1];
arr[n-1] = temp;
}
}
}
if(n%2==1) {
long a = arr[n-2].val * (neg[arr[n-2].idx] ? -1 :1) +
arr[n-3].val * (neg[arr[n-3].idx] ? -1 :1);
boolean f = (a < 0);
a = Math.abs(a);
long b = arr[n-1].val;
long lcm = lcm(a, b);
if(f) {
res[arr[n-2].idx] = lcm/a * -1;
res[arr[n-3].idx] = lcm/a * -1;
} else {
res[arr[n - 2].idx] = lcm / a;
res[arr[n - 3].idx] = lcm / a;
}
res[arr[n-1].idx] = lcm/b * (neg[arr[n-1].idx] ? -1 :1) * - 1;
}
for(int i = 0; i < n; i++) {
w.pr(res[i]+" ");
}
w.pl();
}
static class pr implements Comparable<pr>{
long val;int idx;
public pr(long val, int idx) {
this.val = val;
this.idx = idx;
}
@Override
public int compareTo(pr o) {
return Long.compare(val, o.val);
}
}
//--------------------------INPUT READER--------------------------------//
static class fs {
public BufferedReader br;
StringTokenizer st = new StringTokenizer("");
public fs() { this(System.in); }
public fs(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
}
String next() {
while (!st.hasMoreTokens()) {
try { st = new StringTokenizer(br.readLine()); }
catch (IOException e) { e.printStackTrace(); }
}
return st.nextToken();
}
int ni() { return Integer.parseInt(next()); }
long nl() { return Long.parseLong(next()); }
double nd() { return Double.parseDouble(next()); }
String ns() { return next(); }
int[] na(long nn) {
int n = (int) nn;
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = ni();
return a;
}
long[] nal(long nn) {
int n = (int) nn;
long[] l = new long[n];
for(int i = 0; i < n; i++) l[i] = nl();
return l;
}
}
//-----------------------------------------------------------------------//
//---------------------------PRINTER-------------------------------------//
static class Printer {
static PrintWriter w;
public Printer() {this(System.out);}
public Printer(OutputStream os) {
w = new PrintWriter(os);
}
public void p(int i) {w.println(i);};
public void p(long l) {w.println(l);};
public void p(double d) {w.println(d);};
public void p(String s) { w.println(s);};
public void pr(int i) {w.print(i);};
public void pr(long l) {w.print(l);};
public void pr(double d) {w.print(d);};
public void pr(String s) { w.print(s);};
public void pl() {w.println();};
public void close() {w.close();};
}
//------------------------------------------------------------------------//
//--------------------------VARIABLES------------------------------------//
static fs sc = new fs();
static OutputStream outputStream = System.out;
static Printer w = new Printer(outputStream);
//-----------------------------------------------------------------------//
//--------------------------ADMIN_MODE-----------------------------------//
private static void ADMIN_MODE() throws IOException {
if (System.getProperty("ONLINE_JUDGE") == null) {
w = new Printer(new FileOutputStream("output.txt"));
sc = new fs(new FileInputStream("input.txt"));
}
}
//-------------------------------UTILS------------------------------------//
static long gcd(long a, long b) {
return b == 0 ? (a < 0L ? -a: a) : gcd(b, a%b);
}
static long lcm(long a, long b) {
return a/gcd(a, b)*b;
}
// region pow(a, b, mod) -> a^b
static long mp (long b , long x, long mod) {
if (x == 0) return 1;
if (x == 1) return b;
if (x % 2 == 0) return mp (b * b % mod, x / 2, mod) % mod;
return b * mp (b * b % mod, x / 2, mod) % mod;
}
// endregion
}
|
import java.io.*;
import java.util.*;
public class ddd {
//----------------------------START--------------------------------------//
public static void main(String[] args)
throws IOException {
ADMIN_MODE();
int t = sc.ni();while(t-->0)
solve();
w.close();
}
static boolean[] neg;
static void solve() throws IOException {
int n = sc.ni();
neg = new boolean[n];
pr[] arr = new pr[n];
for(int i = 0; i < n; i++) {
long curr = sc.nl();
if(curr < 0) neg[i] = true;
arr[i] = new pr(Math.abs(curr), i);
}
Arrays.sort(arr);
long[] res = new long[n];
for(int i = 0; i < n-1; i+=2) {
long lcm = lcm(arr[i].val, arr[i+1].val);
res[arr[i].idx] = lcm/arr[i].val * (neg[arr[i].idx] ? -1 :1) * -1;
res[arr[i+1].idx] = lcm/arr[i+1].val * (neg[arr[i+1].idx] ? -1 :1);
}
if(n%2==1) {
long aa = arr[n-3].val * (neg[arr[n-3].idx] ? -1 : 1);
long bb = arr[n-2].val * (neg[arr[n-2].idx] ? -1 : 1);
long cc = arr[n-1].val * (neg[arr[n-1].idx] ? -1 : 1);
if (aa == -1*bb) {
if(aa == cc) {
pr temp = arr[n-1];
arr[n-1] = arr[n-2];
arr[n-2] = temp;
} else {
pr temp = arr[n-3];
arr[n-3] = arr[n-1];
arr[n-1] = temp;
}
}
}
if(n%2==1) {
long a = arr[n-2].val * (neg[arr[n-2].idx] ? -1 :1) +
arr[n-3].val * (neg[arr[n-3].idx] ? -1 :1);
boolean f = (a < 0);
a = Math.abs(a);
long b = arr[n-1].val;
long lcm = lcm(a, b);
if(f) {
res[arr[n-2].idx] = lcm/a * -1;
res[arr[n-3].idx] = lcm/a * -1;
} else {
res[arr[n - 2].idx] = lcm / a;
res[arr[n - 3].idx] = lcm / a;
}
res[arr[n-1].idx] = lcm/b * (neg[arr[n-1].idx] ? -1 :1) * - 1;
}
for(int i = 0; i < n; i++) {
w.pr(res[i]+" ");
}
w.pl();
}
static class pr implements Comparable<pr>{
long val;int idx;
public pr(long val, int idx) {
this.val = val;
this.idx = idx;
}
@Override
public int compareTo(pr o) {
return Long.compare(val, o.val);
}
}
//--------------------------INPUT READER--------------------------------//
static class fs {
public BufferedReader br;
StringTokenizer st = new StringTokenizer("");
public fs() { this(System.in); }
public fs(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
}
String next() {
while (!st.hasMoreTokens()) {
try { st = new StringTokenizer(br.readLine()); }
catch (IOException e) { e.printStackTrace(); }
}
return st.nextToken();
}
int ni() { return Integer.parseInt(next()); }
long nl() { return Long.parseLong(next()); }
double nd() { return Double.parseDouble(next()); }
String ns() { return next(); }
int[] na(long nn) {
int n = (int) nn;
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = ni();
return a;
}
long[] nal(long nn) {
int n = (int) nn;
long[] l = new long[n];
for(int i = 0; i < n; i++) l[i] = nl();
return l;
}
}
//-----------------------------------------------------------------------//
//---------------------------PRINTER-------------------------------------//
static class Printer {
static PrintWriter w;
public Printer() {this(System.out);}
public Printer(OutputStream os) {
w = new PrintWriter(os);
}
public void p(int i) {w.println(i);};
public void p(long l) {w.println(l);};
public void p(double d) {w.println(d);};
public void p(String s) { w.println(s);};
public void pr(int i) {w.print(i);};
public void pr(long l) {w.print(l);};
public void pr(double d) {w.print(d);};
public void pr(String s) { w.print(s);};
public void pl() {w.println();};
public void close() {w.close();};
}
//------------------------------------------------------------------------//
//--------------------------VARIABLES------------------------------------//
static fs sc = new fs();
static OutputStream outputStream = System.out;
static Printer w = new Printer(outputStream);
//-----------------------------------------------------------------------//
//--------------------------ADMIN_MODE-----------------------------------//
private static void ADMIN_MODE() throws IOException {
if (System.getProperty("ONLINE_JUDGE") == null) {
w = new Printer(new FileOutputStream("output.txt"));
sc = new fs(new FileInputStream("input.txt"));
}
}
//-------------------------------UTILS------------------------------------//
static long gcd(long a, long b) {
return b == 0 ? (a < 0L ? -a: a) : gcd(b, a%b);
}
static long lcm(long a, long b) {
return a/gcd(a, b)*b;
}
// region pow(a, b, mod) -> a^b
static long mp (long b , long x, long mod) {
if (x == 0) return 1;
if (x == 1) return b;
if (x % 2 == 0) return mp (b * b % mod, x / 2, mod) % mod;
return b * mp (b * b % mod, x / 2, mod) % mod;
}
// endregion
}
| 1 |
Plagiarised
|
83b44c9c
|
ed610dc9
|
import java.util.Scanner;
public class MinimumGridPath {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int test = scanner.nextInt();
StringBuilder sb = new StringBuilder();
for (int t = 0; t < test; t++) {
int n = scanner.nextInt();
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextLong();
}
long minx = arr[0];
long miny = arr[1];
long min = minx * n + miny * n;
long sumx = arr[0];
long sumy = arr[1];
for(int i=2; i<n; i++) {
int xc;
int yc;
if(i%2 == 0) {
xc = i/2 + 1;
yc = i/2;
sumx += arr[i];
minx = Math.min(minx, arr[i]);
} else {
xc = i/2 + 1;
yc = i/2 + 1;
sumy += arr[i];
miny = Math.min(miny, arr[i]);
}
min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
}
sb.append(min).append(System.lineSeparator());
}
System.out.println(sb);
}
}
/*
// yehara
import java.io.PrintWriter;
import java.util.*;
public class C {
static Scanner sc;
static PrintWriter out;
public static void main(String[] args) throws Exception {
sc = new Scanner(System.in);
out = new PrintWriter(System.out);
int t = sc.nextInt();
for(int i=0; i<t; i++) {
solve();
}
out.flush();
}
static void solve() {
int n = sc.nextInt();
int[] c = new int[n];
for(int i=0; i<n; i++) {
c[i] = Integer.parseInt(sc.next());
}
long minx = c[0];
long miny = c[1];
long min = minx * n + miny * n;
long sumx = c[0];
long sumy = c[1];
for(int i=2; i<n; i++) {
int xc;
int yc;
if(i%2 == 0) {
xc = i/2 + 1;
yc = i/2;
sumx += c[i];
minx = Math.min(minx, c[i]);
} else {
xc = i/2 + 1;
yc = i/2 + 1;
sumy += c[i];
miny = Math.min(miny, c[i]);
}
min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
}
out.println(min);
}
}
*/
|
/*
* akshaygupta26
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.Random;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Collections;
import java.util.*;
public class C
{
public static void main(String[] args)
{
FastReader sc=new FastReader();
StringBuffer ans=new StringBuffer();
int test=sc.nextInt();
while(test-->0)
{
int n=sc.nextInt();
long arr[]=new long[n];
for(int i=0;i<n;i++) {
arr[i]=sc.nextLong();
}
long nn=n;
long ep=1;
long op=1;
long se=arr[0];
long so=arr[1];
long sume=se;long sumo=so;
long minm = (se*nn) +(so*nn);
for(int i=2;i<n;i++) {
if(i%2 == 0) {
++ep;
sume+=arr[i];
se=Math.min(se, arr[i]);
}
else {
++op;
sumo+=arr[i];
so=Math.min(so, arr[i]);
}
long cost = (sume)+(se*(nn-ep));
cost+=((sumo)+(so*(nn-op)));
minm=Math.min(cost, minm);
}
ans.append(minm+"\n");
}
System.out.print(ans);
}
static final Random random=new Random();
static void ruffleSort(int[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n), temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static void ruffleSort(long[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n);
long temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
baa8e497
|
cc9230d3
|
import java.util.*;
import java.io.*;
public class Solution {
public static void main(String str[]) throws IOException{
Reader sc = new Reader();
int t = sc.nextInt();
while(t-->0) {
int n = sc.nextInt();
ArrayList<Tree> tt = new ArrayList<>();
for(int i=0;i<n;i++){
Tree temp = new Tree(sc.nextInt(), sc.nextInt(), i);
tt.add(temp);
}
for(int i=0;i<n-1;i++){
int x = sc.nextInt()-1;
int y = sc.nextInt()-1;
tt.get(x).al.add(tt.get(y));
tt.get(y).al.add(tt.get(x));
}
Pair p = traversal(tt.get(0), null);
System.out.println(Math.max(p.av, p.bv));
}
}
static Pair traversal(Tree node, Tree Parent){
if(node.al.size()==1 && Parent!=null){
Pair p = new Pair(0,0);
return p;
}
long lt = 0;
long rt = 0;
for(Tree t: node.al){
if(t!=Parent){
Pair p = traversal(t, node);
long ll = Math.abs(node.l- t.l) + p.av;
ll = Math.max(ll, Math.abs(node.l-t.r)+p.bv);
long rr = Math.abs(node.r- t.l) + p.av;
rr = Math.max(rr, Math.abs(node.r-t.r)+p.bv);
lt+=ll;
rt+=rr;
}
}
Pair p = new Pair(lt, rt);
return p;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException
{
din = new DataInputStream(
new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
if (cnt != 0) {
break;
}
else {
continue;
}
}
buf[cnt++] = (byte)c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
}
class Pair{
long av;
long bv;
Pair(long av, long bv){
this.av = av;
this.bv = bv;
}
}
class Tree{
int l;
int r;
int i;
ArrayList<Tree> al = new ArrayList<>();
Tree(int l, int r, int i){
this.l = l;
this.r = r;
this.i = i;
}
}
|
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
public class C {
static int[][] lr = new int[2][(int)2e5+10];
static long[][] dp = new long[2][(int)2e5+10];
static ArrayList<ArrayList<Integer>> g;
public static void main(String[] args) {
FastReader fr = new FastReader();
PrintWriter out = new PrintWriter(System.out, true);
int cases = fr.nextInt();
for(int c = 0; c < cases; c++) {
int nodes = fr.nextInt();
g = new ArrayList<ArrayList<Integer>>();
for(int i = 1; i <= nodes; i++) {
lr[0][i] = fr.nextInt();
lr[1][i] = fr.nextInt();
}
for(int i = 0; i <= nodes; i++) {
g.add(new ArrayList<Integer>());
}
for(int i = 0; i < nodes-1; i++) {
int f = fr.nextInt();
int t = fr.nextInt();
g.get(f).add(t);
g.get(t).add(f);
}
DFS(1, -1);
out.write(Math.max(dp[0][1], dp[1][1]) + "\n");
}
out.close();
}
static void DFS(int v, int p) {
dp[0][v] = dp[1][v] = 0;
for(Integer u : g.get(v)) {
if (u == p) continue;
DFS(u, v);
dp[0][v] += Math.max(Math.abs(lr[0][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[0][v] - lr[0][u]));
dp[1][v] += Math.max(Math.abs(lr[1][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[1][v] - lr[0][u]));
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
this.br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try{
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble() { return Double.parseDouble(next()); }
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
778c91af
|
9399204d
|
import java.io.*;
import java.util.*;
import java.text.DecimalFormat;
public class C {
static long mod=(long)1e9+7;
static long mod1=998244353;
static InputStream inputStream = System.in;
static OutputStream outputStream = System.out;
static InputReader in = new InputReader(inputStream);
static PrintWriter out = new PrintWriter(outputStream);
public static void main(String[] args) throws IOException {
int t= in.nextInt();
while(t-->0) {
int n = in.nextInt();
ArrayList<Pair>[] adj = new ArrayList[5];
for(int i = 0;i<5;i++) adj[i] = new ArrayList<>();
for(int i = 0;i<n;i++){
char[] arr = in.next().toCharArray();
int[] count = new int[5];
for(char c:arr)
count[c-'a']++;
for(int j = 0;j<5;j++){
adj[j].add(new Pair(count[j],arr.length-count[j]));
}
}
int max = 0;
for(int i = 0;i<5;i++){
Collections.sort(adj[i]);
int count = 0;
int sum1 = 0;
int sum2 = 0;
for(Pair p:adj[i]){
if(sum1+p.a>sum2+p.b){
count++;
sum1+=p.a;
sum2+=p.b;
}
}
max = Math.max(max,count);
}
out.println(max);
}
out.close();
}
static class Pair implements Comparable<Pair>{
int a,b;
Pair(int a, int b){
this.a = a;
this.b = b;
}
public int compareTo(Pair x){
return Integer.compare(x.a-x.b,this.a-this.b);
}
}
static final Random random=new Random();
static void ruffleSort(char[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); char temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static long gcd(long x, long y){
if(x==0)
return y;
if(y==0)
return x;
long r=0, a, b;
a = Math.max(x, y);
b = Math.min(x, y);
r = b;
while(a % b != 0){
r = a % b;
a = b;
b = r;
}
return r;
}
static long modulo(long a,long b,long c){
long x=1,y=a%c;
while(b > 0){
if(b%2 == 1)
x=(x*y)%c;
y = (y*y)%c;
b = b>>1;
}
return x%c;
}
public static void debug(Object... o){
System.err.println(Arrays.deepToString(o));
}
static int upper_bound(int[] arr,int n,int x){
int mid;
int low=0;
int high=n;
while(low<high){
mid=low+(high-low)/2;
if(x>=arr[mid])
low=mid+1;
else
high=mid;
}
return low;
}
static int lower_bound(int[] arr,int n,int x){
int mid;
int low=0;
int high=n;
while(low<high){
mid=low+(high-low)/2;
if(x<=arr[mid])
high=mid;
else
low=mid+1;
}
return low;
}
static String printPrecision(double d){
DecimalFormat ft = new DecimalFormat("0.00000000000");
return String.valueOf(ft.format(d));
}
static int countBit(long mask){
int ans=0;
while(mask!=0){
mask&=(mask-1);
ans++;
}
return ans;
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] readArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) arr[i] = nextInt();
return arr;
}
}
}
|
import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger;
public final class A
{
static PrintWriter out = new PrintWriter(System.out);
static StringBuilder ans=new StringBuilder();
static FastReader in=new FastReader();
static ArrayList<Integer> g[];
static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
static boolean set[],col[];
static int par[],tot[],partial[];
static int D[],P[][];
static long dp[][],sum=0,max=0,size[];
// static node1 seg[];
//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
public static void main(String args[])throws IOException
{
int T=i();
outer:while(T-->0)
{
int N=i();
int size[]=new int[N];
PriorityQueue<node1> q[]=new PriorityQueue[6];
for(int i=0; i<5; i++)q[i]=new PriorityQueue<node1>();
for(int i=0; i<N; i++)
{
char X[]=in.next().toCharArray();
int s=X.length;
size[i]=s;
int f[]=new int[5];
for(char x:X)f[x-'a']++;
for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
}
int max=0;
for(int i=0; i<5; i++)
{
PriorityQueue<node1> q_new=new PriorityQueue<>();
q_new=q[i];
int c=0;
long f=0;
while(q_new.size()>0)
{
node1 x=q_new.remove();
// System.out.println(x.f+" "+x.size+" "+x.a);
f+=x.a;
if(f>0)
{
c++;
max=Math.max(max, c);
}
else break;
}
}
out.println(max);
}
out.close();
}
static int OR(int i,int j)
{
if(i>j)
{
int t=i;
i=j;
j=t;
}
System.out.println("OR "+i+" "+j);
return i();
}
static int AND(int i,int j)
{
if(i>j)
{
int t=i;
i=j;
j=t;
}
System.out.println("AND "+i+" "+j);
return i();
}
static int XOR(int i,int j)
{
if(i>j)
{
int t=i;
i=j;
j=t;
}
System.out.println("XOR "+i+" "+j);
return i();
}
static boolean f1(int l,char X[])
{
int i=0;
for(; l<X.length; l++)
{
if(X[i]!=X[l])return false;
i++;
}
return true;
}
static int f(int a)
{
for(int i=a+1; a>0; a++)
{
if(GCD(i,a)==1)return i;
}
return 0;
}
static int min(char X[],char str[],int N)
{
int s=0;
for(int i=0; i<N; i++)
{
int it=i%3;
if(X[i]!=str[it])s++;
// ans.append(str[it]);
}
return s;
}
static char f(int i,char X[])
{
int a=0,b=0,c=0;
for(; i<X.length; i+=3)
{
if(X[i]=='R')a++;
if(X[i]=='B')b++;
if(X[i]=='G')c++;
}
if(a>=b && a>=c)return 'R';
if(b>=a && b>=c)return 'B';
return 'G';
}
static void f1(int n,int p,long sum,int N)
{
for(int c:g[n])
{
if(c==p)continue;
long s=sum+N-2*size[c];
f1(c,n,s,N);
max=Math.max(max, s);
}
}
static long f(int i,int j,ArrayList<Integer> A)
{
if(i+1==A.size())
{
return j;
}
int moves=1+A.get(i);
if(j==1)return 1+f(i+1,moves,A);
if(j>0 && dp[i][j-1]==0)f(i,j-1,A);
return dp[i][j]=dp[i][j-1]+f(i+1,j+moves,A);
}
// static void build(int v,int tl,int tr,long A[])
// {
// if(tl==tr)
// {
// seg[v]=new node1(A[tl],A[tr],1,true);
// return ;
// }
// int tm=(tl+tr)/2;
// build(2*v,tl,tm,A);
// build(2*v+1,tm+1,tr,A);
// seg[v]=merge(seg[2*v],seg[2*v+1]);
// }
// static node1 ask(int v,int tl,int tr,int l,int r)
// {
// if(l>r)return new node1(0,0,0,false);//verify true or false
// if(tl==l && tr==r)return seg[v];
// int tm=(tl+tr)/2;
// node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
// node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
// return merge(a,b);
// }
// static node1 merge(node1 a,node1 b)
// {
// long s=0;
// long l1=a.L,r1=a.R,c1=a.cnt;
// long l2=b.L,r2=b.R,c2=b.cnt;
// long g=GCD(l2,r1); s=c1+c2;
// if(g==1)
// {
// s--;
// g=(l2*r1)/g;
// if(c1==1)
// {
// l1=g;
// }
// if(c2==1)r2=g;
// return new node1(l1,r2,s,true);
// }
// return new node1(l1,r2,s,a.leaf^b.leaf);
// }
static long f(long l,long r,long a,long b,long N)
{
while(r-l>1)
{
long m=(l+r)/2;
long x=m*b;
if(N<x)
{
r=m;
continue;
}
if((N-x)%a==0)r=m;
else l=m;
}
return r;
}
static long f1(long a,long A[],long bits[],long sum)
{
long s=A.length;
s=mul(s,a);
s=(s+(sum%mod))%mod;
long p=1L;
for(long x:bits)
{
if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
p<<=1;
}
return s;
}
static long f2(long a,long A[],long bits[])
{
long s=0;
long p=1L;
for(long x:bits)
{
if((a&p)!=0)
{
s=(s+mul(p,x))%mod;
}
p<<=1;
}
return s;
}
static long f(long x1,long y1,long x2,long y2)
{
return Math.abs(x1-x2)+Math.abs(y1-y2);
}
static long f(long x,long max,long s)
{
long l=-1,r=(x/s)+1;
while(r-l>1)
{
long m=(l+r)/2;
if(x-m*s>max)l=m;
else r=m;
}
return l+1;
}
static int f(long A[],long x)
{
int l=-1,r=A.length;
while(r-l>1)
{
int m=(l+r)/2;
if(A[m]>=x)r=m;
else l=m;
}
return r;
}
static int bin(int x,ArrayList<Integer> A)
{
int l=0,r=A.size()-1;
while(l<=r)
{
int m=(l+r)/2;
int a=A.get(m);
if(a==x)return m;
if(a<x)l=m+1;
else r=m-1;
}
return 0;
}
static int left(int x,ArrayList<Integer> A)
{
int l=-1,r=A.size();
while(r-l>1)
{
int m=(l+r)/2;
int a=A.get(m);
if(a<=x)l=m;
else r=m;
}
return l;
}
static int right(int x,ArrayList<Integer> A)
{
int l=-1,r=A.size();
while(r-l>1)
{
int m=(l+r)/2;
int a=A.get(m);
if(a<x)l=m;
else r=m;
}
return r;
}
static boolean equal(long A[],long B[])
{
for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
return true;
}
static int max(int a ,int b,int c,int d)
{
a=Math.max(a, b);
c=Math.max(c,d);
return Math.max(a, c);
}
static int min(int a ,int b,int c,int d)
{
a=Math.min(a, b);
c=Math.min(c,d);
return Math.min(a, c);
}
static HashMap<Integer,Integer> Hash(int A[])
{
HashMap<Integer,Integer> mp=new HashMap<>();
for(int a:A)
{
int f=mp.getOrDefault(a,0)+1;
mp.put(a, f);
}
return mp;
}
static long mul(long a, long b)
{
return ( a %mod * 1L * b%mod )%mod;
}
static void swap(int A[],int a,int b)
{
int t=A[a];
A[a]=A[b];
A[b]=t;
}
static int find(int a)
{
if(par[a]<0)return a;
return par[a]=find(par[a]);
}
static void union(int a,int b)
{
a=find(a);
b=find(b);
if(a!=b)
{
par[a]+=par[b];
par[b]=a;
}
}
static boolean isSorted(int A[])
{
for(int i=1; i<A.length; i++)
{
if(A[i]<A[i-1])return false;
}
return true;
}
static boolean isDivisible(StringBuilder X,int i,long num)
{
long r=0;
for(; i<X.length(); i++)
{
r=r*10+(X.charAt(i)-'0');
r=r%num;
}
return r==0;
}
static int lower_Bound(int A[],int low,int high, int x)
{
if (low > high)
if (x >= A[high])
return A[high];
int mid = (low + high) / 2;
if (A[mid] == x)
return A[mid];
if (mid > 0 && A[mid - 1] <= x && x < A[mid])
return A[mid - 1];
if (x < A[mid])
return lower_Bound( A, low, mid - 1, x);
return lower_Bound(A, mid + 1, high, x);
}
static String f(String A)
{
String X="";
for(int i=A.length()-1; i>=0; i--)
{
int c=A.charAt(i)-'0';
X+=(c+1)%2;
}
return X;
}
static void sort(long[] a) //check for long
{
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static String swap(String X,int i,int j)
{
char ch[]=X.toCharArray();
char a=ch[i];
ch[i]=ch[j];
ch[j]=a;
return new String(ch);
}
static int sD(long n)
{
if (n % 2 == 0 )
return 2;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0 )
return i;
}
return (int)n;
}
static void setGraph(int N)
{
tot=new int[N+1];
partial=new int[N+1];
D=new int[N+1];
P=new int[N+1][(int)(Math.log(N)+10)];
set=new boolean[N+1];
g=new ArrayList[N+1];
for(int i=0; i<=N; i++)
{
g[i]=new ArrayList<>();
D[i]=Integer.MAX_VALUE;
//D2[i]=INF;
}
}
static long pow(long a,long b)
{
//long mod=1000000007;
long pow=1;
long x=a;
while(b!=0)
{
if((b&1)!=0)pow=(pow*x)%mod;
x=(x*x)%mod;
b/=2;
}
return pow;
}
static long toggleBits(long x)//one's complement || Toggle bits
{
int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
return ((1<<n)-1)^x;
}
static int countBits(long a)
{
return (int)(Math.log(a)/Math.log(2)+1);
}
static long fact(long N)
{
long n=2;
if(N<=1)return 1;
else
{
for(int i=3; i<=N; i++)n=(n*i)%mod;
}
return n;
}
static int kadane(int A[])
{
int lsum=A[0],gsum=A[0];
for(int i=1; i<A.length; i++)
{
lsum=Math.max(lsum+A[i],A[i]);
gsum=Math.max(gsum,lsum);
}
return gsum;
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static boolean isPrime(long N)
{
if (N<=1) return false;
if (N<=3) return true;
if (N%2 == 0 || N%3 == 0) return false;
for (int i=5; i*i<=N; i=i+6)
if (N%i == 0 || N%(i+2) == 0)
return false;
return true;
}
static void print(char A[])
{
for(char c:A)System.out.print(c+" ");
System.out.println();
}
static void print(boolean A[])
{
for(boolean c:A)System.out.print(c+" ");
System.out.println();
}
static void print(int A[])
{
for(int a:A)System.out.print(a+" ");
System.out.println();
}
static void print(long A[])
{
for(long i:A)System.out.print(i+ " ");
System.out.println();
}
static void print(ArrayList<Integer> A)
{
for(int a:A)System.out.print(a+" ");
System.out.println();
}
static int i()
{
return in.nextInt();
}
static long l()
{
return in.nextLong();
}
static int[] input(int N){
int A[]=new int[N];
for(int i=0; i<N; i++)
{
A[i]=in.nextInt();
}
return A;
}
static long[] inputLong(int N) {
long A[]=new long[N];
for(int i=0; i<A.length; i++)A[i]=in.nextLong();
return A;
}
static long GCD(long a,long b)
{
if(b==0)
{
return a;
}
else return GCD(b,a%b );
}
}
class node1 implements Comparable<node1>
{
int index,f,size;
long a;
node1(int f,int i,int size)
{
this.f=f;
this.index=i;
this.size=size;
a=2*f-size;
}
public int compareTo(node1 x)
{
if(this.a==x.a)return 0;
else if(this.a<x.a)return 1;
else return -1;
}
}
//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br=new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while(st==null || !st.hasMoreElements())
{
try
{
st=new StringTokenizer(br.readLine());
}
catch(IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str="";
try
{
str=br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
| 0 |
Non-plagiarised
|
25151980
|
3b5cec19
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class C {
public static void main(String[] args) {
FastScanner fs=new FastScanner();
int T=fs.nextInt();
for (int tt=1; tt<=T; tt++) {
int n=fs.nextInt();
int m=fs.nextInt();
int x=fs.nextInt();
int arr[]=fs.readArray(n);
if(m>n) {
System.out.println("NO");
continue;
}
int copy[]=new int [n];
for(int i=0;i<n;i++) {
copy[i]=arr[i];
}
Arrays.sort(copy);
ArrayList<Integer> container[]= new ArrayList[x+1];
for(int i=1;i<=x;i++) {
container[i]=new ArrayList<Integer>();
}
for(int i=0;i<m;i++) {
for(int j=i;j<n;j+=m) {
container[copy[j]].add(i+1);
}
}
int counter[]=new int [n];
for(int i=0;i<n;i++) {
counter[i]=container[arr[i]].get(0);
container[arr[i]].remove(0);
}
System.out.println("YES");
for(int i=0;i<n;i++) {
System.out.print(counter[i]+" ");
}
System.out.println();
}
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
String nextLine() {
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
int[][] readArray(int n,int m) {
int[][] a=new int[n][m];
for (int i=0; i<n; i++) for(int j=0; j<m; j++) a[i][j]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
}
|
import java.util.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Test{
static class Pair implements Comparable<Pair>{
int wt;
int idx;
Pair(int x,int y){
this.wt=x;
this.idx=y;
}
@Override
public int compareTo(Pair x){
return this.wt-x.wt;
}
public String toString(){
return "("+wt+" "+idx+")";
}
}
public static void main (String[] args) throws java.lang.Exception{
FastReader scan=new FastReader();
int t=scan.nextInt();
while(t-->0){
int n=scan.nextInt();
int m=scan.nextInt();
int x=scan.nextInt();
int[]arr=new int[n];
for(int i=0;i<n;i++){
arr[i]=scan.nextInt();
}
Queue<Pair>q=new PriorityQueue<>();
for(int i=1;i<=m;i++){
q.add(new Pair(0,i));
}
System.out.println("YES");
for(int i=0;i<n;i++){
Pair temp=q.poll();
int wt=temp.wt;
int idx=temp.idx;
System.out.print(idx+" ");
//System.out.println(temp);
q.add(new Pair(wt+arr[i],idx));
}
System.out.println();
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble() { return Double.parseDouble(next()); }
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
ad4c7a20
|
f8e7b886
|
import java.io.*;
import java.util.*;
public class Practice
{
// static final long mod=7420738134811L;
static int mod=1000000007;
static final int size=501;
static FastReader sc=new FastReader(System.in);
// static Reader sc=new Reader();
// static Scanner sc=new Scanner(System.in);
static PrintWriter out=new PrintWriter(System.out);
static long[] factorialNumInverse;
static long[] naturalNumInverse;
static int[] sp;
static long[] fact;
static ArrayList<Integer> pr;
public static void main(String[] args) throws IOException, CloneNotSupportedException
{
// System.setIn(new FileInputStream("input.txt"));
// System.setOut(new PrintStream("output.txt"));
// factorial(mod);
// InverseofNumber(mod);
// InverseofFactorial(mod);
// make_seive();
int t=1;
t=sc.nextInt();
for(int i=1;i<=t;i++)
solve(i);
out.close();
out.flush();
// System.out.flush();
// System.exit(0);
}
static void solve(int CASENO) throws IOException, CloneNotSupportedException
{
int n=sc.nextInt();
int k[]=new int[n];
int h[]=new int[n];
for(int i=0;i<n;i++)
k[i]=sc.nextInt();
for(int i=0;i<n;i++)
h[i]=sc.nextInt();
ArrayList<Pair> interval=new ArrayList<Pair>();
ArrayList<Pair> act=new ArrayList<Pair>();
for(int i=0;i<n;i++)
interval.add(new Pair(k[i]-h[i]+1,k[i]));
Collections.sort(interval);
// out.println(interval);
act.add(interval.get(0).clone());
for(int i=1;i<n;i++)
{
Pair p=act.get(act.size()-1);
if(p.y<interval.get(i).x)
act.add(interval.get(i).clone());
else
p.y=Math.max(p.y, interval.get(i).y);
}
// out.println(act);
long mana=0;
for(Pair p: act)
{
long x=p.y-p.x+1;
mana+=(x*(x+1))/2;
}
out.println(mana);
}
static class Pair implements Cloneable, Comparable<Pair>
{
int x,y;
Pair(int a,int b)
{
this.x=a;
this.y=b;
}
@Override
public boolean equals(Object obj)
{
if(obj instanceof Pair)
{
Pair p=(Pair)obj;
return p.x==this.x && p.y==this.y;
}
return false;
}
@Override
public int hashCode()
{
return Math.abs(x)+500*Math.abs(y);
}
@Override
public String toString()
{
return "("+x+" "+y+")";
}
@Override
protected Pair clone() throws CloneNotSupportedException {
return new Pair(this.x,this.y);
}
@Override
public int compareTo(Pair a)
{
long t=(this.x-a.x);
if(t!=0)
return t>0?1:-1;
else
return (int)(this.y-a.y);
}
public void swap()
{
this.y=this.y+this.x;
this.x=this.y-this.x;
this.y=this.y-this.x;
}
}
static class Tuple implements Cloneable, Comparable<Tuple>
{
int x,y,z;
Tuple(int a,int b,int c)
{
this.x=a;
this.y=b;
this.z=c;
}
public boolean equals(Object obj)
{
if(obj instanceof Tuple)
{
Tuple p=(Tuple)obj;
return p.x==this.x && p.y==this.y && p.z==this.z;
}
return false;
}
@Override
public int hashCode()
{
return (this.x+501*this.y);
}
@Override
public String toString()
{
return "("+x+","+y+","+z+")";
}
@Override
protected Tuple clone() throws CloneNotSupportedException {
return new Tuple(this.x,this.y,this.z);
}
@Override
public int compareTo(Tuple a)
{
int x=this.z-a.z;
if(x!=0)
return x;
int X= this.x-a.x;
if(X!=0)
return X;
return a.y-this.y;
}
}
static void arraySort(int arr[])
{
ArrayList<Integer> a=new ArrayList<Integer>();
for (int i = 0; i < arr.length; i++) {
a.add(arr[i]);
}
Collections.sort(a,Comparator.reverseOrder());
for (int i = 0; i < arr.length; i++) {
arr[i]=a.get(i);
}
}
static void arraySort(long arr[])
{
ArrayList<Long> a=new ArrayList<Long>();
for (int i = 0; i < arr.length; i++) {
a.add(arr[i]);
}
Collections.sort(a);
for (int i = 0; i < arr.length; i++) {
arr[i]=a.get(i);
}
}
static HashSet<Integer> primeFactors(int n)
{
HashSet<Integer> ans=new HashSet<Integer>();
if(n%2==0)
{
ans.add(2);
while((n&1)==0)
n=n>>1;
}
for(int i=3;i*i<=n;i+=2)
{
if(n%i==0)
{
ans.add(i);
while(n%i==0)
n=n/i;
}
}
if(n!=1)
ans.add(n);
return ans;
}
static void make_seive()
{
sp=new int[size];
pr=new ArrayList<Integer>();
for (int i=2; i<size; ++i) {
if (sp[i] == 0) {
sp[i] = i;
pr.add(i);
}
for (int j=0; j<(int)pr.size() && pr.get(j)<=sp[i] && i*pr.get(j)<size; ++j)
sp[i * pr.get(j)] = pr.get(j);
}
}
public static void InverseofNumber(int p)
{
naturalNumInverse=new long[size];
naturalNumInverse[0] = naturalNumInverse[1] = 1;
for(int i = 2; i < size; i++)
naturalNumInverse[i] = naturalNumInverse[p % i] * (long)(p - p / i) % p;
}
// Function to precompute inverse of factorials
public static void InverseofFactorial(int p)
{
factorialNumInverse=new long[size];
factorialNumInverse[0] = factorialNumInverse[1] = 1;
// pre-compute inverse of natural numbers
for(int i = 2; i < size; i++)
factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
// Function to calculate factorial of 1 to 200001
public static void factorial(int p)
{
fact=new long[size];
fact[0] = 1;
for(int i = 1; i < size; i++)
fact[i] = (fact[i - 1] * (long)i) % p;
}
// Function to return nCr % p in O(1) time
public static long Binomial(int N, int R)
{
if(R<0)
return 1;
// n C r = n!*inverse(r!)*inverse((n-r)!)
long ans = ((fact[N] * factorialNumInverse[R]) % mod * factorialNumInverse[N - R]) % mod;
return ans;
}
static int findXOR(int x) //from 0 to x
{
if(x<0)
return 0;
if(x%4==0)
return x;
if(x%4==1)
return 1;
if(x%4==2)
return x+1;
return 0;
}
static boolean isPrime(long x)
{
if(x==1)
return false;
if(x<=3)
return true;
if(x%2==0 || x%3==0)
return false;
for(int i=5;i<=Math.sqrt(x);i+=2)
if(x%i==0)
return false;
return true;
}
static long gcd(long a,long b)
{
return (b==0)?a:gcd(b,a%b);
}
static int gcd(int a,int b)
{
return (b==0)?a:gcd(b,a%b);
}
static class Node
{
int vertex,dis;
HashSet<Node> adj;
Node(int ver)
{
vertex=ver;
dis=-1;
adj=new HashSet<Node>();
}
@Override
public String toString()
{
return vertex+" ";
}
}
static class Edge
{
Node to;
int cost;
Edge(Node t,int c)
{
this.to=t;
this.cost=c;
}
@Override
public String toString() {
return "("+to.vertex+","+cost+") ";
}
}
static long power(long x, long y)
{
if(x<=0)
return 1;
long res = 1;
x = x % mod;
if (x == 0)
return 0;
while (y > 0)
{
if ((y & 1) != 0)
res = (res * x) % mod;
y = y >> 1; // y = y/2
x = (x * x) % mod;
}
return res%mod;
}
static long binomialCoeff(long n, long k)
{
if(n<k)
return 0;
long res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of
// [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
static class FastReader
{
byte[] buf = new byte[2048];
int index, total;
InputStream in;
FastReader(InputStream is)
{
in = is;
}
int scan() throws IOException
{
if (index >= total) {
index = 0;
total = in.read(buf);
if (total <= 0) {
return -1;
}
}
return buf[index++];
}
String next() throws IOException
{
int c;
for (c = scan(); c <= 32; c = scan());
StringBuilder sb = new StringBuilder();
for (; c > 32; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
int nextInt() throws IOException
{
int c, val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
long nextLong() throws IOException
{
int c;
long val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
}
static class Reader
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException
{
din = new DataInputStream(
new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
if (cnt != 0) {
break;
}
else {
continue;
}
}
buf[cnt++] = (byte)c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
public void printarray(int arr[])
{
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i]+" ");
System.out.println();
}
}
}
|
import java.util.*;
import java.io.*;
import java.time.*;
import static java.lang.Math.*;
@SuppressWarnings("unused")
public class C {
static boolean DEBUG = false;
static Reader fs;
static PrintWriter pw;
static void solve() {
int n = fs.nextInt(), k[] = fs.readArray(n), h[] = fs.readArray(n);
int prev_h = h[0], prev_k = k[0];
// int ans = 0;
ArrayList<pair> intervals = new ArrayList<>();
for (int i = 0; i < n; i++) {
int start = k[i] - h[i] + 1;
int end = k[i];
intervals.add(new pair(start, end));
}
// pw.println(intervals);
Collections.sort(intervals);
ArrayList<pair> merged = new ArrayList<>();
merge(intervals, merged);
long ans = 0;
for(int i = 0 ; i < merged.size() ; i++) {
ans += sum(merged.get(i).len());
}
pw.println(ans);
}
static void merge(ArrayList<pair>a1, ArrayList<pair>a2) {
int n = a1.size();
int index = 0;
for(int i =1 ; i < n ; i++) {
if(a1.get(index).s >= a1.get(i).f) {
a1.get(index).s = max(a1.get(index).s, a1.get(i).s);
}
else {
index++;
a1.set(index, a1.get(i));
}
}
for(int i = 0 ; i <= index ; i++) {
a2.add(a1.get(i));
}
// pw.println(a1);
}
// int index = 0; // Stores index of last element
// // in output array (modified arr[])
//
// // Traverse all input Intervals
// for (int i=1; i<arr.length; i++)
// {
// // If this is not first Interval and overlaps
// // with the previous one
// if (arr[index].end >= arr[i].start)
// {
// // Merge previous and current Intervals
// arr[index].end = Math.max(arr[index].end, arr[i].end);
// }
// else {
// index++;
// arr[index] = arr[i];
// }
// }
static boolean overlapping(pair p1, pair p2) {
if((p2.f >= p1.f && p1.s >= p2.f) || (p2.s >= p1.f && p1.s >= p2.s)) {
return true;
}
return false;
}
static pair merge(pair p1, pair p2) {
return new pair(min(p1.f, p2.f), max(p1.s, p2.s));
}
static long sum(long n) {
return (n * (n + 1) / 2);
}
static class pair implements Comparable<pair>{
int f, s;
pair(int f, int s) {
this.f = f;
this.s = s;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{" + f + "," + s + "}");
return sb.toString();
}
@Override
public int compareTo(pair o) {
return f - o.f;
}
public int len() {
return s - f + 1;
}
}
public static void main(String[] args) throws IOException {
Instant start = Instant.now();
if (args.length == 2) {
System.setIn(new FileInputStream(new File("D:\\program\\javaCPEclipse\\CodeForces\\src\\input.txt")));
// System.setOut(new PrintStream(new File("output.txt")));
System.setErr(new PrintStream(new File("D:\\program\\javaCPEclipse\\CodeForces\\src\\error.txt")));
DEBUG = true;
}
fs = new Reader();
pw = new PrintWriter(System.out);
int t = fs.nextInt();
while (t-- > 0) {
solve();
}
Instant end = Instant.now();
if (DEBUG) {
pw.println(Duration.between(start, end));
}
pw.close();
}
static void sort(int a[]) {
ArrayList<Integer> l = new ArrayList<Integer>();
for (int x : a)
l.add(x);
Collections.sort(l);
for (int i = 0; i < a.length; i++) {
a[i] = l.get(i);
}
}
public static void print(long a, long b, long c, PrintWriter pw) {
pw.println(a + " " + b + " " + c);
return;
}
static class Reader {
BufferedReader br;
StringTokenizer st;
public Reader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] readArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
int[][] read2Array(int n, int m) {
int a[][] = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = nextInt();
}
}
return a;
}
}
}
| 0 |
Non-plagiarised
|
55ab9b5d
|
c6113c06
|
import java.io.*;
import java.util.*;
public class Main {
static int solve(char ch, char[][] str, int N) {
int[] a = new int[N];
for (int i = 0; i < N; i++) {
int c1 = 0, c2 = 0;
for (char x : str[i]) {
if (x == ch) c1++;
else c2++;
}
a[i] = c1 - c2;
}
int sum = 0, count = N;
for (int x : a) sum += x;
Arrays.sort(a);
for (int i = 0; i < N; i++) {
if (sum > 0) break;
count--;
sum -= a[i];
}
return count;
}
public static void main(String[] args) throws IOException {
// System.out.println("===== input =====");
// BufferedReader br = new BufferedReader(new FileReader("input/input1.txt"));
// BufferedReader br2 = new BufferedReader(new FileReader("input/input1.txt"));
// String s;
// while ((s = br2.readLine()) != null) {
// System.out.println(s);
// }
// System.out.println("===== output =====");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
StringBuilder out = new StringBuilder();
int T = Integer.parseInt(st.nextToken());
while (T-- > 0) {
int n = Integer.parseInt(br.readLine().trim());
char[][] str = new char[n][];
for (int i = 0; i < n; i++) {
str[i] = br.readLine().trim().toCharArray();
}
int ans = 0;
for (char ch = 'a'; ch <= 'e'; ch++) {
ans = Math.max(ans, solve(ch, str, n));
}
out.append(ans).append("\n");
}
System.out.println(out);
}
}
|
//created by Whiplash99
import java.io.*;
import java.util.*;
public class D
{
private static int solve(char ch, char[][] str, int N)
{
int[] a=new int[N];
for(int i=0;i<N;i++)
{
int c1=0, c2=0;
for(char x:str[i])
{
if(x==ch) c1++;
else c2++;
}
a[i]=c1-c2;
}
int sum=0, count=N;
for(int x:a) sum+=x;
Arrays.sort(a);
for(int i=0;i<N;i++)
{
if(sum>0) break;
count--; sum-=a[i];
}
return count;
}
public static void main(String[] args) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int i,N;
int T=Integer.parseInt(br.readLine().trim());
StringBuilder sb=new StringBuilder();
while (T-->0)
{
N=Integer.parseInt(br.readLine().trim());
char[][] str=new char[N][];
for(i=0;i<N;i++) str[i]=br.readLine().trim().toCharArray();
int ans=0;
for(char ch='a';ch<='e';ch++)
{
int tmp=solve(ch,str,N);
ans=Math.max(ans,tmp);
}
sb.append(ans).append("\n");
}
System.out.println(sb);
}
}
| 1 |
Plagiarised
|
3ff25f43
|
c287ea9d
|
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class EDU121C {
public static void main(String[] args) {
JS scan = new JS();
int t = scan.nextInt();
while(t-->0){
int n = scan.nextInt();
long[] k = new long[n];
long[] h = new long[n];
for(int i =0;i<n;i++){
k[i] = scan.nextInt();
}
for(int i = 0;i<n;i++){
h[i] = scan.nextInt();
}
long ans = 0;
long lastD = 0;
long lastHP = 0;
for(int i = 0;i<n;i++){
long dist = k[i]-lastD;
long lo = h[i];
long hi = lastHP+dist;
long hpComingOut = 0;
while(lo<=hi){
long mid = (lo+hi)/2;
boolean check = false;
for(int j = i+1;j<n;j++){
if(k[j]-k[i]<h[j]-mid){
check = true;
break;
}
}
if(check){
//we're in trouble
lo = mid+1;
}else{
hi = mid-1;
hpComingOut = mid;
}
}
if(hpComingOut>dist){
ans+=summ(dist+lastHP)-summ(lastHP);
lastHP+=dist;
}else{
long diff = dist-hpComingOut;
ans+=summ(hpComingOut);
lastHP = hpComingOut;
}
lastD = k[i];
}
System.out.println(ans);
}
}
static long summ(long a){
return (a*(a+1))/2;
}
static class JS {
public int BS = 1 << 16;
public char NC = (char) 0;
byte[] buf = new byte[BS];
int bId = 0, size = 0;
char c = NC;
double num = 1;
BufferedInputStream in;
public JS() {
in = new BufferedInputStream(System.in, BS);
}
public JS(String s) throws FileNotFoundException {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
}
public char nextChar() {
while (bId == size) {
try {
size = in.read(buf);
} catch (Exception e) {
return NC;
}
if (size == -1) return NC;
bId = 0;
}
return (char) buf[bId++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
num = 1;
boolean neg = false;
if (c == NC) c = nextChar();
for (; (c < '0' || c > '9'); c = nextChar()) {
if (c == '-') neg = true;
}
long res = 0;
for (; c >= '0' && c <= '9'; c = nextChar()) {
res = (res << 3) + (res << 1) + c - '0';
num *= 10;
}
return neg ? -res : res;
}
public double nextDouble() {
double cur = nextLong();
return c != '.' ? cur : cur + nextLong() / num;
}
public String next() {
StringBuilder res = new StringBuilder();
while (c <= 32) c = nextChar();
while (c > 32) {
res.append(c);
c = nextChar();
}
return res.toString();
}
public String nextLine() {
StringBuilder res = new StringBuilder();
while (c <= 32) c = nextChar();
while (c != '\n') {
res.append(c);
c = nextChar();
}
return res.toString();
}
public boolean hasNext() {
if (c > 32) return true;
while (true) {
c = nextChar();
if (c == NC) return false;
else if (c > 32) return true;
}
}
}
}
|
import java.util.*;
import java.io.*;
public class monstersandspells {
public static void main(String args[]) throws IOException {
FastScanner in = new FastScanner(System.in);
PrintWriter out = new PrintWriter(System.out);
/*
1
5
1 5 8 9 10
1 2 6 1 2
*/
int t = in.nextInt();
for ( ; t > 0; t--) {
int n = in.nextInt();
long[] times = new long[n];
long[] health = new long[n];
for (int i = 0; i < n; i++)
times[i] = in.nextLong();
for (int i = 0; i < n; i++)
health[i] = in.nextLong();
long small = 0;
long prev = 0;
long lastDamage = 0;
for (int i = 0; i < n; i++) {
long diff = times[i] - prev;
boolean use = true;
long delta = 0;
//System.out.println(i + " " + times[i] + " " + diff);
if (diff >= health[i]) {
delta += health[i];
long curr = health[i];
long lastTime = times[i];
for (int j = i + 1; j < n; j++) {
long increase = times[j] - lastTime;
//long power = damageOverTime(increase + curr, curr + 1);
if (curr + increase >= health[j]) {
curr += increase;
lastTime = times[j];
}
else {
delta += (health[j] - (curr + increase));
curr = health[j];
lastTime = times[j];
}
}
if (delta <= diff) {
use = true;
}
else
use = false;
}
else
use = false;
if (use) {
//System.out.println(damageOverTime(health[i], 1));
small += damageOverTime(delta, 1);
lastDamage = delta;
}
else {
small += damageOverTime((times[i] - prev) + lastDamage, lastDamage + 1);
lastDamage+=(times[i] - prev);
}
// System.out.println(use + " " + delta + " " + lastDamage + " " + small);
prev = times[i];
}
out.println(small);
}
out.close();
}
public static long damageOverTime(long endPower, long startPower) {
return triangleSum(endPower) - triangleSum(startPower - 1);
}
public static long triangleSum(long a) {
return a * (a + 1) / 2;
}
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(InputStream i) {
br = new BufferedReader(new InputStreamReader(i));
st = new StringTokenizer("");
}
public String next() throws IOException {
if (st.hasMoreTokens())
return st.nextToken();
else
st = new StringTokenizer(br.readLine());
return next();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}
| 0 |
Non-plagiarised
|
a3ebea91
|
f80f6d8d
|
// There are 𝑛 beautiful skyscrapers in New York, the height of the 𝑖-th one
// is ℎ𝑖. Today some villains have set on fire first 𝑛−1 of them, and now the
// only safety building is 𝑛-th skyscraper.
// Let's call a jump from 𝑖-th skyscraper to 𝑗-th (𝑖<𝑗) discrete, if all
// skyscrapers between are strictly lower or higher than both of them. Formally,
// jump is discrete, if 𝑖<𝑗 and one of the following conditions satisfied:
// 𝑖+1=𝑗 max(ℎ𝑖+1,…,ℎ𝑗−1)<min(ℎ𝑖,ℎ𝑗) max(ℎ𝑖,ℎ𝑗)<min(ℎ𝑖+1,…,ℎ𝑗−1). At
// the moment, Vasya is staying on the first skyscraper and wants to live a
// little longer, so his goal is to reach 𝑛-th skyscraper with minimal count of
// discrete jumps. Help him with calcualting this number.
// Input The first line contains a single integer 𝑛 (2≤𝑛≤3⋅105) — total amount
// of skyscrapers.
// The second line contains 𝑛 integers ℎ1,ℎ2,…,ℎ𝑛 (1≤ℎ𝑖≤109) — heights of
// skyscrapers.
// Output Print single number 𝑘 — minimal amount of discrete jumps. We can show
// that an answer always exists.
import java.io.*;
import java.util.*;
public class DiscreteCentrifugalJumps {
public static void solve(int n, int[] arr) {
int[] dp = new int[n]; // dp array
for (int i=1; i<n; i++) dp[i] = Integer.MAX_VALUE;
int[] lg = new int[n]; // first greater element from the left
int[] ll = new int[n]; // first smaller element from the left
int[] rg = new int[n]; // first greater element from the right
int[] rl = new int[n]; // first smaller element from the right
List<List<Integer>> jumps = new ArrayList<>(); // for each index i, use a list to record which places it can jump to
for (int i=0; i<n; i++) {
jumps.add(new ArrayList<Integer>());
}
// preprocessing
Stack<Pair<Integer, Integer>> stack = new Stack<>(); // each pair, first is height of skycraper, second is index in original array
for (int i=0; i<n; i++) {
while (!stack.isEmpty() && stack.peek().first < arr[i]) {
stack.pop();
}
if (stack.isEmpty()) lg[i] = -1;
else lg[i] = stack.peek().second; // ith building is first that is greater than s[-1].second building
stack.add(new Pair<Integer, Integer>(arr[i], i));
}
stack.clear();
for (int i=0; i<n; i++) {
while (!stack.isEmpty() && stack.peek().first > arr[i]) {
stack.pop();
}
if (stack.isEmpty()) ll[i] = -1;
else ll[i] = stack.peek().second;
stack.add(new Pair<Integer, Integer>(arr[i], i));
}
stack.clear();
for (int i=n-1; i>=0; i--) {
while (!stack.isEmpty() && stack.peek().first > arr[i]) {
stack.pop();
}
if (stack.isEmpty()) rg[i] = -1;
else rg[i] = stack.peek().second;
stack.add(new Pair<Integer, Integer>(arr[i], i));
}
stack.clear();
for (int i=n-1; i>=0; i--) {
while (!stack.isEmpty() && stack.peek().first < arr[i]) {
stack.pop();
}
if (stack.isEmpty()) rl[i] = -1;
else rl[i] = stack.peek().second;
stack.add(new Pair<Integer, Integer>(arr[i], i));
}
stack.clear();
// we construct the jumps list
for (int i = 0; i<n; i++) {
if (lg[i] != -1) jumps.get(lg[i]).add(i);
if (ll[i] != -1) jumps.get(ll[i]).add(i);
if (rg[i] != -1) jumps.get(i).add(rg[i]);
if (rl[i] != -1) jumps.get(i).add(rl[i]);
}
// dp
for (int i=0; i<n; i++) {
for (int j: jumps.get(i)) {
dp[j] = Math.min(dp[j], dp[i] + 1);
}
}
System.out.println(dp[n-1]);
}
public static void main(String[] args) throws IOException {
try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))){
int n = Integer.parseInt(br.readLine());
String[] s = br.readLine().split(" ");
int[] arr = new int[n];
for (int i=0; i<n; i++) {
arr[i] = Integer.parseInt(s[i]);
}
solve(n, arr);
}
}
}
class Pair<T1, T2> {
public T1 first;
public T2 second;
public Pair(T1 first, T2 second) {
this.first = first;
this.second = second;
}
}
|
import static java.lang.Math.min;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class D_2 {
public static void main(String[] args) throws Exception {
new D_2().go();
}
int USE_FILE = 0;
String INPUT = "5\r\n" +
"1 3 1 4 5\r\n" +
"";
void solve(int caseNr) {
int n = in.nextInt();
int[] h = na(n);
int[] dp = new int[n];
for (int i = 0; i < n; i++) {
dp[i] = inf;
}
dp[0] = 0;
// vector<pair<int, int>> st;
LinkedList<int[]> st = new LinkedList<>();
// lge[maxn], lle[maxn], rge[maxn], rle[maxn];
int[] lge = new int[n];
int[] lle = new int[n];
int[] rge = new int[n];
int[] rle = new int[n];
for (int i = 0; i < n; i++) { // the nearest greater from the left
while (!st.isEmpty() && st.getLast()[0] < h[i]) {
st.removeLast();
}
if (st.isEmpty()) {
lge[i] = -1;
} else {
lge[i] = st.getLast()[1];
}
st.add(new int[]{h[i], i});
}
st.clear();
for (int i = 0; i < n; i++) { // the nearest less from the left
while (!st.isEmpty() && st.getLast()[0] > h[i]) {
st.removeLast();
}
if (st.isEmpty()) {
lle[i] = -1;
} else {
lle[i] = st.getLast()[1];
}
st.add(new int[]{h[i], i});
}
st.clear();
for (int i = n - 1; i >= 0; i--) { // the nearest greater from the right
while (!st.isEmpty() && st.getLast()[0] < h[i]) {
st.removeLast();
}
if (st.isEmpty()) {
rge[i] = -1;
} else {
rge[i] = st.getLast()[1];
}
st.add(new int[]{h[i], i});
}
st.clear();
for (int i = n - 1; i >= 0; i--) { // the nearest less from the right
while (!st.isEmpty() && st.getLast()[0] > h[i]) {
st.removeLast();
}
if (st.isEmpty()) {
rle[i] = -1;
} else {
rle[i] = st.getLast()[1];
}
st.add(new int[]{h[i], i});
}
List<List<Integer>> jumps = new ArrayList<>();
for (int i = 0; i < n; i++) {
jumps.add(new ArrayList<>());
}
for (int i = 0; i < n; i++) {
if (rle[i] != -1) jumps.get(i).add(rle[i]);
if (rge[i] != -1) jumps.get(i).add(rge[i]);
if (lle[i] != -1) jumps.get(lle[i]).add(i);
if (lge[i] != -1) jumps.get(lge[i]).add(i);
}
for (int i = 0; i < n; i++) {
for (int to : jumps.get(i)) {
dp[to] = min(dp[to], dp[i] + 1);
}
}
// System.out.println(jumps);
System.out.println(dp[n - 1]);
return;
} // end of solve2
// ---------------------------------------------------------------------------------------------- //
void testCases() {
int t = 1;
for (int i=1; i<=t; i++) {
solve(i);
}
output_writer.flush();
}
// ---------------------------------------------------------------------------------------------- //
private int[] na(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) {
a[i] = in.nextInt();
}
return a;
}
private int inf = Integer.MAX_VALUE;
// ---------------------------------------------------------------------------------------------- //
// ---------------------------------------------------------------------------------------------- //
static boolean LOCAL = java.lang.System.getProperty("ONLINE_JUDGE") == null;
Scanner in;
PrintWriter output_writer = new PrintWriter(java.lang.System.out);
// the output musn't flush automatic or we time out
static class System {
static PrintWriter out = null;
}
void go() throws Exception {
System.out = output_writer;
if (LOCAL && USE_FILE == 0) {
// if not set expects input from terminal
java.lang.System.setIn(new ByteArrayInputStream(INPUT.getBytes()));
in = new Scanner(java.lang.System.in);
}
if (LOCAL && USE_FILE > 0) {
String filename = String.format("in/cf%d.txt", USE_FILE);
File inputFile = new File(filename);
in = new Scanner(inputFile);
output_writer.printf("[%s]\n", filename);
output_writer.flush();
}
if (!LOCAL) {
in = new Scanner(java.lang.System.in);
}
long startTime = java.lang.System.currentTimeMillis();
testCases();
if (LOCAL) {
java.lang.System.out.printf("[%dms]\n", java.lang.System.currentTimeMillis()-startTime);
}
in.close();
}
}
| 1 |
Plagiarised
|
8f6421f3
|
bdfe8110
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
public class Main{
public static void main (String[] args){
FastReader s = new FastReader();
int t=1;t=s.ni();
for(int test=1;test<=t;test++){
int n=s.ni(),k=s.ni();
int position[]=s.readArray(k),temp[]=s.readArray(k);
int ans[]=new int[n];
Arrays.fill(ans,Integer.MAX_VALUE/2);
for(int i=0;i<k;i++){
ans[position[i]-1]=temp[i];
}
for(int i=1;i<n;i++){
ans[i]=Math.min(ans[i-1]+1,ans[i]);
}
for(int i=n-2;i>=0;i--){
ans[i]=Math.min(ans[i],ans[i+1]+1);
}
for(int i=0;i<n;i++)
System.out.print(ans[i]+" ");
System.out.println();
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader(){
br = new BufferedReader(new InputStreamReader(System.in));}
int ni() { return Integer.parseInt(next()); }
long nl() { return Long.parseLong(next()); }
double nd() { return Double.parseDouble(next()); }
int[] readArray(int n){
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] =Integer.parseInt(next());
return a;
}
String next(){
while (st == null || !st.hasMoreElements()) {try {st = new StringTokenizer(br.readLine());}
catch (IOException e){e.printStackTrace();}}return st.nextToken();}
String nextLine(){String str = "";try {str = br.readLine();}catch (IOException e)
{e.printStackTrace();}return str;}
}
}
|
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.Collections;
import java.util.StringTokenizer;
public class E {
public static void main(String[] args) {
FastScanner fs=new FastScanner();
int T=fs.nextInt();
PrintWriter out=new PrintWriter(System.out);
for (int tt=0; tt<T; tt++) {
int n=fs.nextInt(), k=fs.nextInt();
int[] positions=fs.readArray(k), temps=fs.readArray(k);
int[] forced=new int[n];
Arrays.fill(forced, Integer.MAX_VALUE/2);
for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
for (int i=1; i<n; i++)
forced[i]=Math.min(forced[i], forced[i-1]+1);
for (int i=n-2; i>=0; i--)
forced[i]=Math.min(forced[i], forced[i+1]+1);
for (int i=0; i<n; i++) out.print(forced[i]+" ");
out.println();
}
out.close();
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
}
| 1 |
Plagiarised
|
42fe7dd0
|
9291ca83
|
import java.util.*;
public class Solution {
static Scanner sc=new Scanner(System.in);
public static void main(String args[]) {
int t=sc.nextInt();
outer:while(t-->0){
int n=sc.nextInt();
int[][] ct=new int[n][5];
int[] len=new int[n];
for (int i=0;i<n;i++) {
String s=sc.next();
len[i]=s.length();
for(char c:s.toCharArray()){
ct[i][c-'a']++;
}
}
int mx=0;
for (int i=0;i<5;i++) {
int[] diff=new int[n];
for (int j=0;j<n;j++) {
diff[j]=ct[j][i]-(len[j]-ct[j][i]);
}
Arrays.sort(diff);
int sum=0,inc=0;
for(int j=n-1;j>=0;j--){
sum+=diff[j];
if (sum>0) {
inc++;
}else {
break;
}
}
mx=Math.max(mx,inc);
}
System.out.println(mx);
}
}
}
|
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
public class Practice {
static HashMap<String, Integer> map = new HashMap<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-->0) {
int n = sc.nextInt();
int[][] occurances = new int[5][n];
for(int i=0;i<n;i++){
String s = sc.next();
int[] count = new int[5];
int len = s.length();
for(int j=0;j<s.length();j++){
count[s.charAt(j)-'a']++;
}
for(int j=0;j<5;j++){
occurances[j][i] = count[j] - (len-count[j]);
}
}
int ans = 0;
for(int i=0;i<5;i++){
Arrays.sort(occurances[i]);
int tmpAns = 0; int tmpSum=0;
for(int j=n-1;j>=0;j--){
tmpSum+=occurances[i][j];
if(tmpSum>0) tmpAns++;
else break;
}
ans = Math.max(ans, tmpAns);
}
System.out.println(ans);
}
}
}
| 1 |
Plagiarised
|
ba468e1f
|
ff34fab2
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Codeforces {
public static void main(String[] args) {
FastReader fastReader = new FastReader();
int t = fastReader.nextInt();
while (t-- > 0) {
int n = fastReader.nextInt();
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = fastReader.nextInt();
}
ArrayList<Integer> b = new ArrayList<>();
ArrayList<Integer> r = new ArrayList<>();
char c[] = fastReader.next().toCharArray();
for (int i = 0; i < n; i++) {
if (c[i] == 'B') {
b.add(a[i]);
} else {
r.add(a[i]);
}
}
Collections.sort(b);
Collections.sort(r);
int sizeb = b.size();
boolean isValid = true;
for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
if (b.get(j) < i){
isValid =false;
}
}
for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
if (r.get(j) > i){
isValid =false;
}
}
if (isValid){
System.out.println("YES");
}else{
System.out.println("NO");
}
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.io.*;
public class Div2 {
private static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static String solution(int [] arr, int n, String st)
{
ArrayList<Integer> red = new ArrayList<>();
ArrayList<Integer> blue = new ArrayList<>();
for(int i = 0; i<n; i++)
{
if(st.charAt(i)=='R')
red.add(arr[i]);
else
blue.add(arr[i]);
}
Collections.sort(red);
Collections.sort(blue);
int cb = 1;
for(int j = 0; j<blue.size(); j++)
{
if(blue.get(j)<cb)
return "NO";
cb++;
}
int cr = n;
for(int j = red.size()-1; j>=0; j--)
{
if(red.get(j)>cr)
return "NO";
cr--;
}
return "YES";
}
private static PrintWriter out = new PrintWriter(System.out);
public static void main (String[] args)
{
MyScanner s = new MyScanner();
int t = s.nextInt();
for(int j = 0; j<t ; j++)
{
int n = s.nextInt();
int[] arr = new int[n];
for(int i =0; i<n; i++)
arr[i] = s.nextInt();
String st = s.next();
out.println(solution(arr,n, st));
}
out.flush();
out.close();
}
}
| 0 |
Non-plagiarised
|
1480a727
|
a7d1ce58
|
/*
* Everything is Hard
* Before Easy
* Jai Mata Dii
*/
import java.util.*;
import java.io.*;
public class Main {
static class FastReader{ BufferedReader br;StringTokenizer st;public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}catch (IOException e){e.printStackTrace();}}return st.nextToken();}int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}String nextLine(){String str = ""; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; }}
static long mod = (long)(1e9+7);
// static long mod = 998244353;
// static Scanner sc = new Scanner(System.in);
static FastReader sc = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
public static void main (String[] args) {
int ttt = 1;
ttt = sc.nextInt();
z :for(int tc=1;tc<=ttt;tc++){
int n = sc.nextInt();
long d[] = new long[n];
for(int i=0;i<n;i++) {
d[i] = sc.nextLong();
}
long h[] = new long[n];
for(int i=0;i<n;i++) {
h[i] = sc.nextLong();
}
long req[] = new long[n];
for(int i=n-1;i>0;i--) {
long dif = d[i] - d[i-1];
long nxt = 0;
if(i+1<n) nxt = req[i+1];
long cur = Math.max(nxt, h[i]);
if(dif >= cur) {
req[i] = 0;
}
else {
req[i] = cur-dif;
}
// System.out.println(i+" "+req[i]);
}
long ans = 0, prev = 0;
for(int i=0;i<n;i++) {
if(i == 0) {
ans = ans + sumFrom(0, h[i]);
prev = h[i];
}
else {
if(req[i] == 0) {
ans = ans + sumFrom(0, h[i]);
prev = h[i];
}
else {
if(req[i]>prev) {
ans = ans + sumFrom(prev, req[i]);
ans = ans + sumFrom(req[i], req[i] + (d[i]-d[i-1]));
prev = req[i] + d[i] - d[i-1];
}
else {
ans = ans + sumFrom(prev, prev + (d[i]-d[i-1]));
prev = prev + d[i] - d[i-1];
}
}
}
}
out.write(ans+"\n");
}
out.close();
}
private static long sumFrom(long l, long cur) {
long is1 = (cur*(cur+1))/2;
long is2 = (l*(l+1))/2;
return is1 - is2;
}
static long pow(long a, long b){long ret = 1;while(b>0){if(b%2 == 0){a = (a*a)%mod;b /= 2;}else{ret = (ret*a)%mod;b--;}}return ret%mod;}
static long gcd(long a,long b){if(b==0) return a; return gcd(b,a%b); }
private static void sort(int[] a) {List<Integer> k = new ArrayList<>();for(int val : a) k.add(val);Collections.sort(k);for(int i=0;i<a.length;i++) a[i] = k.get(i);}
private static void ini(List<Integer>[] tre2){for(int i=0;i<tre2.length;i++){tre2[i] = new ArrayList<>();}}
private static void init(List<int[]>[] tre2){for(int i=0;i<tre2.length;i++){tre2[i] = new ArrayList<>();}}
private static void sort(long[] a) {List<Long> k = new ArrayList<>();for(long val : a) k.add(val);Collections.sort(k);for(int i=0;i<a.length;i++) a[i] = k.get(i);}
}
|
import java.util.*;
import java.io.*;
public class AiseHi {
static Scanner sc = new Scanner(System.in);
static int mod = (int)(1e9+7);
static int l;
static long dp[][];
public static void main (String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
z : while(t-->0) {
int n = sc.nextInt();
long dsasds[] = new long[n];
for(int i=0;i<n;i++) {
dsasds[i] = sc.nextLong();
}
long dsasdsuyuiyu[] = new long[n];
for(int i=0;i<n;i++) {
dsasdsuyuiyu[i] = sc.nextLong();
}
long dsasdsuyuiyubtrtr[] = new long[n];
for(int i=n-1;i>0;i--) {
long dif = dsasds[i] - dsasds[i-1];
long nxt = 0;
if(i+1<n) nxt = dsasdsuyuiyubtrtr[i+1];
long cur = Math.max(nxt, dsasdsuyuiyu[i]);
if(dif >= cur) {
dsasdsuyuiyubtrtr[i] = 0;
}
else {
dsasdsuyuiyubtrtr[i] = cur-dif;
}
// System.out.println(i+" "+dsasdsuyuiyubtrtr[i]);
}
long dsasdscsacsauyuiyubtrtr = 0, kokopmom = 0;
for(int i=0;i<n;i++) {
if(i == 0) {
dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(0, dsasdsuyuiyu[i]);
kokopmom = dsasdsuyuiyu[i];
}
else {
if(dsasdsuyuiyubtrtr[i] == 0) {
dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(0, dsasdsuyuiyu[i]);
kokopmom = dsasdsuyuiyu[i];
}
else {
if(dsasdsuyuiyubtrtr[i]>kokopmom) {
dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(kokopmom, dsasdsuyuiyubtrtr[i]);
dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(dsasdsuyuiyubtrtr[i], dsasdsuyuiyubtrtr[i] + (dsasds[i]-dsasds[i-1]));
kokopmom = dsasdsuyuiyubtrtr[i] + dsasds[i] - dsasds[i-1];
}
else {
dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(kokopmom, kokopmom + (dsasds[i]-dsasds[i-1]));
kokopmom = kokopmom + dsasds[i] - dsasds[i-1];
}
}
}
}
System.out.println(dsasdscsacsauyuiyubtrtr);
}
}
private static long sumFrom(long l, long cur) {
long is1 = (cur*(cur+1))/2;
long is2 = (l*(l+1))/2;
return is1 - is2;
}
private static long solve(int i, int k, int pre, int a[], int dsasds[]) {
if(i == a.length) {
int dsasdsuyuiyubtrtr = pre*(l-dsasds[i-1]);
return dsasdsuyuiyubtrtr;
}
if(dp[i][k]!=-1) return dp[i][k];
long cans = Integer.MAX_VALUE;
if(k>0) {
cans = 1L*pre*(dsasds[i]-dsasds[i-1]) + solve(i+1, k-1, pre, a, dsasds);
}
cans = Math.min(cans, 1L*pre*(dsasds[i]-dsasds[i-1]) + solve(i+1, k, a[i], a, dsasds));
return dp[i][k] = cans;
}
private static boolean same(char[] a, char[] b) {
for(int i=0;i<a.length;i++) {
if(a[i]!=b[i]) return false;
}
return true;
}
private static boolean isPos(List<long[]> val, long mid) {
for(int i=0;i<val.size();i++) {
for(int j=0;j<val.get(i).length-1;j++) {
if(val.get(i)[j]>=mid) return false;
mid = mid + 1;
}
}
return true;
}
static long fac[] = new long[100006];
static void precompute() {
int n = 100005;
fac[0] = 1;
for(int i=1;i<=n;i++)
fac[i] = (i * fac[i-1])%mod;
}
static long power(long base, long p, long mod2) {
long dsasdscsacsauyuiyubtrtr = 1;
while(p!=0) {
if(p%2==0) {
base = (base*base)%mod2;
p/=2;
}
else {
dsasdscsacsauyuiyubtrtr = (dsasdscsacsauyuiyubtrtr*base)%mod2;
p-=1;
}
}
return (int) (dsasdscsacsauyuiyubtrtr%mod2);
}
private static boolean checkl(char[] s, char t[]) {
int i=0, j =0;
while(i<s.length && j<t.length) {
if(s[i] == t[j]) {
j++;
}
i++;
}
return j==t.length;
}
static int gcd(long a,long b) { if(b==0) return (int) a; return gcd(b,a%b); }
private static int findn(int[] a, int l, int dsasdsuyuiyu, long m) {
int ret = -1;
while(l<=dsasdsuyuiyu) {
int mid = (l+dsasdsuyuiyu)/2;
if(a[mid]>m) {
dsasdsuyuiyu = mid-1;
}
else {
ret = mid;
l = mid+1;
}
}
return ret;
}
private static int find(int[] a, int l, int dsasdsuyuiyu, long m) {
int ret = -1;
while(l<=dsasdsuyuiyu) {
int mid = (l+dsasdsuyuiyu)/2;
if(a[mid]>=m) {
ret = mid;
dsasdsuyuiyu = mid-1;
}
else l = mid+1;
}
return ret;
}
private static boolean find(String ini, String a) {
return !KMPSearch(ini,a);
}
static boolean KMPSearch(String pat, String txt)
{
int M = pat.length();
int N = txt.length();
int lps[] = new int[M];
int j = 0;
computeLPSArray(pat, M, lps);
int i = 0;
while (i < N) {
if (pat.charAt(j) == txt.charAt(i)) {
j++;
i++;
}
if (j == M) {
j = lps[j - 1];
return true;
}
else if (i < N && pat.charAt(j) != txt.charAt(i)) {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
}
return false;
}
static void computeLPSArray(String pat, int M, int lps[])
{
int len = 0;
int i = 1;
lps[0] = 0; // lps[0] is always 0
// the loop calculates lps[i] for i = 1 to M-1
while (i < M) {
if (pat.charAt(i) == pat.charAt(len)) {
len++;
lps[i] = len;
i++;
}
else // (pat[i] != pat[len])
{
// This is tricky. Consider the example.
// AAACAAAA and i = 7. The idea is similar
// to search step.
if (len != 0) {
len = lps[len - 1];
// Also, note that we do not increment
// i here
}
else // if (len == 0)
{
lps[i] = len;
i++;
}
}
}
}
// private static boolean check(long n,long val) {
// if(n == 0) return true;
//
// while(val<=n) {
//// if(check(n-val,))
// }
// }
private static int find(int[] a, TreeMap<Integer, Integer> ts, int lp) {
int ret = 1;
int idx = -1;
for(int i=a.length-1;i>=0;i--) {
if(a[i] == lp) {
idx = i;
break;
}
}
idx--;
int kokopmom = lp;
while(idx>=0) {
if((kokopmom - a[idx]) >= lp) {
ret++;
kokopmom = a[idx];
}
idx--;
}
return ret;
}
private static void reverse(char[] s) {
char a[] = new char[s.length];
for(int i=0;i<s.length;i++) a[i] = s[i];
for(int i=0;i<s.length;i++)
s[i] = a[a.length-1-i];
}
private static boolean isPalindrome(char[] s) {
int n = s.length;
for(int i=0;i<n/2;i++)
if(s[i]!=s[n-1-i]) return false;
return true;
}
private static boolean is(char[] s) {
for(char c : s) if(c == '0') return false;
return true;
}
// static int ceil(int a,int b) {
// return a/b + (a%b==0?0:1);
// }
static boolean prime[] = new boolean[2000009];
// static int fac[] = new int[2000009];
static void sieve() {
prime[0] = true;
prime[1] = true;
int max = 1000000;
for(int i=2;i*i<=max;i++) {
if(!prime[i]) {
for(int j=i*i;j<=max;j+=i) {
prime[j] = true;
// fac[j] = i;
}
}
}
}
// static long gcd(long a,long b) { if(b==0) return a; return gcd(b,a%b); }
}
class DSU {
int par[];
int size[];
DSU(int n) {
par = new int[n];
size = new int[n];
Arrays.fill(size, 1);
for(int i=0;i<n;i++) par[i] = i;
}
int findPar(int x) {
if(x == par[x]) return x;
return par[x] = findPar(par[x]);
}
boolean join(int u,int v) {
int fu = findPar(u);
int fv = findPar(v);
if(fu!=fv) {
if(size[fu]>size[fv]) {
par[fv] = fu;
size[fu] += size[fv];
}
else {
par[fu] = fv;
size[fv] += size[fu];
}
return true;
}
else return false;
}
}
class pair{
long val;
char c;
pair(long val, char c){
this.val = val;
this.c = c;
}
}
| 1 |
Plagiarised
|
7de69858
|
b76bce8a
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.*;
import java.util.*;
public class A {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static void main(String args[]) {
if (System.getProperty("ONLINE_JUDGE") == null) {
// Input is a file
try {
System.setIn(new FileInputStream("input.txt"));
System.setOut(new PrintStream(new FileOutputStream("output.txt")));
} catch (Exception e) {
System.err.println("Error");
}
} else {
// Input is System.in
}
FastReader sc = new FastReader();
// Scanner sc = new Scanner(System.in);
//System.out.println(java.time.LocalTime.now());
StringBuilder sb = new StringBuilder();
int t = sc.nextInt();
while(t>0) {
int n = sc.nextInt();
long[] arr = new long[n];
long[] pow = new long[n];
for(int i = 0; i<n; i++)arr[i] = sc.nextLong();
for(int i = 0; i<n ;i++)pow[i] = sc.nextLong();
Pair[] p= new Pair[n];
for(int i = 0; i<n; i++){
Pair pp = new Pair(arr[i]-pow[i], arr[i]);
p[i] = pp;
}
long ans = 0;
Arrays.sort(p);
//System.out.println(Arrays.toString(p));
long prevEnd = -1;
long prevN = 0;
for(int i = 0; i<n; i++){
if(p[i].x >= prevEnd){
long nn = p[i].y-p[i].x;
ans+= ((nn)*(nn+1))/2;
prevEnd = p[i].y;
prevN = nn;
}else{
if(prevEnd < p[i].y){
long a = prevN+1;
long nn = p[i].y-prevEnd;
long sum = ((nn)*(2*a+(nn-1)))/2;
ans +=sum;
prevN = a+(nn-1);
prevEnd = p[i].y;
}
}
}
sb.append(ans+"\n");
t--;
}
System.out.println(sb);
}
}
class Pair implements Comparable<Pair>{
long x;
long y;
Pair(long x, long y){
this.x = x;
this.y = y;
}
// @Override
// public boolean equals(Object o) {
// if(this == o)return true;
// if(o == null || this.getClass() != o.getClass())return false;
// Pair p = (Pair)o;
// return x == p.x && y == p.y;
// }
// @Override
// public int hashCode(){
// return Objects.hash(x , y);
// }
@Override
public String toString() {
return "(" + x + ", " + y + ")";
}
@Override
public int compareTo(Pair o) {
return (int)this.x-(int)o.x;
}
}
|
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
public class MonstersAndSpells {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static void main(String[] args) throws IOException {
FastReader input = new FastReader();
BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
int t = input.nextInt();
while (t-- > 0) {
int n = input.nextInt();
long k[] = new long[n];
long h[] = new long[n];
long ans = 0;
for (int i = 0; i < n; i++) {
k[i] = input.nextInt();
}
for (int i = 0; i < n; i++) {
h[i] = input.nextInt();
}
for (int i = n-1; i >0; i--) {
long d = k[i]-k[i-1];
if(h[i-1]+d<h[i]){
h[i-1]+=(h[i]-(h[i-1]+d));
}
}
ans += (h[0]) * (h[0] + 1) / 2;
long last = h[0];
for (int i = 1; i < n; i++) {
if (k[i] - k[i - 1] >= h[i]) {
ans += (h[i]) * (h[i] + 1) / 2;
last = h[i];
} else {
long x = (k[i] - k[i - 1]);
long y = last + x;
long sum1 = (last) * (last + 1) / 2;
long sum2 = (y) * (y + 1) / 2;
ans += (sum2 - sum1);
last = y;
}
}
log.write(ans + "\n");
}
log.flush();
}
}
| 0 |
Non-plagiarised
|
565f77b7
|
856a8eda
|
import java.util.*;
import java.io.*;
public class Solution {
static Scanner scn = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
static StringBuilder sb = new StringBuilder();
public static void main(String[] HastaLaVistaLa) {
int t = scn.nextInt();
while(t-- > 0) solve();
out.println(sb);
out.close();
}
public static void solve() {
// Road To Specialist Day 3
int n = scn.nextInt(), m = scn.nextInt(), x = scn.nextInt();
int[] a = new int[n], ans = new int[n];
for(int i = 0; i < n; i++) a[i] = scn.nextInt();
PriorityQueue<Pair> pq = new PriorityQueue<>();
for(int i = 0; i < m; i++) pq.add(new Pair(0L, i));
for(int i = 0; i < n; i++) {
int e = a[i];
Pair p = pq.poll();
p.value += e;
pq.add(p);
ans[i] = p.id + 1;
}
boolean check = false;
long prev = pq.poll().value;
while(!pq.isEmpty()) {
long cur = pq.poll().value;
if(Math.abs(cur - prev) > x) check = true;
prev = cur;
}
if(check) sb.append("NO");
else {
sb.append("YES\n");
for(int i : ans) sb.append(i + " ");
}
sb.append("\n");
}
static class Pair implements Comparable<Pair> {
int id;
long value;
public Pair(long value, int id) {
this.id = id;
this.value = value;
}
public int compareTo(Pair o) {
return Long.compare(value, o.value);
}
}
}
|
/*input
2
5 2 3
1 2 3 1 2
4 3 3
1 1 2 3
*/
import java.io.*;
import java.util.*;
public class three{
public static class Pair implements Comparable<Pair>{
int min;
int idx;
@Override
public int compareTo(Pair o) {
return min - o.min;
}
}
public static void main(String[] args) throws Exception {
MyScanner scn = new MyScanner();
out = new PrintWriter(new BufferedOutputStream(System.out));
/*
int n = sc.nextInt(); // read input as integer
long k = sc.nextLong(); // read input as long
double d = sc.nextDouble(); // read input as double
String str = sc.next(); // read input as String
String s = sc.nextLine(); // read whole line as String
int result = 3*n;
out.println(result); // print via PrintWriter
*/
//The Code Starts here
int t = scn.nextInt();
while(t-- > 0){
int n = scn.nextInt();
int m = scn.nextInt();
int x = scn.nextInt();
int arr[] = scn.nextIntArray(n);
PriorityQueue<Pair> pq = new PriorityQueue<>();
System.out.println("YES");
for(int i=0;i<m;i++){
Pair p = new Pair();
p.min = arr[i];
p.idx = i+1;
pq.add(p);
System.out.print(p.idx + " ");
}
for(int i=m;i<n;i++){
Pair p = pq.peek();
int mini = p.min;
int index = p.idx;
System.out.print(index + " ");
pq.remove();
Pair np = new Pair();
np.min = arr[i] + mini;
np.idx = index;
pq.add(np);
}
System.out.println();
}
//The Code Ends here
out.close();
}
//-----------PrintWriter for faster output---------------------------------
public static PrintWriter out;
//-----------MyScanner class for faster input----------
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
public int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
public long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
public int[][] nextInt2DArray(int m, int n) {
int[][] arr = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
arr[i][j] = nextInt();
}
return arr;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
public static void debug(Object... o) {
System.out.println(Arrays.deepToString(o));
}
// public static class Pair implements Comparable<Pair> {
// long u;
// long v;
// public Pair(long u, long v) {
// this.u = u;
// this.v = v;
// }
// public int hashCode() {
// int hu = (int) (u ^ (u >>> 32));
// int hv = (int) (v ^ (v >>> 32));
// return 31 * hu + hv;
// }
// public boolean equals(Object o) {
// Pair other = (Pair) o;
// return u == other.u && v == other.v;
// }
// public int compareTo(Pair other) {
// return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
// }
// public String toString() {
// return "[u=" + u + ", v=" + v + "]";
// }
// }
//--------------------------------------------------------
}
| 0 |
Non-plagiarised
|
a0b406e6
|
c9b4bb51
|
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task();
int tcCnt = in.nextInt();
for (int tc = 1; tc <= tcCnt; tc++)
solver.solve(tc, in, out);
out.close();
}
static class Task {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
for (int mask = 1; mask < (int)(Math.pow(3, n)); mask++) {
int copy = mask;
int sum = 0;
for (int idx = 0; idx < n; idx++) {
int digit = copy % 3;
sum += digit == 0 ? 0 : digit == 1 ? a[idx] : -a[idx];
copy = copy / 3;
}
if (sum == 0) {
out.println("YES");
return;
}
}
out.println("NO");
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public String nextToken() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(nextLine());
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
public long nextLong() {
return Long.parseLong(nextToken());
}
public int[] nextIntArray(int size) {
int[] arr = new int[size];
for (int i = 0; i < size; i++) {
arr[i] = nextInt();
}
return arr;
}
}
}
|
import java.lang.*;
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
static void deal(int n,int[] arr) {
HashSet<Integer> hs = new HashSet<>();
int max = (int)Math.pow(3,n);
int[] sum = new int[max];
hs.add(0);
for(int i=1;i<max;i++) {
int s = 0;
int num = i;
int index = 0;
while(num>0) {
int d = num % 3;
num = num /3;
if(d==1) {
s+=arr[index];
} else if(d==2) {
s-=arr[index];
}
index++;
}
sum[i] = s;
if(s==0) {
out.println("YES");
return;
}
hs.add(sum[i]);
}
out.println("NO");
}
static int lowbit(int i) {
return i & (-i);
}
public static void main(String[] args) {
MyScanner sc = new MyScanner();
out = new PrintWriter(new BufferedOutputStream(System.out));
int t = sc.nextInt();
for(int i=0;i<t;i++) {
int n = sc.nextInt();
int[] arr = new int[n];
for(int j=0;j<n;j++) {
arr[j] = sc.nextInt();
}
deal(n,arr);
}
out.close();
}
//-----------PrintWriter for faster output---------------------------------
public static PrintWriter out;
//-----------MyScanner class for faster input----------
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
317a209c
|
3e6def38
|
import java.io.*;
import java.util.*;
public class D_Java {
public static final int MOD = 998244353;
public static int mul(int a, int b) {
return (int)((long)a * (long)b % MOD);
}
int[] f;
int[] rf;
public int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
}
public static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static void shuffleArray(int[] a) {
Random rnd = new Random();
for (int i = a.length-1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
int tmp = a[index];
a[index] = a[i];
a[i] = tmp;
}
}
public static int inv(int a) {
return pow(a, MOD-2);
}
public void doIt() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int k = Integer.parseInt(tok.nextToken());
f = new int[n+42];
rf = new int[n+42];
f[0] = rf[0] = 1;
for (int i = 1; i < f.length; ++i) {
f[i] = mul(f[i-1], i);
rf[i] = mul(rf[i-1], inv(i));
}
int[] events = new int[2*n];
for (int i = 0; i < n; ++i) {
tok = new StringTokenizer(in.readLine());
int le = Integer.parseInt(tok.nextToken());
int ri = Integer.parseInt(tok.nextToken());
events[i] = le*2;
events[i + n] = ri*2 + 1;
}
shuffleArray(events);
Arrays.sort(events);
int ans = 0;
int balance = 0;
for (int r = 0; r < 2*n;) {
int l = r;
while (r < 2*n && events[l] == events[r]) {
++r;
}
int added = r - l;
if (events[l] % 2 == 0) {
// Open event
ans += C(balance + added, k);
if (ans >= MOD) ans -= MOD;
ans += MOD - C(balance, k);
if (ans >= MOD) ans -= MOD;
balance += added;
} else {
// Close event
balance -= added;
}
}
in.close();
System.out.println(ans);
}
public static void main(String[] args) throws IOException {
(new D_Java()).doIt();
}
}
|
import java.io.*;
import java.util.*;
public class D_Java {
public static final int MOD = 998244353;
public static int mul(int a, int b) {
return (int)((long)a * (long)b % MOD);
}
int[] f;
int[] rf;
public int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
}
public static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static void shuffleArray(int[] a) {
Random rnd = new Random();
for (int i = a.length-1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
int tmp = a[index];
a[index] = a[i];
a[i] = tmp;
}
}
public static int inv(int a) {
return pow(a, MOD-2);
}
public void doIt() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int k = Integer.parseInt(tok.nextToken());
f = new int[n+42];
rf = new int[n+42];
f[0] = rf[0] = 1;
for (int i = 1; i < f.length; ++i) {
f[i] = mul(f[i-1], i);
rf[i] = mul(rf[i-1], inv(i));
}
int[] events = new int[2*n];
for (int i = 0; i < n; ++i) {
tok = new StringTokenizer(in.readLine());
int le = Integer.parseInt(tok.nextToken());
int ri = Integer.parseInt(tok.nextToken());
events[i] = le*2;
events[i + n] = ri*2 + 1;
}
shuffleArray(events);
Arrays.sort(events);
int ans = 0;
int balance = 0;
for (int r = 0; r < 2*n;) {
int l = r;
while (r < 2*n && events[l] == events[r]) {
++r;
}
int added = r - l;
if (events[l] % 2 == 0) {
// Open event
ans += C(balance + added, k);
if (ans >= MOD) ans -= MOD;
ans += MOD - C(balance, k);
if (ans >= MOD) ans -= MOD;
balance += added;
} else {
// Close event
balance -= added;
}
}
in.close();
System.out.println(ans);
}
public static void main(String[] args) throws IOException {
(new D_Java()).doIt();
}
}
| 1 |
Plagiarised
|
aa8091b0
|
ac180326
|
import java.util.*;
import java.io.*;
public class AiseHi {
static Scanner sc = new Scanner(System.in);
static int mod = (int)(1e9+7);
public static void main (String[] args) {
PrintWriter out = new PrintWriter(System.out);
int t = 1;
t = sc.nextInt();
z : while(t-->0) {
int n = sc.nextInt();
int m = sc.nextInt();
int x = sc.nextInt();
PriorityQueue<twoval> myQueue = new PriorityQueue<>();
for(int i=1;i<=m;i++) {
myQueue.add(new twoval(0,i));
}
List<twoval> arrayList = new ArrayList<>();
int myArray[] = new int[n];
for(int i=0;i<n;i++) {
int aasjd = sc.nextInt();
arrayList.add(new twoval(aasjd,i));
myArray[i] = aasjd;
}
Collections.sort(arrayList);
int ans[] = new int[n];
for(int i=n-1;i>=0;i--) {
twoval p = myQueue.poll();
long aasjd = p.myArray;
int idx = p.b;
aasjd += arrayList.get(i).myArray;
ans[arrayList.get(i).b] = idx;
myQueue.add(new twoval(aasjd,idx));
}
long dasdaknw[] = new long[m];
long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
for(int i=0;i<n;i++) {
dasdaknw[ans[i]-1] += myArray[i];
}
for(int i=0;i<m;i++) {
min = Math.min(min, dasdaknw[ans[i]-1]);
max = Math.max(max, dasdaknw[ans[i]-1]);
}
if(max-min>x) {
out.write("NO\n");
continue;
}
out.write("YES\n");
for(int aasjd : ans) out.write(aasjd+" ");
out.write("\n");
}
out.close();
}
static int ceil(int myArray,int b) {
return myArray/b + (myArray%b==0?0:1);
}
static boolean prime[] = new boolean[2000009];
static int fac[] = new int[2000009];
static void sieve() {
prime[0] = true;
prime[1] = true;
int max = 1000000;
for(int i=2;i*i<=max;i++) {
if(!prime[i]) {
for(int j=i*i;j<=max;j+=i) {
prime[j] = true;
fac[j] = i;
}
}
}
}
static int gcd(int myArray,int b) { if(b==0) return myArray; return gcd(b,myArray%b); }
}
class twoval implements Comparable<twoval>{
long myArray;
int b;
twoval(long aasjd,int r){
this.myArray = aasjd;
this.b = r;
}
public int compareTo(twoval o) {
return (int) (this.myArray - o.myArray);
}
}
|
//This code is written by प्रविण शंखपाळ
//package wizard;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;
import java.util.Queue;
import java.util.PriorityQueue;
import java.util.List;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
import java.util.Map;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;
public class Dobby {
public static void main(String[] args) {
try {
FastReader fr = new FastReader();
PrintWriter pt = new PrintWriter(System.out);
int t = fr.nextInt();
while (t > 0) {
int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
ArrayList<Pair> pp = new ArrayList<>();
int A[] = new int[n];
for (int i = 0; i < n; i++) {
A[i] = fr.nextInt();
Pair pr = new Pair(A[i], i);
pp.add(pr);
}
Collections.sort(pp);
Collections.reverse(pp);
int ps[] = new int[n];
int pk[] = new int[n];
Arrays.fill(ps, 0);
Arrays.fill(pk, 0);
int index = 0;
for (int i = 0; i < n; i++) {
if (pk[index] < x) {
pk[index] += pp.get(i).a;
}
ps[pp.get(i).b] = index + 1;
index++;
index = index == m ? 0 : index;
}
pt.println("YES");
for (int i = 0; i < n; i++) {
pt.print(ps[i] + " ");
}
pt.println();
t--;
}
pt.close();
} catch (
Exception e) {
return;
}
}
static void merge(long arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
long L[] = new long[n1];
long R[] = new long[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
static void sort(long arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
sort(arr, l, m);
sort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
static class Pair implements Comparable<Pair> {
int a, b;
Pair(int a, int b) {
this.a = a;
this.b = b;
}
public int compareTo(Pair o) {
// TODO Auto-generated method stub
if (this.a != o.a)
return Integer.compare(this.a, o.a);
else
return Integer.compare(this.b, o.b);
// return 0;
}
public boolean equals(Object o) {
if (o instanceof Pair) {
Pair p = (Pair) o;
return p.a == a && p.b == b;
}
return false;
}
}
static int binarySearch(int arr[], int first, int last, int key) {
int mid = (first + last) / 2;
while (first <= last) {
if (arr[mid] < key) {
first = mid + 1;
} else if (arr[mid] == key) {
return mid;
} else {
last = mid - 1;
}
mid = (first + last) / 2;
}
return -1;
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
0c1143f7
|
960a4c0f
|
import java.io.*;
import java.util.*;
public class E {
public static void main(String[] args) {
// TODO Auto-generated method stub
FastScanner sc = new FastScanner();
int t = sc.nextInt();
while(t-- > 0) {
int n = sc.nextInt();
int[] a = new int[n];
for(int i = 0 ; i< n ; i++) {
a[i] = sc.nextInt();
}
long oddMin = a[1];
long evenMin = a[0];
long res = (n * oddMin) + (n * evenMin);
long oddSum = a[1];
long evenSum = a[0];
for(int i = 2 ;i < n ; i++) {
if(i % 2 == 1) {
oddSum += a[i];
oddMin = Math.min(oddMin, a[i]);
}
else {
evenSum += a[i];
evenMin = Math.min(evenMin, a[i]);
}
int odd = (i + 1) / 2;
int even = (i / 2) + 1;
long minCostOdd = oddSum + oddMin*(n - odd);
long minCostEven = evenSum + evenMin*(n - even);
res = Math.min(res, minCostOdd + minCostEven);
}
System.out.println(res);
}
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
// Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
// worst case since it uses a version of quicksort. Although this would never
// actually show up in the real world, in codeforces, people can hack, so
// this is needed.
static void ruffleSort(int[] a) {
//ruffle
int n=a.length;
Random r=new Random();
for (int i=0; i<a.length; i++) {
int oi=r.nextInt(n), temp=a[i];
a[i]=a[oi];
a[oi]=temp;
}
//then sort
Arrays.sort(a);
}
}
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public final class C {
public static void main(String[] args) {
final FastScanner fs = new FastScanner();
final int t = fs.nextInt();
for (int test = 0; test < t; test++) {
final int n = fs.nextInt();
final int[] arr = fs.nextIntArray(n);
long evenSum = arr[0];
long oddSum = arr[1];
int minEven = arr[0];
int minOdd = arr[1];
long res = (long) n * arr[0] + (long) n * arr[1];
for (int i = 2; i < n; i++) {
if (i % 2 == 0) {
minEven = Math.min(minEven, arr[i]);
evenSum += arr[i];
final long eC = n - i / 2 - 1;
final long oC = n - i / 2;
final long curr = evenSum + eC * minEven + oddSum + oC * minOdd;
res = Math.min(res, curr);
} else {
minOdd = Math.min(minOdd, arr[i]);
oddSum += arr[i];
final long c = n - i / 2 - 1;
final long curr = oddSum + c * minOdd + evenSum + c * minEven;
res = Math.min(res, curr);
}
}
System.out.println(res);
}
}
static final class Utils {
private static class Shuffler {
private static void shuffle(int[] x) {
final Random r = new Random();
for (int i = 0; i <= x.length - 2; i++) {
final int j = i + r.nextInt(x.length - i);
swap(x, i, j);
}
}
private static void shuffle(long[] x) {
final Random r = new Random();
for (int i = 0; i <= x.length - 2; i++) {
final int j = i + r.nextInt(x.length - i);
swap(x, i, j);
}
}
private static void swap(int[] x, int i, int j) {
final int t = x[i];
x[i] = x[j];
x[j] = t;
}
private static void swap(long[] x, int i, int j) {
final long t = x[i];
x[i] = x[j];
x[j] = t;
}
}
public static void shuffleSort(int[] arr) {
Shuffler.shuffle(arr);
Arrays.sort(arr);
}
public static void shuffleSort(long[] arr) {
Shuffler.shuffle(arr);
Arrays.sort(arr);
}
private Utils() {}
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
private String next() {
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
//noinspection CallToPrintStackTrace
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
int[] nextIntArray(int n) {
final int[] a = new int[n];
for (int i = 0; i < n; i++) { a[i] = nextInt(); }
return a;
}
long[] nextLongArray(int n) {
final long[] a = new long[n];
for (int i = 0; i < n; i++) { a[i] = nextLong(); }
return a;
}
}
}
| 0 |
Non-plagiarised
|
10bbe9de
|
489930000000
|
import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
SolveQue solveQue = new SolveQue();
solveQue.ques();
}
}
class SolveQue {
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
private static final FastScanner fs = new FastScanner();
private static final Scanner sc = new Scanner(System.in);
private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
private static final long MOD = (long) (1e9 + 7);
private static PrintWriter out = new PrintWriter(System.out);
private static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
private static final int iInf = Integer.MAX_VALUE - (int) (1e6);
private static final long lInf = (long)(1e17);
private static int[] phi;
/** Optimal(Maximum,Minimum) Answers
* 1. Binary search
* 2. Prefix Suffix
* 3. Greedy (sorting searching)
* 4. DP
**/
long[] getP(long[] arr,int n) {
long mn = lInf;
long[] P = new long[n];
Arrays.fill(P,lInf);
long cnt = 0;
for(int i = 0 ; i < n; i++){
long curr = arr[i];
if(mn + cnt < curr){
P[i] = mn + cnt;
} else {
mn = arr[i];
P[i] = arr[i];
cnt = 0;
}
cnt++;
}
return P;
}
long[] getS(long[] arr,int n) {
long mn = lInf;
long[] S = new long[n];
Arrays.fill(S,lInf);
long cnt = 0;
for(int i = n - 1; i >= 0; i--){
long curr = arr[i];
if(mn + cnt < curr){
S[i] = mn + cnt;
}else{
mn = arr[i];
S[i] = arr[i];
cnt = 0;
}
cnt++;
}
return S;
}
void solve(int T) throws IOException {
int n = fs.nextInt();
int k = fs.nextInt();
int[] a = new int[k];
long[] t = new long[k];
long[] arr = new long[n];
Arrays.fill(arr,lInf);
for (int i = 0; i < k; i++) {
a[i] = fs.nextInt();
a[i]--;
}
for (int i = 0; i < k; i++) {
t[i] = fs.nextLong();
arr[a[i]] = t[i];
}
// Arrays.fill(arr,lInf);
long[] P = getP(arr, n);
// Arrays.fill(arr,lInf);
long[] S = getS(arr, n);
for(int i = 0 ; i < n ; i++){
System.out.print(Math.min(P[i],S[i]) + " ");
}
System.out.println();
}
void ques() throws IOException {
int t = 1;
// t = sc.nextInt();
t = fs.nextInt();
// t = Integer.parseInt(br.readLine());
int tt = 1;
while (t-- > 0) {
solve(tt);
tt++;
}
System.gc();
}
}
|
import java.io.*;
import java.util.*;
public class Codeforce {
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(
new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
if (cnt != 0) {
break;
} else {
continue;
}
}
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null)
return;
din.close();
}
}
static int mod = (int) (1e9 + 7);
public static class pair implements Comparator<pair> {
int x;
int y;
public pair() {
}
public pair(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compare(pair o1, pair o2) {
return o1.y - o2.y;
}
}
public static long modularpow(long a, long b) {
long res = 1;
if (b == 0)
return res;
else {
while (b > 0) {
if (b % 2 == 1) {
res *= a;
res %= mod;
}
a = a * a;
a %= mod;
b /= 2;
}
return res % mod;
}
}
public static int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
public static String binary(int a) {
String s1 = "";
while (a > 0) {
s1 = a % 2 + s1;
a /= 2;
}
return s1;
}
public static int Lower_Bound(long a[], int l, int r, long k) {
while (r - l > 1) {
int mid = l + (r - l) / 2;
if (a[mid] <= k) l = mid;
else
r = mid;
}
return l;
}
public static int Upper_Bound(int a[], int l, int r, int k) {
while (r - l > 1) {
int mid = (l + r) / 2;
if (a[mid] <= k)
l = mid;
else
r = mid;
}
return l + 1;
}
public static void main(String arg[]) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
StringBuilder sb = new StringBuilder();
while (t-- > 0) {
br.readLine();
String s[]=br.readLine().split(" ");
int n=Integer.parseInt(s[0]);
int k=Integer.parseInt(s[1]);
long a[]=new long[n];
long b[]=new long[n];
long c[]=new long[n];
Arrays.fill(c,Integer.MAX_VALUE);
String s1[]=br.readLine().split(" ");
s=br.readLine().split(" ");
for(int i=0;i<k;i++)
c[Integer.parseInt(s1[i])-1]=Integer.parseInt(s[i]);
long p=Integer.MAX_VALUE;
for(int i=0;i<n;i++)
{
p=Math.min(p+1,c[i]);
a[i]=p;
}
p=Integer.MAX_VALUE;
for(int i=n-1;i>=0;i--){
p=Math.min(p+1,c[i]);
b[i]=p;
}
for(int i=0;i<n;i++)
sb.append((Math.min(a[i],b[i]))+" ");
sb.append("\n");
}
System.out.println(sb);
}
}
| 0 |
Non-plagiarised
|
161b4a40
|
da5cf40b
|
import java.util.*;
import java.io.*;
public class Main{
static final Random random=new Random();
static long mod=1000000007L;
static HashMap<String,Integer>map=new HashMap<>();
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br=new BufferedReader(new InputStreamReader(System.in));
}
String next(){
while(st==null || !st.hasMoreTokens()){
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str="";
try {
str=br.readLine().trim();
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
int[] readIntArray(int n){
int[] res=new int[n];
for(int i=0;i<n;i++)res[i]=nextInt();
return res;
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append("" + object);
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
public static void main(String[] args) {
try {
FastReader in=new FastReader();
FastWriter out = new FastWriter();
int testCases=in.nextInt();
//int testCases=1;
while(testCases-- > 0){
solve(in);
}
out.close();
} catch (Exception e) {
return;
}
}
public static void solve( FastReader in){
int n=in.nextInt();
String s=in.next();
String t=in.next();
//int k=in.nextInt();
//long y=in.nextInt();
//long n=in.nextLong();
//int k=in.nextInt();
//long k=in.nextLong();
StringBuilder res=new StringBuilder();
char[] s1=s.toCharArray();
char[] t1=t.toCharArray();
int ans=n+2;
int[] cnt={0,0};
for(int i=0;i<n;i++){
if(s1[i]=='0' && t1[i]=='1'){
cnt[0]++;
}
if(s1[i]=='1' && t1[i]=='0'){
cnt[1]++;
}
}
if(cnt[0]==cnt[1])ans=Math.min(ans,cnt[0]+cnt[1]);
cnt[0]=cnt[1]=0;
for(int i=0;i<n;i++){
if(s1[i]=='0' && t1[i]=='0'){
cnt[0]++;
}
if(s1[i]=='1' && t1[i]=='1'){
cnt[1]++;
}
}
if(cnt[1]==cnt[0]+1){
ans=Math.min(ans,cnt[0]+cnt[1]);
}
if(ans>n){
res.append("-1");
}
else{
res.append(""+ans);
}
//int ans=x.size()+y.size();
//res.append(""+"Yes");
//res.append(""+"");
System.out.println(res.toString());
}
static int gcd(int a,int b){
if(b==0){
return a;
}
return gcd(b,a%b);
}
static void sort(int[] arr)
{
ArrayList<Integer> ls = new ArrayList<Integer>();
for(int x: arr)
ls.add(x);
Collections.sort(ls);
for(int i=0; i < arr.length; i++)
arr[i] = ls.get(i);
}
static void reversesort(int[] arr)
{
ArrayList<Integer> ls = new ArrayList<Integer>();
for(int x: arr)
ls.add(x);
Collections.sort(ls);
Collections.reverse(ls);
for(int i=0; i < arr.length; i++)
arr[i] = ls.get(i);
}
static int lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
static void debug(String x){
System.out.println(x);
}
static < E > void print(E res)
{
System.out.println(res);
}
static String rString(String s){
StringBuilder sb=new StringBuilder();
sb.append(s);
return sb.reverse().toString();
}
}
|
/***** ---> :) Vijender Srivastava (: <--- *****/
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
static FastReader sc =new FastReader();
static PrintWriter out=new PrintWriter(System.out);
static long mod=(long)1e9+7;
/* start */
public static void main(String [] args)
{
// int testcases = 1;
int testcases = i();
while(testcases-->0)
{
solve();
}
out.flush();
out.close();
}
static void solve()
{
int n = i();
char c[] = inputC();
char d[] = inputC();
int x01=0,x10=0,x00=0,x11=0;
for(int i=0;i<n;i++)
{
if(c[i]=='0'&&d[i]=='0')x00++;
if(c[i]=='0'&&d[i]=='1')x01++;
if(c[i]=='1'&&d[i]=='0')x10++;
if(c[i]=='1'&&d[i]=='1')x11++;
}
int ans = Integer.MAX_VALUE;
if(x01==0 && x10==0)
{
pl(0);
return ;
}
if(x11==x00+1)
{
ans = min(x11+x00,ans);
}
if(x01==x10)
{
ans = min(x01+x10,ans);
}
if(ans == Integer.MAX_VALUE){
ans = -1;
}
pl(ans);
}
/* end */
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
static void p(Object o)
{
out.print(o);
}
static void pl(Object o)
{
out.println(o);
}
static int i() {
return sc.nextInt();
}
static String s() {
return sc.next();
}
static long l() {
return sc.nextLong();
}
static char[] inputC()
{
String s = sc.nextLine();
return s.toCharArray();
}
static int[] input(int n) {
int A[]=new int[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextInt();
}
return A;
}
static long[] inputL(int n) {
long A[]=new long[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextLong();
}
return A;
}
static long[] putL(long a[]) {
long A[]=new long[a.length];
for(int i=0;i<a.length;i++) {
A[i]=a[i];
}
return A;
}
static String[] inputS(int n) {
String A[]=new String[n];
for(int i=0;i<n;i++) {
A[i]=sc.next();
}
return A;
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static int lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
static String reverse(String s) {
StringBuffer p=new StringBuffer(s);
p.reverse();
return p.toString();
}
static int min(int a,int b) {
return Math.min(a, b);
}
static int min(int a,int b,int c) {
return Math.min(a, Math.min(b, c));
}
static int min(int a,int b,int c,int d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static int max(int a,int b) {
return Math.max(a, b);
}
static int max(int a,int b,int c) {
return Math.max(a, Math.max(b, c));
}
static int max(int a,int b,int c,int d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long min(long a,long b) {
return Math.min(a, b);
}
static long min(long a,long b,long c) {
return Math.min(a, Math.min(b, c));
}
static long min(long a,long b,long c,long d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static long max(long a,long b) {
return Math.max(a, b);
}
static long max(long a,long b,long c) {
return Math.max(a, Math.max(b, c));
}
static long max(long a,long b,long c,long d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long sum(int A[]) {
long sum=0;
for(int i : A) {
sum+=i;
}
return sum;
}
static long sum(long A[]) {
long sum=0;
for(long i : A) {
sum+=i;
}
return sum;
}
static void print(int A[]) {
for(int i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static void print(long A[]) {
for(long i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static long mod(long x) {
return ((x%mod + mod)%mod);
}
static long power(long x, long y)
{
if(y==0)
return 1;
if(x==0)
return 0;
long res = 1;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) ;
y = y >> 1;
x = (x * x);
}
return res;
}
static boolean prime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
double sq=Math.sqrt(n);
for (int i = 5; i <= sq; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
static boolean prime(long n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
double sq=Math.sqrt(n);
for (int i = 5; i <= sq; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
static long[] sort(long a[]) {
ArrayList<Long> arr = new ArrayList<>();
for(long i : a) {
arr.add(i);
}
Collections.sort(arr);
for(int i = 0; i < arr.size(); i++) {
a[i] = arr.get(i);
}
return a;
}
static int[] sort(int a[])
{
ArrayList<Integer> arr = new ArrayList<>();
for(Integer i : a) {
arr.add(i);
}
Collections.sort(arr);
for(int i = 0; i < arr.size(); i++) {
a[i] = arr.get(i);
}
return a;
}
//pair class
private static class Pair implements Comparable<Pair> {
long first, second;
public Pair(long f, long s) {
first = f;
second = s;
}
@Override
public int compareTo(Pair p) {
if (first > p.first)
return 1;
else if (first < p.first)
return -1;
else {
if (second > p.second)
return 1;
else if (second < p.second)
return -1;
else
return 0;
}
}
}
}
| 0 |
Non-plagiarised
|
0b27be88
|
3f4a5b64
|
import java.util.*;
import java.io.*;
public class C {
static class Scan {
private byte[] buf=new byte[1024];
private int index;
private InputStream in;
private int total;
public Scan()
{
in=System.in;
}
public int scan()throws IOException
{
if(total<0)
throw new InputMismatchException();
if(index>=total)
{
index=0;
total=in.read(buf);
if(total<=0)
return -1;
}
return buf[index++];
}
public int scanInt()throws IOException
{
int integer=0;
int n=scan();
while(isWhiteSpace(n))
n=scan();
int neg=1;
if(n=='-')
{
neg=-1;
n=scan();
}
while(!isWhiteSpace(n))
{
if(n>='0'&&n<='9')
{
integer*=10;
integer+=n-'0';
n=scan();
}
else throw new InputMismatchException();
}
return neg*integer;
}
public double scanDouble()throws IOException
{
double doub=0;
int n=scan();
while(isWhiteSpace(n))
n=scan();
int neg=1;
if(n=='-')
{
neg=-1;
n=scan();
}
while(!isWhiteSpace(n)&&n!='.')
{
if(n>='0'&&n<='9')
{
doub*=10;
doub+=n-'0';
n=scan();
}
else throw new InputMismatchException();
}
if(n=='.')
{
n=scan();
double temp=1;
while(!isWhiteSpace(n))
{
if(n>='0'&&n<='9')
{
temp/=10;
doub+=(n-'0')*temp;
n=scan();
}
else throw new InputMismatchException();
}
}
return doub*neg;
}
public String scanString()throws IOException
{
StringBuilder sb=new StringBuilder();
int n=scan();
while(isWhiteSpace(n))
n=scan();
while(!isWhiteSpace(n))
{
sb.append((char)n);
n=scan();
}
return sb.toString();
}
private boolean isWhiteSpace(int n)
{
if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
return true;
return false;
}
}
public static void sort(int arr[],int l,int r) { //sort(arr,0,n-1);
if(l==r) {
return;
}
int mid=(l+r)/2;
sort(arr,l,mid);
sort(arr,mid+1,r);
merge(arr,l,mid,mid+1,r);
}
public static void merge(int arr[],int l1,int r1,int l2,int r2) {
int tmp[]=new int[r2-l1+1];
int indx1=l1,indx2=l2;
//sorting the two halves using a tmp array
for(int i=0;i<tmp.length;i++) {
if(indx1>r1) {
tmp[i]=arr[indx2];
indx2++;
continue;
}
if(indx2>r2) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
if(arr[indx1]<arr[indx2]) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
tmp[i]=arr[indx2];
indx2++;
}
//Copying the elements of tmp into the main array
for(int i=0,j=l1;i<tmp.length;i++,j++) {
arr[j]=tmp[i];
}
}
public static void sort(long arr[],int l,int r) { //sort(arr,0,n-1);
if(l==r) {
return;
}
int mid=(l+r)/2;
sort(arr,l,mid);
sort(arr,mid+1,r);
merge(arr,l,mid,mid+1,r);
}
public static void merge(long arr[],int l1,int r1,int l2,int r2) {
long tmp[]=new long[r2-l1+1];
int indx1=l1,indx2=l2;
//sorting the two halves using a tmp array
for(int i=0;i<tmp.length;i++) {
if(indx1>r1) {
tmp[i]=arr[indx2];
indx2++;
continue;
}
if(indx2>r2) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
if(arr[indx1]<arr[indx2]) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
tmp[i]=arr[indx2];
indx2++;
}
//Copying the elements of tmp into the main array
for(int i=0,j=l1;i<tmp.length;i++,j++) {
arr[j]=tmp[i];
}
}
public static void main(String args[]) throws IOException {
Scan input=new Scan();
StringBuilder ans=new StringBuilder("");
int test=input.scanInt();
for(int tt=1;tt<=test;tt++) {
int n=input.scanInt();
int m=input.scanInt();
int x=input.scanInt();
ans.append("YES\n");
TreeMap<Integer,Stack<Integer>> tm=new TreeMap<>();
for(int i=1;i<=m;i++) {
ans.append(i+" ");
int tmp=input.scanInt();
if(!tm.containsKey(tmp)) {
Stack<Integer> stck=new Stack<>();
stck.add(i);
tm.put(tmp, stck);
}
else {
Stack<Integer> stck=tm.get(tmp);
stck.add(i);
}
}
for(int i=m;i<n;i++) {
int tmp=input.scanInt();
int min=tm.firstKey();
Stack<Integer> stck=tm.get(min);
int indx=stck.pop();
ans.append(indx+" ");
if(stck.isEmpty()) {
tm.remove(min);
}
tmp+=min;
if(!tm.containsKey(tmp)) {
stck=new Stack<>();
stck.add(indx);
tm.put(tmp, stck);
}
else {
stck=tm.get(tmp);
stck.add(indx);
}
}
ans.append("\n");
}
System.out.println(ans);
}
}
|
import java.util.*;
import java.io.*;
public class C {
static class Scan {
private byte[] buf=new byte[1024];
private int index;
private InputStream in;
private int total;
public Scan()
{
in=System.in;
}
public int scan()throws IOException
{
if(total<0)
throw new InputMismatchException();
if(index>=total)
{
index=0;
total=in.read(buf);
if(total<=0)
return -1;
}
return buf[index++];
}
public int scanInt()throws IOException
{
int integer=0;
int n=scan();
while(isWhiteSpace(n))
n=scan();
int neg=1;
if(n=='-')
{
neg=-1;
n=scan();
}
while(!isWhiteSpace(n))
{
if(n>='0'&&n<='9')
{
integer*=10;
integer+=n-'0';
n=scan();
}
else throw new InputMismatchException();
}
return neg*integer;
}
public double scanDouble()throws IOException
{
double doub=0;
int n=scan();
while(isWhiteSpace(n))
n=scan();
int neg=1;
if(n=='-')
{
neg=-1;
n=scan();
}
while(!isWhiteSpace(n)&&n!='.')
{
if(n>='0'&&n<='9')
{
doub*=10;
doub+=n-'0';
n=scan();
}
else throw new InputMismatchException();
}
if(n=='.')
{
n=scan();
double temp=1;
while(!isWhiteSpace(n))
{
if(n>='0'&&n<='9')
{
temp/=10;
doub+=(n-'0')*temp;
n=scan();
}
else throw new InputMismatchException();
}
}
return doub*neg;
}
public String scanString()throws IOException
{
StringBuilder sb=new StringBuilder();
int n=scan();
while(isWhiteSpace(n))
n=scan();
while(!isWhiteSpace(n))
{
sb.append((char)n);
n=scan();
}
return sb.toString();
}
private boolean isWhiteSpace(int n)
{
if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
return true;
return false;
}
}
public static void sort(int arr[],int l,int r) { //sort(arr,0,n-1);
if(l==r) {
return;
}
int mid=(l+r)/2;
sort(arr,l,mid);
sort(arr,mid+1,r);
merge(arr,l,mid,mid+1,r);
}
public static void merge(int arr[],int l1,int r1,int l2,int r2) {
int tmp[]=new int[r2-l1+1];
int indx1=l1,indx2=l2;
//sorting the two halves using a tmp array
for(int i=0;i<tmp.length;i++) {
if(indx1>r1) {
tmp[i]=arr[indx2];
indx2++;
continue;
}
if(indx2>r2) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
if(arr[indx1]<arr[indx2]) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
tmp[i]=arr[indx2];
indx2++;
}
//Copying the elements of tmp into the main array
for(int i=0,j=l1;i<tmp.length;i++,j++) {
arr[j]=tmp[i];
}
}
public static void sort(long arr[],int l,int r) { //sort(arr,0,n-1);
if(l==r) {
return;
}
int mid=(l+r)/2;
sort(arr,l,mid);
sort(arr,mid+1,r);
merge(arr,l,mid,mid+1,r);
}
public static void merge(long arr[],int l1,int r1,int l2,int r2) {
long tmp[]=new long[r2-l1+1];
int indx1=l1,indx2=l2;
//sorting the two halves using a tmp array
for(int i=0;i<tmp.length;i++) {
if(indx1>r1) {
tmp[i]=arr[indx2];
indx2++;
continue;
}
if(indx2>r2) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
if(arr[indx1]<arr[indx2]) {
tmp[i]=arr[indx1];
indx1++;
continue;
}
tmp[i]=arr[indx2];
indx2++;
}
//Copying the elements of tmp into the main array
for(int i=0,j=l1;i<tmp.length;i++,j++) {
arr[j]=tmp[i];
}
}
public static void main(String args[]) throws IOException {
Scan input=new Scan();
StringBuilder ans=new StringBuilder("");
int test=input.scanInt();
for(int tt=1;tt<=test;tt++) {
int n=input.scanInt();
int m=input.scanInt();
int x=input.scanInt();
ans.append("YES\n");
TreeMap<Integer,Stack<Integer>> tm=new TreeMap<>();
for(int i=1;i<=m;i++) {
ans.append(i+" ");
int tmp=input.scanInt();
if(!tm.containsKey(tmp)) {
Stack<Integer> stck=new Stack<>();
stck.add(i);
tm.put(tmp, stck);
}
else {
Stack<Integer> stck=tm.get(tmp);
stck.add(i);
}
}
for(int i=m;i<n;i++) {
int tmp=input.scanInt();
int min=tm.firstKey();
Stack<Integer> stck=tm.get(min);
int indx=stck.pop();
ans.append(indx+" ");
if(stck.isEmpty()) {
tm.remove(min);
}
tmp+=min;
if(!tm.containsKey(tmp)) {
stck=new Stack<>();
stck.add(indx);
tm.put(tmp, stck);
}
else {
stck=tm.get(tmp);
stck.add(indx);
}
}
ans.append("\n");
}
System.out.println(ans);
}
}
| 1 |
Plagiarised
|
a4e39423
|
ba8800f5
|
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));
int n = readInt();
int arr[] = readIntarray();
ArrayList<Integer> a = new ArrayList<>();
ArrayList<Integer> b = new ArrayList<>();
for(int i = 0; i < n; i++){
if(arr[i] == 1){
a.add(i);
}else{
b.add(i);
}
}
if(a.size() == 0){
System.out.println("0");
return;
}
int [][] dp = new int[a.size()][b.size()];
for(int i = 0; i < a.size(); i++){
for(int j = i; j < b.size(); j++) {
if (j == 0) {
dp[i][j] = Math.abs(a.get(i) - b.get(j));
} else if (i == 0) {
dp[i][j] = Math.min(dp[i][j - 1], Math.abs(a.get(i) - b.get(j)));
} else if (i == j) {
dp[i][j] = dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j));
} else {
dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j)));
}
}
}
System.out.println(dp[a.size() - 1][b.size() - 1]);
}
static int readInt() throws IOException {
return Integer.parseInt(br.readLine());
}
static long readLong() throws IOException {
return Long.parseLong(br.readLine());
}
static int[] readIntarray() throws IOException {
String[] _a = br.readLine().split(" ");
int[] _res = new int[_a.length];
for (int i = 0; i < _a.length; i++) {
_res[i] = Integer.parseInt(_a[i]);
}
return _res;
}
static long[] readLongarray() throws IOException {
String[] _a = br.readLine().split(" ");
long[] _res = new long[_a.length];
for (int i = 0; i < _a.length; i++) {
_res[i] = Long.parseLong(_a[i]);
}
return _res;
}
}
|
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());
StringTokenizer st = new StringTokenizer(br.readLine());
int ar[] = new int[n];
for(int i = 0; i < n; i++){
ar[i] = Integer.parseInt(st.nextToken());
}
ArrayList<Integer> ones = new ArrayList<Integer>();
ArrayList<Integer> zeroes = new ArrayList<Integer>();
for(int i = 0; i < n; i++){
if(ar[i] == 1)
ones.add(i);
else
zeroes.add(i);
}
int r = ones.size();
int c = zeroes.size();
int time[][] = new int[r][c];
System.out.println(calculateTime(time, r, c, 0, 0, ones, zeroes));
}
public static int calculateTime(int time[][], int r, int c, int currR, int currC, ArrayList<Integer> ones, ArrayList<Integer> zeroes){
// System.out.println(currR + " " + currC);
if(currR == r)
return 0;
if(currC == c)
return (int)1e9;
if(time[currR][currC] != 0)
return time[currR][currC];
return time[currR][currC] = Math.min((calculateTime(time, r, c, currR + 1, currC + 1, ones, zeroes) + Math.abs(ones.get(currR) - zeroes.get(currC))), calculateTime(time, r, c, currR, currC + 1, ones, zeroes));
}
}
| 0 |
Non-plagiarised
|
3e6def38
|
548ffb07
|
import java.io.*;
import java.util.*;
public class D_Java {
public static final int MOD = 998244353;
public static int mul(int a, int b) {
return (int)((long)a * (long)b % MOD);
}
int[] f;
int[] rf;
public int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
}
public static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static void shuffleArray(int[] a) {
Random rnd = new Random();
for (int i = a.length-1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
int tmp = a[index];
a[index] = a[i];
a[i] = tmp;
}
}
public static int inv(int a) {
return pow(a, MOD-2);
}
public void doIt() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int k = Integer.parseInt(tok.nextToken());
f = new int[n+42];
rf = new int[n+42];
f[0] = rf[0] = 1;
for (int i = 1; i < f.length; ++i) {
f[i] = mul(f[i-1], i);
rf[i] = mul(rf[i-1], inv(i));
}
int[] events = new int[2*n];
for (int i = 0; i < n; ++i) {
tok = new StringTokenizer(in.readLine());
int le = Integer.parseInt(tok.nextToken());
int ri = Integer.parseInt(tok.nextToken());
events[i] = le*2;
events[i + n] = ri*2 + 1;
}
shuffleArray(events);
Arrays.sort(events);
int ans = 0;
int balance = 0;
for (int r = 0; r < 2*n;) {
int l = r;
while (r < 2*n && events[l] == events[r]) {
++r;
}
int added = r - l;
if (events[l] % 2 == 0) {
// Open event
ans += C(balance + added, k);
if (ans >= MOD) ans -= MOD;
ans += MOD - C(balance, k);
if (ans >= MOD) ans -= MOD;
balance += added;
} else {
// Close event
balance -= added;
}
}
in.close();
System.out.println(ans);
}
public static void main(String[] args) throws IOException {
(new D_Java()).doIt();
}
}
|
import java.io.*;
import java.util.*;
public class D_Java {
public static final int MOD = 998244353;
public static int mul(int a, int b) {
return (int)((long)a * (long)b % MOD);
}
int[] f;
int[] rf;
public int C(int n, int k) {
return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
}
public static int pow(int a, int n) {
int res = 1;
while (n != 0) {
if ((n & 1) == 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
static void shuffleArray(int[] a) {
Random rnd = new Random();
for (int i = a.length-1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
int tmp = a[index];
a[index] = a[i];
a[i] = tmp;
}
}
public static int inv(int a) {
return pow(a, MOD-2);
}
public void doIt() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int k = Integer.parseInt(tok.nextToken());
f = new int[n+42];
rf = new int[n+42];
f[0] = rf[0] = 1;
for (int i = 1; i < f.length; ++i) {
f[i] = mul(f[i-1], i);
rf[i] = mul(rf[i-1], inv(i));
}
int[] events = new int[2*n];
for (int i = 0; i < n; ++i) {
tok = new StringTokenizer(in.readLine());
int le = Integer.parseInt(tok.nextToken());
int ri = Integer.parseInt(tok.nextToken());
events[i] = le*2;
events[i + n] = ri*2 + 1;
}
shuffleArray(events);
Arrays.sort(events);
int ans = 0;
int balance = 0;
for (int r = 0; r < 2*n;) {
int l = r;
while (r < 2*n && events[l] == events[r]) {
++r;
}
int added = r - l;
if (events[l] % 2 == 0) {
// Open event
ans += C(balance + added, k);
if (ans >= MOD) ans -= MOD;
ans += MOD - C(balance, k);
if (ans >= MOD) ans -= MOD;
balance += added;
} else {
// Close event
balance -= added;
}
}
in.close();
System.out.println(ans);
}
public static void main(String[] args) throws IOException {
(new D_Java()).doIt();
}
}
| 1 |
Plagiarised
|
53551ea0
|
6be98ece
|
import java.util.*;
public class MyClass {
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
int tc=sc.nextInt();
while(tc>0)
{
int n=sc.nextInt();
int arr[]=new int[n];
int i,max=Integer.MIN_VALUE,min=Integer.MAX_VALUE;
for(i=0;i<n;i++)
{
arr[i]=sc.nextInt();
if(arr[i]>max)
max=arr[i];
if(arr[i]<min)
min=arr[i];
}
int low=min,high=max,mid,ans=min;
while(low<=high)
{
mid=(low+high)/2;
int temp[]=new int[n];
for(i=0;i<n;i++)
temp[i]=arr[i];
boolean flag=true;
for(i=n-1;i>=2;--i)
{
if(temp[i]<mid)
{
flag=false;
break;
}
int deli=Math.min(temp[i]-mid,arr[i]);
int ex=deli/3;
temp[i]=temp[i]-(3*ex);
temp[i-1]=temp[i-1]+(ex);
temp[i-2]=temp[i-2]+(2*ex);
}
if(temp[0]<mid || temp[1]<mid)
flag=false;
if(flag==true)
{
ans=mid;
low=mid+1;
}
else
high=mid-1;
}
System.out.println(ans);
--tc;
}}}
|
import java.util.*;
public class CF763C {
private static final int MAX = 1000000001;
private static final int MIN = 0;
public static final void main(String ...args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
int[] h = new int[n];
int i, b = MAX, e = MIN;
for (i = 0; i < n; i++) {
h[i] = sc.nextInt();
if (b > h[i])
b = h[i];
if (e < h[i])
e = h[i];
}
int[] s = new int[n];
int c, d, ans = b;
// System.out.println(b + " " + e);
while (b <= e) {
c = (b + e) / 2;
// System.out.println(c);
// sc.next();
for (i = 0; i < n; i++) {
s[i] = 0;
}
for (i = n - 1; i >= 2; i--) {
if (h[i] + s[i] < c) {
e = c - 1;
break;
} else {
d = Math.min(h[i], h[i] + s[i] - c) / 3;
s[i - 1] += d;
s[i - 2] += 2 * d;
}
}
// System.out.println(i);
if (i == 1) {
if (h[i] + s[i] < c || h[i - 1] + s[i - 1] < c) {
e = c - 1;
} else {
ans = c;
b = c + 1;
}
}
}
System.out.println(ans);
}
}
}
| 0 |
Non-plagiarised
|
8639f6c6
|
e18ae6a1
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
/**
* Created by dhruvthakker on 01/10/21 at 9:42 am
*/
public class Season2 {
static InputReader in = new InputReader();
static PrintWriter out = new PrintWriter(System.out);
public static void main(String args[]) {
int t = in.nextInt();
while (t-- > 0) {
int n = in.nextInt();
int air = in.nextInt();
Map<Integer, Integer> tempByIndex = new HashMap<>();
int inx[] = new int[air];
for (int i = 0; i < air; i++) {
int x = in.nextInt() - 1;
tempByIndex.put(x, 0);
inx[i] = x;
}
for (int i = 0; i < air; i++) {
tempByIndex.put(inx[i], in.nextInt());
}
long leftMax[] = new long[n];
long rightMax[] = new long[n];
leftMax[0] = tempByIndex.getOrDefault(0, Integer.MAX_VALUE);
rightMax[n - 1] = tempByIndex.getOrDefault(n - 1, Integer.MAX_VALUE);
for (int i = 1; i < n; i++) {
leftMax[i] = Math.min(leftMax[i - 1] + 1, tempByIndex.getOrDefault(i, Integer.MAX_VALUE));
rightMax[n - 1 - i] = Math.min(rightMax[n - i] + 1, tempByIndex.getOrDefault(n - 1 - i, Integer.MAX_VALUE));
}
for (int i = 0; i < n; i++) {
long ans = Math.min(leftMax[i], rightMax[i]);
out.print(ans + " ");
}
out.println();
}
out.flush();
}
static void debug(Object... o) {
System.out.println(Arrays.deepToString(o));
}
static class InputReader {
BufferedReader br;
StringTokenizer st;
public InputReader() {
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main
{
public static void main(String[] args)
{
FastScanner input = new FastScanner();
int tc = input.nextInt();
while (tc-- > 0) {
int n = input.nextInt();
int k = input.nextInt();
int a[] = new int[n+1];
int b[] = new int[k+1];
for (int i = 1; i <=k; i++) {
b[i] = input.nextInt();
}
Arrays.fill(a, Integer.MAX_VALUE);
for (int i = 1; i <=k; i++) {
int value = input.nextInt();
a[b[i]] = value;
}
// System.out.println(Arrays.toString(a));
long L[] = new long[n+1];
long R[] = new long[n+1];
Arrays.fill(L, Integer.MAX_VALUE);
Arrays.fill(R, Integer.MAX_VALUE);
long p = Integer.MAX_VALUE;
for (int i = 1; i <=n; i++) {
p = Math.min(p+1, a[i]);
L[i] = p;
}
p = Integer.MAX_VALUE;
for (int i = n; i >=1; i--) {
p = Math.min(p+1,a[i] );
R[i] = p;
}
// System.out.println(Arrays.toString(L));
// System.out.println(Arrays.toString(R));
long ans[] = new long[n+1];
for (int i = 1; i <=n; i++) {
ans[i] = Math.min(L[i], R[i]);
}
StringBuilder result = new StringBuilder();
for (int i = 1; i <=n; i++) {
result.append(ans[i]+" ");
}
System.out.println(result);
}
}
static class FastScanner
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next()
{
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine() throws IOException
{
return br.readLine();
}
}
}
| 0 |
Non-plagiarised
|
2722ef48
|
e9144440
|
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.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
CNotAssigning solver = new CNotAssigning();
int testCount = Integer.parseInt(in.next());
for (int i = 1; i <= testCount; i++)
solver.solve(i, in, out);
out.close();
}
static class CNotAssigning {
int N = 100010;
int M = N * 2;
int[] h;
int[] e = new int[M];
int[] ne = new int[M];
int idx;
int n;
int[] dep;
int[] res;
public void solve(int testNumber, InputReader in, OutputWriter out) {
n = in.nextInt();
h = new int[n + 1];
dep = new int[n + 1];
res = new int[n - 1];
Arrays.fill(h, -1);
idx = 0;
for (int i = 0; i < n - 1; i++) {
int a = in.nextInt();
int b = in.nextInt();
add(a, b);
add(b, a);
dep[a]++;
dep[b]++;
}
int start = 0;
for (int i = 1; i <= n; i++) {
if (dep[i] > 2) {
out.println(-1);
return;
}
if (dep[i] == 1) {
start = i;
}
}
dfs(start, start, 2);
out.println(res);
}
private void dfs(int u, int p, int num) {
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == p) {
continue;
}
res[i / 2] = num;
dfs(j, u, 7 - num);
}
}
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}
public void println(int[] array) {
print(array);
writer.println();
}
public void close() {
writer.close();
}
public void println(int i) {
writer.println(i);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return nextString();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
|
import java.util.Scanner;
public class C
{
static int N = 100010;
static int[] cot = new int[N];
static boolean[] vis = new boolean[N];
static int[] h = new int[N];
static int[] des = new int[2 * N], next = new int[2 * N];
static int idx = 0;
static int[] ans = new int[N];
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int round = in.nextInt();
for (int z = 0; z < round; z++)
{
int n = in.nextInt();
for (int i = 1; i <= n; i++)
{
h[i] = -1;
vis[i] = false;
cot[i] = 0;
}
idx = 0;
boolean flag = true;
for (int i = 1; i < n; i++)
{
int a = in.nextInt();
int b = in.nextInt();
des[idx] = b;
next[idx] = h[a];
h[a] = idx++;
des[idx] = a;
next[idx] = h[b];
h[b] = idx++;
if (++cot[a] >= 3 | ++cot[b] >= 3)
flag = false;
}
if (!flag)
System.out.println(-1);
else
{
int startPoint = -1;
for (int i = 1; i <= n; i++)
if (cot[i] == 1)
{
startPoint = i;
break;
}
dfs(startPoint, 3);
for (int i = 1; i < n; i++)
System.out.print(ans[i] + " ");
System.out.println();
}
}
}
private static void dfs(int point, int preLen)
{
vis[point] = true;
for (int i = h[point]; i != -1; i = next[i])
if (!vis[des[i]])
{
ans[i / 2 + 1] = 5 - preLen;
// System.out.println(point + ">" + des[i] + " " + ans[i / 2 + 1] + " " + (i / 2
// + 1));
dfs(des[i], ans[i / 2 + 1]);
}
}
}
| 0 |
Non-plagiarised
|
5e3089fa
|
aea245ba
|
//package Div2.C;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SetOrDecrease {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
while(t>0){
String []nk=br.readLine().split(" ");
int n=Integer.parseInt(nk[0]);
long k=Long.parseLong(nk[1]);
String []str=br.readLine().split(" ");
List<Integer> list=new ArrayList<>();
for(int i=0;i<n;i++)
list.add(Integer.parseInt(str[i]));
Collections.sort(list);
long sum=0;
for(int i=0;i<n;i++)
sum+=list.get(i);
if(sum<=k)
System.out.println(0);
else {
long minSteps = sum - k;
long drop=0;
long targetDrop = sum-k;
for (int i = n - 1; i > 0; i--) {
//assignment at ith element
drop += list.get(i) - list.get(0);
if (drop >= targetDrop) {
if (minSteps > n - i)
minSteps = n - i;
} else {
long diff = targetDrop - drop;
long div = diff / (n - i + 1);
long rem = diff % (n - i + 1);
long steps = rem > 0 ? (div + 1) + n - i : div + n - i;
if (minSteps > steps)
minSteps = steps;
}
}
System.out.println(minSteps);
}
t--;
}
}
}
|
import java.awt.image.AreaAveragingScaleFilter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class CF1 {
public static void main(String[] args) {
FastScanner sc=new FastScanner();
int T=sc.nextInt();
// int T=1;
for (int tt=0; tt<T; tt++){
int n = sc.nextInt();
long k = sc.nextLong();
int arr[]= sc.readArray(n);
sort(arr);
long sum=0L;
long ans=Integer.MAX_VALUE;
long min= (long)arr[0];
for (int i=0; i<n; i++){
sum+=arr[i];
}
if (sum<=k) System.out.println(0);
else {
long temp=sum;
long x=0L;
long y=0L;
for (int i=n-1; i>=1; i--){
temp=sum;
//2x +arr[i]-min
y++;
x+=arr[i];
temp-=x-y*min;
if (temp<=k) {
ans=Math.min(ans,y);
break;
}
else {
long b=(temp-k);
if (b%(y+1)==0){
b/=(y+1);
}
else {
b/=(y+1);
b++;
}
ans=Math.min(ans, y+b);
}
}
if (n==1){
ans=arr[0]-k;
}
ans= Math.min(ans, sum-k);
System.out.println(ans);
}
}
}
static long mod =998244353L;
static long power (long a, long b){
long res=1;
while (b>0){
if ((b&1)== 1){
res= (res * a % mod)%mod;
}
a=(a%mod * a%mod)%mod;
b=b>>1;
}
return res;
}
boolean[] sieveOfEratosthenes(int n)
{
boolean prime[] = new boolean[n+1];
for(int i=0;i<=n;i++)
prime[i] = true;
for(int p = 2; p*p <=n; p++)
{
if(prime[p] == true)
{
for(int i = p*p; i <= n; i += p)
prime[i] = false;
}
}
return prime;
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void sortLong(long[] a) {
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static long gcd (long n, long m){
if (m==0) return n;
else return gcd(m, n%m);
}
static class Pair implements Comparable<Pair>{
int x,y;
public Pair(int x, int y){
this.x = x;
this.y = y;
}
public int compareTo(Pair o){
return this.x-o.x;
}
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
}
| 0 |
Non-plagiarised
|
0017d438
|
ac180326
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class A {
static List<Integer> [] adj;
static ArrayList<Integer> temp;
static int mod = (int) 1e9+7;
static boolean[] vis = new boolean[(int)1e5];
static List<Integer> l = new ArrayList<>();
static final Reader s = new Reader();
public static void main(String[] args) throws IOException {
int t = s.nextInt();
// int t=1;
while(t-->0) {
int n = s.nextInt();
int m = s.nextInt();
int d = s.nextInt();
System.out.println("YES");
PriorityQueue<Pair> pq = new PriorityQueue<>();
for(int i=1;i<=m;i++){
pq.add(new Pair(i));
}
for(int i=0;i<n;i++){
int v = s.nextInt();
Pair p = pq.poll();
p.sum+=v;
pq.add(p);
System.out.print(p.id+" ");
}
System.out.println();
}
}
static class Pair implements Comparable<Pair> {
int id;
long sum=0;
public Pair(int id) {
this.id=id;
}
public int compareTo(Pair o) {
return Long.compare(sum, o.sum);
}
}
//Important
//Dont't stick on same approach
//Check long
static void dfs(int i){
vis[i]=true;
l.add(i);
List<Integer> Y = adj[i];
for(int x:Y){
if(!vis[x])dfs(x);
}
}
static long gcd(long a, long b) throws IOException {
return (b == 0) ? a : gcd(b, a % b);
}
static int gcd(int a, int b) throws IOException {
return (b == 0) ? a : gcd(b, a % b);
}
static void sortr(int[] a) {
ArrayList<Integer> l = new ArrayList<>();
for (int i : a)
l.add(i);
Collections.sort(l, Collections.reverseOrder());
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
static void sort(int[] a) {
ArrayList<Integer> l = new ArrayList<>();
for (int i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
static void sort(long[] a) {
ArrayList<Long> l = new ArrayList<>();
for (long i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
static class Reader {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
String next() {
while(st==null||!st.hasMoreTokens()) {
try {
st=new StringTokenizer(in.readLine());
} catch(Exception e) {}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
}
}
|
//This code is written by प्रविण शंखपाळ
//package wizard;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;
import java.util.Queue;
import java.util.PriorityQueue;
import java.util.List;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
import java.util.Map;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;
public class Dobby {
public static void main(String[] args) {
try {
FastReader fr = new FastReader();
PrintWriter pt = new PrintWriter(System.out);
int t = fr.nextInt();
while (t > 0) {
int n = fr.nextInt(), m = fr.nextInt(), x = fr.nextInt();
ArrayList<Pair> pp = new ArrayList<>();
int A[] = new int[n];
for (int i = 0; i < n; i++) {
A[i] = fr.nextInt();
Pair pr = new Pair(A[i], i);
pp.add(pr);
}
Collections.sort(pp);
Collections.reverse(pp);
int ps[] = new int[n];
int pk[] = new int[n];
Arrays.fill(ps, 0);
Arrays.fill(pk, 0);
int index = 0;
for (int i = 0; i < n; i++) {
if (pk[index] < x) {
pk[index] += pp.get(i).a;
}
ps[pp.get(i).b] = index + 1;
index++;
index = index == m ? 0 : index;
}
pt.println("YES");
for (int i = 0; i < n; i++) {
pt.print(ps[i] + " ");
}
pt.println();
t--;
}
pt.close();
} catch (
Exception e) {
return;
}
}
static void merge(long arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
long L[] = new long[n1];
long R[] = new long[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
static void sort(long arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
sort(arr, l, m);
sort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
static class Pair implements Comparable<Pair> {
int a, b;
Pair(int a, int b) {
this.a = a;
this.b = b;
}
public int compareTo(Pair o) {
// TODO Auto-generated method stub
if (this.a != o.a)
return Integer.compare(this.a, o.a);
else
return Integer.compare(this.b, o.b);
// return 0;
}
public boolean equals(Object o) {
if (o instanceof Pair) {
Pair p = (Pair) o;
return p.a == a && p.b == b;
}
return false;
}
}
static int binarySearch(int arr[], int first, int last, int key) {
int mid = (first + last) / 2;
while (first <= last) {
if (arr[mid] < key) {
first = mid + 1;
} else if (arr[mid] == key) {
return mid;
} else {
last = mid - 1;
}
mid = (first + last) / 2;
}
return -1;
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
464a03b8
|
cf27732e
|
import java.util.*;
public class Soltion{
public static void main(String []args){
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0){
int n = sc.nextInt();
Integer[] arr = new Integer[n];
for(int i=0;i<n;i++){
arr[i] = sc.nextInt();
}
String s = sc.next();
List<Integer> blue = new ArrayList<>();
List<Integer> red = new ArrayList<>();
for(int i=0;i<s.length();i++){
if(s.charAt(i)=='B'){
blue.add(arr[i]);
}
else{
red.add(arr[i]);
}
}
Collections.sort(blue);
Collections.sort(red);
int p=1,q=n;
boolean flag = true;
for(int i=red.size()-1;i>=0;i--){
if(red.get(i)>q){
flag = false;
break;
}
q--;
}
for(int i=0;i<blue.size();i++){
if(blue.get(i)<p){
flag = false;
break;
}
p++;
}
System.out.println(flag? "Yes" : "No");
}
}
}
|
import java.util.*;
import java.io.*;
public class code {
// remember long, to reformat ctrl + shift +f
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
public static void main(String[] args) throws Exception {
int t=sc.nextInt();
while(t-->0) {
int n=sc.nextInt();
int []vals=new int[n];
boolean numLine[]=new boolean[n+1];
for(int i=0;i<n;i++)vals[i]=sc.nextInt();
String s=sc.nextLine();
ArrayList<Integer>b=new ArrayList<Integer>();
ArrayList<Integer>r=new ArrayList<Integer>();
for(int i=0;i<n;i++) {
if(s.charAt(i)=='B' && vals[i]>0 )b.add(vals[i]);
else if( s.charAt(i)=='R' && vals[i]<=n)r.add(vals[i]);
}
Collections.sort(b);
Collections.sort(r);
int small=1;
for(int i=0;i<b.size();i++) {
int y=b.get(i);
if(y<small)continue;
numLine[small]=true;
small++;
}
// pw.println(Arrays.toString(numLine));
int large=n;
for(int i=r.size()-1;i>=0;i--) {
int y=r.get(i);
if(y>large)continue;
// y=Math.max(large, y);
numLine[large]=true;
large--;
}
//pw.print(Arrays.toString(numLine));
boolean can=true;
for(int i=1;i<=n;i++) {
if(numLine[i]==false) {
pw.println("no");
can=false;
break;
}
}
if(can)pw.println("yes");
}
pw.close();
}
// --------------------stuff ----------------------
static class pair implements Comparable<pair> {
int v;
int w;
public pair(int v,int w) {
this.v = v;
this.w = w;
}
public int compareTo(pair p) {
return this.w- p.w;// increasing order!!
//return Double.compare(v*w, p.w*p.v);
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public long[] nextlongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public Long[] nextLongArray(int n) throws IOException {
Long[] a = new Long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextIntArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public Integer[] nextIntegerArray(int n) throws IOException {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| 0 |
Non-plagiarised
|
45561f1f
|
cc9230d3
|
/**
* Created by Himanshu
**/
import java.util.*;
import java.io.*;
import java.math.*;
public class C1529 {
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(System.out);
Reader s = new Reader();
int t = s.i();
while (t-- > 0) {
int n = s.i();
pairLong [] arr = new pairLong[n];
for (int i=0;i<n;i++) {
long x = s.l() , y = s.l();
arr[i] = new pairLong(x,y);
}
ArrayList<Integer>[] tree = new ArrayList[n+1];
for (int i=0;i<=n;i++) tree[i] = new ArrayList<>();
for (int i=0;i<n-1;i++) {
int x = s.i() , y = s.i();
tree[x].add(y);
tree[y].add(x);
}
pairLong[] dp = new pairLong[n+1];
boolean [] vis = new boolean[n+1];
pairLong x = value(tree,arr,dp,1,vis);
out.println(Math.max(x.first,x.second));
}
out.flush();
}
private static pairLong value(ArrayList<Integer>[] tree , pairLong [] arr , pairLong [] dp , int in , boolean [] vis) {
if (dp[in] != null) return dp[in];
vis[in] = true;
long a = 0L , b = 0L;
for (int x : tree[in]) {
if (!vis[x]) {
pairLong y = value(tree,arr,dp,x,vis);
a += Math.max(Math.abs(arr[in-1].first-arr[x-1].first) + y.first,Math.abs(arr[in-1].first-arr[x-1].second) + y.second);
b += Math.max(Math.abs(arr[in-1].second-arr[x-1].first) + y.first,Math.abs(arr[in-1].second-arr[x-1].second) + y.second);
}
}
dp[in] = new pairLong(a,b);
return dp[in];
}
private static void bfs(ArrayList<Integer>[] tree , ArrayList<Integer> even ,
ArrayList<Integer> odd , int n) {
Queue<Integer> q = new LinkedList<>();
q.add(1);
int in = 0;
boolean [] vis = new boolean[n+1];
vis[1] = true;
while (!q.isEmpty()) {
Integer a = q.poll();
if (a == null) {
q.add(null);
in++;
} else {
if (in%2 == 0) even.add(a);
else odd.add(a);
for (int x : tree[a]) {
if (!vis[x]) {
q.add(x);
vis[x] = true;
}
}
}
if (q.size() == 0) break;
}
}
public static void shuffle(long[] arr) {
int n = arr.length;
Random rand = new Random();
for (int i = 0; i < n; i++) {
long temp = arr[i];
int randomPos = i + rand.nextInt(n - i);
arr[i] = arr[randomPos];
arr[randomPos] = temp;
}
}
private static int gcd(int a, int b) {
if(b == 0) return a;
return gcd(b,a%b);
}
public static long nCr(long[] fact, long[] inv, int n, int r, long mod) {
if (n < r)
return 0;
return ((fact[n] * inv[n - r]) % mod * inv[r]) % mod;
}
private static void factorials(long[] fact, long[] inv, long mod, int n) {
fact[0] = 1;
inv[0] = 1;
for (int i = 1; i <= n; ++i) {
fact[i] = (fact[i - 1] * i) % mod;
inv[i] = power(fact[i], mod - 2, mod);
}
}
private static long power(long a, long n, long p) {
long result = 1;
while (n > 0) {
if (n % 2 == 0) {
a = (a * a) % p;
n /= 2;
} else {
result = (result * a) % p;
n--;
}
}
return result;
}
private static long power(long a, long n) {
long result = 1;
while (n > 0) {
if (n % 2 == 0) {
a = (a * a);
n /= 2;
} else {
result = (result * a);
n--;
}
}
return result;
}
private static long query(long[] tree, int in, int start, int end, int l, int r) {
if (start >= l && r >= end) return tree[in];
if (end < l || start > r) return 0;
int mid = (start + end) / 2;
long x = query(tree, 2 * in, start, mid, l, r);
long y = query(tree, 2 * in + 1, mid + 1, end, l, r);
return x + y;
}
private static void update(int[] arr, long[] tree, int in, int start, int end, int idx, int val) {
if (start == end) {
tree[in] = val;
arr[idx] = val;
return;
}
int mid = (start + end) / 2;
if (idx > mid) update(arr, tree, 2 * in + 1, mid + 1, end, idx, val);
else update(arr, tree, 2 * in, start, mid, idx, val);
tree[in] = tree[2 * in] + tree[2 * in + 1];
}
private static void build(int[] arr, long[] tree, int in, int start, int end) {
if (start == end) {
tree[in] = arr[start];
return;
}
int mid = (start + end) / 2;
build(arr, tree, 2 * in, start, mid);
build(arr, tree, 2 * in + 1, mid + 1, end);
tree[in] = (tree[2 * in + 1] + tree[2 * in]);
}
static class Reader {
private InputStream mIs;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public Reader() {
this(System.in);
}
public Reader(InputStream is) {
mIs = is;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = mIs.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c)) c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String s() {
int c = read();
while (isSpaceChar(c)) c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long l() {
int c = read();
while (isSpaceChar(c)) c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int i() {
int c = read();
while (isSpaceChar(c)) c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public double d() throws IOException {
return Double.parseDouble(s());
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
public int[] arr(int n) {
int[] ret = new int[n];
for (int i = 0; i < n; i++) {
ret[i] = i();
}
return ret;
}
public long[] arrLong(int n) {
long[] ret = new long[n];
for (int i = 0; i < n; i++) {
ret[i] = l();
}
return ret;
}
}
static class pairLong implements Comparator<pairLong> {
long first, second;
pairLong() {
}
pairLong(long first, long second) {
this.first = first;
this.second = second;
}
@Override
public int compare(pairLong p1, pairLong p2) {
if (p1.first == p2.first) {
if(p1.second > p2.second) return 1;
else return -1;
}
if(p1.first > p2.first) return 1;
else return -1;
}
}
// static class pair implements Comparator<pair> {
// int first, second;
//
// pair() {
// }
//
// pair(int first, int second) {
// this.first = first;
// this.second = second;
// }
//
// @Override
// public int compare(pair p1, pair p2) {
// if (p1.first == p2.first) return p1.second - p2.second;
// return p1.first - p2.first;
// }
// }
}
|
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
public class C {
static int[][] lr = new int[2][(int)2e5+10];
static long[][] dp = new long[2][(int)2e5+10];
static ArrayList<ArrayList<Integer>> g;
public static void main(String[] args) {
FastReader fr = new FastReader();
PrintWriter out = new PrintWriter(System.out, true);
int cases = fr.nextInt();
for(int c = 0; c < cases; c++) {
int nodes = fr.nextInt();
g = new ArrayList<ArrayList<Integer>>();
for(int i = 1; i <= nodes; i++) {
lr[0][i] = fr.nextInt();
lr[1][i] = fr.nextInt();
}
for(int i = 0; i <= nodes; i++) {
g.add(new ArrayList<Integer>());
}
for(int i = 0; i < nodes-1; i++) {
int f = fr.nextInt();
int t = fr.nextInt();
g.get(f).add(t);
g.get(t).add(f);
}
DFS(1, -1);
out.write(Math.max(dp[0][1], dp[1][1]) + "\n");
}
out.close();
}
static void DFS(int v, int p) {
dp[0][v] = dp[1][v] = 0;
for(Integer u : g.get(v)) {
if (u == p) continue;
DFS(u, v);
dp[0][v] += Math.max(Math.abs(lr[0][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[0][v] - lr[0][u]));
dp[1][v] += Math.max(Math.abs(lr[1][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[1][v] - lr[0][u]));
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
this.br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try{
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble() { return Double.parseDouble(next()); }
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
169e34bf
|
c9159d9c
|
import java.util.*;
public class D{
static Scanner sc;
public static void solve(){
int n=sc.nextInt();
Integer a[]=new Integer[n];
int flag;
for(int i=0;i<n;i++) a[i]=sc.nextInt();
String s=sc.next();
ArrayList<Integer> x=new ArrayList<>();
ArrayList<Integer> y=new ArrayList<>();
for(int i=0;i<n;i++){
if(s.charAt(i)=='B') x.add(a[i]);
else y.add(a[i]);
}
Collections.sort(x);
Collections.sort(y);
int p=n;
int q=1;
for(int i=y.size()-1;i>=0;i--){
if(y.get(i)>p){System.out.println("NO"); return;}
p-=1;
}
for(int i=0;i<x.size();i++){
if(x.get(i)<q){System.out.println("NO"); return;}
q+=1;
}
System.out.println("YES");
}
public static void main(String args[]){
sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0) solve();
}
}
|
import java.util.*;
public class SolutionB {
public static long gcd(long a, long b){
if(b==0){
return a;
}
return gcd(b, a%b);
}
public static long gcdSum(long b){
long a = 0;
long temp = b;
while(temp!=0){
a = a + temp%10;
temp = temp/10;
}
return gcd(a,b);
}
public static class Pair{
Long a;
Long b;
public Pair(Long a, Long b) {
this.a = a;
this.b = b;
}
}
public static long factorial (long n){
if(n==0)
return 1;
else if(n==1)
return n;
return n * factorial(n-1);
}
public static long lcm (long n){
if(n<3)
return n;
return lcmForBig(n,n-1);
}
private static long lcmForBig(long n, long l) {
if(l==1)
return n;
n = (n * l) / gcd(n, l);
return lcmForBig(n, l-1);
}
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int t = s.nextInt();
for(int i =0;i<t;i++) {
int n = s.nextInt();
int arr [] = new int[n];
ArrayList<Integer> blue = new ArrayList<>();
ArrayList<Integer> red = new ArrayList<>();
for(int j=0;j<n;j++){
int num = s.nextInt();
arr[j]=num;
}
String color = s.next();
for(int j=0;j<n;j++){
if(color.charAt(j)=='B'){
blue.add(arr[j]);
}
else{
red.add(arr[j]);
}
}
Collections.sort(blue);
String ans = "YES";
int counter = 0;
for(int j=0;j<blue.size();j++){
int current = blue.get(j);
if (current<1){
ans="NO";
break;
}
if(current>counter){
counter++;
}
else{
ans="NO";
break;
}
}
if(ans=="NO"){
System.out.println(ans);
}
else{
int tempCounter = n+1;
Collections.sort(red);
for(int j=red.size()-1;j>=0;j--){
int current = red.get(j);
if(current>=tempCounter){
ans="NO";
break;
}
else{
tempCounter--;
}
}
if(tempCounter-counter!=1)
System.out.println("NO");
else
System.out.println(ans);
}
}
return;
}
}
| 0 |
Non-plagiarised
|
43855bfe
|
ddcadc64
|
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class O4 {
private static String solve(int n, int[] a) {
if (n == 2) {
return a[1] + " " + (-a[0]);
}
int res[] = new int[n];
if (n % 2 == 0) {
diagonalAlignment(a, res, n);
} else {
diagonalAlignment(a, res, n - 3);
if ( a[n - 3] + a[n - 2] != 0)
{
res[n - 1] = a[n - 3] + a[n - 2];
res[n - 2] = -a[n - 1];
res[n - 3] = -a[n - 1];
}
else if (a[n - 1] + a[n - 2] != 0){
res[n - 3] = a[n - 1] + a[n - 2];
res[n - 2] = -a[n - 3];
res[n - 1] = -a[n - 3];
}
else {
res[n - 2] = a[n - 1] + a[n - 3];
res[n - 1] = -a[n - 2];
res[n - 3] = -a[n - 2];
}
}
return formattedArray(res);
}
private static void diagonalAlignment(int[] a, int[] res, int n) {
for (int i = 0; i < n; i += 2) {
res[i + 1] = -a[i];
res[i] = a[i + 1];
}
}
public static void main(String[] args)
throws IOException {
Scanner s = new Scanner();
int t = 1;
t = s.nextInt();
StringBuilder ans = new StringBuilder();
int count = 0;
while (t-- > 0) {
int n = s.nextInt();
int a[] = new int[n];
getInputs(s, a, n);
ans.append(solve(n, a)).append("\n");
}
System.out.println(ans.toString());
}
static class Scanner {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Scanner() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Scanner(String file_name) throws IOException {
din = new DataInputStream(
new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
if (cnt != 0) {
break;
} else {
continue;
}
}
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null)
return;
din.close();
}
}
public static long norm(long a, long MOD) {
return ((a % MOD) + MOD) % MOD;
}
public static long msub(long a, long b, long MOD) {
return norm(norm(a, MOD) - norm(b, MOD), MOD);
}
public static long madd(long a, long b, long MOD) {
return norm(norm(a, MOD) + norm(b, MOD), MOD);
}
public static long mMul(long a, long b, long MOD) {
return norm(norm(a, MOD) * norm(b, MOD), MOD);
}
public static long mDiv(long a, long b, long MOD) {
return norm(norm(a, MOD) / norm(b, MOD), MOD);
}
public static String formattedArray(int a[]) {
StringBuilder res = new StringBuilder("");
for (int e : a)
res.append(e).append(" ");
return res.toString().trim();
}
private static void getInputs(Scanner s, int[] a, int n) throws IOException {
for (int i = 0; i < n; i++) {
a[i] = s.nextInt();
}
}
}
|
import java.util.Scanner;
public class D {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
int t = scn.nextInt();
StringBuilder sb = new StringBuilder();
while (t-- > 0) {
int n = scn.nextInt();
int[] arr = new int[n];
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = scn.nextInt();
}
if (n % 2 != 0) {
if (arr[n - 2] + arr[n - 3] == 0) {
ans[n - 3] = -2 * arr[n - 1];
ans[n - 2] = -arr[n - 1];
ans[n - 1] = arr[n - 2] + arr[n - 3] * 2;
} else {
ans[n - 3] = -arr[n - 1];
ans[n - 2] = -arr[n - 1];
ans[n - 1] = arr[n - 2] + arr[n - 3];
}
n -= 3;
}
for (int i = 0; i < n; i += 2) {
int div = 1;
if (arr[i] % 2 == 0 && arr[i + 1] % 2 == 0)
div = 2;
ans[i] = arr[i + 1] / div;
ans[i + 1] = -arr[i] / div;
}
for (int v : ans) {
sb.append(v);
sb.append(" ");
}
sb.append("\n");
}
System.out.println(sb);
}
}
| 0 |
Non-plagiarised
|
39098126
|
3bcd2014
|
import static java.lang.Integer.MAX_VALUE;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.exit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringTokenizer;
public class B {
static void solve() throws Exception {
int t=scanInt();
while (t-->0){
int n=scanInt();
int []arr=new int[n];
int low=Integer.MAX_VALUE;
int high=0;
for (int i=0;i<n;i++){
arr[i]=scanInt();
low=Math.min(low,arr[i]);
high=Math.max(high,arr[i]);
}
int ans=low;
while (low<=high){
int mid=low+(high-low)/2;
boolean flag=true;
int []temp=new int[n];
for (int i=0;i<n;i++){
temp[i]=arr[i];
}
for (int i=n-1;i>=2;i--){
if(temp[i]<mid){
flag=false;
break;
}
int rem=Math.min(temp[i]-mid,arr[i]);
int taken=rem/3;
temp[i]-=3*taken;
temp[i-1]+=taken;
temp[i-2]+=2*taken;
}
if(temp[0]<mid || temp[1]<mid){
flag=false;
}
if(flag){
low=mid+1;
ans=mid;
}else {
high=mid-1;
}
}
System.out.println(ans);
}
}
static int scanInt() throws IOException {
return parseInt(scanString());
}
static long scanLong() throws IOException {
return parseLong(scanString());
}
static String scanString() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
static BufferedReader in;
static PrintWriter out;
static StringTokenizer tok;
public static void main(String[] args) {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
in.close();
out.close();
} catch (Throwable e) {
e.printStackTrace();
exit(1);
}
}
}
|
import java.io.*;
import java.util.*;
import javax.sound.midi.MidiChannel;
public class Main {
static PrintWriter out;
static Kioken sc;
public static void main(String[] args) throws FileNotFoundException {
boolean t = true;
boolean f = false;
if (f) {
out = new PrintWriter("output.txt");
sc = new Kioken("input.txt");
} else {
out = new PrintWriter((System.out));
sc = new Kioken();
}
int tt = 1;
tt = sc.nextInt();
while (tt-- > 0) {
solve();
}
out.flush();
out.close();
}
static boolean bs(int[] arr, int a){
// out.println(" mid1 " + Arrays.toString(arr) + " " + a);
int[] curr = Arrays.copyOf(arr, arr.length);
for(int i = arr.length - 1; i >= 2; i--){
if(arr[i] < a){
return false;
}
int min = Math.min(arr[i] - a, curr[i]);
min = min/3;
arr[i] -= 3*min;
arr[i - 1] += min;
arr[i-2] += 2*min;
}
for(int i: arr){
if(i < a){
return false;
}
}
return true;
}
public static void solve() {
int n = sc.nextInt();
int[] arr = new int[n];
int max = Integer.MIN_VALUE;
for(int i = 0; i < n; i++){
arr[i] = sc.nextInt();
max = Math.max(max, arr[i]);
}
int l = 0, r = max, ans = 0;
while(l <= r){
int mid = (l+r)/2;
// out.println(" l r " + l + " " + r);
int[] aa = Arrays.copyOf(arr, arr.length);
if(bs(aa, mid)){
// out.println(Arrays.toString(arr) + " " + Arrays.toString(aa) + " mid " + mid );
ans = mid;
l = mid+1;
}else{
r = mid-1;
}
}
out.println(ans);
}
public static long leftShift(long a) {
return (long) Math.pow(2, a);
}
public static void reverse(int[] arr) {
Arrays.sort(arr);
int n = arr.length;
for (int i = 0; i < arr.length; i++) {
int temp = arr[i];
arr[i] = arr[n - 1 - i];
arr[n - 1 - i] = temp;
}
return;
}
public static int lower_bound(ArrayList<Integer> ar, int k) {
int s = 0, e = ar.size();
while (s != e) {
int mid = s + e >> 1;
if (ar.get(mid) <= k) {
s = mid + 1;
} else {
e = mid;
}
}
return Math.abs(s) - 1;
}
public static int upper_bound(ArrayList<Integer> ar, int k) {
int s = 0;
int e = ar.size();
while (s != e) {
int mid = s + e >> 1;
if (ar.get(mid) < k) {
s = mid + 1;
} else {
e = mid;
}
}
if (s == ar.size()) {
return -1;
}
return s;
}
static class Kioken {
// FileInputStream br = new FileInputStream("input.txt");
BufferedReader br;
StringTokenizer st;
Kioken(String filename) {
try {
FileReader fr = new FileReader(filename);
br = new BufferedReader(fr);
st = new StringTokenizer("");
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
Kioken() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer("");
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
public String next() {
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
try {
return br.readLine();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public boolean hasNext() {
String next = null;
try {
next = br.readLine();
} catch (Exception e) {
}
if (next == null || next.length() == 0) {
return false;
}
st = new StringTokenizer(next);
return true;
}
}
}
| 0 |
Non-plagiarised
|
38129877
|
7493a104
|
//package practice.codeforces.round763;
import java.util.Scanner;
public class C {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int t = scanner.nextInt();
while (t-- > 0) {
int n = scanner.nextInt();
int[] h = new int[n];
for (int i = 0; i < n; i++) {
h[i] = scanner.nextInt();
}
System.out.println(binSearchSolution(h));
}
}
private static int binSearchSolution(int[] a) {
int l = 0;
int r = (int)1e9 + 1;
while (l < r - 1) {
int m = l + (r - l) / 2;
if (canAchieve(a, m)) {
l = m;
} else {
r = m;
}
}
return l;
}
private static boolean canAchieve(int[] a, int min) {
int back1 = a[a.length - 2];
int current = a[a.length - 1];
int nextIndex = a.length - 3;
while (nextIndex >= 0) {
int back2 = a[nextIndex];
if (current < min) {
return false;
}
int canMove = Math.min(current - min, a[nextIndex + 2]);
int d = canMove / 3;
current = back1 + d;
back1 = back2 + 2 * d;
nextIndex--;
}
if (current < min || back1 < min) {
return false;
}
return true;
}
}
|
import java.util.Scanner;
public class C {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int t = scanner.nextInt();
while (t-- > 0) {
int n = scanner.nextInt();
int[] h = new int[n];
for (int i = 0; i < n; i++) {
h[i] = scanner.nextInt();
}
System.out.println(binSearchSolution(h));
}
}
private static int binSearchSolution(int[] a) {
int l = 0;
int r = (int)1e9 + 1;
while (l < r - 1) {
int m = l + (r - l) / 2;
if (canAchieve(a, m)) {
l = m;
} else {
r = m;
}
}
return l;
}
private static boolean canAchieve(int[] a, int min) {
int back1 = a[a.length - 2];
int current = a[a.length - 1];
int nextIndex = a.length - 3;
while (nextIndex >= 0) {
int back2 = a[nextIndex];
if (current < min) {
return false;
}
int canMove = Math.min(current - min, a[nextIndex + 2]);
int d = canMove / 3;
current = back1 + d;
back1 = back2 + 2 * d;
nextIndex--;
}
if (current < min || back1 < min) {
return false;
}
return true;
}
}
| 1 |
Plagiarised
|
4138b081
|
f729338f
|
import java.io.*;
import java.util.*;
public class Contest1627C
{
static class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
String next() { // reads in the next string
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() { // reads in the next int
return Integer.parseInt(next());
}
public long nextLong() { // reads in the next long
return Long.parseLong(next());
}
public double nextDouble() { // reads in the next double
return Double.parseDouble(next());
}
}
static InputReader r = new InputReader(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static long mod = 1000000007; static ArrayList<Integer>[] adj; static ArrayList<Integer>[] num; static int[] ans;
public static void main(String[] args)
{
int t = r.nextInt();
while (t > 0)
{
t--;
int n = r.nextInt();
adj = new ArrayList[n];
num = new ArrayList[n];
for (int i = 0; i < n; i ++)
{
adj[i] = new ArrayList<Integer>();
num[i] = new ArrayList<Integer>();
}
int[] deg = new int[n];
boolean flag = false;
for (int i = 0; i < n - 1; i ++)
{
int a = r.nextInt()-1;
int b = r.nextInt()-1;
adj[a].add(b);
adj[b].add(a);
num[a].add(i);
num[b].add(i);
deg[a] ++;
deg[b] ++;
if (deg[a] > 2 || deg[b] > 2)
{
flag = true;
}
}
if (flag)
{
pw.println(-1);
continue;
}
ans = new int[n];
for (int i = 0; i < n; i ++)
{
if (deg[i] == 1)
{
dfs(i,3,-1);
}
}
for (int i = 0; i < n - 1; i ++)
{
pw.println(ans[i]);
}
}
pw.close();
}
static void dfs(int node, int x, int p)
{
for (int j = 0; j < adj[node].size(); j ++)
{
int i = adj[node].get(j);
if (i == p)
{
continue;
}
ans[num[node].get(j)] = x;
dfs(i,5-x,node);
}
}
}
|
import java.io.*;
import java.util.*;
public class Solution{
public static class Edge
{
int index; int u, v;
Edge(int u, int v, int index)
{
this.index=index;
this.u = u;
this.v = v;
}
}
public static void main (String[] args) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb=new StringBuilder();
int t=Integer.parseInt(br.readLine());
while(t-->0)
{
int n=Integer.parseInt(br.readLine());
ArrayList<Edge> graph[] = new ArrayList[n];
for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
for(int i=0; i<n-1; i++)
{
StringTokenizer st=new StringTokenizer(br.readLine());
int u = Integer.parseInt(st.nextToken());
int v = Integer.parseInt(st.nextToken());
u--; v--;
graph[u].add(new Edge(u,v,i));
graph[v].add(new Edge(v,u,i));
}
int start_i = 0;
boolean poss = true;
for(int i =0; i<n; i++)
{
if(graph[i].size()>2)
{
poss = false;
}
else if(graph[i].size() == 1) start_i = i;
}
if(!poss)
{
sb.append("-1\n");
continue;
}
int wts[] = new int[n-1];
ArrayList<Edge> edges = new ArrayList<>();
Edge first = graph[start_i].get(0);
wts[first.index] = 2;
edges = graph[first.v];
while(edges.size()>1)
{
Edge firste = edges.get(0);
Edge sece = edges.get(1);
if(wts[firste.index] != 0 ) //second not visited
{
wts[sece.index] = 5 - wts[firste.index];
edges = graph[sece.v];
}
else //first not visited
{
wts[firste.index] = 5 - wts[sece.index];
edges = graph[firste.v];
}
}
for(int i=0; i<n-1; i++)
sb.append(wts[i]+" ");
sb.append("\n");
}
System.out.println(sb);
}
}
| 0 |
Non-plagiarised
|
5e8d1aaa
|
c4d04ce7
|
import java.io.*;
import java.util.*;
/*
*/
public class E {
static FastReader sc=null;
static long max=(long)1e15+7;
public static void main(String[] args) {
sc=new FastReader();
PrintWriter out=new PrintWriter(System.out);
int t=sc.nextInt();
while(t-->0) {
int n=sc.nextInt(),k=sc.nextInt();
int a[]=sc.readArray(k),te[]=sc.readArray(k);
int curr[]=new int[n];
Arrays.fill(curr, -1);
for(int i=0;i<k;i++) {
a[i]--;
curr[a[i]]=te[i];
}
long min=max;
long ts[]=new long[n];
Arrays.fill(ts, max);
for(int i=n-1;i>=0;i--) {
if(curr[i]!=-1) {
min=Math.min(min, curr[i]+i);
}
ts[i]=Math.min(ts[i], min-i);
}
min=max;
for(int i=0;i<n;i++) {
if(curr[i]!=-1) {
min=Math.min(min, curr[i]-i);
}
ts[i]=Math.min(ts[i], min+i);
}
for(long e:ts)out.print(e+" ");
out.println();
}
out.close();
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
int[] readArray(int n) {
int a[]=new int [n];
for(int i=0;i<n;i++) {
a[i]=sc.nextInt();
}
return a;
}
}
}
|
import java.io.*;
import java.util.*;
/*
*/
public class E {
static FastReader sc=null;
static long nax=(long)1e15+7;
public static void main(String[] args) {
sc=new FastReader();
PrintWriter out=new PrintWriter(System.out);
int test=sc.nextInt();
while(test-->0) {
int n=sc.nextInt(),k=sc.nextInt();
int a[]=sc.readArray(k),t[]=sc.readArray(k);
int present[]=new int[n];
Arrays.fill(present, -1);
for(int i=0;i<k;i++) {
a[i]--;
present[a[i]]=t[i];
}
long min=nax;
long temps[]=new long[n];
Arrays.fill(temps, nax);
for(int i=n-1;i>=0;i--) {
if(present[i]!=-1) {
min=Math.min(min, present[i]+i);
}
temps[i]=Math.min(temps[i], min-i);
}
min=nax;
for(int i=0;i<n;i++) {
if(present[i]!=-1) {
min=Math.min(min, present[i]-i);
}
temps[i]=Math.min(temps[i], min+i);
}
for(long e:temps)out.print(e+" ");
out.println();
}
out.close();
}
static class Pair implements Comparable<Pair>{
int id,t;
Pair(int id,int t){
this.id=id;
this.t=t;
}
@Override
public int compareTo(Pair o) {
return this.id-o.id;
}
}
static int[] ruffleSort(int a[]) {
ArrayList<Integer> al=new ArrayList<>();
for(int i:a)al.add(i);
Collections.sort(al);
for(int i=0;i<a.length;i++)a[i]=al.get(i);
return a;
}
static void print(int a[]) {
for(int e:a) {
System.out.print(e+" ");
}
System.out.println();
}
static class FastReader{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while(!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
}
catch(IOException e){
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
int[] readArray(int n) {
int a[]=new int[n];
for(int i=0;i<n;i++)a[i]=sc.nextInt();
return a;
}
}
}
| 1 |
Plagiarised
|
2bbc6c80
|
4e58558c
|
import java.io.*;
import java.util.*;
public class Main {
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st;
static String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
static int readInt() throws IOException {
return Integer.parseInt(next());
}
static long readLong() throws IOException {
return Long.parseLong(next());
}
static double readDouble() throws IOException {
return Double.parseDouble(next());
}
static char readChar() throws IOException {
return next().charAt(0);
}
static String readLine() throws IOException {
return br.readLine();
}
static class Pair implements Comparable<Pair> {
int f, s;
Pair(int f, int s) {
this.f = f; this.s = s;
}
public int compareTo(Pair other) {
if (this.f != other.f) return this.f - other.f;
return this.s - other.s;
}
}
static List<Integer> adj[];
static int n, a[][];
static long dp[][];
static void DFS(int v, int p) {
for (int u : adj[v]) {
if (u != p) {
DFS(u, v);
for (int i = 0; i <= 1; ++i) {
long add = 0;
for (int j = 0; j <= 1; ++j)
add = Math.max(add, dp[u][j] + Math.abs(a[v][i] - a[u][j]));
dp[v][i] += add;
}
}
}
}
public static void main(String[] args) throws IOException {
for (int t = readInt(); t > 0; --t) {
n = readInt();
adj = new List[n + 1];
for (int i = 1; i <= n; ++i)
adj[i] = new ArrayList();
a = new int[n + 1][2];
for (int i = 1; i <= n; ++i) {
a[i][0] = readInt();
a[i][1] = readInt();
}
for (int i = 1; i < n; ++i) {
int u = readInt(), v = readInt();
adj[u].add(v);
adj[v].add(u);
}
dp = new long[n + 1][2];
DFS(1, 0);
System.out.println(Math.max(dp[1][0], dp[1][1]));
}
}
}
|
import java.io.*;
import java.util.*;
public class Main {
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st;
static String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
static int readInt() throws IOException {
return Integer.parseInt(next());
}
static long readLong() throws IOException {
return Long.parseLong(next());
}
static double readDouble() throws IOException {
return Double.parseDouble(next());
}
static char readChar() throws IOException {
return next().charAt(0);
}
static String readLine() throws IOException {
return br.readLine();
}
static class Pair implements Comparable<Pair> {
int f, s;
Pair(int f, int s) {
this.f = f; this.s = s;
}
public int compareTo(Pair other) {
if (this.f != other.f) return this.f - other.f;
return this.s - other.s;
}
}
static List<Integer> adj[];
static int n, a[][];
static long dp[][];
static void DFS(int v, int p) {
for (int u : adj[v]) {
if (u != p) {
DFS(u, v);
for (int i = 0; i <= 1; ++i) {
long add = 0;
for (int j = 0; j <= 1; ++j)
add = Math.max(add, dp[u][j] + Math.abs(a[v][i] - a[u][j]));
dp[v][i] += add;
}
}
}
}
public static void main(String[] args) throws IOException {
for (int t = readInt(); t > 0; --t) {
n = readInt();
adj = new List[n + 1];
for (int i = 1; i <= n; ++i)
adj[i] = new ArrayList();
a = new int[n + 1][2];
for (int i = 1; i <= n; ++i) {
a[i][0] = readInt();
a[i][1] = readInt();
}
for (int i = 1; i < n; ++i) {
int u = readInt(), v = readInt();
adj[u].add(v);
adj[v].add(u);
}
dp = new long[n + 1][2];
DFS(1, 0);
System.out.println(Math.max(dp[1][0], dp[1][1]));
}
}
}
| 1 |
Plagiarised
|
22b41936
|
2.921E+060
|
import java.io.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Collections;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main1 {
static ArrayList<Integer> list1 = new ArrayList<>() ;
static ArrayList<Integer> list2 = new ArrayList<>() ;
static int n , m ;
static long dp[][] ;
static long solver(int i , int j ){
// i = empty chairs
if (j == m)return 0 ;
int tt1 = n-i ;
int tt2 = m-j ;
if (n-i < m-j)return Long.MAX_VALUE/2 ;
if ( dp[i][j] != -1 )return dp[i][j] ;
long a = solver(i+1 , j) ;
long b = abs( list1.get(i) - list2.get(j)) + solver(i+1 , j+1) ;
return dp[i][j] = min(a , b) ;
}
public static void main(String[] args) throws IOException {
// try {
FastScanner in = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int N = in.nextInt() ;
int a[] = in.readArray(N) ;
for (int i = 0; i <N ; i++) {
if (a[i] == 1)list2.add(i) ;
else list1.add(i) ;
}
n = list1.size() ;
m = list2.size() ;
dp = new long[n][m] ;
for(int i=0 ; i<n ; i++)
for(int j=0 ; j<m ; j++)
dp[i][j] = -1 ;
System.out.println(solver(0 , 0 ));
out.flush();
out.close();
// }
// catch (Exception e){
// return;
// }
}
static long gcd(long a, long b) {
return (b == 0) ? a : gcd(b, a % b);
}
static ArrayList<Integer> list = new ArrayList<>();
static boolean A[] = new boolean[2 * 90000001];
static void seive(int n) {
int maxn = n;
//int maxn = 1000000 ;
A[0] = A[1] = true;
for (int i = 2; i * i <= maxn; i++) {
if (!A[i]) {
for (int j = i * i; j <= maxn; j += i)
A[j] = true;
}
}
for (int i = 2; i <= maxn; i++)
if (!A[i])
list.add(i);
}
static int findLCA(int a, int b, int par[][], int depth[]) {
if (depth[a] > depth[b]) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
int diff = depth[b] - depth[a];
for (int i = 19; i >= 0; i--) {
if ((diff & (1 << i)) > 0) {
b = par[b][i];
}
}
if (a == b)
return a;
for (int i = 19; i >= 0; i--) {
if (par[b][i] != par[a][i]) {
b = par[b][i];
a = par[a][i];
}
}
return par[a][0];
}
static int gcd(int a, int b) {
return (b == 0) ? a : gcd(b, a % b);
}
static void formArrayForBinaryLifting(int n, int par[][]) {
for (int j = 1; j < 20; j++) {
for (int i = 0; i < n; i++) {
if (par[i][j - 1] == -1)
continue;
par[i][j] = par[par[i][j - 1]][j - 1];
}
}
}
static void sort(int ar[]) {
int n = ar.length;
ArrayList<Integer> a = new ArrayList<>();
for (int i = 0; i < n; i++)
a.add(ar[i]);
Collections.sort(a);
for (int i = 0; i < n; i++)
ar[i] = a.get(i);
}
static void sort1(long ar[]) {
int n = ar.length;
ArrayList<Long> a = new ArrayList<>();
for (int i = 0; i < n; i++)
a.add(ar[i]);
Collections.sort(a);
for (int i = 0; i < n; i++)
ar[i] = a.get(i);
}
static long ncr(long n, long r, long mod) {
if (r == 0)
return 1;
long val = ncr(n - 1, r - 1, mod);
val = (n * val) % mod;
val = (val * modInverse(r, mod)) % mod;
return val;
}
static long fast_pow(long base, long n, long M) {
if (n == 0)
return 1;
if (n == 1)
return base % M;
long halfn = fast_pow(base, n / 2, M);
if (n % 2 == 0)
return (halfn * halfn) % M;
else
return (((halfn * halfn) % M) * base) % M;
}
static long modInverse(long n, long M) {
return fast_pow(n, M - 2, M);
}
private static int countDigits(long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
static class FastOutput implements AutoCloseable, Closeable, Appendable {
private static final int THRESHOLD = 32 << 10;
private final Writer os;
private StringBuilder cache = new StringBuilder(THRESHOLD * 2);
public FastOutput append(CharSequence csq) {
cache.append(csq);
return this;
}
public FastOutput append(CharSequence csq, int start, int end) {
cache.append(csq, start, end);
return this;
}
private void afterWrite() {
if (cache.length() < THRESHOLD) {
return;
}
flush();
}
public FastOutput(Writer os) {
this.os = os;
}
public FastOutput(OutputStream os) {
this(new OutputStreamWriter(os));
}
public FastOutput append(char c) {
cache.append(c);
afterWrite();
return this;
}
public FastOutput append(long c) {
cache.append(c);
afterWrite();
return this;
}
public FastOutput append(String c) {
cache.append(c);
afterWrite();
return this;
}
public FastOutput println() {
return append(System.lineSeparator());
}
public FastOutput flush() {
try {
// boolean success = false;
// if (stringBuilderValueField != null) {
// try {
// char[] value = (char[]) stringBuilderValueField.get(cache);
// os.write(value, 0, cache.length());
// success = true;
// } catch (Exception e) {
// }
// }
// if (!success) {
os.append(cache);
// }
os.flush();
cache.setLength(0);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
return this;
}
public void close() {
flush();
try {
os.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
public String toString() {
return cache.toString();
}
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
}
|
import java.util.*;
import java.io.*;
import java.math.*;
/**
*
* @Har_Har_Mahadev
*/
/**
* Main , Solution , Remove Public
*/
public class A {
private static long[][] dp;
private static ArrayList<Integer> lis1,lis0;
public static void process() throws IOException {
int n = sc.nextInt();
int arr[] = sc.readArray(n);
lis1 = new ArrayList<Integer>();
lis0 = new ArrayList<Integer>();
for(int i = 0; i<n; i++) {
if(arr[i] == 1)lis1.add(i+1);
else lis0.add(i+1);
}
Collections.sort(lis0);
Collections.sort(lis1);
int n0 = lis0.size();
int n1 = lis1.size();
dp = new long[n0+1][n1+1];
for(int i = 0; i<=n0; i++) {
Arrays.fill(dp[i], -1);
}
long ans = solve(0,0,n0,n1);
println(ans);
}
private static long solve(int i, int j, int n0, int n1) {
if(j == n1)return 0;
if(i == n0)return INF;
if(dp[i][j] != -1)return dp[i][j];
long ans = solve(i+1, j, n0, n1);
ans = min(ans,abs(lis0.get(i) - lis1.get(j)) + solve(i+1, j+1, n0, n1));
return dp[i][j] = ans;
}
//=============================================================================
//--------------------------The End---------------------------------
//=============================================================================
private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
private static int N = 0;
private static void google(int tt) {
System.out.print("Case #" + (tt) + ": ");
}
static FastScanner sc;
static PrintWriter out;
public static void main(String[] args) throws IOException {
boolean oj = true;
if (oj) {
sc = new FastScanner();
out = new PrintWriter(System.out);
} else {
sc = new FastScanner(100);
out = new PrintWriter("output.txt");
}
int t = 1;
// t = sc.nextInt();
int TTT = 1;
while (t-- > 0) {
// google(TTT++);
process();
}
out.flush();
out.close();
}
static class Pair implements Comparable<Pair> {
int x, y;
Pair(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(Pair o) {
return Integer.compare(this.x, o.x);
}
// @Override
// public boolean equals(Object o) {
// if (this == o) return true;
// if (!(o instanceof Pair)) return false;
// Pair key = (Pair) o;
// return x == key.x && y == key.y;
// }
//
// @Override
// public int hashCode() {
// int result = x;
// result = 31 * result + y;
// return result;
// }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
static void println(Object o) {
out.println(o);
}
static void println() {
out.println();
}
static void print(Object o) {
out.print(o);
}
static void pflush(Object o) {
out.println(o);
out.flush();
}
static int ceil(int x, int y) {
return (x % y == 0 ? x / y : (x / y + 1));
}
static long ceil(long x, long y) {
return (x % y == 0 ? x / y : (x / y + 1));
}
static int max(int x, int y) {
return Math.max(x, y);
}
static int min(int x, int y) {
return Math.min(x, y);
}
static int abs(int x) {
return Math.abs(x);
}
static long abs(long x) {
return Math.abs(x);
}
static long sqrt(long z) {
long sqz = (long) Math.sqrt(z);
while (sqz * 1L * sqz < z) {
sqz++;
}
while (sqz * 1L * sqz > z) {
sqz--;
}
return sqz;
}
static int log2(int N) {
int result = (int) (Math.log(N) / Math.log(2));
return result;
}
static long max(long x, long y) {
return Math.max(x, y);
}
static long min(long x, long y) {
return Math.min(x, y);
}
public static int gcd(int a, int b) {
BigInteger b1 = BigInteger.valueOf(a);
BigInteger b2 = BigInteger.valueOf(b);
BigInteger gcd = b1.gcd(b2);
return gcd.intValue();
}
public static long gcd(long a, long b) {
BigInteger b1 = BigInteger.valueOf(a);
BigInteger b2 = BigInteger.valueOf(b);
BigInteger gcd = b1.gcd(b2);
return gcd.longValue();
}
public static long lcm(long a, long b) {
return (a * b) / gcd(a, b);
}
public static int lcm(int a, int b) {
return (a * b) / gcd(a, b);
}
public static int lower_bound(int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= x)
high = mid;
else
low = mid + 1;
}
return low;
}
public static int upper_bound(int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] > x)
high = mid;
else
low = mid + 1;
}
return low;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
static class FastScanner {
BufferedReader br;
StringTokenizer st;
FastScanner() throws FileNotFoundException {
br = new BufferedReader(new InputStreamReader(System.in));
}
FastScanner(int a) throws FileNotFoundException {
br = new BufferedReader(new FileReader("input.txt"));
}
String next() throws IOException {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
String nextLine() throws IOException {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] readArray(int n) throws IOException {
int[] A = new int[n];
for (int i = 0; i != n; i++) {
A[i] = sc.nextInt();
}
return A;
}
long[] readArrayLong(int n) throws IOException {
long[] A = new long[n];
for (int i = 0; i != n; i++) {
A[i] = sc.nextLong();
}
return A;
}
}
static void ruffleSort(int[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
int temp = a[i];
a[i] = a[r];
a[r] = temp;
}
Arrays.sort(a);
}
static void ruffleSort(long[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
long temp = a[i];
a[i] = a[r];
a[r] = temp;
}
Arrays.sort(a);
}
}
| 0 |
Non-plagiarised
|
ac121776
|
eb6cfca7
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Solution {
static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static class HashMultiSet<T> implements Iterable<T>
{ private final HashMap<T,Integer> map;
private int size;
public HashMultiSet(){map=new HashMap<>(); size=0;}
public void clear(){map.clear(); size=0;}
public int size(){return size;}
public int setSize(){return map.size();}
public boolean contains(T a){return map.containsKey(a);}
public boolean isEmpty(){return size==0;}
public Integer get(T a){return map.getOrDefault(a,0);}
public void add(T a, int count)
{
int cur=get(a);map.put(a,cur+count); size+=count;
if(cur+count==0) map.remove(a);
}
public void addOne(T a){add(a,1);}
public void remove(T a, int count){add(a,Math.max(-get(a),-count));}
public void removeOne(T a){remove(a,1);}
public void removeAll(T a){remove(a,Integer.MAX_VALUE-10);}
public Iterator<T> iterator()
{
return new Iterator<>()
{
private final Iterator<T> iter = map.keySet().iterator();
private int count = 0; private T curElement;
public boolean hasNext(){return iter.hasNext()||count>0;}
public T next()
{
if(count==0)
{
curElement=iter.next();
count=get(curElement);
}
count--; return curElement;
}
};
}
}
static class DisjointUnionSets {
int[] rank, parent;
int n;
// Constructor
public DisjointUnionSets(int n)
{
rank = new int[n];
parent = new int[n];
this.n = n;
makeSet();
}
// Creates n sets with single item in each
void makeSet()
{
for (int i = 0; i < n; i++) {
// Initially, all elements are in
// their own set.
parent[i] = i;
}
}
// Returns representative of x's set
int find(int x)
{
// Finds the representative of the set
// that x is an element of
if (parent[x] != x) {
// if x is not the parent of itself
// Then x is not the representative of
// his set,
parent[x] = find(parent[x]);
// so we recursively call Find on its parent
// and move i's node directly under the
// representative of this set
}
return parent[x];
}
// Unites the set that includes x and the set
// that includes x
void union(int x, int y)
{
// Find representatives of two sets
int xRoot = find(x), yRoot = find(y);
// Elements are in the same set, no need
// to unite anything.
if (xRoot == yRoot)
return;
// If x's rank is less than y's rank
if (rank[xRoot] < rank[yRoot])
// Then move x under y so that depth
// of tree remains less
parent[xRoot] = yRoot;
// Else if y's rank is less than x's rank
else if (rank[yRoot] < rank[xRoot])
// Then move y under x so that depth of
// tree remains less
parent[yRoot] = xRoot;
else // if ranks are the same
{
// Then move y under x (doesn't matter
// which one goes where)
parent[yRoot] = xRoot;
// And increment the result tree's
// rank by 1
rank[xRoot] = rank[xRoot] + 1;
}
}
}
private static boolean try1(String s, int index,int prev){
int n = s.length();
for(int i = index;i<n;i++){
if(s.charAt(i) == '0' && prev == i-1){
return false;
}else if(s.charAt(i) == '0'){
prev = i;
}
}
return true;
}
public static void main(String[] args) {
MyScanner sc = new MyScanner();
int t = sc.nextInt();
while (t-- != 0) {
int n = sc.nextInt();
long a[] = new long[n];
for(int i=0;i<n;i++){
a[i] = sc.nextLong();
}
long mineA = a[0];
long mineB = a[1];
long accA =0 ;
long accB = 0;
long remA = n;
long remB = n;
long ans = (mineA * n) + (mineB *n);
boolean check = true;
for(int i =2;i<n;i++){
if(check){
check = false;
long x = Math.min(a[i],mineA);
long y = Math.max(a[i],mineA);
mineA = x;
accA += y;
remA --;
long sug = (accA + remA * mineA) + (accB + remB * mineB);
ans = Math.min(sug , ans);
}else{
check = true;
long x = Math.min(a[i],mineB);
long y = Math.max(a[i],mineB);
mineB = x;
accB += y;
remB --;
long sug = (accA + remA * mineA) + (accB + remB * mineB);
ans = Math.min(sug,ans);
}
}
System.out.println(ans);
}
}
}
|
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Map.Entry;
import java.util.TreeMap;
public class Main {
public Main() throws FileNotFoundException {
// File file = Paths.get("input.txt").toFile();
// if (file.exists()) {
// System.setIn(new FileInputStream(file));
// }
long t = System.currentTimeMillis();
InputReader reader = new InputReader();
int ttt = reader.nextInt();
for (int tt = 0; tt < ttt; tt++) {
int n=reader.nextInt();
long[] s=new long[n];
for(int i=0;i<n;i++) {
s[i]=reader.nextLong();
}
long smallest1=s[0];
long smallest2=s[1];
long val=n*s[0]+n*s[1];
int left1=n-1;
int left2=n-1;
long base=s[0]+s[1];
for(int i=2;i<n;i++) {
if(i%2==0) {
//left1
val=Math.min(val, base+left2*smallest2+left1*s[i]);
base+=s[i];
smallest1=Math.min(smallest1, s[i]);
left1--;
}else {
val=Math.min(val, base+left1*smallest1+left2*s[i]);
base+=s[i];
smallest2=Math.min(smallest2, s[i]);
left2--;
//left2
}
}
System.out.println(val);
}
}
static class InputReader {
private byte[] buf = new byte[16384];
private int curChar;
private int numChars;
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = System.in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
public long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
public static void main(String[] args) throws FileNotFoundException {
new Main();
}
}
| 0 |
Non-plagiarised
|
49b94994
|
558df7d4
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main1582D {
public static void main(String[] args) {
final FastScanner in = new FastScanner(System.in);
final PrintWriter out = new PrintWriter(System.out);
int t = in.nextInt();
for (int i = 0; i < t; i++) {
int n = in.nextInt();
int[] a = new int[n];
for (int j = 0; j < n; j++) {
a[j] = in.nextInt();
}
int[] b = solution(a, n);
for (int j = 0; j < n; j++) {
out.print(b[j]);
out.print(" ");
}
out.println();
}
out.flush();
out.close();
in.close();
}
private static int[] solution(int[] a, int n) {
int[] b = new int[n];
int start = 0;
if (n % 2 == 1) {
if (a[0] + a[1] != 0) {
b[0] = -a[2];
b[1] = -a[2];
b[2] = a[0] + a[1];
} else if (a[0] + a[2] != 0) {
b[0] = -a[1];
b[1] = a[0] + a[2];
b[2] = -a[1];
} else {
b[0] = a[1] + a[2];
b[1] = -a[0];
b[2] = -a[0];
}
start = 3;
} else {
b[0] = -a[1];
b[1] = a[0];
int gcd = gcd(b[0], b[1]);
b[0] /= gcd;
b[1] /= gcd;
start = 2;
}
for (int i = start; i < n; i += 2) {
b[i] = -a[i + 1];
b[i + 1] = a[i];
}
return b;
}
private static int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
private static class FastScanner {
BufferedReader br;
StringTokenizer st;
FastScanner(InputStream stream) {
try {
br = new BufferedReader(new InputStreamReader(stream));
} catch (Exception e) {
e.printStackTrace();
}
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
int[] readIntArr(int n) {
int[] result = new int[n];
for (int i = 0; i < n; i++) {
result[i] = Integer.parseInt(next());
}
return result;
}
long[] readLongArr(int n) {
long[] result = new long[n];
for (int i = 0; i < n; i++) {
result[i] = Long.parseLong(next());
}
return result;
}
void close() {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
long nextLong() {
return Long.parseLong(next());
}
}
}
|
import java.io.*;
import java.util.*;
public class Pupsen {
public static void main(String[] args) throws Exception {
FastIO in = new FastIO();
int t = in.nextInt();
for (int tc=0; tc<t; tc++) {
int n = in.nextInt();
int[] a = new int[n];
for (int i=0; i<n; i++) {
a[i] = in.nextInt();
}
int[] b = new int[n];
if (n%2==0) {
for (int i=0; i<n-1; i+=2) {
b[i] = -a[i+1];
b[i+1] = a[i];
}
for (int i=0; i<n; i++) System.out.print(b[i]+" ");
}
else {
if (a[0]+a[1]!=0) {
b[0] = -a[2];
b[1] = -a[2];
b[2] = a[0]+a[1];
}
else if (a[0]+a[2]!=0) {
b[0] = -a[1];
b[2] = -a[1];
b[1] = a[0]+a[2];
}
else {
b[1] = -a[0];
b[2] = -a[0];
b[0] = a[1]+a[2];
}
for (int i=3; i<n-1; i+=2) {
b[i] = -a[i+1];
b[i+1] = a[i];
}
for (int i=0; i<n; i++) System.out.print(b[i]+" ");
}
System.out.println();
}
}
static class FastIO {
BufferedReader br;
StringTokenizer st;
PrintWriter pr;
public FastIO() throws IOException
{
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next() throws IOException
{
while (st == null || !st.hasMoreElements()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
public int nextInt() throws NumberFormatException, IOException { return Integer.parseInt(next()); }
public long nextLong() throws NumberFormatException, IOException { return Long.parseLong(next()); }
public double nextDouble() throws NumberFormatException, IOException
{
return Double.parseDouble(next());
}
public String nextLine() throws IOException
{
String str = br.readLine();
return str;
}
}
}
| 0 |
Non-plagiarised
|
04df7bb8
|
aaccc000
|
import java.math.BigInteger;
import java.sql.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main {
static HashMap<Integer,Boolean>map;
static long dp[][];
static boolean flag;
static HashSet<Long>hs;
static long mod=(long)(1e9+7);
public static void main(String[] args) {
StringBuilder ans=new StringBuilder();
FastReader sc=new FastReader();
int t=sc.nextInt();
while(t-->0) {
int n=sc.nextInt();
//int n=sb.length();
int k=sc.nextInt();
long L[]=new long[n];
long R[]=new long[n];
int a[]=new int[k];
int temp[]=new int[k];
for(int i=0;i<k;i++)
a[i]=sc.nextInt();
for(int i=0;i<k;i++)
temp[i]=sc.nextInt();
int c[]=new int [n];
Arrays.fill(c, Integer.MAX_VALUE);
for(int i=0;i<k;i++)
c[a[i]-1]=temp[i];
long p=Integer.MAX_VALUE;
for(int i=0;i<n;i++)
{
p=Math.min(p+1, c[i]);
L[i]=p;
}
p=Integer.MAX_VALUE;
for(int i=n-1;i>=0;i--)
{
p=Math.min(p+1, c[i]);
R[i]=p;
}
for(int i=0;i<n;i++)
{
ans.append(Math.min(L[i], R[i])+" ");
}
ans.append("\n");
}
System.out.println(ans);
}
static class Sparse{
int log[];
long sparse[][];
Sparse(int n){
log=new int [n+1];
for(int i=1;i<n+1;i++)
{
log[i]=log[i/2]+1;
}
sparse=new long[n][18];
}
}
static long solve(String X,String Y,int n,int m,int M){
if(m==0&&n==0)return 0;
// if(m==1&&X.charAt(n-1)!='u')return Integer.MIN_VALUE;
if(n==0||m==0)return Integer.MIN_VALUE;
if(dp[n][m]!=-1)return dp[n][m];
if(Y.charAt(m-1)==X.charAt(n-1))
{
// else if(n==1)return Integer.MAX_VALUE;
return dp[n][m]=1+ Math.max(solve (X,Y,n-1,m,M),solve (X,Y,n-1,m-1,M));
}
else{
return dp[n][m]= solve(X,Y,n-1,m,M);
}
}
static long solve(long [][]g,int n,int m,boolean visited [][]) {
if(n==0||m==0)return 0;
visited[n][m]=true;
long ans=g[n-1][m-1]+Math.max(solve(g, n, m-1, visited),solve(g, n-1, m, visited));
visited[n][m]=false;
return ans;
}
static boolean isP(long x,long n,long m) {
return (x^n)<=m;
}
static class pair{
int n;int i;
pair(int n,int i){
this.n=n;
this.i=i;
}
}
static long solve(char g[][],int n,int m) {
if(n==0||m==0)return 0;
if(n==1&&m==1)return 1;
if(g[n-1][m-1]=='#')return 0;
if(dp[n][m]!=-1)return dp[n][m];
return dp[n][m]= (solve(g, n-1, m)%mod+solve(g, n, m-1)%mod)%mod;
}
static int solve (int v,ArrayList<ArrayList<Integer>>adj,int d[],boolean visited[]) {
visited[v]=true;
for(int u:adj.get(v)) {
if(!visited[u])
{
solve(u, adj, d, visited);
}
d[v]=Math.max(1+d[u], d[v]);
}
return d[v];
}
static class colors{
int c;int n;
public colors(int c,int n) {
// TODO Auto-generated constructor stub
this.c=c;
this.n=n;
}
}
static int CeilIndex(long A[], int l, int r, long key)
{
while (r - l > 1) {
int m = l + (r - l) / 2;
if (A[m] >= key)
r = m;
else
l = m;
}
return r;
}
static int CeilIndexd(long A[], int l, int r, long key)
{
while (r - l > 1) {
int m = l + (r - l) / 2;
if (-1*A[m] >= key)
r = m;
else
l = m;
}
return r;
}
static void solve(ArrayList<Long>A,long bd) {
if(bd>(long)1e9)return;
// if(hs.contains(bd))return;
//A.add(bd);
hs.add(bd);
A.add(bd*10);
A.add(bd*10+1);
// hs.add(bd*10);
//hs.add(bd*10+1);
solve(A,bd*10);
solve(A,bd*10+1);
}
static boolean isPrime(int n)
{
// Corner cases
if (n <= 1)
return false;
if (n <= 3)
return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
static long lcm(long a, long b)
{
return ((a / gcd(a, b))%mod * b%mod)%mod;
}
static long gcd(long a,long b)
{
if (a == 0)
return b%mod;
return (gcd(b % a, a))%mod;
}
//System.out.println(count);
static void dfs(int v,boolean visited[],ArrayList<ArrayList<Integer>>adj,int div[],int t)
{
visited[v]=true;
div[v]=t+1;
for(int u:adj.get(v)) {
if(!visited[u]) {
dfs(u,visited,adj,div,(t+1)%2);
}
}
}
static class Helper{
int a;int b;int t;
public Helper(int a,int b) {
// TODO Auto-generated constructor stub
this.a=a;
this.b=b;
}
}
// System.out.println(max);
//System.out.println(ans.toString());
//main(
static void solvedfs(ArrayList<ArrayList<Integer>>adj,int n,int v,int subt[],int subtAns[],boolean []visited) {
int count=1;
int ans=0;
visited[v]=true;
for(int u:adj.get(v)) {
if(!visited[u])
{
//System.out.println(v+" "+subt[v]+" "+n);
subtAns[u]=Math.max(subtAns[u], subt[v]-subtAns[u]);
solvedfs(adj, n, u, subt, subtAns, visited);
}
}
}
static int dfs(ArrayList<ArrayList<Integer>>adj,int v,int subt[],int subtAns[],boolean []visited) {
int count=0;
int ans=0;
visited[v]=true;
for(int u:adj.get(v)) {
if(!visited[u])
{
count+=ans;
ans=Math.max(dfs(adj,u,subt,subtAns,visited),ans);
}
}
subt[v]=count;
subtAns[v]=ans;
return ans+1;
}
static int solve(ArrayList<ArrayList<Integer>>adj,int node,ArrayList<Integer>A)
{
if(adj.get(node).size()==0)return 1;
int count=0;
for(int v:adj.get(node)) {
count+=solve(adj,v,A);
}
A.set(node,count);
return count+1;
}
static void dfs(String[]building,int i,int j,int n,int m, boolean visited[][]) {
visited[i][j]=true;
if(isValid(building,i+1,j,n,m,visited))
{ visited[i+1][j]=true;
dfs(building,i+1,j,n,m,visited);
}
if(isValid(building,i-1,j,n,m,visited))
{
visited[i-1][j]=true;
dfs(building,i-1,j,n,m,visited);
}
if(isValid(building,i,j+1,n,m,visited))
{visited[i][j+1]=true;
dfs(building,i,j+1,n,m,visited);
}
if(isValid(building,i,j-1,n,m,visited))
{visited[i][j-1]=true;
dfs(building,i,j-1,n,m,visited);
}
}
static boolean isValid(String[]building,int i,int j,int n,int m, boolean visited[][])
{
if(i==-1||j==-1||i==n||j==m||visited[i][j]||building[i].charAt(j)=='#')
return false;
return true;
}
static void compute(boolean sieve[],int n) {
for(int i=2;i<=n;i++) {
if(sieve[i])continue;
for(int j=2*i;j<n;j+=i)
{
sieve[j]=true;
}
}
}
static void computeHs(boolean sieve[]) {
int n=(int)(1e9-1e7+1);
for(int i=1;i<n;i++) {
if(sieve[i])continue;
for(int j=2*i;j<n;j+=i)
{
sieve[j]=true;
}
}
}
static boolean isValid(StringBuilder s,int w) {
if(w>s.length())return false;
HashSet<Character>hs=new HashSet<Character>();
int a[]=new int[3];
for(int i=0;i<w;i++) {
++a[s.charAt(i)-49];
}
if(a[0]>0&&a[1]>0&&a[2]>0)return true;
int start=0;
int end=w;
while(end!=s.length()) {
--a[s.charAt(start)-49];
++a[s.charAt(end)-49];
start++;
end++;
if(a[0]>0&&a[1]>0&&a[2]>0)return true;
}
return false;
}
static int find(int parent[],int i) {
if(parent[i]==-1)return i;
return parent[i]=find(parent,parent[i]);
}
static void union(int parent[],int rank[],int s1,int s2) {
if(rank[s1]>=rank[s2]) {
parent[s2]=s1;
rank[s1]+=rank[s2];
}
else {
parent[s1]=s2;
rank[s2]+=rank[s1];
}
}
static int solve(String S,int K) {
if(K<=0)return 0;
if(S.charAt(K-1)!=S.charAt(K))
return 1+solve(S,K-1);
else return solve(S,K-1);
}
static boolean isValid(int g[][],int r,int c,int n,int m,boolean visited[][],int s) {
if(r==-1||r==n||c==-1||c==m||visited[r][c]||g[r][c]!=s)return false;
return true;
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
import java.io.*;
import java.util.*;
public class GFG {
public static void main (String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-- > 0){
int n = sc.nextInt();
int k = sc.nextInt();
int[] a = new int[k];
int[] temp = new int[k];
for(int i=0;i<k;i++){
a[i] = sc.nextInt();
}
for(int i=0;i<k;i++){
temp[i] = sc.nextInt();
}
long[] c = new long[n];
Arrays.fill(c,Integer.MAX_VALUE);
for(int i=0;i<k;i++){
c[a[i]-1] = temp[i];
}
long p = Integer.MAX_VALUE;
long[] left = new long[n];
for(int i=0;i<n;i++){
p = (p+1<c[i])?p+1:c[i];
left[i] = p;
}
p = Integer.MAX_VALUE;
long[] right = new long[n];
for(int i=n-1;i>=0;i--){
p = (p+1<c[i])?p+1:c[i];
right[i] = p;
}
for(int i=0;i<n;i++){
long kl = (left[i]>right[i])?right[i]:left[i];
System.out.print(kl+" ");
}
System.out.println();
}
}
}
| 1 |
Plagiarised
|
af2b138c
|
e45446bc
|
import java.util.*;
import java.lang.*;
import java.io.*;
public class ecf106 {
//HashMap<Integer,Integer> hm=new HashMap<>();
//ArrayList<Integer> list=new ArrayList<>();
//HashSet<Integer> hs=new HashSet<>();
//Stack<Integer> st=new Stack<>();
//Queue<Integer> q=new LinkedList<>();
//PriorityQueue<Integer> pq=new PriorityQueue<>();
// static ArrayList<ArrayList<Integer>> gp=new ArrayList<>();
//int[] arr=new int[n];
//System.out.println("YES");
//1 hr- atleast 2 qs d-2
//Mt_do 3 qs d-2
//Mt_do 4 qs d-3
//StringBuilder sb=new StringBuilder();
public static void main(String[] args) throws Exception{
InputStreamReader ip=new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(ip);
int t= Integer.parseInt(br.readLine());
while(t-->0){
int n=Integer.parseInt(br.readLine());//Integer.parseInt(strs[0]);
String[] strs=(br.readLine()).trim().split(" ");
// int n=Integer.parseInt(strs[0]),k=Integer.parseInt(strs[1]);//,k=Integer.parseInt(strs[2]);
// strs=(br.readLine()).trim().split(" ");
long[] arr=new long [n];
for(int i=0;i<n;i++){
arr[i]=Integer.parseInt(strs[i]);
}
long min1=0,min2=0;
long x=0,y=0;
long hor=arr[0],vert=arr[1];
long ans=(n*hor)+(n*vert);
for(int i=2;i<n;i++){
if(i%2==0){
x++;
if(arr[i]>=hor){ //v.v.imp donot update horizontal
min1+=arr[i];
}else{
min1+=hor; hor=arr[i];
}
}else{
y++;
if(arr[i]>=vert){ //v.v.imp donot update vertical
min2+=arr[i];
}else{
min2+=vert; vert=arr[i];
}
}
long rem=(n-x)*hor+(n-y)*vert;
ans=Math.min(ans, min1+min2+rem);
}
System.out.println(ans);
}
}
}
// public static void main(String[] args) throws Exception{
// InputStreamReader ip=new InputStreamReader(System.in);
// BufferedReader br = new BufferedReader(ip);
// int t= Integer.parseInt(br.readLine());
// while(t-->0){
// // int n=Integer.parseInt(br.readLine());//Integer.parseInt(strs[0]);
// // String[] strs=(br.readLine()).trim().split(" ");
// // int n=Integer.parseInt(strs[0]),k=Integer.parseInt(strs[1]);//,k=Integer.parseInt(strs[2]);
// // strs=(br.readLine()).trim().split(" ");
// String str=(br.readLine()).trim();
// char[] arr=str.toCharArray();
// int n=arr.length;
// int i=0, l=0, r=n;
// for (i=1; i<n; i++)
// if (arr[i-1]==arr[i] && arr[i]=='0')
// l=i;
// for (i=n-2; i>=0; i--)
// if (arr[i]==arr[i+1] && arr[i]=='1')
// r=i;
// if (l<=r)
// System.out.println("YES");
// else
// System.out.println("NO");
// // int cz=0,co=0;
// // int lz=0;
// // int n=str.length();
// // boolean fg1=true;
// // for(int i=0;i<n;i++){
// // if(arr[i]=='1'){co++;}else{cz++; lz=i;}
// // if(i>0 && arr[i-1]>arr[i]){fg1=false; }
// // }
// // if(co==n || cz==n || fg1 || co==1 ||cz==1){
// // System.out.println("YES"); continue;
// // }
// // // String s1="";
// // // String s2="";
// // StringBuilder sb1=new StringBuilder();
// // StringBuilder sb2=new StringBuilder();
// // for(int i=0;i<n;i+=2){
// // // s1+=arr[i];
// // sb1.append(arr[i]);
// // }
// // for(int i=1;i<n;i+=2){
// // // s2+=arr[i];
// // sb2.append(arr[i]);
// // }
// // char[] arr1=(sb1.toString()).toCharArray();
// // char[] arr2=(sb2.toString()).toCharArray();
// // boolean fg2=true;
// // boolean fg3=true;
// // for(int i=0;i<arr1.length;i++){
// // if(i>0 && arr1[i-1]>arr1[i]){fg2=false; break;}
// // }
// // for(int i=0;i<arr2.length;i++){
// // if(i>0 && arr2[i-1]>arr2[i]){fg3=false;}
// // }
// // if(fg2 ||fg3){
// // System.out.println("YES");
// // }else{
// // System.out.println("NO");
// // }
// }
// }
// }
// int az=0,ao=0;
// ArrayList<Integer> list=new ArrayList<>();
// for(int i=0;i<n;i++){
// if(arr[i]=='0'){az++; if(ao!=0){list.add(ao);} ao=0; }
// else{ao++; if(az!=0){list.add(az); } az=0; }
// }
// if(az!=0){list.add(az); }
// if(ao!=0){list.add(ao);}
// boolean fl=true;
// for(int i=1;i<list.size();i++){
// int v1=list.get(i-1),v2=list.get(i);
// if(v1>1 && v2>1){fl=false; break;}
// }
// if(fl){System.out.println("YES");}
// else{System.out.println("NO");}
// }
// }
// }
//c1 000001111
// boolean fg=true;
// int last=-2;
// for(int i=0;i<=lz;i++){
// if(arr[i]=='0'){ if((last+1)==i){fg=false; break;} last=i; }
// }
// if(fg){System.out.println("YES"); continue;}
// //c2 11111
// fg=true;
// last=-2;
// for(int i=0;i<n;i++){
// if(arr[i]=='0'){ if((last+1)==i){fg=false; break;} last=i; }
// }
// if(fg){System.out.println("YES"); continue;}
// //c3 0000
// fg=true;
// last=-2;
// for(int i=0;i<n;i++){
// if(arr[i]=='1'){ if((last+1)==i){fg=false; break;} last=i; }
// }
// if(fg){System.out.println("YES");}
// else{System.out.println("NO");}
// }
// }
// }
// public static void main(String[] args) throws Exception{
// InputStreamReader ip=new InputStreamReader(System.in);
// BufferedReader br = new BufferedReader(ip);
// int t= Integer.parseInt(br.readLine());
// while(t-->0){
// // int n=Integer.parseInt(br.readLine());//Integer.parseInt(strs[0]);
// String[] strs=(br.readLine()).trim().split(" ");
// int n=Integer.parseInt(strs[0]),k1=Integer.parseInt(strs[1]),k2=Integer.parseInt(strs[2]);//,k=Integer.parseInt(strs[2]);
// strs=(br.readLine()).trim().split(" ");
// int w=Integer.parseInt(strs[0]),b=Integer.parseInt(strs[1]);
// int tw=k1+k2;
// int tb=(2*n)-tw;
// if((tw/2)>=w && (tb/2)>=b){
// System.out.println("YES");
// }else{
// System.out.println("NO");
// }
// }
// }
// }
|
import java.util.*;
import java.lang.*;
import java.io.*;
public class C {
// *** ++
// +=-==+ +++=-
// +-:---==+ *+=----=
// +-:------==+ ++=------==
// =-----------=++=========================
// +--:::::---:-----============-=======+++====
// +---:..:----::-===============-======+++++++++
// =---:...---:-===================---===++++++++++
// +----:...:-=======================--==+++++++++++
// +-:------====================++===---==++++===+++++
// +=-----======================+++++==---==+==-::=++**+
// +=-----================---=======++=========::.:-+*****
// +==::-====================--: --:-====++=+===:..-=+*****
// +=---=====================-... :=..:-=+++++++++===++*****
// +=---=====+=++++++++++++++++=-:::::-====+++++++++++++*****+
// +=======++++++++++++=+++++++============++++++=======+******
// +=====+++++++++++++++++++++++++==++++==++++++=:... . .+****
// ++====++++++++++++++++++++++++++++++++++++++++-. ..-+****
// +======++++++++++++++++++++++++++++++++===+====:. ..:=++++
// +===--=====+++++++++++++++++++++++++++=========-::....::-=++*
// ====--==========+++++++==+++===++++===========--:::....:=++*
// ====---===++++=====++++++==+++=======-::--===-:. ....:-+++
// ==--=--====++++++++==+++++++++++======--::::...::::::-=+++
// ===----===++++++++++++++++++++============--=-==----==+++
// =--------====++++++++++++++++=====================+++++++
// =---------=======++++++++====+++=================++++++++
// -----------========+++++++++++++++=================+++++++
// =----------==========++++++++++=====================++++++++
// =====------==============+++++++===================+++==+++++
// =======------==========================================++++++
// created by : Nitesh Gupta
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
StringBuilder sb = new StringBuilder();
while (t-- > 0) {
String[] scn = (br.readLine()).trim().split(" ");
int n = Integer.parseInt(scn[0]);
long[] arr = new long[n];
scn = (br.readLine()).trim().split(" ");
for (int i = 0; i < n; i++) {
arr[i] = Long.parseLong(scn[i]);
}
long min;
long hor = arr[0], ver = arr[1];
long min1 = 0, min2 = 0;
min = (hor + ver) * n;
long x = 0, y = 0;
for (int i = 2; i < n; i++) {
if (i % 2 == 0) {
x += 1;
if (arr[i] >= hor) {
min1 += arr[i];
} else {
min1 += hor;
hor = arr[i];
}
} else {
y += 1;
if (arr[i] >= ver) {
min2 += arr[i];
} else {
min2 += ver;
ver = arr[i];
}
}
long pro = (n - x) * hor + (n - y) * ver;
min = Math.min(min, min1 + min2 +pro);
}
sb.append(min);
sb.append("\n");
}
System.out.println(sb);
return;
}
public static void sort(long[] arr) {
int n = arr.length;
for (int i = 0; i < n; i++) {
int idx = (int) Math.random() * n;
long temp = arr[i];
arr[i] = arr[idx];
arr[idx] = temp;
}
Arrays.sort(arr);
}
public static void print(long[] dp) {
for (long ele : dp) {
System.out.print(ele + " ");
}
System.out.println();
}
public static void print(long[][] dp) {
for (long[] a : dp) {
for (long ele : a) {
System.out.print(ele + " ");
}
System.out.println();
}
}
}
| 1 |
Plagiarised
|
1dab88fb
|
b7de5c19
|
import java.util.*;
public class Main
{
static class Edge{
public int node;
public int index;
public Edge(int n, int i){
node=n;
index=i;
}
}
static Scanner sc=new Scanner(System.in);
public static void main(String[] args) {
int test=sc.nextInt();
while(test-->0){
solve();
}
}
static void solve(){
int n=sc.nextInt();
ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
for(int i=0;i<n;i++){
graph.add(new ArrayList<>());
}
for (int i = 0; i < n - 1; i++) {
int u = sc.nextInt();
int v = sc.nextInt();
u--; v--;
graph.get(u).add(new Edge(v, i));
graph.get(v).add(new Edge(u, i));
}
int start = 0;
for (int i = 0; i < n; i++) {
if (graph.get(i).size() > 2) {
System.out.println("-1");
return;
} else if (graph.get(i).size() == 1) {
start = i;
}
}
int[] weight = new int[n - 1];
int prevNode = -1;
int curNode = start;
int curWeight = 2;
while (true) {
ArrayList<Edge> edges = graph.get(curNode);
Edge next = edges.get(0);
if (next.node == prevNode) {
if (edges.size() == 1) {
break;
} else {
next = edges.get(1);
}
}
weight[next.index] = curWeight;
prevNode = curNode;
curNode = next.node;
curWeight = 5 - curWeight;
}
for (int i = 0; i < n - 1; i++) {
System.out.print(weight[i]);
System.out.print(" ");
}
System.out.println();
}
}
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int t = scan.nextInt();
for (int i = 0; i < t; i++) {
int n = scan.nextInt();
ArrayList<ArrayList<Pair>> graph = new ArrayList<>();
for (int j = 0; j < n; j++) {
graph.add(new ArrayList<>());
}
for (int j = 0; j < n - 1; j++) {
int u;
int v;
u = scan.nextInt();
v = scan.nextInt();
u--;
v--;
graph.get(u).add(new Pair(v, j));
graph.get(v).add(new Pair(u, j));
}
boolean soluble = true;
int curV = 0;
int prevV = -1;
int[] ans = new int[n];
int prime = 2;
for (int j = 0; j < n; j++) {
ArrayList<Pair> list = graph.get(j);
if (list.size() > 2) {
soluble = false;
} else if (list.size() == 1) {
curV = j;
}
}
if (soluble) {
for (int j = 0; j < n - 1; j++) {
ArrayList<Pair> list = graph.get(curV);
for (int z = 0; z < list.size(); z++) {
if (list.get(z).vertex != prevV) {
ans[list.get(z).numberOfEdge] = prime;
prime = changePrime(prime);
prevV = curV;
curV = list.get(z).vertex;
break;
}
}
}
for (int j = 0; j < n - 1; j++) {
System.out.print(ans[j] + " ");
}
System.out.println();
} else {
System.out.println(-1);
}
}
}
public static int changePrime(int prime) {
if (prime == 2) {
prime = 3;
} else {
prime = 2;
}
return prime;
}
}
class Pair {
int vertex;
int numberOfEdge;
public Pair(int vertex, int numberOfEdge) {
this.vertex = vertex;
this.numberOfEdge = numberOfEdge;
}
}
| 0 |
Non-plagiarised
|
18e2441c
|
43b10dec
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Map;
import java.util.HashMap;
public class cf1515 {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task();
solver.solve(in, out);
out.close();
}
static class Task {
public void solve(InputReader in, PrintWriter out) {
int t = in.nextInt();
while (t-- != 0) {
int n = in.nextInt();
int m = in.nextInt();
int x = in.nextInt();
TreeMap<Integer, ArrayList<Integer>> map = new TreeMap<>();
for (int i = 0; i < n; i++) {
int j = in.nextInt();
if (!map.containsKey(j)) {
map.put(j, new ArrayList<Integer>());
}
map.get(j).add(i);
}
out.println("YES");
int[] ans = new int[n];
int sta = 0;
for (int s : map.keySet()) {
for (int i = 0; i < map.get(s).size(); i++) {
ans[map.get(s).get(i)] = (sta++) % m + 1;
}
}
for(int i=0;i<n;i++) {
out.print(ans[i]+" ");
}
out.println();
}
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreElements()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
}
|
// package eround101;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.util.StringTokenizer;
import java.util.concurrent.TimeUnit;
public class C101 {
static HritikScanner sc = new HritikScanner();
static PrintWriter pw = new PrintWriter(System.out, true);
final static int MOD = (int) 1e9 + 7;
static StringBuilder sb = new StringBuilder();
public static void main(String[] args) {
int t = ni();
while (t-- > 0) {
solve();
}
}
static void solve() {
int n = ni();
int m = ni(), x = ni();
Map<Integer, ArrayList<Integer>> map = new TreeMap<>();
pl("YES");
for(int i = 0; i < n; i++)
{
int num = ni();
if(!map.containsKey(num))
{
map.put(num, new ArrayList<Integer>());
}
map.get(num).add(i);
}
int[] ans = new int[n];
int q = 0;
for(int block : map.keySet())
{
for(int i = 0; i < map.get(block).size(); i++)
{
ans[map.get(block).get(i)] = (q++)%m+1;
}
}
for(int ele : ans)
{
p(ele + " ");
}
pl();
}
/////////////////////////////////////////////////////////////////////////////////
static int[] nextIntArray(int n) {
int[] arr = new int[n];
int i = 0;
while (i < n) {
arr[i++] = ni();
}
return arr;
}
static long[] nextLongArray(int n) {
long[] arr = new long[n];
int i = 0;
while (i < n) {
arr[i++] = nl();
}
return arr;
}
static int[] nextIntArray1(int n) {
int[] arr = new int[n + 1];
int i = 1;
while (i <= n) {
arr[i++] = ni();
}
return arr;
}
/////////////////////////////////////////////////////////////////////////////////
static int ni() {
return sc.nextInt();
}
static long nl() {
return sc.nextLong();
}
static double nd() {
return sc.nextDouble();
}
/////////////////////////////////////////////////////////////////////////////////
static void pl() {
pw.println();
}
static void p(Object o) {
pw.print(o);
}
static void pl(Object o) {
pw.println(o);
}
static void psb(StringBuilder sb) {
pw.print(sb);
}
static void pa(Object arr[]) {
for (Object o : arr) {
p(o);
}
pl();
}
static void pa(int arr[]) {
for (int o : arr) {
p(o);
}
pl();
}
static void pa(long arr[]) {
for (long o : arr) {
p(o);
}
pl();
}
static void pa(double arr[]) {
for (double o : arr) {
p(o);
}
pl();
}
static void pa(char arr[]) {
for (char o : arr) {
p(o);
}
pl();
}
static void pa(List list) {
for (Object o : list) {
p(o);
}
pl();
}
static void pa(Object[][] arr) {
for (int i = 0; i < arr.length; ++i) {
for (Object o : arr[i]) {
p(o);
}
pl();
}
}
static void pa(int[][] arr) {
for (int i = 0; i < arr.length; ++i) {
for (int o : arr[i]) {
p(o);
}
pl();
}
}
static void pa(long[][] arr) {
for (int i = 0; i < arr.length; ++i) {
for (long o : arr[i]) {
p(o);
}
pl();
}
}
static void pa(char[][] arr) {
for (int i = 0; i < arr.length; ++i) {
for (char o : arr[i]) {
p(o);
}
pl();
}
}
static void pa(double[][] arr) {
for (int i = 0; i < arr.length; ++i) {
for (double o : arr[i]) {
p(o);
}
pl();
}
}
/////////////////////////////////////////////////////////////////////////////////
static void print(Object s) {
System.out.println(s);
}
/////////////////////////////////////////////////////////////////////////////////
//-----------HritikScanner class for faster input----------//
static class HritikScanner {
BufferedReader br;
StringTokenizer st;
public HritikScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
//////////////////////////////////////////////////////////////////
public static class Pair implements Comparable<Pair> {
int num, row,col;
Pair(int num, int row, int col) {
this.num = num;
this.row = row;
this.col = col;
}
public int get1() {
return num;
}
public int get2() {
return row;
}
public int compareTo(Pair A) {
return this.num - A.num;
}
public String toString()
{
return num +" "+ row+" "+col;
}
}
//////////////////////////////////////////////////////////////////
// Function to return gcd of a and b time complexity O(log(a+b))
static long gcd(long a, long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
// method to return LCM of two numbers
static long lcm(int a, int b) {
return (a / gcd(a, b)) * b;
}
//////////////////////////////////////////////////////////////////
static boolean isPrime(long n) {
// Corner cases
if (n <= 1) {
return false;
}
if (n <= 3) {
return true;
}
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0) {
return false;
}
for (long i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
//////////////////////////////////////////////////////////////////
static boolean isPowerOfTwo(long n) {
if (n == 0) {
return false;
}
return (long) (Math.ceil((Math.log(n) / Math.log(2))))
== (long) (Math.floor(((Math.log(n) / Math.log(2)))));
}
public static long getFact(int n) {
long ans = 1;
while (n > 0) {
ans *= n;
ans %= MOD;
n--;
}
return ans;
}
public static long pow(long n, int pow) {
if (pow == 0) {
return 1;
}
long temp = pow(n, pow / 2) % MOD;
temp *= temp;
temp %= MOD;
if (pow % 2 == 1) {
temp *= n;
}
temp %= MOD;
return temp;
}
public static long nCr(int n, int r) {
long ans = 1;
int temp = n - r;
while (n > temp) {
ans *= n;
ans %= MOD;
n--;
}
ans *= pow(getFact(r) % MOD, MOD - 2) % MOD;
ans %= MOD;
return ans;
}
//////////////////////////////////////////////////////////////////
// method returns Nth power of A
static double nthRoot(int A, int N) {
// intially guessing a random number between
// 0 and 9
double xPre = Math.random() % 10;
// smaller eps, denotes more accuracy
double eps = 0.001;
// initializing difference between two
// roots by INT_MAX
double delX = 2147483647;
// xK denotes current value of x
double xK = 0.0;
// loop untill we reach desired accuracy
while (delX > eps) {
// calculating current value from previous
// value by newton's method
xK = ((N - 1.0) * xPre
+ (double) A / Math.pow(xPre, N - 1)) / (double) N;
delX = Math.abs(xK - xPre);
xPre = xK;
}
return xK;
}
}
| 1 |
Plagiarised
|
6653a758
|
f6ca6fc8
|
import java.util.*;
public class D {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
for(int i=1;i<=n;i++){
int x=sc.nextInt();
if(x==1)o.add(i);
else e.add(i);
}
for(int i=1;i<=o.size();i++){
dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
for(int j=i+1;j<=e.size();j++)
dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
}
System.out.println(dp[o.size()][e.size()]);
}
}
|
import java.util.*;
import java.io.*;
public class D {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n = sc.nextInt();
ArrayList<Integer> o=new ArrayList<Integer>();
ArrayList<Integer> e=new ArrayList<Integer>();
for(int i=1;i<=n;i++){
int x=sc.nextInt();
if(x==1)o.add(i);
else e.add(i);
}
int dp[][]=new int[o.size()+1][e.size()+1];
for(int i=1;i<=o.size();i++){
dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
for(int j=i+1;j<=e.size();j++){
dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
}
}
System.out.println(dp[o.size()][e.size()]);
}
}
| 1 |
Plagiarised
|
c4ca2ff3
|
d6fb3b9e
|
/* 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 void main (String[] args) throws java.lang.Exception
{
// your code goes here
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
PrintWriter out=new PrintWriter(System.out);
while(t-->0) {
int n=sc.nextInt();
int freq[][]=new int[n][5];
int rem[][]=new int[n][5];
for(int i=0;i<n;i++) {
String str=sc.next();
for(int j=0;j<str.length();j++) {
freq[i][str.charAt(j)-'a']++;
}
for(int k=0;k<5;k++) {
rem[i][k]=str.length()-freq[i][k];
}
}
int ans=0;
for(int i=0;i<5;i++) {
int arr[]=new int[n];
for(int j=0;j<n;j++)
arr[j]=freq[j][i]-rem[j][i];
Arrays.sort(arr);
int total=0;
int sum=0;
for(int k=n-1;k>=0;k--) {
if(sum+arr[k]>0) {
sum=sum+arr[k];
total++;
}
else {
break;
}
}
ans=Math.max(ans,total);
}
out.println(ans);
}
out.flush();
out.close();
}
}
|
import java.util.*;
public class Sol
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
int a[][]=new int[n][5];
int tot[]=new int[n];
for(int i=0;i<n;i++)
{
String x = sc.next();
for(int j=0;j<x.length();j++)
a[i][x.charAt(j)-'a'] += 1;
tot[i]=x.length();
}
int max=Integer.MIN_VALUE;
for(int i=0;i<5;i++)
max=Math.max(max,function(a,n,i,tot));
System.out.println(max);
}
}
static int function(int a[][],int n,int i,int tot[])
{
Integer ans[] = new Integer[n];
for(int j=0;j<n;j++)
ans[j]=a[j][i]-(tot[j]-a[j][i]);
int res=0,j=0;
Arrays.sort(ans,Collections.reverseOrder());
while(j<n&&res+ans[j]>0)
res+=ans[j++];
return j;
}
}
| 0 |
Non-plagiarised
|
1dab88fb
|
7b5f64b7
|
import java.util.*;
public class Main
{
static class Edge{
public int node;
public int index;
public Edge(int n, int i){
node=n;
index=i;
}
}
static Scanner sc=new Scanner(System.in);
public static void main(String[] args) {
int test=sc.nextInt();
while(test-->0){
solve();
}
}
static void solve(){
int n=sc.nextInt();
ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
for(int i=0;i<n;i++){
graph.add(new ArrayList<>());
}
for (int i = 0; i < n - 1; i++) {
int u = sc.nextInt();
int v = sc.nextInt();
u--; v--;
graph.get(u).add(new Edge(v, i));
graph.get(v).add(new Edge(u, i));
}
int start = 0;
for (int i = 0; i < n; i++) {
if (graph.get(i).size() > 2) {
System.out.println("-1");
return;
} else if (graph.get(i).size() == 1) {
start = i;
}
}
int[] weight = new int[n - 1];
int prevNode = -1;
int curNode = start;
int curWeight = 2;
while (true) {
ArrayList<Edge> edges = graph.get(curNode);
Edge next = edges.get(0);
if (next.node == prevNode) {
if (edges.size() == 1) {
break;
} else {
next = edges.get(1);
}
}
weight[next.index] = curWeight;
prevNode = curNode;
curNode = next.node;
curWeight = 5 - curWeight;
}
for (int i = 0; i < n - 1; i++) {
System.out.print(weight[i]);
System.out.print(" ");
}
System.out.println();
}
}
|
import java.util.*;
import java.io.*;
public class Main {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static FastReader obj = new FastReader();
public static PrintWriter out = new PrintWriter(System.out);
public static void sort(long[] a) {
ArrayList<Long> arr = new ArrayList<>();
for (int i = 0; i < a.length; i++)
arr.add(a[i]);
Collections.sort(arr);
for (int i = 0; i < arr.size(); i++)
a[i] = arr.get(i);
}
public static void revsort(long[] a) {
ArrayList<Long> arr = new ArrayList<>();
for (int i = 0; i < a.length; i++)
arr.add(a[i]);
Collections.sort(arr, Collections.reverseOrder());
for (int i = 0; i < arr.size(); i++)
a[i] = arr.get(i);
}
//Cover the small test cases like for n=1 .
public static class pair {
int a;
int b;
pair(int x, int y) {
a = x;
b = y;
}
}
public static long l() {
return obj.nextLong();
}
public static int i() {
return obj.nextInt();
}
public static String s() {
return obj.next();
}
public static long[] l(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++)
arr[i] = l();
return arr;
}
public static int[] i(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = i();
return arr;
}
public static long ceil(long a, long b) {
return (a + b - 1) / b;
}
public static void p(long val) {
out.println(val);
}
public static void p(String s) {
out.println(s);
}
public static void pl(long[] arr) {
for (int i = 0; i < arr.length; i++) {
out.print(arr[i] + " ");
}
out.println();
}
public static void p(int[] arr) {
for (int i = 0; i < arr.length; i++) {
out.print(arr[i] + " ");
}
out.println();
}
public static void sortpair(ArrayList<pair> arr) {
//ascending just change return 1 to return -1 and vice versa to get descending.
//compare based on value of pair.a
arr.sort(new Comparator<pair>() {
public int compare(pair o1, pair o2) {
long val = o1.a - o2.a;
if (val == 0)
return 0;
else if (val > 0)
return 1;
else
return -1;
}
});
}
// Take of the small test cases such as when n=1,2 etc.
// remember in case of fenwick tree ft is 1 based but our array should be 0 based.
// in fenwick tree when we update some index it doesn't change the value to val but it
// adds the val value in it so remember to add val-a[i] instead of just adding val.
//in case of finding the inverse mod do it (biexpo(a,mod-2)%mod + mod )%mod
public static ArrayList<ArrayList<pair>> adj;
public static int[] ans;
public static void main(String[] args) {
int len = i();
while (len-- != 0) {
int n = i();
adj=new ArrayList<>(n+1);
ans=new int[n];
int ok=0;
for(int i=0;i<=n;i++)adj.add(new ArrayList<>());
for(int i=0;i<n-1;i++)
{
int a=obj.nextInt();
int b=obj.nextInt();
adj.get(a).add(new pair(b,i));
adj.get(b).add(new pair(a,i));
if(adj.get(a).size()>2)ok=1;
if(adj.get(b).size()>2)ok=1;
}
if(ok==1)out.println(-1);
else
{
int[] vis=new int[n+1];
if(adj.get(1).size()==2)
{
vis[adj.get(1).get(1).a]=1;
dfs(1,vis,11);
vis[adj.get(1).get(1).a]=0;
vis[1]=0;
dfs(1,vis,2);
}
else
{
dfs(1,vis,11);
}
for(int i=0;i<n-1;i++)out.print(ans[i]+" ");
out.println();
}
}
out.flush();
}
public static void dfs(int cur,int[] vis,int c)
{
vis[cur]=1;
for(pair nd:adj.get(cur))
{
if(vis[nd.a]==1)continue;
if(c==2)ans[nd.b]=11;
else ans[nd.b]=2;
dfs(nd.a,vis,ans[nd.b]);
}
}
}
| 0 |
Non-plagiarised
|
3afcc566
|
d8a171a3
|
//package codeforces.globalround18;
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
//Think through the entire logic before jump into coding!
//If you are out of ideas, take a guess! It is better than doing nothing!
//Read both C and D, it is possible that D is easier than C for you!
//Be aware of integer overflow!
//If you find an answer and want to return immediately, don't forget to flush before return!
public class C {
static InputReader in;
static PrintWriter out;
public static void main(String[] args) {
//initReaderPrinter(true);
initReaderPrinter(false);
solve(in.nextInt());
//solve(1);
}
static void solve(int testCnt) {
for (int testNumber = 0; testNumber < testCnt; testNumber++) {
int n = in.nextInt();
char[] a = in.next().toCharArray(), b = in.next().toCharArray();
int match0 = 0, match1 = 0, mismatch10 = 0, mismatch01 = 0;
for(int i = 0; i < n; i++) {
if(a[i] == b[i]) {
if(a[i] == '0') match0++;
else match1++;
}
else {
if(a[i] == '0') mismatch01++;
else mismatch10++;
}
}
if(mismatch01 + mismatch10 == 0) out.println(0);
else {
if(match1 - match0 == 1 && mismatch01 == mismatch10) {
out.println(min(match0 + match1, mismatch01 + mismatch10));
}
else if(match1 - match0 == 1) {
out.println(match0 + match1);
}
else if(mismatch01 == mismatch10) {
out.println(mismatch01 + mismatch10);
}
else out.println(-1);
}
}
out.close();
}
static void initReaderPrinter(boolean test) {
if (test) {
try {
in = new InputReader(new FileInputStream("src/input.in"));
out = new PrintWriter(new FileOutputStream("src/output.out"));
} catch (IOException e) {
e.printStackTrace();
}
} else {
in = new InputReader(System.in);
out = new PrintWriter(System.out);
}
}
static class InputReader {
BufferedReader br;
StringTokenizer st;
InputReader(InputStream stream) {
try {
br = new BufferedReader(new InputStreamReader(stream), 32768);
} catch (Exception e) {
e.printStackTrace();
}
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
Integer[] nextIntArray(int n) {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
int[] nextIntArrayPrimitive(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
int[] nextIntArrayPrimitiveOneIndexed(int n) {
int[] a = new int[n + 1];
for (int i = 1; i <= n; i++) a[i] = nextInt();
return a;
}
Long[] nextLongArray(int n) {
Long[] a = new Long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
long[] nextLongArrayPrimitive(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
long[] nextLongArrayPrimitiveOneIndexed(int n) {
long[] a = new long[n + 1];
for (int i = 1; i <= n; i++) a[i] = nextLong();
return a;
}
String[] nextStringArray(int n) {
String[] g = new String[n];
for (int i = 0; i < n; i++) g[i] = next();
return g;
}
List<Integer>[] readGraphOneIndexed(int n, int m) {
List<Integer>[] adj = new List[n + 1];
for (int i = 0; i <= n; i++) {
adj[i] = new ArrayList<>();
}
for (int i = 0; i < m; i++) {
int u = nextInt();
int v = nextInt();
adj[u].add(v);
adj[v].add(u);
}
return adj;
}
List<Integer>[] readGraphZeroIndexed(int n, int m) {
List<Integer>[] adj = new List[n];
for (int i = 0; i < n; i++) {
adj[i] = new ArrayList<>();
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
adj[u].add(v);
adj[v].add(u);
}
return adj;
}
/*
A more efficient way of building a graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][] buildGraph(int nodeCnt, int edgeCnt) {
int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt();
edgeCntForEachNode[u]++;
edgeCntForEachNode[v]++;
end1[i] = u;
end2[i] = v;
}
int[][] adj = new int[nodeCnt + 1][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]];
}
for (int i = 0; i < edgeCnt; i++) {
adj[end1[i]][idxForEachNode[end1[i]]] = end2[i];
idxForEachNode[end1[i]]++;
adj[end2[i]][idxForEachNode[end2[i]]] = end1[i];
idxForEachNode[end2[i]]++;
}
return adj;
}
}
}
|
import java.io.*;
import java.util.*;
public class B {
public static void main(String[] args)throws IOException {
FastScanner scan = new FastScanner();
PrintWriter output = new PrintWriter(System.out);
int t = scan.nextInt();
for(int tt = 0;tt<t;tt++) {
int n = scan.nextInt();
char initial[] = scan.next().toCharArray();
char desired[] = scan.next().toCharArray();
int lit1 = 0, lit2 = 0;
int ans = Integer.MAX_VALUE;
for(int i = 0;i<n;i++) {
if(initial[i]=='1') lit1++;
if(desired[i]=='1') lit2++;
}
if(lit1==lit2) {
int count = 0;
for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
ans = Math.min(ans, count);
}
if(lit2==(n-lit1+1)) {
int count = 0;
for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
ans = Math.min(ans, count);
}
if(ans == Integer.MAX_VALUE) ans = -1;
output.println(ans);
}
output.flush();
}
public static int[] sort(int arr[]) {
List<Integer> list = new ArrayList<>();
for(int i:arr) list.add(i);
Collections.sort(list);
for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
return arr;
}
public static int gcd(int a, int b) {
if(a == 0) return b;
return gcd(b%a, a);
}
public static void printArray(int arr[]) {
for(int i:arr) System.out.print(i+" ");
System.out.println();
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
}
| 0 |
Non-plagiarised
|
5289e80a
|
d82fa7e3
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
//6 4 1 1 4 1
//-3 4 -2 0 -4 6 1
// 4 6 1
//-4 -3 -2 0 1 4 6
public class C1 {
private static void solve(List<Integer>[] g, int[][] a) {
long[] dfs = dfs(g, a, 0, -1);
System.out.println(Math.max(dfs[0], dfs[1]));
}
private static long[] dfs(List<Integer>[] g, int[][] a, int v, int p) {
long lans = 0;
long rans = 0;
for (Integer i : g[v]) {
if (i != p) {
long[] dfs = dfs(g, a, i, v);
lans += Math.max(Math.abs(a[v][0] - a[i][1]) + dfs[1], Math.abs(a[v][0] - a[i][0]) + dfs[0]);
rans += Math.max(Math.abs(a[v][1] - a[i][1]) + dfs[1], Math.abs(a[v][1] - a[i][0]) + dfs[0]);
}
}
return new long[]{lans, rans};
}
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int t = sc.nextInt();
for (int i = 0; i < t; i++) {
int n = sc.nextInt();
int[][] a = new int[n][2];
for (int j = 0; j < n; j++) {
a[j] = new int[]{sc.nextInt(), sc.nextInt()};
}
List<Integer>[] g = new ArrayList[n];
for (int j = 0; j < n; j++) {
g[j] = new ArrayList<>();
}
for (int j = 0; j < n - 1; j++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
g[u].add(v);
g[v].add(u);
}
solve(g, a);
}
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long[] readArrayLong(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
int[] readArrayInt(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
}
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastReader in = new FastReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
CParsasHumongousTree solver = new CParsasHumongousTree();
int testCount = Integer.parseInt(in.next());
for (int i = 1; i <= testCount; i++)
solver.solve(i, in, out);
out.close();
}
static class CParsasHumongousTree {
int n;
long[][] dp;
int[] l;
int[] r;
ArrayList<Integer>[] a;
public void solve(int testNumber, FastReader in, PrintWriter out) {
n = in.nextInt();
l = new int[n];
r = new int[n];
dp = new long[n][2];
a = new ArrayList[n];
for (int i = 0; i < n; ++i) {
a[i] = new ArrayList<>();
}
for (int i = 0; i < n; ++i) {
l[i] = in.nextInt();
r[i] = in.nextInt();
}
for (int i = 0; i < n - 1; ++i) {
int u = in.nextInt() - 1, v = in.nextInt() - 1;
a[u].add(v);
a[v].add(u);
}
dfs(0, -1);
out.println(Math.max(dp[0][0], dp[0][1]));
}
void dfs(int u, int p) {
dp[u][0] = dp[u][1] = 0;
for (int v : a[u]) {
if (v != p) {
dfs(v, u);
dp[u][0] += Math.max(dp[v][0] + Math.abs(l[u] - l[v]), dp[v][1] + Math.abs(l[u] - r[v]));
dp[u][1] += Math.max(dp[v][0] + Math.abs(r[u] - l[v]), dp[v][1] + Math.abs(r[u] - r[v]));
}
}
}
}
static class FastReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private FastReader.SpaceCharFilter filter;
public FastReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
public String next() {
int c = read();
while (isSpaceChar(c)) c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| 0 |
Non-plagiarised
|
17e67976
|
656b62de
|
import java.util.*;
public class code
{
int hell(String arr[],int a,int n)
{
int sum=0;
int s=0;
int arr1[]=new int[n];
int x=0;
int y=0;
for(int i=0;i<n;i++)
{
int l=arr[i].length();
for(int j=0;j<l;j++)
{
if(arr[i].charAt(j)==a)
x++;
else
y++;
}
arr1[i]=y-x;
y=0;
x=0;
}
Arrays.sort(arr1);
for(int i=0;i<n;i++)
{
s+=arr1[i];
if(s<0)
sum++;
else
break;
}
return sum;
}
public static void main(String args[])
{
code ob=new code();
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0)
{
int sum1=0;
int sum2=0;
int n=sc.nextInt();
String arr[]=new String[n];
for(int i=0;i<n;i++)
{
arr[i]=sc.next();
}
for(int i=97;i<=102;i++)
{
sum2=ob.hell(arr,i,n);
sum1=Math.max(sum2,sum1);
}
System.out.println(sum1);
}
}
}
|
//import java.io.IOException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.util.PriorityQueue;
public class InterestingStory {
static InputReader inputReader=new InputReader(System.in);
static void solve()
{
int n=inputReader.nextInt();
String arr[]=new String[n];
for (int i=0;i<n;i++)
{
arr[i]=inputReader.readString();
}
int larr[]=new int[n];
for (int i=0;i<n;i++) {
larr[i] = arr[i].length();
}
int freqarr[][]=new int[n][5];
for (int i=0;i<n;i++)
{
freqarr[i]=freq(arr[i],larr[i]);
}
int max=Integer.MIN_VALUE;
for (char c='a';c<='e';c++)
{
max=Math.max(max,helper(freqarr,larr,n,c));
}
out.println(max);
}
static int helper(int freqarr[][],int larr[],int n,char c)
{
int sum=0;
PriorityQueue<Integer>priorityQueue=new PriorityQueue<>();
for (int i=0;i<n;i++)
{
int score=freqarr[i][c-'a']-(larr[i]-freqarr[i][c-'a']);
priorityQueue.add(score);
sum+=score;
}
while (!priorityQueue.isEmpty()&&sum<=0) {
sum -= priorityQueue.poll();
}
return priorityQueue.size();
}
static int []freq(String str,int len)
{
int arr[]=new int[5];
for (int i=0;i<len;i++)
{
arr[str.charAt(i)-'a']++;
}
return arr;
}
static PrintWriter out=new PrintWriter((System.out));
public static void main(String args[])throws IOException
{
int t=inputReader.nextInt();
while(t-->0)
{
solve();
}
out.close();
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int snext() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public String readString() {
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| 0 |
Non-plagiarised
|
40cc90ae
|
9399204d
|
import javax.swing.text.html.parser.Entity;
import java.io.*;
import java.util.*;
import java.math.BigInteger;
public class Main{
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task();
solver.solve(in, out);
out.close();
}
// main solver
static class Task{
double eps= 0.00000001;
static final int MAXN = 1010;
static final int MOD= 1000000007;
// stores smallest prime factor for every number
static int spf[] = new int[MAXN];
static boolean[] prime;
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
public void sieve()
{
spf[1] = 1;
for (int i=2; i<MAXN; i++)
// marking smallest prime factor for every
// number to be itself.
spf[i] = i;
// separately marking spf for every even
// number as 2
for (int i=4; i<MAXN; i+=2)
spf[i] = 2;
for (int i=3; i*i<MAXN; i++)
{
// checking if i is prime
if (spf[i] == i)
{
// marking SPF for all numbers divisible by i
for (int j=i*i; j<MAXN; j+=i)
// marking spf[j] if it is not
// previously marked
if (spf[j]==j)
spf[j] = i;
}
}
}
void sieveOfEratosthenes(int n)
{
// Create a boolean array
// "prime[0..n]" and
// initialize all entries
// it as true. A value in
// prime[i] will finally be
// false if i is Not a
// prime, else true.
prime= new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++)
{
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true)
{
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
}
// function to find first index >= x
public int lowerIndex(List<Integer> arr, int n, int x)
{
int l = 0, h = n - 1;
while (l <= h)
{
int mid = (l + h) / 2;
if (arr.get(mid) >= x)
h = mid - 1;
else
l = mid + 1;
}
return l;
}
public int lowerIndex(int[] arr, int n, int x)
{
int l = 0, h = n - 1;
while (l <= h)
{
int mid = (l + h) / 2;
if (arr[mid] >= x)
h = mid - 1;
else
l = mid + 1;
}
return l;
}
// function to find last index <= y
public int upperIndex(List<Integer> arr, int n, int y)
{
int l = 0, h = n - 1;
while (l <= h)
{
int mid = (l + h) / 2;
if (arr.get(mid) <= y)
l = mid + 1;
else
h = mid - 1;
}
return h;
}
public int upperIndex(int[] arr, int n, int y)
{
int l = 0, h = n - 1;
while (l <= h)
{
int mid = (l + h) / 2;
if (arr[mid] <= y)
l = mid + 1;
else
h = mid - 1;
}
return h;
}
// function to count elements within given range
public int countInRange(List<Integer> arr, int n, int x, int y)
{
// initialize result
int count = 0;
count = upperIndex(arr, n, y) -
lowerIndex(arr, n, x) + 1;
return count;
}
public int _gcd(int a, int b)
{
if(b == 0) {
return a;
}
else {
return _gcd(b, a % b);
}
}
public int add(int a, int b){
a+=b;
if(a>=MOD) a-=MOD;
else if(a<0) a+=MOD;
return a;
}
public int mul(int a, int b){
long res= (long)a*(long)b;
return (int)(res%MOD);
}
public int power(int a, int b) {
int ans=1;
while(b>0){
if((b&1)!=0) ans= mul(ans,a);
b>>=1;
a= mul(a,a);
}
return ans;
}
int[] fact= new int[MAXN];
int[] inv= new int[MAXN];
public int Ckn(int n, int k){
if(k<0 || n<0) return 0;
return mul(mul(fact[n],inv[k]),inv[n-k]);
}
public int inverse(int a){
return power(a,MOD-2);
}
public void preprocess() {
fact[0]=1;
for(int i=1;i<MAXN;i++) fact[i]= mul(fact[i-1],i);
inv[MAXN-1]= inverse(fact[MAXN-1]);
for(int i=MAXN-2;i>=0;i--){
inv[i]= mul(inv[i+1],i+1);
}
}
/**
* return VALUE of lower bound for unsorted array
*/
public int lowerBoundNormalArray(int[] arr, int x){
TreeSet<Integer> set= new TreeSet<>();
for(int num: arr) set.add(num);
return set.lower(x);
}
/**
* return VALUE of upper bound for unsorted array
*/
public int upperBoundNormalArray(int[] arr, int x){
TreeSet<Integer> set= new TreeSet<>();
for(int num: arr) set.add(num);
return set.higher(x);
}
public void debugArr(int[] arr){
for(int i: arr) out.print(i+" ");
out.println();
}
public int rand(){
int min=0, max= MAXN;
int random_int = (int)Math.floor(Math.random()*(max-min+1)+min);
return random_int;
}
InputReader in; PrintWriter out;
static int mod = 1000000007;
int ans = 0;
ArrayList<Integer>g[] = new ArrayList[101];
int cnt[][] = new int[101][101];
int dp[][] = new int[101][101];
int Add(int a, int b){
a+=b; while (a>=mod)a-=mod;
return a;
}
int Mul(int a, int b){
return (int)(((long)a * b) % mod);
}
void dfs(int node, int par, int root, int depth){
cnt[root][depth]++;
for (int v : g[node]){
if (v != par){
dfs(v, node, root, depth+1);
}
}
}
public void solve(InputReader in, PrintWriter out) {
int t = in.nextInt();
while (t-- > 0){
int n = in.nextInt();
String[] str = new String[n];
ArrayList<Integer> diff[] = new ArrayList[5];
for (int i = 0; i < 5; i++) diff[i] = new ArrayList<>();
for (int i = 0; i < n; i++){
str[i] = in.nextToken();
int[] cnt = new int[5];
for (int j = 0; j < str[i].length(); j++){
cnt[str[i].charAt(j) - 'a']++;
}
for (int j = 0; j < 5; j++){
diff[j].add(cnt[j] * 2 - str[i].length());
}
}
int ans = 0;
for (int i = 0; i < 5; i++){
Collections.sort(diff[i]);
Collections.reverse(diff[i]);
int cur = 0, x = 0;
for (int j = 0; j < diff[i].size(); j++){
cur+=diff[i].get(j);
if (cur <= 0){
break;
}
x++;
}
ans = Math.max(ans, x);
}
out.println(ans);
}
}
class SEG {
int n;
int[] segs;
public SEG (int[] a){
this.n= a.length;
segs= new int[4*this.n];
build(a,0,0,this.n-1);
}
public void build(int[] a, int root, int l, int r){
if(l==r){
segs[root]=a[l];
return;
}
int m= (l+r)/2;
build(a,2*root+1,l,m);
build(a,2*root+2,m+1,r);
segs[root]= _gcd(segs[2*root+1], segs[2*root+2]);
}
public int query(int root, int l, int r, int lq, int rq){
if(lq<=l && rq>=r) return segs[root];
if(lq>r || rq<l) return 0;
int m= (l+r)/2;
int left= query(2*root+1, l, m, lq, rq);
int right= query(2*root+2, m+1, r, lq, rq);
return _gcd(left,right);
}
}
}
static class Venice{
public Map<Long,Long> m= new HashMap<>();
public long base=0;
public long totalValue=0;
private int M= 1000000007;
private long addMod(long a, long b){
a+=b;
if(a>=M) a-=M;
return a;
}
public void reset(){
m= new HashMap<>();
base=0;
totalValue=0;
}
public void update(long add){
base= base+ add;
}
public void add(long key, long val){
long newKey= key-base;
m.put(newKey, addMod(m.getOrDefault(newKey,(long)0),val));
}
}
static class Tuple implements Comparable<Tuple>{
int x, y, z;
public Tuple(int x, int y, int z){
this.x= x;
this.y= y;
this.z=z;
}
@Override
public int compareTo(Tuple o){
return this.x-o.x;
}
}
static class Pair implements Comparable<Pair>{
public int x;
public int y;
public Pair(int x, int y){
this.x= x;
this.y= y;
}
@Override
public int compareTo(Pair o) {
return this.x-o.x;
}
}
// public static class compareL implements Comparator<Tuple>{
// @Override
// public int compare(Tuple t1, Tuple t2) {
// return t2.l - t1.l;
// }
// }
// fast input reader class;
static class InputReader {
BufferedReader br;
StringTokenizer st;
public InputReader(InputStream stream) {
br = new BufferedReader(new InputStreamReader(stream));
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
String line = null;
try {
line = br.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
if (line == null) {
return null;
}
st = new StringTokenizer(line);
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public double nextDouble(){
return Double.parseDouble(nextToken());
}
public long nextLong(){
return Long.parseLong(nextToken());
}
public int[] nextIntArr(int n){
int[] arr= new int[n];
for(int i=0;i<n;i++) arr[i]= nextInt();
return arr;
}
public long[] nextLongArr(int n){
long[] arr= new long[n];
for(int i=0;i<n;i++) arr[i]= nextLong();
return arr;
}
public List<Integer> nextIntList(int n){
List<Integer> arr= new ArrayList<>();
for(int i=0;i<n;i++) arr.add(nextInt());
return arr;
}
public int[][] nextIntMatArr(int n, int m){
int[][] mat= new int[n][m];
for(int i=0;i<n;i++) for(int j=0;j<m;j++) mat[i][j]= nextInt();
return mat;
}
public List<List<Integer>> nextIntMatList(int n, int m){
List<List<Integer>> mat= new ArrayList<>();
for(int i=0;i<n;i++){
List<Integer> temp= new ArrayList<>();
for(int j=0;j<m;j++) temp.add(nextInt());
mat.add(temp);
}
return mat;
}
public char[] nextStringCharArr(){
return nextToken().toCharArray();
}
}
}
|
import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger;
public final class A
{
static PrintWriter out = new PrintWriter(System.out);
static StringBuilder ans=new StringBuilder();
static FastReader in=new FastReader();
static ArrayList<Integer> g[];
static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
static boolean set[],col[];
static int par[],tot[],partial[];
static int D[],P[][];
static long dp[][],sum=0,max=0,size[];
// static node1 seg[];
//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
public static void main(String args[])throws IOException
{
int T=i();
outer:while(T-->0)
{
int N=i();
int size[]=new int[N];
PriorityQueue<node1> q[]=new PriorityQueue[6];
for(int i=0; i<5; i++)q[i]=new PriorityQueue<node1>();
for(int i=0; i<N; i++)
{
char X[]=in.next().toCharArray();
int s=X.length;
size[i]=s;
int f[]=new int[5];
for(char x:X)f[x-'a']++;
for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
}
int max=0;
for(int i=0; i<5; i++)
{
PriorityQueue<node1> q_new=new PriorityQueue<>();
q_new=q[i];
int c=0;
long f=0;
while(q_new.size()>0)
{
node1 x=q_new.remove();
// System.out.println(x.f+" "+x.size+" "+x.a);
f+=x.a;
if(f>0)
{
c++;
max=Math.max(max, c);
}
else break;
}
}
out.println(max);
}
out.close();
}
static int OR(int i,int j)
{
if(i>j)
{
int t=i;
i=j;
j=t;
}
System.out.println("OR "+i+" "+j);
return i();
}
static int AND(int i,int j)
{
if(i>j)
{
int t=i;
i=j;
j=t;
}
System.out.println("AND "+i+" "+j);
return i();
}
static int XOR(int i,int j)
{
if(i>j)
{
int t=i;
i=j;
j=t;
}
System.out.println("XOR "+i+" "+j);
return i();
}
static boolean f1(int l,char X[])
{
int i=0;
for(; l<X.length; l++)
{
if(X[i]!=X[l])return false;
i++;
}
return true;
}
static int f(int a)
{
for(int i=a+1; a>0; a++)
{
if(GCD(i,a)==1)return i;
}
return 0;
}
static int min(char X[],char str[],int N)
{
int s=0;
for(int i=0; i<N; i++)
{
int it=i%3;
if(X[i]!=str[it])s++;
// ans.append(str[it]);
}
return s;
}
static char f(int i,char X[])
{
int a=0,b=0,c=0;
for(; i<X.length; i+=3)
{
if(X[i]=='R')a++;
if(X[i]=='B')b++;
if(X[i]=='G')c++;
}
if(a>=b && a>=c)return 'R';
if(b>=a && b>=c)return 'B';
return 'G';
}
static void f1(int n,int p,long sum,int N)
{
for(int c:g[n])
{
if(c==p)continue;
long s=sum+N-2*size[c];
f1(c,n,s,N);
max=Math.max(max, s);
}
}
static long f(int i,int j,ArrayList<Integer> A)
{
if(i+1==A.size())
{
return j;
}
int moves=1+A.get(i);
if(j==1)return 1+f(i+1,moves,A);
if(j>0 && dp[i][j-1]==0)f(i,j-1,A);
return dp[i][j]=dp[i][j-1]+f(i+1,j+moves,A);
}
// static void build(int v,int tl,int tr,long A[])
// {
// if(tl==tr)
// {
// seg[v]=new node1(A[tl],A[tr],1,true);
// return ;
// }
// int tm=(tl+tr)/2;
// build(2*v,tl,tm,A);
// build(2*v+1,tm+1,tr,A);
// seg[v]=merge(seg[2*v],seg[2*v+1]);
// }
// static node1 ask(int v,int tl,int tr,int l,int r)
// {
// if(l>r)return new node1(0,0,0,false);//verify true or false
// if(tl==l && tr==r)return seg[v];
// int tm=(tl+tr)/2;
// node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
// node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
// return merge(a,b);
// }
// static node1 merge(node1 a,node1 b)
// {
// long s=0;
// long l1=a.L,r1=a.R,c1=a.cnt;
// long l2=b.L,r2=b.R,c2=b.cnt;
// long g=GCD(l2,r1); s=c1+c2;
// if(g==1)
// {
// s--;
// g=(l2*r1)/g;
// if(c1==1)
// {
// l1=g;
// }
// if(c2==1)r2=g;
// return new node1(l1,r2,s,true);
// }
// return new node1(l1,r2,s,a.leaf^b.leaf);
// }
static long f(long l,long r,long a,long b,long N)
{
while(r-l>1)
{
long m=(l+r)/2;
long x=m*b;
if(N<x)
{
r=m;
continue;
}
if((N-x)%a==0)r=m;
else l=m;
}
return r;
}
static long f1(long a,long A[],long bits[],long sum)
{
long s=A.length;
s=mul(s,a);
s=(s+(sum%mod))%mod;
long p=1L;
for(long x:bits)
{
if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
p<<=1;
}
return s;
}
static long f2(long a,long A[],long bits[])
{
long s=0;
long p=1L;
for(long x:bits)
{
if((a&p)!=0)
{
s=(s+mul(p,x))%mod;
}
p<<=1;
}
return s;
}
static long f(long x1,long y1,long x2,long y2)
{
return Math.abs(x1-x2)+Math.abs(y1-y2);
}
static long f(long x,long max,long s)
{
long l=-1,r=(x/s)+1;
while(r-l>1)
{
long m=(l+r)/2;
if(x-m*s>max)l=m;
else r=m;
}
return l+1;
}
static int f(long A[],long x)
{
int l=-1,r=A.length;
while(r-l>1)
{
int m=(l+r)/2;
if(A[m]>=x)r=m;
else l=m;
}
return r;
}
static int bin(int x,ArrayList<Integer> A)
{
int l=0,r=A.size()-1;
while(l<=r)
{
int m=(l+r)/2;
int a=A.get(m);
if(a==x)return m;
if(a<x)l=m+1;
else r=m-1;
}
return 0;
}
static int left(int x,ArrayList<Integer> A)
{
int l=-1,r=A.size();
while(r-l>1)
{
int m=(l+r)/2;
int a=A.get(m);
if(a<=x)l=m;
else r=m;
}
return l;
}
static int right(int x,ArrayList<Integer> A)
{
int l=-1,r=A.size();
while(r-l>1)
{
int m=(l+r)/2;
int a=A.get(m);
if(a<x)l=m;
else r=m;
}
return r;
}
static boolean equal(long A[],long B[])
{
for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
return true;
}
static int max(int a ,int b,int c,int d)
{
a=Math.max(a, b);
c=Math.max(c,d);
return Math.max(a, c);
}
static int min(int a ,int b,int c,int d)
{
a=Math.min(a, b);
c=Math.min(c,d);
return Math.min(a, c);
}
static HashMap<Integer,Integer> Hash(int A[])
{
HashMap<Integer,Integer> mp=new HashMap<>();
for(int a:A)
{
int f=mp.getOrDefault(a,0)+1;
mp.put(a, f);
}
return mp;
}
static long mul(long a, long b)
{
return ( a %mod * 1L * b%mod )%mod;
}
static void swap(int A[],int a,int b)
{
int t=A[a];
A[a]=A[b];
A[b]=t;
}
static int find(int a)
{
if(par[a]<0)return a;
return par[a]=find(par[a]);
}
static void union(int a,int b)
{
a=find(a);
b=find(b);
if(a!=b)
{
par[a]+=par[b];
par[b]=a;
}
}
static boolean isSorted(int A[])
{
for(int i=1; i<A.length; i++)
{
if(A[i]<A[i-1])return false;
}
return true;
}
static boolean isDivisible(StringBuilder X,int i,long num)
{
long r=0;
for(; i<X.length(); i++)
{
r=r*10+(X.charAt(i)-'0');
r=r%num;
}
return r==0;
}
static int lower_Bound(int A[],int low,int high, int x)
{
if (low > high)
if (x >= A[high])
return A[high];
int mid = (low + high) / 2;
if (A[mid] == x)
return A[mid];
if (mid > 0 && A[mid - 1] <= x && x < A[mid])
return A[mid - 1];
if (x < A[mid])
return lower_Bound( A, low, mid - 1, x);
return lower_Bound(A, mid + 1, high, x);
}
static String f(String A)
{
String X="";
for(int i=A.length()-1; i>=0; i--)
{
int c=A.charAt(i)-'0';
X+=(c+1)%2;
}
return X;
}
static void sort(long[] a) //check for long
{
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static String swap(String X,int i,int j)
{
char ch[]=X.toCharArray();
char a=ch[i];
ch[i]=ch[j];
ch[j]=a;
return new String(ch);
}
static int sD(long n)
{
if (n % 2 == 0 )
return 2;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0 )
return i;
}
return (int)n;
}
static void setGraph(int N)
{
tot=new int[N+1];
partial=new int[N+1];
D=new int[N+1];
P=new int[N+1][(int)(Math.log(N)+10)];
set=new boolean[N+1];
g=new ArrayList[N+1];
for(int i=0; i<=N; i++)
{
g[i]=new ArrayList<>();
D[i]=Integer.MAX_VALUE;
//D2[i]=INF;
}
}
static long pow(long a,long b)
{
//long mod=1000000007;
long pow=1;
long x=a;
while(b!=0)
{
if((b&1)!=0)pow=(pow*x)%mod;
x=(x*x)%mod;
b/=2;
}
return pow;
}
static long toggleBits(long x)//one's complement || Toggle bits
{
int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;
return ((1<<n)-1)^x;
}
static int countBits(long a)
{
return (int)(Math.log(a)/Math.log(2)+1);
}
static long fact(long N)
{
long n=2;
if(N<=1)return 1;
else
{
for(int i=3; i<=N; i++)n=(n*i)%mod;
}
return n;
}
static int kadane(int A[])
{
int lsum=A[0],gsum=A[0];
for(int i=1; i<A.length; i++)
{
lsum=Math.max(lsum+A[i],A[i]);
gsum=Math.max(gsum,lsum);
}
return gsum;
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static boolean isPrime(long N)
{
if (N<=1) return false;
if (N<=3) return true;
if (N%2 == 0 || N%3 == 0) return false;
for (int i=5; i*i<=N; i=i+6)
if (N%i == 0 || N%(i+2) == 0)
return false;
return true;
}
static void print(char A[])
{
for(char c:A)System.out.print(c+" ");
System.out.println();
}
static void print(boolean A[])
{
for(boolean c:A)System.out.print(c+" ");
System.out.println();
}
static void print(int A[])
{
for(int a:A)System.out.print(a+" ");
System.out.println();
}
static void print(long A[])
{
for(long i:A)System.out.print(i+ " ");
System.out.println();
}
static void print(ArrayList<Integer> A)
{
for(int a:A)System.out.print(a+" ");
System.out.println();
}
static int i()
{
return in.nextInt();
}
static long l()
{
return in.nextLong();
}
static int[] input(int N){
int A[]=new int[N];
for(int i=0; i<N; i++)
{
A[i]=in.nextInt();
}
return A;
}
static long[] inputLong(int N) {
long A[]=new long[N];
for(int i=0; i<A.length; i++)A[i]=in.nextLong();
return A;
}
static long GCD(long a,long b)
{
if(b==0)
{
return a;
}
else return GCD(b,a%b );
}
}
class node1 implements Comparable<node1>
{
int index,f,size;
long a;
node1(int f,int i,int size)
{
this.f=f;
this.index=i;
this.size=size;
a=2*f-size;
}
public int compareTo(node1 x)
{
if(this.a==x.a)return 0;
else if(this.a<x.a)return 1;
else return -1;
}
}
//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br=new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while(st==null || !st.hasMoreElements())
{
try
{
st=new StringTokenizer(br.readLine());
}
catch(IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str="";
try
{
str=br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
| 0 |
Non-plagiarised
|
1162c08f
|
f6ca6fc8
|
import java.util.*;
public class CodeForces1525C{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
for(int i=1;i<=n;i++){
int x=sc.nextInt();
if(x==1)o.add(i);
else e.add(i);
}
for(int i=1;i<=o.size();i++){
dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
for(int j=i+1;j<=e.size();j++)
dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
}
System.out.println(dp[o.size()][e.size()]);
}
}
|
import java.util.*;
import java.io.*;
public class D {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n = sc.nextInt();
ArrayList<Integer> o=new ArrayList<Integer>();
ArrayList<Integer> e=new ArrayList<Integer>();
for(int i=1;i<=n;i++){
int x=sc.nextInt();
if(x==1)o.add(i);
else e.add(i);
}
int dp[][]=new int[o.size()+1][e.size()+1];
for(int i=1;i<=o.size();i++){
dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
for(int j=i+1;j<=e.size();j++){
dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
}
}
System.out.println(dp[o.size()][e.size()]);
}
}
| 1 |
Plagiarised
|
8a39dbf5
|
e1a5831a
|
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 Codeforces {
public static void main(String[] args) throws java.lang.Exception {
/* your code goes here */
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(buf.readLine());
StringBuilder sb = new StringBuilder();
for (int i = 0; i < t; i++) {
String st=buf.readLine();
String st1[]=(buf.readLine()).split(" ");
int n=Integer.parseInt(st1[0]);
int k=Integer.parseInt(st1[1]);
int a[]=new int[k];
int temp[]=new int[k];
long arr[]=new long[n];
String st2[]=(buf.readLine()).split(" ");
String st3[]=(buf.readLine()).split(" ");
for(int j=0;j<k;j++)
{
a[j]=Integer.parseInt(st2[j]);
temp[j]=Integer.parseInt(st3[j]);
}
for(int j=0;j<k;j++)
{
arr[a[j]-1]=temp[j];
}
long min=Integer.MAX_VALUE;
long left[]=new long[n];
long right[]=new long[n];
if(arr[0]==0)
left[0]=min;
else
left[0]=arr[0];
for(int j=1;j<n;j++)
{
if(arr[j]==0)
{
left[j]=left[j-1]+1;
}
else
{
left[j]=Math.min(left[j-1]+1,arr[j]);
}
}
if(arr[n-1]==0)
right[n-1]=min;
else
right[n-1]=arr[n-1];
for(int j=n-2;j>=0;j--)
{
if(arr[j]==0)
{
right[j]=right[j+1]+1;
}
else
{
right[j]=Math.min(right[j+1]+1,arr[j]);
}
}
for(int j=0;j<n;j++)
{
arr[j]=Math.min(left[j],right[j]);
sb.append(arr[j]+" ");
}
sb.append("\n");
}
System.out.println(sb);
}
}
|
/* 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 Codechef
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
for(int q=0;q<t;q++){
// int n = Integer.parseInt(br.readLine());
String s = br.readLine();
String s1[] = br.readLine().split(" ");
int n = Integer.parseInt(s1[0]);
int k = Integer.parseInt(s1[1]);
String s2[] = br.readLine().split(" ");
int a[] = new int[k];
for(int i=0;i<k;i++){
a[i] = Integer.parseInt(s2[i]);
}
String s3[] = br.readLine().split(" ");
int b[] = new int[k];
for(int i=0;i<k;i++){
b[i] = Integer.parseInt(s3[i]);
}
long ans[] = new long[n];
for(int i=0;i<n;i++){
ans[i] = Integer.MAX_VALUE;
}
for(int i=0;i<k;i++){
ans[a[i]-1] = b[i];
}
for(int i=1;i<n;i++){
ans[i] = Math.min(ans[i],ans[i-1]+1);
}
for(int i=n-2;i>=0;i--){
ans[i] = Math.min(ans[i],ans[i+1]+1);
}
for(int i=0;i<n;i++){
System.out.print(ans[i]+" ");
}
System.out.println();
}
}
}
| 0 |
Non-plagiarised
|
2063ba3e
|
2ba7edb6
|
import java.io.*;
import java.util.*;
public class c {
public static void main(String[] args) throws Exception {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int numCases = Integer.parseInt(in.readLine());
for (int casenum = 0; casenum < numCases; casenum++) {
int n = Integer.parseInt(in.readLine());
long[] arr = new long[n];
StringTokenizer tokenizer = new StringTokenizer(in.readLine());
for (int i = 0; i < n; i++) {
arr[i] = Long.parseLong(tokenizer.nextToken());
}
long low = 0;
long high = 1000000000;
low--;
while (low < high) {
long mid = low + (high - low + 1) / 2;
boolean works = test(arr, mid);
if (works) {
low = mid;
} else {
high = mid - 1;
}
//System.out.println(mid + " " + works);
}
System.out.println(low);
}
in.close();
out.close();
}
public static boolean test(long[] arr, long k) {
long[] h = new long[arr.length];
for (int i = 0; i < arr.length; i++) {
h[i] = arr[i];
}
for (int i = h.length - 1; i - 2 >= 0; i--) {
if (h[i] < k)
break;
long d = Math.min((h[i]-k) / 3, arr[i]/3);
h[i] -= 3 * d;
h[i - 1] += d;
h[i-+ 2] += 2 * d;
}
for (int i = 0; i < h.length; i++) {
if (h[i] < k)
return false;
}
//System.out.println(Arrays.toString(h));
return true;
}
}
|
import java.util.*;
import java.io.*;
public class BalancedStones {
public static void main(String[] args) throws IOException {
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(f.readLine());
while (t > 0) {
t--;
int n = Integer.parseInt(f.readLine());
int[] arr = new int[n];
StringTokenizer st = new StringTokenizer(f.readLine());
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
int low = 0;
int high = 1000000000;
int answer = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (check(mid, arr)) {
answer = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
System.out.println(answer);
}
}
public static boolean check(int value, int[] old) {
int[] newarr = new int[old.length];
for (int i = 0; i < old.length; i++) {
newarr[i] = old[i];
}
for (int i = old.length - 1; i >= 0; i--) {
if (newarr[i] < value)
return false;
if (i > 1) {
int d = Math.min(newarr[i] - value, old[i]) / 3;
newarr[i] -= 3 * d;
newarr[i - 1] += d;
newarr[i - 2] += 2 * d;
}
}
return true;
}
}
| 0 |
Non-plagiarised
|
29cb9b0e
|
d3da65ff
|
import java.util.*;
public class Main
{
public static void solve (int ar[],int n)
{
if(n%2==1)
{
int c=ar[2];
int b=ar[1];
int a=ar[0];
if(a+b!=0)
{
ar[2]=-(a+b);
ar[1]=c;
ar[0]=c;
}
else if(b+c!=0)
{
ar[2]=a;
ar[1]=a;
ar[0]=-(b+c);
}
else
{
ar[2]=b;
ar[1]=-(a+c);
ar[0]=b;
}
System.out.print(ar[0]+" "+ar[1]+" "+ar[2]+" ");
for(int i=3;i<(n);i=i+2)
{
System.out.print((-ar[i+1])+" "+ar[i]+" ");
}
System.out.println();
}
// System.out.println(ans[n-1]+ " x"+ans[n-2]+" x"+ans[n-3]);
else
{
for(int i=0;i<(n);i=i+2)
{
System.out.print((-ar[i+1])+" "+ar[i]+" ");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
int ar[]=new int[n];
for(int i=0;i<n;i++)
ar[i]=sc.nextInt();
solve(ar,n);
}
}
}
|
import java.util.*;
public class Main
{
public static void solve (int ar[],int n)
{
if(n%2==1)
{
int c=ar[2];
int b=ar[1];
int a=ar[0];
if(a+b!=0)
{
ar[2]=-(a+b);
ar[1]=c;
ar[0]=c;
}
else if(b+c!=0)
{
ar[2]=a;
ar[1]=a;
ar[0]=-(b+c);
}
else
{
ar[2]=b;
ar[1]=-(a+c);
ar[0]=b;
}
System.out.print(ar[0]+" "+ar[1]+" "+ar[2]+" ");
for(int i=3;i<(n);i=i+2)
{
System.out.print((-ar[i+1])+" "+ar[i]+" ");
}
System.out.println();
}
// System.out.println(ans[n-1]+ " x"+ans[n-2]+" x"+ans[n-3]);
else
{
for(int i=0;i<(n);i=i+2)
{
System.out.print((-ar[i+1])+" "+ar[i]+" ");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
int ar[]=new int[n];
for(int i=0;i<n;i++)
ar[i]=sc.nextInt();
solve(ar,n);
}
}
}
| 1 |
Plagiarised
|
764484c3
|
9028caf7
|
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 Armchairs
{
public static void main (String[] args) throws java.lang.Exception
{
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = sc.nextInt();
Vector<Integer> a = new Vector();
Vector<Integer> b = new Vector();
for (int i=0; i<n; ++i){
int input = sc.nextInt();
if(input==1) a.add(i);
else b.add(i);
}
n = a.size();
int m = b.size();
if(n==0) out.print(0);
else{
int [][]dp = new int [n][m];
for (int i=0; i<n; ++i) for (int j=0; j<m; ++j) dp[i][j] = 25000000;
dp[0][0] = Math.abs(a.get(0) - b.get(0));
for (int i=0; i<n; ++i) for (int j=1; j<m; ++j){
if(i==0) dp[i][j] = Math.min(Math.abs(a.get(i) - b.get(j)),dp[i][j-1]);
else dp[i][j] = Math.min(Math.abs(a.get(i) - b.get(j)) + dp[i-1][j-1],dp[i][j-1]);
}
out.print(dp[n-1][m-1]);
}
out.close();
}
/*Methods*/
static int min(int... ar){int min=Integer.MAX_VALUE;for(int i:ar)min=Math.min(min, i);return min;}
static long min(long... ar){long min=Long.MAX_VALUE;for(long i:ar)min=Math.min(min, i);return min;}
static int max(int... ar) {int max=Integer.MIN_VALUE;for(int i:ar)max=Math.max(max, i);return max;}
static long max(long... ar) {long max=Long.MIN_VALUE;for(long i:ar)max=Math.max(max, i);return max;}
static void reverse(int a[]){for(int i=0;i<a.length>>1;i++){int tem=a[i];a[i]=a[a.length-1-i];a[a.length-1-i]=tem;}}
static void reverse(long a[]){for(int i=0;i<a.length>>1;i++){long tem=a[i];a[i]=a[a.length-1-i];a[a.length-1-i]=tem;}}
static String reverse(String s){StringBuilder sb=new StringBuilder(s);sb.reverse();return sb.toString();}
}
|
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 int[n];
ArrayList<Integer> list=new ArrayList<>();
ArrayList<Integer> space=new ArrayList<>();
for(int i=0;i<n;i++)
{
a[i]=input.nextInt();
if(a[i]==1)
{
list.add(i);
}
else
{
space.add(i);
}
}
int pre[]=new int[space.size()];
for(int i=0;i<list.size();i++)
{
if(i==0)
{
int min=Integer.MAX_VALUE;
for(int j=0;j<space.size();j++)
{
pre[j]=Math.abs(list.get(i)-space.get(j));
min=Math.min(min,pre[j]);
pre[j]=min;
}
}
else
{
int arr[]=new int[space.size()];
for(int j=0;j<i;j++)
{
arr[j]=Integer.MAX_VALUE;
}
int min=Integer.MAX_VALUE;
for(int j=i;j<space.size();j++)
{
int v=Math.abs(list.get(i)-space.get(j));
v+=pre[j-1];
arr[j]=v;
min=Math.min(min,v);
arr[j]=min;
}
for(int j=0;j<space.size();j++)
{
pre[j]=arr[j];
}
}
}
out.println(pre[space.size()-1]);
}
out.close();
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str="";
try
{
str=br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
| 0 |
Non-plagiarised
|
14b0fb8e
|
d221162a
|
import java.io.*;
import java.util.*;
public class Solution {
static long res;
public static void main(String[] args) throws Exception
{
FastReader fr=new FastReader();
int n=fr.nextInt();
ArrayList<Integer> oc=new ArrayList<>();
ArrayList<Integer> em=new ArrayList<>();
res=Long.MAX_VALUE;
for(int i=0;i<n;i++) {
int v=fr.nextInt();
if(v==1)
oc.add(i);
else
em.add(i);
}
Collections.sort(oc);
Collections.sort(em);
long dp[][]=new long[5001][5001];
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[i].length;j++) {
dp[i][j]=-1;
}
}
System.out.println(getMin(oc,em,0,0,dp));
}
public static long getMin(ArrayList<Integer> oc,ArrayList<Integer> em,int idx,int j,long dp[][]) {
if(idx==oc.size())
return 0;
long available=em.size()-j;
long req=oc.size()-idx;
if(available<req)
return Integer.MAX_VALUE;
if(dp[idx][j]!=-1)
return dp[idx][j];
long ch1=getMin(oc,em,idx,j+1,dp);
long ch2=getMin(oc,em,idx+1,j+1,dp)+Math.abs(em.get(j)-oc.get(idx));
return dp[idx][j]=Math.min(ch1,ch2);
}
public static String lcs(String a,String b) {
int dp[][]=new int[a.length()+1][b.length()+1];
for(int i=0;i<=a.length();i++)
{
for(int j=0;j<=b.length();j++)
{
if(i==0||j==0)
dp[i][j]=0;
}
}
for(int i=1;i<=a.length();i++)
{
for(int j=1;j<=b.length();j++)
{
if(a.charAt(i-1)==b.charAt(j-1))
dp[i][j]=1+dp[i-1][j-1];
else
dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
}
}
int i=a.length();
int j=b.length();
String lcs="";
while(i>0&&j>0)
{
if(a.charAt(i-1)==b.charAt(j-1)) {
lcs=a.charAt(i-1)+lcs;
i--;
j--;
}
else
{
if(dp[i-1][j]>dp[i][j-1])
i--;
else
j--;
}
}
return lcs;
}
public static long facto(long n) {
if(n==1||n==0)
return 1;
return n*facto(n-1);
}
public static long gcd(long n1,long n2) {
if (n2 == 0) {
return n1;
}
return gcd(n2, n1 % n2);
}
public static boolean isPali(String s) {
int i=0;
int j=s.length()-1;
while(i<=j) {
if(s.charAt(i)!=s.charAt(j))
return false;
i++;
j--;
}
return true;
}
public static String reverse(String s) {
String res="";
for(int i=0;i<s.length();i++) {
res+=s.charAt(i);
}
return res;
}
public static int bsearch(long suf[],long val) {
int i=0;
int j=suf.length-1;
while(i<=j) {
int mid=(i+j)/2;
if(suf[mid]==val)
return mid;
else if(suf[mid]<val)
j=mid-1;
else
i=mid+1;
}
return -1;
}
public static int[] getFreq(String s) {
int a[]=new int[26];
for(int i=0;i<s.length();i++) {
a[s.charAt(i)-'a']++;
}
return a;
}
public static boolean isPrime(int n) {
for(int i=2;(i*i)<=n;i++) {
if(n%i==0)
return false;
}
return true;
}
}
class Pair{
long i;
long j;
Pair(long num,long freq){
this.i=num;
this.j=freq;
}
}
class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
|
import java.util.*;
import java.io.*;
public class Main2 {
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}
catch (IOException e){e.printStackTrace();}}return st.nextToken();}
int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
String nextLine(){String str = ""; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; }
}
static long mod = 998244353;
// static Scanner sc = new Scanner(System.in);
static FastReader sc = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
public static void main (String[] args) {
int t = 1;
// t = sc.nextInt();
z : while(t-->0) {
int n = sc.nextInt();
int a[] = new int[n];
for(int i=0;i<n;i++) a[i] = sc.nextInt();
List<Integer> a1 = new ArrayList<>();
ArrayList<Integer> a2 = new ArrayList<>();
for (int i = 0; i < n; i++) {
if(a[i] == 0) a1.add(i);
else a2.add(i);
}
long dp[][] = new long[n+1][n+1];
for (int i = 0; i <= n; i++) {
Arrays.fill(dp[i],-1);
}
out.write(find(0,0,a1,a2,dp)+"\n");
}
out.close();
}
private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
if(j == a2.size()) return 0;
int req = a2.size()-j;
int ava = a1.size()-i;
if(ava<req) return Integer.MAX_VALUE/2;
if(dp[i][j] != -1) return dp[i][j];
long ans1 = find(i+1,j,a1,a2,dp);
long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
return dp[i][j] = Math.min(ans1, ans2);
}
}
| 1 |
Plagiarised
|
10584086
|
f229aa7f
|
import java.util.*;
import java.io.*;
public class _1615_C {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int t = Integer.parseInt(in.readLine());
while(t-- > 0) {
int n = Integer.parseInt(in.readLine());
String a = in.readLine();
String b = in.readLine();
int x = 0;
int y = 0;
int match = 0;
for(int i = 0; i < n; i++) {
if(a.charAt(i) == '1') {
x++;
}
if(b.charAt(i) == '1') {
y++;
}
if(a.charAt(i) == b.charAt(i)) {
match++;
}
}
if(x != y && n - x + 1 != y) {
out.println(-1);
}else {
int moves = Integer.MAX_VALUE;
if(x == y) {
int mismatch = n - match;
moves = Math.min(moves, mismatch);
}
if(n - x + 1 == y) {
moves = Math.min(moves, match);
}
out.println(moves);
}
}
in.close();
out.close();
}
}
|
import java.util.*;
import java.io.*;
import java.math.*;
public class cf {
static PrintWriter pw = new PrintWriter(System.out);
public static void main(String[] args) throws IOException, InterruptedException {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
char[] a = sc.next().toCharArray();
char[] b = sc.next().toCharArray();
int x = 0, y = 0, lit = 0,lit2 = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '1')
lit++;
if (b[i] == '1')
lit2++;
if (a[i] == b[i])
x++;
else
y++;
}
if(lit == lit2 || n - lit + 1 == lit2) {
if (lit == lit2 && n - lit + 1 == lit2) {
pw.println(Math.min(x,y));
}else if(lit == lit2) {
pw.println(y);
}else {
pw.println(x);
}
}else {
pw.println(-1);
}
}
pw.close();
}
public static class tuble implements Comparable<tuble> {
int x;
int y;
int z;
public tuble(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
public String toString() {
return x + " " + y + " " + z;
}
public int compareTo(tuble other) {
if (this.x == other.x) {
if (this.y == other.y)
return this.z - other.z;
return this.y - other.y;
} else {
return this.x - other.x;
}
}
}
public static class pair implements Comparable<pair> {
int x;
int y;
public pair(int x, int y) {
this.x = x;
this.y = y;
}
public String toString() {
return x + " " + y;
}
public boolean equals(Object o) {
if (o instanceof pair) {
pair p = (pair) o;
return p.x == x && p.y == y;
}
return false;
}
public int hashCode() {
return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
}
public int compareTo(pair other) {
if (this.x == other.x) {
return Long.compare(this.y, other.y);
}
return Long.compare(this.x, other.x);
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| 0 |
Non-plagiarised
|
cc9230d3
|
ec558d69
|
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
public class C {
static int[][] lr = new int[2][(int)2e5+10];
static long[][] dp = new long[2][(int)2e5+10];
static ArrayList<ArrayList<Integer>> g;
public static void main(String[] args) {
FastReader fr = new FastReader();
PrintWriter out = new PrintWriter(System.out, true);
int cases = fr.nextInt();
for(int c = 0; c < cases; c++) {
int nodes = fr.nextInt();
g = new ArrayList<ArrayList<Integer>>();
for(int i = 1; i <= nodes; i++) {
lr[0][i] = fr.nextInt();
lr[1][i] = fr.nextInt();
}
for(int i = 0; i <= nodes; i++) {
g.add(new ArrayList<Integer>());
}
for(int i = 0; i < nodes-1; i++) {
int f = fr.nextInt();
int t = fr.nextInt();
g.get(f).add(t);
g.get(t).add(f);
}
DFS(1, -1);
out.write(Math.max(dp[0][1], dp[1][1]) + "\n");
}
out.close();
}
static void DFS(int v, int p) {
dp[0][v] = dp[1][v] = 0;
for(Integer u : g.get(v)) {
if (u == p) continue;
DFS(u, v);
dp[0][v] += Math.max(Math.abs(lr[0][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[0][v] - lr[0][u]));
dp[1][v] += Math.max(Math.abs(lr[1][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[1][v] - lr[0][u]));
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
this.br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try{
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble() { return Double.parseDouble(next()); }
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Main
{
static int N=(int)2e5+10;
static int[][] A=new int[2][N];
static long[][] dp=new long[2][N];
static ArrayList<ArrayList<Integer>> links=new ArrayList<>(N);
static {
for (int i=0;i<N;i++)
links.add(new ArrayList<>());
}
static void dfs(int v,int p)
{
dp[0][v]=dp[1][v]=0;
for (Integer link :links.get(v))
{
if (link==p) continue;
dfs(link,v);
dp[0][v]+=Math.max(Math.abs(A[0][v]-A[0][link])+dp[0][link],Math.abs(A[0][v]-A[1][link])+dp[1][link]);
dp[1][v]+=Math.max(Math.abs(A[1][v]-A[0][link])+dp[0][link],Math.abs(A[1][v]-A[1][link])+dp[1][link]);
}
}
public static void main (String[] args) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine()),n,i;
while (t-->0)
{
n=Integer.parseInt(br.readLine());
for (i=1;i<=n;i++)
{
String[] in=br.readLine().split(" ");
A[0][i]=Integer.parseInt(in[0]);
A[1][i]=Integer.parseInt(in[1]);
links.set(i,new ArrayList<>());
}
for (i=1;i<n;i++)
{
String[] in=br.readLine().split(" ");
int a=Integer.parseInt(in[0]);
int b=Integer.parseInt(in[1]);
links.get(a).add(b);
links.get(b).add(a);
}
dfs(1,-1);
System.out.println(Math.max(dp[0][1],dp[1][1]));
}
}
}
| 1 |
Plagiarised
|
3368f340
|
402aff07
|
//package Codeforces;
import java.io.*;
import java.util.*;
public class Menorah {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
StringBuilder sb = new StringBuilder();
while (t-->0){
int n = sc.nextInt();
char[] a = sc.next().toCharArray();
char[] b = sc.next().toCharArray();
int a1=0, b1=0;
for(int i=0;i<n;i++){
if(a[i]=='1')
a1++;
if(b[i]=='1')
b1++;
}
int min = 100000000;
if(a1==b1){
int c = 0;
for(int i=0;i<n;i++){
if(a[i]!=b[i])
c++;
}
min = Math.min(min, c);
}
if(b1==(n-a1+1)){
int ind = -1;
for(int i=0;i<n;i++){
if(a[i]==b[i] && a[i]=='1'){
ind = i;
break;
}
}
int c = 0;
for(int i=0;i<n;i++){
if(i==ind)
continue;
if(a[i]==b[i])
c++;
}
min = Math.min(min, c + 1);
}
if(min == 100000000)
sb.append("-1\n");
else sb.append(min).append("\n");
}
System.out.println(sb);
sc.close();
}
}
|
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while (t-- > 0){
int n = s.nextInt();
String a = s.next();
String b = s.next();
int a1 = 0, b1 = 0;
for (char c: a.toCharArray()){
if (c == '1') a1++;
}
for (char c: b.toCharArray()){
if (c == '1') b1++;
}
int ans = Integer.MAX_VALUE;
int res = 0;
for (int i = 0; i < n; i++) {
if (a.charAt(i) != b.charAt(i)) res++;
}
if (a1 == b1) ans = Math.min(ans, res);
if (b1 == n-a1+1) ans = Math.min(ans, n-res);
if (ans == Integer.MAX_VALUE){
System.out.println("-1");
} else {
System.out.println(ans);
}
}
}
}
| 0 |
Non-plagiarised
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.