buelfhood/ConPlag_1_codeberta_ep30_bs16_lr0_0005_l512_s42_ppy_f_beta_score_2_houlsby
Updated
•
2
Datasets:
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 |
|---|---|---|---|---|---|
51151974 | c23278ec | import java.io.*;
import java.util.*;
public class Solution{
public static void main (String[] args) throws java.lang.Exception {
FastReader sc = new FastReader();
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
int testCase = sc.nextInt();
while (testCase-->0){
int n = sc.nextInt();
String[] strArr = new String[n];
for(int i=0; i<n; i++) {
strArr[i]=sc.nextLine();
}
int[] total = new int[5];
ArrayList<int[]> al = new ArrayList<>();
for(int i=0; i<n; i++){
int[] arr= new int[5];
for(int j=0; j<strArr[i].length(); j++){
arr[strArr[i].charAt(j)-'a']++;
}
for(int j=0; j<5; j++){
total[j]+=arr[j];
}
al.add(arr);
}
int ans=0;
for(int i=0; i<5; i++){
ArrayList<Integer> all = new ArrayList<>();
for(int j=0; j<n; j++){
all.add(strArr[j].length()-2*al.get(j)[i]);
}
java.util.Collections.sort(all);
int c=0, d=0;
for(int j=0; j<n; j++){
c+=all.get(j);
if(c<0) d=j+1;
}
ans = Math.max(ans,d);
}
System.out.println(ans);
}
}
// Fast Reader Class
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.sql.Array;
import java.util.*;
public class P1551C {
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();
String[] s = new String[n];
int[][] freq = new int[n][6];
for (int i = 0; i < n; i++) {
s[i] = in.nextLine();
for (char c : s[i].toCharArray()) {
freq[i][c - 'a']++;
freq[i][5]++;
}
}
int totmax = 0;
for (int i = 0; i < 5; i++) {
List<Integer> diffs = new ArrayList<>(n);
for (int j = 0; j < n; j++) {
diffs.add(2 * freq[j][i] - freq[j][5]);
}
Collections.sort(diffs);
Collections.reverse(diffs);
int curr = 0, cnt = 0;
while (cnt < diffs.size() && curr + diffs.get(cnt) > 0) {
curr += diffs.get(cnt++);
}
totmax = Math.max(totmax, cnt);
}
out.println(totmax);
}
}
}
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 String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
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;
}
}
}
| 0 | Non-plagiarised |
13441e8f | 141effef | import java.util.*;
public class Armchairs {
public static int findMinTime(List<Integer> zeros, List<Integer> ones) {
if (ones.size() == 0)
return 0;
int oneSize = ones.size();
int zeroSize = zeros.size();
int [][] time = new int [oneSize + 1][zeroSize + 1];
for (int i=1; i<=oneSize; i++) {
time[i][i] = time[i - 1][i - 1] + Math.abs(ones.get(i - 1) - zeros.get(i - 1));
for (int j=i+1; j<=zeroSize; j++) {
time[i][j] = Math.min(time[i][j - 1], time[i - 1][j - 1] +
Math.abs(ones.get(i - 1) - zeros.get(j - 1)));
}
}
return time[oneSize][zeroSize];
}
public static void main (String [] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
List<Integer> zeros = new ArrayList<>();
List<Integer> ones = new ArrayList<>();
for (int i=0; i<n; i++) {
int number= sc.nextInt();
if (number == 1)
ones.add(i);
else
zeros.add(i);
}
System.out.println(findMinTime(zeros, ones));
}
} | // package codeforces;
import java.util.*;
public class ArmChairs {
static int[]arr;
static ArrayList<Integer>a;
static ArrayList<Integer>b;
static int dp[][];
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
int n = scn.nextInt();
arr=new int[n];
for(int i=0;i<n;i++) {
arr[i]=scn.nextInt();
}
dp=new int[n+1][n+1];
a =new ArrayList<>();
b =new ArrayList<>();
for(int i=0;i<n;i++) {
if(arr[i]==0) {
a.add(i);
}else{
b.add(i);
}
}
System.out.println(solve(0,0));
}
public static int solve(int i,int j) {
if(i==b.size()) {
return 0;
}
if(j==a.size()) {
return 100000000;
}
if(dp[i][j]!=0) {
return dp[i][j];
}
int x=Math.abs(a.get(j)-b.get(i))+solve(i+1,j+1);
int y=solve(i,j+1);
return dp[i][j]=Math.min(x, y);
}
}
| 0 | Non-plagiarised |
115c99cb | 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 |
cdb801a1 | e14d1ba0 | //package codeforces;
import java.io.*;
import java.util.*;
public class Solution {
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 ni() {
return Integer.parseInt(next());
}
long nl() {
return Long.parseLong(next());
}
double nd() {
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 java.lang.Exception {
FastReader fr = new FastReader();
PrintWriter out = new PrintWriter(System.out);
int t = fr.ni();
while(t-->0) {
int n = fr.ni();
long arr [] = new long[n];
for(int i = 0 ; i < n ; i++) arr[i]= fr.nl();
long even = arr[0];
long odd = arr[1];
long minEven = arr[0];
long minOdd = arr[1];
long ans = (minEven*n) + (minOdd*n);
for(int i = 2 ; i < n ; i++) {
if((i&1) == 0) {
even += arr[i];
minEven = Math.min(minEven, arr[i]);
long a = (i+2)/2;
long b = (i+1)-a;
long temp = (even + (minEven*(n - a)));
temp += (odd + (minOdd*(n - b)));
ans = Math.min(ans, temp);
}else {
odd += arr[i];
minOdd = Math.min(minOdd, arr[i]);
long a = (i+2)/2;
long b = (i+1)-a;
long temp = (even + (minEven*(n - a)));
temp += (odd + (minOdd*(n - b)));
ans = Math.min(ans, temp);
}
}
out.println(ans);
}
out.close();
}
} | import java.util.*;
public class ss
{
public static void main(String[]args)
{
Scanner in=new Scanner (System.in);
int t=in.nextInt();
for(int i1=0;i1<t;i1++)
{
int n=in.nextInt();
long[] ar=new long[n];
for(int i=0;i<n;i++)
{
ar[i]=in.nextLong();
}
long[] ans=new long[n];
ans[0]=ar[0]*n;
long m=ar[0];
long s1=ar[0];
for(int i=2;i<n;i+=2)
{
if(m>ar[i])
{
m=ar[i];
}
s1+=ar[i];
ans[i]=s1-m+m*(n-i/2);
}
ans[1]=ar[1]*n;
m=ar[1];
s1=ar[1];
for(int i=3;i<n;i+=2)
{
if(m>ar[i])
{
m=ar[i];
}
s1+=ar[i];
ans[i]=s1-m+m*(n-i/2);
}
long mini=ans[0]+ans[1];
for(int i=1;i<n-1;i++)
{
mini=Math.min(ans[i]+ans[i+1],mini);
}
System.out.println(mini);
}
}
}
| 0 | Non-plagiarised |
01b911ac | a195911e | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.TreeSet;
import java.util.TreeMap;
import java.util.PriorityQueue;
import java.util.Collections;
import java.util.Stack;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.Iterator;
public class First {
public static void main(String[] args) {
FastScanner fs = new FastScanner();
int T = fs.nextInt();
for (int tt = 0; tt < T; tt++) {
solve(fs);
}
}
static void solve(FastScanner fs)
{
int n=fs.nextInt();
long[] times=takeLong(n, fs);
long[] damage=takeLong(n, fs);
long reqTime=times[n-1]-damage[n-1]+1;
long ans=0;
for(int i=n-1;i>=0;)
{
reqTime=times[i]-damage[i]+1;
long time=times[i];
i--;
while(i>=0 && times[i]>=reqTime)
{
long thisReqTime=times[i]-damage[i]+1;
reqTime=Math.min(reqTime, thisReqTime);
i--;
}
long x=time-reqTime+1;
// pn(x);
ans+=(x*(x+1)/2);
}
pn(ans);
}
static long MOD=(long)(1e9+7);
static boolean check(String x, String ans)
{
if(x.length()!=ans.length()) return x.length()>ans.length();
if(x.compareTo(ans) <= -1) return false;
else return true;
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
static void pn(Object o) { System.out.println(o); }
static void p(Object o) { System.out.print(o); }
static void flush() { System.out.flush(); }
static void debugInt(int[] arr)
{
for(int i=0;i<arr.length;++i)
System.out.print(arr[i]+" ");
System.out.println();
}
static void debugIntInt(int[][] arr)
{
for(int i=0;i<arr.length;++i)
{
for(int j=0;j<arr[0].length;++j)
System.out.print(arr[i][j]+" ");
System.out.println();
}
System.out.println();
}
static void debugLong(long[] arr)
{
for(int i=0;i<arr.length;++i)
System.out.print(arr[i]+" ");
System.out.println();
}
static void debugLongLong(long[][] arr)
{
for(int i=0;i<arr.length;++i)
{
for(int j=0;j<arr[0].length;++j)
System.out.print(arr[i][j]+" ");
System.out.println();
}
System.out.println();
}
static long[] takeLong(int n, FastScanner fs)
{
long[] arr=new long[n];
for(int i=0;i<n;++i)
arr[i]=fs.nextLong();
return arr;
}
static long[][] takeLongLong(int m, int n, FastScanner fs)
{
long[][] arr=new long[m][n];
for(int i=0;i<m;++i)
for(int j=0;j<n;++j)
arr[i][j]=fs.nextLong();
return arr;
}
static int[] takeInt(int n, FastScanner fs)
{
int[] arr=new int[n];
for(int i=0;i<n;++i)
arr[i]=fs.nextInt();
return arr;
}
static int[][] takeIntInt(int m, int n, FastScanner fs)
{
int[][] arr=new int[m][n];
for(int i=0;i<m;++i)
for(int j=0;j<n;++j)
arr[i][j]=fs.nextInt();
return arr;
}
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 int getDecimalFromBinary(String s)
{
long no=0;
for(int i=0;i<s.length();i++)
{
if(s.charAt(i)=='1')
no++;
no=no<<1;
}
return (int)(no>>1);
}
static String getBinaryFromDecimal(int x)
{
StringBuilder sb=new StringBuilder();
for(int i=0;i<31;++i)
{
if((x&1)==0)
sb.append('0');
else
sb.append('1');
x=x>>1;
}
return sb.reverse().toString();
}
static boolean[] sieve()
{
int size=(int)(1e5+5);
boolean[] isPrime=new boolean[size];
Arrays.fill(isPrime, true);
for(int i=2;i<size;++i)
for(int j=2*i;isPrime[i]==true && j<size;j+=i)
isPrime[j]=false;
return isPrime;
}
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());
}
}
}
class SortComp implements Comparator<String>
{
public int compare(String s1, String s2)
{
if(s1.length()!=s2.length()) return s2.length()-s1.length();
if(s1.compareTo(s2) <= -1) return 1;
else return -1;
}
} | import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
static FastReader sc=new FastReader();
static int dp[];
static boolean v[];
// static int mod=998244353;;
static int mod=1000000007;
static int max;
static int bit[];
//static long fact[];
// static long A[];
static HashMap<Integer,Integer> map;
//static StringBuffer sb=new StringBuffer("");
//static HashMap<Integer,Integer> map;
static PrintWriter out=new PrintWriter(System.out);
public static void main(String[] args)
{
// StringBuffer sb=new StringBuffer("");
int ttt=1;
ttt =i();
outer :while (ttt-- > 0)
{
int n=i();
long A[]=inputL(n);
long B[]=inputL(n);
long C[]=new long[n];
for(int i=0;i<n;i++) {
C[i]=A[i]-B[i]+1;
}
long min=C[n-1];
long ans=0;
long last=A[n-1];
for(int i=n-1;i>=0;i--) {
if(C[i]>min) {
continue;
}
if(A[i]<min) {
long y=last-min+1;
ans+=y*(y+1)/2;
last=A[i];
min=C[i];
continue;
}
min=C[i];
}
long y=last-min+1;
ans+=y*(y+1)/2;
System.out.println(ans);
}
//System.out.println(sb.toString());
out.close();
//CHECK FOR N=1 //CHECK FOR M=0
//CHECK FOR N=1 //CHECK FOR M=0
//CHECK FOR N=1
}
static class Pair implements Comparable<Pair>
{
int x;
int y;
int z;
Pair(int x,int y){
this.x=x;
this.y=y;
// this.z=z;
}
@Override
public int compareTo(Pair o) {
if(this.x>o.x)
return 1;
else if(this.x<o.x)
return -1;
else {
if(this.y>o.y)
return 1;
else if(this.y<o.y)
return -1;
else
return 0;
}
}
public int hashCode()
{
final int temp = 14;
int ans = 1;
ans =x*31+y*13;
return ans;
}
@Override
public boolean equals(Object o)
{
if (this == o) {
return true;
}
if (o == null) {
return false;
}
if (this.getClass() != o.getClass()) {
return false;
}
Pair other = (Pair)o;
if (this.x != other.x || this.y!=other.y) {
return false;
}
return true;
}
//
/* FOR TREE MAP PAIR USE */
// public int compareTo(Pair o) {
// if (x > o.x) {
// return 1;
// }
// if (x < o.x) {
// return -1;
// }
// if (y > o.y) {
// return 1;
// }
// if (y < o.y) {
// return -1;
// }
// return 0;
// }
}
static int find(int A[],int a) {
if(A[a]==a)
return a;
return A[a]=find(A, A[a]);
}
//static int find(int A[],int a) {
// if(A[a]==a)
// return a;
// return find(A, A[a]);
//}
//FENWICK TREE
static void update(int i, int x){
for(; i < bit.length; i += (i&-i))
bit[i] += x;
}
static int sum(int i){
int ans = 0;
for(; i > 0; i -= (i&-i))
ans += bit[i];
return ans;
}
//END
static void add(int v) {
if(!map.containsKey(v)) {
map.put(v, 1);
}
else {
map.put(v, map.get(v)+1);
}
}
static void remove(int v) {
if(map.containsKey(v)) {
map.put(v, map.get(v)-1);
if(map.get(v)==0)
map.remove(v);
}
}
public static int upper(int A[],int k,int si,int ei)
{
int l=si;
int u=ei;
int ans=-1;
while(l<=u) {
int mid=(l+u)/2;
if(A[mid]<=k) {
ans=mid;
l=mid+1;
}
else {
u=mid-1;
}
}
return ans;
}
public static int lower(int A[],int k,int si,int ei)
{
int l=si;
int u=ei;
int ans=-1;
while(l<=u) {
int mid=(l+u)/2;
if(A[mid]<=k) {
l=mid+1;
}
else {
ans=mid;
u=mid-1;
}
}
return ans;
}
static int[] copy(int A[]) {
int B[]=new int[A.length];
for(int i=0;i<A.length;i++) {
B[i]=A[i];
}
return B;
}
static long[] copy(long A[]) {
long B[]=new long[A.length];
for(int i=0;i<A.length;i++) {
B[i]=A[i];
}
return B;
}
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 String[] inputS(int n) {
String A[]=new String[n];
for(int i=0;i<n;i++) {
A[i]=sc.next();
}
return A;
}
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 reverse(long A[]) {
int n=A.length;
long B[]=new long[n];
for(int i=0;i<n;i++) {
B[i]=A[n-i-1];
}
for(int i=0;i<n;i++)
A[i]=B[i];
}
static void reverse(int A[]) {
int n=A.length;
int B[]=new int[n];
for(int i=0;i<n;i++) {
B[i]=A[n-i-1];
}
for(int i=0;i<n;i++)
A[i]=B[i];
}
static void input(int A[],int B[]) {
for(int i=0;i<A.length;i++) {
A[i]=sc.nextInt();
B[i]=sc.nextInt();
}
}
static int[][] input(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]=i();
}
}
return A;
}
static char[][] charinput(int n,int m){
char A[][]=new char[n][m];
for(int i=0;i<n;i++) {
String s=s();
for(int j=0;j<m;j++) {
A[i][j]=s.charAt(j);
}
}
return A;
}
static int nextPowerOf2(int n)
{
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n++;
return n;
}
static int highestPowerof2(int x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
static long highestPowerof2(long x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
static int max(int A[]) {
int max=Integer.MIN_VALUE;
for(int i=0;i<A.length;i++) {
max=Math.max(max, A[i]);
}
return max;
}
static int min(int A[]) {
int min=Integer.MAX_VALUE;
for(int i=0;i<A.length;i++) {
min=Math.min(min, A[i]);
}
return min;
}
static long max(long A[]) {
long max=Long.MIN_VALUE;
for(int i=0;i<A.length;i++) {
max=Math.max(max, A[i]);
}
return max;
}
static long min(long A[]) {
long min=Long.MAX_VALUE;
for(int i=0;i<A.length;i++) {
min=Math.min(min, A[i]);
}
return min;
}
static long [] prefix(long A[]) {
long p[]=new long[A.length];
p[0]=A[0];
for(int i=1;i<A.length;i++)
p[i]=p[i-1]+A[i];
return p;
}
static long [] prefix(int A[]) {
long p[]=new long[A.length];
p[0]=A[0];
for(int i=1;i<A.length;i++)
p[i]=p[i-1]+A[i];
return p;
}
static long [] suffix(long A[]) {
long p[]=new long[A.length];
p[A.length-1]=A[A.length-1];
for(int i=A.length-2;i>=0;i--)
p[i]=p[i+1]+A[i];
return p;
}
static long [] suffix(int A[]) {
long p[]=new long[A.length];
p[A.length-1]=A[A.length-1];
for(int i=A.length-2;i>=0;i--)
p[i]=p[i+1]+A[i];
return p;
}
static void fill(int dp[]) {
Arrays.fill(dp, -1);
}
static void fill(int dp[][]) {
for(int i=0;i<dp.length;i++)
Arrays.fill(dp[i], -1);
}
static void fill(int dp[][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
Arrays.fill(dp[i][j],-1);
}
}
}
static void fill(int dp[][][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
for(int k=0;k<dp[0][0].length;k++) {
Arrays.fill(dp[i][j][k],-1);
}
}
}
}
static void fill(long dp[]) {
Arrays.fill(dp, -1);
}
static void fill(long dp[][]) {
for(int i=0;i<dp.length;i++)
Arrays.fill(dp[i], -1);
}
static void fill(long dp[][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
Arrays.fill(dp[i][j],-1);
}
}
}
static void fill(long dp[][][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
for(int k=0;k<dp[0][0].length;k++) {
Arrays.fill(dp[i][j][k],-1);
}
}
}
}
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 power(long x, long y, long p)
{
if(y==0)
return 1;
if(x==0)
return 0;
long res = 1;
x = x % p;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
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 void print(int A[]) {
for(int i : A) {
out.print(i+" ");
}
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 String reverse(String s) {
StringBuffer p=new StringBuffer(s);
p.reverse();
return p.toString();
}
static int i() {
return sc.nextInt();
}
static String s() {
return sc.next();
}
static long l() {
return sc.nextLong();
}
static void sort(int[] A){
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i){
int tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
static void sort(long[] A){
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i){
long tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
static String sort(String s) {
Character ch[]=new Character[s.length()];
for(int i=0;i<s.length();i++) {
ch[i]=s.charAt(i);
}
Arrays.sort(ch);
StringBuffer st=new StringBuffer("");
for(int i=0;i<s.length();i++) {
st.append(ch[i]);
}
return st.toString();
}
static HashMap<Integer,Integer> hash(int A[]){
HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
for(int i : A) {
if(map.containsKey(i)) {
map.put(i, map.get(i)+1);
}
else {
map.put(i, 1);
}
}
return map;
}
static HashMap<Long,Integer> hash(long A[]){
HashMap<Long,Integer> map=new HashMap<Long, Integer>();
for(long i : A) {
if(map.containsKey(i)) {
map.put(i, map.get(i)+1);
}
else {
map.put(i, 1);
}
}
return map;
}
static TreeMap<Integer,Integer> tree(int A[]){
TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
for(int i : A) {
if(map.containsKey(i)) {
map.put(i, map.get(i)+1);
}
else {
map.put(i, 1);
}
}
return map;
}
static TreeMap<Long,Integer> tree(long A[]){
TreeMap<Long,Integer> map=new TreeMap<Long, Integer>();
for(long i : A) {
if(map.containsKey(i)) {
map.put(i, map.get(i)+1);
}
else {
map.put(i, 1);
}
}
return map;
}
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 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 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 |
4dc0247e | 875ed4c8 | import java.io.*;
import java.util.*;
public class ComdeFormces {
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
FastReader sc=new FastReader();
BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
int t=sc.nextInt();
while(t--!=0) {
int n=sc.nextInt();
// int m=sc.nextInt();
ArrayList<ArrayList<pair>> ar=new ArrayList<>();
ArrayList<pair> arr=new ArrayList<>();
int c[]=new int[n];
for(int i=0;i<=n;i++) {
ar.add(new ArrayList<>());
}
for(int i=0;i<n-1;i++) {
int a=sc.nextInt();
int b=sc.nextInt();
ar.get(a).add(new pair(b,i));
ar.get(b).add(new pair(a,i));
}
boolean ans=true;
for(int i=0;i<=n;i++) {
if(ar.get(i).size()>2) {
ans=false;
break;
}
}
if(ans) {
for(int i=1;i<=n;i++) {
if(ar.get(i).size()==1) {
boolean vis[]=new boolean[n+1];
dfs(ar,2,i,vis,c);
break;
}
}
for(int i=0;i<n;i++) {
if(c[i]!=0)log.write(c[i]+" ");
}
}
else log.write("-1");
log.write("\n");
log.flush();
}
}
static void dfs(ArrayList<ArrayList<pair>>ar ,int val,int src,boolean vis[],int c[]) {
if(vis[src])return;
vis[src]=true;
for(int i=0;i<ar.get(src).size();i++) {
if(!vis[ar.get(src).get(i).a]) {
c[ar.get(src).get(i).b]=val;
if(val==2) {
dfs(ar,3,ar.get(src).get(i).a,vis,c);
}
else {
dfs(ar,2,ar.get(src).get(i).a,vis,c);
}
}
}
}
static ArrayList<Integer> divisors(int n){
ArrayList<Integer> ar=new ArrayList<>();
for (int i=2; i<=Math.sqrt(n); i++){
if (n%i == 0){
if (n/i == i) {
ar.add(i);
}
else {
ar.add(i);
ar.add(n/i);
}
}
}
return ar;
}
static int primeDivisor(int n){
ArrayList<Integer> ar=new ArrayList<>();
int cnt=0;
boolean pr=false;
while(n%2==0) {
pr=true;
n/=2;
}
if(pr)ar.add(2);
for(int i=3;i*i<=n;i+=2) {
pr=false;
while(n%i==0) {
n/=i;
pr=true;
}
if(pr)ar.add(i);
}
if(n>2) ar.add(n);
return ar.size();
}
static int mdlg(int num, int base) {
int val=((int)(Math.ceil(Math.log(num)/Math.log(base))));
int val2=(int)Math.pow(base,val);
// System.out.println(num+" "+Math.pow(base,val));
if(num/val2==0)return val;
return val+1;
// return val;
}
static String rev(String s) {
char temp[]=s.toCharArray();
for(int i=0;i<temp.length/2;i++) {
char tp=temp[i];
temp[i]=temp[temp.length-1-i];
temp[temp.length-1-i]=tp;
}
return String.valueOf(temp);
}
static long bsv(long a[],long min,long max) {
long ans=-1;
while(min<=max) {
long mid=min+(max-min)/2;
long an=solvess(a,mid);
// System.out.println("an="+an+"mid="+mid);
if(an==mid) {
ans=Math.max(ans,an);
min=mid+1;
}
else if(an>mid)min=mid+1;
else if(an<mid)max=mid-1;
}
return ans;
}
static long solvess(long aa[],long el) {
long a[]=new long[aa.length];
long min=Long.MAX_VALUE;
for(int i=0;i<a.length;i++ ) {
a[i]=aa[i];
min=Math.min(min, aa[i]);
}
boolean ans=true;
long val[]=new long[a.length];
for(int i=a.length-1;i>=2;i--) {
if(a[i]+val[i]>el) {
if(val[i]>=el) {
long df=a[i];
a[i]-=df;
val[i-1]+=(df/3);
val[i-2]+=2*(df/3);
a[i]+=df%3;
}
else {
long df=a[i]+val[i]-el;
val[i-1]+=(df/3);
val[i-2]+=2*(df/3);
a[i]-=df;
a[i]+=df%3;
}
}
}
for(int i=0;i<a.length;i++) {
a[i]+=val[i];
}
long min2=Long.MAX_VALUE;
for(int i=0;i<a.length;i++) {
min2=Math.min(min2, a[i]);
}
return min2;
}
static int bsd(ArrayList<LinkedList<Integer>> arr, int val,int el) {
int s=0;
int e=arr.size()-1;
int ptr=0;
if(val==1)ptr=1;
while(s<=e) {
int m=s+(e-s)/2;
if(arr.get(m).get(ptr)==el)return m;
else if(arr.get(m).get(ptr)<el)s=m+1;
else e=m-1;
}
return -1;
}
static int bs(ArrayList<pair> arr,int el) {
int start=0;
int end=arr.size()-1;
while(start<=end) {
int mid=start+(end-start)/2;
if(arr.get(mid).a==el)return mid;
else if(arr.get(mid).a<el)start=mid+1;
else end=mid-1;
}
if(start>arr.size()-1)return -2;
return -1;
}
static String eval(String s, long bs, long be,long k) {
String ans="";
for(int i=s.length()-1;i>=0;i--) {
if(s.charAt(i)=='a') {
ans="a"+ans;
}
else if(be>0){
if(be>k) {
for(int j=0;j<k;j++)ans="b"+ans;
be-=k;
}
else {
for(int j=0;j<be;j++)ans="b"+ans;
be=0;
}
}
}
for(int i=0;i<bs;i++)ans="b"+ans;
return ans;
}
static int[][] slv() {
int r=200001;
int bits=(int)(Math.log(r)/Math.log(2))+1;
int cnt[][]=new int[r+1][bits];
for(int i=1;i<=r;i++) {
int temp=i;
int j=0;
int min=Integer.MAX_VALUE;
while(j<bits) {
int tval=1&temp;
temp>>=1;
if(tval==0)cnt[i][j]=cnt[i-1][j]+1;
else {
cnt[i][j]=cnt[i-1][j];
}
j++;
}
}
return cnt;
}
static long find(int s,long a[]) {
if(s>=a.length)return -1;
long num=a[s];
for(int i=s;i<a.length;i+=2) {
num=gcd(num,a[i]);
if(num==1 || num==0)return -1;
}
return num;
}
static long gcd(long a,long b) {
if(b==0)return a;
else return gcd(b,a%b);
}
static long factmod(long n,long mod,long img) {
if(n==0)return 1;
long ans=1;
long temp=1;
while(n--!=0) {
if(temp!=img) {
ans=((ans%mod)*((temp)%mod))%mod;
}
temp++;
}
return ans%mod;
}
static long eval(ArrayList<Integer> a, int k) {
if(a.size()<1 )return 0;
int i=a.size()-1;
long ans=0;
while(i>=0) {
int temp=k;
int prev=0;
while(temp--!=0 && i>=0) {
ans+=Math.abs(a.get(i)-prev);
if(temp==0 || i==0)ans+=a.get(i);
prev=a.get(i);
i--;
}
}
return ans;
}
static int bs(long a[] ,long num) {
int start=0;
int end=a.length-1;
while(start<=end) {
int mid=start+(end-start)/2;
if(a[mid]==num) {
return mid;
}
else if(a[mid]<num)start=mid+1;
else end=mid-1;
}
return start;
}
//utils
static int ncr(int n, int r){
if(r>n-r)r=n-r;
int ans=1;
for(int i=0;i<r;i++){
ans*=(n-i);
ans/=(i+1);
}
return ans;
}
public static class trip{
int a,b,c;
public trip(int a,int b,int c) {
this.a=a;
this.b=b;
this.c=c;
}
public int compareTo(trip q) {
return this.c-q.c;
}
}
static int mergesort(int[] a,int start,int end) {
if(start>=end)return a[end];
int mid=start+(end-start)/2;
int min1=mergesort(a,start,mid);
int min2=mergesort(a,mid+1,end);
merge(a,start,mid,end);
return Math.min(min1, min2);
}
static void merge(int []a, int start,int mid,int end) {
int ptr1=start;
int ptr2=mid+1;
int b[]=new int[end-start+1];
int i=0;
while(ptr1<=mid && ptr2<=end) {
if(a[ptr1]<=a[ptr2]) {
b[i]=a[ptr1];
ptr1++;
i++;
}
else {
b[i]=a[ptr2];
ptr2++;
i++;
}
}
while(ptr1<=mid) {
b[i]=a[ptr1];
ptr1++;
i++;
}
while(ptr2<=end) {
b[i]=a[ptr2];
ptr2++;
i++;
}
for(int j=start;j<=end;j++) {
a[j]=b[j-start];
}
}
public static class FastReader {
BufferedReader b;
StringTokenizer s;
public FastReader() {
b=new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while(s==null ||!s.hasMoreElements()) {
try {
s=new StringTokenizer(b.readLine());
}
catch(IOException e) {
e.printStackTrace();
}
}
return s.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str="";
try {
str=b.readLine();
}
catch(IOException e) {
e.printStackTrace();
}
return str;
}
boolean hasNext() {
if (s != null && s.hasMoreTokens()) {
return true;
}
String tmp;
try {
b.mark(1000);
tmp = b.readLine();
if (tmp == null) {
return false;
}
b.reset();
} catch (IOException e) {
return false;
}
return true;
}
}
public static class pair{
int a;
int b;
public pair(int a,int b) {
this.a=a;
this.b=b;
}
public int compareTo(pair b) {
return b.b-this.b;
}
public int compareToo(pair b) {
if(this.a!=b.a)return this.a-b.a;
else {
return b.b-this.b;
}
}
}
static long pow(long a, long pw) {
long temp;
if(pw==0)return 1;
temp=pow(a,pw/2);
if(pw%2==0)return temp*temp;
return a*temp*temp;
}
static int pow(int a, int pw) {
int temp;
if(pw==0)return 1;
temp=pow(a,pw/2);
if(pw%2==0)return temp*temp;
return a*temp*temp;
}
}
| import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main (String[] args) throws java.lang.Exception
{
FastReader sc = new FastReader();
int t = sc.nextInt();
while(t-->0){
solve(sc);
}
}
public static void solve(FastReader sc){
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){
out.println(-1);out.flush();return;
}else if(graph.get(i).size()==1){
start=i;
}
}
int val=2;
int [] wgt = new int[n-1];
int curr = graph.get(start).get(0).node;
wgt[graph.get(start).get(0).idx] = val;
val=5;
while(true){
ArrayList<Edge> list = graph.get(curr);
if(list.size()==1){
break;
}else{
for(Edge el : list){
if(wgt[el.idx]==0){
wgt[el.idx] = val;
val = 7-val;
curr = el.node;
}
}
}
}
for(int el : wgt){
out.print(el + " ");
}
out.println();
out.flush();
}
static class Edge {
int node;
int idx;
Edge(int src, int nbr) {
this.node = src;
this.idx = nbr;
}
}
/*
int [] arr = new int[n];
for(int i = 0;i<n;++i){
arr[i] = sc.nextInt();
}
*/
static void mysort(int[] arr) {
for(int i=0;i<arr.length;i++) {
int rand = (int) (Math.random() * arr.length);
int loc = arr[rand];
arr[rand] = arr[i];
arr[i] = loc;
}
Arrays.sort(arr);
}
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 |
476e94d3 | 9310ad0c | import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class code2{
public static int GCD(int a, int b)
{
if (b == 0)
return a;
return GCD(b, a % b);
}
//@SuppressWarnings("unchecked")
public static void main(String[] arg) throws IOException{
//Reader in=new Reader();
PrintWriter out = new PrintWriter(System.out);
Scanner in = new Scanner(System.in);
int t=in.nextInt();
while(t-- > 0){
int n=in.nextInt();
long[] k=new long[n];
long[] h=new long[n];
for(int i=0;i<n;i++) k[i]=in.nextLong();
for(int i=0;i<n;i++) h[i]=in.nextLong();
long[] res=new long[n];
long[] power=new long[n];
long l=k[n-1]+1,r=-1;
for(int i=0;i<n;i++){
long lc=k[i]-h[i]+1;
//out.println("lc:"+lc);
long m=h[i];
if(lc<=l){
res[i]=(m*(m+1))/2;
power[i]=h[i];
}
else if(lc>r){
//out.println(m);
res[i]=res[i-1]+(m*(m+1))/2;
power[i]=h[i];
}
else{
res[i]=Long.MAX_VALUE;
for(int j=i-1;j>=0;j--){
if(power[j]+k[i]-k[j] >= h[i]){
long x=power[j]+k[i]-k[j];
if(x>=h[i]){
if(k[i]-h[i]+1>k[j]){
power[i]=h[i];
res[i]=res[j]+(m*(m+1))/2;
}
else{
power[i]=x;
long c=(x*(x+1))/2;
long d=(power[j]*(power[j]+1))/2;
res[i]=res[j]+c-d;
}
break;
}
}
}
}
l=Math.min(l,lc);
r=k[i];
}
out.println(res[n-1]);
}
out.flush();
}
}
| 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;
}
}
public static void main(String[] args) throws Exception {
FastReader sc = new FastReader();
int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
long k[]=new long[n];
for(int i=0;i<n;i++)
{
k[i]=sc.nextLong();
}
long h[]=new long[n];
for(int i=0;i<n;i++)
{
h[i]=sc.nextLong();
}
ArrayList<Long> al=new ArrayList<>();
long csp=h[n-1],idx=k[n-1]-h[n-1];
for(int i=n-2;i>=0;i--)
{
if(idx<k[i])
{
if(k[i]-idx<h[i])
{
long diff=h[i]-(k[i]-idx);
csp+=diff;
idx-=diff;
}
}
else
{
al.add(csp);
csp=h[i];
idx=k[i]-csp;
}
}
long sum=0;
al.add(csp);
for(long i:al)
{
sum=sum+((i*(i+1))/2);
}
System.out.println(sum);
}
}
}
| 0 | Non-plagiarised |
1dab88fb | bac616ee | 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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class NotAssigning {
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 nextFloat() {
return Float.parseFloat(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] nextArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) {
a[i] = this.nextInt();
}
return a;
}
long[] nextArrayLong(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) {
a[i] = this.nextLong();
}
return a;
}
}
static class Pair {
int a, b;
public Pair(int a, int b) {
this.a = a;
this.b = b;
}
}
static boolean vis[];
public static void dfs(ArrayList<ArrayList<Pair>> t, int cur, boolean mode, int[] w) {
vis[cur] = true;
for (Pair p : t.get(cur)) {
if (!vis[p.a]) {
if (mode) {
w[p.b] = 3;
}
else {
w[p.b] = 2;
}
dfs(t, p.a, !mode, w);
}
}
}
public static void solve(int n, int[] u, int[] v) {
ArrayList<ArrayList<Pair>> t = new ArrayList<ArrayList<Pair>>(n);
for (int i=0; i<n; i++) {
t.add(new ArrayList<Pair>());
}
for (int i=0; i<n-1; i++) {
t.get(u[i]).add(new Pair(v[i], i));
t.get(v[i]).add(new Pair(u[i], i));
}
int start = 0;
for (int i=0; i<n; i++) {
if (t.get(i).size() > 2) {
System.out.println("-1");
return;
}
if (t.get(i).size() == 1) {
start = i;
}
}
vis = new boolean[n];
int[] w = new int[n-1];
dfs(t, start, false, w);
StringBuilder ans = new StringBuilder();
for (int i=0; i<n-1; i++) {
ans.append(w[i]).append(" ");
}
System.out.println(ans);
}
public static void main(String[] args) {
FastReader in = new FastReader();
int t = in.nextInt();
while (t-- > 0) {
int n = in.nextInt();
int[] u = new int[n-1];
int[] v = new int[n-1];
for (int i=0; i<n-1; i++) {
u[i] = in.nextInt()-1;
v[i] = in.nextInt()-1;
}
solve(n, u, v);
}
}
}
| 0 | Non-plagiarised |
3368f340 | d8a171a3 | //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.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 |
51cc7026 | e81b2d16 |
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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class fastTemp {
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 int n;
static int arr[];
public static void main(String[] args)
{
FastReader fs = new FastReader();
int t = fs.nextInt();
while(t-- >0){
n = fs.nextInt();
arr = new int[n];
int max = Integer.MIN_VALUE;
for(int i=0;i<n;i++){
arr[i] = fs.nextInt();
if(max<arr[i]){
max =arr[i];
}
}
int l=1;
int r = max;
int ans = 0;
while(l<r){
int mid = l + (r-l+1)/2;
if(check(mid)){
l = mid;
}else{
r = mid-1;
}
}
System.out.println(l);
}
}
static int min = Integer.MAX_VALUE;
public static boolean check(int x){
int ar[] = new int[n];
for(int i=0;i<n;i++){
ar[i] = arr[i];
}
// Collections.copy(curr,arr);
for(int i=n-1;i>=2;i--){
if(ar[i]<x){
return false;
}
int d = (Math.min(arr[i],ar[i]-x))/3;
ar[i-1] += d;
ar[i-2] += 2*d;
}
return ar[0]>=x && ar[1]>=x;
}
} | 1 | Plagiarised |
0df4050e | d9199dfd | import java.io.*;
import java.util.*;
public class MainClass {
public static void main(String[] args) {
Reader in = new Reader(System.in);
int t = in.nextInt();
StringBuilder stringBuilder = new StringBuilder();
while (t-- > 0) {
ArrayList<Integer> reds = new ArrayList<>();
ArrayList<Integer> blue = new ArrayList<>();
int n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt() - 1;
}
char[] s = in.next().toCharArray();
for (int i = 0; i < n; i++) {
if (s[i] == 'R') {
reds.add(a[i]);
} else {
blue.add(a[i]);
}
}
Collections.sort(reds, Collections.reverseOrder());
Collections.sort(blue);
boolean ff = true;
int start = 0;
for (int i = 0; i < blue.size(); i++) {
if (blue.get(i) < start) {
ff = false;
break;
}
start++;
}
start = n - 1;
for (int i = 0; i < reds.size(); i++) {
if (reds.get(i) > start) {
ff = false;
break;
}
start--;
}
stringBuilder.append(ff?"YES":"NO").append("\n");
}
System.out.println(stringBuilder);
}
}
class Reader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public Reader(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());
}
} | 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();
}
}
| 1 | Plagiarised |
df594a00 | fcbe7917 | 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) {
br.readLine();
String[] str = br.readLine().split(" ");
int n = Integer.parseInt(str[0]);
int k = Integer.parseInt(str[1]);
int[] a = new int[k];
int[] t = new int[k];
str = br.readLine().split(" ");
for(int i=0; i<k; i++) {
a[i] = Integer.parseInt(str[i]) - 1;
}
str = br.readLine().split(" ");
for(int i=0; i<k; i++) {
t[i] = Integer.parseInt(str[i]);
}
int[] temp = new int[n];
Arrays.fill(temp, Integer.MAX_VALUE);
int[] left = new int[n];
int[] right = new int[n];
Arrays.fill(left, Integer.MAX_VALUE);
Arrays.fill(right, Integer.MAX_VALUE);
int ind = 0;
for(int i=0; i<k; i++) {
left[a[i]] = t[i];
right[a[i]] = t[i];
}
int minleft = Integer.MAX_VALUE;
for(int i=0; i<n; i++) {
left[i] = Math.min(left[i], minleft);
minleft = left[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : left[i]+1;
}
int minright = Integer.MAX_VALUE;
for(int i=n-1; i>=0; i--) {
right[i] = Math.min(right[i], minright);
minright = right[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : right[i]+1;
}
for(int i=0; i<n; i++) {
temp[i] = Math.min(right[i], left[i]);
System.out.print(temp[i]+" ");
}
System.out.println();
}
}
} | import java.io.*;
import java.util.*;
public class E_Air_Conditioners{
public static void main(String Args[]) throws Exception{
BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
int t= Integer.parseInt(br.readLine());
StringTokenizer st;
while(t-->0){
String gap=br.readLine();
st=new StringTokenizer(br.readLine());
int n= Integer.parseInt(st.nextToken());
int k= Integer.parseInt(st.nextToken());
int pos[]=new int[k];
st=new StringTokenizer(br.readLine());
for(int i=0;i<k;i++){
pos[i]=Integer.parseInt(st.nextToken())-1;
}
int temp[]=new int[k];
st=new StringTokenizer(br.readLine());
int ans[]=new int[n];
int l[]=new int[n];
int r[]=new int[n];
Arrays.fill(ans,Integer.MAX_VALUE);
for(int i=0;i<k;i++){
temp[i]=Integer.parseInt(st.nextToken());
ans[pos[i]]=temp[i];
}
int min=Integer.MAX_VALUE;
for(int i=0;i<n;i++){
if(min==Integer.MAX_VALUE){
min=ans[i];
}
else{
min=Math.min(min+1,ans[i]);
}
l[i]=min;
}
min=Integer.MAX_VALUE;
for(int i=n-1;i>=0;i--){
if(min==Integer.MAX_VALUE){
min=ans[i];
}
else{
min=Math.min(min+1,ans[i]);
}
r[i]=min;
}
for(int i=0;i<n;i++){
System.out.print(Math.min(l[i],r[i])+" ");
}
System.out.println();
}
}
}
| 0 | Non-plagiarised |
3ff60986 | d0b4b96c | 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 int N = (int)2e5 +10;
static ArrayList<ArrayList<Integer>> adj= new ArrayList<>(N);
static
{
for(int i=0; i<N; i++)
{
adj.add(new ArrayList<>());
}
}
static int[][] a = new int[2][N];
static long[][] dp = new long[2][N];
static void dfs(int v, int p){
dp[0][v] = 0;
dp[1][v]=0;
for(int u: adj.get(v))
{
if(u!=p) {
dfs(u, v);
dp[0][v] += Math.max(Math.abs(a[0][v] - a[1][u]) + dp[1][u], Math.abs(a[0][v] - a[0][u]) + dp[0][u]);
dp[1][v] += Math.max(Math.abs(a[1][v] - a[1][u]) + dp[1][u], Math.abs(a[1][v] - a[0][u]) + dp[0][u]);
}
}
}
public static void main(String[] args) throws IOException{
// write your code here
FastReader sc = new FastReader();
int t = sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
for(int i=1; i<=n; i++)
{
a[0][i] = sc.nextInt();
a[1][i] = sc.nextInt();
adj.set(i, new ArrayList<>());
}
for(int i=1; i<n; i++)
{
int u = sc.nextInt();
int v = sc.nextInt();
adj.get(u).add(v);
adj.get(v).add(u);
}
dfs(1, 0);
System.out.println(Math.max(dp[0][1], dp[1][1]));
}
}
}
| 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 int N = (int)2e5 +10;
static ArrayList<ArrayList<Integer>> adj= new ArrayList<>(N);
static
{
for(int i=0; i<N; i++)
{
adj.add(new ArrayList<>());
}
}
static int[][] a = new int[2][N];
static long[][] dp = new long[2][N];
static void dfs(int v, int p){
dp[0][v] = 0;
dp[1][v]=0;
for(int u: adj.get(v))
{
if(u!=p) {
dfs(u, v);
dp[0][v] += Math.max(Math.abs(a[0][v] - a[1][u]) + dp[1][u], Math.abs(a[0][v] - a[0][u]) + dp[0][u]);
dp[1][v] += Math.max(Math.abs(a[1][v] - a[1][u]) + dp[1][u], Math.abs(a[1][v] - a[0][u]) + dp[0][u]);
}
}
}
public static void main(String[] args) throws IOException{
// write your code here
FastReader sc = new FastReader();
int t = sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
for(int i=1; i<=n; i++)
{
a[0][i] = sc.nextInt();
a[1][i] = sc.nextInt();
adj.set(i, new ArrayList<>());
}
for(int i=1; i<n; i++)
{
int u = sc.nextInt();
int v = sc.nextInt();
adj.get(u).add(v);
adj.get(v).add(u);
}
dfs(1, 0);
System.out.println(Math.max(dp[0][1], dp[1][1]));
}
}
}
| 1 | Plagiarised |
1230c43e | ce0b2178 | //package com.company;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static boolean[] primecheck = new boolean[1000002];
public static void main(String[] args) throws IOException {
OutputStream outputStream = System.out;
FastReader in = new FastReader();
PrintWriter out = new PrintWriter(outputStream);
PROBLEM solver = new PROBLEM();
int t = 1;
t = in.nextInt();
for (int i = 0; i < t; i++) {
solver.solve(in, out);
}
out.close();
}
static class PROBLEM {
public void solve(FastReader in, PrintWriter out) {
int n = in.nextInt();
int[] a = in.readArray(n);
char[] c = in.nextLine().toCharArray();
int cur = 1;
ArrayList<Pair> p = new ArrayList<>();
for (int i = 0; i < n; i++) {
p.add(new Pair(c[i], a[i]));
}
Collections.sort(p);
// for (int i = 0; i < n; i++) {
// out.println(p.get(i).x + " " + p.get(i).y);
// }
for (int i = 0; i < n; i++) {
if(p.get(i).x == 'B' && p.get(i).y < i+1){
out.println("NO");
return;
}
if(p.get(i).x == 'R' && p.get(i).y > i+1){
out.println("NO");
return;
}
}
out.println("YES");
// int n = in.nextInt(), m = in.nextInt();
// char[] s = in.nextLine().toCharArray();
//
// int rl = 0, ud = 0, r = 0 , l = 0, rlf = 0, udf = 0;
// int lmax = 0, rmax = 0, umax = 0, dmax = 0;
//
// for (int i = 0; i < s.length; i++) {
// if(s[i] == 'L'){
// if(rlf == 0) rlf = -1;
// rl--;
// l--;
// if(rl == 0) l = 0;
// if(rl < 0 && lmax+rmax <= m) lmax = Math.max(Math.abs(l), lmax);
// }
// if(s[i] == 'R'){
// if(rlf == 0) rlf = 1;
// rl++;
// r++;
//
// if(rl > 0 && lmax+rmax <= m) rmax = Math.max(r, rmax);
// }
// if(s[i] == 'U'){
// if(udf == 0) udf = 1;
// ud++;
// r = Math.max(Math.abs(ud), r);
// if(ud > 0 && umax+dmax <= n) umax = Math.max(Math.abs(ud), umax);
// }
// if(s[i] == 'D'){
// if(udf == 0) udf = -1;
// ud--;
// r = Math.max(Math.abs(ud), r);
// if(ud < 0 && umax+dmax <= n) dmax = Math.max(Math.abs(ud), dmax);
// }
// }
//
// int ansc = 0, ansr = 0;
//
// out.println(rlf + " lmx = " + lmax + " rmax" + rmax);
//
// if(rlf == 1) ansc = m-rmax;
// else if(rlf == -1) ansc = 1+lmax;
// else ansc = 1;
//
// if(udf == 1) ansr = 1+umax;
// else if(udf == -1) ansr = m-dmax;
// else ansr = 1;
//
// out.println(ansr + " " + ansc);
}
}
static HashMap<Integer, Integer> initializeMap(int n){
HashMap<Integer,Integer> hm = new HashMap<>();
for (int i = 0; i <= n; i++) {
hm.put(i, 0);
}
return hm;
}
static boolean isRegular(char[] c){
Stack<Character> s = new Stack<>();
for (char value : c) {
if (s.isEmpty() && value == ')') return false;
if (value == '(') s.push(value);
else s.pop();
}
return s.isEmpty();
}
static ArrayList<ArrayList<Integer>> createAdj(int n, int e){
FastReader in = new FastReader();
ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
for (int i = 0; i < n + 1; i++) {
adj.add(new ArrayList<>());
}
for (int i = 0; i < e; i++) {
int a = in.nextInt(), b = in.nextInt();
System.out.println(a);
adj.get(a).add(b);
adj.get(b).add(a);
}
return adj;
}
static int binarySearch(int[] a, int l, int r, int x){
if(r>=l){
int mid = l + (r-l)/2;
if(a[mid] == x) return mid;
if(a[mid] > x) return binarySearch(a, l, mid-1, x);
else return binarySearch(a,mid+1, r, x);
}
return -1;
}
static boolean isPalindromeI(int n){
int d = 0;
int y = n;
while(y>0){
d++;
y/=10;
}
int[] a = new int[d];
for (int i = 0; i < d; i++) {
a[i] = n%10;
n/=10;
}
System.out.println(Arrays.toString(a));
for (int i = 0; i < d / 2; i++) {
if(a[i] != a[d-i-1]) return false;
}
return true;
}
static long gcd(long a, long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
static long lcm(long a, long b)
{
return (a / gcd(a, b)) * b;
}
static boolean isSquare(double a) {
boolean isSq = false;
double b = Math.sqrt(a);
double c = Math.sqrt(a) - Math.floor(b);
if (c == 0) isSq = true;
return isSq;
}
static int exponentMod(int A, int B, int C) {
// Base cases
if (A == 0)
return 0;
if (B == 0)
return 1;
// If B is even
long y;
if (B % 2 == 0) {
y = exponentMod(A, B / 2, C);
y = (y * y) % C;
}
// If B is odd
else {
y = A % C;
y = (y * exponentMod(A, B - 1, C) % C) % C;
}
return (int) ((y + C) % C);
}
static class Pair implements Comparable<Pair>{
char x;
int y;
Pair(char x, int y){
this.x = x;
this.y = y;
}
public int compareTo(Pair o){
int ans = Integer.compare(x, o.x);
if(o.x == x) ans = Integer.compare(y, o.y);
return ans;
}
}
static class Tuple implements Comparable<Tuple>{
int x, y, id;
Tuple(int x, int y, int id){
this.x = x;
this.y = y;
this.id = id;
}
public int compareTo(Tuple o){
int ans = Integer.compare(x, o.x);
if(o.x == x) ans = Integer.compare(y, o.y);
return ans;
}
}
// public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
// public U x;
// public V y;
//
// public Pair(U x, V y) {
// this.x = x;
// this.y = y;
// }
//
// public int hashCode() {
// return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
// }
//
// public boolean equals(Object o) {
// if (this == o)
// return true;
// if (o == null || getClass() != o.getClass())
// return false;
// Pair<U, V> p = (Pair<U, V>) o;
// return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
// }
//
// public int compareTo(Pair<U, V> b) {
// int cmpU = x.compareTo(b.x);
// return cmpU != 0 ? cmpU : y.compareTo(b.y);
// }
//
// public int compareToY(Pair<U, V> b) {
// int cmpU = y.compareTo(b.y);
// return cmpU != 0 ? cmpU : x.compareTo(b.x);
// }
//
// public String toString() {
// return String.format("(%s, %s)", x.toString(), y.toString());
// }
//
// }
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());
}
char nextChar() {
return next().charAt(0);
}
boolean nextBoolean() {
return !(nextInt() == 0);
}
// boolean nextBoolean(){return Boolean.parseBoolean(next());}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
public int[] readArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++) array[i] = nextInt();
return array;
}
}
private static int[] mergeSort(int[] array) {
//array.length replaced with ctr
int ctr = array.length;
if (ctr <= 1) {
return array;
}
int midpoint = ctr / 2;
int[] left = new int[midpoint];
int[] right;
if (ctr % 2 == 0) {
right = new int[midpoint];
} else {
right = new int[midpoint + 1];
}
for (int i = 0; i < left.length; i++) {
left[i] = array[i];
}
for (int i = 0; i < right.length; i++) {
right[i] = array[i + midpoint];
}
int[] result = new int[array.length];
left = mergeSort(left);
right = mergeSort(right);
result = merge(left, right);
return result;
}
private static int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int leftPointer = 0, rightPointer = 0, resultPointer = 0;
while (leftPointer < left.length || rightPointer < right.length) {
if (leftPointer < left.length && rightPointer < right.length) {
if (left[leftPointer] < right[rightPointer]) {
result[resultPointer++] = left[leftPointer++];
} else {
result[resultPointer++] = right[rightPointer++];
}
} else if (leftPointer < left.length) {
result[resultPointer++] = left[leftPointer++];
} else {
result[resultPointer++] = right[rightPointer++];
}
}
return result;
}
public static void Sieve(int n) {
Arrays.fill(primecheck, true);
primecheck[0] = false;
primecheck[1] = false;
for (int i = 2; i * i < n + 1; i++) {
if (primecheck[i]) {
for (int j = i * 2; j < n + 1; j += i) {
primecheck[j] = false;
}
}
}
}
}
| import java.io.*;
import java.util.*;
public class D {
static class Pair implements Comparable<Pair>{
int a;
char b;
public Pair(int a, char b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(Pair p) {
if(this.b == p.b)
return this.a - p.a;
return this.b - p.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();
int arr[] = scan.readArray(n);
char line[] = scan.next().toCharArray();
ArrayList<Pair> pairs = new ArrayList<Pair>();
for(int i = 0;i<n;i++) {
pairs.add(new Pair(arr[i], line[i]));
}
Collections.sort(pairs);
boolean possible = true;
for(int i = 1;i<=n;i++) {
if(pairs.get(i-1).a == i) {
continue;
}
else if(pairs.get(i-1).a < i && pairs.get(i-1).b == 'R') {
continue;
}
else if(pairs.get(i-1).a > i && pairs.get(i-1).b == 'B') {
continue;
}
else {
possible = false;
break;
}
}
output.println(possible == true ? "YES" : "NO");
}
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);
}
static boolean isPrime(int n) {
if (n <= 1) return false;
else if (n == 2) return true;
else if (n % 2 == 0) return false;
for (int i = 3; i <= Math.sqrt(n); i += 2) if (n % i == 0) return false;
return true;
}
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 |
9f354c5c | a6532df9 |
import java.util.*;
import java.io.*;
import java.math.*;
import java.sql.Array;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Solution {
private static class MyScanner {
private static final int BUF_SIZE = 2048;
BufferedReader br;
private MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
private boolean isSpace(char c) {
return c == '\n' || c == '\r' || c == ' ';
}
String next() {
try {
StringBuilder sb = new StringBuilder();
int r;
while ((r = br.read()) != -1 && isSpace((char)r));
if (r == -1) {
return null;
}
sb.append((char) r);
while ((r = br.read()) != -1 && !isSpace((char)r)) {
sb.append((char)r);
}
return sb.toString();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
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;
}
}
static long mod = (long)(1e9 + 7);
static void sort(long[] arr ) {
ArrayList<Long> al = new ArrayList<>();
for(long e:arr) al.add(e);
Collections.sort(al);
for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
}
static void sort(int[] arr ) {
ArrayList<Integer> al = new ArrayList<>();
for(int e:arr) al.add(e);
Collections.sort(al);
for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
}
static void sort(char[] arr) {
ArrayList<Character> al = new ArrayList<Character>();
for(char cc:arr) al.add(cc);
Collections.sort(al);
for(int i = 0 ;i<arr.length ;i++) arr[i] = al.get(i);
}
static long mod_mul( long... a) {
long ans = a[0]%mod;
for(int i = 1 ; i<a.length ; i++) {
ans = (ans * (a[i]%mod))%mod;
}
return ans;
}
static long mod_sum( long... a) {
long ans = 0;
for(long e:a) {
ans = (ans + e)%mod;
}
return ans;
}
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 long modInverse(long a, long m)
{
long g = gcd(a, m);
return power(a, m - 2, m);
}
static long lcm(long a , long b) {
return (a*b)/gcd(a, b);
}
static int lcm(int a , int b) {
return (int)((a*b)/gcd(a, b));
}
static long power(long x, long y, long m){
if (y == 0) return 1; long p = power(x, y / 2, m) % m; p = (int)((p * (long)p) % m);
if (y % 2 == 0) return p; else return (int)((x * (long)p) % m); }
static class Combinations{
private long[] z;
private long[] z1;
private long[] z2;
private long mod;
public Combinations(long N , long mod) {
this.mod = mod;
z = new long[(int)N+1];
z1 = new long[(int)N+1];
z[0] = 1;
for(int i =1 ; i<=N ; i++) z[i] = (z[i-1]*i)%mod;
z2 = new long[(int)N+1];
z2[0] = z2[1] = 1;
for (int i = 2; i <= N; i++)
z2[i] = z2[(int)(mod % i)] * (mod - mod / i) % mod;
z1[0] = z1[1] = 1;
for (int i = 2; i <= N; i++)
z1[i] = (z2[i] * z1[i - 1]) % mod;
}
long fac(long n) {
return z[(int)n];
}
long invrsNum(long n) {
return z2[(int)n];
}
long invrsFac(long n) {
return invrsFac((int)n);
}
long ncr(long N, long R)
{ if(R<0 || R>N ) return 0;
long ans = ((z[(int)N] * z1[(int)R])
% mod * z1[(int)(N - R)])
% mod;
return ans;
}
}
static class DisjointUnionSets {
int[] rank, parent;
int n;
public DisjointUnionSets(int n)
{
rank = new int[n];
parent = new int[n];
this.n = n;
makeSet();
}
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];
}
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
{
parent[yRoot] = xRoot;
rank[xRoot] = rank[xRoot] + 1;
}
}
}
static int max(int... a ) {
int max = a[0];
for(int e:a) max = Math.max(max, e);
return max;
}
static long max(long... a ) {
long max = a[0];
for(long e:a) max = Math.max(max, e);
return max;
}
static int min(int... a ) {
int min = a[0];
for(int e:a) min = Math.min(e, min);
return min;
}
static long min(long... a ) {
long min = a[0];
for(long e:a) min = Math.min(e, min);
return min;
}
static int[] KMP(String str) {
int n = str.length();
int[] kmp = new int[n];
for(int i = 1 ; i<n ; i++) {
int j = kmp[i-1];
while(j>0 && str.charAt(i) != str.charAt(j)) {
j = kmp[j-1];
}
if(str.charAt(i) == str.charAt(j)) j++;
kmp[i] = j;
}
return kmp;
}
/************************************************ Query **************************************************************************************/
/***************************************** Sparse Table ********************************************************/
static class SparseTable{
private long[][] st;
SparseTable(long[] arr){
int n = arr.length;
st = new long[n][25];
log = new int[n+2];
build_log(n+1);
build(arr);
}
private void build(long[] arr) {
int n = arr.length;
for(int i = n-1 ; i>=0 ; i--) {
for(int j = 0 ; j<25 ; j++) {
int r = i + (1<<j)-1;
if(r>=n) break;
if(j == 0 ) st[i][j] = arr[i];
else st[i][j] = Math.min(st[i][j-1] , st[ i + ( 1 << (j-1) ) ][ j-1 ] );
}
}
}
public long gcd(long a ,long b) {
if(a == 0) return b;
return gcd(b%a , a);
}
public long query(int l ,int r) {
int w = r-l+1;
int power = log[w];
return Math.min(st[l][power],st[r - (1<<power) + 1][power]);
}
private int[] log;
void build_log(int n) {
log[1] = 0;
for(int i = 2 ; i<=n ; i++) {
log[i] = 1 + log[i/2];
}
}
}
/******************************************************** Segement Tree *****************************************************/
/**
static class SegmentTree{
long[] tree;
long[] arr;
int n;
SegmentTree(long[] arr){
this.n = arr.length;
tree = new long[4*n+1];
this.arr = arr;
buildTree(0, n-1, 1);
}
void buildTree(int s ,int e ,int index ) {
if(s == e) {
tree[index] = arr[s];
return;
}
int mid = (s+e)/2;
buildTree( s, mid, 2*index);
buildTree( mid+1, e, 2*index+1);
tree[index] = Math.min(tree[2*index] , tree[2*index+1]);
}
long query(int si ,int ei) {
return query(0 ,n-1 , si ,ei , 1 );
}
private long query( int ss ,int se ,int qs , int qe,int index) {
if(ss>=qs && se<=qe) return tree[index];
if(qe<ss || se<qs) return (long)(1e17);
int mid = (ss + se)/2;
long left = query( ss , mid , qs ,qe , 2*index);
long right= query(mid + 1 , se , qs ,qe , 2*index+1);
return Math.min(left, right);
}
public void update(int index , int val) {
arr[index] = val;
for(long e:arr) System.out.print(e+" ");
update(index , 0 , n-1 , 1);
}
private void update(int id ,int si , int ei , int index) {
if(id < si || id>ei) return;
if(si == ei ) {
tree[index] = arr[id];
return;
}
if(si > ei) return;
int mid = (ei + si)/2;
update( id, si, mid , 2*index);
update( id , mid+1, ei , 2*index+1);
tree[index] = Math.min(tree[2*index] ,tree[2*index+1]);
}
}
*/
/* ***************************************************************************************************************************************************/
// static MyScanner sc = new MyScanner(); // only in case of less memory
static Reader sc = new Reader();
static StringBuilder sb = new StringBuilder();
public static void main(String args[]) throws IOException {
int tc = 1;
tc = sc.nextInt();
for(int i = 1 ; i<=tc ; i++) {
// sb.append("Case #" + i + ": " ); // During KickStart && HackerCup
TEST_CASE();
}
System.out.println(sb);
}
static void TEST_CASE() {
int n = sc.nextInt();
ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
for(int i =0 ; i<n ; i++) adj.add(new ArrayList<>());
int[] U = new int[n-1] , V = new int[n-1];
for(int i = 0 ; i<n-1 ; i++) {
int u = sc.nextInt()-1 , v = sc.nextInt()-1;
U[i] = u; V[i] = v;
adj.get(u).add(v);
adj.get(v).add(u);
}
int ind = -1;
for(int i =0 ; i<n ; i++) {
if(adj.get(i).size()>2) {
sb.append("-1\n");
return;
}
if(adj.get(i).size() == 1) {
ind = i;
}
}
Map<String , Integer> map = new HashMap<>();
dfs(adj, ind, -1, true, map);
for(int i =0 ; i<n-1 ; i++) {
int u = U[i];
int v = V[i];
if(map.containsKey(u+" "+v)) sb.append(map.get(u+" "+v)+" ");
else sb.append(map.get(v+" "+u)+" ");
}
sb.append("\n");
}
static void dfs(ArrayList<ArrayList<Integer>> adj ,int u , int p ,boolean eve ,Map<String , Integer> map ) {
if(eve) {
map.put(u+" "+p, 2);
}else {
map.put(u+" "+p, 3);
}
for(int v:adj.get(u)) {
if(v == p) continue;
eve = !eve;
dfs(adj, v, u, eve, map);
}
}
}
/*******************************************************************************************************************************************************/
/**
1
*/
| import java.io.*;
import java.util.*;
public class new1{
public static void dfs(ArrayList<ArrayList<int[]> > aList1, int p, int u, int[] ans, int v) {
int[] aa = aList1.get(u).get(0);
if(aa[0] != p) {
ans[aa[1]] = v;
if(v == 2) dfs(aList1, u, aa[0], ans, 3);
else dfs(aList1, u, aa[0], ans, 2);
}
else if(aList1.get(u).size() > 1){
aa = aList1.get(u).get(1);
ans[aa[1]] = v;
if(v == 2) dfs(aList1, u, aa[0], ans, 3);
else dfs(aList1, u, aa[0], ans, 2);
}
}
public static void main(String[] args) throws IOException{
BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
FastReader s = new FastReader();
int t = s.nextInt();
for(int z = 0; z < t; z++) {
int n = s.nextInt();
ArrayList<ArrayList<int[]> > aList1 = new ArrayList<ArrayList<int[]> >(n + 1);
for (int j = 1; j <= n + 1; j++) {
ArrayList<int[]> list = new ArrayList<>();
aList1.add(list);
}
for(int j = 0; j < n - 1; j ++) {
int u = s.nextInt();
int v = s.nextInt();
int[] aa = {v, j};
int[] bb = {u, j};
aList1.get(u).add(aa);
aList1.get(v).add(bb);
}
int pos = 1; int ind = -1;
for(int i = 1; i <= n; i++) {
if(aList1.get(i).size() > 2) {
pos = 0;
break;
}
if(aList1.get(i).size() == 1) {
ind = i;
}
}
if(pos == 0) {
output.write(-1 + "\n");
}
else {
int[] ans = new int[n - 1];
dfs(aList1, -1, ind, ans, 2);
for(int i = 0; i < n - 1; i++) {
output.write(ans[i] + " ");
}
output.write("\n");
}
}
output.flush();
}
}
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();
}
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 = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}} | 0 | Non-plagiarised |
8703709f | d2901569 | 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();
Integer[] k = intInput(n, in), h = intInput(n, in);
long ans = 0;
int a = k[n - 1];
int current = k[n - 1];
for (int i = n - 1; i >= 0; i--) {
if (current > k[i]) {
ans += sum(a - current + 1);
a = k[i];
current = k[i]-h[i]+1;
}else {
current = Math.min(current, k[i] - h[i]+1);
}
}
ans += sum(a - current + 1);
out.println(ans);
}
out.flush();
}
static long sum(long a) {
return a * (a + 1) / 2;
}
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 val;
int ind;
boolean positive;
Data(int val, int ind) {
this.val = Math.abs(val);
this.ind = ind;
this.positive = val >= 0;
}
}
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.val - o2.val);
}
}
class compareInd implements Comparator<Data> {
@Override
public int compare(Data o1, Data o2) {
return o1.ind - o2.ind == 0 ? o1.val - o2.val : o1.ind - o2.ind;
}
}
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;
}
} | import java.util.*;
import java.util.Scanner;
public class Solution {
static int mod=1000000007;;
//
public static void main(String[] args) {
// TODO Auto-generated method stub
// System.out.println();
Scanner sc=new Scanner(System.in);
int tt=sc.nextInt();
//
//
while(tt-->0){
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();
}
long ans=0;
int start=k[0]-h[0]-1;
int end=k[0];
int last=0;
for(int j=0;j<n;j++) {
start=k[j]-h[j]+1;
end=k[j];
last=j;
for(int i=j+1;i<n;i++) {
int temp=k[i]-h[i]+1;
if(temp<=end) {
start=Math.min(start, temp);
end=Math.max(end, k[i]);
last=i;
}
}
j=last;
long va=end-start+1;
ans+=(va*(va+1))/2;
}
System.out.println(ans);
}
}
}
| 0 | Non-plagiarised |
161b4a40 | 49e94e7e | 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();
}
} | import java.io.BufferedReader;
import java.io.IOException;
import java.lang.*;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
public class Main {
/* 10^(7) = 1s.
* ceilVal = (a+b-1) / b */
static final int mod = 1000000007;
static final long temp = 998244353;
static final long MOD = 1000000007;
static final long M = (long)1e9+7;
static class Pair implements Comparable<Pair>
{
int first, second;
public Pair(int first, int second)
{
this.first = first;
this.second = second;
}
public int compareTo(Pair ob)
{
return (int)(first - ob.first);
}
}
static class Tuple implements Comparable<Tuple>
{
int first, second,third;
public Tuple(int first, int second, int third)
{
this.first = first;
this.second = second;
this.third = third;
}
public int compareTo(Tuple o)
{
return (int)(o.third - this.third);
}
}
public static class DSU
{
int[] parent;
int[] rank; //Size of the trees is used as the rank
public DSU(int n)
{
parent = new int[n];
rank = new int[n];
Arrays.fill(parent, -1);
Arrays.fill(rank, 1);
}
public int find(int i) //finding through path compression
{
return parent[i] < 0 ? i : (parent[i] = find(parent[i]));
}
public boolean union(int a, int b) //Union Find by Rank
{
a = find(a);
b = find(b);
if(a == b) return false; //if they are already connected we exit by returning false.
// if a's parent is less than b's parent
if(rank[a] < rank[b])
{
//then move a under b
parent[a] = b;
}
//else if rank of j's parent is less than i's parent
else if(rank[a] > rank[b])
{
//then move b under a
parent[b] = a;
}
//if both have the same rank.
else
{
//move a under b (it doesnt matter if its the other way around.
parent[b] = a;
rank[a] = 1 + rank[a];
}
return true;
}
}
static class Reader
{
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) throws IOException {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long[] longReadArray(int n) throws IOException {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
public static int gcd(int a, int b)
{
if(b == 0)
return a;
else
return gcd(b,a%b);
}
public static long lcm(long a, long b)
{
return (a / LongGCD(a, b)) * b;
}
public static long LongGCD(long a, long b)
{
if(b == 0)
return a;
else
return LongGCD(b,a%b);
}
public static long LongLCM(long a, long b)
{
return (a / LongGCD(a, b)) * b;
}
//Count the number of coprime's upto N
public static long phi(long n) //euler totient/phi function
{
long ans = n;
// for(long i = 2;i*i<=n;i++)
// {
// if(n%i == 0)
// {
// while(n%i == 0) n/=i;
// ans -= (ans/i);
// }
// }
//
// if(n > 1)
// {
// ans -= (ans/n);
// }
for(long i = 2;i<=n;i++)
{
if(isPrime(i))
{
ans -= (ans/i);
}
}
return ans;
}
public static long fastPow(long x, long n)
{
if(n == 0)
return 1;
else if(n%2 == 0)
return fastPow(x*x,n/2);
else
return x*fastPow(x*x,(n-1)/2);
}
public static long modPow(long x, long y, long p)
{
long res = 1;
x = x % p;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
static long modInverse(long n, long p)
{
return modPow(n, p - 2, p);
}
// Returns nCr % p using Fermat's little theorem.
public static long nCrModP(long n, long r,long p)
{
if (n<r)
return 0;
if (r == 0)
return 1;
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 - r)], p)
% p)
% p;
}
public static long fact(long n)
{
long[] fac = new long[(int)(n) + 1];
fac[0] = 1;
for (long i = 1; i <= n; i++)
fac[(int)(i)] = fac[(int)(i - 1)] * i;
return fac[(int)(n)];
}
public static long nCr(long n, long k)
{
long ans = 1;
for(long i = 0;i<k;i++)
{
ans *= (n-i);
ans /= (i+1);
}
return ans;
}
//Modular Operations for Addition and Multiplication.
public static long perfomMod(long x)
{
return ((x%M + M)%M);
}
public static long addMod(long a, long b)
{
return perfomMod(perfomMod(a)+perfomMod(b));
}
public static long subMod(long a, long b)
{
return perfomMod(perfomMod(a)-perfomMod(b));
}
public static long mulMod(long a, long b)
{
return perfomMod(perfomMod(a)*perfomMod(b));
}
public static boolean isPrime(long n)
{
if(n == 1)
{
return false;
}
//check only for sqrt of the number as the divisors
//keep repeating so only half of them are required. So,sqrt.
for(int i = 2;i*i<=n;i++)
{
if(n%i == 0)
{
return false;
}
}
return true;
}
public static List<Integer> SieveList(int n)
{
boolean prime[] = new boolean[(int)(n+1)];
Arrays.fill(prime, true);
List<Integer> l = new ArrayList<>();
for (int p = 2; p*p<=n; p++)
{
if (prime[p] == true)
{
for(int i = p*p; i<=n; i += p)
{
prime[i] = false;
}
}
}
for (int p = 2; p<=n; p++)
{
if (prime[p] == true)
{
l.add(p);
}
}
return l;
}
public static int countDivisors(int x)
{
int c = 0;
for(int i = 1;i*i<=x;i++)
{
if(x%i == 0)
{
if(x/i != i)
{
c+=2;
}
else
{
c++;
}
}
}
return c;
}
public static long log2(long n)
{
long ans = (long)(log(n)/log(2));
return ans;
}
public static boolean isPow2(long n)
{
return (n != 0 && ((n & (n-1))) == 0);
}
public static boolean isSq(int x)
{
long s = (long)Math.round(Math.sqrt(x));
return s*s==x;
}
/*
*
* >= <=
0 1 2 3 4 5 6 7
5 5 5 6 6 6 7 7
lower_bound for 6 at index 3 (>=)
upper_bound for 6 at index 6(To get six reduce by one) (<=)
*/
public static int LowerBound(int a[], int x)
{
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;
}
public static int UpperBound(long a[], long x)
{
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;
}
public static void Sort(long[] a)
{
List<Long> l = new ArrayList<>();
for (long i : a) l.add(i);
Collections.sort(l);
// Collections.reverse(l); //Use to Sort decreasingly
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
public static void ssort(char[] a)
{
List<Character> l = new ArrayList<>();
for (char i : a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
public static void main(String[] args) throws Exception
{
Reader sc = new Reader();
PrintWriter fout = new PrintWriter(System.out);
int tt = sc.nextInt();
while(tt-- > 0)
{
int n = sc.nextInt();
char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
for(int i = 0;i<n;i++)
{
if(a[i] == '0' && b[i] == '0')
{
c00++;
}
else if(a[i] == '0' && b[i] == '1')
{
c01++;
}
else if(a[i] == '1' && b[i] == '0')
{
c10++;
}
else if(a[i] == '1' && b[i] == '1')
{
c11++;
}
}
int ans = mod;
if(c01 == c10) ans = min(ans, c01 + c10);
if(c11 == c00 + 1) ans = min(ans, c11 + c00);
fout.println((ans == mod) ? -1 : ans);
}
fout.close();
}
} | 0 | Non-plagiarised |
547ee69b | 5ce1fe32 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] a = new int[n];
for(int i=0; i<n; i++) {
a[i] = in.nextInt();
}
System.out.println(getMinimumTime(a, n));
}
public static int getMinimumTime(int[] a, int n) {
int[][] minTime = new int[n][n];
int[] posOfPerson = new int[n];
int totalOccupied = 0;
for(int i=0; i<n; i++) {
if(a[i] == 1) {
posOfPerson[totalOccupied] = i;
}
totalOccupied += a[i];
}
for(int i=0; i<n; i++) {
Arrays.fill(minTime[i], 1, n, Integer.MAX_VALUE);
}
if(a[0] == 0) {
minTime[0][1] = Math.abs(0-posOfPerson[0]);
}
int unoccupiedPlaces = 1-a[0];
for(int i=1; i<n; i++) {
if(a[i] == 0) {
unoccupiedPlaces++;
}
for(int j=1; j<=Math.min(totalOccupied, unoccupiedPlaces); j++) {
if(a[i] == 1) {
minTime[i][j] = minTime[i-1][j];
}
else if(j == unoccupiedPlaces) {
minTime[i][j] = minTime[i-1][j-1] + Math.abs(i-posOfPerson[j-1]);
}
else {
minTime[i][j] = Math.min(minTime[i-1][j], minTime[i-1][j-1] + Math.abs(i-posOfPerson[j-1]));
}
}
}
return minTime[n-1][totalOccupied];
}
}
| // Rohit Bohra | 16/05/2021 : 13:13:29
import java.io.*;
import java.util.*;
@SuppressWarnings("unchecked")
public class D{
static long[][] dp;
static List<Integer> seats,people;
static int n1,n2;
static long solve(int i,int j){
if(i==n1) return 0;
long ans = Integer.MAX_VALUE;
if(n1-i>n2-j) return ans;
if(dp[i][j]!=-1) return dp[i][j];
ans = min(solve(i,j+1),solve(i+1,j+1)+Math.abs(people.get(i)-seats.get(j)));
// out.printf("%d %d : %ld",i,j,ans);
return dp[i][j]=ans;
}
public static void main(String args[])throws IOException{
int n=sc.nextInt();
seats = new ArrayList<>(n/2);
people = new ArrayList<>(n/2);
for(int i=1;i<=n;i++){
if(sc.nextInt()==0){
seats.add(i);
}else{
people.add(i);
}
}
n1=people.size();
n2=seats.size();
// if(n2==n){
// out.println(0);
// }
dp = new long[n1][n2];
for(int i=0;i<n1;i++)
Arrays.fill(dp[i],-1);
long ans =solve(0,0);
out.println(ans);
out.close();
}
static int M=(int)Math.pow(10,9)+7;
public static void sort(int[] arr,boolean reverse){
ArrayList<Integer> list = new ArrayList<Integer>();
int n =arr.length;
for(int i=0;i<n;i++){
list.add(arr[i]);
}
if(reverse)
Collections.sort(list,Collections.reverseOrder());
else
Collections.sort(list);
for(int i=0;i<n;i++){
arr[i] = list.get(i);
}
}
public static double min(double ...a){
double min=Double.MAX_VALUE;
for(double i : a)
min =Math.min(i,min);
return min;
}
public static long min(long ...a){
long min=Long.MAX_VALUE;
for(long i : a)
min =Math.min(i,min);
return min;
}
public static int min(int ...a){
int min=Integer.MAX_VALUE;
for(int i : a)
min =Math.min(i,min);
return min;
}
public static double max(double ...a){
double max=Double.MIN_VALUE;
for(double i : a)
max =Math.max(i,max);
return max;
}
public static long max(long ...a){
long max=Long.MIN_VALUE;
for(long i : a)
max =Math.max(i,max);
return max;
}
public static int max(int ...a){
int max=Integer.MIN_VALUE;
for(int i : a)
max =Math.max(i,max);
return max;
}
static class Pair{
// Implementing equals() and hashCode()
// Map<Pair, V> map = //...
private final int x;
private final int y;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Pair)) return false;
Pair pair = (Pair) o;
return x == pair.x && y == pair.y;
}
@Override
public int hashCode() {
int result = x;
result = 31 * result + y;
return result;
}
}
static FastScanner sc = new FastScanner();
static PrintWriter out =new PrintWriter(System.out);
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());
}
public long[] readLongArray(int n) {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
}
} | 0 | Non-plagiarised |
49e94e7e | fcc7e8fa | import java.io.BufferedReader;
import java.io.IOException;
import java.lang.*;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
public class Main {
/* 10^(7) = 1s.
* ceilVal = (a+b-1) / b */
static final int mod = 1000000007;
static final long temp = 998244353;
static final long MOD = 1000000007;
static final long M = (long)1e9+7;
static class Pair implements Comparable<Pair>
{
int first, second;
public Pair(int first, int second)
{
this.first = first;
this.second = second;
}
public int compareTo(Pair ob)
{
return (int)(first - ob.first);
}
}
static class Tuple implements Comparable<Tuple>
{
int first, second,third;
public Tuple(int first, int second, int third)
{
this.first = first;
this.second = second;
this.third = third;
}
public int compareTo(Tuple o)
{
return (int)(o.third - this.third);
}
}
public static class DSU
{
int[] parent;
int[] rank; //Size of the trees is used as the rank
public DSU(int n)
{
parent = new int[n];
rank = new int[n];
Arrays.fill(parent, -1);
Arrays.fill(rank, 1);
}
public int find(int i) //finding through path compression
{
return parent[i] < 0 ? i : (parent[i] = find(parent[i]));
}
public boolean union(int a, int b) //Union Find by Rank
{
a = find(a);
b = find(b);
if(a == b) return false; //if they are already connected we exit by returning false.
// if a's parent is less than b's parent
if(rank[a] < rank[b])
{
//then move a under b
parent[a] = b;
}
//else if rank of j's parent is less than i's parent
else if(rank[a] > rank[b])
{
//then move b under a
parent[b] = a;
}
//if both have the same rank.
else
{
//move a under b (it doesnt matter if its the other way around.
parent[b] = a;
rank[a] = 1 + rank[a];
}
return true;
}
}
static class Reader
{
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) throws IOException {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long[] longReadArray(int n) throws IOException {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
public static int gcd(int a, int b)
{
if(b == 0)
return a;
else
return gcd(b,a%b);
}
public static long lcm(long a, long b)
{
return (a / LongGCD(a, b)) * b;
}
public static long LongGCD(long a, long b)
{
if(b == 0)
return a;
else
return LongGCD(b,a%b);
}
public static long LongLCM(long a, long b)
{
return (a / LongGCD(a, b)) * b;
}
//Count the number of coprime's upto N
public static long phi(long n) //euler totient/phi function
{
long ans = n;
// for(long i = 2;i*i<=n;i++)
// {
// if(n%i == 0)
// {
// while(n%i == 0) n/=i;
// ans -= (ans/i);
// }
// }
//
// if(n > 1)
// {
// ans -= (ans/n);
// }
for(long i = 2;i<=n;i++)
{
if(isPrime(i))
{
ans -= (ans/i);
}
}
return ans;
}
public static long fastPow(long x, long n)
{
if(n == 0)
return 1;
else if(n%2 == 0)
return fastPow(x*x,n/2);
else
return x*fastPow(x*x,(n-1)/2);
}
public static long modPow(long x, long y, long p)
{
long res = 1;
x = x % p;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
static long modInverse(long n, long p)
{
return modPow(n, p - 2, p);
}
// Returns nCr % p using Fermat's little theorem.
public static long nCrModP(long n, long r,long p)
{
if (n<r)
return 0;
if (r == 0)
return 1;
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 - r)], p)
% p)
% p;
}
public static long fact(long n)
{
long[] fac = new long[(int)(n) + 1];
fac[0] = 1;
for (long i = 1; i <= n; i++)
fac[(int)(i)] = fac[(int)(i - 1)] * i;
return fac[(int)(n)];
}
public static long nCr(long n, long k)
{
long ans = 1;
for(long i = 0;i<k;i++)
{
ans *= (n-i);
ans /= (i+1);
}
return ans;
}
//Modular Operations for Addition and Multiplication.
public static long perfomMod(long x)
{
return ((x%M + M)%M);
}
public static long addMod(long a, long b)
{
return perfomMod(perfomMod(a)+perfomMod(b));
}
public static long subMod(long a, long b)
{
return perfomMod(perfomMod(a)-perfomMod(b));
}
public static long mulMod(long a, long b)
{
return perfomMod(perfomMod(a)*perfomMod(b));
}
public static boolean isPrime(long n)
{
if(n == 1)
{
return false;
}
//check only for sqrt of the number as the divisors
//keep repeating so only half of them are required. So,sqrt.
for(int i = 2;i*i<=n;i++)
{
if(n%i == 0)
{
return false;
}
}
return true;
}
public static List<Integer> SieveList(int n)
{
boolean prime[] = new boolean[(int)(n+1)];
Arrays.fill(prime, true);
List<Integer> l = new ArrayList<>();
for (int p = 2; p*p<=n; p++)
{
if (prime[p] == true)
{
for(int i = p*p; i<=n; i += p)
{
prime[i] = false;
}
}
}
for (int p = 2; p<=n; p++)
{
if (prime[p] == true)
{
l.add(p);
}
}
return l;
}
public static int countDivisors(int x)
{
int c = 0;
for(int i = 1;i*i<=x;i++)
{
if(x%i == 0)
{
if(x/i != i)
{
c+=2;
}
else
{
c++;
}
}
}
return c;
}
public static long log2(long n)
{
long ans = (long)(log(n)/log(2));
return ans;
}
public static boolean isPow2(long n)
{
return (n != 0 && ((n & (n-1))) == 0);
}
public static boolean isSq(int x)
{
long s = (long)Math.round(Math.sqrt(x));
return s*s==x;
}
/*
*
* >= <=
0 1 2 3 4 5 6 7
5 5 5 6 6 6 7 7
lower_bound for 6 at index 3 (>=)
upper_bound for 6 at index 6(To get six reduce by one) (<=)
*/
public static int LowerBound(int a[], int x)
{
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;
}
public static int UpperBound(long a[], long x)
{
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;
}
public static void Sort(long[] a)
{
List<Long> l = new ArrayList<>();
for (long i : a) l.add(i);
Collections.sort(l);
// Collections.reverse(l); //Use to Sort decreasingly
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
public static void ssort(char[] a)
{
List<Character> l = new ArrayList<>();
for (char i : a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
public static void main(String[] args) throws Exception
{
Reader sc = new Reader();
PrintWriter fout = new PrintWriter(System.out);
int tt = sc.nextInt();
while(tt-- > 0)
{
int n = sc.nextInt();
char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
for(int i = 0;i<n;i++)
{
if(a[i] == '0' && b[i] == '0')
{
c00++;
}
else if(a[i] == '0' && b[i] == '1')
{
c01++;
}
else if(a[i] == '1' && b[i] == '0')
{
c10++;
}
else if(a[i] == '1' && b[i] == '1')
{
c11++;
}
}
int ans = mod;
if(c01 == c10) ans = min(ans, c01 + c10);
if(c11 == c00 + 1) ans = min(ans, c11 + c00);
fout.println((ans == mod) ? -1 : ans);
}
fout.close();
}
} | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
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);
TaskA solver = new TaskA();
int t;
t = in.nextInt();
//t = 1;
while (t > 0) {
solver.call(in,out);
t--;
}
out.close();
}
static class TaskA {
public void call(InputReader in, PrintWriter out) {
int n, _00 = 0, _01 = 0, _11 = 0, _10 = 0;
n = in.nextInt();
char[] s = in.next().toCharArray();
char[] s1 = in.next().toCharArray();
for (int i = 0; i < n; i++) {
if(s[i]==s1[i]){
if(s[i]=='0'){
_00++;
}
else{
_11++;
}
}
else{
if(s[i]=='0'){
_01++;
}
else{
_10++;
}
}
}
int ans = Integer.MAX_VALUE;
if(_10 ==_01){
ans = 2*_01;
}
if(_11 == _00 + 1){
ans = Math.min(ans, 2*_00 + 1);
}
if(ans == Integer.MAX_VALUE){
out.println(-1);
}
else{
out.println(ans);
}
}
}
static int gcd(int a, int 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 class answer implements Comparable<answer>{
int a, b;
public answer(int a, int b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(answer o) {
return o.a - this.a;
}
}
static class arrayListClass {
ArrayList<Integer> arrayList2 ;
public arrayListClass(ArrayList<Integer> arrayList) {
this.arrayList2 = arrayList;
}
}
static long gcd(long a, long b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
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 final Random random=new Random();
static void shuffleSort(int[] a) {
int n = a.length;
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 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());
}
}
} | 0 | Non-plagiarised |
35f0c004 | efa38999 | 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=input.nextInt();
while(T-->0)
{
int n=input.nextInt();
String a=input.next();
String b=input.next();
int same1=0,same0=0,opp1=0,opp0=0;
for(int i=0;i<n;i++)
{
if(a.charAt(i)==b.charAt(i))
{
if(a.charAt(i)=='1') same1++;
else same0++;
}
else
{
if(a.charAt(i)=='1') opp1++;
else opp0++;
}
}
if(same0+same1==n)
{
out.println(0);
}
else
{
int x=same1+opp1;
int y=same1+opp0;
int z=same0+opp0;
if(x==y || (z+1)==y)
{
int min=Integer.MAX_VALUE;
if((same0+same1)%2!=0 && same0==(same0+same1)/2)
{
min=Math.min(min,same0+same1);
}
if((opp0+opp1)%2==0 && opp0==(opp0+opp1)/2)
{
min=Math.min(min,opp0+opp1);
}
out.println(min);
}
else
{
out.println(-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 Main {
// For fast input output
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
try {
br = new BufferedReader(
new FileReader("input.txt"));
PrintStream out = new PrintStream(new FileOutputStream("output.txt"));
System.setOut(out);
} catch (Exception e) {
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;
}
}
// end of fast i/o code
public static void main(String[] args) {
FastReader reader = new FastReader();
StringBuilder sb = new StringBuilder("");
int t = reader.nextInt();
int ans = 0;
while (t-- > 0) {
int n = reader.nextInt();
String a = reader.nextLine();
String b = reader.nextLine();
ans = -1;
int even_demand = 0;
int odd_demand = 0;
int same_ones = 0, same_zeros = 0;
int diff_ones = 0, diff_zeros = 0;
for(int i=0; i<n; i++){
if(a.charAt(i)==b.charAt(i)){
even_demand++;
if(a.charAt(i)=='1'){
same_ones++;
}else{
same_zeros++;
}
}else{
odd_demand++;
if(a.charAt(i)=='1'){
diff_ones++;
}else{
diff_zeros++;
}
}
}
// System.out.println(even_demand+" "+same_ones+" "+same_zeros+" "+odd_demand+" "+diff_ones+" "+diff_zeros);
if(even_demand%2==1 && same_ones==same_zeros+1){
ans = even_demand;
}
if(odd_demand%2==0 && diff_ones==diff_zeros){
if(ans==-1){
ans = odd_demand;
}else{
ans = Math.min(ans, odd_demand);
}
}
sb.append(ans + "\n");
}
System.out.println(sb);
}
} | 0 | Non-plagiarised |
ac180326 | d1cd194e | //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;
}
}
}
| import java.util.*;
import java.lang.*;
import java.io.*;
public class Template {
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 solve(String s)
// {
//// Scanner sc = new Scanner(System.in);
//// String s = sc.next();
//
// int x[] = new int[2];
// x[0] = x[1] = -1;
//
// int ans = 0;
// int n = s.length();
// for(int i=0;i<n;i++)
// {
// int c = s.charAt(i) - '0';
// if(c == 1 || c == 0)
// {
// x[(i%2) ^ c] = i;
// }
// int min = Math.min(x[0], x[1]);
// ans += i - min;
// //System.out.println(ans);
// }
// System.out.println(ans);
// }
//
// public static void main(String args[])
// {
// FastReader sc = new FastReader();
// //solve();
// //Scanner sc = new Scanner(System.in)
// int testcases = sc.nextInt(); // nTest is the number of treasure hunts.
//
//// int testcases = 3;
// while(testcases-- > 0)
// {
// String s = sc.next();
// solve(s);
//
// }
//
// }
static class Pair implements Comparable<Pair>
{
int h;
int ind;
Pair(int h, int ind)
{
this.h = h;
this.ind = ind;
}
@Override
public int compareTo(Pair o) {
return this.h - o.h;
}
}
public static void main(String[] args) {
FastReader fs=new FastReader();
int T=fs.nextInt();
for (int tt=0; tt<T; tt++) {
int n = fs.nextInt();
int m = fs.nextInt();
int x = fs.nextInt();
if(n < m)
{
System.out.println("NO");
continue;
}
Pair a[] = new Pair[n];
PriorityQueue<Pair> heap = new PriorityQueue<>();
for(int i=0;i<n;i++)
{
a[i] = new Pair(fs.nextInt(), i);
}
Arrays.sort(a);
for(int i=1;i<=m;i++)
{
heap.add(new Pair(0, i));
}
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
int ans[] = new int[n];
int idx = 0;
while(!heap.isEmpty() && idx < n)
{
Pair curr = heap.poll();
curr.h += a[idx].h;
ans[a[idx].ind] = curr.ind;
heap.add(new Pair(curr.h, curr.ind));
idx++;
}
// int towers[] = new int[m+1];
// int tower = 1;
// boolean flag = false;
// boolean inc = true;
// for(int i=0;i<n;i++)
// {
// if(tower == m+1)
// {
// tower = m;
// inc = false;
// }
// if(tower == 0)
// {
// tower = 1;
// inc = true;
// }
// towers[tower] += a[i].h;
// System.out.println(a[i].h +" THis" + tower);
//// min = Math.min(min, towers[tower]);
//// max = Math.max(max, towers[tower]);
// ans[a[i].ind] = tower;
//// if(Math.abs(max - min) > x)
//// {
//// System.out.println("NO" + a[i].ind+" "+a[i].h +" "+min +" "+max);
//// flag = true;
//// break;
//// }
// if(inc)
// tower++;
// else
// tower--;
// }
// for(int i=1;i<=m;i++)
// {
// min = Math.min(min, towers[i]);
// max = Math.max(max, towers[i]);
// }
// if(Math.abs(max - min) > x)
// {
// System.out.println("NO" + max+" "+min);// + a[i].ind+" "+a[i].h +" "+min +" "+max);
// //flag = true;
// continue;
// }
// if(flag)
// continue;
System.out.println("YES");
for(int i:ans)
System.out.print(i+" ");
System.out.println();
}
}
}
| 0 | Non-plagiarised |
a7063d01 | ac4d0fc5 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.io.BufferedReader;
import java.io.InputStreamReader;
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);
solve(in, out);
out.close();
}
static String reverse(String s) {
return (new StringBuilder(s)).reverse().toString();
}
static void sieveOfEratosthenes(int n, int factors[], ArrayList<Integer> ar)
{
factors[1]=1;
int p;
for(p = 2; p*p <=n; p++)
{
if(factors[p] == 0)
{
ar.add(p);
factors[p]=p;
for(int i = p*p; i <= n; i += p)
if(factors[i]==0)
factors[i] = p;
}
}
for(;p<=n;p++){
if(factors[p] == 0)
{
factors[p] = p;
ar.add(p);
}
}
}
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 void sort2(char ar[]) {
int n = ar.length;
ArrayList<Character> 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 class SegTree {
long tree[];
long lz[];
long r;
long combine(long a, long b){
return Math.min(a,b);
}
void build(long a[], int v, int tl, int tr) {
if (tl == tr) {
tree[v] = a[tl];
}
else {
int tm = (tl + tr) / 2;
build(a, v*2, tl, tm);
build(a, v*2+1, tm+1, tr);
tree[v] = combine(tree[2*v], tree[2*v+1]);
}
}
void pointUpdate(int v, int tl, int tr, int pos, long val) {
if(tl>pos||tr<pos)
return;
if(tl==pos&&tr==pos){
tree[v] = val;
return;
}
int tm = ((tl + tr) >> 1);
pointUpdate(v*2, tl, tm, pos, val);
pointUpdate(v*2+1, tm+1, tr, pos, val);
tree[v] = combine(tree[2*v],tree[2*v+1]);
}
// void push(int v, int tl, int tr){
// if(tl==tr){
// lz[v] = 0;
// return;
// }
// tree[2*v] += lz[v];
// tree[2*v+1] += lz[v];
// lz[2*v] += lz[v];
// lz[2*v+1] += lz[v];
// lz[v] = 0;
// }
// void rangeUpdate(int v, int tl, int tr, int l, int r, long val) {
// if(tl>r||tr<l)
// return;
// push(v, tl, tr);
// if(tl>=l&&tr<=r){
// tree[v] += val;
// lz[v] += val;
// return;
// }
// int tm = ((tl + tr) >> 1);
// rangeUpdate(v*2, tl, tm, l, r, val);
// rangeUpdate(v*2+1, tm+1, tr, l, r, val);
// tree[v] = combine(tree[2*v],tree[2*v+1]);
// }
long get(int v, int tl, int tr, int l, int r, long val) {
if(l>tr||r<tl||tree[v]>val){
return 0;
}
if (tl == tr) {
tree[v] = Integer.MAX_VALUE;
return 1;
}
int tm = ((tl + tr) >> 1);
long al = get(2*v, tl, tm, l, r, val);
long ar = get(2*v+1, tm+1, tr, l, r, val);
tree[v] = combine(tree[2*v],tree[2*v+1]);
return al+ar;
}
}
static class BIT{
int n;
long tree[];
long operate(long el, long val){
return el+val;
}
void update(int x, long val){
for(;x<n;x+=(x&(-x))){
tree[x] = operate(tree[x], val);
}
}
long get(int x){
long sum = 0;
for(;x>0;x-=(x&(-x))){
sum = operate(sum, tree[x]);
}
return sum;
}
}
static int parent[];
static int rank[];
static long m = 0;
static int find_set(int v) {
if (v == parent[v])
return v;
return find_set(parent[v]);
}
static void make_set(int v) {
parent[v] = v;
rank[v] = 1;
}
static void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rank[a] < rank[b]){
int tmp = a;
a = b;
b = tmp;
}
parent[b] = a;
// if (rank[a] == rank[b])
// rank[a]++;
rank[a] += rank[b];
max1 = Math.max(max1,rank[a]);
}
}
static int parent1[];
static int rank1[];
static int find_set1(int v) {
if (v == parent1[v])
return v;
return find_set1(parent1[v]);
}
static void make_set1(int v) {
parent1[v] = v;
rank1[v] = 1;
}
static void union_sets1(int a, int b) {
a = find_set1(a);
b = find_set1(b);
if (a != b) {
if (rank1[a] < rank1[b]){
int tmp = a;
a = b;
b = tmp;
}
parent1[b] = a;
// if (rank1[a] == rank1[b])
// rank1[a]++;
rank1[a] += rank1[b];
}
}
static long max1 = 0;
static int count = 0;
static int count1 = 0;
static boolean possible;
public static void solve(InputReader sc, PrintWriter pw){
int i, j = 0;
// int t = 1;
long mod = 1000000007;
// int factors[] = new int[1000001];
// ArrayList<Integer> ar = new ArrayList<>();
// sieveOfEratosthenes(1000000, factors, ar);
// HashSet<Integer> set = new HashSet<>();
// for(int x:ar){
// set.add(x);
// }
int t = sc.nextInt();
u: while (t-- > 0) {
int n = sc.nextInt();
int e[][] = new int[n-1][2];
int x[] = new int[n];
int m = 0;
for(i=0;i<n-1;i++){
e[i][0] = sc.nextInt()-1;
e[i][1] = sc.nextInt()-1;
x[e[i][0]]++;
x[e[i][1]]++;
m = Math.max(x[e[i][0]],m);
m = Math.max(x[e[i][1]],m);
}
if(m>2)
pw.println(-1);
else{
if(n==2){
pw.println(2);
}
else if(n==3){
pw.println(2+" "+3);
}
else{
int d = 0;
int ans[] = new int[n-1];
ArrayList<Integer> ar[] = new ArrayList[n];
ArrayList<Integer> ar1[] = new ArrayList[n];
for(i=0;i<n;i++){
ar[i] = new ArrayList<>();
ar1[i] = new ArrayList<>();
}
for(i=0;i<n-1;i++){
int a = e[i][0];
int b = e[i][1];
ar[a].add(b);
ar1[a].add(i);
ar[b].add(a);
ar1[b].add(i);
if(x[a]==1)
d = a;
if(x[b]==1)
d = b;
}
visit(d,ar,ar1,ans,-1,2);
for(i=0;i<n-1;i++){
pw.print(ans[i]+" ");
}
pw.println();
}
}
}
}
static void visit(int d, ArrayList<Integer> ar[], ArrayList<Integer> ar1[], int ans[], int par, int v){
if(ar[d].get(0)!=par){
ans[ar1[d].get(0)] = v;
visit(ar[d].get(0), ar, ar1, ans, d, 5-v);
return;
}
if(ar[d].size()==1)
return;
ans[ar1[d].get(1)] = v;
visit(ar[d].get(1), ar, ar1, ans, d, 5-v);
}
static void KMPSearch(char pat[], char txt[], int pres[]){
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[j] == txt[i]) {
j++;
i++;
}
if (j == M) {
pres[i-1] = 1;
j = lps[j - 1];
}
else if (i < N && pat[j] != txt[i]) {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
}
}
static void computeLPSArray(char pat[], int M, int lps[])
{
int len = 0;
int i = 1;
lps[0] = 0;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
}
else
{
if (len != 0) {
len = lps[len - 1];
}
else
{
lps[i] = len;
i++;
}
}
}
}
static long[][] matrixMult(long a[][], long b[][], long mod){
int n = a.length;
int m = a[0].length;
int p = b[0].length;
long c[][] = new long[n][p];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
for(int k=0;k<p;k++){
c[i][k] += a[i][j]*b[j][k];
c[i][k] %= mod;
}
}
}
return c;
}
static long[][] exp(long mat[][], long b, long mod){
if(b==0){
int n = mat.length;
long res[][] = new long[n][n];
for(int i=0;i<n;i++){
res[i][i] = 1;
}
return res;
}
long half[][] = exp(mat, b/2, mod);
long res[][] = matrixMult(half, half, mod);
if(b%2==1){
res = matrixMult(res, mat, mod);
}
return res;
}
static void countPrimeFactors(int num, int a[], HashMap<Integer,Integer> pos){
for(int i=2;i*i<num;i++){
if(num%i==0){
int y = pos.get(i);
while(num%i==0){
a[y]++;
num/=i;
}
}
}
if(num>1){
int y = pos.get(num);
a[y]++;
}
}
static void assignAnc(ArrayList<Integer> ar[], int depth[], int sz[], int par[][] ,int curr, int parent, int d){
depth[curr] = d;
sz[curr] = 1;
par[curr][0] = parent;
for(int v:ar[curr]){
if(parent==v)
continue;
assignAnc(ar, depth, sz, par, v, curr, d+1);
sz[curr] += sz[v];
}
}
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 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 long lcm(int a, int b){
return a*b/gcd(a,b);
}
static class CustomPair {
long a[];
CustomPair(long a[]) {
this.a = a;
}
}
static class Pair1 implements Comparable<Pair1> {
long a;
long b;
Pair1(long a, long b) {
this.a = a;
this.b = b;
}
public int compareTo(Pair1 p) {
if(a!=p.a)
return (a<p.a?-1:1);
return (b<p.b?-1:1);
}
}
static class Pair implements Comparable<Pair> {
int a;
int b;
int c;
Pair(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public int compareTo(Pair p) {
if(b!=p.b)
return (b-p.b);
return (a-p.a);
}
}
static class Pair2 implements Comparable<Pair2> {
int a;
int b;
int c;
Pair2(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public int compareTo(Pair2 p) {
return a-p.a;
}
}
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 long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
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);
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 9992768);
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());
}
}
} | import java.io.*;
import java.util.*;
public class Main {
static boolean[] ret;
static boolean[] updated;
static ArrayList<Integer>[] adjacencyList;
static Edge[] edgeList;
static class Edge {
int start, end, number;
public Edge (int _start, int _end, int _number) {
start = _start;
end = _end;
number = _number;
}
}
public static void dfs(int node) {
updated[node] = true;
for (int next : adjacencyList[edgeList[node].start]) {
if (!updated[next]) {
ret[next] = !ret[node];
dfs(next);
}
}
for (int next : adjacencyList[edgeList[node].end]) {
if (!updated[next]) {
ret[next] = !ret[node];
dfs(next);
}
}
}
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 numCases = Integer.parseInt(br.readLine());
for (int i = 0; i < numCases; i++) {
int numVertices = Integer.parseInt(br.readLine());
int[] numEdges = new int[numVertices];
edgeList = new Edge[numVertices - 1];
adjacencyList = new ArrayList[numVertices];
for (int j = 0; j < numVertices; j++) {
adjacencyList[j] = new ArrayList<>();
}
for (int j = 0; j < numVertices - 1; j++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken()) - 1;
int b = Integer.parseInt(st.nextToken()) - 1;
edgeList[j] = new Edge(a, b, j);
numEdges[a]++;
numEdges[b]++;
adjacencyList[a].add(j);
adjacencyList[b].add(j);
}
boolean good = true;
for (int j = 0; j < numVertices; j++) {
if (numEdges[j] > 2) {
good = false;
break;
}
}
if (!good) {
pw.println(-1);
} else {
ret = new boolean[numVertices - 1];
updated = new boolean[numVertices - 1];
dfs(0);
for (boolean b : ret) {
if (b)
pw.print(5 + " ");
else
pw.print(2 + " ");
}
pw.println();
}
}
br.close();
pw.close();
}
} | 0 | Non-plagiarised |
1162c08f | a4d6775d | 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.io.*;
import java.util.*;
public class ArmChairs {
public static int solution(int n, int[] arr) {
ArrayList<Integer> one = new ArrayList<Integer>();
ArrayList<Integer> zero = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
one.add(i);
} else {
zero.add(i);
}
}
int[][] dp = new int[one.size() + 1][zero.size() + 1];
for (int i = 1; i <= one.size(); i++) {
dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
for (int j = i + 1; j <= zero.size(); j++) {
dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
}
}
return dp[one.size()][zero.size()];
}
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
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]);
}
log.write(Integer.toString(solution(n, arr)) + "\n");
log.flush();
}
} | 1 | Plagiarised |
End of preview. Expand
in Dataset Viewer.
Dataset Card for Dataset Name
The dataset is called ConPlag. It's a source code plagiarism dataset. The original dataset is available at Zenodo. (https://zenodo.org/records/7332790). The research paper presenting the dataset can be found at Arxiv. (https://arxiv.org/abs/2303.10763) All the credit goes to the authors.
Dataset Details
Dataset Description
The dataset has pairs of codes and the task is to classify whether they were plagiarised or not.
Dataset Structure
The dataset has two versions (subsets) 1 for raw and 2 for template free. The dataset is split into 70% for training, 15% for validation and 15% for testing.
- Downloads last month
- 0
Size of downloaded dataset files:
10.2 MB
Size of the auto-converted Parquet files:
2.89 MB
Number of rows:
1,822