Numbrix puzzles are similar to Hidato.
The most important difference is that it is only possible to move 1 node left, right, up, or down (sometimes referred to as the Von Neumann neighborhood).
Published puzzles also tend not to have holes in the grid and may not always indicate the end node.
Two examples follow:

Example 1
Problem.

 0  0  0  0  0  0  0  0  0
 0  0 46 45  0 55 74  0  0
 0 38  0  0 43  0  0 78  0
 0 35  0  0  0  0  0 71  0
 0  0 33  0  0  0 59  0  0
 0 17  0  0  0  0  0 67  0
 0 18  0  0 11  0  0 64  0
 0  0 24 21  0  1  2  0  0
 0  0  0  0  0  0  0  0  0

Solution.

 49 50 51 52 53 54 75 76 81
 48 47 46 45 44 55 74 77 80
 37 38 39 40 43 56 73 78 79
 36 35 34 41 42 57 72 71 70
 31 32 33 14 13 58 59 68 69
 30 17 16 15 12 61 60 67 66
 29 18 19 20 11 62 63 64 65
 28 25 24 21 10  1  2  3  4
 27 26 23 22  9  8  7  6  5

Example 2
Problem.

 0  0  0  0  0  0  0  0  0
 0 11 12 15 18 21 62 61  0
 0  6  0  0  0  0  0 60  0
 0 33  0  0  0  0  0 57  0
 0 32  0  0  0  0  0 56  0
 0 37  0  1  0  0  0 73  0
 0 38  0  0  0  0  0 72  0
 0 43 44 47 48 51 76 77  0
 0  0  0  0  0  0  0  0  0

Solution.

  9 10 13 14 19 20 63 64 65
  8 11 12 15 18 21 62 61 66
  7  6  5 16 17 22 59 60 67
 34 33  4  3 24 23 58 57 68
 35 32 31  2 25 54 55 56 69
 36 37 30  1 26 53 74 73 70
 39 38 29 28 27 52 75 72 71
 40 43 44 47 48 51 76 77 78
 41 42 45 46 49 50 81 80 79

Task
Write a program to solve puzzles of this ilk,
demonstrating your program by solving the above examples.
Extra credit for other interesting examples.



Related tasks

 A* search algorithm
 Solve a Holy Knight's tour
 Knight's tour
 N-queens problem
 Solve a Hidato puzzle
 Solve a Holy Knight's tour
 Solve a Hopido puzzle
 Solve the no connection puzzle


 
 
//////////////////////////////////////////////////////////////////////////////
///  NumbrixSolver                                                         ///
///     Solve the puzzle, by using system verilog randomization engine     ///
//////////////////////////////////////////////////////////////////////////////
class NumbrixSolver;
  rand int solvedBoard[][];
  int fixedBoard[][];
  int numCells;
  ////////////////////////////////////////////////////////////////////////////
  /// Dynamically resize the board accordingly to the size of the reference///
  /// board                                                                ///
  ////////////////////////////////////////////////////////////////////////////
  constraint height {
    solvedBoard.size == fixedBoard.size;
  }
  constraint width {
    foreach(solvedBoard[i]) solvedBoard[i].size == fixedBoard[i].size;
  }
 
  ////////////////////////////////////////////////////////////////////////////
  ///  Fix the positions defined in the input board                        ///
  ////////////////////////////////////////////////////////////////////////////
  constraint fixed {
    foreach(solvedBoard[i]) foreach(solvedBoard[i][j])
      if(fixedBoard[i][j] != 0)solvedBoard[i][j] == fixedBoard[i][j];
  }
  ////////////////////////////////////////////////////////////////////////////
  ///  Ensures that the whole board is filled from the number with numbers ///
  ///   1,2,3,...,numCells                                                 ///
  ////////////////////////////////////////////////////////////////////////////
  constraint range {
    foreach(solvedBoard[i])foreach(solvedBoard[i][j])
      solvedBoard[i][j] inside {[1:numCells]};
  }
  ////////////////////////////////////////////////////////////////////////////
  ///  Ensures that there is no repeated number, consequently every number ///
  ///  is present on the board                                             ///
  ////////////////////////////////////////////////////////////////////////////
  constraint uniqueness {
    foreach(solvedBoard[i1]) foreach(solvedBoard[i1][j1])
    foreach(solvedBoard[i2]) foreach(solvedBoard[i2][j2])
      if((i1 != i2) || (j1 != j2)) solvedBoard[i1][j1] != solvedBoard[i2][j2];
  }
 
  ////////////////////////////////////////////////////////////////////////////
  /// Ensures that exists one direction connecting the numbers in          ///
  /// increasing order                                                     ///
  ////////////////////////////////////////////////////////////////////////////
  constraint f_seq {
    foreach(solvedBoard[i])foreach(solvedBoard[i][j])
      (solvedBoard[i][j] == (numCells)) ||
      (solvedBoard[(i < solvedBoard.size-1) ? (i+1): i][j]    == 
                                         solvedBoard[i][j]+1) ||
      (solvedBoard[i][(j < solvedBoard[i].size - 1) ? j+1: j] == 
                                         solvedBoard[i][j]+1) ||
      (solvedBoard[(i > 0) ? i-1: i][j]                       == 
                                         solvedBoard[i][j]+1) ||
      (solvedBoard[i][(j > 0)? j-1:j]                         == 
                                         solvedBoard[i][j]+1);
  }
 
 
  function void pre_randomize();
    // the multiplication is not supported in the constraints
    numCells = fixedBoard.size * fixedBoard[0].size;
  endfunction
  function void printSolvedBoard();
    foreach(solvedBoard[i]) begin
      foreach(solvedBoard[j]) begin
        $write("%4d", solvedBoard[i][j]);
      end
      $display("");
    end
  endfunction
endclass
 
 
//////////////////////////////////////////////////////////////////////////////
/// SolveNumBrix: A program demonstrating how to use NumbrixSolver class   ///
//////////////////////////////////////////////////////////////////////////////
 
program SolveNumbrix;
  NumbrixSolver board;
  initial begin
    board = new;
    board.fixedBoard = '{
      '{0,  0,  0,  0,  0,  0,  0,  0,  0},
      '{0,  0, 46, 45,  0, 55, 74,  0,  0},
      '{0, 38,  0,  0, 43,  0,  0, 78,  0},
      '{0, 35,  0,  0,  0,  0,  0, 71,  0},
      '{0,  0, 33,  0,  0,  0, 59,  0,  0},
      '{0, 17,  0,  0,  0,  0,  0, 67,  0},
      '{0, 18,  0,  0, 11,  0,  0, 64,  0},
      '{0,  0, 24, 21,  0,  1,  2,  0,  0},
      '{0,  0,  0,  0,  0,  0,  0,  0,  0}};
    if(board.randomize()) begin
      $display("Solution for the Example 1");
      board.printSolvedBoard();    
    end
    else begin
      $display("Failed to solve Example 1");
    end
 
    board.fixedBoard = '{
       {0,  0,  0,  0,  0,  0,  0,  0,  0},
       {0, 11, 12, 15, 18, 21, 62, 61,  0},
       {0,  6,  0,  0,  0,  0,  0, 60,  0},
       {0, 33,  0,  0,  0,  0,  0, 57,  0},
       {0, 32,  0,  0,  0,  0,  0, 56,  0},
       {0, 37,  0,  1,  0,  0,  0, 73,  0},
       {0, 38,  0,  0,  0,  0,  0, 72,  0},
       {0, 43, 44, 47, 48, 51, 76, 77,  0},
      '{0,  0,  0,  0,  0,  0,  0,  0,  0}};
 
    if(board.randomize()) begin
      $display("Solution for the Example 2");
      board.printSolvedBoard();    
    end
    else begin
      $display("Failed to solve Example 2");
    end
    $finish;
  end
endprogram
 