feat: add 2-SAT solver (#345)

* Implement 2-SAT solver

* Use `abs_diff` for numbers instead of manually calculating it

* Fix formatting

Author: sn-chr

DIRECTORY.md

@@ -59,6 +59,7 @@
     * [Tarjan's Strongly Connected Components](https://github.com/TheAlgorithms/Rust/blob/master/src/graph/strongly_connected_components.rs)
     * [Centroid Decomposition](https://github.com/TheAlgorithms/Rust/blob/master/src/graph/centroid_decomposition.rs)
     * [Dinic's Max Flow](https://github.com/TheAlgorithms/Rust/blob/master/src/graph/dinic_maxflow.rs)
+    * [2-SAT Problem](https://github.com/TheAlgorithms/Rust/blob/master/src/graph/two_satisfiability.rs)
   * [Lib](https://github.com/TheAlgorithms/Rust/blob/master/src/lib.rs)
   * Math
     * [Baby-Step Giant-Step Algorithm](https://github.com/TheAlgorithms/Rust/blob/master/src/math/baby_step_giant_step.rs)

README.md

@@ -45,6 +45,7 @@ These are for demonstration purposes only.
 - [x] [Topological sorting](./src/graph/topological_sort.rs)
 - [x] [Centroid Decomposition](./src/graph/centroid_decomposition.rs)
 - [x] [Dinic's Max Flow](./src/graph/dinic_maxflow.rs)
+- [x] [2-SAT Problem](./src/graph/two_satisfiability.rs)
 
 ## [Math](./src/math)
 - [x] [Baby-Step Giant-Step Algorithm](./src/math/baby_step_giant_step.rs)

src/graph/mod.rs

@@ -14,6 +14,7 @@ mod prim;
 mod prufer_code;
 mod strongly_connected_components;
 mod topological_sort;
+mod two_satisfiability;
 
 pub use self::bellman_ford::bellman_ford;
 pub use self::breadth_first_search::breadth_first_search;
@@ -31,3 +32,4 @@ pub use self::prim::{prim, prim_with_start};
 pub use self::prufer_code::{prufer_decode, prufer_encode};
 pub use self::strongly_connected_components::StronglyConnectedComponents;
 pub use self::topological_sort::topological_sort;
+pub use self::two_satisfiability::solve_two_satisfiability;

src/graph/two_satisfiability.rs

@@ -0,0 +1,118 @@
+use super::strongly_connected_components::StronglyConnectedComponents as SCCs;
+
+pub type Condition = (i64, i64);
+type Graph = Vec<Vec<usize>>;
+
+#[inline]
+fn variable(var: i64) -> usize {
+    if var < 0 {
+        (((-var) << 1) + 1) as usize
+    } else {
+        (var << 1) as usize
+    }
+}
+
+/// Returns an assignment that satisfies all the constraints, or a variable
+/// that makes such an assignment impossible. Variables should be numbered
+/// from 1 to n, and a negative number -m corresponds to the negated variable
+/// m. For more information about this problem, please visit:
+/// https://en.wikipedia.org/wiki/2-satisfiability
+pub fn solve_two_satisfiability(
+    expression: &[Condition],
+    num_variables: usize,
+) -> Result<Vec<bool>, i64> {
+    let num_verts = (num_variables + 1) << 1;
+    let mut result = Vec::new();
+    let mut sccs = SCCs::new(num_verts);
+    let mut adj = Graph::new();
+    adj.resize(num_verts, vec![]);
+    expression.iter().for_each(|cond| {
+        let v1 = variable(cond.0);
+        let v2 = variable(cond.1);
+        adj[v1 ^ 1].push(v2);
+        adj[v2 ^ 1].push(v1);
+    });
+    sccs.find_components(&adj);
+    result.resize(num_variables + 1, false);
+    for var in (2..num_verts).step_by(2) {
+        if sccs.component[var] == sccs.component[var ^ 1] {
+            return Err((var >> 1) as i64);
+        }
+        // if a variable isn't
+        if sccs.component[var] < sccs.component[var ^ 1] {
+            result[var >> 1] = true;
+        }
+    }
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::thread;
+
+    use super::*;
+
+    fn check_answer(expression: &[Condition], answers: &[bool]) -> bool {
+        let mut ok = true;
+        for &(c1, c2) in expression {
+            let mut cv = false;
+            if c1 < 0 {
+                cv |= !answers[-c1 as usize];
+            } else {
+                cv |= answers[c1 as usize];
+            }
+            if c2 < 0 {
+                cv |= !answers[-c2 as usize];
+            } else {
+                cv |= answers[c2 as usize];
+            }
+            ok &= cv;
+        }
+        ok
+    }
+    #[test]
+    fn basic_test() {
+        let conds = vec![(1, 1), (2, 2)];
+        let res = solve_two_satisfiability(&conds, 2);
+        assert!(res.is_ok());
+        assert!(check_answer(&conds, &res.unwrap()));
+
+        let conds = vec![(1, 2), (-2, -2)];
+        let res = solve_two_satisfiability(&conds, 2);
+        assert!(res.is_ok());
+        assert!(check_answer(&conds, &res.unwrap()));
+
+        let conds = vec![];
+        let res = solve_two_satisfiability(&conds, 2);
+        assert!(res.is_ok());
+        assert!(check_answer(&conds, &res.unwrap()));
+
+        let conds = vec![(-1, -1), (-2, -2), (1, 2)];
+        let res = solve_two_satisfiability(&conds, 2);
+        assert!(res.is_err());
+    }
+
+    #[test]
+    #[ignore]
+    fn big_test() {
+        // We should spawn a new thread and set its stack size to something
+        // big (256MB in this case), because doing DFS (for finding SCCs) is
+        // a stack-intensive operation. 256MB should be enough for 3e5
+        // variables though.
+        let builder = thread::Builder::new().stack_size(256 * 1024 * 1024);
+        let handler = builder
+            .spawn(|| {
+                let num_conds = 3e5 as i64;
+                let mut conds = vec![];
+                for i in 1..num_conds {
+                    conds.push((i, -(i + 1)));
+                }
+                conds.push((num_conds, num_conds));
+                let res = solve_two_satisfiability(&conds, num_conds as usize);
+                assert!(res.is_ok());
+                assert!(check_answer(&conds, &res.unwrap()));
+            })
+            .unwrap();
+        handler.join().unwrap();
+    }
+}

src/math/pollard_rho.rs

@@ -73,7 +73,7 @@ fn pollard_rho_customizable(
             {
                 small_iteration += 1;
                 x = advance(x, c, number);
-                let diff = (x as i128 - y as i128).abs() as u128;
+                let diff = x.abs_diff(y);
                 remainder = (remainder * diff) % number as u128;
             }
             current_gcd = gcd(remainder as u64, number);
@@ -87,7 +87,7 @@ fn pollard_rho_customizable(
     if current_gcd == number {
         while current_gcd == 1 {
             x_start = advance(x_start, c, number);
-            current_gcd = gcd((x_start as i128 - y as i128).abs() as u64, number);
+            current_gcd = gcd(x_start.abs_diff(y) as u64, number);
         }
     }
     current_gcd