geometry

2014-04-11T23:11:53+09:00

-点クラス　複素平面をイメージ #highlight(java){{ class P{ static final double EPS=1e-10; static int signum(double x){ return x<-EPS?-1:x>EPS?1:0; } static Comparator

comp = new Comparator

(){ public int compare(P p1, P p2) { return signum(p1.x-p2.x)!=0?signum(p1.x-p2.x):signum(p1.y-p2.y); } }; public static final P O = new P(0,0); final double x, y; P(double _x,double _y){ x=_x; y=_y; } //四則 P add(P a){ return new P(x+a.x,y+a.y); } P sub(P a){ return new P(x-a.x,y-a.y); } P mul(P a){ return new P(x*a.x-y*a.y,x*a.y+y*a.x); } P div(P a){ double d2=a.dist2(O); return new P(dot(a,this)/d2,cross(a,this)/d2); } //共役 P conj(){ return new P(x,-y); } //内積　a・b=|a||b|cosθ=a.x*b.x+a.y*b.y static double dot(P a,P b){ return a.x*b.x+a.y*b.y; } //外積　a×b=|a||b|sinθ=a.x*b.y-a.y*b.x static double cross(P a,P b){ return a.x*b.y-a.y*b.x; } //二乗距離 double dist2(P p){ return (x-p.x)*(x-p.x)+(y-p.y)*(y-p.y); } //a,b間の距離 double dist(P p){ return sqrt(dist2(p)); } public double norm(){ return dist(O); } // a→b→cと進むときの向き static int ccw(P a,P b,P c){ b = b.sub(a); c = c.sub(a); if(cross(b,c)>EPS) return 1;//counter clockwise if(cross(b,c)<-EPS) return -1;//clockwise if(dot(b,c)<-EPS) return 2;//c--a--b on line if(b.norm()0?s:2*PI-s; } //oを中心に回転 P rotate(P o,double arg){ return this.add(this.sub(o).mul(new P(cos(arg),sin(arg)))); } //→OA,→OBの面積の2倍 static double S2(P a,P b,P o){ return cross(a.sub(o),b.sub(o)); } static double S(P a,P b,P o){ return S2(a,b,o)/2; } //絶対値と偏角から座標を取得 static P polar(double abs,double arg){ return new P(abs*cos(arg),abs*sin(arg)); } // ? static P proj(P p,P o){ return o.mul(new P(dot(p,o)/o.norm(),0)); } public boolean equals(Object obj) { if(obj instanceof P){ P p=(P)obj; return signum(x-p.x)==0 && signum(y-p.y)==0; } return false; } public String toString(){ return "("+x+","+y+")"; } } }} -線クラス #highlight(java){{ //(注) //dist,isIntersectは擬似的に二項関係の演算子として扱う //intersectionはPのコンストラクタとして扱う class L extends AL{ L(P _p1, P _p2) {super(_p1, _p2);} //直線と点の距離 double dist(P p){ return abs(P.S(p2,p,p1))/p1.sub(p2).norm(); } boolean isIntersect(P p){ return abs(P.S(p2,p,p1))EPS?1:0; } public P p1,p2; AL(P _p1,P _p2){ p1=_p1; p2=_p2; } boolean isPoint(){ return p1.equals(p2); } // public double a(){ // P dir= p2.sub(p1); // return dir.y/dir.x; // } // public double b(){ // return P.cross(p1,p2)/(p1.x-p2.x); // } //平行 boolean isParallel(AL l){ return abs(P.cross(p2.sub(p1),l.p2.sub(l.p1)))

others

2014-04-10T23:21:36+09:00

-next_permutation #highlight(java){{ static boolean next_permutation(int[]as) { int n = as.length; for (int i = n - 1; i > 0; i--) { if (as[i - 1] < as[i]) { int j = n; while (as[i - 1] >= as[--j]); swap(as, i - 1, j); reverse(as, i, n); return true; } } return false; } static void swap(int[] is, int i, int j) { int t = is[i]; is[i] = is[j]; is[j] = t; } static void reverse(int[] is, int s, int t) { while (s < --t) swap(is, s++, t); } }}

minimum cost flow

2013-11-22T23:24:55+09:00

-辺クラス #highlight(java){{ class Edge { int to, cap, cost, rev; Edge(int to, int cap, int cost, int rev) { this.to = to; this.cap = cap; this.cost = cost; this.rev = rev; } } }} -最小費用流(Bellman-Ford) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; List[] list; int[] d; int[] prevv, preve; void addEdge(int from, int to, int cap, int cost) { list[from].add(new Edge(to, cap, cost,list[to].size())); list[to].add(new Edge(from, 0, -cost, list[from].size()-1)); } int min_cost_flow(int s, int t , int f) { int n = list.length; d = new int[n]; prevv = new int[n]; preve = new int[n]; int res = 0; while (f > 0) { Arrays.fill(d, INF); d[s] = 0; boolean update = true; while (update) { update = false; for (int v = 0; v < n; v++) { if (d[v] == INF) continue; for (int i = 0; i < list[v].size(); i++) { Edge e = list[v].get(i); if (e.cap > 0 && d[e.to] > d[v] + e.cost) { d[e.to] = d[v] + e.cost; prevv[e.to] = v; preve[e.to] = i; update = true; } } } } if (d[t] == INF) return -1; int c = f; for (int v = t; v != s; v = prevv[v]) { c = Math.min(c, list[prevv[v]].get(preve[v]).cap); } f -= c; res += c * d[t]; for (int v = t; v != s; v = prevv[v]) { Edge e = list[prevv[v]].get(preve[v]); e.cap -= c; list[v].get(e.rev).cap += c; } } return res; } }}

max flow

2013-11-22T18:31:42+09:00

-辺クラス #highlight(java){{ class Edge { int to; int cap; int rev; Edge(int to, int cost, int rev) { this.to = to; this.cap = cost; this.rev = rev; } } }} -Ford-Fulkerson法(隣接リスト) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; List[] list; boolean[] used; void addEdge(int from, int to, int cap) { list[from].add(new Edge(to, cap,list[to].size())); list[to].add(new Edge(from, 0, list[from].size()-1)); } int dfs(int v, int t, int f) { if (v == t) return f; used[v] = true; for (int i = 0; i < list[v].size(); i++) { Edge e = list[v].get(i); if (!used[e.to] && e.cap > 0) { int d = dfs(e.to, t, Math.min(f, e.cap)); if (d > 0) { e.cap -= d; list[e.to].get(e.rev).cap += d; return d; } } } return 0; } int ford_fulkerson(int s, int t) { int flow = 0; while (true) { Arrays.fill(used, false); int f = dfs(s, t, INF); if (f == 0) return flow; flow += f; } } }}

string

2013-11-11T00:38:34+09:00

-反転 #highlight(java){{ String reverse(String s) { String ans = ""; int len = s.length(); for (int i = 0; i < len; i++) ans += s.charAt(len-i-1); return ans; } }} -回文判定~ 空文字列""もtrueを返す #highlight(java){{ boolean isPalindrome(String s) { int i = 0, j = s.length()-1; while (i < j) { if (s.charAt(i) != s.charAt(j)) return false; i++; j--; } return true; } }}

search

2013-10-26T13:01:27+09:00

-lower_bound~ key以上の値が出現する最初のインデックスを返す #highlight(java){{ int lower_bound(int[] a, int key) { int lb = 0, ub = a.length-1; if (a[lb] == key) return lb; while (ub - lb > 1) { int mid = (ub + lb) / 2; if (a[mid] >= key) ub = mid; else lb = mid; } return ub; } }} -upper_bound~ keyより大きい値が出現する最初のインデックスを返す #highlight(java){{ int upper_bound(int[] a, int key) { int lb = 0, ub = a.length-1; if (a[ub] == key) return ub + 1; while (ub - lb > 1) { int mid = (ub + lb) / 2; if (a[mid] > key) ub = mid; else lb = mid; } return lb+1; } }}

minimum spanning tree

2013-10-09T11:51:29+09:00

-Prim法(隣接行列) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; int[][] cost; int prim() { int n = cost.length; int[] mincost = new int[n]; boolean[] used = new boolean[n]; Arrays.fill(mincost, INF); mincost[0] = 0; int res = 0; while (true) { int v = -1; for (int u = 0; u < n; u++) { if (!used[u] && (v == -1 || mincost[u] < mincost[v])) v = u; } if (v == -1) break; used[v] = true; res += mincost[v]; for (int u = 0; u < n; u++) { mincost[u] = Math.min(mincost[u], cost[v][u]); } } return res; } }} -Prim法(隣接リスト) #highlight(java){{ class Edge { int to; int cost; Edge(int to, int cost) { this.to = to; this.cost = cost; } } class Pair implements Comparable { int index; int cost; Pair(int i, int c) { index = i; cost = c; } @Override public int compareTo(Pair o) { return cost - o.cost; } } final int INF = Integer.MAX_VALUE/2; List[] list; int prim() { int n = list.length; int[] mincost = new int[n]; Arrays.fill(mincost, INF); mincost[0] = 0; Queue queue = new PriorityQueue(); queue.add(new Pair(0, 0)); int res = 0; while (!queue.isEmpty()) { Pair p = queue.poll(); int v = p.index, c = p.cost; if (mincost[v] < c) continue; res += mincost[v]; for (Edge e : list[v]) { if (mincost[e.to] > e.cost) { mincost[e.to] = e.cost; queue.add(new Pair(e.to, e.cost)); } } } return res; } }} -Kruskal法 #highlight(java){{ class Edge implements Comparable { int from; int to; int cost; Edge(int from, int to, int cost) { this.from = from; this.to = to; this.cost = cost; } @Override public int compareTo(Edge o) { return cost - o.cost; } } Edge[] edge; int n; //頂点数 int kruskal() { Arrays.sort(edge); UnionFind uf = new UnionFind(n); int res = 0; for (int i = 0; i < edge.length; i++) { Edge e = edge[i]; if (!uf.same(e.from, e.to)) { uf.unite(e.from, e.to); res += e.cost; } } return res; } }}

shortest path

2013-10-08T12:54:29+09:00

-Bellman-Ford法(隣接行列) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; int[][] cost; int[] d; void bellman_ford(int s) { int n = cost.length; d = new int[n]; for (int i = 0; i < d.length; i++) d[i] = INF; d[s] = 0; boolean update; while (true) { update = false; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (cost[i][j] != INF) { if (d[i] != INF && d[i] + cost[i][j] < d[j]) { d[j] = d[i] + cost[i][j]; update = true; } } } } if (!update) break; } } }} -Dijkstra法(隣接行列) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; int[][] cost; int[] d; void dijkstra(int s) { int n = cost.length; d = new int[n]; boolean[] used = new boolean[n]; Arrays.fill(d, INF); d[s] = 0; while (true) { int v = -1; for (int u = 0; u < n; u++) { if (!used[u] && (v == -1 || d[u] < d[v])) v = u; } if (v == -1) break; used[v] = true; for (int u = 0; u < n; u++) { d[u] = Math.min(d[u], d[v]+cost[v][u]); } } } }} -Warshall-Floyd法(隣接行列) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; int[][] cost; int[][] d; void warshall_floyd() { int n = cost.length; d = new int[n][n]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) d[i][j] = cost[i][j]; for (int i = 0; i < n; i++) d[i][i] = 0; for (int k = 0; k < n; k++) for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) d[i][j] = Math.min(d[i][j], d[i][k]+d[k][j]); } }} -辺クラス #highlight(java){{ class Edge { int to; int cost; Edge(int to, int cost) { this.to = to; this.cost = cost; } } }} -Bellman-Ford法(隣接リスト) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; List[] list; int[] d; void bellman_ford(int s) { int n = list.length; d = new int[n]; Arrays.fill(d, INF); d[s] = 0; boolean update; while (true) { update = false; for (int i = 0; i < n; i++) { for (Edge e : list[i]) { if (d[i] != INF && d[i] + e.cost < d[e.to]) { d[e.to] = d[i] + e.cost; update = true; } } } if (!update) break; } } }} -Dijkstra法(隣接リスト) #highlight(java){{ class Pair implements Comparable { int index; int distance; Pair(int i, int d) { index = i; distance = d; } @Override public int compareTo(Pair o) { return distance - o.distance; } } final int INF = Integer.MAX_VALUE/2; List[] list; int[] d; void dijkstra(int s) { int n = list.length; d = new int[n]; Arrays.fill(d, INF); d[s] = 0; Queue queue = new PriorityQueue(); queue.add(new Pair(s, 0)); while (!queue.isEmpty()) { Pair p = queue.poll(); int v = p.index, dis = p.distance; if (d[v] < dis) continue; for (Edge e : list[v]) { if (d[v] + e.cost < d[e.to]) { d[e.to] = d[v] + e.cost; queue.add(new Pair(e.to, d[e.to])); } } } } }} -負の閉路がある場合はtrueを返す(隣接リスト) #highlight(java){{ List[] list; int[] d; boolean find_negative_loop() { int n = list.length; d = new int[n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { for (Edge e : list[j]) { if (d[j] + e.cost < d[e.to]) { d[e.to] = d[j] + e.cost; if (i == n-1) return true; } } } } return false; } }} -負の閉路がある場合はtrueを返す(隣接行列) #highlight(java){{ final int INF = Integer.MAX_VALUE/2; int[][] cost; int[] d; boolean find_negative_loop() { int n = cost.length; d = new int[n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < n; k++) { if (cost[j][k] != INF) { if (d[j] + cost[j][k] < d[k]) { d[k] = d[j] + cost[j][k]; if (i == n-1) return true; } } } } } return false; } }} -経路復元(Dijkstra) #highlight(java){{ int[][] cost; int[] d; int[] prev; void dijkstra(int s) { int n = cost.length; d = new int[n]; prev = new int[n]; boolean[] used = new boolean[n]; Arrays.fill(d, INF); Arrays.fill(prev, -1); d[s] = 0; while (true) { int v = -1; for (int u = 0; u < n; u++) { if (!used[u] && (v == -1 || d[u] < d[v])) v = u; } if (v == -1) break; used[v] = true; for (int u = 0; u < n; u++) { d[u] = Math.min(d[u], d[v]+cost[v][u]); prev[u] = v; } } } }}

data structure

2013-10-07T22:37:02+09:00

-union find木 #highlight(java){{ class UnionFind { int[] par; int[] rank; int n; UnionFind(int n) { par = new int[n]; rank = new int[n]; this.n = n; for (int i = 0; i < n; i++) par[i] = i; } //木の根を求める //0<=x

procom @ ウィキ

メニュー