File size: 3,755 Bytes
c574d3a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
/*
- At first, the program generates graphs of all sizes from 10 to 50
- To ensure the graph is connected, start with a ring graph
- Just increase the degree of each node by 2 by adding edges randomly
- Sometimes it might be stuck where it can't add anymore edges without creating parallel edges, but some nodes don't have a degree of 4
- Just maintain a counter and restart when too many iterations happen without adding edges
- If A is the adjacency matrix, (A^k)[i][j] gives the number of paths from i to j with k edges
- If the rows and columns of A were permuted into B, B^k would also be permuted the same way
- To find the permutation, sort every row A^k and B^k and just try to match each row in A with each row in B
- This won't work if the rows aren't distinct after sorting, just choose a different k or regenerate a graph
*/
import java.io.*;
import java.util.*;
public class Solution {
static final Reader in = new Reader();
static final PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
long[][][] mats=new long[41][][];
int[] pow = new int[41];
for(int ti=10; ti<=50; ++ti) {
mats[ti-10] = new long[ti][ti];
for(int i=0; i<ti; ++i)
mats[ti-10][i][(i+1)%ti]=mats[ti-10][(i+1)%ti][i]=1;
int[] deg = new int[ti];
int trs=0;
for(int i=0; i<ti&&trs<ti; ++i) {
trs=0;
while(deg[i]<2&&trs<ti) {
int j=r(ti);
if(j!=i&&mats[ti-10][i][j]==0&°[j]<2) {
mats[ti-10][i][j]=mats[ti-10][j][i]=1;
++deg[i];
++deg[j];
}
++trs;
}
}
if(trs<ti) {
long[][] pa = new long[ti][], pa2 = new long[ti][];
for(int i=0; i<ti; ++i)
pa[i]=Arrays.copyOf(mats[ti-10][i], ti);
for(int it=0; it<ti&&pow[ti-10]==0; ++it) {
pa=matMultM(mats[ti-10], pa);
for(int i=0; i<ti; ++i) {
pa2[i]=Arrays.copyOf(pa[i], ti);
Arrays.sort(pa2[i]);
}
boolean ok=true;
for(int i=0; i<ti&&ok; ++i)
for(int j=i+1; j<ti&&ok; ++j)
ok=!Arrays.equals(pa2[i], pa2[j]);
if(ok)
pow[ti-10]=it+2;
}
}
if(pow[ti-10]==0)
--ti;
}
int tt=in.nextInt();
for(int ti=1; ti<=tt; ++ti) {
int l=in.nextInt(), r=in.nextInt();
if(l==-1)
return;
out.println(l);
for(int i=0; i<l; ++i)
for(int j=i+1; j<l; ++j)
if(mats[l-10][i][j]>0)
out.println((i+1)+" "+(j+1));
out.flush();
long[][] mat1 = new long[l][l], mat2 = new long[l][l], mat3 = new long[l][l];
in.nextInt();
for(int i=0; i<l*2; ++i) {
int u=in.nextInt()-1, v=in.nextInt()-1;
mat2[u][v]=mat2[v][u]=mat3[u][v]=mat3[v][u]=1;
}
for(int i=0; i<l; ++i)
mat1[i]=Arrays.copyOf(mats[l-10][i], l);
for(int it=0; it<pow[l-10]-1; ++it) {
mat1=matMultM(mats[l-10], mat1);
mat2=matMultM(mat3, mat2);
}
for(int i=0; i<l; ++i) {
Arrays.sort(mat1[i]);
Arrays.sort(mat2[i]);
}
for(int i=0; i<l; ++i)
for(int j=0; j<l; ++j)
if(Arrays.equals(mat1[i], mat2[j]))
out.print((j+1)+" ");
out.println();
out.flush();
}
out.close();
}
static long[][] matMultM(long[][] a, long[][] b) {
long[][] product = new long[a.length][b[0].length];
for(int i=0; i<a.length; ++i)
for(int j=0; j<b[0].length; ++j)
for(int k=0; k<b.length; ++k)
product[i][j]+=a[i][k]*b[k][j];
return product;
}
static int r(int n) {
return (int)(Math.random()*n);
}
static class Reader {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
String next() {
while(st==null||!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch(Exception e) {}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
}
}
|