i need help with my void Sudoku::solve() i give the cpp files and header file for sudoku and the backtrack header i have to use function form the backtrack header file to solve the problem i need help with

"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()) { //solving

} }"

//header file #include #include

#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 m_Initial; bool m_IsSolved; BackTrack m_Problem;

public: Sudoku(std::vector 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 #include

class BackTrack { public: typedef std::vector::const_iterator const_iterator; typedef std::vector::const_iterator iterator;

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

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