Fix calculation of last row

1 files changed, 29 insertions, 24 deletions

diff --git a/src/solvers/intuitive.rs b/src/solvers/intuitive.rs
index f858a42..f4afcff 100644
--- a/src/solvers/intuitive.rs
+++ b/src/solvers/intuitive.rs
@@ -1,5 +1,6 @@
 use crate::solver::Solver;
 use crate::structs::GapHeights;
+use std::os::raw::c_ushort;
 
 /// Solve for a given N and return the resulting wall
 pub struct NormalSolver<T: num::PrimInt> {
@@ -62,10 +63,9 @@ impl<T: num::PrimInt> SaveState<T> {
     }
 
     #[allow(dead_code)]
-    pub unsafe fn bridge_gap(mut self, gap: u32) -> Self {
+    pub unsafe fn bridge_gap(&mut self, gap: u32) {
         self.set_bit(gap - self.sum);
         self.sum = gap;
-        self
     }
 }
 
@@ -107,24 +107,24 @@ impl<T: num::PrimInt> NormalSolver<T> {
         self.permute(
             permutohedron::factorial(self.n as usize),
             0,
-            ((0..self.h).collect::<Vec<u32>>()).as_ref(),
+            ((0..(self.h - 1)).collect::<Vec<u32>>()).as_ref(),
         );
         unsafe { println!("tries: {}\nsolutions: {}", TRIES, SOLUTIONS) }
     }
 
     fn permute(&mut self, up: usize, index: usize, numbers: &[u32]) {
         let chunk = self.permutations.len() / self.h as usize;
-        if index as usize == numbers.len() - 2 {
+        if index as usize == numbers.len() - 1 {
             let mut new_num = Vec::from(numbers);
             if self.n == 6 {
-                new_num[2] = 675;
+                new_num[2] = 680;
             }
             if self.n == 8 {
                 //new_num[3] = 38728;
                 new_num[3] = 36719;
             }
 
-            if self.check_perm(&new_num[..(new_num.len() - 1)]) {
+            if self.check_perm(&new_num) {
                 for i in new_num {
                     println!("{}\t{}", numbers[0], i);
                 }
@@ -134,7 +134,7 @@ impl<T: num::PrimInt> NormalSolver<T> {
         if index as usize == numbers.len() {
             //println!("checking {:?}", numbers);
             if self.check_perm(&numbers) {
-                //println!("success");
+                println!("success");
                 for i in numbers {
                     println!("{},{}", numbers[0], i);
                 }
@@ -152,6 +152,9 @@ impl<T: num::PrimInt> NormalSolver<T> {
     }
 
     fn check_perm(&mut self, nums: &[u32]) -> bool {
+        //for i in nums {
+        //    println!("{},{}", nums[0], i);
+        //}
         unsafe {
             TRIES += 1;
         }
@@ -167,19 +170,16 @@ impl<T: num::PrimInt> NormalSolver<T> {
                 sums[sum - 1] = i as u32;
             }
         }
-        //for i in 0..sums.len() {
-        //    let test = SaveState::<u64>::new();
-        //    if sums[i] == self.w {
-        //        if !test.bridges_gap(i as u32, self.n) {
-        //            //return false;
-        //        }
-        //        unsafe {
-        //            test.bridge_gap(i as u32);
-        //        }
-        //    }
-        //}
-        unsafe {
-            SOLUTIONS += 1;
+        let mut test = SaveState::<u64>::new();
+        for i in 0..sums.len() {
+            if sums[i] == self.w {
+                if !test.bridges_gap(i as u32, self.n) {
+                    return false;
+                }
+                unsafe {
+                    test.bridge_gap(i as u32);
+                }
+            }
         }
         //println!("{:?}", sums);
         let vec = sums
@@ -189,22 +189,27 @@ impl<T: num::PrimInt> NormalSolver<T> {
         //println!("{:?}", vec);
         let vec = GapHeights::from_heights(vec); //.output(self.n, self.h);
 
-        if !self.check_gaps(&vec) {
-            return false;
+        //if !self.check_gaps(&vec) {
+        //    return false;
+        //}
+        //println!("success");
+        unsafe {
+            SOLUTIONS += 1;
         }
-        println!("success");
-        vec.as_stone_wall(self.n).output();
+        //vec.as_stone_wall(self.n).output();
         true
     }
 
     #[allow(dead_code)]
     fn check_gaps(&mut self, wall: &GapHeights) -> bool {
+        self.solve_stack = vec![SaveState::new(); self.h as usize];
         for (i, r) in wall.iter().enumerate() {
             let stone = (i + 1) as u32 - self.solve_stack[r as usize].sum;
             if stone > self.n {
                 return false;
             }
             self.solve_stack[r as usize].set_bit(stone);
+            self.solve_stack[r as usize].sum = i as u32;
         }
         for state in self.solve_stack.as_ref() as &[SaveState<T>] {
             if state.bitmask != T::from(1 << self.n).unwrap() {