procom @ ウィキ

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); }

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

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; } } }}

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

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;

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

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; } }}

comparator

2013-10-04T13:32:45+09:00

-Integer降順のComparator #highlight(java){{ class DescendComparator implements Comparator{ @Override public int compare(T o0, T o1) { return -((Integer)o0).compareTo((Integer)o1); } } }}