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


/*REXX program solves a  Numbrix (R) puzzle, it also displays the puzzle and solution.  */
maxR=   0;     maxC=   0;          maxX=   0;    /*define  maxR,  maxC,  and  maxX.     */
minR= 9e9;     minC= 9e9;          minX= 9e9;    /*   "    minR,  minC,   "   minX.     */
cells=  0                                        /*the number of cells  (so far).       */
parse arg xxx                                    /*get the cell definitions from the CL.*/
xxx=translate(xxx,  ',,,,,'  ,  "/\;:_")         /*also allow other characters as comma.*/
@.=
           do  while xxx\='';       parse var  xxx    r c   marks  ','  xxx
               do  while marks\='';               _=@.r.c
               parse var marks  x  marks
               if datatype(x, 'N')  then x= abs(x) / 1                /*normalize  │x│  */
               minR= min(minR, r);       minC= min(minC, c)           /*find min R and C*/
               maxR= max(maxR, r);       maxC= max(maxC, c)           /*  "  max "  "  "*/
               if x==1    then do;   !r= r;   !c= c                   /*the START cell. */
                               end
               if _\==''  then call err  "cell at"  r  c  'is already occupied with:'  _
               @.r.c= x;       c=  c +1;           cells= cells + 1   /*assign a mark.  */
               if x==.              then iterate                      /*is a hole?  Skip*/
               if \datatype(x,'W')  then call err  'illegal marker specified:'    x
               minX= min(minX, x);  maxX= max(maxX, x)                /*min  &  max   X.*/
               end   /*while marks\='' */
           end       /*while xxx  \='' */
call show                                        /* [↓]  is used for making fast moves. */
Nr = '0  1   0  -1    -1   1   1  -1'            /*possible  row     for the next move. */
Nc = '1  0  -1   0     1  -1   1  -1'            /*   "      column   "   "    "    "   */
pMoves= words(Nr)   -   4                        /*is this to be a Numbrix puzzle ?     */
 
     do i=1  for pMoves;    Nr.i= word(Nr, i);    Nc.i= word(Nc, i)   /*for fast moves. */
     end   /*i*/
say
if \next(2, !r, !c)  then call err   'No solution possible for this Numbrix puzzle.'
say 'A solution for the Numbrix puzzle exists.';          say;          call show
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
err:  say;   say '***error*** (from Numbrix puzzle): '    arg(1);       say;       exit 13
/*──────────────────────────────────────────────────────────────────────────────────────*/
next: procedure expose @. Nr. Nc. cells pMoves;  parse arg #,r,c;       ##= # + 1
        do t=1  for pMoves                                      /* [↓]  try some moves. */
        parse value   r+Nr.t  c+Nc.t    with   nr  nc           /*next move coördinates.*/
        if @.nr.nc==.  then do;                  @.nr.nc= #     /*let's try this move.  */
                            if #==cells          then return 1  /*is this the last move?*/
                            if next(##, nr, nc)  then return 1
                            @.nr.nc=.                           /*undo the above move.  */
                            iterate                             /*go & try another move.*/
                            end
        if @.nr.nc==#  then do                                  /*this a fill─in move ? */
                            if #==cells          then return 1  /*this is the last move.*/
                            if next(##, nr, nc)  then return 1  /*a fill─in move.       */
                           end
        end   /*t*/
      return 0                                                  /*this ain't working.   */
/*──────────────────────────────────────────────────────────────────────────────────────*/
show: if maxR<1 | maxC<1  then call err  'no legal cell was specified.'
      if minX<1           then call err  'no  1  was specified for the puzzle start'
      w= max(2, length(cells) );      do   r=maxR  to minR  by -1;   _=
                                        do c=minC  to maxC;          _= _  right(@.r.c, w)
                                        end   /*c*/
                                      say _
                                      end   /*r*/
      say;      return