i need help with my solve function in cpp file i have to use backtrack form the

Question

i need help with my solve function in cpp file i have to use backtrack form the header file .

//header file
#include <iostream>
#include <vector>

#include "backtrack.h"

class Sudoku
{
public:
   const static unsigned int GRID_SIZE = 81;
   const static unsigned int ROW_SIZE = 9;
   const static unsigned int COL_SIZE = 9;
   const static unsigned int MAX_VALUE = 9;
   const static unsigned int BOX_SIZE = 3;

private:
   std::vector<int> m_Initial;
   bool m_IsSolved;
   BackTrack m_Problem;

public:
   Sudoku(std::vector<int> initial) : m_Initial(initial), m_IsSolved(false), m_Problem(GRID_SIZE, MAX_VALUE)
   {
   }

   void solve();

   bool isSolved() const
   {
       return m_IsSolved;
   }

   void print(std::ostream& os) const
   {
       int k = 0;
       for (int i = 0; i < ROW_SIZE; ++i)
       {
           for (int j = 0; j < COL_SIZE; ++j)
           {
               os << m_Problem[k] + 1 << ' ';
               if (j % BOX_SIZE == BOX_SIZE - 1)
                   os << ' ';
               ++k;
           }
           os << std::endl;
           if (i % BOX_SIZE == BOX_SIZE - 1)
               os << std::endl;
       }
   }
private:
   int square(int k) const
   {
       int r = row(k) / BOX_SIZE;
       int c = column(k) / BOX_SIZE;
       return c + BOX_SIZE * r;
   }

   int innerSquare(int k) const
   {
       int r = row(k) % BOX_SIZE;
       int c = column(k) % BOX_SIZE;
       return c + BOX_SIZE * r;
   }

   int row(int k) const
   {
       return k / ROW_SIZE;
   }

   int column(int k) const
   {
       return k % ROW_SIZE;
   }

   int posBySquare(int ou, int in) const
   {
       int r = (ou / BOX_SIZE) * BOX_SIZE;
       int c = (ou % BOX_SIZE) * BOX_SIZE;
       r += in / BOX_SIZE;
       c += in % BOX_SIZE;
       return posByColRow(c, r);
   }

   int posByColRow(int col, int row) const
   {
       return ROW_SIZE * row + col;
   }

};

inline std::ostream& operator<<(std::ostream& os, const Sudoku& puzzle)
{
   puzzle.print(os);
   return os;
}

//cpp file

void Sudoku::solve()
{
   // NOTE: Backtrack is 0-based, so you need to add 1 for the puzzle
   m_IsSolved = false;
   int count = 0;
   while ((!m_IsSolved) && m_Problem.more())
   {
      
   

    }
}

//backtrack header file

#include <vector>
#include <algorithm>

class BackTrack
{
public:
   typedef std::vector<unsigned int>::const_iterator const_iterator;
   typedef std::vector<unsigned int>::const_iterator iterator;

private:
   bool m_Done;
   std::vector<unsigned int> m_Arities;
   std::vector<unsigned int> m_Values;
public:
   BackTrack(unsigned int nVariables, unsigned int arity = 9) : m_Done(false), m_Arities(nVariables, arity), m_Values(nVariables, 0)
   {}

   template<class Iterator>
   BackTrack(Iterator start, Iterator end) : m_Done(false), m_Arities(start, end)
   {
       std::fill_n(std::back_inserter(m_Values), m_Arities.size(), 0);
   }

   unsigned int operator[](unsigned int i) const
   {
       return m_Values[i];
   }

   unsigned int size() const
   {
       return m_Values.size();
   }

   unsigned int arity(unsigned int i) const
   {
       return m_Arities[i];
   }

   bool more() const
   {
       return !m_Done;
   }

   void prune(unsigned int level)
   {
       level = (level > size()) ? size() : level;
       std::fill(m_Values.begin() + level, m_Values.end(), 0);
       int k = level - 1;
       bool carry = true;
       while (k >= 0 && carry)
       {
           m_Values[k] += 1;
           if (m_Values[k] >= m_Arities[k])
               m_Values[k] = 0;
           else
               carry = false;
           --k;
       }
       m_Done = carry;
   }

   BackTrack& operator++()
   {
       prune(size());
       return *this;
   }

   BackTrack operator++(int)
   {
       BackTrack oldValue = *this;
       prune(size());
       return oldValue;
   }

   const_iterator begin() const
   {
       return m_Values.begin();
   }

   iterator begin()
   {
       return m_Values.begin();
   }

   const_iterator end() const
   {
       return m_Values.end();
   }

   iterator end()
   {
       return m_Values.end();
   }
};

Explanation / Answer

Replace the solve method with the below code

and then change the datatype void to bool at the calling location of the solve method.

Related Questions

Navigate

• Browse (All)
• Browse I
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.