History

Some experimental tests added

Dmitry Kabak (userdima committed 13 years ago

Commit 793a5e81 parent 19a9d493 files · +270 −1Browse files

Showing the changes to java/tests/EgorTask1Test.java (1 of 3 files). Show all

Unified · Split

java/tests/EgorTask1Test.java+237−0
@@ -0,0 +1,237 @@
1
2import static utils.Utils.*;
3
4import java.io.OutputStreamWriter;
5import java.io.BufferedWriter;
6import java.util.Comparator;
7import java.io.OutputStream;
8import java.io.PrintWriter;
9import java.io.Writer;
10import java.util.List;
11import java.io.IOException;
12import java.util.Arrays;
13import java.util.InputMismatchException;
14import java.util.ArrayList;
15import java.util.NoSuchElementException;
16import java.math.BigInteger;
17import java.io.InputStream;
18
19/// This test is based on Egor Kulikov task solution from
20/// http://codeforces.com/submissions/Egor
21/// http://codeforces.com/problemset/problem/336/E
22
23/**
24 * Built using CHelper plug-in
25 * Actual solution is at the top
26 * @author Egor Kulikov (egor@egork.net)
27 */
28public class EgorTask1Test {
29 public static void main(String[] args) {
30 InputStream inputStream = System.in;
31 OutputStream outputStream = System.out;
32 InputReader in = new InputReader(inputStream);
33 OutputWriter out = new OutputWriter(outputStream);
34 TaskE solver = new TaskE();
35 solver.solve(1, in, out);
36 out.close();
37 }
38}
39
40class TaskE {
41 static final long MOD = 1000000007;
42
43 long[][][] result;
44 long[][][] resultSmall;
45 long[][] c = IntegerUtils.generateBinomialCoefficients(13);
46
47 public void solve(int testNumber, InputReader in, OutputWriter out) {
48 int size = in.readInt();
49 int count = in.readInt();
50 result = new long[size + 1][count + 1][16];
51 resultSmall = new long[size + 1][count + 1][16];
52 ArrayUtils.fill(result, -1);
53 ArrayUtils.fill(resultSmall, -1);
54 long answer = calculate(size, count, 0);
55 answer *= IntegerUtils.factorial(count, MOD);
56 answer %= MOD;
57 out.printLine(answer);
58 }
59
60 private long calculate(int size, int count, int mask) {
61 if (count < 0)
62 return 0;
63 if (result[size][count][mask] != -1)
64 return result[size][count][mask];
65 long current = 0;
66 if (mask == 0)
67 current += 2 * calculate(0, count - 2, 15);
68 for (int i = 0; i < 4; i++) {
69 int j = (i + 1) & 3;
70 if ((mask >> i & 1) != 0 || (mask >> j & 1) != 0)
71 continue;
72 int remaining = 15 - mask - (1 << i) - (1 << j);
73 for (int k = remaining; ; k = (k - 1) & remaining) {
74 current += calculateSmall(size, count - 1 - Integer.bitCount(k), mask + (1 << i) + (1 << j) + k);
75 if (k == 0)
76 break;
77 }
78 }
79 int remaining = 15 - mask;
80 for (int k = remaining; ; k = (k - 1) & remaining) {
81 current += calculateSmall(size, count - Integer.bitCount(k), mask + k);
82 if (k == 0)
83 break;
84 }
85 return result[size][count][mask] = current % MOD;
86 }
87
88 private long calculateSmall(int size, int count, int mask) {
89 if (count < 0)
90 return 0;
91 if (resultSmall[size][count][mask] != -1)
92 return resultSmall[size][count][mask];
93 if (size == 0)
94 return resultSmall[size][count][mask] = count == 0 ? 1 : 0;
95 int max = 3 * Integer.bitCount(15 - mask);
96 int pairCount = 0;
97 for (int i = 0; i < 4; i++) {
98 int j = (i + 1) & 3;
99 if ((mask >> i & 1) == 0 && ((mask >> j & 1) == 0))
100 pairCount++;
101 }
102 long current = 0;
103 for (int j = 0; j <= pairCount; j++) {
104 for (int i = 0; i <= max - 2 * j; i++)
105 current += calculate(size - 1, count - i - j, mask) * c[max - 2 * j][i] * c[pairCount][j];
106 }
107 return resultSmall[size][count][mask] = current % MOD;
108 }
109}
110
111class IntegerUtils {
112
113 public static long[][] generateBinomialCoefficients(int n) {
114 long[][] result = new long[n + 1][n + 1];
115 for (int i = 0; i <= n; i++) {
116 result[i][0] = 1;
117 for (int j = 1; j <= i; j++)
118 result[i][j] = result[i - 1][j - 1] + result[i - 1][j];
119 }
120 return result;
121 }
122
123 public static long factorial(int n, long mod) {
124 long result = 1;
125 for (int i = 2; i <= n; i++)
126 result = result * i % mod;
127 return result % mod;
128 }
129
130 }
131
132class InputReader {
133
134 private InputStream stream;
135 private byte[] buf = new byte[1024];
136 private int curChar;
137 private int numChars;
138 private SpaceCharFilter filter;
139
140 public InputReader(InputStream stream) {
141 this.stream = stream;
142 }
143
144 public int read() {
145 if (numChars == -1)
146 throw new InputMismatchException();
147 if (curChar >= numChars) {
148 curChar = 0;
149 try {
150 numChars = stream.read(buf);
151 } catch (IOException e) {
152 throw new InputMismatchException();
153 }
154 if (numChars <= 0)
155 return -1;
156 }
157 return buf[curChar++];
158 }
159
160 public int readInt() {
161 int c = read();
162 while (isSpaceChar(c))
163 c = read();
164 int sgn = 1;
165 if (c == '-') {
166 sgn = -1;
167 c = read();
168 }
169 int res = 0;
170 do {
171 if (c < '0' || c > '9')
172 throw new InputMismatchException();
173 res *= 10;
174 res += c - '0';
175 c = read();
176 } while (!isSpaceChar(c));
177 return res * sgn;
178 }
179
180 public boolean isSpaceChar(int c) {
181 if (filter != null)
182 return filter.isSpaceChar(c);
183 return isWhitespace(c);
184 }
185
186 public static boolean isWhitespace(int c) {
187 return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
188 }
189
190 public interface SpaceCharFilter {
191 public boolean isSpaceChar(int ch);
192 }
193}
194
195class OutputWriter {
196 private final PrintWriter writer;
197
198 public OutputWriter(OutputStream outputStream) {
199 writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
200 }
201
202 public OutputWriter(Writer writer) {
203 this.writer = new PrintWriter(writer);
204 }
205
206 public void print(Object...objects) {
207 for (int i = 0; i < objects.length; i++) {
208 if (i != 0)
209 writer.print(' ');
210 writer.print(objects[i]);
211 }
212 }
213
214 public void printLine(Object...objects) {
215 print(objects);
216 writer.println();
217 }
218
219 public void close() {
220 writer.close();
221 }
222
223 }
224
225class ArrayUtils {
226
227 public static void fill(long[][] array, long value) {
228 for (long[] row : array)
229 Arrays.fill(row, value);
230 }
231
232 public static void fill(long[][][] array, long value) {
233 for (long[][] row : array)
234 fill(row, value);
235 }
236
237 }