├── .gitignore ├── .travis.yml ├── Cargo.toml ├── LICENSE ├── README.md └── src ├── bfs.rs ├── bound.rs ├── dijsktra.rs ├── ford_fulkerson.rs ├── gcd.rs ├── graph.rs ├── kruskal.rs ├── lib.rs ├── maxmin.rs ├── mod_calc.rs ├── parser.rs ├── prime.rs ├── rmq.rs ├── seq.rs ├── text.rs ├── union_find.rs └── warshall_floyd.rs /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | /target/ 3 | **/*.rs.bk 4 | Cargo.lock 5 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: rust 2 | rust: "1.15.1" -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "procon-lib" 3 | version = "0.1.0" 4 | authors = ["kgtkr "] 5 | 6 | [dependencies] 7 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 tkr 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 競プロ用のRustライブラリ 2 | 3 | [![Build Status](https://travis-ci.org/kgtkr/procon-lib-rs.svg?branch=master)](https://travis-ci.org/kgtkr/procon-lib-rs) 4 | 5 | ## 特徴 6 | 7 | * 依存ライブラリ0 8 | * AtCoder環境(v1.15.1)でのテスト済み 9 | * コピペで使える 10 | 11 | ## 現在の機能 12 | 13 | * bfs 14 | * upper_bound/lower_bound 15 | * dijsktra 16 | * 入力値パースマクロ 17 | * 素数列挙/素数判定/約数列挙/素因数分解 18 | * union_find 19 | * warshall_floyd 20 | * グラフの相互変換 21 | * kruskal 22 | * gcd/lcm/extgcd 23 | * 文字列便利関数 24 | * 数列便利関数 25 | * rmq 26 | * ford_fulkerson -------------------------------------------------------------------------------- /src/bfs.rs: -------------------------------------------------------------------------------- 1 | use graph; 2 | 3 | //graphは全てのコストが等しい 4 | pub fn bfs( 5 | &graph::ListGraph(ref graph): &graph::ListGraph, 6 | start: graph::NodeId, 7 | goal: graph::NodeId, 8 | ) -> Option> { 9 | let mut visited = Vec::with_capacity(graph.len()); 10 | visited.resize(graph.len(), None); 11 | 12 | // Queue に初期値を積む 13 | let mut queue = vec![start]; 14 | while queue.len() > 0 { 15 | // queueから取り出す 16 | let n = queue[0]; 17 | queue.remove(0); 18 | // 行けるノード 19 | for &(_, next_node, _) in &graph[n] { 20 | if visited[next_node].is_none() { 21 | visited[next_node] = Some(n); 22 | // Queueに積む 23 | queue.push(next_node) 24 | } 25 | 26 | if next_node == goal { 27 | visited[start] = None; 28 | let mut path = vec![goal]; 29 | let mut c = visited[goal]; 30 | while let Some(id) = c { 31 | path.push(id); 32 | c = visited[id]; 33 | } 34 | path.reverse(); 35 | return Some(path); 36 | } 37 | } 38 | } 39 | None 40 | } 41 | 42 | #[cfg(test)] 43 | mod tests { 44 | use super::*; 45 | 46 | #[test] 47 | fn test1() { 48 | let mut maze = graph::Maze(vec![ 49 | vec![true, false, true, false, true], 50 | vec![true, false, true, true, true], 51 | vec![true, false, true, false, true], 52 | vec![true, true, true, false, true], 53 | vec![true, false, true, false, true], 54 | ]); 55 | //y*5+x 56 | assert_eq!( 57 | Some(vec![0, 3, 7, 10, 11, 12, 8, 4, 5, 6, 9, 13, 16]), 58 | bfs( 59 | &graph::ListGraph::from(graph::MazeID::from(maze.clone())), 60 | 0, 61 | 16 62 | ) 63 | ); 64 | 65 | assert_eq!( 66 | Some(vec![16, 13, 9, 6, 5, 4, 8, 12, 11, 10, 7, 3, 0]), 67 | bfs( 68 | &graph::ListGraph::from(graph::MazeID::from(maze.clone())), 69 | 16, 70 | 0 71 | ) 72 | ); 73 | 74 | maze.0[3][1] = false; 75 | assert_eq!( 76 | None, 77 | bfs( 78 | &graph::ListGraph::from(graph::MazeID::from(maze.clone())), 79 | 0, 80 | 16 81 | ) 82 | ); 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /src/bound.rs: -------------------------------------------------------------------------------- 1 | //参考 http://www.pandanoir.info/entry/2015/12/26/190000 2 | 3 | //(小さい,同じ,大きい) 4 | pub fn bound_count(vec: &Vec, val: &T) -> (usize, usize, usize) { 5 | let lb = lower_bound(vec, 0, vec.len(), val); 6 | let ub = upper_bound(vec, 0, vec.len(), val); 7 | (lb, ub - lb, vec.len() - ub) 8 | } 9 | 10 | //より小さい 11 | pub fn less_count(vec: &Vec, val: &T) -> usize { 12 | lower_bound(vec, 0, vec.len(), val) 13 | } 14 | 15 | //より大きい 16 | pub fn larger_count(vec: &Vec, val: &T) -> usize { 17 | vec.len() - upper_bound(vec, 0, vec.len(), val) 18 | } 19 | 20 | //同じ 21 | pub fn eq_count(vec: &Vec, val: &T) -> usize { 22 | upper_bound(vec, 0, vec.len(), val) - lower_bound(vec, 0, vec.len(), val) 23 | } 24 | 25 | //vecは昇順ソート済み 26 | //以上 27 | pub fn lower_bound(vec: &Vec, mut first: usize, mut last: usize, val: &T) -> usize { 28 | let mut mid; 29 | while last - first > 1 { 30 | mid = (first + last) / 2; 31 | if &vec[mid] < val { 32 | first = mid; 33 | } else { 34 | last = mid; 35 | } 36 | } 37 | if &vec[first] < val { 38 | last 39 | } else { 40 | first 41 | } 42 | } 43 | 44 | //より大きい 45 | pub fn upper_bound(vec: &Vec, mut first: usize, mut last: usize, val: &T) -> usize { 46 | let mut mid; 47 | while last - first > 1 { 48 | mid = (first + last) / 2; 49 | if &vec[mid] <= val { 50 | first = mid; 51 | } else { 52 | last = mid; 53 | } 54 | } 55 | if &vec[first] <= val { 56 | last 57 | } else { 58 | first 59 | } 60 | } 61 | 62 | #[cfg(test)] 63 | mod tests { 64 | use super::*; 65 | 66 | #[test] 67 | fn test1() { 68 | let vec = vec![-1, 0, 0, 0, 1, 2, 2, 5, 5, 9]; 69 | let len = vec.len(); 70 | 71 | assert_eq!(0, lower_bound(&vec, 0, len, &-2)); 72 | assert_eq!(0, upper_bound(&vec, 0, len, &-2)); 73 | assert_eq!(0, less_count(&vec, &-2)); 74 | assert_eq!(0, eq_count(&vec, &-2)); 75 | assert_eq!(10, larger_count(&vec, &-2)); 76 | assert_eq!((0, 0, 10), bound_count(&vec, &-2)); 77 | 78 | assert_eq!(0, lower_bound(&vec, 0, len, &-1)); 79 | assert_eq!(1, upper_bound(&vec, 0, len, &-1)); 80 | assert_eq!(0, less_count(&vec, &-1)); 81 | assert_eq!(1, eq_count(&vec, &-1)); 82 | assert_eq!(9, larger_count(&vec, &-1)); 83 | assert_eq!((0, 1, 9), bound_count(&vec, &-1)); 84 | 85 | assert_eq!(1, lower_bound(&vec, 0, len, &0)); 86 | assert_eq!(4, upper_bound(&vec, 0, len, &0)); 87 | assert_eq!(1, less_count(&vec, &0)); 88 | assert_eq!(3, eq_count(&vec, &0)); 89 | assert_eq!(6, larger_count(&vec, &0)); 90 | assert_eq!((1, 3, 6), bound_count(&vec, &0)); 91 | 92 | assert_eq!(9, lower_bound(&vec, 0, len, &9)); 93 | assert_eq!(10, upper_bound(&vec, 0, len, &9)); 94 | assert_eq!(9, less_count(&vec, &9)); 95 | assert_eq!(1, eq_count(&vec, &9)); 96 | assert_eq!(0, larger_count(&vec, &9)); 97 | assert_eq!((9, 1, 0), bound_count(&vec, &9)); 98 | 99 | assert_eq!(10, lower_bound(&vec, 0, len, &10)); 100 | assert_eq!(10, upper_bound(&vec, 0, len, &10)); 101 | assert_eq!(10, less_count(&vec, &10)); 102 | assert_eq!(0, eq_count(&vec, &10)); 103 | assert_eq!(0, larger_count(&vec, &10)); 104 | assert_eq!((10, 0, 0), bound_count(&vec, &10)); 105 | } 106 | } 107 | -------------------------------------------------------------------------------- /src/dijsktra.rs: -------------------------------------------------------------------------------- 1 | use std::cmp::Ordering; 2 | use std::collections::BinaryHeap; 3 | use graph; 4 | 5 | #[derive(PartialEq, Debug, Clone)] 6 | pub struct Node { 7 | pub edges: Vec, 8 | pub done: bool, 9 | pub cost: Option, 10 | pub before: Option, 11 | } 12 | 13 | impl Node { 14 | pub fn new(node: graph::Node) -> Node { 15 | Node { 16 | edges: node, 17 | done: false, 18 | cost: None, 19 | before: None, 20 | } 21 | } 22 | 23 | pub fn set_start(&mut self) { 24 | self.cost = Some(0); 25 | } 26 | } 27 | 28 | #[derive(PartialEq, Debug, Clone)] 29 | pub struct Dijsktra { 30 | pub nodes: Vec, 31 | } 32 | 33 | impl Dijsktra { 34 | pub fn new(graph::ListGraph(nodes): graph::ListGraph) -> Dijsktra { 35 | Dijsktra { 36 | nodes: nodes 37 | .into_iter() 38 | .map(|node| Node::new(node)) 39 | .collect::>(), 40 | } 41 | } 42 | 43 | pub fn cost(&self, node: graph::NodeId) -> Option { 44 | self.nodes[node].cost 45 | } 46 | 47 | pub fn dijsktra(&mut self, start: graph::NodeId) { 48 | let mut heap = BinaryHeap::new(); 49 | heap.push(State { 50 | cost: 0, 51 | node: start, 52 | }); 53 | self.nodes[start].set_start(); 54 | 55 | while let Some(done_node) = heap.pop().map(|State { node, cost: _ }| node) { 56 | self.nodes[done_node].done = true; 57 | for (_, edge_to, edge_cost) in self.nodes[done_node].edges.clone() { 58 | let cost = self.nodes[done_node].cost.unwrap() + edge_cost; 59 | if self.nodes[edge_to] 60 | .cost 61 | .map(|to_cost| cost < to_cost) 62 | .unwrap_or(true) 63 | { 64 | self.nodes[edge_to].cost = Some(cost); 65 | self.nodes[edge_to].before = Some(done_node); 66 | heap.push(State { 67 | node: edge_to, 68 | cost: cost, 69 | }); 70 | } 71 | } 72 | } 73 | } 74 | 75 | pub fn path(&self, goal: usize) -> Vec { 76 | let mut path = Vec::new(); 77 | path.push(goal); 78 | let mut current = goal; 79 | while let Some(node) = self.nodes[current].before { 80 | path.push(node); 81 | current = node; 82 | } 83 | path.reverse(); 84 | path 85 | } 86 | } 87 | 88 | #[derive(Copy, Clone, Eq, PartialEq)] 89 | struct State { 90 | cost: graph::Cost, 91 | node: graph::NodeId, 92 | } 93 | 94 | impl Ord for State { 95 | fn cmp(&self, other: &State) -> Ordering { 96 | other.cost.cmp(&self.cost) 97 | } 98 | } 99 | 100 | impl PartialOrd for State { 101 | fn partial_cmp(&self, other: &State) -> Option { 102 | Some(self.cmp(other)) 103 | } 104 | } 105 | 106 | #[cfg(test)] 107 | mod tests { 108 | use super::*; 109 | 110 | #[test] 111 | fn test1() { 112 | let mut graph = vec![ 113 | vec![(2, 10), (1, 1)], 114 | vec![(3, 2)], 115 | vec![(1, 1), (3, 3), (4, 1)], 116 | vec![(0, 7), (4, 2)], 117 | vec![], 118 | ]; 119 | 120 | let mut dij = Dijsktra::new(graph.into()); 121 | 122 | dij.dijsktra(0); 123 | 124 | assert_eq!(Some(0), dij.cost(0)); 125 | assert_eq!(Some(1), dij.cost(1)); 126 | assert_eq!(Some(10), dij.cost(2)); 127 | assert_eq!(Some(3), dij.cost(3)); 128 | assert_eq!(Some(5), dij.cost(4)); 129 | 130 | assert_eq!(vec![0], dij.path(0)); 131 | assert_eq!(vec![0, 1], dij.path(1)); 132 | assert_eq!(vec![0, 2], dij.path(2)); 133 | assert_eq!(vec![0, 1, 3], dij.path(3)); 134 | assert_eq!(vec![0, 1, 3, 4], dij.path(4)); 135 | } 136 | } 137 | -------------------------------------------------------------------------------- /src/ford_fulkerson.rs: -------------------------------------------------------------------------------- 1 | use std::cmp::min; 2 | 3 | #[derive(PartialEq, Debug, Clone)] 4 | struct Edge { 5 | pub to: usize, 6 | pub cap: i64, 7 | pub rev: usize, 8 | } 9 | 10 | struct FordFulkerson(Vec<(Vec, bool)>); 11 | 12 | impl FordFulkerson { 13 | pub fn new(n: usize) -> FordFulkerson { 14 | let v = (Vec::new(), false); 15 | let mut nodes = Vec::with_capacity(n); 16 | nodes.resize(n, v); 17 | FordFulkerson(nodes) 18 | } 19 | 20 | pub fn add_edge(&mut self, from: usize, to: usize, cap: i64) { 21 | let f_size = self.0[from].0.len(); 22 | let t_size = self.0[to].0.len(); 23 | self.0[from].0.push(Edge { 24 | to: to, 25 | cap: cap, 26 | rev: t_size, 27 | }); 28 | self.0[to].0.push(Edge { 29 | to: from, 30 | cap: 0, 31 | rev: f_size, 32 | }); 33 | } 34 | 35 | pub fn dfs(&mut self, v: usize, t: usize, f: i64) -> i64 { 36 | if v == t { 37 | return f; 38 | } 39 | self.0[v].1 = true; 40 | for i in 0..self.0[v].0.len() { 41 | if !self.0[self.0[v].0[i].to].1 && self.0[v].0[i].cap > 0 { 42 | let d = { 43 | let x = self.0[v].0[i].to; 44 | let y = min(f, self.0[v].0[i].cap); 45 | self.dfs(x, t, y) 46 | }; 47 | if d > 0 { 48 | self.0[v].0[i].cap -= d; 49 | { 50 | let x = self.0[v].0[i].to; 51 | let y = self.0[v].0[i].rev; 52 | self.0[x].0[y].cap += d; 53 | } 54 | return d; 55 | } 56 | } 57 | } 58 | 0 59 | } 60 | 61 | pub fn max_flow(&mut self, s: usize, t: usize) -> i64 { 62 | let mut flow = 0; 63 | loop { 64 | for i in 0..self.0.len() { 65 | self.0[i].1 = false; 66 | } 67 | let f = self.dfs(s, t, ::max_value()); 68 | if f == 0 { 69 | return flow; 70 | } 71 | flow += f; 72 | } 73 | } 74 | } 75 | 76 | pub fn max_match(a: usize, b: usize, path: Vec<(usize, usize)>) -> i64 { 77 | //スタート、グループa、グループb、ゴール 78 | let mut flow = FordFulkerson::new(a + b + 2); 79 | 80 | //スタートとaを結ぶ 81 | for i in 1..a + 1 { 82 | flow.add_edge(0, i, 1); 83 | } 84 | 85 | //aとbを結ぶ 86 | for (x, y) in path { 87 | flow.add_edge(x + 1, y + a + 1, 1); 88 | } 89 | 90 | //bとゴールを結ぶ 91 | for i in a + 1..a + b + 1 { 92 | flow.add_edge(i, a + b + 1, 1); 93 | } 94 | 95 | flow.max_flow(0, a + b + 1) 96 | } 97 | 98 | mod tests { 99 | use super::*; 100 | 101 | #[test] 102 | fn test1() { 103 | let mut flow = FordFulkerson::new(5); 104 | flow.add_edge(0, 1, 10); 105 | flow.add_edge(0, 2, 2); 106 | flow.add_edge(1, 2, 6); 107 | flow.add_edge(1, 3, 6); 108 | flow.add_edge(2, 4, 5); 109 | flow.add_edge(3, 2, 3); 110 | flow.add_edge(3, 4, 8); 111 | assert_eq!(11, flow.max_flow(0, 4)); 112 | } 113 | 114 | #[test] 115 | fn test2() { 116 | assert_eq!( 117 | 3, 118 | max_match(3, 3, vec![(0, 0), (0, 1), (1, 0), (1, 2), (2, 1)]) 119 | ); 120 | assert_eq!( 121 | 2, 122 | max_match(3, 4, vec![(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (2, 0)]) 123 | ); 124 | } 125 | } 126 | -------------------------------------------------------------------------------- /src/gcd.rs: -------------------------------------------------------------------------------- 1 | //最大公約数 2 | pub fn gcd(a: i64, b: i64) -> i64 { 3 | if b == 0 { 4 | a 5 | } else { 6 | gcd(b, a % b) 7 | } 8 | } 9 | 10 | //最小公倍数 11 | pub fn lcm(a: i64, b: i64) -> i64 { 12 | a * b / gcd(a, b) 13 | } 14 | 15 | //拡張ユークリッド(参照版) 16 | pub fn extgcd_ref(a: i64, b: i64, x: &mut i64, y: &mut i64) -> i64 { 17 | let mut d = a; 18 | if b != 0 { 19 | d = extgcd_ref(b, a % b, y, x); 20 | *y -= (a / b) * *x; 21 | } else { 22 | *x = 1; 23 | *y = 0; 24 | } 25 | d 26 | } 27 | 28 | //拡張ユークリッド 29 | //(gcd(a,b),x,y) 30 | pub fn extgcd(a: i64, b: i64) -> (i64, i64, i64) { 31 | let mut x = 0; 32 | let mut y = 0; 33 | let gcd = extgcd_ref(a, b, &mut x, &mut y); 34 | (gcd, x, y) 35 | } 36 | 37 | #[cfg(test)] 38 | mod tests { 39 | use super::*; 40 | 41 | #[test] 42 | fn test_gcd() { 43 | assert_eq!(5, gcd(5, 0)); 44 | assert_eq!(11, gcd(0, 11)); 45 | assert_eq!(7, gcd(182, 1029)); 46 | } 47 | 48 | #[test] 49 | fn test_lcm() { 50 | assert_eq!(1873326, lcm(182, 10293)); 51 | assert_eq!(66356, lcm(212, 313)); 52 | } 53 | 54 | #[test] 55 | fn test_extgcd() { 56 | assert_eq!((1, -7, 12), extgcd(29, 17)); 57 | assert_eq!((12, -7, 18), extgcd(924, 360)); 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /src/graph.rs: -------------------------------------------------------------------------------- 1 | pub type NodeId = usize; 2 | 3 | pub type Cost = i64; 4 | 5 | pub type Node = Vec; 6 | 7 | pub type Edge = (NodeId, NodeId, Cost); 8 | 9 | #[derive(PartialEq, Debug, Clone)] 10 | pub struct MatrixGraph(pub Vec>>); 11 | 12 | impl From>>> for MatrixGraph { 13 | fn from(data: Vec>>) -> MatrixGraph { 14 | MatrixGraph(data) 15 | } 16 | } 17 | 18 | impl From for MatrixGraph { 19 | fn from(graph: ListGraph) -> MatrixGraph { 20 | FlatGraph::from(graph).into() 21 | } 22 | } 23 | 24 | impl From for MatrixGraph { 25 | fn from(FlatGraph(len, data): FlatGraph) -> MatrixGraph { 26 | let mut vec = Vec::with_capacity(len); 27 | vec.resize(len, { 28 | let mut v = Vec::with_capacity(len); 29 | v.resize(len, None); 30 | v 31 | }); 32 | 33 | for (from, to, cost) in data { 34 | vec[from][to] = Some(cost); 35 | } 36 | 37 | vec.into() 38 | } 39 | } 40 | 41 | #[derive(PartialEq, Debug, Clone)] 42 | pub struct ListGraph(pub Vec>); 43 | 44 | impl From>> for ListGraph { 45 | fn from(data: Vec>) -> ListGraph { 46 | ListGraph( 47 | data 48 | .into_iter() 49 | .enumerate() 50 | .map(|(from, edges)| { 51 | edges 52 | .into_iter() 53 | .map(|(to, cost)| (from, to, cost)) 54 | .collect() 55 | }) 56 | .collect(), 57 | ) 58 | } 59 | } 60 | 61 | impl From>> for ListGraph { 62 | fn from(data: Vec>) -> ListGraph { 63 | ListGraph(data) 64 | } 65 | } 66 | 67 | impl From for ListGraph { 68 | fn from(FlatGraph(len, data): FlatGraph) -> ListGraph { 69 | let mut vec = Vec::with_capacity(len); 70 | vec.resize(len, Vec::new()); 71 | 72 | for (from, to, cost) in data { 73 | vec[from].push((from, to, cost)); 74 | } 75 | 76 | ListGraph(vec) 77 | } 78 | } 79 | 80 | impl From for ListGraph { 81 | fn from(graph: MatrixGraph) -> ListGraph { 82 | FlatGraph::from(graph).into() 83 | } 84 | } 85 | 86 | #[derive(PartialEq, Debug, Clone)] 87 | pub struct FlatGraph(pub usize, pub Vec); 88 | 89 | impl From for FlatGraph { 90 | fn from(ListGraph(data): ListGraph) -> FlatGraph { 91 | let len = data.len(); 92 | (len, data.into_iter().flat_map(|x| x).collect::>()).into() 93 | } 94 | } 95 | 96 | impl From<(usize, Vec<(NodeId, NodeId, Cost)>)> for FlatGraph { 97 | fn from((len, data): (usize, Vec<(NodeId, NodeId, Cost)>)) -> FlatGraph { 98 | FlatGraph(len, data) 99 | } 100 | } 101 | 102 | impl From for FlatGraph { 103 | fn from(MatrixGraph(data): MatrixGraph) -> FlatGraph { 104 | let mut vec = Vec::new(); 105 | let len = data.len(); 106 | 107 | for (from, v) in data.into_iter().enumerate() { 108 | for (to, cost) in v.into_iter().enumerate() { 109 | if let Some(cost) = cost { 110 | vec.push((from, to, cost)); 111 | } 112 | } 113 | } 114 | 115 | (len, vec).into() 116 | } 117 | } 118 | 119 | #[derive(PartialEq, Debug, Clone)] 120 | pub struct MazeID(pub Vec>>); 121 | impl From for ListGraph { 122 | fn from(MazeID(maze): MazeID) -> ListGraph { 123 | if maze.len() == 0 { 124 | return ListGraph(Vec::new()); 125 | } 126 | 127 | let h = maze.len(); 128 | let w = maze[0].len(); 129 | 130 | let mut graph = Vec::new(); 131 | for y in 0..h { 132 | for x in 0..w { 133 | if let Some(_) = maze[y][x] { 134 | let mut edges = Vec::new(); 135 | if y != 0 { 136 | if let Some(to) = maze[y - 1][x] { 137 | edges.push((to, 1)); 138 | } 139 | } 140 | if x != 0 { 141 | if let Some(to) = maze[y][x - 1] { 142 | edges.push((to, 1)); 143 | } 144 | } 145 | if x != w - 1 { 146 | if let Some(to) = maze[y][x + 1] { 147 | edges.push((to, 1)); 148 | } 149 | } 150 | if y != h - 1 { 151 | if let Some(to) = maze[y + 1][x] { 152 | edges.push((to, 1)); 153 | } 154 | } 155 | graph.push(edges); 156 | } 157 | } 158 | } 159 | ListGraph::from(graph) 160 | } 161 | } 162 | 163 | //迷路 164 | #[derive(PartialEq, Debug, Clone)] 165 | pub struct Maze(pub Vec>); 166 | 167 | impl From for MazeID { 168 | fn from(Maze(maze): Maze) -> MazeID { 169 | let mut id = 0; 170 | MazeID( 171 | maze 172 | .into_iter() 173 | .map(|vec| { 174 | vec 175 | .into_iter() 176 | .map(|x| { 177 | if x { 178 | let res: Option = Some(id); 179 | id += 1; 180 | res 181 | } else { 182 | None 183 | } 184 | }) 185 | .collect::>() 186 | }) 187 | .collect::>(), 188 | ) 189 | } 190 | } 191 | 192 | #[cfg(test)] 193 | mod tests { 194 | use super::*; 195 | 196 | #[test] 197 | fn list_to_matrix() { 198 | assert_eq!( 199 | MatrixGraph(vec![ 200 | vec![None, Some(1), None, Some(3)], 201 | vec![Some(10), Some(1), None, None], 202 | vec![None, None, Some(5), None], 203 | vec![None, None, None, None], 204 | ]), 205 | MatrixGraph::from(ListGraph(vec![ 206 | vec![(0, 1, 1), (0, 3, 3)], 207 | vec![(1, 0, 10), (1, 1, 1)], 208 | vec![(2, 2, 5)], 209 | vec![], 210 | ])) 211 | ); 212 | } 213 | 214 | #[test] 215 | fn flat_to_matrix() { 216 | assert_eq!( 217 | MatrixGraph(vec![ 218 | vec![None, Some(1), None, Some(3)], 219 | vec![Some(10), Some(1), None, None], 220 | vec![None, None, Some(5), None], 221 | vec![None, None, None, None], 222 | ]), 223 | MatrixGraph::from(FlatGraph( 224 | 4, 225 | vec![(0, 1, 1), (0, 3, 3), (1, 0, 10), (1, 1, 1), (2, 2, 5)] 226 | )) 227 | ); 228 | } 229 | 230 | #[test] 231 | fn data_to_list() { 232 | assert_eq!( 233 | ListGraph(vec![ 234 | vec![(0, 1, 1), (0, 3, 3)], 235 | vec![(1, 0, 10), (1, 1, 1)], 236 | vec![(2, 2, 5)], 237 | vec![], 238 | ]), 239 | ListGraph::from(vec![ 240 | vec![(1, 1), (3, 3)], 241 | vec![(0, 10), (1, 1)], 242 | vec![(2, 5)], 243 | vec![], 244 | ]) 245 | ); 246 | } 247 | 248 | #[test] 249 | fn flat_to_list() { 250 | assert_eq!( 251 | ListGraph(vec![ 252 | vec![(0, 1, 1), (0, 3, 3)], 253 | vec![(1, 0, 10), (1, 1, 1)], 254 | vec![(2, 2, 5)], 255 | vec![], 256 | ]), 257 | ListGraph::from(FlatGraph( 258 | 4, 259 | vec![(0, 1, 1), (0, 3, 3), (1, 0, 10), (1, 1, 1), (2, 2, 5)] 260 | )) 261 | ); 262 | } 263 | 264 | #[test] 265 | fn list_to_flat() { 266 | assert_eq!( 267 | FlatGraph( 268 | 4, 269 | vec![(0, 1, 1), (0, 3, 3), (1, 0, 10), (1, 1, 1), (2, 2, 5)] 270 | ), 271 | FlatGraph::from(ListGraph(vec![ 272 | vec![(0, 1, 1), (0, 3, 3)], 273 | vec![(1, 0, 10), (1, 1, 1)], 274 | vec![(2, 2, 5)], 275 | vec![], 276 | ])) 277 | ); 278 | } 279 | 280 | #[test] 281 | fn mtrix_to_flat() { 282 | assert_eq!( 283 | FlatGraph( 284 | 4, 285 | vec![(0, 1, 1), (0, 3, 3), (1, 0, 10), (1, 1, 1), (2, 2, 5)] 286 | ), 287 | FlatGraph::from(MatrixGraph(vec![ 288 | vec![None, Some(1), None, Some(3)], 289 | vec![Some(10), Some(1), None, None], 290 | vec![None, None, Some(5), None], 291 | vec![None, None, None, None], 292 | ])) 293 | ); 294 | } 295 | 296 | #[test] 297 | fn maze_id_to_list() { 298 | assert_eq!( 299 | ListGraph(vec![ 300 | vec![(0, 2, 1)], 301 | vec![(1, 4, 1)], 302 | vec![(2, 0, 1), (2, 3, 1), (2, 6, 1)], 303 | vec![(3, 2, 1), (3, 4, 1)], 304 | vec![(4, 1, 1), (4, 3, 1), (4, 5, 1), (4, 7, 1)], 305 | vec![(5, 4, 1)], 306 | vec![(6, 2, 1)], 307 | vec![(7, 4, 1)], 308 | ]), 309 | ListGraph::from(MazeID::from(Maze(vec![ 310 | vec![true, false, true, false], 311 | vec![true, true, true, true], 312 | vec![true, false, true, false], 313 | ]))) 314 | ); 315 | } 316 | 317 | #[test] 318 | fn maze_to_maze_id() { 319 | assert_eq!( 320 | MazeID(vec![ 321 | vec![Some(0), None, Some(1), None], 322 | vec![Some(2), Some(3), Some(4), Some(5)], 323 | vec![Some(6), None, Some(7), None], 324 | ]), 325 | MazeID::from(Maze(vec![ 326 | vec![true, false, true, false], 327 | vec![true, true, true, true], 328 | vec![true, false, true, false], 329 | ])) 330 | ); 331 | } 332 | } 333 | -------------------------------------------------------------------------------- /src/kruskal.rs: -------------------------------------------------------------------------------- 1 | use graph::FlatGraph; 2 | use union_find::UnionFind; 3 | 4 | pub fn kruskal(FlatGraph(node_len, mut edges): FlatGraph) -> FlatGraph { 5 | edges.sort_by(|&(_, _, ref a), &(_, _, ref b)| a.cmp(b)); 6 | let mut uf = UnionFind::new(node_len); 7 | let mut res = FlatGraph(node_len, Vec::new()); 8 | for (from, to, cost) in edges { 9 | if !uf.same(from, to) { 10 | uf.unite(from, to); 11 | res.1.push((from, to, cost)); 12 | } 13 | } 14 | res 15 | } 16 | 17 | #[cfg(test)] 18 | mod tests { 19 | use super::*; 20 | 21 | #[test] 22 | fn test1() { 23 | assert_eq!( 24 | FlatGraph( 25 | 7, 26 | vec![ 27 | (0, 2, 1), 28 | (3, 5, 1), 29 | (1, 2, 2), 30 | (2, 3, 3), 31 | (3, 6, 5), 32 | (4, 5, 5), 33 | ] 34 | ), 35 | kruskal(FlatGraph( 36 | 7, 37 | vec![ 38 | (0, 2, 1), 39 | (1, 2, 2), 40 | (1, 4, 10), 41 | (2, 3, 3), 42 | (2, 5, 7), 43 | (3, 5, 1), 44 | (3, 6, 5), 45 | (4, 5, 5), 46 | (5, 6, 8), 47 | ] 48 | )) 49 | ); 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | pub mod bfs; 2 | pub mod bound; 3 | pub mod dijsktra; 4 | pub mod ford_fulkerson; 5 | pub mod gcd; 6 | pub mod graph; 7 | pub mod kruskal; 8 | pub mod maxmin; 9 | pub mod mod_calc; 10 | pub mod parser; 11 | pub mod prime; 12 | pub mod rmq; 13 | pub mod seq; 14 | pub mod text; 15 | pub mod union_find; 16 | pub mod warshall_floyd; 17 | -------------------------------------------------------------------------------- /src/maxmin.rs: -------------------------------------------------------------------------------- 1 | use std::cmp::{max, min}; 2 | 3 | macro_rules! max { 4 | ($x:expr) => { 5 | $x 6 | }; 7 | ($x:expr, $($xs:tt)+) => { 8 | max($x,max!($($xs)+)) 9 | }; 10 | } 11 | 12 | macro_rules! min { 13 | ($x:expr) => { 14 | $x 15 | }; 16 | ($x:expr, $($xs:tt)+) => { 17 | min($x,min!($($xs)+)) 18 | }; 19 | } 20 | 21 | #[cfg(test)] 22 | mod tests { 23 | use super::*; 24 | #[test] 25 | fn max_test() { 26 | assert_eq!(10, max!(10)); 27 | assert_eq!(10, max!(1, 2, 10)); 28 | assert_eq!(10, max!(2, 10, 1)); 29 | assert_eq!(10, max!(10, 1, 2)); 30 | assert_eq!(10, max!(2, 10, 1, 2, 5, 8, 7)); 31 | } 32 | 33 | #[test] 34 | fn min_test() { 35 | assert_eq!(1, min!(1)); 36 | assert_eq!(1, min!(1, 2, 10)); 37 | assert_eq!(1, min!(2, 10, 1)); 38 | assert_eq!(1, min!(10, 1, 2)); 39 | assert_eq!(1, min!(2, 10, 1, 2, 5, 8, 7)); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/mod_calc.rs: -------------------------------------------------------------------------------- 1 | const MOD: i64 = 1000000007; 2 | 3 | pub fn power(x: i64, y: i64) -> i64 { 4 | if y == 0 { 5 | 1 6 | } else if y == 1 { 7 | x % MOD 8 | } else if y % 2 == 0 { 9 | power(x, y / 2).pow(2) % MOD 10 | } else { 11 | power(x, y / 2).pow(2) * x % MOD 12 | } 13 | } 14 | 15 | pub fn div(a: i64, b: i64) -> i64 { 16 | mul(a, power(b, MOD - 2)) 17 | } 18 | 19 | pub fn add(a: i64, b: i64) -> i64 { 20 | (a + b) % MOD 21 | } 22 | 23 | pub fn mul(a: i64, b: i64) -> i64 { 24 | ((a % MOD) * (b % MOD)) % MOD 25 | } 26 | -------------------------------------------------------------------------------- /src/parser.rs: -------------------------------------------------------------------------------- 1 | #[macro_export] 2 | macro_rules! input { 3 | ($s:expr=>$($t:tt)*) => { 4 | let mut lines=$s.split("\n"); 5 | $( 6 | line_parse!(lines,$t); 7 | )* 8 | }; 9 | } 10 | 11 | macro_rules! line_parse { 12 | ($lines:expr,($($name:ident:$t:tt)*)) => { 13 | let mut line=$lines.next().unwrap().split_whitespace(); 14 | $(value_def!(line,$name,$t);)* 15 | }; 16 | 17 | //複数行 18 | ($lines:expr,{$n:expr;$name:ident:$t:tt}) => { 19 | values_def!($lines,$n,$name,$t); 20 | }; 21 | } 22 | 23 | macro_rules! value_def { 24 | ($line:expr, $name:ident, $t:tt) => { 25 | let $name = value!($line, $t); 26 | }; 27 | } 28 | 29 | macro_rules! values_def { 30 | ($lines:expr, $n:expr, $name:ident, $t:tt) => { 31 | let $name = { 32 | let mut vec = Vec::new(); 33 | for i in 0..$n { 34 | let mut next = $lines.next().unwrap().split_whitespace(); 35 | vec.push(value!(next, $t)); 36 | } 37 | vec 38 | }; 39 | }; 40 | } 41 | 42 | macro_rules! value { 43 | //配列 44 | ($line:expr,[$t:tt]) => { 45 | $line.map(|x|{ 46 | let mut iter=::std::iter::once(x); 47 | value!(iter,$t) 48 | }).collect::>() 49 | }; 50 | //タプル 51 | ($line:expr,($($t:tt),*)) => { 52 | ($(value!($line,$t),)*) 53 | }; 54 | //文字列 55 | ($line:expr,#) => { 56 | $line.next().unwrap() 57 | }; 58 | //インデックス(-1) 59 | ($line:expr,@) => { 60 | $line.next().unwrap().parse::().unwrap()-1 61 | }; 62 | //単一値 63 | ($line:expr,$t:ty) => { 64 | $line.next().unwrap().parse::<$t>().unwrap() 65 | }; 66 | } 67 | 68 | #[test] 69 | fn test1() { 70 | { 71 | input!( 72 | "3 73 | 5 2 74 | 2 3 4 5 6 75 | 10 76 | 20 77 | 30 78 | 1 2 79 | 8 1 80 | 2 3 81 | 4 1 82 | 1283 23 43 32 83 | 1 2 3 84 | 2 3 4 85 | 3 4 5 86 | "=> 87 | (n:usize) //単一値 88 | (k:i64 p:i64) //複数値 89 | (list1:[i64]) //配列 90 | {n;list2:i64} //N回繰り返し 91 | (tup:(i64,i64)) //タプル 92 | {n;list3:(i64,i64)} 93 | (i:i64 list4:[i64]) 94 | {n;map:[i64]} 95 | ); 96 | assert_eq!(n, 3); 97 | assert_eq!(k, 5); 98 | assert_eq!(p, 2); 99 | assert_eq!(list1, vec![2, 3, 4, 5, 6]); 100 | assert_eq!(list2, vec![10, 20, 30]); 101 | assert_eq!(tup, (1, 2)); 102 | assert_eq!(list3, vec![(8, 1), (2, 3), (4, 1)]); 103 | assert_eq!(i, 1283); 104 | assert_eq!(list4, vec![23, 43, 32]); 105 | assert_eq!(map, vec![vec![1, 2, 3], vec![2, 3, 4], vec![3, 4, 5]]); 106 | } 107 | 108 | { 109 | input!( 110 | "3 111 | 5 2 112 | 2 3 4 5 6 113 | 10 114 | 20 115 | 30 116 | 1 2 117 | 8 1 118 | 2 3 119 | 4 1 120 | 1283 23 43 32 121 | 1 2 122 | "=> 123 | (n:usize) //単一値 124 | (k:# p:#) //複数値 125 | (list1:[#]) //配列 126 | {n;list2:#} //N回繰り返し 127 | (tup:(#,#)) //タプル 128 | {n;list3:(#,#)} 129 | (i:# list4:[#]) 130 | (index:[@]) 131 | ); 132 | assert_eq!(n, 3); 133 | assert_eq!(k, "5"); 134 | assert_eq!(p, "2"); 135 | assert_eq!(list1, vec!["2", "3", "4", "5", "6"]); 136 | assert_eq!(list2, vec!["10", "20", "30"]); 137 | assert_eq!(tup, ("1", "2")); 138 | assert_eq!(list3, vec![("8", "1"), ("2", "3"), ("4", "1")]); 139 | assert_eq!(i, "1283"); 140 | assert_eq!(list4, vec!["23", "43", "32"]); 141 | assert_eq!(index, vec![0, 1]); 142 | } 143 | } 144 | -------------------------------------------------------------------------------- /src/prime.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashMap; 2 | 3 | //nの約数列挙 4 | pub fn divisor(n: usize) -> Vec { 5 | let mut res = Vec::new(); 6 | for i in (1..).take_while(|x| x * x <= n) { 7 | if n % i == 0 { 8 | res.push(i); 9 | if i != n / i { 10 | res.push(n / i); 11 | } 12 | } 13 | } 14 | res 15 | } 16 | 17 | //max以下の素数列挙 18 | pub fn prime_sieve(n: usize) -> (Vec, Vec) { 19 | let mut prime = Vec::new(); 20 | let mut is_prime = Vec::with_capacity(n + 1); 21 | is_prime.resize(n + 1, true); 22 | is_prime[0] = false; 23 | is_prime[1] = false; 24 | for i in 2..n + 1 { 25 | if is_prime[i] { 26 | prime.push(i); 27 | { 28 | let mut j = 2 * i; 29 | while j <= n { 30 | is_prime[j] = false; 31 | j += i; 32 | } 33 | } 34 | } 35 | } 36 | 37 | (prime, is_prime) 38 | } 39 | 40 | //素数判定 41 | pub fn is_prime(n: i64) -> bool { 42 | n != 1 && (2..).take_while(|i| i * i <= n).all(|i| n % i != 0) 43 | } 44 | 45 | //素因数分解 46 | pub fn prime_factor(mut n: i64) -> HashMap { 47 | let mut res: HashMap = HashMap::new(); 48 | let mut i = 2; 49 | while i * i <= n { 50 | while n % i == 0 { 51 | let v = match res.get(&i) { 52 | Some(v) => *v + 1, 53 | None => 1, 54 | }; 55 | res.insert(i, v); 56 | n /= i; 57 | } 58 | i += 1; 59 | } 60 | if n != 1 { 61 | res.insert(n, 1); 62 | } 63 | res 64 | } 65 | 66 | #[cfg(test)] 67 | mod tests { 68 | use super::*; 69 | 70 | #[test] 71 | fn test_prime() { 72 | assert_eq!( 73 | ( 74 | vec![2, 3, 5, 7], 75 | vec![ 76 | false, false, true, true, false, true, false, true, false, false, false 77 | ] 78 | ), 79 | prime_sieve(10) 80 | ); 81 | assert_eq!( 82 | ( 83 | vec![2, 3, 5, 7, 11], 84 | vec![ 85 | false, false, true, true, false, true, false, true, false, false, false, true 86 | ] 87 | ), 88 | prime_sieve(11) 89 | ); 90 | } 91 | 92 | #[test] 93 | fn test_divisor() { 94 | assert_eq!(vec![1, 10, 2, 5], divisor(10)); 95 | assert_eq!( 96 | vec![1, 150, 2, 75, 3, 50, 5, 30, 6, 25, 10, 15], 97 | divisor(150) 98 | ); 99 | assert_eq!(vec![1, 9, 3], divisor(9)); 100 | } 101 | 102 | #[test] 103 | fn test_is_prime() { 104 | assert_eq!(false, is_prime(1)); 105 | assert_eq!(true, is_prime(2)); 106 | assert_eq!(true, is_prime(3)); 107 | assert_eq!(false, is_prime(4)); 108 | assert_eq!(false, is_prime(9)); 109 | assert_eq!(true, is_prime(11)); 110 | } 111 | 112 | #[test] 113 | fn test_prime_factor() { 114 | assert_eq!(HashMap::new(), prime_factor(1)); 115 | 116 | assert_eq!( 117 | { 118 | let mut map = HashMap::new(); 119 | map.insert(2, 1); 120 | map 121 | }, 122 | prime_factor(2) 123 | ); 124 | 125 | assert_eq!( 126 | { 127 | let mut map = HashMap::new(); 128 | map.insert(3, 1); 129 | map 130 | }, 131 | prime_factor(3) 132 | ); 133 | 134 | assert_eq!( 135 | { 136 | let mut map = HashMap::new(); 137 | map.insert(2, 1); 138 | map.insert(5, 1); 139 | map 140 | }, 141 | prime_factor(10) 142 | ); 143 | 144 | assert_eq!( 145 | { 146 | let mut map = HashMap::new(); 147 | map.insert(2, 1); 148 | map.insert(5, 1); 149 | map 150 | }, 151 | prime_factor(10) 152 | ); 153 | 154 | assert_eq!( 155 | { 156 | let mut map = HashMap::new(); 157 | map.insert(2, 3); 158 | map.insert(3, 2); 159 | map.insert(5, 1); 160 | map 161 | }, 162 | prime_factor(360) 163 | ); 164 | } 165 | } 166 | -------------------------------------------------------------------------------- /src/rmq.rs: -------------------------------------------------------------------------------- 1 | //蟻本 2 | use std::cmp::min; 3 | 4 | #[derive(PartialEq, Debug, Clone)] 5 | struct RMQ(pub Vec); 6 | 7 | impl RMQ { 8 | pub fn new(n: usize) -> RMQ { 9 | let mut n2 = 1; 10 | while n2 < n { 11 | n2 *= 2; 12 | } 13 | let size = n2 * 2 - 1; 14 | let mut v = Vec::with_capacity(size); 15 | v.resize(size, ::max_value()); 16 | RMQ(v) 17 | } 18 | 19 | pub fn len(&self) -> usize { 20 | (self.0.len() + 1) / 2 21 | } 22 | 23 | pub fn update(&mut self, mut k: usize, a: i64) { 24 | k += self.len() - 1; 25 | self.0[k] = a; 26 | while k > 0 { 27 | k = (k - 1) / 2; 28 | self.0[k] = min(self.0[k * 2 + 1], self.0[k * 2 + 2]); 29 | } 30 | } 31 | 32 | fn query_f(&self, a: usize, b: usize, k: usize, l: usize, r: usize) -> i64 { 33 | if r <= a || b <= l { 34 | ::max_value() 35 | } else if a <= l && r <= b { 36 | self.0[k] 37 | } else { 38 | min( 39 | self.query_f(a, b, k * 2 + 1, l, (l + r) / 2), 40 | self.query_f(a, b, k * 2 + 2, (l + r) / 2, r), 41 | ) 42 | } 43 | } 44 | 45 | pub fn query(&self, a: usize, b: usize) -> i64 { 46 | self.query_f(a, b, 0, 0, self.len()) 47 | } 48 | } 49 | 50 | #[cfg(test)] 51 | mod tests { 52 | use super::*; 53 | 54 | #[test] 55 | fn test1() { 56 | let mut rmq = RMQ::new(6); 57 | rmq.update(1, 3); 58 | rmq.update(5, 10); 59 | assert_eq!(rmq.query(0, 1), ::max_value()); 60 | assert_eq!(rmq.query(2, 5), ::max_value()); 61 | assert_eq!(rmq.query(2, 6), 10); 62 | assert_eq!(rmq.query(1, 5), 3); 63 | assert_eq!(rmq.query(1, 6), 3); 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /src/seq.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashMap; 2 | 3 | pub fn diff_seq(v: Vec) -> Vec { 4 | v.clone() 5 | .into_iter() 6 | .skip(1) 7 | .zip(v.into_iter()) 8 | .map(|(a, b)| a - b) 9 | .collect() 10 | } 11 | 12 | pub fn one_base_to_zero_base(v: Vec) -> Vec { 13 | v.into_iter().map(|x| x - 1).collect() 14 | } 15 | 16 | pub fn sum_seq(v: Vec) -> Vec { 17 | v.into_iter() 18 | .scan(0, |state, x| { 19 | *state = *state + x; 20 | Some(*state) 21 | }) 22 | .collect() 23 | } 24 | 25 | pub fn sum_seq_2d(mut vec: Vec>) -> Vec> { 26 | for i in 0..vec.len() { 27 | for j in 0..vec[0].len() { 28 | vec[i][j] += if j != 0 { vec[i][j - 1] } else { 0 }; 29 | } 30 | } 31 | 32 | for i in 0..vec.len() { 33 | for j in 0..vec[0].len() { 34 | vec[i][j] += if i != 0 { vec[i - 1][j] } else { 0 }; 35 | } 36 | } 37 | 38 | vec 39 | } 40 | 41 | pub fn sum_seq_2d_rect( 42 | sum_vec: &Vec>, 43 | (x1, y1): (usize, usize), 44 | (x2, y2): (usize, usize), 45 | ) -> i64 { 46 | sum_vec[x2][y2] + (if x1 != 0 && y1 != 0 { 47 | sum_vec[x1 - 1][y1 - 1] 48 | } else { 49 | 0 50 | }) - (if x1 != 0 { sum_vec[x1 - 1][y2] } else { 0 }) - (if y1 != 0 { 51 | sum_vec[x2][y1 - 1] 52 | } else { 53 | 0 54 | }) 55 | } 56 | 57 | pub fn map_add(map: &mut HashMap, key: i64, add: i64) { 58 | let v = match map.get(&key) { 59 | Some(v) => *v + add, 60 | None => add, 61 | }; 62 | map.insert(key, v); 63 | } 64 | 65 | #[cfg(test)] 66 | mod tests { 67 | use super::*; 68 | 69 | #[test] 70 | fn diff_seq_test() { 71 | assert_eq!(vec![-9, 1, 0, 1], diff_seq(vec![10, 1, 2, 2, 3])); 72 | assert_eq!(vec![] as Vec, diff_seq(vec![10])); 73 | } 74 | 75 | #[test] 76 | fn one_base_to_zero_base_test() { 77 | assert_eq!( 78 | vec![0, 1, 3, 1, 2], 79 | one_base_to_zero_base(vec![1, 2, 4, 2, 3]) 80 | ); 81 | assert_eq!(vec![] as Vec, one_base_to_zero_base(vec![])); 82 | } 83 | 84 | #[test] 85 | fn sum_seq_test() { 86 | assert_eq!(vec![1, 1, 3, 7, 9, 12], sum_seq(vec![1, 0, 2, 4, 2, 3])); 87 | assert_eq!(vec![] as Vec, sum_seq(vec![])); 88 | } 89 | 90 | #[test] 91 | fn sum_seq_2d_test() { 92 | assert_eq!(vec![] as Vec>, sum_seq_2d(vec![])); 93 | assert_eq!( 94 | vec![vec![1, 3], vec![1, 13], vec![3, 18], vec![13, 28]], 95 | sum_seq_2d(vec![vec![1, 2], vec![0, 10], vec![2, 3], vec![10, 0]]) 96 | ); 97 | } 98 | 99 | #[test] 100 | fn sum_seq_2d_rect_test() { 101 | let sum = sum_seq_2d(vec![vec![1, 2], vec![0, 10], vec![2, 3], vec![10, 0]]); 102 | assert_eq!(1, sum_seq_2d_rect(&sum, (0, 0), (0, 0))); 103 | assert_eq!(0, sum_seq_2d_rect(&sum, (1, 0), (1, 0))); 104 | assert_eq!(2, sum_seq_2d_rect(&sum, (0, 1), (0, 1))); 105 | assert_eq!(28, sum_seq_2d_rect(&sum, (0, 0), (3, 1))); 106 | assert_eq!(13, sum_seq_2d_rect(&sum, (1, 1), (3, 1))); 107 | } 108 | 109 | #[test] 110 | fn map_add_test() { 111 | let mut map = HashMap::new(); 112 | map_add(&mut map, 0, 1); 113 | assert_eq!( 114 | { 115 | let mut v = HashMap::new(); 116 | v.insert(0, 1); 117 | v 118 | }, 119 | map 120 | ); 121 | 122 | map_add(&mut map, 0, 1); 123 | assert_eq!( 124 | { 125 | let mut v = HashMap::new(); 126 | v.insert(0, 2); 127 | v 128 | }, 129 | map 130 | ); 131 | 132 | map_add(&mut map, 10, 5); 133 | assert_eq!( 134 | { 135 | let mut v = HashMap::new(); 136 | v.insert(0, 2); 137 | v.insert(10, 5); 138 | v 139 | }, 140 | map 141 | ); 142 | 143 | map_add(&mut map, 8, 0); 144 | assert_eq!( 145 | { 146 | let mut v = HashMap::new(); 147 | v.insert(0, 2); 148 | v.insert(10, 5); 149 | v.insert(8, 0); 150 | v 151 | }, 152 | map 153 | ); 154 | } 155 | } 156 | -------------------------------------------------------------------------------- /src/text.rs: -------------------------------------------------------------------------------- 1 | pub fn char2id(c: char) -> usize { 2 | c as usize - 'a' as usize 3 | } 4 | 5 | pub fn id2char(id: usize) -> char { 6 | (id + 'a' as usize) as u8 as char 7 | } 8 | 9 | #[cfg(test)] 10 | mod tests { 11 | use super::*; 12 | 13 | #[test] 14 | fn char2id_test() { 15 | assert_eq!(0, char2id('a')); 16 | assert_eq!(1, char2id('b')); 17 | } 18 | 19 | #[test] 20 | fn id2char_test() { 21 | assert_eq!('a', id2char(0)); 22 | assert_eq!('b', id2char(1)); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/union_find.rs: -------------------------------------------------------------------------------- 1 | #[derive(PartialEq, Debug, Clone)] 2 | pub struct UnionFindNode { 3 | pub par: usize, 4 | pub rank: usize, 5 | } 6 | 7 | #[derive(PartialEq, Debug, Clone)] 8 | pub struct UnionFind(pub Vec); 9 | 10 | impl UnionFind { 11 | //初期化 12 | pub fn new(size: usize) -> UnionFind { 13 | let mut vec = Vec::new(); 14 | for i in 0..size { 15 | vec.push(UnionFindNode { par: i, rank: 0 }); 16 | } 17 | 18 | UnionFind(vec) 19 | } 20 | 21 | //根を求める 22 | pub fn find(&mut self, x: usize) -> usize { 23 | if self.0[x].par == x { 24 | x 25 | } else { 26 | let par = self.0[x].par; 27 | let v = self.find(par); 28 | self.0[x].par = v; 29 | v 30 | } 31 | } 32 | 33 | //xとyの集合を併合 34 | pub fn unite(&mut self, x: usize, y: usize) { 35 | let x = self.find(x); 36 | let y = self.find(y); 37 | if x == y { 38 | return; 39 | } 40 | 41 | if self.0[x].rank < self.0[y].rank { 42 | self.0[x].par = y; 43 | } else { 44 | self.0[y].par = x; 45 | if self.0[x].rank == self.0[y].rank { 46 | self.0[x].rank += 1; 47 | } 48 | } 49 | } 50 | 51 | //xとyが同じ集合に属するか 52 | pub fn same(&mut self, x: usize, y: usize) -> bool { 53 | self.find(x) == self.find(y) 54 | } 55 | } 56 | 57 | #[cfg(test)] 58 | mod tests { 59 | use super::*; 60 | 61 | #[test] 62 | fn new() { 63 | assert_eq!( 64 | UnionFind(vec![ 65 | UnionFindNode { par: 0, rank: 0 }, 66 | UnionFindNode { par: 1, rank: 0 }, 67 | UnionFindNode { par: 2, rank: 0 }, 68 | ]), 69 | UnionFind::new(3) 70 | ); 71 | } 72 | 73 | #[test] 74 | fn find() { 75 | let mut uf = UnionFind(vec![ 76 | UnionFindNode { par: 0, rank: 1 }, 77 | UnionFindNode { par: 0, rank: 0 }, 78 | UnionFindNode { par: 1, rank: 0 }, 79 | UnionFindNode { par: 3, rank: 0 }, 80 | UnionFindNode { par: 4, rank: 0 }, 81 | ]); 82 | 83 | { 84 | let mut uf = uf.clone(); 85 | assert_eq!(0, uf.find(0)); 86 | assert_eq!( 87 | UnionFind(vec![ 88 | UnionFindNode { par: 0, rank: 1 }, 89 | UnionFindNode { par: 0, rank: 0 }, 90 | UnionFindNode { par: 1, rank: 0 }, 91 | UnionFindNode { par: 3, rank: 0 }, 92 | UnionFindNode { par: 4, rank: 0 }, 93 | ]), 94 | uf 95 | ); 96 | } 97 | 98 | { 99 | let mut uf = uf.clone(); 100 | assert_eq!(0, uf.find(1)); 101 | assert_eq!( 102 | UnionFind(vec![ 103 | UnionFindNode { par: 0, rank: 1 }, 104 | UnionFindNode { par: 0, rank: 0 }, 105 | UnionFindNode { par: 1, rank: 0 }, 106 | UnionFindNode { par: 3, rank: 0 }, 107 | UnionFindNode { par: 4, rank: 0 }, 108 | ]), 109 | uf 110 | ); 111 | } 112 | { 113 | let mut uf = uf.clone(); 114 | for _ in 0..2 { 115 | assert_eq!(0, uf.find(2)); 116 | assert_eq!( 117 | UnionFind(vec![ 118 | UnionFindNode { par: 0, rank: 1 }, 119 | UnionFindNode { par: 0, rank: 0 }, 120 | UnionFindNode { par: 0, rank: 0 }, 121 | UnionFindNode { par: 3, rank: 0 }, 122 | UnionFindNode { par: 4, rank: 0 }, 123 | ]), 124 | uf 125 | ); 126 | } 127 | } 128 | 129 | { 130 | let mut uf = uf.clone(); 131 | assert_eq!(4, uf.find(4)); 132 | assert_eq!( 133 | UnionFind(vec![ 134 | UnionFindNode { par: 0, rank: 1 }, 135 | UnionFindNode { par: 0, rank: 0 }, 136 | UnionFindNode { par: 1, rank: 0 }, 137 | UnionFindNode { par: 3, rank: 0 }, 138 | UnionFindNode { par: 4, rank: 0 }, 139 | ]), 140 | uf 141 | ); 142 | } 143 | } 144 | 145 | #[test] 146 | fn unite() { 147 | let mut uf = UnionFind(vec![ 148 | UnionFindNode { par: 0, rank: 0 }, 149 | UnionFindNode { par: 1, rank: 0 }, 150 | UnionFindNode { par: 2, rank: 0 }, 151 | UnionFindNode { par: 3, rank: 0 }, 152 | UnionFindNode { par: 4, rank: 0 }, 153 | ]); 154 | 155 | uf.unite(2, 2); 156 | assert_eq!( 157 | UnionFind(vec![ 158 | UnionFindNode { par: 0, rank: 0 }, 159 | UnionFindNode { par: 1, rank: 0 }, 160 | UnionFindNode { par: 2, rank: 0 }, 161 | UnionFindNode { par: 3, rank: 0 }, 162 | UnionFindNode { par: 4, rank: 0 }, 163 | ]), 164 | uf 165 | ); 166 | 167 | for _ in 0..2 { 168 | uf.unite(0, 1); 169 | assert_eq!( 170 | UnionFind(vec![ 171 | UnionFindNode { par: 0, rank: 1 }, 172 | UnionFindNode { par: 0, rank: 0 }, 173 | UnionFindNode { par: 2, rank: 0 }, 174 | UnionFindNode { par: 3, rank: 0 }, 175 | UnionFindNode { par: 4, rank: 0 }, 176 | ]), 177 | uf 178 | ); 179 | } 180 | 181 | uf.unite(3, 1); 182 | assert_eq!( 183 | UnionFind(vec![ 184 | UnionFindNode { par: 0, rank: 1 }, 185 | UnionFindNode { par: 0, rank: 0 }, 186 | UnionFindNode { par: 2, rank: 0 }, 187 | UnionFindNode { par: 0, rank: 0 }, 188 | UnionFindNode { par: 4, rank: 0 }, 189 | ]), 190 | uf 191 | ); 192 | 193 | uf.unite(0, 4); 194 | assert_eq!( 195 | UnionFind(vec![ 196 | UnionFindNode { par: 0, rank: 1 }, 197 | UnionFindNode { par: 0, rank: 0 }, 198 | UnionFindNode { par: 2, rank: 0 }, 199 | UnionFindNode { par: 0, rank: 0 }, 200 | UnionFindNode { par: 0, rank: 0 }, 201 | ]), 202 | uf 203 | ); 204 | } 205 | 206 | #[test] 207 | fn same() { 208 | let mut uf = UnionFind(vec![ 209 | UnionFindNode { par: 0, rank: 0 }, 210 | UnionFindNode { par: 0, rank: 1 }, 211 | UnionFindNode { par: 2, rank: 0 }, 212 | UnionFindNode { par: 3, rank: 0 }, 213 | UnionFindNode { par: 4, rank: 0 }, 214 | ]); 215 | 216 | assert_eq!(true, uf.same(0, 1)); 217 | assert_eq!(true, uf.same(1, 0)); 218 | assert_eq!(false, uf.same(1, 3)); 219 | } 220 | } 221 | -------------------------------------------------------------------------------- /src/warshall_floyd.rs: -------------------------------------------------------------------------------- 1 | use graph; 2 | use std::cmp::min; 3 | 4 | pub fn warshall_floyd( 5 | graph::MatrixGraph(mut vec): graph::MatrixGraph, 6 | ) -> Vec>> { 7 | for k in 0..vec.len() { 8 | for i in 0..vec.len() { 9 | for j in 0..vec.len() { 10 | let now = vec[i][j]; 11 | let new = match (vec[i][k], vec[k][j]) { 12 | (Some(a), Some(b)) => Some(a + b), 13 | _ => None, 14 | }; 15 | vec[i][j] = match (now, new) { 16 | (Some(a), Some(b)) => Some(min(a, b)), 17 | (None, Some(x)) => Some(x), 18 | (Some(x), None) => Some(x), 19 | (None, None) => None, 20 | }; 21 | } 22 | } 23 | } 24 | 25 | vec 26 | } 27 | 28 | #[cfg(test)] 29 | mod tests { 30 | use super::*; 31 | 32 | #[test] 33 | fn test1() { 34 | let mut graph = graph::MatrixGraph::from(graph::ListGraph::from(vec![ 35 | vec![(2, 10), (1, 1)], 36 | vec![(3, 2)], 37 | vec![(1, 1), (3, 3), (4, 1)], 38 | vec![(0, 7), (4, 2)], 39 | vec![], 40 | ])); 41 | 42 | assert_eq!( 43 | vec![ 44 | vec![Some(10), Some(1), Some(10), Some(3), Some(5)], 45 | vec![Some(9), Some(10), Some(19), Some(2), Some(4)], 46 | vec![Some(10), Some(1), Some(20), Some(3), Some(1)], 47 | vec![Some(7), Some(8), Some(17), Some(10), Some(2)], 48 | vec![None, None, None, None, None], 49 | ], 50 | warshall_floyd(graph) 51 | ); 52 | } 53 | } 54 | --------------------------------------------------------------------------------