281. Java 5、11628バイト、A000947
// package oeis_challenge;
import java.util.*;
import java.lang.*;
class Main {
// static void assert(boolean cond) {
// if (!cond)
// throw new Error("Assertion failed!");
// }
/* Use the formula a(n) = A000063(n + 2) - A000936(n).
It's unfair that I use the formula of "number of free polyenoid with n
nodes and symmetry point group C_{2v}" (formula listed in A000063)
without understanding why it's true...
*/
static int catalan(int x) {
int ans = 1;
for (int i = 1; i <= x; ++i)
ans = ans * (2*x+1-i) / i;
return ans / -~x;
}
static int A63(int n) {
int ans = catalan(n/2 - 1);
if (n%4 == 0) ans -= catalan(n/4 - 1);
if (n%6 == 0) ans -= catalan(n/6 - 1);
return ans;
}
static class Point implements Comparable<Point> {
final int x, y;
Point(int _x, int _y) {
x = _x; y = _y;
}
/// @return true if this is a point, false otherwise (this is a vector)
public boolean isPoint() {
return (x + y) % 3 != 0;
}
/// Translate this point by a vector.
public Point add(Point p) {
assert(this.isPoint() && ! p.isPoint());
return new Point(x + p.x, y + p.y);
}
/// Reflect this point along x-axis.
public Point reflectX() {
return new Point(x - y, -y);
}
/// Rotate this point 60 degrees counter-clockwise.
public Point rot60() {
return new Point(x - y, x);
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
Point p = (Point) o;
return x == p.x && y == p.y;
}
@Override
public int hashCode() {
return 21521 * (3491 + x) + y;
}
public String toString() {
// return String.format("(%d, %d)", x, y);
return String.format("setxy %d %d", x * 50 - y * 25, y * 40);
}
public int compareTo(Point p) {
int a = Integer.valueOf(x).compareTo(p.x);
if (a != 0) return a;
return Integer.valueOf(y).compareTo(p.y);
}
/// Helper class.
static interface Predicate {
abstract boolean test(Point p);
}
static abstract class UnaryFunction {
abstract Point apply(Point p);
}
}
static class Edge implements Comparable<Edge> {
final Point a, b; // guarantee a < b
Edge(Point x, Point y) {
assert x != y;
if (x.compareTo(y) > 0) { // y < x
a = y; b = x;
} else {
a = x; b = y;
}
}
public int compareTo(Edge e) {
int x = a.compareTo(e.a);
if (x != 0) return x;
return b.compareTo(e.b);
}
}
/// A graph consists of multiple {@code Point}s.
static class Graph {
private HashMap<Point, Point> points;
public Graph() {
points = new HashMap<Point, Point>();
}
public Graph(Graph g) {
points = new HashMap<Point, Point>(g.points);
}
public void add(Point p, Point root) {
assert(p.isPoint());
assert(root.isPoint());
assert(p == root || points.containsKey(root));
points.put(p, root);
}
public Graph map(Point.UnaryFunction fn) {
Graph result = new Graph();
for (Map.Entry<Point, Point> pq : points.entrySet()) {
Point p = pq.getKey(), q = pq.getValue();
assert(p.isPoint()) : p;
assert(q.isPoint()) : q;
p = fn.apply(p); assert(p.isPoint()) : p;
q = fn.apply(q); assert(q.isPoint()) : q;
result.points.put(p, q);
}
return result;
}
public Graph reflectX() {
return this.map(new Point.UnaryFunction() {
public Point apply(Point p) {
return p.reflectX();
}
});
}
public Graph rot60() {
return this.map(new Point.UnaryFunction() {
public Point apply(Point p) {
return p.rot60();
}
});
}
@Override
public boolean equals(Object o) {
if (o == null) return false;
if (o.getClass() != getClass()) return false;
Graph g = (Graph) o;
return points.equals(g.points);
}
@Override
public int hashCode() {
return points.hashCode();
}
Graph[] expand(Point.Predicate fn) {
List<Graph> result = new ArrayList<Graph>();
for (Point p : points.keySet()) {
int[] deltaX = new int[] { -1, 0, 1, 1, 0, -1};
int[] deltaY = new int[] { 0, 1, 1, 0, -1, -1};
for (int i = 6; i --> 0;) {
Point p1 = new Point(p.x + deltaX[i], p.y + deltaY[i]);
if (points.containsKey(p1) || !fn.test(p1)
|| !p1.isPoint()) continue;
Graph g = new Graph(this);
g.add(p1, p);
result.add(g);
}
}
return result.toArray(new Graph[0]);
}
public static Graph[] expand(Graph[] graphs, Point.Predicate fn) {
Set<Graph> result = new HashSet<Graph>();
for (Graph g0 : graphs) {
Graph[] g = g0.expand(fn);
for (Graph g1 : g) {
if (result.contains(g1)) continue;
result.add(g1);
}
}
return result.toArray(new Graph[0]);
}
private Edge[] edges() {
List<Edge> result = new ArrayList<Edge>();
for (Map.Entry<Point, Point> pq : points.entrySet()) {
Point p = pq.getKey(), q = pq.getValue();
if (p.equals(q)) continue;
result.add(new Edge(p, q));
}
return result.toArray(new Edge[0]);
}
/**
* Check if two graphs are isomorphic... under translation.
* @return {@code true} if {@code this} is isomorphic
* under translation, {@code false} otherwise.
*/
public boolean isomorphic(Graph g) {
if (points.size() != g.points.size()) return false;
Edge[] a = this.edges();
Edge[] b = g.edges();
Arrays.sort(a);
Arrays.sort(b);
// for (Edge e : b)
// System.err.println(e.a + " - " + e.b);
// System.err.println("------- >><< ");
assert (a.length > 0);
assert (a.length == b.length);
int a_bx = a[0].a.x - b[0].a.x, a_by = a[0].a.y - b[0].a.y;
for (int i = 0; i < a.length; ++i) {
if (a_bx != a[i].a.x - b[i].a.x ||
a_by != a[i].a.y - b[i].a.y) return false;
if (a_bx != a[i].b.x - b[i].b.x ||
a_by != a[i].b.y - b[i].b.y) return false;
}
return true;
}
// C_{2v}.
public boolean correctSymmetry() {
Graph[] graphs = new Graph[6];
graphs[0] = this.reflectX();
for (int i = 1; i < 6; ++i) graphs[i] = graphs[i-1].rot60();
assert(graphs[5].rot60().isomorphic(graphs[0]));
int count = 0;
for (Graph g : graphs) {
if (this.isomorphic(g)) ++count;
// if (count >= 2) {
// return false;
// }
}
// if (count > 1) System.err.format("too much: %d%n", count);
assert(count > 0);
return count == 1; // which is, basically, true
}
public void reflectSelfType2() {
Graph g = this.map(new Point.UnaryFunction() {
public Point apply(Point p) {
return new Point(p.y - p.x, p.y);
}
});
Point p = new Point(1, 1);
assert (p.equals(points.get(p)));
points.putAll(g.points);
assert (p.equals(points.get(p)));
Point q = new Point(0, 1);
assert (q.equals(points.get(q)));
points.put(p, q);
}
public void reflectSelfX() {
Graph g = this.reflectX();
points.putAll(g.points); // duplicates doesn't matter
}
}
static int A936(int n) {
// if (true) return (new int[]{0, 0, 0, 1, 1, 2, 4, 4, 12, 10, 29, 27, 88, 76, 247, 217, 722, 638, 2134, 1901, 6413})[n];
// some unreachable codes here for testing.
int ans = 0;
if (n % 2 == 0) { // reflection type 2. (through line 2x == y)
Graph[] graphs = new Graph[1];
graphs[0] = new Graph();
Point p = new Point(1, 1);
graphs[0].add(p, p);
for (int i = n / 2 - 1; i --> 0;)
graphs = Graph.expand(graphs, new Point.Predicate() {
public boolean test(Point p) {
return 2*p.x > p.y;
}
});
int count = 0;
for (Graph g : graphs) {
g.reflectSelfType2();
if (g.correctSymmetry()) {
++count;
// for (Edge e : g.edges())
// System.err.println(e.a + " - " + e.b);
// System.err.println("------*");
}
// else System.err.println("Failed");
}
assert (count%2 == 0);
// System.err.println("A936(" + n + ") count = " + count + " -> " + (count/2));
ans += count / 2;
}
// Reflection type 1. (reflectX)
Graph[] graphs = new Graph[1];
graphs[0] = new Graph();
Point p = new Point(1, 0);
graphs[0].add(p, p);
if (n % 2 == 0) graphs[0].add(new Point(2, 0), p);
for (int i = (n-1) / 2; i --> 0;)
graphs = Graph.expand(graphs, new Point.Predicate() {
public boolean test(Point p) {
return p.y > 0;
}
});
int count = 0;
for (Graph g : graphs) {
g.reflectSelfX();
if (g.correctSymmetry()) {
++count;
// for (Edge e : g.edges())
// System.err.printf(
// "pu %s pd %s\n"
// // "%s - %s%n"
// , e.a, e.b);
// System.err.println("-------/");
}
// else System.err.println("Failed");
}
if(n % 2 == 0) {
assert(count % 2 == 0);
count /= 2;
}
ans += count;
// System.err.println("A936(" + n + ") = " + ans);
return ans;
}
public static void main(String[] args) {
// Probably
if (! "1.5.0_22".equals(System.getProperty("java.version"))) {
System.err.println("Warning: Java version is not 1.5.0_22");
}
// A936(6);
for (int i = 0; i < 20; ++i)
System.out.println(i + " | " + (A63(i+9) - A936(i+7)));
//A936(i+2);
}
}
オンラインでお試しください！
サイドノート：
- Java 5を使用してローカルでテスト済み（警告が出力されないように-TIOデバッグタブを参照）
- しないでください。今まで。つかいます。Java。1.一般的なJavaよりも冗長です。
これによりチェーンが破損する場合があります。 - ギャップ（7日と48分）は、この回答によって作成されたギャップよりも大きくはありません。ギャップは、前の回答よりも7日と1時間25分遅れています。
大バイト数の新記録！私は（誤って？）タブの代わりにスペースを使用しているため、バイトカウントが必要以上に大きくなっています。私のマシンでは9550バイトです。（この改訂を書いている時点で）- 次のシーケンス。
- コードは、現在の形式では、シーケンスの最初の20項のみを出力します。ただし、最初の1000個のアイテムを印刷するように変更するのは簡単です（
20in for (int i = 0; i < 20; ++i)をに変更することにより1000）
わーい！これにより、OEISページにリストされているより多くの用語を計算できます！（初めて、チャレンジのためにJavaを使用する必要があります）OEISがどこかにもっと用語を持たない限り...
簡単な説明
シーケンスの説明の説明。
シーケンスは、対称グループC 2vを持つ自由な非平面ポリエノイドの数を求めます。ここで、
- ポリエノイド：（ポリエン炭化水素の数学モデル）木（または縮退の場合は単一の頂点）を六角格子に埋め込むことができます。
たとえば、木を考えます
O O O O (3)
| \ / \
| \ / \
O --- O --- O O --- O O --- O
| \
| (2) \
(1) O O
最初のものは六角格子に埋め込むことはできませんが、2番目のものは埋め込むことができます。その特定の埋め込みは、3番目のツリーとは異なると見なされます。
- 非平面ポリエノイド：重複する2つの頂点が存在するようにツリーを埋め込みます。
(2)そして(3)上のツリーは平面です。ただし、これは非平面です。
O---O O
/ \
/ \
O O
\ /
\ /
O --- O
（7つの頂点と6つのエッジがあります）
- 遊離ポリエノイド：回転と反射によって取得できる1つのポリエノイドのバリアントは、1としてカウントされます。
- C 2vグループ：ポリエノイドは、2つの垂直な反射面がある場合にのみカウントされ、それ以上はカウントされません。
たとえば、2つの頂点を持つ唯一のポリエノイド
O --- O
には3つの反射面があります。水平面-、垂直面|、およびコンピューター画面に平行な面■です。それは多すぎる。
一方、これは
O --- O
\
\
O
には2つの反射面が/あり■ます：と。
メソッドの説明
そして今、実際に数を数える方法に関するアプローチ。
まず、公式a(n) = A000063(n + 2) - A000936(n)（OEISページにリストされている）を当たり前のように受け止めます。私は論文の説明を読みませんでした。
[この部分を修正するTODO]
もちろん、非平面よりも平面を数える方が簡単です。それもこの論文の目的です。
幾何学的に平坦なポリエノイド（頂点が重複しない）は、コンピュータープログラミングによって列挙されます。したがって、幾何学的に非平面のポリエノイドの数にアクセスできます。
そのため、プログラムは平面状ポリエノイドの数をカウントし、合計から減算します。
とにかく木は平面であるため、明らか■に反射面があります。そのため、条件は「2D表現で反射軸を持つツリーの数をカウントする」ことになります。
単純な方法は、nノードを持つすべてのツリーを生成し、正しい対称性をチェックすることです。ただし、反射軸を持つツリーの数のみを検索するため、半分にすべての可能なハーフツリーを生成し、軸を介してそれらをミラーリングしてから、正しい対称性を確認します。さらに、生成されるポリエノイドは（平面）ツリーであるため、反射軸に一度だけ触れる必要があります。
関数public static Graph[] expand(Graph[] graphs, Point.Predicate fn)はグラフの配列を取り、それぞれがnノードを持ち、グラフの配列を出力します。それぞれがn+1ノードを持ち、互いに等しくありません（変換中）-追加されたノードはpredicateを満たさなければなりませんfn。
考えられる2つの反射軸について考えます。1つは頂点を通過してエッジと一致するもの（x = 0）、もう1つはエッジの垂直二等分線です（2x = y）。とにかく、生成されたグラフは同型なので、そのうちの1つだけを取ることができます。
だから、最初の軸のx = 0基地グラフが単一のノードで構成されてから、我々は、開始(1, 0)（ケースでn奇数である）、または間のエッジを持つ2つのノード(1, 0) - (2, 0)（ケースでnもある）、そして次に、そのノードを展開しますy > 0。これは、プログラムの「反射タイプ1」セクションで行われ、生成された各グラフに対して、X軸x = 0（g.reflectSelfX()）を介して自身を反射（ミラー）し、正しい対称性があるかどうかを確認します。
ただし、もしn2で割り切れる場合、この方法で各グラフを2回カウントしたことに注意してください2x = y + 3。これは、軸によってミラーイメージも生成するためです。
（2つのオレンジ色のものに注意してください）
軸についても同様で、偶数の2x = y場合（点のみ）nから開始し、の(1, 1)ようなグラフを生成し2*x > y、それぞれを2x = y軸に反映し（g.reflectSelfType2()）、で接続(1, 0)し(1, 1)、正しい対称性があるかどうかを確認します。2で割ることも忘れないでください。
