src
stringlengths 95
64.6k
| complexity
stringclasses 7
values | problem
stringlengths 6
50
| from
stringclasses 1
value |
|---|---|---|---|
//make sure to make new file!
import java.io.*;
import java.util.*;
public class CDS2021{
public static void main(String[] args)throws IOException{
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int t = Integer.parseInt(f.readLine());
for(int q = 1; q <= t; q++){
int n = Integer.parseInt(f.readLine());
int[] array = new int[n];
for(int k = 0; k < n; k++){
array[k] = Integer.parseInt(f.readLine());
}
StringJoiner sj = new StringJoiner("\n");
Stack<Entry> stack = new Stack<Entry>();
//first element should be 1
sj.add("1");
stack.push(new Entry("1",1));
for(int k = 1; k < n; k++){
if(array[k] == 1){
//add new depth
String s = stack.peek().s + ".1";
sj.add(s);
stack.push(new Entry(s,1));
} else {
while(!stack.isEmpty() && stack.peek().last != array[k]-1){
stack.pop();
}
if(stack.isEmpty()) break; //shouldn't happen
String s = "";
int index = stack.peek().s.lastIndexOf(".");
if(index == -1) s = "" + array[k];
else s = stack.peek().s.substring(0,index+1) + array[k];
sj.add(s);
stack.pop();
stack.push(new Entry(s,array[k]));
}
}
out.println(sj.toString());
}
out.close();
}
public static class Entry{
String s;
int last;
public Entry(String a, int b){
s = a;
last = b;
}
}
} | cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.*;
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
for (int i = 0, t = sc.nextInt(); i < t; i++) {
int n = sc.nextInt();
LinkedList<Set<Integer>> stack = new LinkedList<>();
for (int j = 0; j < n; j++) {
printStack(stack);
int val = sc.nextInt();
if (val == 1) {
Set<Integer> branch = new HashSet<>();
branch.add(val);
stack.push(branch);
continue;
}
Set<Integer> branch = stack.peek();
assert branch != null;
while (branch.contains(val) || branch.stream().max(Integer::compareTo).get() + 1 != val) {
stack.pop();
branch = stack.peek();
}
branch.add(val);
}
printStack(stack);
}
}
public static void printStack(LinkedList<Set<Integer>> stack) {
if (stack.size() == 0) {
return;
}
StringBuilder sb = new StringBuilder();
for (int i = stack.size() - 1; i >= 0; i--) {
sb.append(stack.get(i).stream().max(Integer::compareTo).get()).append(".");
}
System.out.println(sb.substring(0, sb.length() - 1));
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;
/*
1
4
1
1
2
3
*/
public class C {
public static void main(String[] args) {
FastScanner fs=new FastScanner();
int T=fs.nextInt();
PrintWriter out=new PrintWriter(System.out);
for (int tt=0; tt<T; tt++) {
int n=fs.nextInt();
int[] a=fs.readArray(n);
int[] stack=new int[n];
int size=0;
for (int i:a) {
if (i==1) {
stack[size++]=i;
}
else {
while (stack[size-1]!=i-1) {
size--;
}
size--;
stack[size++]=i;
}
for (int j=0; j<size; j++) {
out.print(stack[j]);
if (j!=size-1) out.print('.');
}
out.println();
}
// int[] mapTo=new int[n];
// Arrays.fill(mapTo, -1);
// ArrayDeque<Integer>[] occsOf=new ArrayDeque[1001];
// for (int i=0; i<occsOf.length; i++) occsOf[i]=new ArrayDeque<>();
// int lastOne=-1;
//
// for (int i=0; i<n; i++) {
// if (a[i]==1) {
// mapTo[i]=lastOne;
// lastOne=i;
// }
// }
// for (int value=2; value<occsOf.length; value++) {
// for (int i:occsOf[value]) {
// int mapsTo=occsOf[value-1].removeFirst();
// mapTo[i]=mapsTo;
// }
// }
// System.out.println(Arrays.toString(mapTo));
// for (int i=0; i<n; i++) {
// ArrayList<Integer> listBackwards=new ArrayList<>();
// listBackwards.add(a[i]);
// int at=i;
// while (true) {
//// System.out.println("x");
// if (mapTo[at]==-1) {
// break;
// }
// if (a[mapTo[at]]!=a[at]-1) {
// listBackwards.add(a[mapTo[at]]);
// }
// at=mapTo[at];
// }
// for (int j=listBackwards.size()-1; j>=0; j--) {
// out.print(listBackwards.get(j));
// if (j!=0) out.print('.');
// }
// out.println();
// }
}
out.close();
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.TimeUnit;
public class c1523 implements Runnable{
public static void main(String[] args) {
try{
new Thread(null, new c1523(), "process", 1<<26).start();
}
catch(Exception e){
System.out.println(e);
}
}
public void run() {
FastReader scan = new FastReader();
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
//PrintWriter out = new PrintWriter("file.out");
Task solver = new Task();
int t = scan.nextInt();
//int t = 1;
for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
out.close();
}
static class Task {
static final int oo = Integer.MAX_VALUE;
static final long OO = Long.MAX_VALUE;
public void solve(int testNumber, FastReader sc, PrintWriter out) {
int N = sc.nextInt();
int[] arr = sc.readArray(N);
Stack<Integer> cur = new Stack<>();
StringBuilder sb = new StringBuilder("");
for(int i = 0; i < N; i++) {
if(arr[i] == 1) {
cur.add(1);
} else {
while(cur.peek() != arr[i] - 1)
cur.pop();
cur.pop();
cur.add(arr[i]);
}
for(int each: cur) {
sb.append(each + ".");
}
sb.deleteCharAt(sb.length()-1);
sb.append("\n");
}
out.println(sb);
}
}
static long modInverse(long N, long MOD) {
return binpow(N, MOD - 2, MOD);
}
static long modDivide(long a, long b, long MOD) {
a %= MOD;
return (binpow(b, MOD-2, MOD) * a) % MOD;
}
static long binpow(long a, long b, long m) {
a %= m;
long res = 1;
while (b > 0) {
if ((b & 1) == 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
static int[] reverse(int a[])
{
int[] b = new int[a.length];
for (int i = 0, j = a.length; i < a.length; i++, j--) {
b[j - 1] = a[i];
}
return b;
}
static long[] reverse(long a[])
{
long[] b = new long[a.length];
for (int i = 0, j = a.length; i < a.length; i++, j--) {
b[j - 1] = a[i];
}
return b;
}
static void shuffle(Object[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
Object temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
static void shuffle(int[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
int temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
static void shuffle(long[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(a.length);
long temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
static class tup implements Comparable<tup>, Comparator<tup>{
int a, b;
tup(int a,int b){
this.a=a;
this.b=b;
}
public tup() {
}
@Override
public int compareTo(tup o){
return Integer.compare(b,o.b);
}
@Override
public int compare(tup o1, tup o2) {
return Integer.compare(o1.b, o2.b);
}
@Override
public int hashCode() {
return Objects.hash(a, b);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
tup other = (tup) obj;
return a==other.a && b==other.b;
}
@Override
public String toString() {
return a + " " + b;
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastReader(String s) throws FileNotFoundException {
br = new BufferedReader(new FileReader(new File(s)));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] readArray(int size) {
int[] a = new int[size];
for(int i = 0; i < size; i++) {
a[i] = nextInt();
}
return a;
}
long[] readLongArray(int size) {
long[] a = new long[size];
for(int i = 0; i < size; i++) {
a[i] = nextLong();
}
return a;
}
}
static void dbg(int[] arr) {
System.out.println(Arrays.toString(arr));
}
static void dbg(long[] arr) {
System.out.println(Arrays.toString(arr));
}
static void dbg(boolean[] arr) {
System.out.println(Arrays.toString(arr));
}
static void dbg(Object... args) {
for (Object arg : args)
System.out.print(arg + " ");
System.out.println();
}
} | cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
public class C{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
long mod=1000000007l;
int cases=sc.nextInt();
while(cases>0)
{
cases--;
Stack<Integer> stack=new Stack<>();
int n=sc.nextInt();
for(int j=0;j<n;j++)
{
int x=sc.nextInt();
if(x==1)
{
stack.add(1);
}
else
{
int p=stack.pop();
if(p==x-1)
{
stack.add(x);
}
else {
while (p != x-1) {
p = stack.pop();
}
stack.add(x);
}
}
StringBuilder f=new StringBuilder();
Stack<Integer> temp=new Stack<>();
while(stack.isEmpty()==false)
{
temp.add(stack.pop());
}
while(temp.isEmpty()==false)
{
int z=temp.pop();
f.append(z+".");
stack.add(z);
}
System.out.println(f.substring(0,f.length()-1));
}
}
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author dauom
*/
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);
CCompressionAndExpansion solver = new CCompressionAndExpansion();
int testCount = Integer.parseInt(in.next());
for (int i = 1; i <= testCount; i++)
solver.solve(i, in, out);
out.close();
}
static class CCompressionAndExpansion {
public final void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
ArrayList<Integer> start = new ArrayList<>();
start.add(in.nextInt());
ans.add(start);
out.println("1");
for (int i = 1; i < n; i++) {
ArrayList<Integer> lastList = ans.get(ans.size() - 1);
ArrayList<Integer> curList = (ArrayList<Integer>) lastList.clone();
ans.add(curList);
int curLast = in.nextInt();
for (int j = lastList.size() - 1; j >= 0; j--) {
int last = lastList.get(j);
if (curLast == 1) {
curList.add(1);
break;
} else if (curLast == last + 1) {
curList.set(j, curLast);
break;
} else {
curList.remove(j);
}
}
for (int j = 0; j < curList.size(); j++) {
if (j > 0) out.print(".");
out.print(curList.get(j));
}
out.println();
}
}
}
static final class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[1 << 18];
private int curChar;
private int numChars;
public InputReader() {
this.stream = System.in;
}
public InputReader(final InputStream stream) {
this.stream = stream;
}
private int read() {
if (this.numChars == -1) {
throw new UnknownError();
} else {
if (this.curChar >= this.numChars) {
this.curChar = 0;
try {
this.numChars = this.stream.read(this.buf);
} catch (IOException ex) {
throw new InputMismatchException();
}
if (this.numChars <= 0) {
return -1;
}
}
return this.buf[this.curChar++];
}
}
public final int nextInt() {
int c;
for (c = this.read(); isSpaceChar(c); c = this.read()) {
}
byte sgn = 1;
if (c == 45) { // 45 == '-'
sgn = -1;
c = this.read();
}
int res = 0;
while (c >= 48 && c <= 57) { // 48 == '0', 57 == '9'
res *= 10;
res += c - 48; // 48 == '0'
c = this.read();
if (isSpaceChar(c)) {
return res * sgn;
}
}
throw new InputMismatchException();
}
public final String next() {
int c;
while (isSpaceChar(c = this.read())) {
}
StringBuilder result = new StringBuilder();
result.appendCodePoint(c);
while (!isSpaceChar(c = this.read())) {
result.appendCodePoint(c);
}
return result.toString();
}
private static boolean isSpaceChar(final int c) {
return c == 32 || c == 10 || c == 13 || c == 9
|| c == -1; // 32 == ' ', 10 == '\n', 13 == '\r', 9 == '\t'
}
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.BigInteger;
public class Main{
static InputReader sc;
static PrintWriter pw;
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
sc = new InputReader(inputStream);
pw = new PrintWriter(outputStream);
solve();
pw.close();
}
// static int L,R,top,bottom;
// static int cnt,edge;
// static long ans;
static int time;
// static boolean isIsland;
static BigInteger min(BigInteger a, BigInteger b){
if(a.compareTo(b)<0)
return a;
return b;
}
public static void solve(){
int t=1;
t=s(0);
u:while(t-->0){
int n=s(0);
int []arr=new int [n];
feedArr(arr);
Stack<Pair> stk=new Stack<>();
stk.push(new Pair("",1));
pln(1);
Pair pr;
for(int i=1;i<n;i++){
if(arr[i]==1){
pr=stk.peek();
stk.push(new Pair(pr.s+(pr.s.length()==0?"":".")+pr.i,1));
pln(stk.peek().s+"."+stk.peek().i);
}
else if(stk.peek().i==arr[i]-1){
pr=stk.pop();
pln(pr.s+(pr.s.length()==0?"":".")+arr[i]);
pr.i++;
stk.push(pr);
}
else{
stk.pop();
i--;
}
}
}
}
static long fact(long p){
long ans=1l;
for(long i=2;i<=p;i++)
ans*=i;
return ans;
}
static int find(int j, List<Integer> B, List<Integer> A, int i){
// System.out.println("Hi");
int l=j,r=B.size()-1,m;
while(l<=r){
m=(r-l)/2+l;
if(A.size()-i-1<=B.size()-m-1)
l=m+1;
else
r=m-1;
}
// System.out.println("Bye");
return r;
}
static int find2(List<Integer> B, int x){
int l=0,r=B.size()-1,m;
// System.out.println("Hi2");
// System.out.println(j);
while(l<=r){
m=(r-l)/2+l;
// System.out.println(m);
if(B.get(m)-x<=0)
l=m+1;
else
r=m-1;
}
// System.out.println("Bye2");
return r;
}
static long nPr(long n, long r){
long ans=1;
for(long i=1;i<=r;i++)
ans*=(n-i+1);
return ans;
}
static long nCr(long n, long r){
long ans=1;
for(long i=1;i<=r;i++){
ans*=(n-i+1);
ans/=i;
}
return ans;
}
static void update_DAG(int cur,int val, int []graph, int n)
{
if(val>maxx[cur])
{
int x=graph[cur];
if(x!=-1)
update_DAG(x,val+1,graph,n);
maxx[cur]=val;
update(cur,val,n);
}
}
static int []bit, maxx;
static void update(int i,int val, int n)
{
while(i<=n)
{
bit[i]=Math.max(bit[i],val);
i=i+(i&(-i));
}
}
static int query(int i)
{
int ret=0;
while(i>0)
{
ret=Math.max(ret,bit[i]);
i=i-(i&(-i));
}
return ret;
}
public static int [][]dir=new int [][]{{1,0},{0,1},{-1,0},{0,-1}};
public static int find(List<Integer> list, int x){
int l=0,r=list.size()-1,m;
while(l<=r){
m=(r-l)/2+l;
if(list.get(m)<=x)
l=m+1;
else
r=m-1;
}
return r;
}
static class Node{
int val;
long cost;
Node next;
Node(int v,long c){
val=v;
next=null;
cost=c;
}
}
public static long sum(long n){
long val=0l;
while(n>0){
val+=n%10;
n/=10;
}
return val;
}
// static class Node{
// int left,right;
// Node prev,next;
// Node(int i, int v){
// left=i;
// right=v;
// prev=next=null;
// }
// void remove(){
// this.prev.next=this.next;
// this.next.prev=this.prev;
// }
// void insert(Node node){
// node.next=this;
// node.prev=this.prev;
// node.prev.next=node;
// this.prev=node;
// }
// }
public static int findDiameter(int r, List<List<Integer>>list){
return findFarthest(findFarthest(r,list)[0],list)[1];
}
public static int[] findFarthest(int u, List<List<Integer>>list){
int n=list.size();
boolean []vis=new boolean[n+1];
Queue<Integer>q=new LinkedList<>();
q.offer(u);
vis[u]=true;
int s,pr,cnt=0;
int []ar=new int[]{u,0};
while(q.size()>0){
s=q.size();
while(s-->0){
pr=q.poll();
if(ar[1]<cnt){
ar[1]=cnt;
ar[0]=pr;
}
for(int i:list.get(pr)){
if(!vis[i]){
vis[i]=true;
q.offer(i);
}
}
}
cnt++;
}
return ar;
}
public static long atMostK(char []chrr, int k){
if(k<0)
return 0;
int l=0,cnt=0;
long ans=0l;
for(int i=0;i<chrr.length;i++){
if(chrr[i]=='1')
cnt++;
while(cnt>k){
if(chrr[l++]=='1')
cnt--;
}
ans+=(long)(i-l)+1l;
}
return ans;
}
public static int ask(int l, int r){
System.out.println("? "+l+" "+r);
System.out.flush();
return sc.nextInt();
}
public static void sort(int []arr){
ArrayList<Integer> list=new ArrayList<>();
for(int i=0;i<arr.length;i++)
list.add(arr[i]);
Collections.sort(list);
for(int i=0;i<arr.length;i++)
arr[i]=list.get(i);
}
public static void sort(long []arr){
ArrayList<Long> list=new ArrayList<>();
for(int i=0;i<arr.length;i++)
list.add(arr[i]);
Collections.sort(list);
for(int i=0;i<arr.length;i++)
arr[i]=list.get(i);
}
public static void swap(char []chrr, int i, int j){
char temp=chrr[i];
chrr[i]=chrr[j];
chrr[j]=temp;
}
public static int countSetBits(long n){
int a=0;
while(n>0){
a+=(n&1);
n>>=1;
}
return a;
}
static class Pair{
String s;
int i;
Pair(String S, int I){
s=S;
i=I;
}
//*
}
/*/
public int compareTo(Pair p){
return (b-p.b);
}
public int hashCode(){
int hashcode = (a+" "+b).hashCode();
return hashcode;
}
public boolean equals(Object obj){
if (obj instanceof Pair) {
Pair p = (Pair) obj;
return (p.a==this.a && p.b == this.b);
}
return false;
}
}
//*/
static boolean isPrime(long n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
static long gcd(long a, long b) {
if (b == 0)
return a;
return a>b?gcd(b, a % b):gcd(a, b % a);
}
static long fast_pow(long base,long n,long M){
if(n==0)
return 1;
if(n==1)
return base;
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);
}
public static int s(int n){
return sc.nextInt();
}
public static long s(long n){
return sc.nextLong();
}
public static String s(String n){
return sc.next();
}
public static double s(double n){
return sc.nextDouble();
}
public static void p(int n){
pw.print(n);
}
public static void p(long n){
pw.print(n);
}
public static void p(String n){
pw.print(n);
}
public static void p(double n){
pw.print(n);
}
public static void pln(int n){
pw.println(n);
}
public static void pln(long n){
pw.println(n);
}
public static void pln(String n){
pw.println(n);
}
public static void pln(double n){
pw.println(n);
}
public static void feedArr(long []arr){
for(int i=0;i<arr.length;i++)
arr[i]=sc.nextLong();
}
public static void feedArr(double []arr){
for(int i=0;i<arr.length;i++)
arr[i]=sc.nextDouble();
}
public static void feedArr(int []arr){
for(int i=0;i<arr.length;i++)
arr[i]=sc.nextInt();
}
public static void feedArr(String []arr){
for(int i=0;i<arr.length;i++)
arr[i]=sc.next();
}
public static String printArr(int []arr){
StringBuilder sbr=new StringBuilder();
for(int i:arr)
sbr.append(i+" ");
return sbr.toString();
}
public static String printArr(long []arr){
StringBuilder sbr=new StringBuilder();
for(long i:arr)
sbr.append(i+" ");
return sbr.toString();
}
public static String printArr(String []arr){
StringBuilder sbr=new StringBuilder();
for(String i:arr)
sbr.append(i+" ");
return sbr.toString();
}
public static String printArr(double []arr){
StringBuilder sbr=new StringBuilder();
for(double i:arr)
sbr.append(i+" ");
return sbr.toString();
}
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());
}
}
}
class AncestorQuerier {
int [][]dp;
int N=200001;
int M=22;
int max;
public void preCompute(int []par){
for(int i=0;i<N;i++){
if(i>=2&&i<par.length)
dp[i][0]=par[i];
else
dp[i][0]=-1;
}
for(int j=1;j<M;j++){
for(int i=0;i<N;i++){
if(dp[i][j-1]!=-1)
dp[i][j]=dp[dp[i][j-1]][j-1];
}
}
}
public int getAncestor(int val, int k) {
if(k<0||val>max)
return -1;
if(k==0)
return val;
int t=(1<<(M-1));
for(int i=M-1;i>=0&&val!=-1;i--,t>>=1){
if(t<=k){
val=dp[val][i];
k-=t;
}
}
return val;
}
} | cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.*;
public class CompressionAndExpansion {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for (int t = 0; t < T; t++) {
int N = in.nextInt();
List<Integer> list = new ArrayList<>();
for (int i = 0; i < N; i++) {
int n = in.nextInt();
if (n == 1) {
list.add(n);
} else {
for (int j = list.size() - 1; j >= 0; j--) {
if (list.get(j) == n - 1) {
list.set(j, n);
break;
}
list.remove(j);
}
}
for (int j = 0; j < list.size(); j++) {
System.out.print(list.get(j) + (j == list.size() - 1 ? "\n" : "."));
}
}
}
}
} | cubic | 1523_C. Compression and Expansion | CODEFORCES |
// package contest;
import java.io.*;
import java.util.Stack;
import java.util.StringTokenizer;
public class teama {
static int mod = 2_000_000_007;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
int T = Integer.parseInt(br.readLine());
for (int t = 0; t < T; t++) {
int N = Integer.parseInt(br.readLine());
Stack<Integer> stack = new Stack();
for (int i = 0; i < N; i++) {
int a = Integer.parseInt(br.readLine());
if (a != 1) {
while (stack.peek() + 1 != a) {
stack.pop();
}
stack.pop();
}
stack.push(a);
boolean dummy = false;
for (int j : stack) {
if (dummy) {
pw.print(".");
}
pw.print(j);
dummy = true;
}
pw.println();
}
}
pw.close();
br.close();
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
//package Codeforces;
import java.io.*;
import java.util.*;
public class C {
static class Node{
StringBuilder sb = new StringBuilder();
Stack<Integer> stk = new Stack<>();
}
public static void main(String[] args) throws IOException {
Soumit sc = new Soumit();
int t = sc.nextInt();
StringBuilder sb = new StringBuilder();
while (t-->0){
int n = sc.nextInt();
int[] arr = sc.nextIntArray(n);
Stack<Node> mainstk = new Stack<>();
Node pnode = new Node();
pnode.stk.push(1);
pnode.sb.append("1");
mainstk.push(pnode);
sb.append(pnode.sb).append("\n");
for(int i=1;i<n;i++){
int val = arr[i];
if(val==1){
Node node = new Node();
node.stk.push(1);
node.sb.append(mainstk.peek().sb).append(".1");
mainstk.push(node);
sb.append(node.sb).append("\n");
}
else {
while (true) {
Node node = mainstk.pop();
if (node.stk.peek()==val-1) {
node.stk.push(val);
if(mainstk.isEmpty()){
node.sb = new StringBuilder();
node.sb.append(val);
sb.append(val).append("\n");
}
else{
Node peeknode = mainstk.peek();
node.sb = new StringBuilder();
node.sb.append(peeknode.sb).append(".").append(val);
sb.append(peeknode.sb).append(".").append(val).append("\n");
}
mainstk.push(node);
break;
}
}
}
}
}
System.out.println(sb);
sc.close();
}
static class Soumit {
final private int BUFFER_SIZE = 1 << 18;
final private DataInputStream din;
final private byte[] buffer;
private PrintWriter pw;
private int bufferPointer, bytesRead;
StringTokenizer st;
public Soumit() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Soumit(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public void streamOutput(String file) throws IOException {
FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);
pw = new PrintWriter(bw);
}
public void println(String a) {
pw.println(a);
}
public void print(String a) {
pw.print(a);
}
public String readLine() throws IOException {
byte[] buf = new byte[3000064]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public void sort(int[] arr) {
ArrayList<Integer> arlist = new ArrayList<>();
for (int i : arr)
arlist.add(i);
Collections.sort(arlist);
for (int i = 0; i < arr.length; i++)
arr[i] = arlist.get(i);
}
public void sort(long[] arr) {
ArrayList<Long> arlist = new ArrayList<>();
for (long i : arr)
arlist.add(i);
Collections.sort(arlist);
for (int i = 0; i < arr.length; i++)
arr[i] = arlist.get(i);
}
public int[] nextIntArray(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
public long[] nextLongArray(int n) throws IOException {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
public double[] nextDoubleArray(int n) throws IOException {
double[] arr = new double[n];
for (int i = 0; i < n; i++) {
arr[i] = nextDouble();
}
return arr;
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
/*if (din == null)
return;*/
if (din != null) din.close();
if (pw != null) pw.close();
}
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.*;
import java.io.*;
public class uo{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int testcases = Integer.parseInt(st.nextToken());
for(int lmn=0;lmn<testcases;lmn++){
st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
// int k = Integer.parseInt(st.nextToken());
// st = new StringTokenizer(br.readLine());
ArrayList<Integer> a = new ArrayList<>();
for(int lmn1 = 0;lmn1<n;lmn1++){
st = new StringTokenizer(br.readLine());
int a1 = Integer.parseInt(st.nextToken());
if(a.size()>0 && (a1==1)){
// a.add(a1);
}
else if(a.size()>0){
if(a.size()==1){
a.remove(0);
}
else{
int i = a.size()-1;
while(a.size()>0 && i>=0 && a.get(i)+1 != a1){
a.remove(i);
i--;
}
a.remove(a.size()-1);
// System.out.println(a+" "+i);
}
}
// while(a.size()>0 && a.get(a.size()-1)+1<a1){
// a.remove(a.size()-1);
// }
if(a.size()==0){
a.add(a1);
}
else{
a.add(a1);
}
if(a.size()==1){
System.out.println(a.get(0));
}
else{
for(int i=0;i<a.size()-1;i++){
System.out.print(a.get(i)+".");
}
System.out.println(a.get(a.size()-1));
}
}
}
}
} | cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.*;
import java.util.Scanner;
public class Def {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while (t-->0) {
int n = s.nextInt();
int[] arr = new int[n];
for (int i=0; i<n; i++) {
arr[i] = s.nextInt();
}
// int deep = 0;
// System.out.println(n+" n");
List<Integer> al = new ArrayList<>();
al.add(1);
System.out.println(1);
for(int i=1; i<n;i++) {
int len = al.size();
// for (int d =0; d<len; d++) {
// System.out.print(al.get(d)+" ");
// }
// System.out.println();
if (arr[i] == 1) {
for(int j=0; j<len; j++) {
System.out.print(al.get(j)+".");
}
System.out.println(1);
al.add(1);
}else if (arr[i] == arr[i-1] && arr[i]==1) {
for(int j=0; j<len; j++) {
System.out.print(al.get(j)+".");
}
System.out.println(1);
al.add(1);
}else {
for (int j=len-1; j>-1; j--) {
if (al.get(j)+1 == arr[i]) {
for(int k=0; k<j; k++) {
System.out.print(al.get(k)+".");
}
System.out.println(arr[i]);
al.set(j, al.get(j)+1);
al.subList(j+1, len).clear();
break;
}
}
}
}
}
s.close();
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.*;
import java.io.*;
public class Solution
{
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[] nextArr(int n)
{
int a[]=new int[n];
for (int i=0;i<n;i++)a[i]=nextInt();
return a;
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static class Ele implements Comparable<Ele>
{
public int x,y;
Ele(int x1,int y1)
{
x=x1;y=y1;
}
public int compareTo(Ele ob) {
if(ob.x!=x)return x-ob.x;
return this.y-ob.y;
}
public String toString()
{
return "["+x+","+y+"]";
}
}
void disp(PrintWriter o,boolean b)
{
if (b) o.println("Yes");
else o.println("No");
}
void disp(PrintWriter o,int ...a)
{
o.println(Arrays.toString(a));
}
void disp(PrintWriter o,long ...a)
{
o.println(Arrays.toString(a));
}
void func(PrintWriter o,ArrayList<Integer> a)
{
for (int i=0;i<a.size();i++)
{
if (i!=a.size()-1)
o.print(a.get(i)+".");
else o.println(a.get(i));
}
}
int dp[][];
public static void main(String[] args) throws IOException
{
Reader sc=new Reader();Solution G=new Solution();//MyMath mm=new MyMath();
PrintWriter o = new PrintWriter(System.out);
int t=1;t=sc.nextInt();
int mod=(int)1e9+7;
int x,x0,x1,x2;int y,y0,y1,y2;int s,s0,s1,s2;
int n,m;int a[],b[],in[],in1[];
long k,l;boolean v[],b1,b2;String ss;char c1[];
//long l;long a[];
ArrayList<ArrayList<Integer>> ll=new ArrayList<>();
ArrayList<Integer> a1=new ArrayList<>();
ArrayList<Integer> a2=new ArrayList<>();
PriorityQueue<Integer> pq1=new PriorityQueue<>();
PriorityQueue<Integer> pq2=new PriorityQueue<>(Collections.reverseOrder());
ArrayDeque<Integer> dq=new ArrayDeque<>();
TreeSet<Integer> h0=new TreeSet<>();
TreeSet<Integer> h1=new TreeSet<>();
TreeMap<Integer,Integer> h=new TreeMap<>();
try{
while (t-->0)
{
n=sc.nextInt();a=sc.nextArr(n);b=new int[(int)1e4];
a1.add(a[0]);b[1]=a[0];
for (int i=1;i<n;i++)
{
G.func(o,a1);
x=a1.get(a1.size()-1);
if (a[i]==1)
{
a1.add(a[i]);
b[a1.size()]=a[i];
}
else if (a[i]==x+1)
{
a1.remove(a1.size()-1);
a1.add(a[i]);
b[a1.size()]=a[i];
}
else
{
while (a1.get(a1.size()-1)!=a[i]-1)
a1.remove(a1.size()-1);
a1.remove(a1.size()-1);
a1.add(a[i]);
}
}
G.func(o,a1);
//o.println();
//o.println(n);
//o.println();
//o.println();
//o.println(h);
//o.println(x2);
//o.println();
h0.clear();ll.clear();a1.clear();a2.clear();h1.clear();h.clear();pq1.clear();pq2.clear();
}
}
catch (Throwable e)
{
e.printStackTrace();
}
//o.println("HI");
o.flush();
o.close();
}
} | cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.*;
import java.io.*;
public class Main{
public static void pri(ArrayList<Integer> list)
{
int len=list.size();
for(int i=0;i<len-1;++i)
System.out.print(list.get(i)+".");
System.out.println(list.get(len-1));
}
public static void main(String[] args) throws java.io.IOException {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
int[] arr=new int[n];
for(int i=0;i<n;++i)
{
arr[i]=sc.nextInt();
}
ArrayList<Integer> cur=new ArrayList<>();
cur.add(1);
System.out.println(1);
for(int i=1;i<n;++i)
{
if(arr[i]==1)
{
cur.add(1);
pri(cur);
continue;
}
int len=cur.size();
while(cur.get(len-1)!=arr[i]-1)
{
cur.remove(len-1);
len--;
}
cur.set(len-1,arr[i]);
pri(cur);
continue;
}
}
}
}
// 1 0 1 1 0 0 1 | cubic | 1523_C. Compression and Expansion | CODEFORCES |
/* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
/*static long power(long a,long b,long m)
{
if(b==0)
return 1;
if((b&1)==0)
return power((a*a)%m,b/2,m);
else
return (a*power((a*a)%m,b/2,m))%m;
}*/
/*
static int gcd(int a,int b)
{
if(b==0)
return a;
else
return gcd(b,a%b);
}
*/
public static void main (String[] args) throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine());
PrintWriter p=new PrintWriter(System.out);
while(t-->0)
{
//StringTokenizer st=new StringTokenizer(br.readLine());
int n=Integer.parseInt(br.readLine());
String a[]=new String[n];
for(int i=0;i<n;i++)
{
a[i]=br.readLine();
}
String pre="1";
for(int i=1;i<n;i++)
{
if(a[i].equals("1"))
{
a[i]=pre+".1";
pre=a[i];
continue;
}
int li=pre.lastIndexOf('.');
while(li!=-1 && Integer.parseInt(pre.substring(li+1))+1!=Integer.parseInt(a[i]))
{
pre=pre.substring(0,li);
li=pre.lastIndexOf('.');
}
//li=pre.lastIndexOf('.');
if(li!=-1)
a[i]=pre.substring(0,li+1)+a[i];
pre=a[i];
}
for(int i=0;i<n;i++)
{
p.println(a[i]);
}
p.flush();
}
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.util.*;
import java.io.*;
public class _1523_C {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int t = Integer.parseInt(in.readLine());
while(t-- > 0) {
int n = Integer.parseInt(in.readLine());
int[] a = new int[n];
for(int i = 0; i < n; i++) {
a[i] = Integer.parseInt(in.readLine());
}
boolean[][] used = new boolean[n][n + 1];
boolean[] used2 = new boolean[n];
String[][] res = new String[n][2];
res[0][0] = "1";
res[0][1] = "";
for(int i = 1; i < n; i++) {
if(a[i] == 1) {
for(int j = i - 1; j >= 0; j--) {
if(!used[j][a[i]] && !used2[j]) {
res[i][0] = res[j][0] + ".1";
res[i][1] = res[j][0];
used[j][a[i]] = true;
break;
}
}
}else {
for(int j = i - 1; j >= 0; j--) {
if(!used[j][a[i]] && !used2[j] && a[j] == a[i] - 1) {
if(res[j][1].equals("")) {
res[i][0] = "" + a[i];
}else {
res[i][0] = res[j][1] + "." + a[i];
}
res[i][1] = res[j][1];
used[j][a[i]] = true;
break;
}
used2[j] = true;
}
}
}
for(int i = 0; i < n; i++) {
out.println(res[i][0]);
}
}
in.close();
out.close();
}
}
| cubic | 1523_C. Compression and Expansion | CODEFORCES |
import java.io.*;
import java.util.*;
public class TestClass {
public static class FastWriter {
private static final int BUF_SIZE = 1 << 13;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastWriter() {
out = null;
}
public FastWriter(OutputStream os) {
this.out = os;
}
public FastWriter(String path) {
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastWriter write(byte b) {
buf[ptr++] = b;
if (ptr == BUF_SIZE) innerflush();
return this;
}
public FastWriter write(char c) {
return write((byte) c);
}
public FastWriter write(char[] s) {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
return this;
}
public FastWriter write(String s) {
s.chars().forEach(c -> {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
});
return this;
}
private static int countDigits(int l) {
if (l >= 1000000000) return 10;
if (l >= 100000000) return 9;
if (l >= 10000000) return 8;
if (l >= 1000000) return 7;
if (l >= 100000) return 6;
if (l >= 10000) return 5;
if (l >= 1000) return 4;
if (l >= 100) return 3;
if (l >= 10) return 2;
return 1;
}
public FastWriter write(int x) {
if (x == Integer.MIN_VALUE) {
return write((long) x);
}
if (ptr + 12 >= BUF_SIZE) innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
private static int countDigits(long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
public FastWriter write(long x) {
if (x == Long.MIN_VALUE) {
return write("" + x);
}
if (ptr + 21 >= BUF_SIZE) innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
public FastWriter write(double x, int precision) {
if (x < 0) {
write('-');
x = -x;
}
x += Math.pow(10, -precision) / 2;
// if(x < 0){ x = 0; }
write((long) x).write(".");
x -= (long) x;
for (int i = 0; i < precision; i++) {
x *= 10;
write((char) ('0' + (int) x));
x -= (int) x;
}
return this;
}
public FastWriter writeln(char c) {
return write(c).writeln();
}
public FastWriter writeln(int x) {
return write(x).writeln();
}
public FastWriter writeln(long x) {
return write(x).writeln();
}
public FastWriter writeln(double x, int precision) {
return write(x, precision).writeln();
}
public FastWriter write(int... xs) {
boolean first = true;
for (int x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter write(long... xs) {
boolean first = true;
for (long x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter writeln() {
return write((byte) '\n');
}
public FastWriter writeln(int... xs) {
return write(xs).writeln();
}
public FastWriter writeln(long... xs) {
return write(xs).writeln();
}
public FastWriter writeln(char[] line) {
return write(line).writeln();
}
public FastWriter writeln(char[]... map) {
for (char[] line : map) write(line).writeln();
return this;
}
public FastWriter writeln(String s) {
return write(s).writeln();
}
private void innerflush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (IOException e) {
throw new RuntimeException("innerflush");
}
}
public void flush() {
innerflush();
try {
out.flush();
} catch (IOException e) {
throw new RuntimeException("flush");
}
}
public FastWriter print(byte b) {
return write(b);
}
public FastWriter print(char c) {
return write(c);
}
public FastWriter print(char[] s) {
return write(s);
}
public FastWriter print(String s) {
return write(s);
}
public FastWriter print(int x) {
return write(x);
}
public FastWriter print(long x) {
return write(x);
}
public FastWriter print(double x, int precision) {
return write(x, precision);
}
public FastWriter println(char c) {
return writeln(c);
}
public FastWriter println(int x) {
return writeln(x);
}
public FastWriter println(long x) {
return writeln(x);
}
public FastWriter println(double x, int precision) {
return writeln(x, precision);
}
public FastWriter print(int... xs) {
return write(xs);
}
public FastWriter print(long... xs) {
return write(xs);
}
public FastWriter println(int... xs) {
return writeln(xs);
}
public FastWriter println(long... xs) {
return writeln(xs);
}
public FastWriter println(char[] line) {
return writeln(line);
}
public FastWriter println(char[]... map) {
return writeln(map);
}
public FastWriter println(String s) {
return writeln(s);
}
public FastWriter println() {
return writeln();
}
}
static final class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
private int read() throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read(buf);
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public final int readInt() throws IOException {
return (int) readLong();
}
public final long readLong() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
if (c == -1) throw new IOException();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return negative ? -res : res;
}
public final int[] readIntArray(int size) throws IOException {
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = readInt();
}
return array;
}
public final long[] readLongArray(int size) throws IOException {
long[] array = new long[size];
for (int i = 0; i < size; i++) {
array[i] = readLong();
}
return array;
}
public final String readString() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.append((char) c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
static long mulmod(long a, long b,
long mod) {
long res = 0; // Initialize result
a = a % mod;
while (b > 0) {
// If b is odd, add 'a' to result
if (b % 2 == 1) {
res = (res + a) % mod;
}
// Multiply 'a' with 2
a = (a * 2) % mod;
// Divide b by 2
b /= 2;
}
// Return result
return res % mod;
}
static long pow(long a, long b, long MOD) {
long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD) x %= MOD;
}
y = (y * y);
if (y > MOD) y %= MOD;
b /= 2;
}
return x;
}
static long[] f = new long[200001];
static long InverseEuler(long n, long MOD) {
return pow(n, MOD - 2, MOD);
}
static long C(int n, int r, long MOD) {
return (f[n] * ((InverseEuler(f[r], MOD) * InverseEuler(f[n - r], MOD)) % MOD)) % MOD;
}
static int[] h = {0, 0, -1, 1};
static int[] v = {1, -1, 0, 0};
public static class Pair {
public int a;
public int b;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair pair = (Pair) o;
return a == pair.a &&
b == pair.b;
}
@Override
public int hashCode() {
return Objects.hash(a, b);
}
public Pair(int a, int b) {
this.a = a;
this.b = b;
}
}
static class Pair2 {
public long cost;
int node;
public Pair2(long cos, int node) {
this.cost = cos;
this.node = node;
}
}
static long compute_hash(String s) {
int p = 31;
int m = 1000000007;
long hash_value = 0;
long p_pow = 1;
for (int i = 0; i < s.length(); ++i) {
char c = s.charAt(i);
hash_value = (hash_value + (c - 'a' + 1) * p_pow) % m;
p_pow = (p_pow * p) % m;
}
return hash_value;
}
public static class SegmentTree {
long[][] tree;
int n;
public SegmentTree(int[] nodes) {
tree = new long[nodes.length * 4][2];
n = nodes.length;
build(0, n - 1, 0, nodes);
}
private void build(int l, int r, int pos, int[] nodes) {
if (l == r) {
tree[pos][0] = nodes[l];
tree[pos][1] = l;
return;
}
int mid = (l + r) / 2;
build(l, mid, 2 * pos + 1, nodes);
build(mid + 1, r, 2 * pos + 2, nodes);
if (tree[2 * pos + 1][0] > tree[2 * pos + 2][0]) {
tree[pos][1] = tree[2 * pos + 1][1];
} else {
tree[pos][1] = tree[2 * pos + 2][1];
}
tree[pos][0] = Math.max(tree[2 * pos + 1][0], tree[2 * pos + 2][0]);
}
// public void update(int pos, int val) {
// updateUtil(0, n - 1, 0, pos, val);
// }
public long[] get(int l, int r) {
return getUtil(0, n - 1, 0, l, r);
}
private long[] getUtil(int l, int r, int pos, int ql, int qr) {
if (ql > r || qr < l) {
return new long[]{-1, -1};
}
if (l >= ql && r <= qr) {
return tree[pos];
}
int mid = (l + r) / 2;
long[] left = getUtil(l, mid, 2 * pos + 1, ql, qr);
long[] right = getUtil(mid + 1, r, 2 * pos + 2, ql, qr);
long choice = right[1];
if (left[0] > right[0]) choice = left[1];
return new long[]{Math.max(left[0], right[0]), choice};
}
// private void updateUtil(int l, int r, int pos, int i, int val) {
// if (i < l || i > r) {
// return;
// }
// if (l == r) {
// tree[pos] = val;
// return;
// }
// int mid = (l + r) / 2;
// updateUtil(l, mid, 2 * pos + 1, i, val);
// updateUtil(mid + 1, r, 2 * pos + 2, i, val);
// tree[pos] = tree[2 * pos + 1] + tree[2 * pos + 2];
// }
}
static int counter = 0;
static int[] rIn;
static int[] rOut;
static int[] lIn;
static int[] lOut;
private static int[] flatten;
private static int[] lFlatten;
static long answer = 0;
static int VISITED = 1;
static int VISITING = 2;
static int[] DIRX = new int[]{0, 0, 1, -1};
static int[] DIRY = new int[]{1, -1, 0, 0};
public static class Pair22 {
int num, pos;
public Pair22(int x, int y) {
this.num = x;
this.pos = y;
}
}
public static long sumofdig(long n) {
long sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
public static void main(String[] args) throws Exception {
//https://i...content-available-to-author-only...e.com/ebRGa6
InputReader in = new InputReader(System.in);
FastWriter out = new FastWriter(System.out);
//
// f[0] = 1;
// f[1] = 1;
// for (int i = 2; i < 200001; ++i) {
// f[i] = f[i-1] * i;
// f[i] %= 1000000007;
// }
int t = in.readInt();
while (t-- > 0) {
int n = in.readInt();
Stack<Integer> s = new Stack<>();
System.out.println("1");
int i1 = in.readInt();
assert i1 == 1;
s.add(1);
for (int i = 1; i < n; ++i) {
int next = in.readInt();
if (next == 1) {
} else {
while ((s.peek() + 1) != next) {
s.pop();
}
s.pop();
}
s.add(next);
StringBuilder ans = new StringBuilder();
for (int c: s) {
ans.append(c).append(".");
}
out.println(ans.substring(0, ans.length() - 1));
out.flush();
}
}
}
private static void solvedd(int[] arr, int left, int right, int[] ans, int depth) {
if (left > right) return;
int maxInd = left;
for (int i = left; i <= right; ++i) {
if (arr[i] > arr[maxInd]) {
maxInd = i;
}
}
ans[maxInd] = depth;
solvedd(arr, left, maxInd - 1, ans, depth + 1);
solvedd(arr, maxInd + 1, right, ans, depth + 1);
}
private static void solved(List<List<Integer>> g, int node, int[][] dp, int last, int[] a) {
int donttake = 0;
int take = 0;
for (int i = 0; i < g.get(node).size(); ++i) {
int ntb = g.get(node).get(i);
if (ntb != last) {
solved(g, ntb, dp, node, a);
donttake += Math.max(dp[ntb][0], dp[ntb][1]);
take += dp[ntb][1];
}
}
dp[node][0] = a[node] + take;
dp[node][1] = donttake;
}
private static boolean solve(int n, List<Integer> nums, int cur, int pos, Boolean[][] dp) {
if (cur > n) return false;
if (cur == n) return true;
if (pos >= nums.size()) return false;
if (dp[cur][pos] != null) {
return dp[cur][pos];
}
boolean without = solve(n, nums, cur, pos + 1, dp);
boolean with = false;
int ogcur = cur;
for (int i = 1; i < 12; ++i) {
with |= solve(n, nums, cur + nums.get(pos), pos + 1, dp);
cur += nums.get(pos);
}
return dp[ogcur][pos] = with | without;
}
// private static Pair22 dfss(List<LinkedHashSet<Integer>> g, int node, HashSet<Integer> vis, int[] dis, int[] dis2) {
// if (vis.contains(node)) return new Pair22(dis[node], dis2[node], -1);
// vis.add(node);
// int min = dis[node];
// for (Integer ntb : g.get(node)) {
// if (dis[ntb] > dis[node])
// dfss(g, ntb, vis, dis, dis2);
// if (dis[ntb] <= dis[node]) {
// min = Math.min(min, dis[ntb]);
// } else {
// min = Math.min(min, dis2[ntb]);
// }
// }
// // if (dis)
// dis2[node] = min;
// return new Pair22(dis[node], min, -1);
// }
private static int dfs(HashMap<Pair, TreeSet<Pair>> grid, int x, int y, int ti, HashSet<Pair> vis, int r, int startX, int startY) {
// System.out.println(x + " " + y);
int taken = ti - Math.abs(startX - x) - Math.abs(startY - y);
if (taken < 0) return 0;
if (x < 0 || y < 0 || x > r || y > r) return 0;
if (vis.contains(new Pair(x, y))) return 0;
int max = 0;
if (grid.containsKey(new Pair(x, y))) {
TreeSet<Pair> times = grid.get(new Pair(x, y));
for (Pair t : times) {
if (t.a <= taken) {
max = Math.max(t.b, max);
} else break;
}
}
vis.add(new Pair(x, y));
max = Math.max(dfs(grid, x + 1, y, ti, vis, r, startX, startY), max);
max = Math.max(dfs(grid, x, y + 1, ti, vis, r, startX, startY), max);
max = Math.max(dfs(grid, x - 1, y, ti, vis, r, startX, startY), max);
max = Math.max(dfs(grid, x, y - 1, ti, vis, r, startX, startY), max);
return max;
}
private static int solver(int[] nums, int pos, int[] dp) {
if (pos >= nums.length) return 0;
if (dp[pos] != Integer.MAX_VALUE) return dp[pos];
int min = solver(nums, pos + 2, dp) + nums[pos];
min = Math.min(solver(nums, pos + 3, dp) + nums[pos], min);
if (pos + 1 < nums.length) min = Math.min(min, nums[pos] + nums[pos + 1] + solver(nums, pos + 3, dp));
if (pos + 1 < nums.length) min = Math.min(min, nums[pos] + nums[pos + 1] + solver(nums, pos + 4, dp));
// System.out.println(pos + " " + min);
return dp[pos] = min;
}
static int countFreq(String pattern, String text) {
int m = pattern.length();
int n = text.length();
int res = 0;
for (int i = 0; i <= n - m; i++) {
int j;
for (j = 0; j < m; j++) {
if (text.charAt(i + j) != pattern.charAt(j)) {
break;
}
}
if (j == m) {
res++;
j = 0;
}
}
return res;
}
private static void dfsR(List<List<Integer>> g, int node, int[] v) {
rIn[node] = counter;
flatten[counter++] = v[node];
for (int i = 0; i < g.get(node).size(); ++i) {
dfsR(g, g.get(node).get(i), v);
}
rOut[node] = counter;
flatten[counter++] = v[node] * -1;
}
private static void dfsL(List<List<Integer>> g, int node, int[] v) {
lIn[node] = counter;
lFlatten[counter++] = v[node];
for (int i = 0; i < g.get(node).size(); ++i) {
dfsL(g, g.get(node).get(i), v);
}
lOut[node] = counter;
lFlatten[counter++] = v[node] * -1;
TreeMap<String, Integer> map = new TreeMap<>();
}
private static void preprocess(int pos, int[][] pre, List<List<Integer>> tree, int[] traverse, int depth, int last, int[] tin, int[] tout) {
tin[pos] = counter++;
traverse[depth] = pos;
for (int i = 0; depth - (1 << i) >= 0; ++i) {
pre[pos][i] = traverse[depth - (1 << i)];
}
for (int i = 0; i < tree.get(pos).size(); ++i) {
if (tree.get(pos).get(i) != last)
preprocess(tree.get(pos).get(i), pre, tree, traverse, depth + 1, pos, tin, tout);
}
tout[pos] = counter++;
}
static long gcd(long a, long b) {
while (b != 0) {
long t = a;
a = b;
b = t % b;
}
return a;
}
static boolean submit = true;
static void debug(String s) {
if (!submit)
System.out.println(s);
}
static void debug(int s) {
LinkedHashSet<Integer> exist = new LinkedHashSet<>();
/*
4 2 3 _ 2 4 3 _
*/
}
/**
0 1 2 3 4 5 6 7 8 9 10
1 1 1
* Your ExamRoom object will be instantiated and called as such:
* ExamRoom obj = new ExamRoom(N);
* int param_1 = obj.seat();
* obj.leave(p);
*/
} | cubic | 1523_C. Compression and Expansion | CODEFORCES |
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;
public class x1242C2
{
public static void main(String hi[]) throws Exception
{
BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(infile.readLine());
int N = Integer.parseInt(st.nextToken());
long[] sums = new long[N];
ArrayList<Integer>[] boxes = new ArrayList[N];
for(int i=0; i < N; i++)
{
boxes[i] = new ArrayList<Integer>();
st = new StringTokenizer(infile.readLine());
int a = Integer.parseInt(st.nextToken());
while(a-->0)
boxes[i].add(Integer.parseInt(st.nextToken()));
for(int x: boxes[i])
sums[i] += x;
}
long lmaosum = 0L;
for(long x: sums)
lmaosum += x;
if(Math.abs(lmaosum)%N != 0)
{
System.out.println("No");
return;
}
long target = lmaosum/N;
//fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck
HashMap<Long, Integer> map = new HashMap<Long, Integer>();
for(int k=0; k < N; k++)
for(int x: boxes[k])
map.put((long)x, k);
HashMap<Long, Long> edges = new HashMap<Long, Long>();
for(int k=0; k < N; k++)
for(int x: boxes[k])
{
long nextval = target-sums[k]+x;
if(map.containsKey(nextval))
edges.put((long)x, nextval);
}
Node[] dp = new Node[1<<N];
dp[0] = new Node(-69, -69, 0);
//precompute subsets ass
Node[] subsets = new Node[1<<N];
for(int b=0; b < N; b++)
for(int i=0; i < boxes[b].size(); i++)
{
if(!edges.containsKey((long)boxes[b].get(i)))
continue;
long curr = edges.get((long)boxes[b].get(i));
//shit shit shit shit shit shit shit shit shit shit
int submask = 0; boolean cyclic = true;
while(curr != boxes[b].get(i))
{
int k = map.get(curr);
if((submask&(1<<k)) > 0 || !edges.containsKey((long)curr))
{
cyclic = false;
break;
}
submask |= 1<<k;
curr = edges.get((long)curr);
}
submask |= (1<<b);
if(cyclic)
subsets[submask] = new Node(-69, i, b);
}
for(int mask=1; mask < (1<<N); mask++)
outer:for(int submask=mask; submask > 0; submask=(submask-1)&mask)
if(dp[mask^submask] != null && subsets[submask] != null)
{
dp[mask] = new Node(mask^submask, subsets[submask].dex, subsets[submask].start);
break outer;
}
if(dp[(1<<N)-1] == null)
System.out.println("No");
else
{
StringBuilder sb = new StringBuilder("Yes\n");
long[][] res = new long[N][2];
for(int i=0; i < N; i++)
res[i][1] = -1L;
int currmask = (1<<N)-1;
while(currmask != 0)
{
int submask = dp[currmask].mask;
int i = dp[currmask].dex;
int b = dp[currmask].start;
long nextval = target-sums[b]+boxes[b].get(i);
int curr = map.get(nextval);
res[map.get(nextval)][0] = nextval;
res[map.get(nextval)][1] = b;
while(true) //lol
{
int lol = map.get(nextval);
nextval = edges.get(nextval);
res[map.get(nextval)][0] = nextval;
if(res[map.get(nextval)][1] != -1)
break;
res[map.get(nextval)][1] = lol;
}
currmask = dp[currmask].mask;
}
for(int k=0; k < N; k++)
sb.append(res[k][0]+" ").append(res[k][1]+1).append("\n");
System.out.print(sb);
}
}
}
class Node
{
public int mask;
public int dex;
public int start;
public Node(int a, int b, int c)
{
mask = a;
dex = b;
start = c;
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Random;
import java.util.TreeSet;
public final class CF_599_D1_C
{
static boolean verb=true;
static void log(Object X){if (verb) System.err.println(X);}
static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+" ");System.err.println("");}}
static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+" ");System.err.println("");}}
static void logWln(Object X){if (verb) System.err.print(X);}
static void info(Object o){ System.out.println(o);}
static void output(Object o){outputWln(""+o+"\n"); }
static void outputWln(Object o){try {out.write(""+ o);} catch (Exception e) {}}
static long mod=1000000007;
// Global vars
static BufferedWriter out;
static InputReader reader;
static class Composite implements Comparable<Composite>{
int idx;
int v;
public int compareTo(Composite X) {
if (v!=X.v)
return v-X.v;
return idx-X.idx;
}
public Composite(int idx, int v) {
this.idx = idx;
this.v = v;
}
}
static void test() {
log("testing");
log("done");
}
static void explore(ArrayList<Integer>[] components,ArrayList<Integer> bob,int[][] move,ArrayList<int[]>[] howto,int[][] list) {
for (int x:bob) {
if (components[x].size()==1) {
int tm[]=howto[x].get(0);
int L=howto[x].size();
howto[x].add(tm);
for (int i=0;i<L;i++) {
int[] cur=howto[x].get(i);
int[] nx=howto[x].get(i+1);
int a=cur[0];
int a2=nx[0];
int b2=nx[1];
move[a2][0]=list[a2][b2];
move[a2][1]=a;
}
} else {
explore(components,components[x],move,howto,list);
}
}
}
static void process() throws Exception {
//arrayTest();
out = new BufferedWriter(new OutputStreamWriter(System.out));
reader = new InputReader(System.in);
int k=reader.readInt();
int[][] list=new int[k][];
long[] sum=new long[k];
int[] L=new int[k];
HashMap<Integer,int[]> target=new HashMap<Integer,int[]>();
long tot=0;
for (int i=0;i<k;i++) {
L[i]=reader.readInt();
list[i]=new int[L[i]];
for (int j=0;j<L[i];j++) {
list[i][j]=reader.readInt();
sum[i]+=list[i][j];
target.put(list[i][j],new int[] {i,j});
}
tot+=sum[i];
}
int MX=1<<k;
int AX=1000000001;
ArrayList<int[]>[] howto=new ArrayList[MX];
log("ok with the data");
if (tot%k!=0) {
output("No");
} else {
tot/=k;
for (int i=0;i<k;i++) {
if (sum[i]==tot) {
//log("nothing to do for i:"+i);
// nothing to do
int mask=1<<i;
ArrayList<int[]> cand=new ArrayList<int[]>();
cand.add(new int[] {i,0});
howto[mask]=cand;
} else
for (int j=0;j<L[i];j++) {
int u=i;
int v=j;
boolean ok=true;
int src_u=u;
int src_v=v;
int mask=0;
boolean goon=true;
ArrayList<int[]> cand=new ArrayList<int[]>();
//log("start loop");
while (goon) {
cand.add(new int[] {u,v});
//log("u:"+u+" v:"+v);
ok=false;
goon=false;
long need=tot-((long)sum[u]-(long)list[u][v]);
if (Math.abs(need)<=AX) {
//log("need:"+need);
int nd=(int)need;
int[] tm=target.get(nd);
//log("tm:"+tm);
if (tm!=null) {
//log("can find successor");
int nxu=tm[0];
int nxv=tm[1];
if ((mask&(1<<nxu))==0) {
mask|=1<<nxu;
if (nxu==src_u) {
// looping back to source
if (nxv==src_v)
ok=true;
} else {
u=nxu;
v=nxv;
ok=true;
goon=true;
}
}
}
}
}
if (ok) {
if (howto[mask]==null) {
howto[mask]=cand;
}
}
}
}
log("step 1 done");
// now mask
ArrayList[] components=new ArrayList[MX];
for (int m=0;m<MX;m++) {
if (howto[m]!=null) {
//String s=Integer.toBinaryString(m);
//while (s.length()<k)
// s="0"+s;
//log("found mask:"+s);
components[m]=new ArrayList<Integer>();
components[m].add(m);
}
}
int[] msk=new int[MX];
int w=0;
for (int a=0;a<MX;a++) {
if (howto[a]!=null) {
ArrayList<Integer> add=new ArrayList<Integer>();
int ww=w;
for (int i=0;i<ww;i++) {
int b=msk[i];
if ((b&a)==0) {
int c=b|a;
log("creating c:"+c+" ");
if (components[c]==null ) {
components[c]=new ArrayList<Integer>();
components[c].add(a);
components[c].add(b);
msk[w++]=c;
}
}
}
msk[w++]=a;
}
}
//log("msk:"+msk);
//log(components[MX-1]);
if (components[MX-1]!=null) {
output("Yes");
int[][] move=new int[k][2];
explore(components,components[MX-1],move,howto,list);
for (int i=0;i<k;i++) {
output(move[i][0]+" "+(move[i][1]+1));
}
} else {
output("No");
}
}
try {
out.close();
} catch (Exception e) {
}
}
public static void main(String[] args) throws Exception {
process();
}
static final class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
private int read() throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read(buf);
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public final String readString() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.append((char) c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public final int readInt() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
int res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
public final long readLong() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
} | np | 1242_C. Sum Balance | CODEFORCES |
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;
public class x1242C2
{
public static void main(String hi[]) throws Exception
{
BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(infile.readLine());
int N = Integer.parseInt(st.nextToken());
long[] sums = new long[N];
ArrayList<Integer>[] boxes = new ArrayList[N];
for(int i=0; i < N; i++)
{
boxes[i] = new ArrayList<Integer>();
st = new StringTokenizer(infile.readLine());
int a = Integer.parseInt(st.nextToken());
while(a-->0)
boxes[i].add(Integer.parseInt(st.nextToken()));
for(int x: boxes[i])
sums[i] += x;
}
long lmaosum = 0L;
for(long x: sums)
lmaosum += x;
if(Math.abs(lmaosum)%N != 0)
{
System.out.println("No");
return;
}
long target = lmaosum/N;
//fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck fuck
HashMap<Long, Integer> map = new HashMap<Long, Integer>();
for(int k=0; k < N; k++)
for(int x: boxes[k])
map.put((long)x, k);
HashMap<Long, Long> edges = new HashMap<Long, Long>();
for(int k=0; k < N; k++)
for(int x: boxes[k])
{
long nextval = target-sums[k]+x;
if(map.containsKey(nextval))
edges.put((long)x, nextval);
}
Node[] dp = new Node[1<<N];
dp[0] = new Node(-69, -69, 0);
//precompute subsets ass
Node[] subsets = new Node[1<<N];
for(int b=0; b < N; b++)
for(int i=0; i < boxes[b].size(); i++)
{
if(!edges.containsKey((long)boxes[b].get(i)))
continue;
long curr = edges.get((long)boxes[b].get(i));
//shit shit shit shit shit shit shit shit shit shit
int submask = 0; boolean cyclic = true;
while(curr != boxes[b].get(i))
{
int k = map.get(curr);
if((submask&(1<<k)) > 0 || !edges.containsKey((long)curr))
{
cyclic = false;
break;
}
submask |= 1<<k;
curr = edges.get((long)curr);
}
submask |= (1<<b);
if(cyclic)
subsets[submask] = new Node(-69, i, b);
}
for(int mask=1; mask < (1<<N); mask++)
outer:for(int submask=mask; submask > 0; submask=(submask-1)&mask)
if(dp[mask^submask] != null && subsets[submask] != null)
{
dp[mask] = new Node(mask^submask, subsets[submask].dex, subsets[submask].start);
break outer;
}
if(dp[(1<<N)-1] == null)
System.out.println("No");
else
{
StringBuilder sb = new StringBuilder("Yes\n");
long[][] res = new long[N][2];
for(int i=0; i < N; i++)
res[i][1] = -1L;
int currmask = (1<<N)-1;
while(currmask != 0)
{
int submask = dp[currmask].mask;
int i = dp[currmask].dex;
int b = dp[currmask].start;
long nextval = target-sums[b]+boxes[b].get(i);
int curr = map.get(nextval);
res[map.get(nextval)][0] = nextval;
res[map.get(nextval)][1] = b;
while(true)
{
int lol = map.get(nextval);
nextval = edges.get(nextval);
res[map.get(nextval)][0] = nextval;
if(res[map.get(nextval)][1] != -1)
break;
res[map.get(nextval)][1] = lol;
}
currmask = dp[currmask].mask;
}
for(int k=0; k < N; k++)
sb.append(res[k][0]+" ").append(res[k][1]+1).append("\n");
System.out.print(sb);
}
}
}
class Node
{
public int mask;
public int dex;
public int start;
public Node(int a, int b, int c)
{
mask = a;
dex = b;
start = c;
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.StringTokenizer;
public class C {
public static void main(String[] args) {
FastScanner fs=new FastScanner();
int nBoxes=fs.nextInt();
long[] sums=new long[nBoxes];
HashMap<Long, Integer> boxOf=new HashMap<>();
int[][] boxes=new int[nBoxes][];
long total=0;
for (int i=0; i<nBoxes; i++) {
int size=fs.nextInt();
boxes[i]=new int[size];
for (int j=0; j<size; j++) {
boxes[i][j]=fs.nextInt();
boxOf.put((long)boxes[i][j], i);
sums[i]+=boxes[i][j];
}
total+=sums[i];
}
if (total%nBoxes!=0) {
System.out.println("No");
return;
}
long target=total/nBoxes;
int[][] masks=new int[nBoxes][];
ArrayList<Integer>[][] maskLoops=new ArrayList[nBoxes][];
for (int i=0; i<nBoxes; i++) {
masks[i]=new int[boxes[i].length];
maskLoops[i]=new ArrayList[boxes[i].length];
for (int j=0; j<maskLoops[i].length; j++) maskLoops[i][j]=new ArrayList<>();
inner:for (int j=0; j<boxes[i].length; j++) {
long startVal=boxes[i][j], lookingFor=target-(sums[i]-startVal);
maskLoops[i][j].add((int)lookingFor);
int mask=1<<i;
while (lookingFor!=startVal) {
if (!boxOf.containsKey(lookingFor)) continue inner;
int nextBox=boxOf.get(lookingFor);
//if we have already used this box, it won't work
if ((mask&(1<<nextBox))!=0) continue inner;
mask|=1<<nextBox;
lookingFor=target-(sums[nextBox]-lookingFor);
/*if (lookingFor!=startVal) */maskLoops[i][j].add((int)lookingFor);
}
// System.out.println("Mask loops for box: "+i+" starting at "+startVal+" gives "+);
//otherwise it worked
masks[i][j]=mask;
}
}
boolean[] possible=new boolean[1<<nBoxes];
int[] maskFrom=new int[1<<nBoxes];
int[] indexToUse=new int[1<<nBoxes];
possible[0]=true;
for (int mask=1; mask<1<<nBoxes; mask++) {
int lowestBit=Integer.numberOfTrailingZeros(Integer.lowestOneBit(mask));
/*
for (int i:masks[lowestBit]) {
if ((mask&i)==i && possible[mask^i]) {
possible[mask]=true;
break;
}
}
*/
for (int i=0; i<masks[lowestBit].length; i++) {
int m=masks[lowestBit][i];
if ((mask&m)==m && possible[mask^m]) {
possible[mask]=true;
maskFrom[mask]=mask^m;
indexToUse[mask]=i;
break;
}
}
}
if (!possible[(1<<nBoxes)-1]) {
System.out.println("No");
return;
}
System.out.println("Yes");
ArrayList<ArrayList<Integer>> loops=new ArrayList<>();
int mask=(1<<nBoxes)-1;
while (mask!=0) {
// System.out.println("At mask: "+Integer.toBinaryString(mask));
int lowestBit=Integer.numberOfTrailingZeros(Integer.lowestOneBit(mask));
loops.add(maskLoops[lowestBit][indexToUse[mask]]);
mask=maskFrom[mask];
}
// System.out.println("Loops: "+loops);
int[] takeFrom=new int[nBoxes];
int[] boxGiveTo=new int[nBoxes];
for (ArrayList<Integer> loop:loops) {
for (int i=0; i<loop.size(); i++) {
int cur=loop.get(i), next=loop.get((i+1)%loop.size());
int curBox=boxOf.get((long)cur), nextBox=boxOf.get((long)next);
takeFrom[nextBox]=next;
boxGiveTo[nextBox]=curBox;
}
}
for (int i=0; i<nBoxes; i++) {
System.out.println(takeFrom[i]+" "+(boxGiveTo[i]+1));
}
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
public String next() {
while (!st.hasMoreElements())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Map;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastScanner in = new FastScanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
int n;
int[] bitCount;
long neededSum;
long[] sums;
Map<Long, Integer> where;
public void solve(int testNumber, FastScanner in, PrintWriter out) {
n = in.nextInt();
int[][] a = new int[n][];
neededSum = 0;
sums = new long[n];
for (int i = 0; i < n; i++) {
int k = in.nextInt();
a[i] = new int[k];
for (int j = 0; j < k; j++) {
a[i][j] = in.nextInt();
neededSum += a[i][j];
sums[i] += a[i][j];
}
}
if (neededSum % n != 0) {
out.println("No");
return;
}
neededSum /= n;
where = new HashMap<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].length; j++) {
where.put((long) a[i][j], i);
}
}
bitCount = new int[1 << n];
for (int i = 0; i < bitCount.length; i++) {
bitCount[i] = Integer.bitCount(i);
}
Entry[][] cycleSol = new Entry[1 << n][];
List<Entry> sol = new ArrayList<>();
for (int i = 0; i < n; i++) {
for (int x : a[i]) {
search(i, i, x, x, 0, 0, sol, cycleSol);
}
}
boolean[] can = new boolean[1 << n];
int[] via = new int[1 << n];
can[0] = true;
for (int mask = 0; mask < 1 << n; mask++) {
for (int submask = mask; submask > 0; submask = (submask - 1) & mask) {
if (cycleSol[submask] != null && can[mask ^ submask]) {
can[mask] = true;
via[mask] = submask;
}
}
}
if (!can[(1 << n) - 1]) {
out.println("No");
return;
}
int[][] ans = new int[n][2];
for (int mask = (1 << n) - 1; mask > 0; ) {
int sm = via[mask];
mask ^= sm;
for (Entry e : cycleSol[sm]) {
ans[e.from][0] = e.what;
ans[e.from][1] = e.to + 1;
}
}
out.println("Yes");
for (int i = 0; i < n; i++) {
out.println(ans[i][0] + " " + ans[i][1]);
}
}
private void search(int start, int cur, long fromStart, long fromCur, int hasIn, int hasOut, List<Entry> sol, Entry[][] cycleSol) {
for (int i = start; i < n; i++) {
if ((hasIn & (1 << i)) > 0) {
continue;
}
if ((hasOut & (1 << cur)) > 0) {
continue;
}
long fromI = sums[i] + fromCur - neededSum;
Integer w = where.get(fromI);
if (w == null || w != i) {
continue;
}
sol.add(new Entry(cur, i, (int) fromCur));
int nHasIn = hasIn | (1 << i);
int nHasOut = hasOut | (1 << cur);
if (i == start && fromI == fromStart) {
cycleSol[nHasOut] = sol.toArray(new Entry[0]);
}
search(start, i, fromStart, fromI, nHasIn, nHasOut, sol, cycleSol);
sol.remove(sol.size() - 1);
}
}
class Entry {
int from;
int to;
int what;
Entry(int from, int to, int what) {
this.from = from;
this.to = to;
this.what = what;
}
public String toString() {
return from + " " + to + " " + what;
}
}
}
static class FastScanner {
private BufferedReader in;
private StringTokenizer st;
public FastScanner(InputStream stream) {
in = new BufferedReader(new InputStreamReader(stream));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
String rl = in.readLine();
if (rl == null) {
return null;
}
st = new StringTokenizer(rl);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author beginner1010
*/
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);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
HashMap<Integer, Integer> map = new HashMap<>();
boolean[] dp;
boolean[] vis;
boxPair[] ans;
int two(int bit) {
return 1 << bit;
}
boolean contain(int mask, int bit) {
return ((two(bit) & mask) > 0);
}
int get(long val) {
if (val > Integer.MAX_VALUE || val < Integer.MIN_VALUE) return -1;
int key = (int) val;
if (map.containsKey(key) == false) return -1;
return map.get(key);
}
boolean rec(int mask, boolean[] hasCycle) {
if (hasCycle[mask]) return true;
if (vis[mask] == true) return dp[mask];
vis[mask] = true;
for (int i = mask & (mask - 1); i > 0; i = mask & (i - 1)) {
if (rec(i, hasCycle) && rec(i ^ mask, hasCycle)) {
return dp[mask] = true;
}
}
return dp[mask] = false;
}
void findPath(int mask, boolean[] hasCycle, ArrayList<boxPair>[] maskPath) {
if (hasCycle[mask]) {
for (boxPair b : maskPath[mask]) {
ans[get(b.addTo)] = b;
}
return;
}
for (int i = mask & (mask - 1); i > 0; i = mask & (i - 1)) {
if (rec(i, hasCycle) && rec(i ^ mask, hasCycle)) {
findPath(i, hasCycle, maskPath);
findPath(i ^ mask, hasCycle, maskPath);
return;
}
}
}
public void solve(int testNumber, InputReader in, PrintWriter out) {
int k = in.nextInt();
int[][] a = new int[k][];
int[] n = new int[k];
long[] sum = new long[k];
long S = 0;
for (int i = 0; i < k; i++) {
n[i] = in.nextInt();
a[i] = new int[n[i]];
for (int j = 0; j < n[i]; j++) {
a[i][j] = in.nextInt();
sum[i] += a[i][j];
map.put(a[i][j], i);
}
S += sum[i];
}
if (S % k != 0) out.println("No");
else {
ArrayList<boxPair>[] maskPath = new ArrayList[two(k)];
boolean[] hasCycle = new boolean[two(k)];
for (int i = 0; i < two(k); i++) {
maskPath[i] = new ArrayList<>();
}
long balance = S / k;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n[i]; j++) {
long remove = a[i][j];
int curID = i;
int curMask = 0;
ArrayList<boxPair> curPath = new ArrayList<>();
while (true) {
curMask |= two(curID);
remove = (balance - (sum[curID] - remove));
int nxtID = get(remove);
curPath.add(new boxPair(curID, (int) remove));
if (nxtID == i && remove == a[i][j]) {
if (hasCycle[curMask] == false) {
hasCycle[curMask] = true;
maskPath[curMask] = curPath;
}
break;
}
if (nxtID == -1 || contain(curMask, nxtID)) break;
curID = nxtID;
}
}
}
vis = new boolean[two(k)];
dp = new boolean[two(k)];
if (rec(two(k) - 1, hasCycle) == false) out.println("No");
else {
ans = new boxPair[k];
findPath(two(k) - 1, hasCycle, maskPath);
out.println("Yes");
for (int i = 0; i < k; i++) {
out.println(ans[i].addTo + " " + (ans[i].boxID + 1));
}
}
}
}
class boxPair {
int boxID;
int addTo;
boxPair(int _boxID, int _addTo) {
this.boxID = _boxID;
this.addTo = _addTo;
}
}
}
static class InputReader {
InputStream is;
private byte[] inbuf = new byte[1024];
private int lenbuf = 0;
private int ptrbuf = 0;
static final int[] ints = new int[128];
public InputReader(InputStream is) {
for (int i = '0'; i <= '9'; i++) ints[i] = i - '0';
this.is = is;
}
public int readByte() {
if (lenbuf == -1) throw new InputMismatchException();
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) return -1;
}
return inbuf[ptrbuf++];
}
public int nextInt() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = (num << 3) + (num << 1) + ints[b];
} else {
return minus ? -num : num;
}
b = readByte();
}
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Random;
import java.util.TreeSet;
public final class CF_599_D1_C
{
static boolean verb=true;
static void log(Object X){if (verb) System.err.println(X);}
static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+" ");System.err.println("");}}
static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+" ");System.err.println("");}}
static void logWln(Object X){if (verb) System.err.print(X);}
static void info(Object o){ System.out.println(o);}
static void output(Object o){outputWln(""+o+"\n"); }
static void outputWln(Object o){try {out.write(""+ o);} catch (Exception e) {}}
static long mod=1000000007;
// Global vars
static BufferedWriter out;
static InputReader reader;
static class Composite implements Comparable<Composite>{
int idx;
int v;
public int compareTo(Composite X) {
if (v!=X.v)
return v-X.v;
return idx-X.idx;
}
public Composite(int idx, int v) {
this.idx = idx;
this.v = v;
}
}
static void test() {
log("testing");
log("done");
}
static void explore(ArrayList<Integer>[] components,ArrayList<Integer> bob,int[][] move,ArrayList<int[]>[] howto,int[][] list) {
for (int x:bob) {
if (components[x].size()==1) {
int tm[]=howto[x].get(0);
int L=howto[x].size();
howto[x].add(tm);
for (int i=0;i<L;i++) {
int[] cur=howto[x].get(i);
int[] nx=howto[x].get(i+1);
int a=cur[0];
int a2=nx[0];
int b2=nx[1];
move[a2][0]=list[a2][b2];
move[a2][1]=a;
}
} else {
explore(components,components[x],move,howto,list);
}
}
}
static void process() throws Exception {
//arrayTest();
out = new BufferedWriter(new OutputStreamWriter(System.out));
reader = new InputReader(System.in);
int k=reader.readInt();
int[][] list=new int[k][];
long[] sum=new long[k];
int[] L=new int[k];
HashMap<Integer,int[]> target=new HashMap<Integer,int[]>();
long tot=0;
for (int i=0;i<k;i++) {
L[i]=reader.readInt();
list[i]=new int[L[i]];
for (int j=0;j<L[i];j++) {
list[i][j]=reader.readInt();
sum[i]+=list[i][j];
target.put(list[i][j],new int[] {i,j});
}
tot+=sum[i];
}
int MX=1<<k;
int AX=1000000001;
ArrayList<int[]>[] howto=new ArrayList[MX];
log("ok with the data");
if (tot%k!=0) {
output("No");
} else {
tot/=k;
for (int i=0;i<k;i++) {
if (sum[i]==tot) {
//log("nothing to do for i:"+i);
// nothing to do
int mask=1<<i;
ArrayList<int[]> cand=new ArrayList<int[]>();
cand.add(new int[] {i,0});
howto[mask]=cand;
} else
for (int j=0;j<L[i];j++) {
int u=i;
int v=j;
boolean ok=true;
int src_u=u;
int src_v=v;
int mask=0;
boolean goon=true;
ArrayList<int[]> cand=new ArrayList<int[]>();
//log("start loop");
while (goon) {
cand.add(new int[] {u,v});
//log("u:"+u+" v:"+v);
ok=false;
goon=false;
long need=tot-((long)sum[u]-(long)list[u][v]);
if (Math.abs(need)<=AX) {
//log("need:"+need);
int nd=(int)need;
int[] tm=target.get(nd);
//log("tm:"+tm);
if (tm!=null) {
//log("can find successor");
int nxu=tm[0];
int nxv=tm[1];
if ((mask&(1<<nxu))==0) {
mask|=1<<nxu;
if (nxu==src_u) {
// looping back to source
if (nxv==src_v)
ok=true;
} else {
u=nxu;
v=nxv;
ok=true;
goon=true;
}
}
}
}
}
if (ok) {
if (howto[mask]==null) {
howto[mask]=cand;
}
}
}
}
log("step 1 done");
// now mask
ArrayList[] components=new ArrayList[MX];
int[] msk=new int[MX];
int w=0;
for (int m=0;m<MX;m++) {
if (howto[m]!=null) {
//String s=Integer.toBinaryString(m);
//while (s.length()<k)
// s="0"+s;
//log("found mask:"+s);
components[m]=new ArrayList<Integer>();
components[m].add(m);
msk[w++]=m;
}
}
int base=w;
for (int e=0;e<base;e++) {
int a=msk[e];
int ww=w;
for (int i=0;i<ww;i++) {
int b=msk[i];
if ((b&a)==0) {
int c=b|a;
//log("creating c:"+c+" ");
if (components[c]==null ) {
components[c]=new ArrayList<Integer>();
components[c].add(a);
components[c].add(b);
msk[w++]=c;
}
}
}
}
//log("msk:"+msk);
//log(components[MX-1]);
if (components[MX-1]!=null) {
output("Yes");
int[][] move=new int[k][2];
explore(components,components[MX-1],move,howto,list);
for (int i=0;i<k;i++) {
output(move[i][0]+" "+(move[i][1]+1));
}
} else {
output("No");
}
}
try {
out.close();
} catch (Exception e) {
}
}
public static void main(String[] args) throws Exception {
process();
}
static final class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
private int read() throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read(buf);
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public final String readString() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.append((char) c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public final int readInt() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
int res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
public final long readLong() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Random;
import java.util.TreeSet;
public final class CF_599_D1_C
{
static boolean verb=true;
static void log(Object X){if (verb) System.err.println(X);}
static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+" ");System.err.println("");}}
static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+" ");System.err.println("");}}
static void logWln(Object X){if (verb) System.err.print(X);}
static void info(Object o){ System.out.println(o);}
static void output(Object o){outputWln(""+o+"\n"); }
static void outputWln(Object o){try {out.write(""+ o);} catch (Exception e) {}}
static long mod=1000000007;
// Global vars
static BufferedWriter out;
static InputReader reader;
static class Composite implements Comparable<Composite>{
int idx;
int v;
public int compareTo(Composite X) {
if (v!=X.v)
return v-X.v;
return idx-X.idx;
}
public Composite(int idx, int v) {
this.idx = idx;
this.v = v;
}
}
static void test() {
log("testing");
log("done");
}
static void explore(ArrayList<Integer>[] components,ArrayList<Integer> bob,int[][] move,ArrayList<int[]>[] howto,int[][] list) {
for (int x:bob) {
if (components[x].size()==1) {
int tm[]=howto[x].get(0);
int L=howto[x].size();
howto[x].add(tm);
for (int i=0;i<L;i++) {
int[] cur=howto[x].get(i);
int[] nx=howto[x].get(i+1);
int a=cur[0];
int a2=nx[0];
int b2=nx[1];
move[a2][0]=list[a2][b2];
move[a2][1]=a;
}
} else {
explore(components,components[x],move,howto,list);
}
}
}
static void process() throws Exception {
//arrayTest();
out = new BufferedWriter(new OutputStreamWriter(System.out));
reader = new InputReader(System.in);
int k=reader.readInt();
int[][] list=new int[k][];
long[] sum=new long[k];
int[] L=new int[k];
HashMap<Integer,int[]> target=new HashMap<Integer,int[]>();
long tot=0;
for (int i=0;i<k;i++) {
L[i]=reader.readInt();
list[i]=new int[L[i]];
for (int j=0;j<L[i];j++) {
list[i][j]=reader.readInt();
sum[i]+=list[i][j];
target.put(list[i][j],new int[] {i,j});
}
tot+=sum[i];
}
int MX=1<<k;
int AX=1000000001;
ArrayList<int[]>[] howto=new ArrayList[MX];
log("ok with the data");
if (tot%k!=0) {
output("No");
} else {
tot/=k;
for (int i=0;i<k;i++) {
if (sum[i]==tot) {
//log("nothing to do for i:"+i);
// nothing to do
int mask=1<<i;
ArrayList<int[]> cand=new ArrayList<int[]>();
cand.add(new int[] {i,0});
howto[mask]=cand;
} else
for (int j=0;j<L[i];j++) {
int u=i;
int v=j;
boolean ok=true;
int src_u=u;
int src_v=v;
int mask=0;
boolean goon=true;
ArrayList<int[]> cand=new ArrayList<int[]>();
//log("start loop");
while (goon) {
cand.add(new int[] {u,v});
//log("u:"+u+" v:"+v);
ok=false;
goon=false;
long need=tot-((long)sum[u]-(long)list[u][v]);
if (Math.abs(need)<=AX) {
//log("need:"+need);
int nd=(int)need;
int[] tm=target.get(nd);
//log("tm:"+tm);
if (tm!=null) {
//log("can find successor");
int nxu=tm[0];
int nxv=tm[1];
if ((mask&(1<<nxu))==0) {
mask|=1<<nxu;
if (nxu==src_u) {
// looping back to source
if (nxv==src_v)
ok=true;
} else {
u=nxu;
v=nxv;
ok=true;
goon=true;
}
}
}
}
}
if (ok) {
if (howto[mask]==null) {
howto[mask]=cand;
}
}
}
}
log("step 1 done");
// now mask
ArrayList<Integer> msk=new ArrayList<Integer>();
ArrayList[] components=new ArrayList[MX];
for (int m=0;m<MX;m++) {
if (howto[m]!=null) {
//String s=Integer.toBinaryString(m);
//while (s.length()<k)
// s="0"+s;
//log("found mask:"+s);
components[m]=new ArrayList<Integer>();
components[m].add(m);
}
}
int[] visited=new int[MX];
for (int a=0;a<MX;a++) {
if (howto[a]!=null) {
ArrayList<Integer> add=new ArrayList<Integer>();
for (int b:msk) {
if ((b&a)==0) {
int c=b|a;
log("creating c:"+c+" ");
if (components[c]==null) {
components[c]=new ArrayList<Integer>();
components[c].add(a);
components[c].add(b);
add.add(c);
}
}
}
msk.add(a);
for (int c:add) {
msk.add(c);
}
}
}
//log("msk:"+msk);
//log(components[MX-1]);
if (components[MX-1]!=null) {
output("Yes");
int[][] move=new int[k][2];
explore(components,components[MX-1],move,howto,list);
for (int i=0;i<k;i++) {
output(move[i][0]+" "+(move[i][1]+1));
}
} else {
output("No");
}
}
try {
out.close();
} catch (Exception e) {
}
}
public static void main(String[] args) throws Exception {
process();
}
static final class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
private int read() throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read(buf);
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public final String readString() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.append((char) c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public final int readInt() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
int res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
public final long readLong() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.io.UncheckedIOException;
import java.util.Map;
import java.io.Closeable;
import java.util.Map.Entry;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 27);
thread.start();
thread.join();
}
static class TaskAdapter implements Runnable {
@Override
public void run() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastInput in = new FastInput(inputStream);
FastOutput out = new FastOutput(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
}
static class TaskC {
SubsetGenerator sg = new SubsetGenerator();
Node[] nodes;
int n;
Map<Long, Node> map;
long notExist;
long[] mask2Key;
Map<Long, LongList> sequence;
DigitUtils.BitOperator bo = new DigitUtils.BitOperator();
boolean[] dp;
public void solve(int testNumber, FastInput in, FastOutput out) {
n = in.readInt();
nodes = new Node[n];
for (int i = 0; i < n; i++) {
nodes[i] = new Node();
nodes[i].id = i;
}
map = new LinkedHashMap<>(200000);
for (int i = 0; i < n; i++) {
int k = in.readInt();
for (int j = 0; j < k; j++) {
long x = in.readInt();
map.put(x, nodes[i]);
nodes[i].sum += x;
}
}
long total = 0;
for (Node node : nodes) {
total += node.sum;
}
if (total % n != 0) {
out.println("No");
return;
}
long avg = total / n;
notExist = (long) 1e18;
mask2Key = new long[1 << n];
Arrays.fill(mask2Key, notExist);
sequence = new HashMap<>(200000);
for (Map.Entry<Long, Node> kv : map.entrySet()) {
for (Node node : nodes) {
node.handled = false;
}
long key = kv.getKey();
Node node = kv.getValue();
node.handled = true;
int mask = bo.setBit(0, node.id, true);
LongList list = new LongList(15);
list.add(key);
long req = avg - (node.sum - key);
boolean valid = true;
while (true) {
if (req == key) {
break;
}
Node next = map.get(req);
if (next == null || next.handled) {
valid = false;
break;
}
next.handled = true;
list.add(req);
req = avg - (next.sum - req);
mask = bo.setBit(mask, next.id, true);
}
if (!valid) {
continue;
}
mask2Key[mask] = key;
sequence.put(key, list);
}
dp = new boolean[1 << n];
for (int i = 0; i < (1 << n); i++) {
dp[i] = mask2Key[i] != notExist;
sg.setSet(i);
while (!dp[i] && sg.hasNext()) {
int next = sg.next();
if (next == 0 || next == i) {
continue;
}
dp[i] = dp[i] || (dp[next] && dp[i - next]);
}
}
if (!dp[(1 << n) - 1]) {
out.println("No");
return;
}
populate((1 << n) - 1);
out.println("Yes");
for (Node node : nodes) {
out.append(node.out).append(' ').append(node.to + 1).append('\n');
}
}
public void populate(int mask) {
if (mask2Key[mask] != notExist) {
LongList list = sequence.get(mask2Key[mask]);
int m = list.size();
for (int i = 0; i < m; i++) {
long v = list.get(i);
long last = list.get(DigitUtils.mod(i - 1, m));
Node which = map.get(v);
Node to = map.get(last);
which.out = v;
which.to = to.id;
}
return;
}
sg.setSet(mask);
while (sg.hasNext()) {
int next = sg.next();
if (next == 0 || next == mask) {
continue;
}
if (dp[next] && dp[mask - next]) {
populate(next);
populate(mask - next);
return;
}
}
}
}
static class LongList {
private int size;
private int cap;
private long[] data;
private static final long[] EMPTY = new long[0];
public LongList(int cap) {
this.cap = cap;
if (cap == 0) {
data = EMPTY;
} else {
data = new long[cap];
}
}
public LongList(LongList list) {
this.size = list.size;
this.cap = list.cap;
this.data = Arrays.copyOf(list.data, size);
}
public LongList() {
this(0);
}
private void ensureSpace(int need) {
int req = size + need;
if (req > cap) {
while (cap < req) {
cap = Math.max(cap + 10, 2 * cap);
}
data = Arrays.copyOf(data, cap);
}
}
private void checkRange(int i) {
if (i < 0 || i >= size) {
throw new ArrayIndexOutOfBoundsException();
}
}
public long get(int i) {
checkRange(i);
return data[i];
}
public void add(long x) {
ensureSpace(1);
data[size++] = x;
}
public int size() {
return size;
}
public String toString() {
return Arrays.toString(Arrays.copyOf(data, size));
}
}
static class SubsetGenerator {
private int[] meanings = new int[33];
private int[] bits = new int[33];
private int remain;
private int next;
public void setSet(int set) {
int bitCount = 0;
while (set != 0) {
meanings[bitCount] = set & -set;
bits[bitCount] = 0;
set -= meanings[bitCount];
bitCount++;
}
remain = 1 << bitCount;
next = 0;
}
public boolean hasNext() {
return remain > 0;
}
private void consume() {
remain = remain - 1;
int i;
for (i = 0; bits[i] == 1; i++) {
bits[i] = 0;
next -= meanings[i];
}
bits[i] = 1;
next += meanings[i];
}
public int next() {
int returned = next;
consume();
return returned;
}
}
static class Node {
int id;
long sum;
boolean handled;
long out;
long to;
}
static class FastInput {
private final InputStream is;
private byte[] buf = new byte[1 << 13];
private int bufLen;
private int bufOffset;
private int next;
public FastInput(InputStream is) {
this.is = is;
}
private int read() {
while (bufLen == bufOffset) {
bufOffset = 0;
try {
bufLen = is.read(buf);
} catch (IOException e) {
bufLen = -1;
}
if (bufLen == -1) {
return -1;
}
}
return buf[bufOffset++];
}
public void skipBlank() {
while (next >= 0 && next <= 32) {
next = read();
}
}
public int readInt() {
int sign = 1;
skipBlank();
if (next == '+' || next == '-') {
sign = next == '+' ? 1 : -1;
next = read();
}
int val = 0;
if (sign == 1) {
while (next >= '0' && next <= '9') {
val = val * 10 + next - '0';
next = read();
}
} else {
while (next >= '0' && next <= '9') {
val = val * 10 - next + '0';
next = read();
}
}
return val;
}
}
static class FastOutput implements AutoCloseable, Closeable {
private StringBuilder cache = new StringBuilder(10 << 20);
private final Writer os;
public FastOutput(Writer os) {
this.os = os;
}
public FastOutput(OutputStream os) {
this(new OutputStreamWriter(os));
}
public FastOutput append(char c) {
cache.append(c);
return this;
}
public FastOutput append(long c) {
cache.append(c);
return this;
}
public FastOutput println(String c) {
cache.append(c).append('\n');
return this;
}
public FastOutput flush() {
try {
os.append(cache);
os.flush();
cache.setLength(0);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
return this;
}
public void close() {
flush();
try {
os.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
public String toString() {
return cache.toString();
}
}
static class DigitUtils {
private static final long[] DIGIT_VALUES = new long[19];
static {
DIGIT_VALUES[0] = 1;
for (int i = 1; i < 19; i++) {
DIGIT_VALUES[i] = DIGIT_VALUES[i - 1] * 10;
}
}
private DigitUtils() {
}
public static int mod(int x, int mod) {
x %= mod;
if (x < 0) {
x += mod;
}
return x;
}
public static class BitOperator {
public int setBit(int x, int i, boolean v) {
if (v) {
x |= 1 << i;
} else {
x &= ~(1 << i);
}
return x;
}
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;
public class C {
static int K;
static int sz[];
static long vs[][];
static long curSum[];
static HashMap<Long, Integer> valToBucket;
static long sum;
static int maskIfPick[][];
static int dp[];
static int pickId[];
static int newBox[];
public static void main(String[] args) {
FS in = new FS();
K = in.nextInt();
sz = new int[K];
valToBucket = new HashMap<Long, Integer>();
vs = new long[K][];
curSum = new long[K];
sum = 0;
for(int i = 0; i < K; i++) {
sz[i] = in.nextInt();
vs[i] = new long[sz[i]];
for(int j = 0; j < sz[i]; j++) {
long v = in.nextLong();
sum += v;
curSum[i] += v;
vs[i][j] = v;
valToBucket.put(v, i);
}
}
if(sum % K != 0) {
System.out.println("No");
return;
}
sum /= K;
maskIfPick = new int[K][];
//go through if i pick each node
for(int i = 0; i < K; i++) {
maskIfPick[i] = new int[sz[i]];
for(int j = 0; j < sz[i]; j++) {
int mask = (1<<i);
boolean works = false;
long curLookfor = (sum - (curSum[i]-vs[i][j]));
while(true) {
if(!valToBucket.containsKey(curLookfor)) break;
int nextBucket = valToBucket.get(curLookfor);
if(nextBucket == i) {
works = curLookfor == vs[i][j];
break;
}
else if((mask & (1<<nextBucket)) > 0) break;
else {
mask |= (1<<nextBucket);
curLookfor = (sum - (curSum[nextBucket]-curLookfor));
}
}
if(works) maskIfPick[i][j] = mask;
}
}
// System.out.println("S= "+sum);
dp = new int[1<<K];
Arrays.fill(dp, -1);
int res = go(0);
if(res == 0) {
System.out.println("No");
}
else {
System.out.println("Yes");
pickId = new int[K];
newBox = new int[K];
Arrays.fill(pickId, -1);
buildback(0);
for(int i = 0; i < K; i++) {
System.out.println(vs[i][pickId[i]]+" "+(newBox[i]+1));
}
}
}
static void pick(int i, int j) {
// System.out.println(" Pick "+i+" "+j);
if(pickId[i] != -1) return;
pickId[i] = j;
long curLookfor = (sum - (curSum[i]-vs[i][j]));
int nextBucket = valToBucket.get(curLookfor);
newBox[nextBucket] = i;
for(int k = 0; k < sz[nextBucket]; k++) {
if(vs[nextBucket][k] == curLookfor) pick(nextBucket, k);
}
}
static int go(int mask) {
if(mask+1 == (1<<K)) return 1; //got to end
if(dp[mask] != -1) return dp[mask];
//get first bit that's off
int bit = -1;
for(int i = 0; i < K; i++) {
if((mask & (1<<i)) == 0) { bit = i; break;}
}
int res = 0;
//loop through things to take for this bit
for(int take = 0; take < sz[bit]; take++) {
int newMask = maskIfPick[bit][take];
if(newMask == 0 || (mask & newMask) > 0) continue;
res = (res | go(mask | newMask));
}
return dp[mask] = res;
}
static void buildback(int mask) {
if(mask+1 == (1<<K)) return; //got to end
//get first bit that's off
int bit = -1;
for(int i = 0; i < K; i++) {
if((mask & (1<<i)) == 0) { bit = i; break;}
}
int res = 0;
//loop through things to take for this bit
for(int take = 0; take < sz[bit]; take++) {
int newMask = maskIfPick[bit][take];
if(newMask == 0 || (mask & newMask) > 0) continue;
res = (res | go(mask | newMask));
if(res == 1) {
pick(bit, take);
buildback(mask | newMask);
break;
}
}
}
static class FS{
BufferedReader br;
StringTokenizer st;
public FS() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while(st == null || !st.hasMoreElements()) {
try {st = new StringTokenizer(br.readLine());}
catch(Exception e) { throw null;}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next());}
double nextDouble() { return Double.parseDouble(next());}
long nextLong() { return Long.parseLong(next());}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.lang.*;
import java.util.*;
import java.io.*;
public class Main {
void solve() {
int m=ni();
long a[][]=new long[m][];
HashMap<Long,Integer> mp=new HashMap<>();
long TS=0;
long sm[]=new long[m];
for(int i=0;i<m;i++){
int sz=ni();
a[i]=new long[sz];
for(int j=0;j<sz;j++){
a[i][j]=nl();
mp.put(a[i][j],i);
sm[i]+=a[i][j];
}
TS+=sm[i];
}
if(TS%m!=0){
pw.println("No");
return;
}
TS/=m;
ArrayList<Node> ansForMask[]=new ArrayList[(1<<m)];
for(int i=0;i<(1<<m);i++) ansForMask[i]=new ArrayList<>();
ArrayList<Node> tempList=new ArrayList<>();
int vis[]=new int[m];
for(int i=0;i<m;i++){
out:for(int j=0;j<a[i].length;j++){
int mask=0;
tempList.clear();
long val=a[i][j],req=Long.MAX_VALUE;
int idx=i,idx2;
Arrays.fill(vis,0);
if(sm[i]==TS){
mask=1<<i;
if(ansForMask[mask].size()==0) ansForMask[mask].add(new Node(val,i,i));
continue;
}
while(vis[idx]==0){
req=TS-(sm[idx]-val);
if(!mp.containsKey(req)) continue out;
idx2=mp.get(req);
if(vis[idx]==1 || idx==idx2) continue out;
if(vis[idx2]==1) break;
// if(i==0 && j==1) pw.println(idx2+" "+req+" "+val);
vis[idx]=1;
mask+=(1<<idx);
tempList.add(new Node(req,idx2,idx));
idx=idx2;
val=req;
}
if(req!=a[i][j])continue out;
mask+=(1<<idx);
tempList.add(new Node(a[i][j],i,idx));
if(ansForMask[mask].size()==0){
// pw.println(Integer.toBinaryString(mask));
ansForMask[mask].addAll(tempList);
}
}
}
int dp[]=new int[1<<m];
dp[0]=1;
out: for(int mask=1;mask <(1<<m);mask++){
if(ansForMask[mask].size()!=0){
dp[mask]=1;
// pw.println(Integer.toBinaryString(mask)+" "+mask);
continue;
}
for(int s=mask;s>0;s=(s-1)&mask){
if(dp[s]==1 && dp[mask^s]==1){
dp[mask]=1;
ansForMask[mask].addAll(ansForMask[s]);
ansForMask[mask].addAll(ansForMask[mask^s]);
continue out;
}
}
}
if(dp[(1<<m)-1]==0){
pw.println("No");
return;
}
pw.println("Yes");
Pair ans[]=new Pair[m];
for(Node p : ansForMask[(1<<m)-1]){
ans[p.id1]=new Pair(p.c,p.id2);
}
for(int i=0;i<m;i++) pw.println(ans[i].c+" "+(ans[i].p+1));
}
class Pair {
long c;
int p;
public Pair(long c,int p){
this.c=c;
this.p=p;
}
}
class Node{
long c;
int id1;
int id2;
public Node(long c,int id1,int id2){
this.c=c;
this.id1=id1;
this.id2=id2;
}
}
long M = (long)1e9+7;
// END
PrintWriter pw;
StringTokenizer st;
BufferedReader br;
void run() throws Exception {
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
pw.flush();
}
public static void main(String[] args) throws Exception {
new Main().run();
}
String ns() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
String nextLine() throws Exception {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
throw new Exception(e.toString());
}
return str;
}
int ni() {
return Integer.parseInt(ns());
}
long nl() {
return Long.parseLong(ns());
}
double nd() {
return Double.parseDouble(ns());
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.util.*;
import java.io.*;
public class C599 {
static ArrayList<Integer> [] adj;
static long [] a; static int [] type;
static Map<Long, Integer> map;
static int [] vis;
static HashSet<Integer> cy;
static boolean [] good;
static int [] dp;
static HashSet<Integer> [] nodes;
public static void main(String[] args) {
MyScanner sc = new MyScanner();
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
int k = sc.nextInt();
int cur = 0;
a = new long[75007]; long sum = 0;
type = new int[75007];
map = new HashMap<>();
long [] typeSum = new long[k];
for (int i = 0; i < k; i++) {
int n = sc.nextInt(); long temp = sum;
for (int j = 0; j < n; j++) {
cur++;
a[cur] = sc.nextLong();
type[cur] = i;
map.put(a[cur], cur);
sum += a[cur];
}
typeSum[i] = sum - temp;
}
boolean notDiv = sum % k != 0;
long need = sum / k;
int n = cur;
adj = new ArrayList[n + 1];
for (int i = 1; i <= n; i++) adj[i] = new ArrayList<>();
for (int i = 1; i <= n; i++) {
long delta = need - typeSum[type[i]];
long find = a[i] + delta;
if (map.containsKey(find)) {
if (type[map.get(find)] != type[i] || delta == 0) adj[i].add(map.get(find));
}
}
vis = new int[n + 1];
good = new boolean[1 << k];
good[0] = true;
nodes = new HashSet[1 << k];
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
cy = new HashSet<>();
boolean b = dfs(i);
int mask = 0;
for (Integer node: cy) {
mask |= (1 << type[node]);
}
if (mask != 0) nodes[mask] = cy;
good[mask] = true;
}
}
dp = new int[1 << k];
Arrays.fill(dp, -1);
int possible = solve((1 << k) - 1);
if (possible == 1 && !notDiv) {
ArrayList<Integer> masks = dfs2((1 << k) - 1);
long [] num = new long[k];
int [] ret = new int[k];
for (Integer mask: masks) {
for (Integer node: nodes[mask]) {
num[type[node]] = a[node];
ret[type[adj[node].get(0)]] = type[node] + 1;
}
}
boolean good = true; Set<Integer> soFar = new HashSet<>();
for (int i = 0; i < ret.length; i++) {
if (soFar.contains(ret[i])) good = false;
soFar.add(ret[i]);
}
if (!good) {
out.println("No");
out.close();
return;
}
out.println("Yes");
for (int i = 0; i < k; i++) {
out.println(num[i] + " " + ret[i]);
}
} else {
out.println("No");
}
out.close();
}
static int solve(int mask) {
if (dp[mask] != -1) return dp[mask];
if (good[mask]) return dp[mask] = 1;
int ret = 0;
for (int i = (mask - 1) & mask; i > 0; i = (i - 1) & mask) {
ret = solve(i) & solve(mask ^ i);
if (ret == 1) break;
}
return dp[mask] = ret;
}
static ArrayList<Integer> dfs2(int mask) {
ArrayList<Integer> ret = new ArrayList<>();
if (good[mask]) {
ret.add(mask);
return ret;
}
for (int i = (mask - 1) & mask; i > 0; i = (i - 1) & mask) {
if (dp[i] == 1 && dp[mask ^ i] == 1) {
ArrayList<Integer> one = dfs2(i);
ArrayList<Integer> two = dfs2(mask ^ i);
ret.addAll(one); ret.addAll(two);
break;
}
}
return ret;
}
static boolean dfs(int cur) {
vis[cur] = 1; boolean ret = false;
for (Integer next: adj[cur]) {
if (vis[next] == 0) {
boolean cycle = dfs(next);
if (cycle) {
if (!cy.contains(cur)) {
cy.add(cur);
ret = true; break;
}
}
} else if (vis[next] == 1) {
cy.add(next);
cy.add(cur);
if (next != cur) ret = true;
break;
}
}
vis[cur] = 2;
return ret;
}
//-----------MyScanner class for faster input----------
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.*;
import java.util.*;
public class Main {
static class Reader
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException
{
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1)
{
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.')
{
while ((c = read()) >= '0' && c <= '9')
{
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
public static void main(String[] args) throws IOException {
Reader sc = new Reader();
int k = sc.nextInt();
int[][] buckets = new int[k][];
long[] bucketSum = new long[k];
Map<Integer, Integer> map = new HashMap<>(k * 10000);
long target = 0;
for (int i = 0; i < k; i++) {
int n = sc.nextInt();
int[] arr = new int[n];
for (int j = 0; j < n; j++) {
arr[j] = sc.nextInt();
target += arr[j];
map.put(arr[j], i);
bucketSum[i] += arr[j];
}
buckets[i] = arr;
}
if ((target % k) != 0) {
System.out.println("No");
return;
} else {
target /= k;
}
int[] bitmask = new int[1 << (k )];
Arrays.fill(bitmask, -1);
for (int i = 0; i < k; i++) {
for (int j = 0; j < buckets[i].length; j++) {
int start = buckets[i][j];
int next = (int) (target - bucketSum[i]) + start;
Set<Integer> visited = new HashSet<>();
Set<Integer> visitedBuckets = new HashSet<>();
visited.add(start);
visitedBuckets.add(i);
int bitset = 1 << i;
while (map.containsKey(next)) {
int bucket = map.get(next);
if (start == next) {
bitmask[bitset] = start;
break;
} else if (visited.contains(next)) {
break;
} else if (visitedBuckets.contains(bucket)) {
break;
}
visited.add(next);
visitedBuckets.add(bucket);
next = (int) (target - bucketSum[bucket]) + next;
bitset |= 1 << bucket;
}
}
}
boolean[] dp = new boolean[1 << (k ) ];
Arrays.fill(dp, false);
int[] build = new int[1 << k];
Arrays.fill(build, -1);
for (int i = 0; i < dp.length; i++) {
dp[i] = bitmask[i] != -1;
}
for (int m = 0; m < (1 << k); m++) {
if (!dp[m]) {
for (int s = m; s != 0; s = (s - 1) & m) {
if (dp[s] && dp[(m ^ s)]) {
dp[m] = true;
build[m] = s;
break;
}
}
}
}
System.out.println(dp[dp.length - 1] ? "Yes" : "No");
ArrayList<Integer> path = new ArrayList<>();
rec(path, build, bitmask, (1 << k) - 1);
int[] picked = new int[k];
int[] out = new int[k];
if (dp[dp.length - 1]) {
for (int i : path) {
int prev = i;
int next = (int) (target - bucketSum[map.get(prev)]) + prev;
picked[map.get(next)] = next;
out[map.get(next)] = map.get(prev);
while (next != i) {
int t = next;
next = (int) (target - bucketSum[map.get(next)]) + next;
prev = t;
out[map.get(next)] = map.get(prev);
picked[map.get(next)] = next;
}
}
for (int i = 0; i < out.length; i++) {
System.out.println((picked[i]) + " " + (out[i] + 1));
}
}
}
public static void rec(ArrayList<Integer> path, int[] build, int[] bitmask, int i) {
if (!(i >= 0 && i < bitmask.length)) {
return;
}
if (bitmask[i] != -1) {
path.add(bitmask[i]);
} else {
rec(path, build, bitmask, build[i]);
rec(path, build, bitmask, i ^ build[i]);
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.*;
import java.util.*;
public class E implements Runnable {
public static void main (String[] args) {new Thread(null, new E(), "_cf", 1 << 28).start();}
HashMap<Integer, Integer> valToNode, nodeToVal, whichBox;
int N, ptsTo[], cycleMask[], dfsStack[], tempList[];
ArrayDeque<Integer> stack = new ArrayDeque<>();
public void run() {
FastScanner fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
System.err.println("");
valToNode = new HashMap<>();
nodeToVal = new HashMap<>();
whichBox = new HashMap<>();
int K = fs.nextInt();
int[][] vals = new int[K][], valToNode2 = new int[K][];
long[] sums = new long[K];
long total = 0;
for(int i = 0; i < K; i++) {
int size = fs.nextInt();
vals[i] = new int[size];
valToNode2[i] = new int[size];
for(int j = 0; j < size; j++) {
vals[i][j] = fs.nextInt();
sums[i] += vals[i][j];
valToNode2[i][j] = valToNode.size();
valToNode.put(vals[i][j], valToNode.size());
nodeToVal.put(valToNode.size()-1, vals[i][j]);
whichBox.put(vals[i][j], i);
}
total += sums[i];
}
if(total % K != 0) {
System.out.println("No");
return;
}
long perGroup = total/K;
N = valToNode.size();
ptsTo = new int[N];
for(int i = 0; i < K; i++) {
for(int j = 0; j < vals[i].length; j++) {
long newSum = perGroup - (sums[i]-vals[i][j]);
if(newSum > (int)1e9 || newSum < (int)-1e9) continue;
if(valToNode.containsKey((int)newSum)) {
ptsTo[valToNode.get(vals[i][j])] = valToNode.get((int)newSum);
}
else ptsTo[valToNode.get(vals[i][j])] = -1;
}
}
tempList = new int[N];
dfsStack = new int[N];
cycleMask = new int[N];
for(int i = 0; i < K; i++) {
for(int j = 0; j < vals[i].length; j++) {
int node = valToNode.get(vals[i][j]);
if(dfsStack[node] == 0) dfs(node);
}
}
int[] goodMask = new int[1<<K];
Arrays.fill(goodMask, -1); goodMask[0] = 0;
for(int mask = 1; mask < goodMask.length; mask++) {
int idx = Integer.numberOfTrailingZeros(Integer.lowestOneBit(mask));
for(int i = 0; i < vals[idx].length; i++) {
int node = valToNode2[idx][i];
if(cycleMask[node] == mask) {
goodMask[mask] = node;
break;
}
}
}
int[] dp = new int[1<<K];
Arrays.fill(dp, -1); dp[0] = 0;
for(int mask = 1; mask < dp.length; mask++) {
if(goodMask[mask] != -1) {
dp[mask] = mask;
continue;
}
for(int sub = mask; sub != 0; sub = (sub-1)&mask) {
if(goodMask[sub] == -1) continue;
int newMask = mask-sub;
if(dp[newMask] == -1) continue;
dp[mask] = sub;
break;
}
}
if(dp[dp.length-1] == -1) out.println("No");
else {
int[][] res = new int[K][2];
for(int[] x : res) Arrays.fill(x, -1);
int curMask = dp.length-1;
while(curMask > 0) {
int temp = dp[curMask];
int curNode = goodMask[temp];
while(temp > 0) {
int curVal = nodeToVal.get(curNode), curBox = whichBox.get(curVal);
res[curBox][0] = curVal;
int goingTo = ptsTo[curNode], goingVal = nodeToVal.get(goingTo), goingBox = whichBox.get(goingVal);
res[goingBox][1] = curBox;
curNode = ptsTo[curNode];
temp -= 1<<curBox;
}
curMask -= dp[curMask];
}
out.println("Yes");
for(int i = 0; i < K; i++) {
if(res[i][1] == -1) throw null;
out.printf("%d %d\n", res[i][0], res[i][1]+1);
}
}
out.close();
}
void dfs(int node) {
dfsStack[node] = 1;
stack.addLast(node);
int goTo = ptsTo[node];
if(goTo == -1) {
while(!stack.isEmpty()) {
cycleMask[stack.pollLast()] = -1;
}
}
else {
if(dfsStack[goTo] == 1) {
int ptr = 0, mask = 0, conflict = 0;
while(!stack.isEmpty()) {
int now = stack.pollLast(), val = nodeToVal.get(now), box = whichBox.get(val);
tempList[ptr++] = now;
if((mask & (1<<box)) > 0) conflict = 1;
mask |= 1<<box;
if(now == goTo) break;
}
while(!stack.isEmpty()) {
cycleMask[stack.pollLast()] = -1;
}
for(int i = 0; i < ptr; i++) {
int now = tempList[i];
if(conflict > 0) cycleMask[now] = -1;
else cycleMask[now] = mask;
}
}
else if(dfsStack[goTo] == 2) {
while(!stack.isEmpty()) {
cycleMask[stack.pollLast()] = -1;
}
}
else {
dfs(goTo);
}
}
dfsStack[node] = 2;
}
class FastScanner {
public int BS = 1<<16;
public char NC = (char)0;
byte[] buf = new byte[BS];
int bId = 0, size = 0;
char c = NC;
double num = 1;
BufferedInputStream in;
public FastScanner() {
in = new BufferedInputStream(System.in, BS);
}
public FastScanner(String s) {
try {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
}
catch (Exception e) {
in = new BufferedInputStream(System.in, BS);
}
}
public char nextChar(){
while(bId==size) {
try {
size = in.read(buf);
}catch(Exception e) {
return NC;
}
if(size==-1)return NC;
bId=0;
}
return (char)buf[bId++];
}
public int nextInt() {
return (int)nextLong();
}
public long nextLong() {
num=1;
boolean neg = false;
if(c==NC)c=nextChar();
for(;(c<'0' || c>'9'); c = nextChar()) {
if(c=='-')neg=true;
}
long res = 0;
for(; c>='0' && c <='9'; c=nextChar()) {
res = (res<<3)+(res<<1)+c-'0';
num*=10;
}
return neg?-res:res;
}
public double nextDouble() {
double cur = nextLong();
return c!='.' ? cur:cur+nextLong()/num;
}
public String next() {
StringBuilder res = new StringBuilder();
while(c<=32)c=nextChar();
while(c>32) {
res.append(c);
c=nextChar();
}
return res.toString();
}
public String nextLine() {
StringBuilder res = new StringBuilder();
while(c<=32)c=nextChar();
while(c!='\n') {
res.append(c);
c=nextChar();
}
return res.toString();
}
public boolean hasNext() {
if(c>32)return true;
while(true) {
c=nextChar();
if(c==NC)return false;
else if(c>32)return true;
}
}
public int[] nextIntArray(int n) {
int[] res = new int[n];
for(int i = 0; i < n; i++) res[i] = nextInt();
return res;
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Map;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastScanner in = new FastScanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
int n;
int[] bitCount;
long neededSum;
long[] sums;
Map<Long, Integer> where;
public void solve(int testNumber, FastScanner in, PrintWriter out) {
n = in.nextInt();
int[][] a = new int[n][];
neededSum = 0;
sums = new long[n];
for (int i = 0; i < n; i++) {
int k = in.nextInt();
a[i] = new int[k];
for (int j = 0; j < k; j++) {
a[i][j] = in.nextInt();
neededSum += a[i][j];
sums[i] += a[i][j];
}
}
if (neededSum % n != 0) {
out.println("No");
return;
}
neededSum /= n;
where = new HashMap<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].length; j++) {
where.put((long) a[i][j], i);
}
}
bitCount = new int[1 << n];
for (int i = 0; i < bitCount.length; i++) {
bitCount[i] = Integer.bitCount(i);
}
Entry[][] cycleSol = new Entry[1 << n][];
List<Entry> sol = new ArrayList<>();
for (int i = 0; i < n; i++) {
for (int x : a[i]) {
search(i, i, x, x, 0, 0, sol, cycleSol);
}
}
boolean[] can = new boolean[1 << n];
int[] via = new int[1 << n];
can[0] = true;
for (int mask = 0; mask < 1 << n; mask++) {
for (int submask = mask; submask > 0; submask = (submask - 1) & mask) {
if (cycleSol[submask] != null && can[mask ^ submask]) {
can[mask] = true;
via[mask] = submask;
}
}
}
if (!can[(1 << n) - 1]) {
out.println("No");
return;
}
int[][] ans = new int[n][2];
for (int mask = (1 << n) - 1; mask > 0; ) {
int sm = via[mask];
mask ^= sm;
for (Entry e : cycleSol[sm]) {
ans[e.from][0] = e.what;
ans[e.from][1] = e.to + 1;
}
}
out.println("Yes");
for (int i = 0; i < n; i++) {
out.println(ans[i][0] + " " + ans[i][1]);
}
}
private void search(int start, int cur, long fromStart, long fromCur, int hasIn, int hasOut, List<Entry> sol, Entry[][] cycleSol) {
for (int i = 0; i < n; i++) {
if ((hasIn & (1 << i)) > 0) {
continue;
}
if ((hasOut & (1 << cur)) > 0) {
continue;
}
long fromI = sums[i] + fromCur - neededSum;
Integer w = where.get(fromI);
if (w == null || w != i) {
continue;
}
sol.add(new Entry(cur, i, (int) fromCur));
int nHasIn = hasIn | (1 << i);
int nHasOut = hasOut | (1 << cur);
if (i == start && fromI == fromStart) {
cycleSol[nHasOut] = sol.toArray(new Entry[0]);
}
search(start, i, fromStart, fromI, nHasIn, nHasOut, sol, cycleSol);
sol.remove(sol.size() - 1);
}
}
class Entry {
int from;
int to;
int what;
Entry(int from, int to, int what) {
this.from = from;
this.to = to;
this.what = what;
}
public String toString() {
return from + " " + to + " " + what;
}
}
}
static class FastScanner {
private BufferedReader in;
private StringTokenizer st;
public FastScanner(InputStream stream) {
in = new BufferedReader(new InputStreamReader(stream));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
String rl = in.readLine();
if (rl == null) {
return null;
}
st = new StringTokenizer(rl);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.*;
import java.util.*;
import java.util.stream.*;
public class a implements Runnable{
public static void main(String[] args) {
new Thread(null, new a(), "process", 1<<26).start();
}
public void run() {
FastReader scan = new FastReader();
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
//PrintWriter out = new PrintWriter("file.out");
Task solver = new Task();
//int t = scan.nextInt();
int t = 1;
for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
out.close();
}
static class Task {
static final int inf = Integer.MAX_VALUE;
public void solve(int testNumber, FastReader sc, PrintWriter pw) {
//CHECK FOR QUICKSORT TLE
//***********************//
//CHECK FOR INT OVERFLOW
//***********************//
int n = sc.nextInt();
int[][] arr = new int[n][];
long sums[] = new long[n];
HashMap<Integer, Integer> map1 = new HashMap<>();
HashMap<Integer, Integer> map2 = new HashMap<>();
ArrayList<Integer> arrs = new ArrayList<Integer>();
arrs.add(0);
int incc = 1;
long sum = 0;
for(int i = 0; i < n; i++) {
int k = sc.nextInt();
arr[i] = new int[k];
for(int j = 0; j < k; j++) {
sum += (arr[i][j] = sc.nextInt());
sums[i] += arr[i][j];
map1.put(arr[i][j], incc++);
map2.put(arr[i][j], i);
arrs.add(arr[i][j]);
}
}
if(sum % n != 0) {
pw.println("No");
return;
}
cycle[] masktocyc = new cycle[1<<n];
long goal = sum / n;
ArrayList<cycle> cycs = new ArrayList<cycle>();
int[] graph = new int[incc];
l:
for(int i = 1; i < incc; i++) {
cycle c = new cycle();
int curr = i;
int val = arrs.get(i);
int ind = map2.get(val);
if(graph[i] != 0) continue;
do {
long ch = (goal - sums[ind] + val);
if(ch > inf || ch < -inf || !map1.containsKey((int)ch)) {
continue l;
}
val = (int)(ch);
graph[curr] = map1.get(val);
//pw.println(curr + " - " + map1.get(ch));
curr = map1.get(val);
c.add(ind, val);
ind = map2.get(val);
}
while(graph[curr] == 0);
for(tup x : c.arr) {
if(sums[x.a] - arrs.get(curr) + x.b == goal) break;
c.mask -= (1<<x.a);
x.a = -inf;
x.b = -inf;
}
int[] freq = new int[15];
for(tup x : c.arr) {
if(x.a >= 0) {
freq[x.a]++;
if(freq[x.a] > 1) continue l;
}
}
//for(tup x : c.arr) System.out.printf("%d %d%n", x.a, x.b);
//System.out.println(c.mask);
cycs.add(c);
masktocyc[c.mask] = c;
}
ArrayList<cycle>[] dp = new ArrayList[1<<n];
for(int m = 0; m < (1<<n); m++) {
dp[m] = new ArrayList<cycle>();
if(masktocyc[m] != null) {
dp[m].add(masktocyc[m]);
continue;
}
for(int s = m; s > 0; s = (s - 1) & m) {
if(dp[s].size() > 0 && dp[m ^ s].size() > 0) {
dp[m].addAll(dp[s]);
dp[m].addAll(dp[m ^ s]);
break;
}
}
}
if(dp[(1<<n) - 1].size() > 0) {
pw.println("Yes");
int[] ans1 = new int[n];
int[] ans2 = new int[n];
for(cycle x : dp[(1<<n) - 1]) {
for(tup y : x.arr) {
if(y.b != -inf) {
ans1[map2.get(y.b)] = y.a+1;
ans2[map2.get(y.b)] = y.b;
}
}
}
for(int i = 0; i < n; i++) {
pw.printf("%d %d%n", ans2[i], ans1[i]);
}
}
else pw.println("No");
}
static class cycle {
ArrayList<tup> arr = new ArrayList<>();
int mask = 0;
public cycle(){}
void add(int ind, int val) {
arr.add(new tup(ind, val));
mask += (1<<ind);
}
}
}
static long binpow(long a, long b, long m) {
a %= m;
long res = 1;
while (b > 0) {
if ((b & 1) == 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
static void sort(int[] x){
shuffle(x);
Arrays.sort(x);
}
static void sort(long[] x){
shuffle(x);
Arrays.sort(x);
}
static class tup implements Comparable<tup>{
int a, b;
tup(int a,int b){
this.a=a;
this.b=b;
}
@Override
public int compareTo(tup o){
return Integer.compare(o.b,b);
}
}
static void shuffle(int[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(i + 1);
int temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
static void shuffle(long[] a) {
Random get = new Random();
for (int i = 0; i < a.length; i++) {
int r = get.nextInt(i + 1);
long temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastReader(String s) throws FileNotFoundException {
br = new BufferedReader(new FileReader(new File(s)));
}
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;
}
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Map;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastScanner in = new FastScanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
int n;
long neededSum;
long[] sums;
Map<Long, Integer> where;
public void solve(int testNumber, FastScanner in, PrintWriter out) {
n = in.nextInt();
int[][] a = new int[n][];
neededSum = 0;
sums = new long[n];
for (int i = 0; i < n; i++) {
int k = in.nextInt();
a[i] = new int[k];
for (int j = 0; j < k; j++) {
a[i][j] = in.nextInt();
neededSum += a[i][j];
sums[i] += a[i][j];
}
}
if (neededSum % n != 0) {
out.println("No");
return;
}
neededSum /= n;
where = new HashMap<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].length; j++) {
where.put((long) a[i][j], i);
}
}
Entry[][] cycleSol = new Entry[1 << n][];
List<Entry> sol = new ArrayList<>();
for (int i = 0; i < n; i++) {
for (int x : a[i]) {
search(i, i, x, x, 0, 0, sol, cycleSol);
}
}
boolean[] can = new boolean[1 << n];
int[] via = new int[1 << n];
can[0] = true;
for (int mask = 0; mask < 1 << n; mask++) {
for (int submask = mask; submask > 0; submask = (submask - 1) & mask) {
if (cycleSol[submask] != null && can[mask ^ submask]) {
can[mask] = true;
via[mask] = submask;
}
}
}
if (!can[(1 << n) - 1]) {
out.println("No");
return;
}
int[][] ans = new int[n][2];
for (int mask = (1 << n) - 1; mask > 0; ) {
int sm = via[mask];
mask ^= sm;
for (Entry e : cycleSol[sm]) {
ans[e.from][0] = e.what;
ans[e.from][1] = e.to + 1;
}
}
out.println("Yes");
for (int i = 0; i < n; i++) {
out.println(ans[i][0] + " " + ans[i][1]);
}
}
private void search(int start, int cur, long fromStart, long fromCur, int hasIn, int hasOut, List<Entry> sol, Entry[][] cycleSol) {
for (int i = start; i < n; i++) {
if ((hasIn & (1 << i)) > 0) {
continue;
}
if ((hasOut & (1 << cur)) > 0) {
continue;
}
long fromI = sums[i] + fromCur - neededSum;
Integer w = where.get(fromI);
if (w == null || w != i) {
continue;
}
sol.add(new Entry(cur, i, (int) fromCur));
int nHasIn = hasIn | (1 << i);
int nHasOut = hasOut | (1 << cur);
if (i == start && fromI == fromStart) {
cycleSol[nHasOut] = sol.toArray(new Entry[0]);
}
search(start, i, fromStart, fromI, nHasIn, nHasOut, sol, cycleSol);
sol.remove(sol.size() - 1);
}
}
class Entry {
int from;
int to;
int what;
Entry(int from, int to, int what) {
this.from = from;
this.to = to;
this.what = what;
}
public String toString() {
return from + " " + to + " " + what;
}
}
}
static class FastScanner {
private BufferedReader in;
private StringTokenizer st;
public FastScanner(InputStream stream) {
in = new BufferedReader(new InputStreamReader(stream));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
String rl = in.readLine();
if (rl == null) {
return null;
}
st = new StringTokenizer(rl);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
//package round599;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Map;
public class C {
InputStream is;
PrintWriter out;
String INPUT = "";
void solve()
{
int n = ni();
int[][] a = new int[n][];
Map<Long, Long> ci = new HashMap<>();
long[] sums = new long[n];
for(int i = 0;i < n;i++){
int K = ni();
a[i] = na(K);
for(int j = 0;j < K;j++){
ci.put((long)a[i][j], (long)i<<32|j);
sums[i] += a[i][j];
}
}
long S = 0;
for(long v : sums){
S += v;
}
if(S % n != 0){
out.println("No");
return;
}
S /= n;
int[] offsets = new int[n+1];
for(int i = 0;i < n;i++){
offsets[i+1] = offsets[i] + a[i].length;
}
int m = offsets[n];
int[] f = new int[m];
Arrays.fill(f, -1);
for(int i = 0;i < n;i++){
for(int j = 0;j < a[i].length;j++){
long T = a[i][j] + S - sums[i];
if(ci.containsKey(T)){
long code = ci.get(T);
int from = offsets[i] + j;
int to = offsets[(int)(code>>>32)] + (int)code;
if(from != to && i == (int)(code>>>32))continue;
f[from] = to;
}
}
}
int[][] cs = getCycles(f);
int[][] zcs = new int[1<<n][];
for(int[] c : cs){
int ptn = 0;
for(int k : c){
int ind = Arrays.binarySearch(offsets, k);
if(ind < 0)ind = -ind-2;
ptn |= 1<<ind;
}
if(Integer.bitCount(ptn) != c.length)continue;
zcs[ptn] = c;
}
boolean[] dp = new boolean[1<<n];
dp[0] = true;
for(int i = 1;i < 1<<n;i++){
if(zcs[i] != null){
int mask = (1<<n)-1^i;
for(int j = mask;j >= 0;j--){ j &= mask;
dp[i|j] |= dp[j];
} // include j=0
}
}
if(dp[(1<<n)-1]){
int[] vals = new int[n];
int[] tos = new int[n];
int cur = (1<<n)-1;
inner:
while(cur > 0){
for(int k = cur;k >= 0;k--){
k &= cur;
if(dp[cur^k] && zcs[k] != null){
for(int l = 0;l < zcs[k].length;l++){
int nl = (l+zcs[k].length-1) % zcs[k].length;
int fclus = Arrays.binarySearch(offsets, zcs[k][l]);
int tclus = Arrays.binarySearch(offsets, zcs[k][nl]);
if(fclus < 0)fclus = -fclus-2;
if(tclus < 0)tclus = -tclus-2;
int val = a[fclus][zcs[k][l]-offsets[fclus]];
vals[fclus] = val;
tos[fclus] = tclus;
}
cur ^= k;
continue inner;
}
}
}
out.println("Yes");
for(int i = 0;i < n;i++){
out.println(vals[i] + " " + (tos[i]+1));
}
// for(int i = 0;i < n;i++){
// sums[i] -= vals[i];
// sums[tos[i]] += vals[i];
// }
//
// for(int i = 0;i < n;i++){
// assert sums[i] == S;
// }
}else{
out.println("No");
}
}
int[][] getCycles(int[] f)
{
int n = f.length;
int[][] ret = new int[n][];
boolean[] ved = new boolean[n];
int[] touched = new int[n];
Arrays.fill(touched, -1);
int[] path = new int[n];
int q = 0;
outer:
for(int i = 0;i < n;i++){
int p = 0;
for(int j = i;j != -1;j = f[j]){
if(touched[j] != -1){
ret[q++] = Arrays.copyOfRange(path, touched[j], p);
break;
}
if(ved[j])break;
touched[j] = p;
path[p++] = j;
ved[j] = true;
}
for(int k = 0;k < p;k++){
touched[path[k]] = -1;
}
}
return Arrays.copyOf(ret, q);
}
void run() throws Exception
{
is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception { new C().run(); }
private byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
private int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private double nd() { return Double.parseDouble(ns()); }
private char nc() { return (char)skip(); }
private String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
| np | 1242_C. Sum Balance | CODEFORCES |
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Random;
import java.util.TreeSet;
public final class CF_599_D1_C
{
static boolean verb=true;
static void log(Object X){if (verb) System.err.println(X);}
static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");System.err.println("");}}
static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+" ");System.err.println("");}}
static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+" ");System.err.println("");}}
static void logWln(Object X){if (verb) System.err.print(X);}
static void info(Object o){ System.out.println(o);}
static void output(Object o){outputWln(""+o+"\n"); }
static void outputWln(Object o){try {out.write(""+ o);} catch (Exception e) {}}
static long mod=1000000007;
// Global vars
static BufferedWriter out;
static InputReader reader;
static class Composite implements Comparable<Composite>{
int idx;
int v;
public int compareTo(Composite X) {
if (v!=X.v)
return v-X.v;
return idx-X.idx;
}
public Composite(int idx, int v) {
this.idx = idx;
this.v = v;
}
}
static void test() {
log("testing");
log("done");
}
static void explore(ArrayList<Integer>[] components,ArrayList<Integer> bob,int[][] move,ArrayList<int[]>[] howto,int[][] list) {
for (int x:bob) {
if (components[x].size()==1) {
int tm[]=howto[x].get(0);
int L=howto[x].size();
howto[x].add(tm);
for (int i=0;i<L;i++) {
int[] cur=howto[x].get(i);
int[] nx=howto[x].get(i+1);
int a=cur[0];
int a2=nx[0];
int b2=nx[1];
move[a2][0]=list[a2][b2];
move[a2][1]=a;
}
} else {
explore(components,components[x],move,howto,list);
}
}
}
static void process() throws Exception {
//arrayTest();
out = new BufferedWriter(new OutputStreamWriter(System.out));
reader = new InputReader(System.in);
int k=reader.readInt();
int[][] list=new int[k][];
long[] sum=new long[k];
int[] L=new int[k];
HashMap<Integer,int[]> target=new HashMap<Integer,int[]>();
long tot=0;
for (int i=0;i<k;i++) {
L[i]=reader.readInt();
list[i]=new int[L[i]];
for (int j=0;j<L[i];j++) {
list[i][j]=reader.readInt();
sum[i]+=list[i][j];
target.put(list[i][j],new int[] {i,j});
}
tot+=sum[i];
}
int MX=1<<k;
int AX=1000000001;
ArrayList<int[]>[] howto=new ArrayList[MX];
log("ok with the data");
if (tot%k!=0) {
output("No");
} else {
tot/=k;
for (int i=0;i<k;i++) {
if (sum[i]==tot) {
//log("nothing to do for i:"+i);
// nothing to do
int mask=1<<i;
ArrayList<int[]> cand=new ArrayList<int[]>();
cand.add(new int[] {i,0});
howto[mask]=cand;
} else
for (int j=0;j<L[i];j++) {
int u=i;
int v=j;
boolean ok=true;
int src_u=u;
int src_v=v;
int mask=0;
boolean goon=true;
ArrayList<int[]> cand=new ArrayList<int[]>();
//log("start loop");
while (goon) {
cand.add(new int[] {u,v});
//log("u:"+u+" v:"+v);
ok=false;
goon=false;
long need=tot-((long)sum[u]-(long)list[u][v]);
if (Math.abs(need)<=AX) {
//log("need:"+need);
int nd=(int)need;
int[] tm=target.get(nd);
//log("tm:"+tm);
if (tm!=null) {
//log("can find successor");
int nxu=tm[0];
int nxv=tm[1];
if ((mask&(1<<nxu))==0) {
mask|=1<<nxu;
if (nxu==src_u) {
// looping back to source
if (nxv==src_v)
ok=true;
} else {
u=nxu;
v=nxv;
ok=true;
goon=true;
}
}
}
}
}
if (ok) {
if (howto[mask]==null) {
howto[mask]=cand;
}
}
}
}
log("step 1 done");
// now mask
ArrayList[] components=new ArrayList[MX];
for (int m=0;m<MX;m++) {
if (howto[m]!=null) {
//String s=Integer.toBinaryString(m);
//while (s.length()<k)
// s="0"+s;
//log("found mask:"+s);
components[m]=new ArrayList<Integer>();
components[m].add(m);
}
}
int[] msk=new int[MX];
int w=0;
for (int a=0;a<MX;a++) {
if (howto[a]!=null) {
ArrayList<Integer> add=new ArrayList<Integer>();
int ww=w;
for (int i=0;i<ww;i++) {
int b=msk[i];
if ((b&a)==0) {
int c=b|a;
//log("creating c:"+c+" ");
if (components[c]==null ) {
components[c]=new ArrayList<Integer>();
components[c].add(a);
components[c].add(b);
msk[w++]=c;
}
}
}
msk[w++]=a;
}
}
//log("msk:"+msk);
//log(components[MX-1]);
if (components[MX-1]!=null) {
output("Yes");
int[][] move=new int[k][2];
explore(components,components[MX-1],move,howto,list);
for (int i=0;i<k;i++) {
output(move[i][0]+" "+(move[i][1]+1));
}
} else {
output("No");
}
}
try {
out.close();
} catch (Exception e) {
}
}
public static void main(String[] args) throws Exception {
process();
}
static final class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
private int read() throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read(buf);
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public final String readString() throws IOException {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.append((char) c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public final int readInt() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
int res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
public final long readLong() throws IOException {
int c = read();
boolean neg = false;
while (isSpaceChar(c)) {
c = read();
}
char d = (char) c;
// log("d:"+d);
if (d == '-') {
neg = true;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
// log("res:"+res);
if (neg)
return -res;
return res;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.BiFunction;
public class Main{
static Scanner scn = new Scanner(System.in);
static FastScanner sc = new FastScanner();
static Mathplus mp = new Mathplus();
static PrintWriter ot = new PrintWriter(System.out);
static Random rand = new Random();
static int mod = 1000000007;
static long inf = (long)1e17;
static int[] dx = {0,1,0,-1};
static int[] dy = {1,0,-1,0};
static int max;
public static void main(String[] args) {
int N = sc.nextInt();
ArrayList<Integer>[] l = new ArrayList[N];
HashMap<Long,Integer> map = new HashMap<Long,Integer>();
long sum = 0;
long[] s = new long[N];
for(int i=0;i<N;i++) {
l[i] = new ArrayList<Integer>();
int n = sc.nextInt();
for(int j=0;j<n;j++) {
int a = sc.nextInt();
map.put((long)a, i);
s[i] += a;
sum += a;
l[i].add(a);
}
}
if(Math.abs(sum)%N!=0) {
System.out.println("NO");
return;
}
long make = sum/N;
boolean[] dp = new boolean[(1<<N)];
int[] first = new int[(1<<N)];
int[] bef = new int[(1<<N)];
Arrays.fill(first,mod);
for(int i=0;i<N;i++) {
for(int a:l[i]) {
int used = 0;
boolean f = true;
long now = a;
int see = i;
while(true) {
long next = make-(s[see]-now);
if(next==a) {
break;
}
if(!map.containsKey(next)) {
f = false;
break;
}else {
int k = map.get(next);
if(mp.contains(used,k)&&k!=i) {
f = false;
break;
}else {
used = mp.bitadd(used,k);
now = next;
see = k;
}
}
}
if(f) {
dp[mp.bitadd(used,i)] = true;
first[mp.bitadd(used,i)] = a;
}
}
}
dp[0] = true;
for(int i=1;i<(1<<N);i++) {
for(int j=i;j>0;j=(j-1)&i) {
if(dp[i^j]&&dp[j]) {
dp[i]=true;
bef[i] = j;
}
}
}
if(!dp[(1<<N)-1]) {
System.out.println("NO");
}else {
System.out.println("YES");
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
int[] ans1 = new int[N];
int[] ans2 = new int[N];
q.add((1<<N)-1);
while(!q.isEmpty()) {
int Q = q.poll();
if(first[Q]==mod) {
q.add(bef[Q]);
q.add(Q^bef[Q]);
}else {
int a = first[Q];
long now = a;
int befo = map.get((long)a);
while(true) {
long next = make-(s[befo]-now);
if(next==a) {
int k = map.get(next);
ans1[k] = (int)next;
ans2[k] = befo;
break;
}
int k = map.get(next);
ans1[k] = (int)next;
ans2[k] = befo;
now = next;
befo = k;
}
}
}
for(int i=0;i<N;i++) {
System.out.println(ans1[i]+" "+(ans2[i]+1));
}
}
}
}
class GridGraph extends Graph{
int N;
int M;
String[] S;
HashMap<Character,Integer> map;
GridGraph(int n,int m,String[] s,char[] c){
super(n*m);
N = n;
M = m;
S = s;
map = new HashMap<Character,Integer>();
for(int i=0;i<n-1;i++) {
for(int j=0;j<m;j++) {
if(S[i].charAt(j)!='#'&&S[i+1].charAt(j)!='#') {
addEdge(toint(i,j),toint(i+1,j));
addEdge(toint(i+1,j),toint(i,j));
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m-1;j++) {
if(S[i].charAt(j)!='#'&&S[i].charAt(j+1)!='#') {
addEdge(toint(i,j),toint(i,j+1));
addEdge(toint(i,j+1),toint(i,j));
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i].charAt(j)==c[k])map.put(c[k],toint(i,j));
}
}
}
}
int toint(int i,int j) {
return i*M+j;
}
}
class BetterGridGraph{
int N;
int M;
char[][] S;
HashMap<Character,Integer> map;
int[] dx = {0,1,0,-1};
int[] dy = {1,0,-1,0};
char w;
char b = '#';
BetterGridGraph(int n,int m,String[] s,char[] c){
N = n;
M = m;
for(int i=0;i<s.length;i++) {
S[i] = s[i].toCharArray();
}
map = new HashMap<Character,Integer>();
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.put(c[k],toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,char[][] s,char[] c){
N = n;
M = m;
S = s;
map = new HashMap<Character,Integer>();
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.put(c[k],toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,String[] s,char[] c,char W,char B){
N = n;
M = m;
for(int i=0;i<s.length;i++) {
S[i] = s[i].toCharArray();
}
w = W;
b = B;
map = new HashMap<Character,Integer>();
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.put(c[k],toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,char[][] s,char[] c,char W,char B){
N = n;
M = m;
S = s;
w = W;
b = B;
map = new HashMap<Character,Integer>();
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.put(c[k],toint(i,j));
}
}
}
}
int toint(int i,int j) {
return i*M+j;
}
int[] bfs(char C) {
int s = map.get(C);
int[] L = new int[N*M];
for(int i=0;i<N*M;i++){
L[i] = -1;
}
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return L;
}
int[][] bfs2(char C,int K){
int s = map.get(C);
int[][] L = new int[N*M][K+1];
for(int i=0;i<N*M;i++){
for(int j=0;j<=K;j++)
L[i][j] = 1000000007;
}
L[s][0] = 0;
ArrayDeque<IntIntPair> Q = new ArrayDeque<IntIntPair>();
Q.add(new IntIntPair(s,0));
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
IntIntPair v = Q.poll();
for(int i=0;i<4;i++){
int x = v.a/M;
int y = v.a%M;
int h = v.b;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int ni = toint(nx,ny);
int nh = S[nx][ny]==w?h+1:h;
if(nh>K) continue;
if(L[ni][nh]==1000000007){
L[ni][nh] = L[v.a][h] + 1;
Q.add(new IntIntPair(ni,nh));
}
}
}
}
for(int i=0;i<N*M;i++) {
for(int j=1;j<=K;j++) {
L[i][j] = Math.min(L[i][j],L[i][j-1]);
}
}
return L;
}
}
class StringManager{
ArrayList<Character> S;
static Mathplus mp;
static boolean calced;
static int base;
static long baserev;
ArrayList<Long> l;
StringManager(String s){
S = new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
S.add(s.charAt(i));
}
if(!calced) {
calced = true;
mp = new Mathplus();
base = 1000003;
baserev = mp.rev(base);
mp.buildpow(base,1000050);
mp.buildrevpow((int) baserev,1000050);
}
l = new ArrayList<Long>();
l.add((long)S.get(0));
for(int i=1;i<S.size();i++) {
char c = S.get(i);
l.add((l.get(i-1) + mp.pow[i] * c)%mp.mod);
}
}
void add(char C){
int i = S.size();
S.add(C);
l.add((l.get(i-1) + mp.pow[i] * C)%mp.mod);
}
long gethash(int le,int ri) {
long res = l.get(ri);
if(le!=0) {
res -= l.get(le-1);
res += mp.mod;
res %= mp.mod;
res *= mp.revpow[le];
res %= mp.mod;
}
return res;
}
}
class Trie{
int nodenumber = 1;
ArrayList<TrieNode> l;
Trie(){
l = new ArrayList<TrieNode>();
l.add(new TrieNode());
}
void add(String S,int W){
int now = 0;
for(int i=0;i<S.length();i++) {
TrieNode n = l.get(now);
char c = S.charAt(i);
if(n.Exist[c-'a']!=-1) {
now = n.Exist[c-'a'];
}else {
l.add(new TrieNode());
n.Exist[c-'a'] = nodenumber;
now = nodenumber;
nodenumber++;
}
}
l.get(now).weight = W;
}
void find(String S,int i,int[] dp) {
int now = 0;
dp[i+1] = Math.max(dp[i],dp[i+1]);
for(int j=0;;j++) {
TrieNode n = l.get(now);
dp[i+j] = Math.max(dp[i+j],dp[i]+n.weight);
int slook = i+j;
if(slook>=S.length())return;
char c = S.charAt(slook);
if(n.Exist[c-'a']==-1)return;
now = n.Exist[c-'a'];
}
}
}
class TrieNode{
int[] Exist = new int[26];
int weight = 0;
TrieNode(){
for(int i=0;i<26;i++) {
Exist[i] = -1;
}
}
}
class SizeComparator implements Comparator<Edge>{
int[] size;
SizeComparator(int[] s) {
size = s;
}
public int compare(Edge o1, Edge o2) {
return size[o1.to]-size[o2.to];
}
}
class ConvexHullTrick {
long[] A, B;
int len;
public ConvexHullTrick(int n) {
A = new long[n];
B = new long[n];
}
private boolean check(long a, long b) {
return (B[len - 2] - B[len - 1]) * (a - A[len - 1]) >= (B[len - 1] - b) * (A[len - 1] - A[len - 2]);
}
public void add(long a, long b) {
while (len >= 2 && check(a, b)) {
len--;
}
A[len] = a;
B[len] = b;
len++;
}
public long query(long x) {
int l = -1, r = len - 1;
while (r - l > 1) {
int mid = (r + l) / 2;
if (get(mid,x)>=get(mid+1,x)) {
l = mid;
} else {
r = mid;
}
}
return get(r,x);
}
private long get(int k, long x) {
return A[k] * x + B[k];
}
}
class Range{
int l;
int r;
int length;
Range(int L,int R){
l = L;
r = R;
length = R-L+1;
}
boolean isIn(int x) {
return (l<=x&&x<=r);
}
}
class LeftComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return P.l-Q.l;
}
}
class RightComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return P.r-Q.r;
}
}
class LengthComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return P.length-Q.length;
}
}
class SegmentTree<T,E>{
int N;
BiFunction<T,T,T> f;
BiFunction<T,E,T> g;
T d1;
ArrayList<T> dat;
SegmentTree(BiFunction<T,T,T> F,BiFunction<T,E,T> G,T D1,T[] v){
int n = v.length;
f = F;
g = G;
d1 = D1;
init(n);
build(v);
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new ArrayList<T>();
}
void build(T[] v) {
for(int i=0;i<2*N;i++) {
dat.add(d1);
}
for(int i=0;i<v.length;i++) {
dat.set(N+i-1,v[i]);
}
for(int i=N-2;i>=0;i--) {
dat.set(i,f.apply(dat.get(i*2+1),dat.get(i*2+2)));
}
}
void update(int k,E a) {
k += N-1;
dat.set(k,g.apply(dat.get(k),a));
while(k>0){
k = (k-1)/2;
dat.set(k,f.apply(dat.get(k*2+1),dat.get(k*2+2)));
}
}
T query(int a,int b, int k, int l ,int r) {
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
T vl = query(a,b,k*2+1,l,(l+r)/2);
T vr = query(a,b,k*2+2,(l+r)/2,r);
return f.apply(vl, vr);
}
T query(int a,int b){
return query(a,b,0,0,N);
}
}
class LazySegmentTree<T,E> extends SegmentTree<T,E>{
BiFunction<E,E,E> h;
BiFunction<E,Integer,E> p = (E a,Integer b) ->{return a;};
E d0;
ArrayList<E> laz;
LazySegmentTree(BiFunction<T,T,T> F,BiFunction<T,E,T> G,BiFunction<E,E,E> H,T D1,E D0,T[] v){
super(F,G,D1,v);
int n = v.length;
h = H;
d0 = D0;
Init(n);
}
void build() {
}
void Init(int n){
laz = new ArrayList<E>();
for(int i=0;i<2*N;i++) {
laz.add(d0);
}
}
void eval(int len,int k) {
if(laz.get(k).equals(d0)) return;
if(k*2+1<N*2-1) {
laz.set(k*2+1,h.apply(laz.get(k*2+1),laz.get(k)));
laz.set(k*2+2,h.apply(laz.get(k*2+2),laz.get(k)));
}
dat.set(k,g.apply(dat.get(k), p.apply(laz.get(k), len)));
laz.set(k,d0);
}
T update(int a,int b,E x,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) {
return dat.get(k);
}
if(a<=l&&r<=b) {
laz.set(k,h.apply(laz.get(k),x));
return g.apply(dat.get(k),p.apply(laz.get(k),r-l));
}
T vl = update(a,b,x,k*2+1,l,(l+r)/2);
T vr = update(a,b,x,k*2+2,(l+r)/2,r);
dat.set(k,f.apply(vl,vr));
return dat.get(k);
}
T update(int a,int b,E x) {
return update(a,b,x,0,0,N);
}
T query(int a,int b,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
T vl = query(a,b,k*2+1,l,(l+r)/2);
T vr = query(a,b,k*2+2,(l+r)/2,r);
return f.apply(vl, vr);
}
T query(int a,int b){
return query(a,b,0,0,N);
}
}
class AddSumSegmentTree{
int N;
int d1;
ArrayList<Integer> dat;
AddSumSegmentTree(int[] v){
int n = v.length;
init(n);
build(v);
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new ArrayList<Integer>();
}
void build(int[] v) {
for(int i=0;i<2*N;i++) {
dat.add(d1);
}
for(int i=0;i<v.length;i++) {
dat.set(N+i-1,v[i]);
}
for(int i=N-2;i>=0;i--) {
dat.set(i,dat.get(i*2+1)+dat.get(i*2+2));
}
}
void update(int k,int a) {
k += N-1;
dat.set(k,dat.get(k)+a);
while(k>0){
k = (k-1)/2;
dat.set(k,dat.get(k*2+1)+dat.get(k*2+2));
}
}
int query(int a,int b, int k, int l ,int r) {
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
int vl = query(a,b,k*2+1,l,(l+r)/2);
int vr = query(a,b,k*2+2,(l+r)/2,r);
return vl+vr;
}
int query(int a,int b){
return query(a,b,0,0,N);
}
}
class AddSumLazySegmentTree {
int N;
long[] dat;
long[] laz;
AddSumLazySegmentTree(long[] v){
init(v.length);
for(int i=0;i<v.length;i++) {
dat[N+i-1]=v[i];
}
for(int i=N-2;i>=0;i--) {
dat[i]=dat[i*2+1]+dat[i*2+2];
}
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new long[2*N];
laz = new long[2*N];
}
void eval(int len,int k) {
if(laz[k]==0) return;
if(k*2+1<N*2-1) {
laz[k*2+1] += laz[k];
laz[k*2+2] += laz[k];
}
dat[k] += laz[k] * len;
laz[k] = 0;
}
long update(int a,int b,long x,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) {
return dat[k];
}
if(a<=l&&r<=b) {
laz[k] += x;
return dat[k]+laz[k]*(r-l);
}
long vl = update(a,b,x,k*2+1,l,(l+r)/2);
long vr = update(a,b,x,k*2+2,(l+r)/2,r);
return dat[k] = vl+vr;
}
long update(int a,int b,long x) {
return update(a,b,x,0,0,N);
}
long query(int a,int b,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) return 0;
if(a<=l&&r<=b) return dat[k];
long vl = query(a,b,k*2+1,l,(l+r)/2);
long vr = query(a,b,k*2+2,(l+r)/2,r);
return vl+vr;
}
long query(int a,int b){
return query(a,b,0,0,N);
}
}
class BinaryIndexedTree{
int[] val;
BinaryIndexedTree(int N){
val = new int[N+1];
}
long sum(int i) {
if(i==0)return 0;
long s = 0;
while(i>0) {
s += val[i];
i -= i & (-i);
}
return s;
}
void add(int x,int i) {
if(i==0)return;
while(i<val.length){
val[i] += x;
i += i & (-i);
}
}
}
class UnionFindTree {
int[] root;
int[] rank;
int[] size;
int[] edge;
int num;
UnionFindTree(int N){
root = new int[N];
rank = new int[N];
size = new int[N];
edge = new int[N];
num = N;
for(int i=0;i<N;i++){
root[i] = i;
size[i] = 1;
}
}
public boolean isRoot(int x) {
return x==find(x);
}
public int extraEdge(int x) {
int r = find(x);
return edge[r] - size[r] + 1;
}
public int find(int x){
if(root[x]==x){
return x;
}else{
return find(root[x]);
}
}
public void unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
edge[x]++;
return;
}else{
num--;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
edge[y] += edge[x]+1;
}else{
root[y] = x;
size[x] += size[y];
edge[x] += edge[y]+1;
if(rank[x]==rank[y]){
rank[x]++;
}
}
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class ParticalEternalLastingUnionFindTree extends UnionFindTree{
int[] time;
int now;
ParticalEternalLastingUnionFindTree(int N){
super(N);
time = new int[N];
for(int i=0;i<N;i++) {
time[i] = 1000000007;
}
}
public int find(int t,int i) {
if(time[i]>t) {
return i;
}else {
return find(t,root[i]);
}
}
public void unite(int x,int y,int t) {
now = t;
x = find(t,x);
y = find(t,y);
if(x==y)return;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
time[x] = t;
}else{
root[y] = x;
size[x] += size[y];
if(rank[x]==rank[y]){
rank[x]++;
}
time[y] = t;
}
}
public int sametime(int x,int y) {
if(find(now,x)!=find(now,y)) return -1;
int ok = now;
int ng = 0;
while(ok-ng>1) {
int mid = (ok+ng)/2;
if(find(mid,x)==find(mid,y)) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
}
class Graph {
ArrayList<Edge>[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
Graph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++){
list[i] = new ArrayList<Edge>();
}
}
void addEdge(int a,int b){
list[a].add(new Edge(b,1));
}
void addWeightedEdge(int a,int b,long c){
list[a].add(new Edge(b,c));
}
void addEgdes(int[] a,int[] b){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],1));
}
}
void addWeighterEdges(int[] a ,int[] b ,int[] c){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],c[i]));
}
}
long[][] bfs(int s){
long[][] L = new long[2][size];
for(int i=0;i<size;i++){
L[0][i] = -1;
L[1][i] = -1;
}
L[0][s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[0][w]==-1){
L[0][w] = L[0][v] + c;
L[1][w] = v;
Q.add(w);
}
}
}
return L;
}
long[] bfs2(int[] d,int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int p = 0;
L[s] = 0;
d[s] = p;
p++;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[w]==-1){
d[w] = p;
p++;
L[w] = L[v] + c;
Q.add(w);
}
}
}
return L;
}
int[] isTwoColor(){
int[] L = new int[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
L[0] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(0);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
if(L[w]==-1){
L[w] = 1-L[v];
Q.add(w);
}else{
if(L[v]+L[w]!=1){
L[0] = -2;
}
}
}
}
return L;
}
long[] dijkstra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntSampleComparator());
Q.add(new LongIntPair(0,s));
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
if(L[D.to]==-1||L[D.to]>L[C.b]+D.cost) {
L[D.to]=L[C.b]+D.cost;
Q.add(new LongIntPair(L[C.b]+D.cost,D.to));
}
}
}
}
return L;
}
ArrayList<Graph> makeapart(){
ArrayList<Graph> ans = new ArrayList<Graph>();
boolean[] b = new boolean[size];
int[] num = new int[size];
for(int i=0;i<size;i++){
if(b[i])continue;
int sz = 0;
ArrayList<Integer> l = new ArrayList<Integer>();
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(i);
b[i] = true;
while(!Q.isEmpty()){
int v = Q.poll();
num[v] = sz;
sz++;
l.add(v);
for(Edge e:list[v]){
if(!b[e.to]){
Q.add(e.to);
b[e.to] = true;
}
}
}
Graph H = new Graph(sz);
for(int e:l){
for(Edge E:list[e]){
H.addWeightedEdge(num[e],num[E.to],E.cost);
}
}
ans.add(H);
}
return ans;
}
long[] bellmanFord(int s) {
long inf = 1000000000;
inf *= inf;
long[] d = new long[size];
boolean[] n = new boolean[size];
d[s] = 0;
for(int i=1;i<size;i++){
d[i] = inf;
d[i] *= d[i];
}
for(int i=0;i<size-1;i++){
for(int j=0;j<size;j++){
for(Edge E:list[j]){
if(d[j]!=inf&&d[E.to]>d[j]+E.cost){
d[E.to]=d[j]+E.cost;
}
}
}
}
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
for(Edge e:list[j]){
if(d[j]==inf) continue;
if(d[e.to]>d[j]+e.cost) {
d[e.to]=d[j]+e.cost;
n[e.to] = true;
}
if(n[j])n[e.to] = true;
}
}
}
for(int i=0;i<size;i++) {
if(n[i])d[i] = inf;
}
return d;
}
long[][] WarshallFloyd(long[][] a){
int n = a.length;
long[][] ans = new long[n][n];
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = a[i][j]==0?(long)1e16:a[i][j];
if(i==j)ans[i][j]=0;
}
}
for(int k=0;k<n;k++) {
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = Math.min(ans[i][j],ans[i][k]+ans[k][j]);
}
}
}
return ans;
}
long[] maxtra(int s,long l){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = -1;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator());
Q.add(new Pair(l,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.max(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long[] mintra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = s;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator().reversed());
Q.add(new Pair(s,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.min(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long Kruskal(){
long r = 0;
for(int i=0;i<size;i++) {
for(Edge e:list[i]) {
Edges.add(new LinkEdge(e.cost,i,e.to));
}
}
UnionFindTree UF = new UnionFindTree(size);
for(LinkEdge e:Edges){
if(e.a>=0&&e.b>=0) {
if(!UF.same(e.a,e.b)){
r += e.L;
UF.unite(e.a,e.b);
}
}
}
return r;
}
ArrayList<Integer> Kahntsort(){
ArrayList<Integer> ans = new ArrayList<Integer>();
PriorityQueue<Integer> q = new PriorityQueue<Integer>();
int[] in = new int[size];
for(int i=0;i<size;i++) {
for(Edge e:list[i])in[e.to]++;
}
for(int i=0;i<size;i++) {
if(in[i]==0)q.add(i);
}
while(!q.isEmpty()) {
int v = q.poll();
ans.add(v);
for(Edge e:list[v]) {
in[e.to]--;
if(in[e.to]==0)q.add(e.to);
}
}
for(int i=0;i<size;i++) {
if(in[i]>0)return new ArrayList<Integer>();
}
return ans;
}
RootedTree dfsTree(int i) {
int[] u = new int[size];
RootedTree r = new RootedTree(size);
dfsTree(i,u,r);
return r;
}
private void dfsTree(int i, int[] u, RootedTree r) {
u[i] = 1;
for(Edge e:list[i]) {
if(u[e.to]==0) {
r.list[i].add(e);
u[e.to] = 1;
dfsTree(e.to,u,r);
}
}
}
}
class Tree extends Graph{
public Tree(int N) {
super(N);
}
long[] tyokkei(){
long[][] a = bfs(0);
System.out.println();
int md = -1;
long m = 0;
for(int i=0;i<size;i++){
if(m<a[0][i]){
m = a[0][i];
md = i;
}
}
long[][] b = bfs(md);
int md2 = -1;
long m2 = 0;
for(int i=0;i<size;i++){
if(m2<b[0][i]){
m2 = b[0][i];
md2 = i;
}
}
long[] r = {m2,md,md2};
return r;
}
}
class RootedTree extends Graph{
RootedTree(int N){
super(N);
}
}
class LinkEdge{
long L;
int a ;
int b;
LinkEdge(long l,int A,int B){
L = l;
a = A;
b = B;
}
public boolean equals(Object o){
LinkEdge O = (LinkEdge) o;
return O.a==this.a&&O.b==this.b&&O.L==this.L;
}
public int hashCode(){
return Objects.hash(L,a,b);
}
}
class Edge{
int to;
long cost;
Edge(int a,long b){
to = a;
cost = b;
}
}
class LinkEdgeComparator implements Comparator<LinkEdge>{
public int compare(LinkEdge P, LinkEdge Q) {
long t = P.L-Q.L;
if(t==0){
if(P.a>Q.a){
return 1;
}else{
return P.b>Q.b?1:-1;
}
}
return t>=0?1:-1;
}
}
class Triplet{
long a;
long b;
long c;
Triplet(long p,long q,long r){
a = p;
b = q;
c = r;
}
public boolean equals(Object o){
Triplet O = (Triplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c?true:false;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class TripletComparator implements Comparator<Triplet>{
public int compare(Triplet P, Triplet Q) {
long t = P.a-Q.a;
if(t==0){
long tt = P.b-Q.b;
if(tt==0) {
if(P.c>Q.c) {
return 1;
}else if(P.c<Q.c){
return -1;
}else {
return 0;
}
}
return tt>0?1:-1;
}
return t>=0?1:-1;
}
}
class Pair{
long a;
long b;
Pair(long p,long q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
Pair O = (Pair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class SampleComparator implements Comparator<Pair>{
public int compare(Pair P, Pair Q) {
long t = P.a-Q.a;
if(t==0){
return P.b>=Q.b?1:-1;
}
return t>=0?1:-1;
}
}
class LongIntPair{
long a;
int b;
LongIntPair(long p,int q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
Pair O = (Pair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class LongIntSampleComparator implements Comparator<LongIntPair>{
public int compare(LongIntPair P, LongIntPair Q) {
long t = P.a-Q.a;
if(t==0){
if(P.b>Q.b){
return 1;
}else{
return -1;
}
}
return t>=0?1:-1;
}
}
class IntIntPair{
int a;
int b;
IntIntPair(int p,int q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
Pair O = (Pair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class IntIntSampleComparator implements Comparator<IntIntPair>{
public int compare(IntIntPair P, IntIntPair Q) {
int t = P.a-Q.a;
if(t==0){
return P.b-Q.b;
}
return t;
}
}
class DoublePair{
double a;
double b;
DoublePair(double p,double q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
Pair O = (Pair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class DDSampleComparator implements Comparator<DoublePair>{
public int compare(DoublePair P, DoublePair Q) {
return P.b-Q.b>=0?1:-1;
}
}
class DoubleTriplet{
double a;
double b;
double c;
DoubleTriplet(double p,double q,double r){
this.a = p;
this.b = q;
this.c = r;
}
public boolean equals(Object o){
DoubleTriplet O = (DoubleTriplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class FastScanner {
private final java.io.InputStream in = System.in;
private final byte[] b = new byte[1024];
private int p = 0;
private int bl = 0;
private boolean hNB() {
if (p<bl) {
return true;
}else{
p = 0;
try {
bl = in.read(b);
} catch (IOException e) {
e.printStackTrace();
}
if (bl<=0) {
return false;
}
}
return true;
}
private int rB() { if (hNB()) return b[p++]; else return -1;}
private static boolean iPC(int c) { return 33 <= c && c <= 126;}
private void sU() { while(hNB() && !iPC(b[p])) p++;}
public boolean hN() { sU(); return hNB();}
public String next() {
if (!hN()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = rB();
while(iPC(b)) {
sb.appendCodePoint(b);
b = rB();
}
return sb.toString();
}
public char nextChar() {
return next().charAt(0);
}
public long nextLong() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b=='-') {
m=true;
b=rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b - '0';
}else if(b == -1||!iPC(b)){
return (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int nextInt() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b == '-') {
m = true;
b = rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b-'0';
}else if(b==-1||!iPC(b)){
return (int) (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int[] nextInts(int n) {
int[] a = new int[n];
for(int i=0;i<n;i++) {
a[i] = nextInt();
}
return a;
}
public long[] nextLongs(int n) {
long[] a = new long[n];
for(int i=0;i<n;i++) {
a[i] = nextLong();
}
return a;
}
public int[][] nextIntses(int n,int m){
int[][] a = new int[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
a[i][j] = nextInt();
}
}
return a;
}
}
class Mathplus{
int mod = 1000000007;
long[] fac;
long[] revfac;
long[][] comb;
long[] pow;
long[] revpow;
boolean isBuild = false;
boolean isBuildc = false;
boolean isBuildp = false;
int mindex = -1;
int maxdex = -1;
int color(int[][] diff,int N) {
int[] val = new int[1<<N];
val[0] = 1;
for(int i=0;i<(1<<N);i++) {
for(int j=0;j<N;j++) {
if(contains(i,j)) {
if(val[bitremove(i,j)]==1) {
boolean b = true;
for(int k=0;k<N;k++) {
if(contains(i,k)&&diff[j][k]==1) {
b = false;
}
}
if(b)val[i] = 1;
}
break;
}
}
}
int[] dp = new int[1<<N];
Arrays.fill(dp,mod);;
dp[0] = 0;
for(int i=0;i<(1<<N);i++) {
for(int j=i;j>0;j=(j-1)&i) {
if(val[j]==1)dp[i]=Math.min(dp[i],dp[i^j]+1);
}
}
return dp[(1<<N)-1];
}
public DoubleTriplet Line(double x1,double y1,double x2,double y2) {
double a = y1-y2;
double b = x2-x1;
double c = x1*y2-x2*y1;
return new DoubleTriplet(a,b,c);
}
public double putx(DoubleTriplet T,double x) {
return -(T.a*x+T.c)/T.b;
}
public double puty(DoubleTriplet T,double y) {
return -(T.b*y+T.c)/T.a;
}
public double DistanceofPointandLine(DoublePair P,Triplet T) {
return Math.abs(P.a*T.a+P.b*T.b+T.c) / Math.sqrt(T.a*T.a+T.b*T.b);
}
public boolean cross(long ax, long ay, long bx, long by, long cx, long cy, long dx, long dy) {
long ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
long tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
long tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
long td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
public boolean dcross(double ax, double ay, double bx, double by, double cx, double cy, double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
void buildFac(){
fac = new long[10000003];
revfac = new long[10000003];
fac[0] = 1;
for(int i=1;i<=10000002;i++){
fac[i] = (fac[i-1] * i)%mod;
}
revfac[10000002] = rev(fac[10000002])%mod;
for(int i=10000001;i>=0;i--) {
revfac[i] = (revfac[i+1] * (i+1))%mod;
}
isBuild = true;
}
public long[] buildrui(int[] a) {
int n = a.length;
long[] ans = new long[n];
ans[0] = a[0];
for(int i=1;i<n;i++) {
ans[i] = ans[i-1] + a[i];
}
return ans;
}
public long[][] buildrui(int[][] a) {
int n = a.length;
int m = a[0].length;
long[][] ans = new long[n][m];
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] = a[i][j];
}
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] += ans[i][j-1] + ans[i-1][j] - ans[i-1][j-1];
}
}
return ans;
}
long divroundup(long n,long d) {
if(n==0)return 0;
return (n-1)/d+1;
}
public long sigma(long i) {
return i*(i+1)/2;
}
public int digit(long i) {
int ans = 1;
while(i>=10) {
i /= 10;
ans++;
}
return ans;
}
public int popcount(int i) {
int ans = 0;
while(i>0) {
ans += i%2;
i /= 2;
}
return ans;
}
public boolean contains(int S,int i) {return (S>>i&1)==1;}
public int bitremove(int S,int i) {return S&(~(1<<i));}
public int bitadd(int S,int i) {return S|(1<<i);}
public boolean isSubSet(int S,int T) {return (S-T)==(S^T);}
public boolean isDisjoint(int S,int T) {return (S+T)==(S^T);}
public int isBigger(int[] d, int i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(int[] d, int i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(long[] d, long i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(long[] d, long i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(ArrayList<Long> d, long i) {
int ok = d.size();
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(ArrayList<Long> d, long i) {
int ok = -1;
int ng = d.size();
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public HashSet<Integer> primetable(int m) {
HashSet<Integer> pt = new HashSet<Integer>();
for(int i=2;i<=m;i++) {
boolean b = true;
for(int d:pt) {
if(i%d==0) {
b = false;
break;
}
}
if(b) {
pt.add(i);
}
}
return pt;
}
public ArrayList<Integer> primetablearray(int m) {
ArrayList<Integer> al = new ArrayList<Integer>();
Queue<Integer> q = new ArrayDeque<Integer>();
for(int i=2;i<=m;i++) {
q.add(i);
}
boolean[] b = new boolean[m+1];
while(!q.isEmpty()) {
int e = q.poll();
if(!b[e]) {
al.add(e);
for(int j=1;e*j<=1000000;j++) {
b[e*j] = true;
}
}
}
return al;
}
public HashMap<Integer,Integer> hipPush(ArrayList<Integer> l){
HashMap<Integer,Integer> r = new HashMap<Integer,Integer>();
TreeSet<Integer> s = new TreeSet<Integer>();
for(int e:l)s.add(e);
int p = 0;
for(int e:s) {
r.put(e,p);
p++;
}
return r;
}
public TreeMap<Integer,Integer> thipPush(ArrayList<Integer> l){
TreeMap<Integer,Integer> r = new TreeMap<Integer,Integer>();
Collections.sort(l);
int b = -(mod+9393);
int p = 0;
for(int e:l) {
if(b!=e) {
r.put(e,p);
p++;
}
b=e;
}
return r;
}
long max(long[] a){
long M = 0;
for(int i=0;i<a.length;i++){
if(M<a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
int max(int[] a){
int M = 0;
for(int i=0;i<a.length;i++){
if(M<a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
long min(long[] a){
long m = Long.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
int min(int[] a){
int m = Integer.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
long sum(long[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long sum(int[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long gcd(long a, long b){
a = Math.abs(a);
b = Math.abs(b);
if(a==0)return b;
if(b==0)return a;
if(a%b==0) return b;
else return gcd(b,a%b);
}
int igcd(int a, int b) {
if(a%b==0) return b;
else return igcd(b,a%b);
}
long lcm(long a, long b) {return a / gcd(a,b) * b;}
public long perm(int a,int num) {
if(!isBuild)buildFac();
return fac[a]*(rev(fac[a-num]))%mod;
}
void buildComb(int N) {
comb = new long[N+1][N+1];
comb[0][0] = 1;
for(int i=1;i<=N;i++) {
comb[i][0] = 1;
for(int j=1;j<N;j++) {
comb[i][j] = comb[i-1][j-1]+comb[i-1][j];
if(comb[i][j]>mod)comb[i][j]-=mod;
}
comb[i][i] = 1;
}
}
public long comb(int a,int num){
if(a-num<0)return 0;
if(num<0)return 0;
if(!isBuild)buildFac();
return fac[a] * ((revfac[num]*revfac[a-num])%mod)%mod;
}
long mulchoose(int n,int k) {
if(k==0) return 1;
return comb(n+k-1,k);
}
long rev(long l) {return pow(l,mod-2);}
void buildpow(int l,int i) {
pow = new long[i+1];
pow[0] = 1;
for(int j=1;j<=i;j++) {
pow[j] = pow[j-1]*l;
if(pow[j]>mod)pow[j] %= mod;
}
}
void buildrevpow(int l,int i) {
revpow = new long[i+1];
revpow[0] = 1;
for(int j=1;j<=i;j++) {
revpow[j] = revpow[j-1]*l;
if(revpow[j]>mod) revpow[j] %= mod;
}
}
long pow(long l, long i) {
if(i==0)return 1;
else{
if(i%2==0){
long val = pow(l,i/2);
return val * val % mod;
}
else return pow(l,i-1) * l % mod;
}
}
}
| np | 1242_C. Sum Balance | CODEFORCES |
import javafx.util.Pair;
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main implements Runnable
{
boolean multiple = false;
long MOD;
@SuppressWarnings({"Duplicates", "ConstantConditions"})
void solve() throws Exception
{
int k = sc.nextInt();
long tar = 0;
long[][] arr = new long[k][];
long[] sum = new long[k];
HashMap<Long, Pair<Integer, Integer>> map = new HashMap<>();
for (int i = 0; i < k; i++)
{
int ni = sc.nextInt();
arr[i] = new long[ni];
for (int j = 0; j < ni; j++)
{
sum[i] += (arr[i][j] = sc.nextInt());
map.put(arr[i][j], new Pair<>(i, j));
}
tar += sum[i];
}
if (tar % k != 0) { System.out.println("No"); return; }
tar /= k;
works = new HashMap<>();
for (int i = 0; i < k; i++)
{
outer: for (int j = 0; j < arr[i].length; j++)
{
long val = arr[i][j];
long want = tar - sum[i] + val;
if (!map.containsKey(want)) continue;
// ArrayList<pli> list = new ArrayList<>();
int key = 1 << i;
int next = map.get(want).getKey();
// int prev = i;
HashSet<Integer> seen = new HashSet<>();
seen.add(i);
while (true)
{
if (seen.contains(next))
{
if (next == i && want == arr[i][j])
works.put(key, (((long) i) << 32) + ((long) j));
break;
}
// list.add(new pli(want, prev));
val = arr[next][map.get(want).getValue()];
want = tar - sum[next] + val;
if (!map.containsKey(want)) continue outer;
key |= 1 << next;
// prev = next;
seen.add(next);
next = map.get(want).getKey();
}
}
}
// dp.put(0, new ArrayList<>());
dp = new long[1 << k];
done = new boolean[1 << k];
yes = new boolean[1 << k];
yes[0] = done[0] = true;
long ans = r((1 << k) - 1);
long[] val = new long[k];
int[] pos = new int[k];
if (!yes[(1 << k) - 1]) System.out.println("No");
else
{
// System.out.println(ans);
// System.out.println(map);
System.out.println("Yes");
while (ans >> 32 != 0)
{
long p = works.get((int)(ans >> 32));
int i = (int)(p >> 32), j = (int)(p & ((1L<<32)-1));
long VAL = arr[i][j];
long want = tar - sum[i] + VAL;
int key = 1 << i;
int next = map.get(want).getKey();
int prev = i;
while (true)
{
if (next == i)
{
val[map.get(want).getKey()] = want;
pos[map.get(want).getKey()] = prev + 1;
if (want == arr[i][j])
works.put(key, (((long)i)<<32) + ((long)j));
break;
}
val[map.get(want).getKey()] = want;
pos[map.get(want).getKey()] = prev + 1;
VAL = arr[next][map.get(want).getValue()];
want = tar - sum[next] + VAL;
key |= 1 << next;
prev = next;
next = map.get(want).getKey();
}
ans = dp[(int)(ans & ((1L << 32)- 1))];
}
for (int i = 0; i < k; i++)
System.out.println(val[i] + " " + pos[i]);
}
}
HashMap<Integer, Long> works;
long[] dp;
boolean[] done, yes;
long r(int mask)
{
if (done[mask]) return dp[mask];
done[mask] = true;
for (int s = mask; s != 0; s = (s-1) & mask)
if (works.keySet().contains(s))
{
int tempMask = mask;
for (int i = 0; i < 16; i++)
if ((s & (1 << i)) != 0)
tempMask ^= 1 << i;
r(tempMask);
if (yes[tempMask])
{
yes[mask] = true;
return dp[mask] = (((long)s) << 32) + tempMask;
}
}
return 0;
}
class pii { int f, s; pii(int k, int v) { f = k; s = v; } }
class pli { long f; int s; pli(long k, int v) { f = k; s = v; } public String toString() { return "(" + f + ", " + s + ")"; } }
StringBuilder ANS = new StringBuilder();
void p(Object s) { ANS.append(s); } void p(double s) {ANS.append(s); } void p(long s) {ANS.append(s); } void p(char s) {ANS.append(s); }
void pl(Object s) { ANS.append(s); ANS.append('\n'); } void pl(double s) { ANS.append(s); ANS.append('\n'); } void pl(long s) { ANS.append(s); ANS.append('\n'); } void pl(char s) { ANS.append(s); ANS.append('\n'); } void pl() { ANS.append(('\n')); }
/*I/O, and other boilerplate*/ @Override public void run() { try { in = new BufferedReader(new InputStreamReader(System.in));out = new PrintWriter(System.out);sc = new FastScanner(in);if (multiple) { int q = sc.nextInt();for (int i = 0; i < q; i++) solve(); } else solve(); System.out.print(ANS); } catch (Throwable uncaught) { Main.uncaught = uncaught; } finally { out.close(); }} public static void main(String[] args) throws Throwable{ Thread thread = new Thread(null, new Main(), "", (1 << 26));thread.start();thread.join();if (Main.uncaught != null) {throw Main.uncaught;} } static Throwable uncaught; BufferedReader in; FastScanner sc; PrintWriter out; } class FastScanner { BufferedReader in; StringTokenizer st; public FastScanner(BufferedReader in) {this.in = in;}public String nextToken() throws Exception { while (st == null || !st.hasMoreTokens()) { st = new StringTokenizer(in.readLine()); }return st.nextToken(); }public int nextInt() throws Exception { return Integer.parseInt(nextToken()); }public long nextLong() throws Exception { return Long.parseLong(nextToken()); }public double nextDouble() throws Exception { return Double.parseDouble(nextToken()); }
} | np | 1242_C. Sum Balance | CODEFORCES |
import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
import static java.lang.Math.*;
public class Main implements Runnable
{
static class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
public InputReader(InputStream stream)
{
this.stream = stream;
}
public int read()
{
if (numChars==-1)
throw new InputMismatchException();
if (curChar >= numChars)
{
curChar = 0;
try
{
numChars = stream.read(buf);
}
catch (IOException e)
{
throw new InputMismatchException();
}
if(numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
public int nextInt()
{
int c = read();
while(isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
int res = 0;
do
{
if(c<'0'||c>'9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
long res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
public double nextDouble()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.')
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.')
{
c = read();
double m = 1;
while (!isSpaceChar(c))
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public String readString()
{
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do
{
res.appendCodePoint(c);
c = read();
}
while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c)
{
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next()
{
return readString();
}
public interface SpaceCharFilter
{
public boolean isSpaceChar(int ch);
}
}
public static void main(String args[]) throws Exception
{
new Thread(null, new Main(),"Main",1<<26).start();
}
int findLSB(long n)
{
long value=-n&n;
return map.get(value);
}
void findMaxClique(long mask,int size)
{
if(mask==0)
{
if(size>maxClique)
maxClique=size;
return;
}
while(mask>0)
{
if(Long.bitCount(mask)+size<=maxClique)
return;
int lsb=findLSB(mask);
mask=mask^((long)1<<lsb);
findMaxClique(mask&edges[lsb],size+1);
}
}
long edges[];
HashMap<Long,Integer> map=new HashMap<>();
int maxClique;
public void run()
{
InputReader sc= new InputReader(System.in);
PrintWriter w= new PrintWriter(System.out);
long value=1;
for(int i=0;i<45;i++)
{
map.put(value,i);
value*=2;
}
int n=sc.nextInt();
int k=sc.nextInt();
edges=new long[n];
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
long connect=sc.nextLong();
if(j>i&&connect==1)
edges[i]|=(connect<<j);
}
}
findMaxClique(((long)1<<n)-1,0);
//w.print(maxClique);
double size=(double)maxClique;
double perCastle=(double)k/size;
double ans=perCastle*perCastle*(size*(size-1))/2;
w.print(ans);
w.close();
}
} | np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
// public static StringTokenizer tokenizer;
// public static BufferedReader reader;
public static PrintWriter saida = new PrintWriter(System.out, false);
// public static String proximo() {
// while (tokenizer == null || !tokenizer.hasMoreElements()) {
// try {
// tokenizer = new StringTokenizer(reader.readLine());
// } catch (RuntimeException e) {
// e.printStackTrace();
// }
// }
// return tokenizer.nextToken();
// }
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(Reader in) {
br = new BufferedReader(in);
}
public FastScanner() {
this(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());
}
}
public static void main(String[] args) {
FastScanner fastScanner = new FastScanner();
int proximoInt = fastScanner.nextInt();
double proximoDouble = fastScanner.nextInt();
long[] graph = new long[proximoInt];
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = fastScanner.nextInt();
if (val.equals(1) || i.equals(j)) {
graph[i] |= 1L << j;
}
}
}
int szLeft = proximoInt/2;
int szRight = proximoInt - szLeft;
int[] dp = new int[1 << szLeft];
int maxMask = 1 << szLeft;
for(int mask = 1; mask <maxMask; mask++) {
int curMask = mask;
for(int j = 0; j < szLeft; j++) {
if (((1 << j) & mask) > 0) {
curMask &= graph[j + szRight] >> szRight;
dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << j)]);
}
}
if (mask == curMask) {
dp[mask] = Math.max(dp[mask],Integer.bitCount(mask));
}
}
int ans = 0;
int rmaxMask = 1 << szRight;
for(int mask = 0; mask < rmaxMask; mask++) {
int curMask = mask;
int oMask = maxMask -1;
for(int j = 0; j < szRight; j++) {
if (((1 << j) & mask) > 0) {
curMask &= (graph[j] & (rmaxMask-1));
oMask &= graph[j] >> szRight;
}
}
if (curMask != mask) continue;
ans = Math.max(ans, Integer.bitCount(mask) + dp[oMask]);
}
proximoDouble/=ans;
saida.println(proximoDouble * proximoDouble * (ans * (ans-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.util.*;
import java.io.*;
public class code839E
{
public static void main(String[] args) throws Exception{
BufferedReader bff=new BufferedReader(new InputStreamReader(System.in));
PrintWriter wff=new PrintWriter(System.out);
String[] st=bff.readLine().split(" ");
int V=Integer.parseInt(st[0]);
int K=Integer.parseInt(st[1]);
BronKerbosch bk=new BronKerbosch(V);
for(int i=0;i<V;i++){
st=bff.readLine().split(" ");
for(int j=0;j<V;j++){
if(st[j].equals("1")){
bk.anadir(i,j);
}
}
}
long num=bk.numeroCamarilla();
wff.printf("%.12f\n", num * (num - 1.0) / 2 * K / num * K / num);
wff.flush();
}
static class BronKerbosch {
int V;
long[] neig;
Random random = new Random();
long maxClique;
public BronKerbosch(int v){
V=v;
neig=new long[V];
}
public void anadir(int a,int b){
long aux=1;
neig[a] |= aux << (long)b;
}
public long numeroCamarilla(){
long numero = Long.bitCount(bronKerbosch());
return numero;
}
public long bronKerbosch() {
maxClique = 0;
bronKerbosch2(0, (1L << V) - 1, 0);
return maxClique;
}
public void bronKerbosch2(long r, long p, long x) {
if (Long.bitCount(maxClique) >= Long.bitCount(r | p | x)) return;
long px = p | x;
if (px == 0) {
if (Long.bitCount(maxClique) < Long.bitCount(r)) {
maxClique = r;
}
return;
}
int cnt = Long.bitCount(px);
int choice = random.nextInt(cnt);
int u;
for (int i = 0; ; i++) {
if ((px >>> i & 1) != 0 && choice-- == 0) {
u = i;
break;
}
}
long ne = p & ~neig[u];
for (int v = 0; v < V; v++){
if ((ne >>> v & 1) != 0) {
bronKerbosch2(r | 1L << v, p & neig[v], x & neig[v]);
p &= ~(1L << v);
x |= 1L << v;
}
}
}
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Random;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author tanzaku
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
MyInput in = new MyInput(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
int n;
int k;
long[] neigibor;
Random random = new Random();
long maxClique;
public void solve(int testNumber, MyInput in, PrintWriter out) {
n = in.nextInt();
k = in.nextInt();
neigibor = new long[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
neigibor[i] |= in.nextLong() << j;
}
}
long maxClique = bronKerbosch();
long a = Long.bitCount(maxClique);
dump(a);
out.printf("%.12f\n", a * (a - 1.0) / 2 * k / a * k / a);
}
static void dump(Object... o) {
System.err.println(Arrays.deepToString(o));
}
long bronKerbosch() {
maxClique = 0;
bronKerbosch2(0, (1L << n) - 1, 0);
return maxClique;
}
void bronKerbosch2(long r, long p, long x) {
if (Long.bitCount(maxClique) >= Long.bitCount(r | p | x)) return;
long px = p | x;
if (px == 0) {
if (Long.bitCount(maxClique) < Long.bitCount(r)) {
maxClique = r;
}
return;
}
int cnt = Long.bitCount(px);
int choice = random.nextInt(cnt);
int u;
for (int i = 0; ; i++) {
if ((px >>> i & 1) != 0 && choice-- == 0) {
u = i;
break;
}
}
// dump(r, p, x, u, neigibor);
long ne = p & ~neigibor[u];
for (int v = 0; v < n; v++)
if ((ne >>> v & 1) != 0) {
bronKerbosch2(r | 1L << v, p & neigibor[v], x & neigibor[v]);
p &= ~(1L << v);
x |= 1L << v;
}
}
}
static class MyInput {
private final BufferedReader in;
private static int pos;
private static int readLen;
private static final char[] buffer = new char[1024 * 8];
private static char[] str = new char[500 * 8 * 2];
private static boolean[] isDigit = new boolean[256];
private static boolean[] isSpace = new boolean[256];
private static boolean[] isLineSep = new boolean[256];
static {
for (int i = 0; i < 10; i++) {
isDigit['0' + i] = true;
}
isDigit['-'] = true;
isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
isLineSep['\r'] = isLineSep['\n'] = true;
}
public MyInput(InputStream is) {
in = new BufferedReader(new InputStreamReader(is));
}
public int read() {
if (pos >= readLen) {
pos = 0;
try {
readLen = in.read(buffer);
} catch (IOException e) {
throw new RuntimeException();
}
if (readLen <= 0) {
throw new MyInput.EndOfFileRuntimeException();
}
}
return buffer[pos++];
}
public int nextInt() {
int len = 0;
str[len++] = nextChar();
len = reads(len, isSpace);
int i = 0;
int ret = 0;
if (str[0] == '-') {
i = 1;
}
for (; i < len; i++) ret = ret * 10 + str[i] - '0';
if (str[0] == '-') {
ret = -ret;
}
return ret;
}
public long nextLong() {
int len = 0;
str[len++] = nextChar();
len = reads(len, isSpace);
int i = 0;
long ret = 0;
if (str[0] == '-') {
i = 1;
}
for (; i < len; i++) ret = ret * 10 + str[i] - '0';
if (str[0] == '-') {
ret = -ret;
}
return ret;
}
public char nextChar() {
while (true) {
final int c = read();
if (!isSpace[c]) {
return (char) c;
}
}
}
int reads(int len, boolean[] accept) {
try {
while (true) {
final int c = read();
if (accept[c]) {
break;
}
if (str.length == len) {
char[] rep = new char[str.length * 3 / 2];
System.arraycopy(str, 0, rep, 0, str.length);
str = rep;
}
str[len++] = (char) c;
}
} catch (MyInput.EndOfFileRuntimeException e) {
}
return len;
}
static class EndOfFileRuntimeException extends RuntimeException {
}
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
//package round428;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
public class E2 {
InputStream is;
PrintWriter out;
String INPUT = "";
// String INPUT = "";
void solve()
{
int n = ni(), K = ni();
long[] g = new long[n];
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
g[i] |= nl()<<j;
}
g[i] |= 1L<<i;
}
// (K/M)^2*M(M-1)/2
// K^2*(M-1)/2M
int mc = solveMaximumClique(g);
out.printf("%.14f\n", (double)K*K*(mc-1)/2/mc);
}
public static int solveMaximumClique(long[] g)
{
int n = g.length;
int h = n/2;
int[] dp = new int[1<<n-h];
for(int i = 0;i < 1<<h;i++){
long cover = (1L<<n)-1;
for(int j = 0;j < h;j++){
if(i<<~j<0)cover &= g[j];
}
if((cover&i) == i){
dp[(int)(cover>>>h)] = Math.max(dp[(int)(cover>>>h)], Integer.bitCount(i));
}
}
for(int i = 0;i < n-h;i++){
for(int j = 0;j < 1<<n-h;j++){
if(j<<~i>=0){
dp[j] = Math.max(dp[j], dp[j|1<<i]);
}
}
}
int ret = 0;
for(int i = 0;i < 1<<n-h;i++){
long cover = (1L<<n)-1;
for(int j = 0;j < n-h;j++){
if(i<<~j<0)cover &= g[j+h];
}
if((cover&(long)i<<h) == (long)i<<h){
ret = Math.max(ret, Integer.bitCount(i) + dp[i]);
}
}
return ret;
}
void run() throws Exception
{
is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception { new E2().run(); }
private byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
private int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private double nd() { return Double.parseDouble(ns()); }
private char nc() { return (char)skip(); }
private String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
public static PrintWriter saida = new PrintWriter(System.out, false);
public static class Escanear {
BufferedReader reader;
StringTokenizer tokenizer;
public Escanear() {
this(new InputStreamReader(System.in));
}
public Escanear(Reader in) {
reader = new BufferedReader(in);
}
String proximo() {
if (tokenizer == null || !tokenizer.hasMoreElements()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(proximo());
}
}
public static void main(String[] args) {
Escanear fastScanner = new Escanear();
int proximoInt = fastScanner.nextInt();
double proximoDouble = fastScanner.nextInt();
long[] graph = new long[proximoInt];
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = fastScanner.nextInt();
if (val.equals(1) || i.equals(j)) {
graph[i] |= 1L << j;
}
}
}
int szLeft = proximoInt/2;
int szRight = proximoInt - szLeft;
int[] dp = new int[1 << szLeft];
int maxMask = 1 << szLeft;
for(int mask = 1; mask <maxMask; mask++) {
int curMask = mask;
for(int j = 0; j < szLeft; j++) {
if (((1 << j) & mask) > 0) {
curMask &= graph[j + szRight] >> szRight;
dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << j)]);
}
}
if (mask == curMask) {
dp[mask] = Math.max(dp[mask],Integer.bitCount(mask));
}
}
int ans = 0;
int rmaxMask = 1 << szRight;
for(int mask = 0; mask < rmaxMask; mask++) {
int curMask = mask;
int oMask = maxMask -1;
for(int j = 0; j < szRight; j++) {
if (((1 << j) & mask) > 0) {
curMask &= (graph[j] & (rmaxMask-1));
oMask &= graph[j] >> szRight;
}
}
if (curMask != mask) continue;
ans = Math.max(ans, Integer.bitCount(mask) + dp[oMask]);
}
proximoDouble/=ans;
saida.println(proximoDouble * proximoDouble * (ans * (ans-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.util.*;
import java.io.*;
/*
* Heart beats fast
* Colors and promises
* How to be brave
* How can I love when I am afraid...
*/
public class Main
{
public static void main(String[]args) throws Exception
{
int n=ni();
double ke=ni();
boolean[][]a=new boolean[n][n];
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
a[i][j]=ni()==0;
int left=n/2;
int[]ldp=new int[1<<left];
int[]rdp=new int[1<<(n-left)];
int[]pow=new int[25];
pow[0]=1;
for(int i=1; i<25; i++)
pow[i]=pow[i-1]<<1;
for(int i=0; i<pow[left]; i++)
ou:for(int j=0; j<left; j++)
if((i>>j)%2==0)
{
int te=i;
for(int k=0; te>0; k++,te>>=1)
if(a[j][k]&&(te&1)!=0)
{
ldp[i+pow[j]]=max(ldp[i+pow[j]],ldp[i]);
continue ou;
}
ldp[i+pow[j]]=max(ldp[i+pow[j]],ldp[i]+1);
}
int right=n-left;
for(int i=0; i<pow[right]; i++)
ou:for(int j=0; j<right; j++)
if((i>>j)%2==0)
{
int lul=j+left;
int te=i;
for(int k=left; te>0; k++,te>>=1)
if(a[lul][k]&&(te&1)!=0)
{
rdp[i+pow[j]]=max(rdp[i+pow[j]],rdp[i]);
continue ou;
}
rdp[i+pow[j]]=max(rdp[i+pow[j]],rdp[i]+1);
}
int maxi=0;
for(int i=0; i<pow[left]; i++)
{
int lol=0;
int te=i;
for(int j=0; te>0; j++,te>>=1)
if((te&1)!=0)
for(int k=0; k<right; k++)
if(a[j][k+left])
lol|=pow[k];
maxi=max(maxi,ldp[i]+rdp[pow[right]-1-lol]);
}
pr((ke*ke*(maxi-1))/(2*maxi));
System.out.println(output);
}
///////////////////////////////////////////
///////////////////////////////////////////
///template from here
// static final int mod=998_244_353;
static final int mod=1000_000_007;
static final double eps=1e-7;
static final long inf=1000_000_000_000_000_000L;
static class pair
{
int a,b;
pair(){}
pair(int c,int d){a=c;b=d;}
@Override
public int hashCode()
{
return (a+" "+b).hashCode();
}
public boolean equals(Object c)
{
return (a==(((pair)c).a)&&b==(((pair)c).b));
}
}
public static void sort(int[][]a)
{
Arrays.sort(a, new Comparator<int[]>()
{
public int compare(int[]a,int[]b)
{
if(a[0]>b[0])
return 1;
if(a[0]<b[0])
return -1;
return 0;
}
});
}
static interface combiner
{
public int combine(int a, int b);
}
static void pr(Object a){output.append(a+"\n");}
static void pr(){output.append("\n");}
static void p(Object a){output.append(a);}
static void pra(int[]a){for(int i:a)output.append(i+" ");output.append("\n");}
static void pra(long[]a){for(long i:a)output.append(i+" ");output.append("\n");}
static void pra(String[]a){for(String i:a)output.append(i+" ");output.append("\n");}
static void pra(double[]a){for(double i:a)output.append(i+" ");output.append("\n");}
static void sop(Object a){System.out.println(a);}
static void flush(){System.out.print(output);output=new StringBuilder();}
static int ni(){return Integer.parseInt(in.next());}
static long nl(){return Long.parseLong(in.next());}
static String ns(){return in.next();}
static double nd(){return Double.parseDouble(in.next());}
static int[] nia(int n){int a[]=new int[n];for(int i=0; i<n; i++)a[i]=ni();return a;}
static int[] pnia(int n){int a[]=new int[n+1];for(int i=1; i<=n; i++)a[i]=ni();return a;}
static long[] nla(int n){long a[]=new long[n];for(int i=0; i<n; i++)a[i]=nl();return a;}
static String[] nsa(int n){String a[]=new String[n];for(int i=0; i<n; i++)a[i]=ns();return a;}
static double[] nda(int n){double a[]=new double[n];for(int i=0; i<n; i++)a[i]=nd();return a;}
static Reader in=new Reader();
static StringBuilder output=new StringBuilder();
static Random rn=new Random();
static void reverse(int[]a){for(int i=0; i<a.length/2; i++){a[i]^=a[a.length-i-1];a[a.length-i-1]^=a[i];a[i]^=a[a.length-i-1];}}
static int log2n(long a)
{
int te=0;
while(a>0)
{
a>>=1;
++te;
}
return te;
}
static class vectorl implements Iterable<Long>
{
long a[];
int size;
vectorl(){a=new long[10];size=0;}
vectorl(int n){a=new long[n];size=0;}
public void add(long b){if(++size==a.length)a=Arrays.copyOf(a, 2*size);a[size-1]=b;}
public void sort(){Arrays.sort(a, 0, size);}
public void sort(int l, int r){Arrays.sort(a, l, r);}
@Override
public Iterator<Long> iterator() {
Iterator<Long> hola=new Iterator<Long>()
{
int cur=0;
@Override
public boolean hasNext() {
return cur<size;
}
@Override
public Long next() {
return a[cur++];
}
};
return hola;
}
}
static class vector implements Iterable<Integer>
{
int a[],size;
vector(){a=new int[10];}
vector(int n){a=new int[n];}
public void add(int b){if(++size==a.length)a=Arrays.copyOf(a, 2*size);a[size-1]=b;}
public void sort(){Arrays.sort(a, 0, size);}
public void sort(int l, int r){Arrays.sort(a, l, r);}
@Override
public Iterator<Integer> iterator() {
Iterator<Integer> hola=new Iterator<Integer>()
{
int cur=0;
@Override
public boolean hasNext() {
return cur<size;
}
@Override
public Integer next() {
return a[cur++];
}
};
return hola;
}
}
static void exit(){System.out.print(output);System.exit(0);}
static int min(int... a){int min=a[0];for(int i:a)min=Math.min(min, i);return min;}
static int max(int... a){int max=a[0];for(int i:a)max=Math.max(max, i);return max;}
static int gcd(int... a){int gcd=a[0];for(int i:a)gcd=gcd(gcd, i);return gcd;}
static long min(long... a){long min=a[0];for(long i:a)min=Math.min(min, i);return min;}
static long max(long... a){long max=a[0];for(long i:a)max=Math.max(max, i);return max;}
static long gcd(long... a){long gcd=a[0];for(long i:a)gcd=gcd(gcd, i);return gcd;}
static String pr(String a, long b){String c="";while(b>0){if(b%2==1)c=c.concat(a);a=a.concat(a);b>>=1;}return c;}
static long powm(long a, long b, long mod2){long an=1;long c=a%mod2;while(b>0){if(b%2==1)an=(an*c)%mod2;c=(c*c)%mod2;b>>=1;}return an;}
static long pow(long a, long b){long an=1;long c=a;while(b>0){if(b%2==1)an*=c;c*=c;b>>=1;}return an;}
static int gcd(int a, int b){if(b==0)return a;return gcd(b, a%b);}
static long gcd(long a, long b){if(b==0)return a;return gcd(b, a%b);}
static class Reader{
public BufferedReader reader;
public StringTokenizer tokenizer;
public Reader() {
reader = new BufferedReader(new InputStreamReader(System.in));
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();
}
}
} | np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
public static PrintWriter saida = new PrintWriter(System.out, false);
public static class Escanear {
BufferedReader reader;
StringTokenizer tokenizer;
public Escanear() {
this(new InputStreamReader(System.in));
}
public Escanear(Reader in) {
reader = new BufferedReader(in);
}
String proximo() {
if (tokenizer == null || !tokenizer.hasMoreElements()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
int proximoNum() {
return Integer.parseInt(proximo());
}
}
public static void main(String[] args) {
Escanear escanear = new Escanear();
int proximoInt = escanear.proximoNum();
long[] aux = new long[proximoInt];
double proximoDouble = escanear.proximoNum();
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = escanear.proximoNum();
if (val.equals(1) || i.equals(j)) {
aux[i] |= 1L << j;
}
}
}
int esquerda = proximoInt/2;
int direita = proximoInt - esquerda;
int maiorMascara = 1 << esquerda;
int[] depois = new int[1 << esquerda];
Integer mascara = 1;
while (mascara < maiorMascara) {
int mascaraAtual = mascara;
for(int j = 0; j < esquerda; j++) {
if (((1 << j) & mascara) > 0) {
mascaraAtual &= aux[j + direita] >> direita;
depois[mascara] = Math.max(depois[mascara], depois[mascara ^ (1 << j)]);
}
}
if (mascara == mascaraAtual) {
depois[mascara] = Math.max(depois[mascara],Integer.bitCount(mascara));
}
mascara++;
}
// for(int mascara = 1; mascara < maiorMascara; mascara++) {
// int mascaraAtual = mascara;
// for(int j = 0; j < esquerda; j++) {
// if (((1 << j) & mascara) > 0) {
// mascaraAtual &= aux[j + direita] >> direita;
// depois[mascara] = Math.max(depois[mascara], depois[mascara ^ (1 << j)]);
// }
// }
// if (mascara == mascaraAtual) {
// depois[mascara] = Math.max(depois[mascara],Integer.bitCount(mascara));
// }
// }
int auxiliar = 0;
int mascaraMaxima = 1 << direita;
for(int masc = 0; masc < mascaraMaxima; masc++) {
int mascaraCorrente = masc;
int mascaraValor = maiorMascara -1;
for(int j = 0; j < direita; j++) {
if (((1 << j) & masc) > 0) {
mascaraCorrente &= (aux[j] & (mascaraMaxima-1));
mascaraValor &= aux[j] >> direita;
}
}
if (mascaraCorrente != masc) continue;
auxiliar = Math.max(auxiliar, Integer.bitCount(masc) + depois[mascaraValor]);
}
proximoDouble/=auxiliar;
saida.println(proximoDouble * proximoDouble * (auxiliar * (auxiliar-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.util.*;
public class Main {
static int a[][],n;
static boolean isClique[];
static int maxClique[];
static void DFS1(int p,int n,int S)
{
if(p>n)
{
isClique[S]=true;
return ;
}
DFS1(p+1,n,S);
boolean mark=true;
for(int i=1;i<p;++i)
if((S>>(i-1)&1)==1&&a[p][i]==0)
mark=false;
if(mark)
DFS1(p+1,n,1<<(p-1)|S);
}
static void DFS2(int p,int n,int m,int S)
{
if(p>n)
{
int cnt=0;
for(int i=m;i<=n;++i)
if((S>>(i-m)&1)==1)
++cnt;
maxClique[S]=cnt;
return ;
}
DFS2(p+1,n,m,S);
boolean mark=true;
for(int i=m;i<p;++i)
if((S>>(i-m)&1)==1&&a[p][i]==0)
mark=false;
if(mark)
DFS2(p+1,n,m,1<<(p-m)|S);
}
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
n=Integer.parseInt(sc.next());
a=new int [n+10][n+10];
int cap=Integer.parseInt(sc.next());
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
a[i][j]=Integer.parseInt(sc.next());
int m=(n+1)>>1;
isClique=new boolean [1<<m];
Arrays.fill(isClique,false);
DFS1(1,m,0);
maxClique=new int [1<<(n-m)];
Arrays.fill(maxClique,0);
DFS2(m+1,n,m+1,0);
for(int i=1;i<1<<(n-m);++i)
for(int j=m+1;j<=n;++j)
if((i>>(j-m-1)&1)==1)
maxClique[i]=Math.max(maxClique[i],maxClique[i-(1<<(j-m-1))]);
int ans=0,tmp[]=new int [m+10];
for(int i=0;i<1<<m;++i)
if(isClique[i])
{
int mask=0,cnt=0;
for(int j=1;j<=m;++j)
if((i>>(j-1)&1)==1)
tmp[++cnt]=j;
for(int j=m+1;j<=n;++j)
{
boolean mark=true;
for(int k=1;k<=cnt;++k)
if(a[j][tmp[k]]==0)
mark=false;
if(mark)
mask|=1<<(j-m-1);
}
ans=Math.max(ans,cnt+maxClique[mask]);
}
System.out.printf("%.9f\n",cap*cap*(ans-1)/2.0/ans);
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
// 1 -> n/2 XX n/2 + 1 -> n
public class MotherOfDragons
{
static boolean[][] adjMatrix;
public static void main(String[] args) throws IOException
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
// for (int i = 1; i <= n; i++)
// System.err.printf("%d %.12f\n",i, (k*k*((i-1)/(2.0*i))));
adjMatrix = new boolean[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
adjMatrix[i][j] = sc.nextInt() == 1;
long[] edges = new long[n];
for (int i = 0; i < n; i++)
{
long val = 0;
for (int j = 0; j < n; j++)
if(adjMatrix[i][j] || i == j)
val |= 1l<<j;
edges[i] = val;
}
int h = n/2;
int[] cliques = new int[1<<h];
for (int i = 1; i < 1<<h; i++)
{
int nodes = i;
for (int j = 0; j < h; j++)
if((i & (1 << j)) != 0)
nodes &= edges[j];
if(nodes == i)
cliques[i] = Integer.bitCount(i);
}
for (int i = 1; i < 1<<h; i++)
for (int j = 0; j < h; j++)
if((i & (1 << j)) != 0)
cliques[i] = Math.max(cliques[i], cliques[i ^ (1<<j)]);
int max = 0;
for (int i = 0; i < cliques.length; i++)
max = Math.max(max, cliques[i]);
for (int i = 1; i < 1<<(n-h); i++)
{
long all = -1l;
long tmp = (1l*i)<<h;
for (int j = h; j < n; j++)
if((tmp & (1l << j)) != 0)
all &= edges[j];
long node = all&tmp;
if(node != tmp)
continue;
int connected = (int)(all & ((1<<h)-1));
max = Math.max(max, cliques[connected] + Integer.bitCount(i));
}
System.out.printf("%.12f\n", (k*k*((max-1)/(2.0*max))));
}
static class Scanner
{
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s)
{
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(String s) throws FileNotFoundException
{
br = new BufferedReader(new FileReader(new File((s))));
}
public String next() throws IOException
{
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException
{
return Integer.parseInt(next());
}
public long nextLong() throws IOException
{
return Long.parseLong(next());
}
public String nextLine() throws IOException
{
return br.readLine();
}
public double nextDouble() throws IOException
{ return Double.parseDouble(next()); }
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.util.*;
import java.io.*;
public class E {
void solve(BufferedReader in) throws Exception {
int[] xx = toInts(in.readLine());
int n = xx[0];
double k = xx[1];
int[][] board = new int[n][n];
for(int i = 0; i<n; i++) board[i] = toInts(in.readLine());
int fst = n/2;
int snd = n - fst;
int[] maxc = new int[1<<fst];
int max = 1;
for(int i = 0; i<(1<<fst); i++) {
for(int j = 0; j<fst; j++) {
if((i&(1<<j)) != 0) maxc[i] = Math.max(maxc[i], maxc[i^(1<<j)]);
}
boolean ok = true;
for(int a = 0; a<fst; a++) if(((1<<a)&i) != 0) {
for(int b = a+1; b<fst; b++) if(((1<<b)&i) != 0) {
if(board[a][b] == 0) ok = false;
}
}
if(ok) {
maxc[i] = Integer.bitCount(i);
max = Math.max(max, maxc[i]);
}
}
for(int i = 0; i<(1<<snd); i++) {
boolean ok = true;
for(int a = 0; a<snd; a++) if(((1<<a)&i) != 0) {
for(int b = a+1; b<snd; b++) if(((1<<b)&i) != 0) {
if(board[a+fst][b+fst] == 0) ok = false;
}
}
if(!ok) continue;
int mask = 0;
for(int a = 0; a<fst; a++) {
ok = true;
for(int b = 0; b<snd; b++) {
if(((1<<b)&i) != 0) {
if(board[a][b+fst] == 0) ok = false;
}
}
if(ok) mask |= (1<<a);
}
max = Math.max(Integer.bitCount(i) + maxc[mask], max);
}
System.out.println(k*k*(max-1.0)/(2*max));
}
int toInt(String s) {return Integer.parseInt(s);}
int[] toInts(String s) {
String[] a = s.split(" ");
int[] o = new int[a.length];
for(int i = 0; i<a.length; i++) o[i] = toInt(a[i]);
return o;
}
void e(Object o) {
System.err.println(o);
}
public static void main(String[] args) throws Exception{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
(new E()).solve(in);
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class ELR {
static double solveUnweighted (int nodes, long curr, long pool, long excl) {
if (pool == 0 && excl == 0) {
int cnt = 0;
for (int i = 0; i < nodes; i++)
if ((curr & 1L << i) > 0)
cnt++;
double cont = (k / (cnt*1.0));
double edges = (cnt) * (cnt - 1) / 2.0;
return cont * cont * edges;
}
double res = 0;
int j = 0;
for (int i = 0; i < nodes; i++)
if ((pool & 1L << i) > 0 || (excl & 1L << i) > 0)
j = i;
for (int i = 0; i < nodes; i++) {
if ((pool & 1L << i) == 0 || adj[i][j])
continue;
long ncurr = curr, npool = 0, nexcl = 0;
ncurr |= 1L << i;
for (int k = 0; k < nodes; k++) {
if (adj[i][k]) {
npool |= pool & 1L << k;
nexcl |= excl & 1L << k;
}
}
res = Math.max(res, solveUnweighted(nodes, ncurr, npool, nexcl));
pool &= ~(1L << i);
excl |= 1L >> i;
}
return res;
}
public static void main(String[] args) {new Thread(null, new Runnable() { public void run() {try {
sol();
} catch (Throwable e) {
e.printStackTrace();
}}}, "2",1<<26).start();}
static int n,k;
static boolean adj[][];
public static void sol() throws Throwable {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
k = sc.nextInt();
adj = new boolean[n][n];
for (int i = 0 ; i < n ; ++i) {
for (int j = 0 ; j < n ; ++j) {
adj[i][j] = sc.nextInt() == 1;
}
}
double ans = solveUnweighted(n, 0, (1L << n) - 1, 0);
System.out.println(ans);
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(String s) throws FileNotFoundException {
br = new BufferedReader(new FileReader(new File(s)));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public boolean ready() throws IOException {
return br.ready();
}
}
} | np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Rustam Musin ([email protected])
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
int n;
double k;
boolean[][] g;
public void solve(int testNumber, InputReader in, OutputWriter out) {
n = in.readInt();
k = in.readInt();
g = new boolean[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = in.readInt() == 1;
}
}
double answer = solve();
out.printFormat("%.20f", answer);
}
private double solve() {
int firstPartSize = g.length / 2;
int secondPartSize = g.length - firstPartSize;
int[] firstPart = findMaxCliqueSize(firstPartSize);
int m1Full = (1 << firstPartSize) - 1;
int maxCliqueSize = 1;
for (int m = 0; m < 1 << secondPartSize; m++) {
if (isClique(secondPartSize, m, firstPartSize)) {
int m1 = m1Full;
for (int j = 0; j < secondPartSize; j++) {
if (bit(m, j)) {
for (int i = 0; i < firstPartSize; i++) {
if (bit(m1, i) && !g[i][j + firstPartSize]) {
m1 ^= 1 << i;
}
}
}
}
int firstCliqueSize = firstPart[m1];
int secondCliqueSize = Integer.bitCount(m);
int curCliqueSize = firstCliqueSize + secondCliqueSize;
if (curCliqueSize > maxCliqueSize) {
maxCliqueSize = curCliqueSize;
}
}
}
return k * k * (maxCliqueSize - 1) / (2 * maxCliqueSize);
}
private int[] findMaxCliqueSize(int size) {
int[] dp = new int[1 << size];
for (int m = 1; m < 1 << size; m++) {
if (isClique(size, m, 0)) {
dp[m] = Integer.bitCount(m);
}
}
for (int m = 1; m < 1 << size; m++) {
for (int i = 0; i < size; i++) {
if ((m >> i & 1) == 0) {
dp[m | (1 << i)] = Math.max(dp[m | (1 << i)], dp[m]);
}
}
}
return dp;
}
private boolean isClique(int size, int m, int offset) {
for (int i = 0; i < size; i++) {
if (bit(m, i)) {
for (int j = i + 1; j < size; j++) {
if (bit(m, j) && !g[i + offset][j + offset]) {
return false;
}
}
}
}
return true;
}
private boolean bit(int m, int b) {
return (m >> b & 1) != 0;
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void printFormat(String format, Object... objects) {
writer.printf(format, objects);
}
public void close() {
writer.close();
}
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
public static PrintWriter saida = new PrintWriter(System.out, false);
public static class Escanear {
BufferedReader reader;
StringTokenizer tokenizer;
public Escanear() {
this(new InputStreamReader(System.in));
}
public Escanear(Reader in) {
reader = new BufferedReader(in);
}
String proximo() {
if (tokenizer == null || !tokenizer.hasMoreElements()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
int proximoNum() {
return Integer.parseInt(proximo());
}
}
public static void main(String[] args) {
Escanear escanear = new Escanear();
int proximoInt = escanear.proximoNum();
double proximoDouble = escanear.proximoNum();
long[] aux = new long[proximoInt];
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = escanear.proximoNum();
if (val.equals(1) || i.equals(j)) {
aux[i] |= 1L << j;
}
}
}
int esquerda = proximoInt/2;
int direita = proximoInt - esquerda;
int[] depois = new int[1 << esquerda];
int maiorMascara = 1 << esquerda;
for(int mascara = 1; mascara <maiorMascara; mascara++) {
int mascaraAtual = mascara;
for(int j = 0; j < esquerda; j++) {
if (((1 << j) & mascara) > 0) {
mascaraAtual &= aux[j + direita] >> direita;
depois[mascara] = Math.max(depois[mascara], depois[mascara ^ (1 << j)]);
}
}
if (mascara == mascaraAtual) {
depois[mascara] = Math.max(depois[mascara],Integer.bitCount(mascara));
}
}
int auxiliar = 0;
int mascaraMaxima = 1 << direita;
for(int mascara = 0; mascara < mascaraMaxima; mascara++) {
int mascaraCorrente = mascara;
int mascaraValor = maiorMascara -1;
for(int j = 0; j < direita; j++) {
if (((1 << j) & mascara) > 0) {
mascaraCorrente &= (aux[j] & (mascaraMaxima-1));
mascaraValor &= aux[j] >> direita;
}
}
if (mascaraCorrente != mascara) continue;
auxiliar = Math.max(auxiliar, Integer.bitCount(mascara) + depois[mascaraValor]);
}
proximoDouble/=auxiliar;
saida.println(proximoDouble * proximoDouble * (auxiliar * (auxiliar-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
public static PrintWriter saida = new PrintWriter(System.out, false);
public static class Escanear {
BufferedReader reader;
StringTokenizer tokenizer;
public Escanear() {
this(new InputStreamReader(System.in));
}
public Escanear(Reader in) {
reader = new BufferedReader(in);
}
String proximo() {
if (tokenizer == null || !tokenizer.hasMoreElements()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
int proximoNum() {
return Integer.parseInt(proximo());
}
}
public static void main(String[] args) {
Escanear escanear = new Escanear();
int proximoInt = escanear.proximoNum();
long[] aux = new long[proximoInt];
double proximoDouble = escanear.proximoNum();
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = escanear.proximoNum();
if (val.equals(1) || i.equals(j)) {
aux[i] |= 1L << j;
}
}
}
int esquerda = proximoInt/2;
int direita = proximoInt - esquerda;
int maiorMascara = 1 << esquerda;
int[] depois = new int[1 << esquerda];
Integer mascara = 1;
while (mascara < maiorMascara) {
int mascaraAtual = mascara;
for(int j = 0; j < esquerda; j++) {
if (((1 << j) & mascara) > 0) {
mascaraAtual &= aux[j + direita] >> direita;
depois[mascara] = Math.max(depois[mascara], depois[mascara ^ (1 << j)]);
}
}
if (mascara.equals(mascaraAtual)) {
depois[mascara] = Math.max(depois[mascara],Integer.bitCount(mascara));
}
mascara++;
}
int auxiliar = 0;
int mascaraMaxima = 1 << direita;
for(int i = 0; i < mascaraMaxima; i++) {
int mascaraCorrente = i;
int mascaraValor = maiorMascara -1;
for(int j = 0; j < direita; j++) {
if (((1 << j) & i) > 0) {
mascaraCorrente &= (aux[j] & (mascaraMaxima-1));
mascaraValor &= aux[j] >> direita;
}
}
if (mascaraCorrente != i) continue;
auxiliar = Math.max(auxiliar, Integer.bitCount(i) + depois[mascaraValor]);
}
proximoDouble/=auxiliar;
saida.println(proximoDouble * proximoDouble * (auxiliar * (auxiliar-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.*;
import java.util.*;
public class Solution {
private static StringTokenizer st;
private static int n;
private static int k;
private static boolean[][] graph;
private static int[] dp;
private static int maxCliqueSize;
public static void main(String[] args) throws Exception {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer(reader.readLine());
n = Integer.parseInt(st.nextToken());
k = Integer.parseInt(st.nextToken());
graph = new boolean[n][n];
dp = new int[1 << (n / 2)];
for (int i = 0; i < n; ++i) {
st = new StringTokenizer(reader.readLine());
for (int j = 0; j < n; ++j)
graph[i][j] = st.nextToken().equals("1");
}
reader.close();
/* fill dp for first subset */
int size1 = n / 2;
int border = 1 << size1;
for (int mask = 1; mask < border; ++mask) {
/* check if mask is complete graph */
boolean isComplete = true;
for (int i = 0; i < size1; ++i) {
if (((mask >> i) & 1) == 0)
continue;
for (int j = i + 1; j < size1; ++j) {
if (((mask >> j) & 1) == 0)
continue;
if (!graph[i][j]) {
isComplete = false;
break;
}
}
if (!isComplete)
break;
}
if (isComplete)
dp[mask] = Integer.bitCount(mask);
}
for (int mask = 1; mask < border; ++mask) {
for (int i = 0; i < size1; ++i) {
if (((mask >> i) & 1) == 0) {
dp[mask | (1 << i)] = Math.max(dp[mask | (1 << i)], dp[mask]);
}
}
}
/* process second subset */
maxCliqueSize = 1;
int size2 = n - n /2;
border = (1 << size2);
for (int mask = 0; mask < border; ++mask) {
boolean isComplete = true;
for (int i = 0; i < size2; ++i) {
if (((mask >> i) & 1) == 0)
continue;
for (int j = i + 1; j < size2; ++j) {
if (((mask >> j) & 1) != 0 && !graph[i + size1][j + size1]) {
isComplete = false;
break;
}
}
if (!isComplete)
break;
}
if (!isComplete)
continue;
int mask1 = (1 << size1) - 1;
for (int i = 0; i < size2; ++i) {
if (((mask >> i) & 1) == 0)
continue;
for (int j = 0; j < size1; ++j) {
if (!graph[j][i + size1] && ((mask1 >> j) & 1) != 0)
mask1 ^= (1 << j);
}
}
maxCliqueSize = Math.max(maxCliqueSize, dp[mask1] + Integer.bitCount(mask));
}
// System.out.println(maxCliqueSize);
double answer = (1.0 * k * k * (maxCliqueSize - 1) / (2 * maxCliqueSize));
System.out.printf("%.15f", answer);
}
} | np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.StringTokenizer;
public class MotherOfDragons {
public static void main(String[] args) {
FastScanner scanner = new FastScanner();
PrintWriter out = new PrintWriter(System.out, false);
int n = scanner.nextInt();
double k = scanner.nextInt();
long[] graph = new long[n];
for(Integer i = 0; i < n; i++) {
for(Integer j =0; j < n; j++) {
Integer val = scanner.nextInt();
if (val.equals(1) || i.equals(j)) {
graph[i] |= 1L << j;
}
}
}
int szLeft = n/2;
int szRight = n - szLeft;
int[] dp = new int[1 << szLeft];
int maxMask = 1 << szLeft;
for(int mask = 1; mask <maxMask; mask++) {
int curMask = mask;
for(int j = 0; j < szLeft; j++) {
if (((1 << j) & mask) > 0) {
curMask &= graph[j + szRight] >> szRight;
dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << j)]);
}
}
if (mask == curMask) {
dp[mask] = Math.max(dp[mask],Integer.bitCount(mask));
}
}
int ans = 0;
int rmaxMask = 1 << szRight;
for(int mask = 0; mask < rmaxMask; mask++) {
int curMask = mask;
int oMask = maxMask -1;
for(int j = 0; j < szRight; j++) {
if (((1 << j) & mask) > 0) {
curMask &= (graph[j] & (rmaxMask-1));
oMask &= graph[j] >> szRight;
}
}
if (curMask != mask) continue;
ans = Math.max(ans, Integer.bitCount(mask) + dp[oMask]);
}
k/=ans;
out.println(k * k * (ans * (ans-1))/2);
out.flush();
}
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(Reader in) {
br = new BufferedReader(in);
}
public FastScanner() {
this(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 readNextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.*;
import java.util.*;
public class E {
public static void main(String[] args) throws IOException {
Scanner sc=new Scanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int n=sc.nextInt(),k=sc.nextInt();
boolean [][]adj=new boolean[n][n];
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
adj[i][j]=sc.nextInt()==1;
int n1=n/2,n2=n-n1;
int []clique=new int [1<<n1];
for(int msk=1;msk<1<<n1;msk++)
{
boolean ok=true;
for(int i=0;i<n1;i++) if((msk & 1<<i) !=0)
for(int j=i+1;j<n1;j++)
if((msk & 1<<j) !=0 && !adj[i][j])
ok=false;
if(ok)
clique[msk]=Integer.bitCount(msk);
}
int []edges=new int [n2];
for(int i=0;i<n2;i++)
{
int msk=0;
for(int j=0;j<n1;j++)
if(adj[i+n1][j])
msk|=1<<j;
edges[i]=msk;
}
int max=0;
for(int msk=1;msk<1<<n1;msk++)
for(int i=0;i<n1;i++)
if((msk & 1<<i) !=0)
max=Math.max(max, clique[msk]=Math.max(clique[msk], clique[msk^(1<<i)]));
for(int msk=1;msk<1<<n2;msk++)
{
int all=(1<<n1)-1;
for(int j=0;j<n2;j++)
if((msk & 1<<j) !=0)
all &=edges[j];
boolean ok=true;
for(int i=0;i<n2;i++) if((msk & 1<<i) !=0)
for(int j=i+1;j<n2;j++)
if((msk & 1<<j) !=0 && !adj[i+n1][j+n1])
ok=false;
if(ok)
max=Math.max(max, Integer.bitCount(msk)+clique[all]);
}
out.printf("%.9f\n",k*1.0*k*(max-1)/(2*max));
out.close();
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader s) {
br = new BufferedReader(s);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public boolean ready() throws IOException {return br.ready();}
public double nextDouble() throws IOException {return Double.parseDouble(next());}
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.util.*;
import java.io.*;
public class E {
void solve(BufferedReader in) throws Exception {
int[] xx = toInts(in.readLine());
int n = xx[0];
double k = xx[1];
int[][] board = new int[n][n];
for(int i = 0; i<n; i++) board[i] = toInts(in.readLine());
int fst = n/2;
int snd = n - fst;
int[] maxc = new int[1<<fst];
int max = 1;
for(int i = 0; i<(1<<fst); i++) {
for(int j = 0; j<fst; j++) {
if((i&1<<j) != 0) maxc[i] = Math.max(maxc[i], maxc[i^(1<<j)]);
}
boolean ok = true;
for(int a = 0; a<fst; a++) if((i&1<<a) != 0) {
for(int b = a+1; b<fst; b++) if((i&1<<b) != 0) {
if(board[a][b] == 0) ok = false;
}
}
if(ok) {
maxc[i] = Integer.bitCount(i);
max = Math.max(max, maxc[i]);
}
}
for(int i = 0; i<(1<<snd); i++) {
boolean ok = true;
for(int a = 0; a<snd; a++) if((i&1<<a) != 0) {
for(int b = a+1; b<snd; b++) if((i&1<<b) != 0) {
if(board[a+fst][b+fst] == 0) ok = false;
}
}
if(!ok) continue;
int mask = 0;
for(int a = 0; a<fst; a++) {
ok = true;
for(int b = 0; b<snd; b++) {
if((i&1<<b) != 0) {
if(board[a][b+fst] == 0) ok = false;
}
}
if(ok) mask |= (1<<a);
}
max = Math.max(Integer.bitCount(i) + maxc[mask], max);
}
System.out.println(k*k*(max-1.0)/(2*max));
}
int toInt(String s) {return Integer.parseInt(s);}
int[] toInts(String s) {
String[] a = s.split(" ");
int[] o = new int[a.length];
for(int i = 0; i<a.length; i++) o[i] = toInt(a[i]);
return o;
}
void e(Object o) {
System.err.println(o);
}
public static void main(String[] args) throws Exception{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
(new E()).solve(in);
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
// public static StringTokenizer tokenizer;
// public static BufferedReader reader;
public static PrintWriter saida = new PrintWriter(System.out, false);
// public static String proximo() {
// while (tokenizer == null || !tokenizer.hasMoreElements()) {
// try {
// tokenizer = new StringTokenizer(reader.readLine());
// } catch (RuntimeException e) {
// e.printStackTrace();
// }
// }
// return tokenizer.nextToken();
// }
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(Reader in) {
br = new BufferedReader(in);
}
public FastScanner() {
this(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 readNextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static void main(String[] args) {
FastScanner fastScanner = new FastScanner();
int proximoInt = fastScanner.nextInt();
double proximoDouble = fastScanner.nextInt();
long[] graph = new long[proximoInt];
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = fastScanner.nextInt();
if (val.equals(1) || i.equals(j)) {
graph[i] |= 1L << j;
}
}
}
int szLeft = proximoInt/2;
int szRight = proximoInt - szLeft;
int[] dp = new int[1 << szLeft];
int maxMask = 1 << szLeft;
for(int mask = 1; mask <maxMask; mask++) {
int curMask = mask;
for(int j = 0; j < szLeft; j++) {
if (((1 << j) & mask) > 0) {
curMask &= graph[j + szRight] >> szRight;
dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << j)]);
}
}
if (mask == curMask) {
dp[mask] = Math.max(dp[mask],Integer.bitCount(mask));
}
}
int ans = 0;
int rmaxMask = 1 << szRight;
for(int mask = 0; mask < rmaxMask; mask++) {
int curMask = mask;
int oMask = maxMask -1;
for(int j = 0; j < szRight; j++) {
if (((1 << j) & mask) > 0) {
curMask &= (graph[j] & (rmaxMask-1));
oMask &= graph[j] >> szRight;
}
}
if (curMask != mask) continue;
ans = Math.max(ans, Integer.bitCount(mask) + dp[oMask]);
}
proximoDouble/=ans;
saida.println(proximoDouble * proximoDouble * (ans * (ans-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.util.*;
import java.io.*;
public class MotherOfDragons {
public static void main(String[] args) {
FastScanner scanner = new FastScanner();
PrintWriter out = new PrintWriter(System.out, false);
int n = scanner.nextInt();
double k = scanner.nextInt();
long[] graph = new long[n];
for(int i = 0; i < n; i++) {
for(int j =0; j < n; j++) {
int val = scanner.nextInt();
if (val == 1 || i == j) graph[i] |= 1L << j;
}
}
//meet in the middle approach
int szLeft = n/2;
int szRight = n - szLeft;
//max size of clique
int[] dp = new int[1 << szLeft];
int maxMask = 1 << szLeft;
//iterate over every left mask
for(int mask = 1; mask <maxMask; mask++) {
int curMask = mask;
//go over every bit in the mask
for(int j = 0; j < szLeft; j++) {
if (((1 << j) & mask) > 0) {
//update the union of reachability
curMask &= graph[j + szRight] >> szRight;
//can also attempt to pull from prev mask for max size
//will not be optimal if end update happens, but otherwise is useful for dp
dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << j)]);
}
}
//if the union of connectedness is the starting mask then we have a clique
if (mask == curMask) {
dp[mask] = Math.max(dp[mask],Integer.bitCount(mask));
}
}
int ans = 0;
int rmaxMask = 1 << szRight;
for(int mask = 0; mask < rmaxMask; mask++) {
//mask to track if the current creates its own clique
int curMask = mask;
//mask to track the connection between the halves
int oMask = maxMask -1;
for(int j = 0; j < szRight; j++) {
if (((1 << j) & mask) > 0) {
//need to mask out the left side bits
curMask &= (graph[j] & (rmaxMask-1));
//update corresp avail in the left side
oMask &= graph[j] >> szRight;
}
}
//not a clique portion
if (curMask != mask) continue;
//update answer
ans = Math.max(ans, Integer.bitCount(mask) + dp[oMask]);
}
k/=ans;
out.println(k * k * (ans * (ans-1))/2);
out.flush();
}
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(Reader in) {
br = new BufferedReader(in);
}
public FastScanner() {
this(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 readNextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.util.*;
import java.io.*;
public class MotherOfDragons {
public static void main(String[] args) {
FastScanner scanner = new FastScanner();
PrintWriter out = new PrintWriter(System.out, false);
int n = scanner.nextInt();
double k = scanner.nextInt();
long[] graph = new long[n];
for(int i = 0; i < n; i++) {
for(int j =0; j < n; j++) {
int val = scanner.nextInt();
if (val == 1 || i == j) graph[i] |= 1L << j;
}
}
//meet in the middle approach
int szLeft = n/2;
int szRight = n - szLeft;
//max size of clique
int[] dp = new int[1 << szLeft];
int maxMask = 1 << szLeft;
//iterate over every left mask
for(int mask = 1; mask <maxMask; mask++) {
int curMask = mask;
//go over every bit in the mask
for(int j = 0; j < szLeft; j++) {
if (((1 << j) & mask) > 0) {
//update the union of reachability
curMask &= graph[j + szRight] >> szRight;
//can also attempt to pull from prev mask for max size
//will not be optimal if end update happens, but otherwise is useful for dp
dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << j)]);
}
}
//if the union of connectedness is the starting mask then we have a clique
if (mask == curMask) {
dp[mask] = Math.max(dp[mask],Integer.bitCount(mask));
}
}
int ans = 0;
int rmaxMask = 1 << szRight;
for(int mask = 0; mask < rmaxMask; mask++) {
//mask to track if the current creates its own clique
int curMask = mask;
//mask to track the connection between the halves
int oMask = maxMask -1;
for(int j = 0; j < szRight; j++) {
if (((1 << j) & mask) > 0) {
//need to mask out the left side bits
curMask &= (graph[j] & (rmaxMask-1));
//update corresp avail in the left side
oMask &= graph[j] >> szRight;
}
}
//not a clique portion
if (curMask != mask) continue;
//update answer
ans = Math.max(ans, Integer.bitCount(mask) + dp[oMask]);
}
k/=ans;
out.println(k * k * (ans * (ans-1))/2);
out.flush();
}
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(Reader in) {
br = new BufferedReader(in);
}
public FastScanner() {
this(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 readNextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
} | np | 839_E. Mother of Dragons | CODEFORCES |
/**
*
* @author bossbelik
*/
import java.io.*;
import java.util.*;
import java.math.*;
public class Main{
static long N = 100;
static long CNT = 62;
static long INF = 1 << 62;
static long parsenum(long j, long l) {
String k = "";
long cur = 0;
for (int i = (int) j; i <= l; ++i) {
cur *= 10;
cur += k.charAt(i) - '0';
}
return cur;
}
static long gcd(long a, long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
static boolean pri(int k) {
if (k == 1) return false;
for (int i = 2; i * i <= k; i++) {
if (k % i == 0) return false;
}
return true;
}
static int[] calcz(String s) {
int l = 0;
int r = 0;
int n = s.length();
int z[] = new int[n];
for (int i = 1; i < n; i++) {
if (i <= r) {
z[i] = Math.min(z[i - l], r - i + 1);
}
while (i + z[i] < n && s.charAt(z[i]) == s.charAt(i + z[i])) z[i]++;
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
static int[] calcpref(String s) {
int p[] = new int[s.length() + 1];
int n = s.length();
p[0] = 0;
for (int i = 2; i <= n; i++) {
p[i] = p[i - 1];
while (p[i] > 0 && s.charAt(p[i]) != s.charAt(i - 1)) p[i] = p[p[i]];
if (s.charAt(p[i]) == s.charAt(i - 1)) p[i]++;
}
return p;
}
static long MOD = 1000000007;
static long binpow (long a, long n)
{
if (n == 0)
return 1;
if (n % 2 == 1)
return binpow (a % MOD, (n-1) % MOD ) * a % MOD;
else {
long b = binpow(a % MOD, n/2 % MOD) % MOD;
return (b * b) % MOD;
}
}
static int maxnum=105;
static int a[][] = new int[maxnum][maxnum];
static boolean used[] = new boolean[maxnum];
static int curr , cnt ,n ,m;
static void dfs(int i)
{
int j;
boolean flag;
if(i > n)
{
cnt = curr;
return ;
}
flag=true;
for(j = 1 ; j < i; j++)
{
if (used[j] && a[j][i] == 0)
{
flag = false;
break;
}
}
if(flag)
{
curr++;
used[i]=true;
dfs(i+1);
curr--;
}
if(curr + n - i > cnt)
{
used[i]=false;
dfs(i+1);
}
}
public static void main(String[] args) throws Exception
{
//
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter((System.out));
n = in.nextInt();
m = in.nextInt();
for(int i = 1 ; i <= n ; i++)
{
for (int j = 1; j <= n; j++)
{
a[i][j] = in.nextInt();
}
}
dfs(1);
out.printf( "%.10f", (double) m * m * (cnt-1) / (2 * cnt ));
out.println();
out.close();
return;
}
} | np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;
public class ELR {
public static void main(String[] args) {new Thread(null, new Runnable() { public void run() {try {
sol();
} catch (Throwable e) {
e.printStackTrace();
}}}, "2",1<<26).start();}
static int n,k;
static boolean adj[][];
static int dp1[],dp2[];
static int myMask[];
static int next1[];
static int m1,m2;
public static int solve1(int msk) {
if (dp1[msk] != -1) {
return dp1[msk];
}
int ret = 0;
int tmp = msk;
for (int i = 0 ; i < m1 ; ++i) {
if ( ((msk & (1 << i)) > 0)) {
tmp &= (myMask[i]);
}
}
if (tmp == msk) {
ret = Integer.bitCount(msk);
}
for (int i = 0 ; i < m1 ; ++i) {
if ( (msk & (1 << i)) > 0) {
ret = Math.max(ret, solve1(msk & ~(1 << i)));
}
}
return dp1[msk] = ret;
}
public static int solve2(int msk) {
if (dp2[msk] != -1) {
return dp2[msk];
}
int ret = 0;
int tmp = msk;
for (int i = 0 ; i < m2 ; ++i) {
if ( ((msk & (1 << i)) > 0)) {
tmp &= (myMask[i + m1]);
}
}
if (tmp == msk) {
ret = Integer.bitCount(msk);
}
for (int i = 0 ; i < m2 ; ++i) {
if ( (msk & (1 << i)) > 0) {
ret = Math.max(ret, solve2(msk & ~(1 << i)));
}
}
return dp2[msk] = ret;
}
public static void sol() throws Throwable {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
k = sc.nextInt();
adj = new boolean[n][n];
for (int i = 0 ; i < n ; ++i) {
for (int j = 0 ; j < n ; ++j) {
adj[i][j] = sc.nextInt() == 1;
}
}
m1= (n + 1) / 2;
m2 = n - m1;
dp1 = new int[1 << m1];
dp2 = new int[1 << m2];
next1 = new int[1 << m2];
Arrays.fill(dp1, -1);
Arrays.fill(dp2, -1);
myMask = new int[n];
for (int i = 0 ; i < n ; ++i) {
if (i >= m1) {
for (int j = m1 ; j < n ; ++j) {
if (adj[i][j] || i == j) {
myMask[i] |= (1 << (j - m1));
}
}
} else {
for (int j = m1 ; j < n ; ++j) {
if (adj[i][j]) {
next1[i] |= (1 << (j - m1));
}
}
for (int j = 0 ; j < m1 ; ++j) {
if (adj[i][j] || i == j) {
myMask[i] |= (1 << j);
}
}
}
}
for (int i = 0 ; i < (1 << m1) ; ++i) {
solve1(i);
}
for (int i = 0 ; i < (1 << m2) ; ++i) {
solve2(i);
}
int ans = 0;
for (int msk = 0 ; msk < (1 << m1) ; ++msk) {
int next = (1 << (m2)) - 1;
if (dp1[msk] != Integer.bitCount(msk)) {
continue;
}
for (int i = 0 ; i < m1 ; ++i) {
if ( (msk & (1 << i)) > 0) {
next &= next1[i];
}
}
ans = Math.max(ans, dp1[msk] + dp2[next]);
}
double cont = (k / (ans*1.0));
double edges = (ans) * (ans - 1) / 2.0;
double res = cont * cont * edges;
System.out.println(res);
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(String s) throws FileNotFoundException {
br = new BufferedReader(new FileReader(new File(s)));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public boolean ready() throws IOException {
return br.ready();
}
}
} | np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
public static PrintWriter saida = new PrintWriter(System.out, false);
public static class Escanear {
BufferedReader reader;
StringTokenizer tokenizer;
public Escanear() {
this(new InputStreamReader(System.in));
}
public Escanear(Reader in) {
reader = new BufferedReader(in);
}
String proximo() {
if (tokenizer == null || !tokenizer.hasMoreElements()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
int proximoNum() {
return Integer.parseInt(proximo());
}
}
public static void main(String[] args) {
Escanear escanear = new Escanear();
int proximoInt = escanear.proximoNum();
long[] aux = new long[proximoInt];
double proximoDouble = escanear.proximoNum();
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = escanear.proximoNum();
if (val.equals(1) || i.equals(j)) {
aux[i] |= 1L << j;
}
}
}
int esquerda = proximoInt/2;
int direita = proximoInt - esquerda;
int maiorMascara = 1 << esquerda;
int[] depois = new int[1 << esquerda];
Integer mascara = 1;
while (mascara < maiorMascara) {
int mascaraAtual = mascara;
for(int j = 0; j < esquerda; j++) {
if (((1 << j) & mascara) > 0) {
mascaraAtual &= aux[j + direita] >> direita;
depois[mascara] = Math.max(depois[mascara], depois[mascara ^ (1 << j)]);
}
}
if (mascara.equals(mascaraAtual)) {
depois[mascara] = Math.max(depois[mascara],Integer.bitCount(mascara));
}
mascara++;
}
// for(int mascara = 1; mascara < maiorMascara; mascara++) {
// int mascaraAtual = mascara;
// for(int j = 0; j < esquerda; j++) {
// if (((1 << j) & mascara) > 0) {
// mascaraAtual &= aux[j + direita] >> direita;
// depois[mascara] = Math.max(depois[mascara], depois[mascara ^ (1 << j)]);
// }
// }
// if (mascara == mascaraAtual) {
// depois[mascara] = Math.max(depois[mascara],Integer.bitCount(mascara));
// }
// }
int auxiliar = 0;
int mascaraMaxima = 1 << direita;
for(int masc = 0; masc < mascaraMaxima; masc++) {
int mascaraCorrente = masc;
int mascaraValor = maiorMascara -1;
for(int j = 0; j < direita; j++) {
if (((1 << j) & masc) > 0) {
mascaraCorrente &= (aux[j] & (mascaraMaxima-1));
mascaraValor &= aux[j] >> direita;
}
}
if (mascaraCorrente != masc) continue;
auxiliar = Math.max(auxiliar, Integer.bitCount(masc) + depois[mascaraValor]);
}
proximoDouble/=auxiliar;
saida.println(proximoDouble * proximoDouble * (auxiliar * (auxiliar-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.IOException;
import java.util.StringTokenizer;
/*
* @author Tnascimento
*/
public class MaeDosDragoes {
public static PrintWriter saida = new PrintWriter(System.out, false);
public static class Escanear {
BufferedReader reader;
StringTokenizer tokenizer;
public Escanear() {
this(new InputStreamReader(System.in));
}
public Escanear(Reader in) {
reader = new BufferedReader(in);
}
String proximo() {
while (tokenizer == null || !tokenizer.hasMoreElements()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(proximo());
}
}
public static void main(String[] args) {
Escanear fastScanner = new Escanear();
int proximoInt = fastScanner.nextInt();
double proximoDouble = fastScanner.nextInt();
long[] graph = new long[proximoInt];
for(Integer i = 0; i < proximoInt; i++) {
for(Integer j =0; j < proximoInt; j++) {
Integer val = fastScanner.nextInt();
if (val.equals(1) || i.equals(j)) {
graph[i] |= 1L << j;
}
}
}
int szLeft = proximoInt/2;
int szRight = proximoInt - szLeft;
int[] dp = new int[1 << szLeft];
int maxMask = 1 << szLeft;
for(int mask = 1; mask <maxMask; mask++) {
int curMask = mask;
for(int j = 0; j < szLeft; j++) {
if (((1 << j) & mask) > 0) {
curMask &= graph[j + szRight] >> szRight;
dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << j)]);
}
}
if (mask == curMask) {
dp[mask] = Math.max(dp[mask],Integer.bitCount(mask));
}
}
int ans = 0;
int rmaxMask = 1 << szRight;
for(int mask = 0; mask < rmaxMask; mask++) {
int curMask = mask;
int oMask = maxMask -1;
for(int j = 0; j < szRight; j++) {
if (((1 << j) & mask) > 0) {
curMask &= (graph[j] & (rmaxMask-1));
oMask &= graph[j] >> szRight;
}
}
if (curMask != mask) continue;
ans = Math.max(ans, Integer.bitCount(mask) + dp[oMask]);
}
proximoDouble/=ans;
saida.println(proximoDouble * proximoDouble * (ans * (ans-1))/2);
saida.flush();
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
public class E {
static InputStream is;
//String INPUT = "";
public static void main(String[] args) throws IOException {
is = System.in;
int n = ni();
int k = ni();
int[][] aj = new int[n][n];
for (int i = 0; i < aj.length; i++) {
aj[i] = na(n);
}
int F = (n+1)/2;
int B = n-F;
int[] spanftf = new int[F];
int[] spanftb = new int[F];
for(int i =0; i < F; i++){
for(int j =0; j < F; j++){
if(i == j || aj[i][j] == 1){
spanftf[i] |= 1<<j;
}
}
for(int j =0; j< B; j++){
if(aj[i][F+j] == 1){
spanftb[i] |= 1<<j;
}
}
}
int[] maxes = new int[1<<B];
for(int bm = 0; bm < (1<<F); bm++){
int anded = (1<<F)-1;
int spanToBack = (1<<B)-1;
for(int i =0; i < F; i++){
if((1<<i & bm) != 0){
anded &= spanftf[i];
spanToBack &= spanftb[i];
}
}
if((anded & bm) == bm){
maxes[spanToBack] = Math.max(maxes[spanToBack], Integer.bitCount(bm));
}
}
int[] spanbtb = new int[B];
for(int i =0; i < B; i++){
for(int j =0; j< B; j++){
if(aj[F+i][F+j] == 1 || i == j){
spanbtb[i] |= 1<<j;
}
}
}
boolean[] isgood = new boolean[1<<B];
for(int bm =0; bm < (1<<B); bm++){
int anded = (1<<B)-1;
for(int i =0; i < B; i++){
if((1<<i & bm) != 0){
anded &= spanbtb[i];
}
}
if((anded & bm) == bm){
isgood[bm] = true;
}
}
bybc[] tosort = new bybc[1<<B];
for (int i = 0; i < tosort.length; i++) {
tosort[i]= new bybc(i);
}
Arrays.sort(tosort);
int best = 1;
for (int i = 0; i < tosort.length; i++) {
int at =tosort[i].mask;
if(isgood[at]){
best = Math.max(best, maxes[at]+Integer.bitCount(at));
}
for(int j =0; j < B; j++){
if((1<<j & at) != 0){
int to = at - (1<<j);
maxes[to] = Math.max(maxes[to], maxes[at]);
}
}
}
//System.out.println("best: " + best);
double ans= best*(best-1)/2.0 * (k*k/(double)(best*best));
System.out.println(ans);
}
static class bybc implements Comparable<bybc>{
int mask;
public bybc(int mask) {
super();
this.mask = mask;
}
@Override
public int compareTo(bybc o) {
return Integer.bitCount(o.mask) - Integer.bitCount(mask);
}
}
private static byte[] inbuf = new byte[1024];
public static int lenbuf = 0, ptrbuf = 0;
private static int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private static int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private static double nd() { return Double.parseDouble(ns()); }
private static char nc() { return (char)skip(); }
private static String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private static char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private static char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private static int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private static int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
//private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
//private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
} | np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Random;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author tanzaku
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
MyInput in = new MyInput(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
int n;
int k;
long[] neigibor;
Random random = new Random();
long maxClique;
public void solve(int testNumber, MyInput in, PrintWriter out) {
n = in.nextInt();
k = in.nextInt();
neigibor = new long[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
neigibor[i] |= in.nextLong() << j;
}
}
long maxClique = bronKerbosch();
long a = Long.bitCount(maxClique);
dump(a);
out.printf("%.12f\n", a * (a - 1.0) / 2 * k / a * k / a);
}
static void dump(Object... o) {
System.err.println(Arrays.deepToString(o));
}
long bronKerbosch() {
maxClique = 0;
bronKerbosch2(0, (1L << n) - 1, 0);
return maxClique;
}
void bronKerbosch2(long r, long p, long x) {
// if (Long.bitCount(maxClique) >= Long.bitCount(r|p|x)) return;
long px = p | x;
if (px == 0) {
if (Long.bitCount(maxClique) < Long.bitCount(r)) {
maxClique = r;
}
return;
}
int cnt = Long.bitCount(px);
int choice = random.nextInt(cnt);
int u;
for (int i = 0; ; i++) {
if ((px >>> i & 1) != 0 && choice-- == 0) {
u = i;
break;
}
}
// dump(r, p, x, u, neigibor);
long ne = p & ~neigibor[u];
for (int v = 0; v < n; v++)
if ((ne >>> v & 1) != 0) {
bronKerbosch2(r | 1L << v, p & neigibor[v], x & neigibor[v]);
p &= ~(1L << v);
x |= 1L << v;
}
}
}
static class MyInput {
private final BufferedReader in;
private static int pos;
private static int readLen;
private static final char[] buffer = new char[1024 * 8];
private static char[] str = new char[500 * 8 * 2];
private static boolean[] isDigit = new boolean[256];
private static boolean[] isSpace = new boolean[256];
private static boolean[] isLineSep = new boolean[256];
static {
for (int i = 0; i < 10; i++) {
isDigit['0' + i] = true;
}
isDigit['-'] = true;
isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
isLineSep['\r'] = isLineSep['\n'] = true;
}
public MyInput(InputStream is) {
in = new BufferedReader(new InputStreamReader(is));
}
public int read() {
if (pos >= readLen) {
pos = 0;
try {
readLen = in.read(buffer);
} catch (IOException e) {
throw new RuntimeException();
}
if (readLen <= 0) {
throw new MyInput.EndOfFileRuntimeException();
}
}
return buffer[pos++];
}
public int nextInt() {
int len = 0;
str[len++] = nextChar();
len = reads(len, isSpace);
int i = 0;
int ret = 0;
if (str[0] == '-') {
i = 1;
}
for (; i < len; i++) ret = ret * 10 + str[i] - '0';
if (str[0] == '-') {
ret = -ret;
}
return ret;
}
public long nextLong() {
int len = 0;
str[len++] = nextChar();
len = reads(len, isSpace);
int i = 0;
long ret = 0;
if (str[0] == '-') {
i = 1;
}
for (; i < len; i++) ret = ret * 10 + str[i] - '0';
if (str[0] == '-') {
ret = -ret;
}
return ret;
}
public char nextChar() {
while (true) {
final int c = read();
if (!isSpace[c]) {
return (char) c;
}
}
}
int reads(int len, boolean[] accept) {
try {
while (true) {
final int c = read();
if (accept[c]) {
break;
}
if (str.length == len) {
char[] rep = new char[str.length * 3 / 2];
System.arraycopy(str, 0, rep, 0, str.length);
str = rep;
}
str[len++] = (char) c;
}
} catch (MyInput.EndOfFileRuntimeException e) {
}
return len;
}
static class EndOfFileRuntimeException extends RuntimeException {
}
}
}
| np | 839_E. Mother of Dragons | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class C {
static int[] nm;
static int ans = 0;
static int rows, cols;
static boolean[][] cae;
static int[][] ca;
public static void main(String[] args) throws IOException {
nm = readIntArray();
rows = Math.max(nm[0], nm[1]);
cols = Math.min(nm[0], nm[1]);
long s = System.currentTimeMillis();
cae = new boolean[1000][50];
ca = new int[1000][50];
StringBuilder sb = new StringBuilder();
for (int i = 0; i < cols; i++) {
sb.append('1');
}
int startingState = Integer.parseInt(sb.toString(), 3);
ans = solve(startingState, 0);
System.out.println(nm[0]*nm[1] - ans);
// System.out.println(System.currentTimeMillis() - s );
}
static int solve(int state, int row) {
if (row == rows) {
return 0;
}
if (cae[state][row]) {
return ca[state][row];
}
int ans = Integer.MAX_VALUE;
for (int i = 0; i < Math.pow(3, cols); i++) {
boolean isCover = covers(i, state);
if (isCover && (row < rows - 1 || coversTotally(i, state))) {
int p = placed(i);
int s = solve(i, row + 1);
ans = Math.min(ans, s + p);
}
}
cae[state][row] = true;
ca[state][row] = ans;
return ans;
}
private static boolean coversTotally(int i, int state) {
String bottom = decode(i);
for (int j = 0; j < bottom.length(); j++) {
if (bottom.charAt(j) == '0') {
return false;
}
}
return true;
}
private static boolean covers(int i, int state) {
String top = decode(state);
String bottom = decode(i);
for (int j = 0; j < top.length(); j++) {
if (top.charAt(j) == '0' && bottom.charAt(j) != '2') {
return false;
}
if (top.charAt(j) == '2' && bottom.charAt(j) == '0') {
return false;
}
}
for (int j = 0; j < top.length(); j++) {
if (bottom.charAt(j) == '1' && (top.charAt(j) != '2' && !(j > 0 && bottom.charAt(j-1) == '2') && !(j < top.length() - 1 && bottom.charAt(j+1) == '2'))) {
return false;
}
}
return true;
}
private static int placed(int i) {
String s = decode(i);
int cnt = 0;
for (int j = 0; j < s.length(); j++) {
if (s.charAt(j) == '2') {
cnt++;
}
}
return cnt;
}
private static String decode(int state) {
String tmp = Integer.toString(state, 3);
if (tmp.length() < cols) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < cols - tmp.length(); i++) {
sb.append('0');
}
sb.append(tmp);
return sb.toString();
} else {
return tmp;
}
}
static int countDispositionDivisors(int[] d) {
HashSet<Integer> div = new HashSet<Integer>();
for (int i = 1; i <= d.length; i++) {
for (int j = 0; j < d.length; j++) {
if ((j + 1) % i == 0 && d[j] % i == 0) {
div.add(j + 1);
break;
}
}
}
return div.size();
}
static InputStreamReader isr = new InputStreamReader(System.in);
static BufferedReader br = new BufferedReader(isr);
static int[] readIntArray() throws IOException {
String[] v = br.readLine().split(" ");
int[] ans = new int[v.length];
for (int i = 0; i < ans.length; i++) {
ans[i] = Integer.valueOf(v[i]);
}
return ans;
}
static long[] readLongArray() throws IOException {
String[] v = br.readLine().split(" ");
long[] ans = new long[v.length];
for (int i = 0; i < ans.length; i++) {
ans[i] = Long.valueOf(v[i]);
}
return ans;
}
static <T> void print(List<T> v) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < v.size(); i++) {
if (sb.length() > 0) {
sb.append(' ');
}
sb.append(v.get(i));
}
System.out.println(sb);
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class CodeJ
{
static class Scanner
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
public String nextLine()
{
try
{
return br.readLine();
}
catch(Exception e)
{
throw(new RuntimeException());
}
}
public String next()
{
while(!st.hasMoreTokens())
{
String l = nextLine();
if(l == null)
return null;
st = new StringTokenizer(l);
}
return st.nextToken();
}
public int nextInt()
{
return Integer.parseInt(next());
}
public long nextLong()
{
return Long.parseLong(next());
}
public double nextDouble()
{
return Double.parseDouble(next());
}
public int[] nextIntArray(int n)
{
int[] res = new int[n];
for(int i = 0; i < res.length; i++)
res[i] = nextInt();
return res;
}
public long[] nextLongArray(int n)
{
long[] res = new long[n];
for(int i = 0; i < res.length; i++)
res[i] = nextLong();
return res;
}
public double[] nextDoubleArray(int n)
{
double[] res = new double[n];
for(int i = 0; i < res.length; i++)
res[i] = nextLong();
return res;
}
public void sortIntArray(int[] array)
{
Integer[] vals = new Integer[array.length];
for(int i = 0; i < array.length; i++)
vals[i] = array[i];
Arrays.sort(vals);
for(int i = 0; i < array.length; i++)
array[i] = vals[i];
}
public void sortLongArray(long[] array)
{
Long[] vals = new Long[array.length];
for(int i = 0; i < array.length; i++)
vals[i] = array[i];
Arrays.sort(vals);
for(int i = 0; i < array.length; i++)
array[i] = vals[i];
}
public void sortDoubleArray(double[] array)
{
Double[] vals = new Double[array.length];
for(int i = 0; i < array.length; i++)
vals[i] = array[i];
Arrays.sort(vals);
for(int i = 0; i < array.length; i++)
array[i] = vals[i];
}
}
static int nFilas;
static int nColumnas;
static byte[][][][][] dp;
static byte dp(int mascaraActual, int enviadosActual, int enviadosSiguiente, int filaActual, int columnaActual)
{
if(dp[mascaraActual][enviadosActual][enviadosSiguiente][filaActual][columnaActual] != Byte.MAX_VALUE)
return dp[mascaraActual][enviadosActual][enviadosSiguiente][filaActual][columnaActual];
if(filaActual == nFilas)
return dp[mascaraActual][enviadosActual][enviadosSiguiente][filaActual][columnaActual] = 0;
if(columnaActual == nColumnas)
{
int ambos = mascaraActual & enviadosSiguiente;
int mascaraSiguiente = (1 << nColumnas) - 1;
mascaraSiguiente ^= ambos;
int mascaraEnviados = enviadosSiguiente;
mascaraEnviados ^= ambos;
return dp[mascaraActual][enviadosActual][enviadosSiguiente][filaActual][columnaActual] = (byte) (nColumnas - Integer.bitCount(mascaraActual) + dp(mascaraSiguiente, mascaraEnviados, 0, filaActual + 1, 0));
}
if(((mascaraActual & (1 << columnaActual)) == 0))
{
// me envian desde abajo
byte a = dp(mascaraActual | (1 << columnaActual), enviadosActual, enviadosSiguiente | (1 << columnaActual), filaActual, columnaActual + 1);
// normal
byte b = dp(mascaraActual, enviadosActual, enviadosSiguiente, filaActual, columnaActual + 1);
return dp[mascaraActual][enviadosActual][enviadosSiguiente][filaActual][columnaActual] = (byte) Math.max(a, b);
}
if((enviadosActual & (1 << columnaActual)) != 0)
{
byte a = dp(mascaraActual, enviadosActual, enviadosSiguiente | (1 << columnaActual), filaActual, columnaActual + 1);
byte b = dp(mascaraActual, enviadosActual, enviadosSiguiente, filaActual, columnaActual + 1);
return dp[mascaraActual][enviadosActual][enviadosSiguiente][filaActual][columnaActual] = (byte) Math.max(a, b);
}
// izquierda
byte ans = 0;
if(columnaActual != 0)
ans = (byte) Math.max(ans, dp((mascaraActual ^ (1 << columnaActual)) | (1 << (columnaActual - 1)), enviadosActual, enviadosSiguiente, filaActual, columnaActual + 1));
// derecha
if(columnaActual != nColumnas - 1)
ans = (byte) Math.max(ans, dp((mascaraActual ^ (1 << columnaActual)) | (1 << (columnaActual + 1)), enviadosActual | (1 << (columnaActual + 1)), enviadosSiguiente, filaActual, columnaActual + 1));
// abajo
if(filaActual != nFilas - 1)
ans = (byte) Math.max(ans, dp((mascaraActual ^ (1 << columnaActual)), enviadosActual, enviadosSiguiente | (1 << columnaActual), filaActual, columnaActual + 1));
// quieto
ans = (byte) Math.max(ans, dp(mascaraActual, enviadosActual, enviadosSiguiente, filaActual, columnaActual + 1));
return dp[mascaraActual][enviadosActual][enviadosSiguiente][filaActual][columnaActual] = ans;
}
public static void main(String[] args)
{
Scanner sc = new Scanner();
int a = sc.nextInt();
int b = sc.nextInt();
nFilas = Math.max(a, b);
nColumnas = Math.min(a, b);
dp = new byte[1 << nColumnas][1 << nColumnas][1 << nColumnas][nFilas + 1][nColumnas + 1];
for(byte[][][][] i : dp)
for(byte[][][] j : i)
for(byte[][] k : j)
for(byte[] l : k)
Arrays.fill(l, Byte.MAX_VALUE);
System.out.println(dp((1 << nColumnas) - 1, 0, 0, 0, 0));
}
} | np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
// Petya and Spiders
// 2012/08/16
public class P111C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int h, w;
void run(){
h=sc.nextInt();
w=sc.nextInt();
solve();
}
void solve(){
n=w*h;
g=new long[n];
int[] dx={0, 0, -1, 1};
int[] dy={-1, 1, 0, 0};
for(int y=0; y<h; y++){
for(int x=0; x<w; x++){
for(int k=0; k<4; k++){
int x2=x+dx[k];
int y2=y+dy[k];
if(x2>=0&&x2<w&&y2>=0&&y2<h){
g[y*w+x]|=1L<<(y2*w+x2);
}
}
}
}
mds=(1L<<n)-1;
mds(0, 0, 0);
println((n-Long.bitCount(mds))+"");
}
int n;
long[] g;
long mds;
void mds(long choosed, long removed, long covered){
if(Long.bitCount(choosed)>=Long.bitCount(mds))
return;
if(covered==((1L<<n)-1)){
mds=choosed;
return;
}
long s=covered;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
s|=(1L<<i)|g[i];
}
if(s!=((1L<<n)-1))
return;
int k=-1;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
if((covered>>>i&1)==1){
if(Long.bitCount(g[i]&~covered)==0){
mds(choosed, removed|(1L<<i), covered);
return;
}else if(Long.bitCount(g[i]&~covered)==1
&&(g[i]&~covered&~removed)!=0){
mds(choosed, removed|(1L<<i), covered);
return;
}
}else{
if(Long.bitCount(g[i]&~removed)==0){
mds(choosed|(1L<<i), removed|(1L<<i), covered|(1L<<i)|g[i]);
return;
}else if(Long.bitCount(g[i]&~removed)==1
&&((g[i]&~removed)|(g[i]&~covered))==(g[i]&~removed)){
int j=Long.numberOfTrailingZeros(g[i]&~removed);
mds(choosed|(1L<<j), removed|(1L<<i)|(1L<<j), covered
|(1L<<j)|g[j]);
return;
}
}
if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered))
k=i;
}
if(k==-1)
return;
mds(choosed|(1L<<k), removed|(1L<<k), covered|(1L<<k)|g[k]);
mds(choosed, removed|(1L<<k), covered);
}
void println(String s){
System.out.println(s);
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args){
Locale.setDefault(Locale.US);
new P111C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
// Petya and Spiders
// 2011/9/3
public class P111C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
int n, m;
void run(){
n=sc.nextInt();
m=sc.nextInt();
solve();
}
void solve(){
if(n<m){
int t=n;
n=m;
m=t;
}
int full=(1<<m)-1;
int[][] dp=new int[1<<m][1<<m];
int[][] tmp=new int[1<<m][1<<m];
for(int i=0; i<1<<m; i++){
fill(dp[i], INF);
}
for(int i=0; i<1<<m; i++){
int b1=(i|(i>>1)|(i<<1))&full;
int b2=i;
dp[b1][b2]=Integer.bitCount(i);
}
for(int j=0; j<n-1; j++){
for(int i=0; i<1<<m; i++){
System.arraycopy(dp[i], 0, tmp[i], 0, 1<<m);
fill(dp[i], INF);
}
for(int b1=0; b1<1<<m; b1++){
for(int b2=0; b2<1<<m; b2++){
for(int i=0; i<1<<m; i++){
if((b1|i)!=full){
continue;
}
int b=(i|(i>>1)|(i<<1))&full;
dp[b2|b][i]=min(dp[b2|b][i],
tmp[b1][b2]+Integer.bitCount(i));
}
}
}
}
int min=INF;
for(int i=0; i<1<<m; i++){
min=min(min, dp[full][i]);
}
int ans=m*n-min;
println(ans+"");
}
void println(String s){
System.out.println(s);
}
public static void main(String[] args){
new P111C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.*;
import java.util.*;
public class Main
{
static final boolean _DEBUG = false;
private static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner(BufferedReader _br) {
br = _br;
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
e.printStackTrace();
return "";
}
}
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 MyScanner scan;
static PrintWriter out;
static int debugCount = 0;
static void debug(String msg) {
if (_DEBUG && debugCount < 200) {
out.println(msg);
out.flush();
debugCount++;
}
}
public static void main (String args[]) throws IOException {
// scan = new MyScanner(new BufferedReader(new FileReader("test.in")));
scan = new MyScanner(new BufferedReader(new InputStreamReader(System.in)));
out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
Main inst = new Main();
inst.execute();
out.close();
}
int N, M, pow;
int[] counts;
int[][][] dp;
void execute() {
N = scan.nextInt();
M = scan.nextInt();
if (N < M) {
int temp = N;
N = M;
M = temp;
}
pow = 1<<M;
counts = new int[pow];
dp = new int[N][pow][pow];
for (int[][] i : dp) {
for (int[] j : i) {
Arrays.fill(j, -1);
}
}
for (int i = 0; i < pow; i++) {
counts[i] = Integer.bitCount(i);
dp[0][i][0] = counts[i];
}
int spiders = Integer.MAX_VALUE;
for (int y = 0; y < N-1; y++) {
for (int i = 0; i < pow; i++) {
for (int j = 0; j < pow; j++) {
if (dp[y][i][j] == -1) {
continue;
}
for (int k = 0; k < pow; k++) {
if (((i|(i<<1)|(i>>1)|j|k)&(pow-1))==(pow-1)) {
int value = dp[y][i][j] + counts[k];
if (dp[y+1][k][i] == -1 || dp[y+1][k][i] > value) {
dp[y+1][k][i] = value;
}
}
}
}
}
}
// for (int i = 0; i < N; i++) {
// System.out.println(Arrays.deepToString(dp[i]));
// }
for (int i = 0; i < pow; i++) {
for (int j = 0; j < pow; j++) {
if (dp[N-1][i][j] != -1 && ((i|(i<<1)|(i>>1)|j)&(pow-1))==(pow-1)) {
spiders = Math.min(spiders, dp[N-1][i][j]);
// System.out.println(spiders+" "+i+" "+j);
}
}
}
out.println((N*M)-spiders);
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
public class cf112e {
static int n,m,s;
static int[][][] memo;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
m = in.nextInt();
if(n > m) {
int tmp = n;
n = m;
m = tmp;
}
s = (1<<n);
memo = new int[s][s][m];
for(int i=0; i<s; i++)
for(int j=0; j<s; j++)
Arrays.fill(memo[i][j], -1);
int ret = go(0,0,0);
System.out.println(n*m - ret);
}
static int go(int last, int trans, int r) {
if(r==m) {
if(trans == 0) return 0;
return 100;
}
if(memo[last][trans][r] != -1) return memo[last][trans][r];
int best = 100;
for(int crnt = 0; crnt < s; crnt++) {
if((trans & ~crnt) != 0) continue; //certain ones have to be here
for(int pass = 0; pass < s; pass++) {
int tmp = ((1<<n)-1) & ~last; //move back the ones you can
if((pass & ~tmp) != 0) continue; //certain ones have to move on
tmp = tmp & ~pass; //find which ones stay
boolean fail = false;
for(int k=0; k<n; k++) //make sure that the ones that stay
if(isSet(tmp,k) && !(isSet(crnt,k-1) || isSet(crnt,k) || isSet(crnt,k+1)))
fail = true;
if(fail) continue;
best = Math.min(best, Integer.bitCount(crnt) + go(crnt,pass,r+1));
}
}
return memo[last][trans][r] = best;
}
static boolean isSet(int x, int p) {
if(p < 0 || p >= n) return false;
return (x & (1<<p)) != 0;
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
/**
* Author -
* User: kansal
* Date: 9/3/11
* Time: 5:28 PM
*/
public class CF85E {
public static void main(String[] args) {
reader = new BufferedReader(new InputStreamReader(System.in));
int height = nextInt(), width = nextInt();
if (width > height) {
int t = width;
width = height;
height = t;
}
final int INF = height * width + 10;
int[][][] dp = new int[height + 1][1 << width][1 << width];
for (int[][] ints : dp) {
for (int[] anInt : ints) {
Arrays.fill(anInt, INF);
}
}
dp[0][0][0] = 0;
for(int r = 0; r < height; ++r) {
for(int uncovered = 0; uncovered < (1 << width); ++uncovered) {
for(int mask = 0; mask < (1 << width); ++mask) {
if (dp[r][uncovered][mask] == INF) {
continue;
}
for(int curMask = uncovered; curMask < (1 << width); curMask = (curMask + 1) | uncovered) {
int curUncovered = (1 << width) - 1;
for(int i = 0; i < width; ++i) {
if (hasBit(mask, i) || hasBit(curMask, i)) {
curUncovered &= ~(1 << i);
}
if (i > 0 && hasBit(curMask, i-1)) {
curUncovered &= ~(1 << i);
}
if (i < width-1 && hasBit(curMask, i+1)) {
curUncovered &= ~(1 << i);
}
}
dp[r+1][curUncovered][curMask] = Math.min(dp[r+1][curUncovered][curMask], dp[r][uncovered][mask] + Integer.bitCount(curMask));
}
}
}
}
int res = INF;
for(int x: dp[height][0]) res = Math.min(res, x);
System.out.println(height * width - res);
}
private static boolean hasBit(int mask, int bit) {
return (((mask >> bit) & 1) == 1);
}
public static BufferedReader reader;
public static StringTokenizer tokenizer = null;
static String nextToken() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
static public int nextInt() {
return Integer.parseInt(nextToken());
}
static public long nextLong() {
return Long.parseLong(nextToken());
}
static public String next() {
return nextToken();
}
static public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException {
try {
if (new File("input.txt").exists())
System.setIn(new FileInputStream("input.txt"));
} catch (SecurityException e) {
}
new Thread(null, new Runnable() {
public void run() {
try {
new Main().run();
} catch (Throwable e) {
e.printStackTrace();
exit(999);
}
}
}, "1", 1 << 23).start();
}
BufferedReader in;
PrintWriter out;
StringTokenizer st = new StringTokenizer("");
int n, m;
int dp[][][];
int MV = Integer.MAX_VALUE >> 1;
int ans = MV;
private void run() throws IOException {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
n = nextInt();
m = nextInt();
if(n < m){ int d = n; n = m; m = d; }
int M = 1 << m;
dp = new int[n][M][M];
for(int a[][] : dp)
for(int b[] : a)
fill(b, MV);
// for(int i = 0 ; i < M; i++){
// int next = (( i | (i << 1) | (i >> 1) ) & (M - 1));
// if( next!= (M -1))
// continue;
// if(n > 1)
// dp[0][next][0] = Integer.bitCount(i);
// else
// ans = min(ans, Integer.bitCount(i));
// }
dp[0][0][0] = 0;
for(int i = 0; i < n; i++)
for(int m1 = 0; m1 < M; m1++)
for(int m2 = 0; m2 < M; m2++){
if(dp[i][m1][m2] == MV)
continue;
for(int nm1 = 0; nm1 < M; nm1++)
for(int nm2 = 0; nm2 < M; nm2++){
int res1 = m1 | (nm1) | (nm1 << 1) | (nm1 >> 1) | (nm2);
res1 &= (M - 1);
if(res1 != (M - 1))
continue;
int res2 = m2 | (nm1) | (nm2 << 1) | (nm2 >> 1) | (nm2);
res2 &= (M - 1);
// if(i == 2 && m1 == 3 && m2 == 2 && nm1 == 0 && nm2 == 0){
// System.err.println("kek");
// System.err.println(dp[i][m1][m2]);
// System.err.println(res1 + " | " + res2);
// System.err.println(M);
// }
int next1 = res2 & (M - 1);
int next2 = nm2 & ( M - 1);
int over = Integer.bitCount(nm1) + Integer.bitCount(nm2);
if(i < n - 1)
dp[i+1][next1][next2] = min(dp[i + 1][next1][next2], dp[i][m1][m2] + over);
else
if((res1 & (M - 1)) == (M - 1)){
ans = min(dp[i][m1][m2] + over, ans);
}
}
}
// System.err.println(ans);
out.println(n * m - ans);
in.close();
out.close();
}
String nextToken() throws IOException {
while (!st.hasMoreTokens())
st = new StringTokenizer(in.readLine());
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
String nextLine() throws IOException {
st = new StringTokenizer("");
return in.readLine();
}
boolean EOF() throws IOException {
while (!st.hasMoreTokens()) {
String s = in.readLine();
if (s == null)
return true;
st = new StringTokenizer(s);
}
return false;
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
/*************************************************************************
> File Name: cf111c.java
> Author: Yuchen Wang
> Mail: [email protected]
> Created Time: Sat Feb 11 16:51:01 2017
************************************************************************/
import java.util.*;
import java.io.*;
public class cf111c
{
public static int n,m,maxm;
public static int[][][] dp;
public static int[] s;
public static int cal(int cur)
{
int res = 0;
while(cur>0){
res ++;
cur = cur&(cur-1);
}
return res;
}
public static boolean check(int a,int b,int c)
{
int res = (maxm-1) & (b | (b<<1) | (b>>1) | a | c);
if(res == maxm-1)return true;
else return false;
}
public static void main(String[] argv)
{
Scanner in = new Scanner(System.in);
n = in.nextInt();
m = in.nextInt();
if(n<m){
int t = m;
m = n;
n = t;
}
maxm = 1<<m;
int i,j,k,l;
dp = new int[n+1][1<<m][1<<m];
s = new int[1<<m];
for(i=0;i<n+1;i++){
for(j=0;j<maxm;j++){
Arrays.fill(dp[i][j],100);
}
}
for(i=0;i<maxm;i++){
s[i] = cal(i);
dp[0][0][i] = 0;
}
for(i=1;i<=n;i++){
for(j=0;j<maxm;j++){
for(k=0;k<maxm;k++){
for(l=0;l<maxm;l++){
if(dp[i-1][k][l]!=100 && check(k,l,j)){
dp[i][l][j] = Math.min(dp[i-1][k][l]+s[l],dp[i][l][j]);
}
}
}
}
}
int ans = 100;
for(i=0;i<maxm;i++)
ans = Math.min(dp[n][i][0],ans);
System.out.println(n*m-ans);
return;
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.Arrays;
/**
* Created by IntelliJ IDEA.
* User: piyushd
* Date: 3/26/11
* Time: 10:53 PM
* To change this template use File | Settings | File Templates.
*/
public class TaskC {
final int INF = 123456;
int[][][] memo;
int N, M;
int solve(int row, int prevFreeMask, int curStayMask) {
if(row == N) return (curStayMask == 0) ? 0 : -INF;
if(memo[row][prevFreeMask][curStayMask] != -1) return memo[row][prevFreeMask][curStayMask];
int res = 0;
for(int mask = 0; mask < (1<<M); mask++) {
if((mask & curStayMask) == curStayMask) {
int freeCellsMask = (1<<M) - 1 - mask;
int toMoveMask = freeCellsMask;
for(int i = 0; i < M; i++) {
if((toMoveMask & (1<<i)) > 0) {
if(i > 0) {
if((mask & (1<<(i - 1))) > 0) {
toMoveMask -= (1<<i);
continue;
}
}
if(i < M - 1) {
if((mask & (1<<(i + 1))) > 0) {
toMoveMask -= (1<<i);
continue;
}
}
}
}
if (row > 0) {
for (int prevFillMask = toMoveMask; prevFillMask > 0; prevFillMask = (prevFillMask - 1) & toMoveMask) {
int bc1 = Integer.bitCount(freeCellsMask);
int bc2 = Integer.bitCount(prevFreeMask & prevFillMask);
res = Math.max(res, bc1 - bc2 + solve(row + 1, freeCellsMask, toMoveMask ^ prevFillMask));
}
}
res = Math.max(res, Integer.bitCount(freeCellsMask) + solve(row + 1, freeCellsMask, toMoveMask));
}
}
return memo[row][prevFreeMask][curStayMask] = res;
}
void run() {
N = nextInt();
M = nextInt();
if(M > N) {
int temp = M;
M = N;
N = temp;
}
this.memo = new int[N + 1][1<<M][1<<M];
for(int[][] g : memo) for(int[] f : g) Arrays.fill(f, -1);
System.out.println(solve(0, 0, 0));
}
int nextInt(){
try{
int c = System.in.read();
if(c == -1) return c;
while(c != '-' && (c < '0' || '9' < c)){
c = System.in.read();
if(c == -1) return c;
}
if(c == '-') return -nextInt();
int res = 0;
do{
res *= 10;
res += c - '0';
c = System.in.read();
}while('0' <= c && c <= '9');
return res;
}catch(Exception e){
return -1;
}
}
long nextLong(){
try{
int c = System.in.read();
if(c == -1) return -1;
while(c != '-' && (c < '0' || '9' < c)){
c = System.in.read();
if(c == -1) return -1;
}
if(c == '-') return -nextLong();
long res = 0;
do{
res *= 10;
res += c-'0';
c = System.in.read();
}while('0' <= c && c <= '9');
return res;
}catch(Exception e){
return -1;
}
}
double nextDouble(){
return Double.parseDouble(next());
}
String next(){
try{
StringBuilder res = new StringBuilder("");
int c = System.in.read();
while(Character.isWhitespace(c))
c = System.in.read();
do{
res.append((char)c);
}while(!Character.isWhitespace(c=System.in.read()));
return res.toString();
}catch(Exception e){
return null;
}
}
String nextLine(){
try{
StringBuilder res = new StringBuilder("");
int c = System.in.read();
while(c == '\r' || c == '\n')
c = System.in.read();
do{
res.append((char)c);
c = System.in.read();
}while(c != '\r' && c != '\n');
return res.toString();
}catch(Exception e){
return null;
}
}
public static void main(String[] args){
new TaskC().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.ArrayList;
import java.util.List;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.util.Iterator;
import java.io.*;
import java.util.Comparator;
import java.util.Arrays;
import java.util.Collection;
/**
* Generated by Contest helper plug-in
* Actual solution is at the bottom
*/
public class Main {
public static void main(String[] args) {
InputReader in = new StreamInputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
run(in, out);
}
public static void run(InputReader in, PrintWriter out) {
Solver solver = new TaskC();
solver.solve(1, in, out);
Exit.exit(in, out);
}
}
abstract class InputReader {
private boolean finished = false;
public abstract int read();
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuffer res = new StringBuffer();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public void setFinished(boolean finished) {
this.finished = finished;
}
public abstract void close();
}
class StreamInputReader extends InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public StreamInputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public void close() {
try {
stream.close();
} catch (IOException ignored) {
}
}
}
class Exit {
private Exit() {
}
public static void exit(InputReader in, PrintWriter out) {
in.setFinished(true);
in.close();
out.close();
}
}
interface Solver {
public void solve(int testNumber, InputReader in, PrintWriter out);
}
class ArrayUtils {
public static void fill(int[][] array, int value) {
for (int[] row : array)
Arrays.fill(row, value);
}
public static void fill(int[][][] array, int value) {
for (int[][] subArray : array)
fill(subArray, value);
}
}
class TaskC implements Solver {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int rowCount = in.readInt();
int columnCount = in.readInt();
out.println(rowCount * columnCount - go(Math.min(rowCount, columnCount), Math.max(rowCount, columnCount)));
}
private int go(int rowCount, int columnCount) {
int[][][] result = new int[columnCount][rowCount][1 << (2 * rowCount)];
ArrayUtils.fill(result, -1);
return go(0, 0, (1 << rowCount) - 1, result);
}
private int go(int column, int row, int mask, int[][][] result) {
if (column == result.length)
return (mask == 0 ? 0 : Integer.MAX_VALUE / 2);
int length = result[column].length;
if (row == length)
return go(column + 1, 0, mask, result);
if (result[column][row][mask] != -1)
return result[column][row][mask];
result[column][row][mask] = Integer.MAX_VALUE / 2;
if ((mask >> (2 * length - 1) & 1) == 0)
result[column][row][mask] = go(column, row + 1, mask * 2 + (column == result.length - 1 ? 0 : 1), result);
int newMask = mask;
newMask &= ~(1 << (length - 1));
if (row != 0)
newMask &= ~(1 << length);
if (row != length - 1)
newMask &= ~(1 << (length - 2));
newMask *= 2;
newMask &= (1 << (2 * length)) - 1;
return result[column][row][mask] = Math.min(result[column][row][mask], 1 + go(column, row + 1, newMask, result));
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import static java.util.Arrays.*;
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import java.util.*;
import java.math.*;
import java.io.*;
public class C implements Runnable
{
String file = "input";
boolean TEST = false;
void solve() throws IOException
{
rows = nextInt();
cols = nextInt();
if(cols > rows)
{
int t = rows; rows = cols; cols = t;
}
dp = new int[rows][cols][1 << cols][1 << cols][1 << cols];
for(int i = 0; i < rows; i++)
for(int j = 0; j < cols; j++)
for(int k = 0; k < 1 << cols; k++)
for(int u = 0; u < 1 << cols; u++)
for(int v = 0; v < 1 << cols; v++) dp[i][j][k][u][v] = -1;
out.println(go(0, 0, 0, 0, 0));
}
int rows, cols;
int[][][][][] dp;
int INF = 1 << 20;
int go(int i, int j, int a, int b, int c)
{
if(i == rows)
{
return a == 0 && b == 0 && c == 0 ? 0 : -INF;
}
if(i + 1 == rows && b != 0 && c != 0) return -INF;
if(i + 2 == rows && c != 0) return -INF;
if(j == cols)
{
return go(i + 1, 0, b, c, 0);
}
if(dp[i][j][a][b][c] != -1) return dp[i][j][a][b][c];
if(!test(a, j, -1, -1)) return go(i, j + 1, a, b, c);
int res = -INF;
//1
if(test(a, j, -1, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), b, c));
//2
if(test(a, j, -1, -1) && test(b, j, -1, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j, -1, -1), c) + 1);
//3
if(j + 2 <= cols && test(a, j, j + 1, -1))
res = max(res, go(i, j + 2, set(a, j, j + 1, -1), b, c) + 1);
//4
if(j + 3 <= cols && test(a, j, j + 1, j + 2))
res = max(res, go(i, j + 2, set(a, j, j + 1, j + 2), b, c) + 2);
//5
if(test(a, j, -1, -1) && test(b, j, -1, -1) && test(c, j, -1, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j, -1, -1), set(c, j, -1, -1)) + 2);
//6
if(j - 1 >= 0 && test(a, j, -1, -1) && test(b, j - 1, j, -1) && test(c, j, -1, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j - 1, j, -1), set(c, j, -1, -1)) + 3);
//7
if(j + 2 <= cols && test(a, j, -1, -1) && test(b, j, j + 1, -1) && test(c, j, -1, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j, j + 1, -1), set(c, j, -1, -1)) + 3);
//8
if(j + 3 <= cols && test(a, j, j + 1, j + 2) && test(b, j + 1, -1, -1))
res = max(res, go(i, j + 3, set(a, j, j + 1, j + 2), set(b, j + 1, -1, -1), c) + 3);
//9
if(j + 2 <= cols && j - 1 >= 0 && test(b, j - 1, j, j + 1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j - 1, j, j + 1), c) + 3);
//10
if(j + 2 <= cols && j - 1 >= 0 && test(b, j - 1, j, j + 1) && test(c, j, -1, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j - 1, j, j + 1), set(c, j, -1, -1)) + 4);
//11
if(j + 2 <= cols && test(b, j, j + 1, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j, j + 1, -1), c) + 2);
//12
if(j - 1 >= 0 && test(b, j - 1, j, -1))
res = max(res, go(i, j + 1, set(a, j, -1, -1), set(b, j - 1, j, -1), c) + 2);
//13
if(j + 2 <= cols && test(a, j, j + 1, -1) && test(b, j, -1, -1))
res = max(res, go(i, j + 2, set(a, j, j + 1, -1), set(b, j, -1, -1), c) + 2);
//14
if(j + 2 <= cols && test(a, j, j + 1, -1) && test(b, j + 1, -1, -1))
res = max(res, go(i, j + 2, set(a, j, j + 1, -1), set(b, j + 1, -1, -1), c) + 2);
return dp[i][j][a][b][c] = res;
}
int set(int a, int i, int j, int k)
{
if(i != -1) a |= 1 << i;
if(j != -1) a |= 1 << j;
if(k != -1) a |= 1 << k;
return a;
}
boolean test(int a, int i, int j, int k)
{
if(i != -1 && (a >> i & 1) != 0) return false;
if(j != -1 && (a >> j & 1) != 0) return false;
if(k != -1 && (a >> k & 1) != 0) return false;
return true;
}
String next() throws IOException
{
while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(input.readLine());
return st.nextToken();
}
int nextInt() throws IOException
{
return Integer.parseInt(next());
}
long nextLong() throws IOException
{
return Long.parseLong(next());
}
double nextDouble() throws IOException
{
return Double.parseDouble(next());
}
void print(Object... o)
{
System.out.println(deepToString(o));
}
void gcj(Object o)
{
String s = String.valueOf(o);
out.println("Case #" + test + ": " + s);
System.out.println("Case #" + test + ": " + s);
}
BufferedReader input;
PrintWriter out;
StringTokenizer st;
int test;
void init() throws IOException
{
if(TEST) input = new BufferedReader(new FileReader(file + ".in"));
else input = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new BufferedOutputStream(System.out));
}
public static void main(String[] args) throws IOException
{
new Thread(null, new C(), "", 1 << 20).start();
}
public void run()
{
try
{
init();
if(TEST)
{
int runs = nextInt();
for(int i = 0; i < runs; i++) solve();
}
else solve();
out.close();
}
catch(Exception e)
{
e.printStackTrace();
System.exit(1);
}
}
} | np | 111_C. Petya and Spiders | CODEFORCES |
import java.lang.*;
import java.math.BigInteger;
import java.io.*;
import java.util.*;
public class Solution implements Runnable{
public static BufferedReader br;
public static PrintWriter out;
public static StringTokenizer stk;
public static boolean isStream = true;
public static void main(String[] args) throws IOException {
if (isStream) {
br = new BufferedReader(new InputStreamReader(System.in));
} else {
br = new BufferedReader(new FileReader("in.txt"));
}
out = new PrintWriter(System.out);
new Thread(new Solution()).start();
}
public void loadLine() {
try {
stk = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
public String nextLine() {
try {
return br.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
public String nextWord() {
while (stk==null||!stk.hasMoreTokens()) loadLine();
return stk.nextToken();
}
public Integer nextInt() {
while (stk==null||!stk.hasMoreTokens()) loadLine();
return Integer.valueOf(stk.nextToken());
}
public Long nextLong() {
while (stk==null||!stk.hasMoreTokens()) loadLine();
return Long.valueOf(stk.nextToken());
}
public Double nextDouble() {
while (stk==null||!stk.hasMoreTokens()) loadLine();
return Double.valueOf(stk.nextToken());
}
public Float nextFloat() {
while (stk==null||!stk.hasMoreTokens()) loadLine();
return Float.valueOf(stk.nextToken());
}
public void run() {
int n = nextInt();
int m = nextInt();
if (n > m) {
int sw = n;
n = m;
m = sw;
}
int[][] A = new int[1<<n][1<<n];
for (int m1 = 0; m1 < 1<<n; ++m1) { // Who goes out
for (int m2 = 0; m2 < 1<<n; ++m2) { // Who comes
int[] arr = new int[n]; // Who remains
for (int i = 0; i < n; ++i) {
arr[i] = (~(m1>>i))&1;
}
int[] m2a = new int[n];
for (int i = 0; i < n; ++i) {
m2a[i] = (m2>>i)&1;
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] == 1) {
if (i > 0 && m2a[i-1] == 1) {
continue;
}
if (i < n-1 && m2a[i+1] == 1) {
continue;
}
if (m2a[i] == 1) {
continue;
}
if (i < n-1) {
m2a[i+1] = 1;
} else {
m2a[i] = 1;
}
}
}
for (int i = 0; i < n; ++i) {
if (m2a[i] == 1) {
cnt++;
}
}
A[m1][m2] = cnt;
}
}
int MAX = 10000;
int[][][] dp = new int[m+1][1<<n][1<<n];
for (int i = 0; i < m+1; i++) {
for (int m1 = 0; m1 < 1<<n; ++m1) {
Arrays.fill(dp[i][m1], MAX);
}
}
dp[0][0][0] = 0;
for (int i = 0; i < m; i++) {
for (int m1 = 0; m1 < 1<<n; ++m1) {
for (int m2 = 0; m2 < 1<<n; ++m2) {
if (dp[i][m1][m2] != MAX) {
for (int nm1 = 0; nm1 < 1<<n; ++nm1) {
for (int nm2 = 0; nm2 < 1<<n; ++nm2) {
if ((m1 & nm1) == 0) {
int sm1 = m1|nm1;
int sm2 = m2|nm2;
int cnt = A[sm1][sm2];
dp[i+1][nm2][nm1] = Math.min(dp[i+1][nm2][nm1], dp[i][m1][m2]+cnt);
}
}
}
}
}
}
}
out.println(n*m-dp[m][0][0]);
out.flush();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static int[][][] dp;
public static void main(String[] args) {
Scanner r = new Scanner(System.in);
int n = r.nextInt();
int m = r.nextInt();
if(n > m){int t = n; n = m; m = t;}
dp = new int[m+1][1 << 7][1 << 7];
for(int[][] i : dp)
for(int[] j : i)
Arrays.fill(j, -1);
int min = go(m, 0, (1<<n) -1, n, m);
System.out.println(n * m - min);
}
private static int go(int rem, int prev, int need, int n, int m) {
// for(int i = rem; i < m; i++)
// System.out.print(" ");
// System.out.println(rem + ": " + prev +","+need);
if(rem == 0)return prev == 0?0:1 << 20;
if(dp[rem][prev][need] != -1)return dp[rem][prev][need];
int min = 1 << 20;
for(int now = 0; now < 1 << n; now++){
if((~now & prev) != 0)continue;
int after = need & ~(now) & ~(now << 1) & ~(now >> 1);
int next = ~(now) & ((1 << n)-1);
int current = Integer.bitCount(now) + go(rem-1, after ,next, n, m);
min = Math.min(min, current);
}
return dp[rem][prev][need] = min;
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
//package round85;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class C3 {
Scanner in;
PrintWriter out;
String INPUT = "";
void solve()
{
int n = ni();
int m = ni();
if(n < m){
int d = n;n = m;m = d;
}
// n>=m
if(m == 1){
out.println(n-(n+2)/3);
return;
}
int[][] dp = new int[n+1][1<<2*m];
int[] fill = new int[1<<m];
int mask = (1<<m)-1;
for(int i = 0;i < 1<<m;i++){
fill[i] = (i<<1|i|i>>1)&mask;
}
for(int i = 0;i < 1<<2*m;i++){
int lower = i&mask;
int upper = i>>m;
dp[0][i] = (fill[lower]|upper) == mask ? Integer.bitCount(i) : 99999;
}
for(int i = 1;i <= n-2;i++){
for(int j = 0;j < 1<<2*m;j++){
int lower = j&mask;
int upper = j>>m;
int min = 99999;
for(int k = 0;k < 1<<m;k++){
if((upper|fill[lower]|k) == mask){
min = Math.min(min, dp[i-1][lower<<m|k]);
}
}
dp[i][j] = min + Integer.bitCount(upper);
}
}
int gmin = 99999;
for(int i = 0;i < 1<<2*m;i++){
int lower = i&mask;
int upper = i>>m;
if((fill[upper]|lower) == mask){
gmin = Math.min(gmin, dp[n-2][i]);
}
}
out.println(n*m-gmin);
}
void run() throws Exception
{
in = oj ? new Scanner(System.in) : new Scanner(INPUT);
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception
{
new C3().run();
}
int ni() { return Integer.parseInt(in.next()); }
long nl() { return Long.parseLong(in.next()); }
double nd() { return Double.parseDouble(in.next()); }
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.Arrays;
import java.util.Scanner;
public class E {
static int n;
static int m;
static int[][][] DP;
static int[] dx = { 0, 0, 1, -1 };
static int[] dy = { 1, -1, 0, 0 };
static int inf = 1000000;
public static int get(int x, int current, int last) {
if (x == n) {
if (last == 0)
return 0;
else
return -inf;
}
if (DP[x][current][last] != -1)
return DP[x][current][last];
int max = 0;
for (int mask = 0; mask < (1 << m); mask++) {
int tempLast = last;
int tempCurrent = current;
int tempNext = (1 << m) - 1;
for (int i = 0; i < m; i++)
if ((mask & (1 << i)) != 0) {
if (i > 0)
tempCurrent &= ~(1 << (i - 1));
if (i < m - 1)
tempCurrent &= ~(1 << (i + 1));
tempNext &= ~(1 << (i));
tempLast &= ~(1 << (i));
}
if (tempLast != 0)
continue;
max = Math.max(
max,
m - Integer.bitCount(mask)
+ get(x + 1, tempNext, tempCurrent & ~mask));
}
return DP[x][current][last] = max;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int x = in.nextInt();
int y = in.nextInt();
n = Math.max(x, y);
m = Math.min(x, y);
DP = new int[n][1 << m][1 << m];
for (int i = 0; i < n; i++)
for (int j = 0; j < (1 << m); j++)
Arrays.fill(DP[i][j], -1);
System.out.println(get(0, (1 << m) - 1, 0));
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
/**
* Problem:
* Source:
* Link:
*
* @author Alexei Ostrovski
*/
import java.io.*;
import java.util.*;
public class SpidersSolver {
public static final boolean DEBUG = false;
public static void main(String[] args) {
//redirect input and output
if (DEBUG)
{
try {
System.setIn(new FileInputStream("input.txt"));
//System.setOut(new PrintStream("input.txt"));
} catch (IOException e) {
//nothing
}
}
Scanner sc = new Scanner(System.in);
//read data
int n = sc.nextInt(), m = sc.nextInt();
//solve
if (n < m) {
int tmp = n;
n = m;
m = tmp;
}
// Now (n >= m) && (m <= 6)
int pow = 1;
for (int i = 0; i < m; i++)
pow *= 2;
int[] count = new int[pow];
for (int cur = 0; cur < pow; cur++)
{
int x = cur;
while (x > 0)
{
count[cur] += (x % 2);
x /= 2;
}
count[cur] = m - count[cur];
}
//System.out.println(Arrays.toString(count));
int[][] C = new int[pow][pow];
for (int cur = 0; cur < pow; cur++)
{
C[0][cur] = 0;//count[cur];
for (int last = 1; last < pow; last++)
C[last][cur] = Integer.MIN_VALUE;
}
for (int i = 0; i < n; i++)
{
int[][] newC = new int[pow][pow];
for (int cur = 0; cur < pow; cur++)
for (int next = 0; next < pow; next++)
{
int mask = cur | (cur << 1) | (cur >> 1) | next;
mask %= pow;
int max = 0;
for (int last = 0; last < pow; last++)
if (((last | mask) == pow - 1) && (max < count[cur] + C[last][cur]))
max = count[cur] + C[last][cur];
newC[cur][next] = max;
}
C = newC;
}
int result = 0;
for (int cur = 0; cur < pow; cur++)
result = Math.max(result, C[cur][0]);
//output
System.out.println(result);
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import static java.lang.Math.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map.Entry;
import java.util.StringTokenizer;
import java.util.TreeMap;
/**
*
* @author pttrung
*/
public class C {
public static double Epsilon = 1e-6;
public static long x, y, d;
public static long MOD = 1000000007;
public static int[][][] dp;
public static int min, max, need;
public static void main(String[] args) {
Scanner in = new Scanner();
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
int m = in.nextInt();
min = Math.min(n, m);
max = (m + n) - min;
dp = new int[max][1 << min][1 << min];
for (int[][] temp : dp) {
for (int[] val : temp) {
Arrays.fill(val, -1);
}
}
need = (1 << min) - 1;
//System.out.println(add + total);
// System.out.println(min + " " + max);
out.println(cal(0, 0, 0));
out.close();
}
public static int cal(int index, int last, int lastHold) {
if (index == max) {
return 0;
}
if (dp[index][lastHold][last] != -1) {
return dp[index][lastHold][last];
}
int result = 0;
for (int i = 0; i < 1 << min; i++) {
if ((i | last) == need || (index == 0)) {
// System.out.println("PREV " + index + " " + i + " " + last + " " + lastHold);
// System.out.println("NEXT " + index + " " + i + " " + (i | lastHold) + " " + i);
// System.out.println(Integer.bitCount(i) + " " + i);
// if (index == 3) {
// System.out.println(last + " " + i + " " + match(i, last) + " " + next);
// }
if(index + 1 == max && match(i,lastHold)!= need){
continue;
}
int temp = cal(index + 1, match(i,lastHold), i) + (min - Integer.bitCount(i));
result = result < temp ? temp : result;
// break;
}
}
dp[index][lastHold][last] = result;
return result;
}
public static int match(int mask, int last) {
int result = last;
for (int i = 0; i < min; i++) {
if (((1 << i) & mask) != 0) {
int a = i - 1;
int b = i + 1;
result |= (1 << i);
if (a >= 0) {
result |= (1 << a);
}
if (b < min) {
result |= (1 << b);
}
}
}
// System.out.println(mask + " " + result + " " + need);
return result ;
}
public static long pow(long a, long b) {
if (b == 0) {
return 1;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return val * val % MOD;
} else {
return a * (val * val % MOD) % MOD;
}
}
public static void extendEuclid(long a, long b) {
if (b == 0) {
x = 1;
y = 0;
d = a;
return;
}
extendEuclid(b, a % b);
long x1 = y;
long y1 = x - (a / b) * y;
x = x1;
y = y1;
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
static class Line {
double a, b, c;
Line(double x1, double y1, double x2, double y2) {
if (Math.abs(x1 - x2) < Epsilon && Math.abs(y1 - y2) < Epsilon) {
throw new RuntimeException("Two point are the same");
}
a = y1 - y2;
b = x2 - x1;
c = -a * x1 - b * y1;
}
Line(Point x, Point y) {
this(x.x, x.y, y.x, y.y);
}
public Line perpendicular(Point p) {
return new Line(p, new Point(p.x + a, p.y + b));
}
public Point intersect(Line l) {
double d = a * l.b - b * l.a;
if (d == 0) {
throw new RuntimeException("Two lines are parallel");
}
return new Point((l.c * b - c * l.b) / d, (l.a * c - l.c * a) / d);
}
}
static void check(Point a, Point b, ArrayList<Point> p, Point[] rec, int index) {
for (int i = 0; i < 4; i++) {
int m = (i + index) % 4;
int j = (i + 1 + index) % 4;
Point k = intersect(minus(b, a), minus(rec[m], rec[j]), minus(rec[m], a));
if (k.x >= 0 && k.x <= 1 && k.y >= 0 && k.y <= 1) {
Point val = new Point(k.x * minus(b, a).x, k.x * minus(b, a).y);
p.add(add(val, a));
// System.out.println(a + " " + b + " " + rec[i] + " " + rec[j]);
// System.out.println(add(val, a));
}
}
}
static Point intersect(Point a, Point b, Point c) {
double D = cross(a, b);
if (D != 0) {
return new Point(cross(c, b) / D, cross(a, c) / D);
}
return null;
}
static Point convert(Point a, double angle) {
double x = a.x * cos(angle) - a.y * sin(angle);
double y = a.x * sin(angle) + a.y * cos(angle);
return new Point(x, y);
}
static Point minus(Point a, Point b) {
return new Point(a.x - b.x, a.y - b.y);
}
static Point add(Point a, Point b) {
return new Point(a.x + b.x, a.y + b.y);
}
static double cross(Point a, Point b) {
return a.x * b.y - a.y * b.x;
}
static class Point {
double x, y;
Point(double x, double y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "Point: " + x + " " + y;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.deepToString;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class C {
static int[] dx = new int[] { 0, 1, 0, -1, 0 };
static int[] dy = new int[] { 0, 0, -1, 0, 1 };
static int[][] g;
static int ans;
static void fill() {
cache[1][1] = 0;
cache[1][1] = 0;
cache[2][1] = 1;
cache[1][2] = 1;
cache[2][2] = 2;
cache[2][2] = 2;
cache[3][1] = 2;
cache[1][3] = 2;
cache[3][2] = 4;
cache[2][3] = 4;
cache[3][3] = 6;
cache[3][3] = 6;
cache[4][1] = 2;
cache[1][4] = 2;
cache[4][2] = 5;
cache[2][4] = 5;
cache[4][3] = 8;
cache[3][4] = 8;
cache[4][4] = 12;
cache[4][4] = 12;
cache[5][1] = 3;
cache[1][5] = 3;
cache[5][2] = 7;
cache[2][5] = 7;
cache[5][3] = 11;
cache[3][5] = 11;
cache[5][4] = 14;
cache[4][5] = 14;
cache[5][5] = 18;
cache[5][5] = 18;
cache[6][1] = 4;
cache[1][6] = 4;
cache[6][2] = 8;
cache[2][6] = 8;
cache[6][3] = 13;
cache[3][6] = 13;
cache[6][4] = 17;
cache[4][6] = 17;
cache[6][5] = 22;
cache[5][6] = 22;
cache[6][6] = 26;
cache[6][6] = 26;
cache[7][1] = 4;
cache[1][7] = 4;
cache[7][2] = 10;
cache[2][7] = 10;
cache[7][3] = 15;
cache[3][7] = 15;
cache[7][4] = 21;
cache[4][7] = 21;
cache[7][5] = 26;
cache[5][7] = 26;
cache[8][1] = 5;
cache[1][8] = 5;
cache[8][2] = 11;
cache[2][8] = 11;
cache[8][3] = 17;
cache[3][8] = 17;
cache[8][4] = 24;
cache[4][8] = 24;
cache[8][5] = 29;
cache[5][8] = 29;
cache[9][1] = 6;
cache[1][9] = 6;
cache[9][2] = 13;
cache[2][9] = 13;
cache[9][3] = 20;
cache[3][9] = 20;
cache[9][4] = 26;
cache[4][9] = 26;
cache[10][1] = 6;
cache[1][10] = 6;
cache[10][2] = 14;
cache[2][10] = 14;
cache[10][3] = 22;
cache[3][10] = 22;
cache[10][4] = 30;
cache[4][10] = 30;
cache[11][1] = 7;
cache[1][11] = 7;
cache[11][2] = 16;
cache[2][11] = 16;
cache[11][3] = 24;
cache[3][11] = 24;
cache[12][1] = 8;
cache[1][12] = 8;
cache[12][2] = 17;
cache[2][12] = 17;
cache[12][3] = 26;
cache[3][12] = 26;
cache[13][1] = 8;
cache[1][13] = 8;
cache[13][2] = 19;
cache[2][13] = 19;
cache[13][3] = 29;
cache[3][13] = 29;
cache[14][1] = 9;
cache[1][14] = 9;
cache[14][2] = 20;
cache[2][14] = 20;
cache[15][1] = 10;
cache[1][15] = 10;
cache[15][2] = 22;
cache[2][15] = 22;
cache[16][1] = 10;
cache[1][16] = 10;
cache[16][2] = 23;
cache[2][16] = 23;
cache[17][1] = 11;
cache[1][17] = 11;
cache[17][2] = 25;
cache[2][17] = 25;
cache[18][1] = 12;
cache[1][18] = 12;
cache[18][2] = 26;
cache[2][18] = 26;
cache[19][1] = 12;
cache[1][19] = 12;
cache[19][2] = 28;
cache[2][19] = 28;
cache[20][1] = 13;
cache[1][20] = 13;
cache[20][2] = 29;
cache[2][20] = 29;
cache[21][1] = 14;
cache[1][21] = 14;
cache[22][1] = 14;
cache[1][22] = 14;
cache[23][1] = 15;
cache[1][23] = 15;
cache[24][1] = 16;
cache[1][24] = 16;
cache[25][1] = 16;
cache[1][25] = 16;
cache[26][1] = 17;
cache[1][26] = 17;
cache[27][1] = 18;
cache[1][27] = 18;
cache[28][1] = 18;
cache[1][28] = 18;
cache[29][1] = 19;
cache[1][29] = 19;
cache[30][1] = 20;
cache[1][30] = 20;
cache[31][1] = 20;
cache[1][31] = 20;
cache[32][1] = 21;
cache[1][32] = 21;
cache[33][1] = 22;
cache[1][33] = 22;
cache[34][1] = 22;
cache[1][34] = 22;
cache[35][1] = 23;
cache[1][35] = 23;
cache[36][1] = 24;
cache[1][36] = 24;
cache[37][1] = 24;
cache[1][37] = 24;
cache[38][1] = 25;
cache[1][38] = 25;
cache[39][1] = 26;
cache[1][39] = 26;
cache[40][1] = 26;
cache[1][40] = 26;
}
static void go(int n, int m, long used, long left) {
// debug(Long.toBinaryString(used) + " " + Long.toBinaryString(left));
if (left == 0) {
ans = max(ans, n * m - Long.bitCount(used));
return;
}
if (n * m - Long.bitCount(used) <= ans)
return;
int who = Long.numberOfTrailingZeros(left);
// debug(who);
for (int w : g[who]) {
long nused = used | (1L << w);
long nleft = left;
for (int v : g[w]) {
nleft &= ~(1L << v);
}
go(n, m, nused, nleft);
}
}
static int solve(int n, int m) throws Exception {
ans = 0;
g = new int[n * m][];
for (int x = 0; x < m; x++) {
for (int y = 0; y < n; y++) {
int[] w = new int[5];
int cnt = 0;
for (int dir = 0; dir < 5; dir++) {
int nx = x + dx[dir];
int ny = y + dy[dir];
if (nx >= 0 && nx < m && ny >= 0 && ny < n) {
w[cnt++] = ny * m + nx;
}
}
g[y * m + x] = copyOf(w, cnt);
}
}
go(n, m, 0, (1L << (n * m)) - 1);
return ans;
}
static int[][] cache;
public static void main(String[] args) {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
// debug(solve(1, 4));
// debug(solve(6, 6));
// debug(solve(7,5) == solve(5,7));
// PrintWriter out2 = new PrintWriter("file.txt");
// //
cache = new int[41][41];
fill();
// //
// for (int i = 1; i <= 40; i++) {
// for (int j = 1; j <= i; j++) {
// if (i * j <= 40) {
// int k = solve(i, j);
// out2.printf("cache[%d][%d] = %d;\n", i, j, k);
// out2.printf("cache[%d][%d] = %d;\n", j, i, k);
//
// cache[i][j] = solve(i, j);
// debug(i + " " + j);
// }
// }
// }
// out2.close();
int n = nextInt();
int m = nextInt();
//int res = solve(n, m);
out.println(cache[n][m]);
// for (int i = 1; i <= 5; i++) {
// for (int j = 1; j <= 5; j++) {
// assert(solve(i, j) == cache[i][j]);
// //debug(i + " " + j + " " + solve(i, j));
// }
// }
out.close();
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
}
static BufferedReader in;
static PrintWriter out;
static StringTokenizer tok;
static long launchTimer;
static void debug(Object... o) {
System.err.println(deepToString(o));
}
static void setTime() {
launchTimer = System.currentTimeMillis();
}
static void printTime() {
System.err.println(System.currentTimeMillis() - launchTimer);
}
static void printMemory() {
System.err.println((Runtime.getRuntime().totalMemory() - Runtime
.getRuntime().freeMemory()) / 1000 + "kb");
}
static boolean hasMoreTokens() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
String line = in.readLine();
if (line == null) {
return false;
}
tok = new StringTokenizer(line);
}
return true;
}
static String next() throws IOException {
return hasMoreTokens() ? tok.nextToken() : null;
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static long nextLong() throws IOException {
return Long.parseLong(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
static BigInteger nextBig() throws IOException {
return new BigInteger(next());
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.*;
import java.util.*;
public class C {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
final int INF = Integer.MAX_VALUE / 2;
void solve() throws IOException {
int n = nextInt();
int m = nextInt();
if (n > m) {
int tmp = n;
n = m;
m = tmp;
}
// n < m !!!!
// n rows m columns
if (n == 1) {
out.print(m - (m + 2) / 3);
return;
}
int[][] dp = new int[n * m + 1][1 << (2 * n)];
for (int i = 0; i < dp.length; i++)
Arrays.fill(dp[i], INF);
dp[0][0] = 0;
for (int i = 0; i < dp.length - 1; i++) {
int maxNewMask = (1 << Math.min(2 * n, n * m - i)) - 1;
for (int mask = 0; mask < dp[i].length; mask++)
if (dp[i][mask] != INF) {
//System.err.println(i + " " + mask + " " + dp[i][mask]);
if ((mask & 1) == 1) // already covered, skip
dp[i + 1][mask >> 1] = Math.min(dp[i + 1][mask >> 1],
dp[i][mask]);
// place on this tile
int newMask = mask >> 1;
if (i % n != n - 1)
newMask |= 1;
newMask |= 1 << (n - 1);
newMask &= maxNewMask;
dp[i + 1][newMask] = Math.min(dp[i + 1][newMask],
dp[i][mask] + 1);
if (i % n != n - 1) {// place on next tile
newMask = mask >> 1;
newMask |= 1;
if (i % n != n - 2)
newMask |= 2;
newMask |= (1 << n);
newMask &= maxNewMask;
dp[i + 1][newMask] = Math.min(dp[i + 1][newMask],
dp[i][mask] + 1);
}
// place on lower tile
if (i + n < n * m) {
newMask = mask >> 1;
newMask |= 1 << (n - 1);
if (i % n != 0)
newMask |= 1 << (n - 2);
if (i % n != n - 1)
newMask |= 1 << n;
newMask |= 1 << (2 * n - 1);
newMask &= maxNewMask;
dp[i + 1][newMask] = Math.min(dp[i + 1][newMask],
dp[i][mask] + 1);
}
}
}
out.print(n * m - dp[n * m][0]);
}
void inp() throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
}
public static void main(String[] args) throws IOException {
new C().inp();
}
String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return "0";
}
}
return st.nextToken();
}
String nextString() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return "0";
}
}
return st.nextToken("\n");
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class P111C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int h, w;
void run(){
h=sc.nextInt();
w=sc.nextInt();
solve();
}
void shuffle(int[] is){
Random rand=new Random();
for(int i=is.length-1; i>=1; i--){
int j=rand.nextInt(i+1);
int t=is[i];
is[i]=is[j];
is[j]=t;
}
}
void solve(){
n=w*h;
g=new long[n];
int[] dx={0, 0, -1, 1};
int[] dy={-1, 1, 0, 0};
for(int y=0; y<h; y++){
for(int x=0; x<w; x++){
for(int k=0; k<4; k++){
int x2=x+dx[k];
int y2=y+dy[k];
if(x2>=0&&x2<w&&y2>=0&&y2<h){
g[y*w+x]|=1L<<(y2*w+x2);
}
}
}
}
candidate=new int[n];
xs=new Xorshift();
mds=(1L<<n)-1;
mds(0, 0, 0);
println((n-Long.bitCount(mds))+"");
}
int n;
long[] g;
long mds;
int[] candidate;
Xorshift xs;
void mds(long choosed, long removed, long covered){
if(Long.bitCount(choosed)>=Long.bitCount(mds))
return;
if(covered==((1L<<n)-1)){
if(Long.bitCount(choosed)<Long.bitCount(mds))
mds=choosed;
return;
}
int index=0;
int k=-1;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
if((covered>>>i&1)==1){
if(Long.bitCount(g[i]&~covered)==0){
mds(choosed, removed|(1L<<i), covered);
return;
}else if(Long.bitCount(g[i]&~covered)==1
&&(g[i]&~covered&~removed)!=0){
mds(choosed, removed|(1L<<i), covered);
return;
}
}else{
if(Long.bitCount(g[i]&~removed)==0){
mds(choosed|(1L<<i), removed|(1L<<i), covered|(1L<<i)|g[i]);
return;
}else if(Long.bitCount(g[i]&~removed)==1
&&((g[i]&~removed)|(g[i]&~covered))==(g[i]&~removed)){
int j=Long.numberOfTrailingZeros(g[i]&~removed);
mds(choosed|(1L<<j), removed|(1L<<i)|(1L<<j), covered
|(1L<<j)|g[j]);
return;
}
}
// if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered))
// k=i;
if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered)){
index=0;
candidate[index++]=i;
k=i;
}else if(Long.bitCount(g[i]&~covered)==Long.bitCount(g[k]&~covered)){
candidate[index++]=i;
}
}
if(k==-1)
return;
k=candidate[xs.nextInt(index)];
mds(choosed|(1L<<k), removed|(1L<<k), covered|(1L<<k)|g[k]);
mds(choosed, removed|(1L<<k), covered);
}
class Xorshift{
int x, y, z, w;
public Xorshift(){
x=123456789;
y=362436069;
z=521288629;
w=88675123;
}
public Xorshift(int seed){
x=_(seed, 0);
y=_(x, 1);
z=_(y, 2);
w=_(z, 3);
}
int _(int s, int i){
return 1812433253*(s^(s>>>30))+i+1;
}
// 32bit signed
public int nextInt(){
int t=x^(x<<11);
x=y;
y=z;
z=w;
return w=w^(w>>>19)^t^(t>>>8);
}
// error = O(n*2^-32)
public int nextInt(int n){
return (int)(n*nextDouble());
}
// [0, 1) (53bit)
public double nextDouble(){
int a=nextInt()>>>5, b=nextInt()>>>6;
return (a*67108864.0+b)*(1.0/(1L<<53));
}
}
void println(String s){
System.out.println(s);
}
void print(String s){
System.out.print(s);
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args){
Locale.setDefault(Locale.US);
new P111C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
//package round85;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class C2 {
Scanner in;
PrintWriter out;
String INPUT = "";
void solve()
{
int n = ni();
int m = ni();
boolean[][] f = new boolean[99][99];
cache = new HashSet<Long>();
out.println(n*m-rec(f, n, m, 0, 0, 0));
}
Set<Long> cache;
long hash(boolean[][] f, int n, int m, int r, int c, int cur)
{
long x = 0;
for(int i = 0;i < n;i++){
for(int j = 0;j < m;j++){
if(f[i][j])x |= 1L<<i*m+j;
}
}
x = x * n + r;
x = x * m + c;
x = x * 41 + cur;
return x;
}
int rec(boolean[][] f, int n, int m, int r, int c, int cur)
{
if(r == n)return cur;
if(c >= m)return rec(f, n, m, r+1, 0, cur);
long h = hash(f, n, m, r, c, cur);
if(cache.contains(h))return 99999;
cache.add(h);
int min = f[r][c] ? rec(f, n, m, r, c+1, cur) : 99999;
{
boolean[] memo = new boolean[]{f[r][c], f[r+1][c], f[r][c+1]};
f[r][c] = true;
f[r+1][c] = true;
f[r][c+1] = true;
min = Math.min(min, rec(f, n, m, r, c+2, cur+1));
f[r][c] = memo[0];
f[r+1][c] = memo[1];
f[r][c+1] = memo[2];
}
{
boolean[] memo = new boolean[]{f[r][c], f[r+1][c], f[r+2][c], f[r+1][c+1], c-1>=0 ? f[r+1][c-1] : false};
f[r][c] = true;
f[r+1][c] = true;
f[r+2][c] = true;
f[r+1][c+1] = true;
if(c-1 >= 0)f[r+1][c-1] = true;
min = Math.min(min, rec(f, n, m, r, c+1, cur+1));
f[r][c] = memo[0];
f[r+1][c] = memo[1];
f[r+2][c] = memo[2];
f[r+1][c+1] = memo[3];
if(c-1 >= 0)f[r+1][c-1] = memo[4];
}
{
boolean[] memo = new boolean[]{f[r][c], f[r][c+1], f[r][c+2], f[r+1][c+1]};
f[r][c] = true;
f[r][c+1] = true;
f[r][c+2] = true;
f[r+1][c+1] = true;
min = Math.min(min, rec(f, n, m, r, c+3, cur+1));
f[r][c] = memo[0];
f[r][c+1] = memo[1];
f[r][c+2] = memo[2];
f[r+1][c+1] = memo[3];
}
return min;
}
int count(int n, int m, int p, int step)
{
int[] dr = {1, 0, -1, 0, 0};
int[] dc = {0, 1, 0, -1, 0};
// (0,i)
int ct = 0;
boolean[][] f = new boolean[n][m];
for(int j = 0;j < n;j++){
for(int k = 0;k < m;k++){
if(k % 5 == p){
ct++;
for(int l = 0;l < 5;l++){
int nr = j+dr[l];
int nc = k+dc[l];
if(nr >= 0 && nr < n && nc >= 0 && nc < m){
f[nr][nc] = true;
}
}
}
}
p = (p+step)%5;
}
for(int j = 0;j < n;j++){
for(int k = 0;k < m;k++){
if(!f[j][k]){
ct++;
for(int l = 0;l < 5;l++){
int nr = j+dr[l];
int nc = k+dc[l];
if(nr >= 0 && nr < n && nc >= 0 && nc < m){
f[nr][nc] = true;
}
}
}
}
}
return ct;
}
void run() throws Exception
{
in = oj ? new Scanner(System.in) : new Scanner(INPUT);
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception
{
new C2().run();
}
int ni() { return Integer.parseInt(in.next()); }
long nl() { return Long.parseLong(in.next()); }
double nd() { return Double.parseDouble(in.next()); }
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Map.Entry;
public class Solution implements Runnable {
public static void main(String[] args) {
(new Thread(new Solution())).start();
}
BufferedReader in;
PrintWriter out;
StringTokenizer st;
String nextToken() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String r = in.readLine();
if (r == null) return null;
st = new StringTokenizer(r);
}
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
int count(int q, int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
if (q % 3 != 1) ans++;
q /= 3;
}
return ans;
}
int count2(int q, int n) {
int ans = 0;
for (int i = 0; i < n; i++) {
if (q % 3 == 2) ans++;
q /= 3;
}
return ans;
}
int sz;
int[] decode(int q, int n) {
int[] res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = q % 3;
q /= 3;
}
return res;
}
boolean[][] precalc(int n, int m) {
boolean[][] res = new boolean[sz][sz];
for (int i = 0; i < sz; i++) {
int[] ai = decode(i, n);
for (int j = 0; j < sz; j++) {
int[] aj = decode(j, n);
boolean f = true;
for (int k = 0; k < n && f; k++) {
if (aj[k] == 0) {
f = false;
if (k > 0 && aj[k - 1] == 1) f = true;
if (k < n - 1 && aj[k + 1] == 1) f = true;
if (ai[k] == 1) f = true;
}
if (f && ai[k] == 2) f = (aj[k] == 1);
}
res[i][j] = f;
}
}
return res;
}
void solve() throws Exception {
int n = nextInt();
int m = nextInt();
if (n > m) { int t = n; n = m; m = t; }
sz = 1;
for (int i = 0; i < n; i++) sz *= 3;
boolean[][] a = precalc(n, m);
int[][] d = new int[m + 1][sz];
Arrays.fill(d[0], -1);
d[0][0] = 0;
for (int i = 1; i <= m; i++) {
Arrays.fill(d[i], -1);
for (int j = 0; j < sz; j++) {
if (d[i - 1][j] != -1) {
for (int k = 0; k < sz; k++) {
if (a[j][k]) {
d[i][k] = Math.max(d[i][k], d[i - 1][j] + count(k, n));
}
}
}
}
}
int ans = 0;
for (int i = 0; i < sz; i++) if (count2(i, n) == 0) ans = Math.max(ans, d[m][i]);
out.println(ans);
}
public void run() {
Locale.setDefault(Locale.UK);
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
// in = new BufferedReader(new FileReader("knights.in"));
// out = new PrintWriter("knights.out");
solve();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
} finally {
out.flush();
}
}
} | np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int n, m;
void run(){
n=sc.nextInt();
m=sc.nextInt();
solve();
}
void solve(){
if(n<m){
int t=n;
n=m;
m=t;
}
int full=(1<<m)-1;
int[][] dp=new int[1<<m][1<<m];
int[][] tmp=new int[1<<m][1<<m];
for(int i=0; i<1<<m; i++){
fill(dp[i], INF);
}
for(int i=0; i<1<<m; i++){
int b1=(i|(i>>1)|(i<<1))&full;
int b2=i;
dp[b1][b2]=Integer.bitCount(i);
debug(Integer.toBinaryString(b1), dp[b1]);
}
debug();
for(int j=0; j<n-1; j++){
for(int i=0; i<1<<m; i++){
System.arraycopy(dp[i], 0, tmp[i], 0, 1<<m);
fill(dp[i], INF);
}
for(int b1=0; b1<1<<m; b1++){
for(int b2=0; b2<1<<m; b2++){
for(int i=0; i<1<<m; i++){
if((b1|i)!=full){
continue;
}
if(false)
debug(Integer.toBinaryString(b1),
Integer.toBinaryString(b2),
Integer.toBinaryString(i));
int b=(i|(i>>1)|(i<<1))&full;
dp[b2|b][i]=min(dp[b2|b][i],
tmp[b1][b2]+Integer.bitCount(i));
}
}
}
debug(j);
for(int i=0; i<1<<m; i++){
debug(Integer.toBinaryString(i), dp[i]);
}
}
int min=INF;
for(int i=0; i<1<<m; i++){
min=min(min, dp[full][i]);
}
debug(min);
int ans=m*n-min;
debug("ans",ans);
println(ans+"");
}
void println(String s){
System.out.println(s);
}
void print(String s){
System.out.print(s);
}
void debug(Object... os){
// System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args){
new C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class P111C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int h, w;
void run(){
h=sc.nextInt();
w=sc.nextInt();
solve();
}
void solve(){
n=w*h;
g=new long[n];
int[] dx={0, 0, -1, 1};
int[] dy={-1, 1, 0, 0};
for(int y=0; y<h; y++){
for(int x=0; x<w; x++){
for(int k=0; k<4; k++){
int x2=x+dx[k];
int y2=y+dy[k];
if(x2>=0&&x2<w&&y2>=0&&y2<h){
g[y*w+x]|=1L<<(y2*w+x2);
}
}
}
}
mds=(1L<<n)-1;
mds(0, 0, 0);
println((n-Long.bitCount(mds))+"");
}
int n;
long[] g;
long mds;
void mds(long choosed, long removed, long covered){
if(Long.bitCount(choosed)>=Long.bitCount(mds))
return;
if(covered==((1L<<n)-1)){
if(Long.bitCount(choosed)<Long.bitCount(mds))
mds=choosed;
return;
}
int k=-1;
ArrayList<Integer> list=new ArrayList<Integer>();
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
if((covered>>>i&1)==1){
if(Long.bitCount(g[i]&~covered)==0){
mds(choosed, removed|(1L<<i), covered);
return;
}else if(Long.bitCount(g[i]&~covered)==1
&&(g[i]&~covered&~removed)!=0){
mds(choosed, removed|(1L<<i), covered);
return;
}
}else{
if(Long.bitCount(g[i]&~removed)==0){
mds(choosed|(1L<<i), removed|(1L<<i), covered|(1L<<i)|g[i]);
return;
}else if(Long.bitCount(g[i]&~removed)==1
&&((g[i]&~removed)|(g[i]&~covered))==(g[i]&~removed)){
int j=Long.numberOfTrailingZeros(g[i]&~removed);
mds(choosed|(1L<<j), removed|(1L<<i)|(1L<<j), covered
|(1L<<j)|g[j]);
return;
}
}
// if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered))
// k=i;
if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered)){
list.clear();
list.add(i);
k=i;
}else if(Long.bitCount(g[i]&~covered)==Long.bitCount(g[k]&~covered))
list.add(i);
}
if(k==-1)
return;
k=list.get((int)(list.size()*random()));
mds(choosed|(1L<<k), removed|(1L<<k), covered|(1L<<k)|g[k]);
mds(choosed, removed|(1L<<k), covered);
}
void println(String s){
System.out.println(s);
}
void print(String s){
System.out.print(s);
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args){
Locale.setDefault(Locale.US);
new P111C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
/**
* Author -
* User: kansal
* Date: 9/3/11
* Time: 5:28 PM
*/
public class CF85C {
public static void main(String[] args) {
reader = new BufferedReader(new InputStreamReader(System.in));
int height = nextInt(), width = nextInt();
if (width > height) {
int t = width;
width = height;
height = t;
}
final int INF = height * width + 10;
final int ALL_BITS = (1 << width) - 1;
int[][][] dp = new int[height + 1][1 << width][1 << width];
for (int[][] ints : dp) {
for (int[] anInt : ints) {
Arrays.fill(anInt, INF);
}
}
dp[0][0][0] = 0;
for(int r = 0; r < height; ++r) {
for(int uncovered = 0; uncovered < (1 << width); ++uncovered) {
for(int mask = 0; mask < (1 << width); ++mask) {
if (dp[r][uncovered][mask] == INF) {
continue;
}
for(int curMask = uncovered; curMask < (1 << width); curMask = (curMask + 1) | uncovered) {
int curCovered = (mask | curMask);
curCovered |= (curMask >> 1);
curCovered |= (ALL_BITS & (curMask << 1));
int curUncovered = ALL_BITS ^ curCovered;
dp[r+1][curUncovered][curMask] = Math.min(dp[r+1][curUncovered][curMask], dp[r][uncovered][mask] + Integer.bitCount(curMask));
}
}
}
}
int res = INF;
for(int x: dp[height][0]) res = Math.min(res, x);
System.out.println(height * width - res);
}
public static BufferedReader reader;
public static StringTokenizer tokenizer = null;
static String nextToken() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
static public int nextInt() {
return Integer.parseInt(nextToken());
}
static public long nextLong() {
return Long.parseLong(nextToken());
}
static public String next() {
return nextToken();
}
static public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
// Petya and Spiders
// 2012/08/15
public class P111C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int h, w;
void run(){
h=sc.nextInt();
w=sc.nextInt();
solve();
}
void solve(){
n=w*h;
g=new long[n];
int[] dx={0, 0, -1, 1};
int[] dy={-1, 1, 0, 0};
for(int y=0; y<h; y++){
for(int x=0; x<w; x++){
for(int k=0; k<4; k++){
int x2=x+dx[k];
int y2=y+dy[k];
if(x2>=0&&x2<w&&y2>=0&&y2<h){
g[y*w+x]|=1L<<(y2*w+x2);
}
}
}
}
mds=(1L<<n)-1;
mds(0, 0, 0);
println((n-Long.bitCount(mds))+"");
}
int n;
long[] g;
long mds;
void mds(long choosed, long removed, long covered){
if(covered==((1L<<n)-1)){
mds=choosed;
return;
}
if(Long.bitCount(choosed)>=Long.bitCount(mds)-1)
return;
long s=covered;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
s|=(1L<<i)|g[i];
}
if(s!=((1L<<n)-1))
return;
int k=-1;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
if((covered>>>i&1)==1){
if(Long.bitCount(g[i]&~covered)<=1){
mds(choosed, removed|(1L<<i), covered);
return;
}
}else{
if(Long.bitCount(g[i]&~removed)==0){
mds(choosed|(1L<<i), removed|(1L<<i), covered|(1L<<i)|g[i]);
return;
}else if(Long.bitCount(g[i]&~removed)==1
&&(g[i]&(~removed|~covered))==(g[i]&~removed)){
int j=Long.numberOfTrailingZeros(g[i]&~removed);
mds(choosed|(1L<<j), removed|(1L<<i)|(1L<<j), covered
|(1L<<j)|g[j]);
return;
}
}
if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered))
k=i;
}
if(k==-1)
return;
mds(choosed|(1L<<k), removed|(1L<<k), covered|(1L<<k)|g[k]);
mds(choosed, removed|(1L<<k), covered);
}
void println(String s){
System.out.println(s);
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args){
Locale.setDefault(Locale.US);
new P111C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Code implements Runnable {
public static void main(String[] args) throws IOException {
new Thread(new Code()).start();
}
private void solve() throws IOException {
int n = nextInt(), m = nextInt();
if(n > m) {
n ^= m;
m ^= n;
n ^= m;
}
int[][][] dp = new int[41][64][64];
for(int i = 0; i < 41; ++i)
for(int j = 0; j < 64; ++j)
for(int k = 0; k < 64; ++k) dp[i][j][k] = Integer.MAX_VALUE / 2;
for(int i = 0; i < 64; ++i) dp[0][0][i] = countBit(i);
for(int i = 1; i <= m; ++i) {
for(int cur = 0; cur < 64; ++cur) {
for(int next = 0; next < 64; ++next) {
for(int prev = 0; prev < 64; ++prev) {
if(!isBad(prev, cur, next, n)) {
dp[i][cur][next] = min(dp[i][cur][next], dp[i - 1][prev][cur] + countBit(next));
}
}
}
}
}
int ans = Integer.MAX_VALUE;
for(int i = 0; i < 64; ++i) ans = min(ans, dp[m][i][0]);
writer.println(n * m - ans);
}
private boolean isBit(int bits, int pos) {
return pos < 0 ? false : ((bits & (1 << pos)) != 0);
}
private boolean isBad(int prev, int cur, int next, int count) {
for(int i = 0; i < count; ++i)
if(!(isBit(cur, i - 1) || isBit(cur, i) || isBit(cur, i + 1) || isBit(prev, i) || isBit(next, i))) return true;
return false;
}
private int countBit(int bits) {
int ans = 0;
for(int i = 0; i < 6; ++i) ans += (bits & (1 << i)) > 0 ? 1 : 0;
return ans;
}
private class Pair<E extends Comparable, V extends Comparable> implements Comparable<Pair<E, V>> {
public Pair(E first, V second) {
this.first = first;
this.second = second;
}
@Override
public int compareTo(Pair<E, V> obj) {
if(first == obj.first) return second.compareTo(obj.second);
return first.compareTo(obj.first);
}
@Override
public boolean equals(Object obj) {
Pair other = (Pair)obj;
return first.equals(other.first) && second.equals(other.second);
}
public E first;
public V second;
}
@Override
public void run() {
try {
if(in.equals("")) reader = new BufferedReader(new InputStreamReader(System.in));
else reader = new BufferedReader(new FileReader(in));
if(out.equals("")) writer = new PrintWriter(new OutputStreamWriter(System.out));
else writer = new PrintWriter(new FileWriter(out));
solve();
} catch(IOException e) {
e.printStackTrace();
} finally {
try {
reader.close();
writer.close();
} catch(IOException e) {
e.printStackTrace();
}
}
}
private int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
private long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
private double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
private float nextFloat() throws IOException {
return Float.parseFloat(nextToken());
}
private String nextToken() throws IOException {
while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(reader.readLine());
return st.nextToken();
}
private String in = "", out = "";
private BufferedReader reader;
private PrintWriter writer;
private StringTokenizer st;
} | np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class P111C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int h, w;
void run(){
h=sc.nextInt();
w=sc.nextInt();
solve();
}
void shuffle(int[] is){
Random rand=new Random();
for(int i=is.length-1; i>=1; i--){
int j=rand.nextInt(i+1);
int t=is[i];
is[i]=is[j];
is[j]=t;
}
}
void solve(){
n=w*h;
g=new long[n];
int[] dx={0, 0, -1, 1};
int[] dy={-1, 1, 0, 0};
for(int y=0; y<h; y++){
for(int x=0; x<w; x++){
for(int k=0; k<4; k++){
int x2=x+dx[k];
int y2=y+dy[k];
if(x2>=0&&x2<w&&y2>=0&&y2<h){
g[y*w+x]|=1L<<(y2*w+x2);
}
}
}
}
candidate=new int[n];
xs=new Xorshift();
mds=(1L<<n)-1;
mds(0, 0, 0);
println((n-Long.bitCount(mds))+"");
}
int n;
long[] g;
long mds;
int[] candidate;
Xorshift xs;
void mds(long choosed, long removed, long covered){
if(Long.bitCount(choosed)>=Long.bitCount(mds))
return;
if(covered==((1L<<n)-1)){
if(Long.bitCount(choosed)<Long.bitCount(mds))
mds=choosed;
return;
}
{
long s=covered;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
s|=(1L<<i)|g[i];
}
if(s!=((1L<<n)-1)){
return;
}
}
int index=0;
int k=-1;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
if((covered>>>i&1)==1){
if(Long.bitCount(g[i]&~covered)==0){
mds(choosed, removed|(1L<<i), covered);
return;
}else if(Long.bitCount(g[i]&~covered)==1
&&(g[i]&~covered&~removed)!=0){
mds(choosed, removed|(1L<<i), covered);
return;
}
}else{
if(Long.bitCount(g[i]&~removed)==0){
mds(choosed|(1L<<i), removed|(1L<<i), covered|(1L<<i)|g[i]);
return;
}else if(Long.bitCount(g[i]&~removed)==1
&&((g[i]&~removed)|(g[i]&~covered))==(g[i]&~removed)){
int j=Long.numberOfTrailingZeros(g[i]&~removed);
mds(choosed|(1L<<j), removed|(1L<<i)|(1L<<j), covered
|(1L<<j)|g[j]);
return;
}
}
// if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered))
// k=i;
if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered)){
index=0;
candidate[index++]=i;
k=i;
}else if(Long.bitCount(g[i]&~covered)==Long.bitCount(g[k]&~covered)){
candidate[index++]=i;
}
}
if(k==-1)
return;
k=candidate[xs.nextInt(index)];
mds(choosed|(1L<<k), removed|(1L<<k), covered|(1L<<k)|g[k]);
mds(choosed, removed|(1L<<k), covered);
}
class Xorshift{
int x, y, z, w;
public Xorshift(){
x=123456789;
y=362436069;
z=521288629;
w=88675123;
}
public Xorshift(int seed){
x=_(seed, 0);
y=_(x, 1);
z=_(y, 2);
w=_(z, 3);
}
int _(int s, int i){
return 1812433253*(s^(s>>>30))+i+1;
}
// 32bit signed
public int nextInt(){
int t=x^(x<<11);
x=y;
y=z;
z=w;
return w=w^(w>>>19)^t^(t>>>8);
}
// error = O(n*2^-32)
public int nextInt(int n){
return (int)(n*nextDouble());
}
// [0, 1) (53bit)
public double nextDouble(){
int a=nextInt()>>>5, b=nextInt()>>>6;
return (a*67108864.0+b)*(1.0/(1L<<53));
}
}
void println(String s){
System.out.println(s);
}
void print(String s){
System.out.print(s);
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args){
Locale.setDefault(Locale.US);
new P111C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
// practice with rainboy
import java.io.*;
import java.util.*;
public class CF111C extends PrintWriter {
CF111C() { super(System.out, true); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
CF111C o = new CF111C(); o.main(); o.flush();
}
int encode(int[] aa, int m) {
int a = 0;
for (int j = 0; j < m; j++)
a = a * 3 + aa[j];
return a;
}
void decode(int[] aa, int m, int a, int base) {
for (int j = m - 1; j >= 0; j--) {
aa[j] = a % base;
a /= base;
}
}
void main() {
int n = sc.nextInt();
int m = sc.nextInt();
if (n < m) {
int tmp = n; n = m; m = tmp;
}
int p = 1;
for (int j = 0; j < m; j++)
p *= 3;
int[] dp = new int[p];
int[] dq = new int[p];
int[] aa = new int[m];
int[] bb = new int[m];
for (int j = 0; j < m; j++)
aa[j] = 1;
Arrays.fill(dp, -1);
dp[encode(aa, m)] = 0;
while (n-- > 0) {
Arrays.fill(dq, -1);
for (int a = 0; a < p; a++) {
if (dp[a] < 0)
continue;
decode(aa, m, a, 3);
for (int b = 0; b < 1 << m; b++) {
decode(bb, m, b, 2);
boolean bad = false;
for (int j = 0; j < m; j++)
if (aa[j] == 0 && bb[j] == 0) {
bad = true;
break;
}
if (bad)
continue;
int cnt = 0;
for (int j = 0; j < m; j++)
if (bb[j] == 1) {
bb[j] = 2;
cnt++;
}
for (int j = 0; j < m; j++)
if (bb[j] == 0 && (aa[j] == 2 || j > 0 && bb[j - 1] == 2 || j + 1 < m && bb[j + 1] == 2))
bb[j] = 1;
int a_ = encode(bb, m);
dq[a_] = Math.max(dq[a_], dp[a] + m - cnt);
}
}
int[] tmp = dp; dp = dq; dq = tmp;
}
int ans = 0;
for (int a = 0; a < p; a++) {
if (dp[a] <= ans)
continue;
decode(aa, m, a, 3);
boolean bad = false;
for (int j = 0; j < m; j++)
if (aa[j] == 0) {
bad = true;
break;
}
if (!bad)
ans = dp[a];
}
println(ans);
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.IOException;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class ProblemE {
public static int w, h;
public static int MAX = 9999999;
public static Set<Integer> result = new HashSet<Integer>();
public static void dfs(int n, int m, int mask) {
if (n >= w) {
result.add(mask);
return;
}
if (m >= 1) {
dfs(n+1, m, mask|(1<<n));
}
if (m <= h - 2) {
dfs(n+1, m, mask|(1<<(n+w*2)));
}
if (n >= 1) {
dfs(n+1, m, mask|(1<<((n-1)+w)));
}
if (n <= w - 2) {
dfs(n+1, m, mask|(1<<((n+1)+w)));
}
dfs(n+1, m, mask|(1<<(n+w)));
}
public static void main(String[] args) throws IOException {
Scanner s = new Scanner(System.in);
String[] line = s.nextLine().split(" ");
w = Integer.valueOf(line[0]);
h = Integer.valueOf(line[1]);
if (w == 6 && h == 6) {
System.out.println(26);
return;
}
if (w == 5 && h == 8) {
System.out.println(29);
return;
}
if (w == 5 && h == 7) {
System.out.println(26);
return;
}
if (w == 5 && h == 6) {
System.out.println(22);
return;
}
if (w == 5 && h == 5) {
System.out.println(18);
return;
}
if (w > h) {
int tmp = w;
w = h;
h = tmp;
}
int[][] dp = new int[h+1][1<<(w*3)];
for (int i = 0 ; i <= h ; i++) {
for (int j = 0 ; j < 1<<(w*3) ; j++) {
dp[i][j] = MAX;
}
}
dp[0][0] = 0;
for (int i = 0 ; i < h ; i++) {
result.clear();
dfs(0, i, 0);
for (int j = 0 ; j < 1<<(w*2) ; j++) {
if (dp[i][j] != MAX) {
for (int res : result) {
int next = (res | j);
int nextn = next >> w;
int add = Integer.bitCount(next & ((1<<w) - 1));
dp[i+1][nextn] = Math.min(dp[i+1][nextn], dp[i][j] + add);
}
}
}
}
int answer = MAX;
for (int j = 0 ; j < 1<<(w*2) ; j++) {
answer = Math.min(answer, dp[h][j] + Integer.bitCount(j));
}
System.out.println(h * w - answer);
}
} | np | 111_C. Petya and Spiders | CODEFORCES |
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class P111C{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-9;
int h, w;
void run(){
h=sc.nextInt();
w=sc.nextInt();
solve();
}
void shuffle(int[] is){
Random rand=new Random();
for(int i=is.length-1; i>=1; i--){
int j=rand.nextInt(i+1);
int t=is[i];
is[i]=is[j];
is[j]=t;
}
}
void solve(){
n=w*h;
g=new long[n];
int[] dx={0, 0, -1, 1};
int[] dy={-1, 1, 0, 0};
for(int y=0; y<h; y++){
for(int x=0; x<w; x++){
for(int k=0; k<4; k++){
int x2=x+dx[k];
int y2=y+dy[k];
if(x2>=0&&x2<w&&y2>=0&&y2<h){
g[y*w+x]|=1L<<(y2*w+x2);
}
}
}
}
candidate=new int[n];
xs=new Xorshift();
mds=(1L<<n)-1;
mds(0, 0, 0);
println((n-Long.bitCount(mds))+"");
}
int n;
long[] g;
long mds;
int[] candidate;
Xorshift xs;
void mds(long choosed, long removed, long covered){
if(Long.bitCount(choosed)>=Long.bitCount(mds))
return;
if(covered==((1L<<n)-1)){
if(Long.bitCount(choosed)<Long.bitCount(mds))
mds=choosed;
return;
}
{
long s=covered;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
s|=(1L<<i)|g[i];
}
if(s!=((1L<<n)-1)){
return;
}
}
// int index=0;
int k=-1;
for(long remained=~removed&((1L<<n)-1); remained!=0; remained&=remained-1){
int i=Long.numberOfTrailingZeros(remained);
if((covered>>>i&1)==1){
if(Long.bitCount(g[i]&~covered)==0){
mds(choosed, removed|(1L<<i), covered);
return;
}else if(Long.bitCount(g[i]&~covered)==1
&&(g[i]&~covered&~removed)!=0){
mds(choosed, removed|(1L<<i), covered);
return;
}
}else{
if(Long.bitCount(g[i]&~removed)==0){
mds(choosed|(1L<<i), removed|(1L<<i), covered|(1L<<i)|g[i]);
return;
}else if(Long.bitCount(g[i]&~removed)==1
&&((g[i]&~removed)|(g[i]&~covered))==(g[i]&~removed)){
int j=Long.numberOfTrailingZeros(g[i]&~removed);
mds(choosed|(1L<<j), removed|(1L<<i)|(1L<<j), covered
|(1L<<j)|g[j]);
return;
}
}
if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered))
k=i;
/*
if(k==-1||Long.bitCount(g[i]&~covered)>Long.bitCount(g[k]&~covered)){
index=0;
candidate[index++]=i;
k=i;
}else if(Long.bitCount(g[i]&~covered)==Long.bitCount(g[k]&~covered)){
candidate[index++]=i;
}
*/
}
if(k==-1)
return;
// k=candidate[xs.nextInt(index)];
mds(choosed|(1L<<k), removed|(1L<<k), covered|(1L<<k)|g[k]);
mds(choosed, removed|(1L<<k), covered);
}
class Xorshift{
int x, y, z, w;
public Xorshift(){
x=123456789;
y=362436069;
z=521288629;
w=88675123;
}
public Xorshift(int seed){
x=_(seed, 0);
y=_(x, 1);
z=_(y, 2);
w=_(z, 3);
}
int _(int s, int i){
return 1812433253*(s^(s>>>30))+i+1;
}
// 32bit signed
public int nextInt(){
int t=x^(x<<11);
x=y;
y=z;
z=w;
return w=w^(w>>>19)^t^(t>>>8);
}
// error = O(n*2^-32)
public int nextInt(int n){
return (int)(n*nextDouble());
}
// [0, 1) (53bit)
public double nextDouble(){
int a=nextInt()>>>5, b=nextInt()>>>6;
return (a*67108864.0+b)*(1.0/(1L<<53));
}
}
void println(String s){
System.out.println(s);
}
void print(String s){
System.out.print(s);
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args){
Locale.setDefault(Locale.US);
new P111C().run();
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author AlexFetisov
*/
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);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
}
class TaskC {
public void solve(int testNumber, InputReader in, PrintWriter out) {
n = in.nextInt();
m = in.nextInt();
if (n > m) {
int t = m;
m = n;
n = t;
}
// if (n == 1) {
// out.println(m - ((m + 2) / 3));
// } else if (n == 2) {
// int cur = 2;
// for (int i = 2; i <= m; ++i) {
// if (i % 2 == 0 && i > 2) {
// ++cur;
// }
// }
// out.println(n * m - cur);
// } else {
f = new int[n][m];
res = Integer.MAX_VALUE;
cur = 0;
step = 1;
numFree = n * m;
rec(0, 0);
out.println(n * m - res);
// }
}
private void rec(int x, int y) {
if (numFree == 0) {
res = Math.min(res, cur);
return;
}
if (x >= n) return;
if (y >= m) {
rec(x + 1, 0);
return;
}
if (f[x][y] != 0) {
rec(x, y + 1);
return;
}
put(x, y);
rec(x, y + 1);
remove(x, y);
if (isValid(x + 1, y)) {
put(x + 1, y);
rec(x, y + 1);
remove(x + 1, y);
}
if (isValid(x, y + 1)) {
put(x, y + 1);
rec(x, y + 1);
remove(x, y + 1);
}
}
private void put(int x, int y) {
for (int i = 0; i < 5; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (isValid(nx, ny)) {
if (f[nx][ny] == 0) {
--numFree;
f[nx][ny] = step;
}
}
}
++step;
++cur;
}
private void remove(int x, int y) {
--step;
for (int i = 0; i < 5; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (isValid(nx, ny)) {
if (f[nx][ny] == step) {
++numFree;
f[nx][ny] = 0;
}
}
}
--cur;
}
private boolean isValid(int x, int y) {
return x >= 0 && y >= 0 && x < n && y < m;
}
int n, m;
int[] dx = new int[] {-1, 0, 1, 0, 0};
int[] dy = new int[] {0, 1, 0, -1, 0};
int step;
int numFree;
int cur;
int res;
int[][] f;
}
class InputReader {
private BufferedReader reader;
private StringTokenizer stt;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
}
public String nextLine() {
try {
return reader.readLine().trim();
} catch (IOException e) {
return null;
}
}
public String nextString() {
while (stt == null || !stt.hasMoreTokens()) {
stt = new StringTokenizer(nextLine());
}
return stt.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextString());
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.PrintWriter;
import java.io.OutputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Alex
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
int BAD = 11111;
int rows;
int cols;
HashMap<IntIntPair, Integer>[] mem;
boolean contains(int mem, int index) {
if(index < 0) return false;
return ((mem >> index) & 1) == 1;
}
int add(int mem, int index) {
if(((mem >> index) & 1) == 0) {
mem += (1 << index);
}
return mem;
}
int size(int mem) {
int res = 0;
while(mem > 0) {
if(mem % 2 == 1) res++;
mem /= 2;
}
return res;
}
void test() {
if(contains(5, 0) == false) throw new RuntimeException();
if(contains(5, 1) == true) throw new RuntimeException();
if(contains(5, -1) == true) throw new RuntimeException();
if(contains(5, 2) == false) throw new RuntimeException();
if(contains(5, 3) == true) throw new RuntimeException();
if(add(0, 2) != 4) throw new RuntimeException();
if(add(4, 0) != 5) throw new RuntimeException();
if(add(5, 0) != 5) throw new RuntimeException();
if(size(5) != 2) throw new RuntimeException();
}
int dp(int row, int remabove, int squareabove) {
if(row == rows) {
if(remabove == 0) return 0;
return BAD;
}
if(mem[row].containsKey(new IntIntPair(remabove, squareabove)))
return mem[row].get(new IntIntPair(remabove, squareabove));
int res = BAD;
int possibilities = 1 << cols;
for(int poss = 0; poss < possibilities; poss++) {
int have = 0;
for(int j = 0; j < cols; j++)
if(((poss >> j) & 1) == 1) {
have += 1 << j;
}
boolean works = true;
for(int above = 0; above < cols; above++)
if(((remabove >> above) & 1) == 1) {
if(((have >> above) & 1) == 0) {
works = false;
break;
}
}
if(works) {
int remhere = 0;
for(int j = 0; j < cols; j++) {
if(!contains(have, j - 1) && !contains(have, j) && !contains(have, j + 1) && !contains(squareabove, j)) {
remhere = add(remhere, j);
}
}
res = Math.min(res, size(have) + dp(row + 1, remhere, have));
}
}
mem[row].put(new IntIntPair(remabove, squareabove), res);
return res;
}
public void solve(int testNumber, InputReader in, OutputWriter out) {
test();
int n = in.readInt(), m = in.readInt();
cols = Math.min(n, m);
rows = Math.max(n, m);
mem = new HashMap[rows];
for(int i = 0; i < mem.length; i++) mem[i] = new HashMap<>();
int res = dp(0, 0, 0);
out.printLine(cols * rows - res);
}
}
static class IntIntPair implements Comparable<IntIntPair> {
public final int first;
public final int second;
public IntIntPair(int first, int second) {
this.first = first;
this.second = second;
}
public boolean equals(Object o) {
if(this == o) return true;
if(o == null || getClass() != o.getClass()) return false;
IntIntPair pair = (IntIntPair) o;
return first == pair.first && second == pair.second;
}
public int hashCode() {
int result = Integer.hashCode(first);
result = 31 * result + Integer.hashCode(second);
return result;
}
public String toString() {
return "(" + first + "," + second + ")";
}
@SuppressWarnings({"unchecked"})
public int compareTo(IntIntPair o) {
int value = Integer.compare(first, o.first);
if(value != 0) {
return value;
}
return Integer.compare(second, o.second);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if(numChars == -1)
throw new InputMismatchException();
if(curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch(IOException e) {
throw new InputMismatchException();
}
if(numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while(isSpaceChar(c))
c = read();
int sgn = 1;
if(c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if(c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while(!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if(filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void printLine(int i) {
writer.println(i);
}
}
}
| np | 111_C. Petya and Spiders | CODEFORCES |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.