^{La sfida è stata presa con il permesso del mio concorso per la sfida del codice universitario}

---

La dipendenza che abbiamo sui telefoni cellulari ci fa caricare ogni notte fino al livello massimo della batteria, quindi non corriamo il rischio di rimanere senza energia entro la metà del giorno successivo. Ci sono anche persone che, quando vedono uno sbocco gratuito durante il giorno, lo fanno pagare per ciò che può accadere.

Sono uno di loro.

Nel corso degli anni, ho perfezionato la mia tecnica per non caricare la batteria al massimo ogni notte. Con le mie routine ripetitive perfettamente conosciute, sono chiaro su quali orari della giornata sarò in grado di fare quelle ricariche parziali (e quante unità aumenterà il livello) e cosa abbassa il livello della batteria tra ogni carica. Con questi dati, ogni notte calcolo il livello minimo della batteria con cui devo uscire di casa il giorno successivo in modo che non scenda mai sotto la mia soglia autoimposta di due unità.

Quello che non sono ancora riuscito a padroneggiare è lo stesso calcolo quando lascio la routine stabilita e ho diverse alternative per fare le cose. Succede, ad esempio, nei giorni in cui sono in viaggio verso un'altra città a cui posso arrivare in diversi modi.

Nel mio primo approccio al problema, presumo di voler muovermi in una "scacchiera", dall'angolo in alto a sinistra all'angolo in basso a destra. In ogni "cella" posso caricare il cellulare un importo specifico, oppure non posso e il suo livello di carico scende.

Sfida

Data una matrice FxC di numeri interi, genera la quantità minima di livello di batteria di cui ho bisogno per passare dall'angolo superiore sinistro a quello inferiore destro senza che il livello di carico scenda mai al di sotto di 2 unità.

Nella matrice, un numero positivo indica quanto posso caricare il mio telefono cellulare prima di dover riprendere a seguire il mio percorso, mentre un numero negativo indica che non ci sono prese e che la batteria del cellulare abbassa il suo livello di carica di tale importo. È garantito che le quantità nelle celle di origine e di destinazione (angolo in alto a sinistra e in basso a destra) sono sempre 0 e che il resto dei valori (valore assoluto) non superi 100.

Esempio
dato:

$$\begin{bmatrix} 📱&-1&1&-1 \\ -1&-1&-1&-1 \\ -1&1&-1&-1 \\ 1&1&-1&0 \end{bmatrix}$$

Il percorso di cui ho bisogno di meno batteria è:

$$\begin{bmatrix} 📱&-1&1&-1 \\ \color{blue}{-1}&-1&-1&-1 \\ \color{blue}{-1}&1&-1&-1 \\ \color{blue}{1}&\color{blue}{1}&\color{blue}{-1}&0 \end{bmatrix}$$

E il livello minimo della batteria di cui ho bisogno è 4

Appunti

• L'inizio sarà sempre l'angolo in alto a sinistra
• La fine sarà sempre l'angolo in basso a destra
• Non puoi andare in una cella che hai già superato. Esempio: una volta in posizione (0,1), non è possibile passare al punto iniziale (0,0)
• Il livello della batteria non può (per qualsiasi motivo) scendere al di sotto di 2
• Puoi presumere che ci sarà sempre un inizio e una fine
• Puoi prendere le matrici monodimensionali come multidimensionali, se necessario [1,2,3] == [[1,2,3]]
• Possono esserci più percorsi corretti (costo minimo necessario)
• Il tuo obiettivo è fornire solo il livello di batteria iniziale più basso necessario, non il percorso
• Puoi andare solo in verticale e in orizzontale (non in diagonale)

Casi test

[0, 0] => 2
[0, 1, 0] => 2
[0, -1, 0] => 3
[0, 15, -20, 5, 0] => 7
[[0, -3],[-5, 0]] => 5
[[0, -5, -9, 5], [-3, 5, 2, -2], [2, -4, -4, 0]] => 5
[[0, -1, 1, -1], [-1, -1, -1, -1], [-1, 1, -1, -1], [1, 1, -1, 0]] => 4

JavaScript (ES7),  162 156  154 byte

m=>(M=g=(x,y,n,k)=>m.map((r,Y)=>[r[x+1]]+[m[y+1]]?r.map((v,X)=>r[1/v&&(x-X)**2+(y-Y)**2==1&&g(X,Y,u=v+n,k<u?k:u,r[X]=g),X]=v):M=M>k?M:k))(0,0,0)|M<0?2-M:2

Provalo online!

Commentate

m => (                          // m[] = input matrix
  M =                           // initialize M to a non-numeric value
  g = (x, y, n, k) =>           // g = recursive depth-first search function
    m.map((r, Y) =>             // for each row r[] at position Y in m[]:
      [r[x + 1]] +              //   if either r[x + 1]
      [m[y + 1]] ?              //   or m[y + 1] is defined:
        r.map((v, X) =>         //     for each value v at position X in r[]:
          r[                    //
            1 / v &&            //       if v is numeric
            (x - X) ** 2 +      //       and the squared Euclidean distance
            (y - Y) ** 2 == 1   //       between (x, y) and (X, Y) is 1:
            &&                  //
              g(                //         do a recursive call:
                X, Y,           //           with (X, Y)
                u = v + n,      //           with n = n + v
                k < u ? k : u,  //           with k = min(k, n + v)
                r[X] = g        //           set r[X] to a non-numeric value
              ),                //         end of recursive call
            X                   //       then restore r[X]
          ] = v                 //       to its initial value
        )                       //     end of inner map()
      :                         //   else (we've reached the bottom right corner):
        M = M > k ? M : k       //     update M to max(M, k)
    )                           // end of outer map()
)(0, 0, 0) |                    // initial call to g with x = y = n = 0 and k undefined
M < 0 ? 2 - M : 2               // return 2 - M if M is negative, or 2 otherwise

Python 2 , 208 202 byte

lambda s:2-f(s)
def f(s,x=0,y=0):
 if x>-1<y<s[y:]>[]<s[y][x:]!="">s[y][x]:k=s[y][x];s[y][x]="";return k+min(0,max([len(s[y+1:]+s[y][x+1:])and f(eval(`s`),x+a/3-1,y+a%3-1)for a in 7,1,5,3]))
 return-9e9

Provalo online!

---

Python 2 , 217 211 byte

i=input()
X,Y=len(i[0]),len(i)
s=[[0]*4+[i]];r=[]
for m,l,x,y,g in s:
 if X>x>-1<y<Y<"">g[y][x]:r+=[m]*(Y-y<2>X-x);l+=g[y][x];g[y][x]="";s+=[[min(m,l),l,x+a/3-1,y+a%3-1,eval(`g`)]for a in 7,1,5,3]
print 2-max(r)

Provalo online!

R , 224 220 217 213 210 byte

f=function(x,m=rbind(0,cbind(0,x,0),0),i=2,j=2,p=F,k=c(1:-1,0,0,-1:1),b=Inf,`^`=min){m[i,j]=0
for(h in 1:4)b=b^'if'(all(c(R<-i+k[h],C<-j+k[h+4])>dim(x)),max(2,2-cumsum(p)^0),if(v<-m[R,C])b^f(x,m,R,C,c(p,v)))
b}

Provalo online!

C # (compilatore interattivo Visual C #) , 242 byte

a=>{int m=1<<31,n=~m;void g(int w,int x,int y,int z){for(int i=4,t,c,d,e;i-->0;)try{t=a[c=i<1?w-1:i<2?w+1:w,d=i>2?x-1:i>1?x+1:x];n=t==0&z<n?z:n;a[c,d]=m;e=y+t<2?2-y-t:0;if(t!=m)g(c,d,y+t+e,z+e);a[c,d]=t;}catch{}}a[0,0]=m;g(0,0,2,2);return n;}

Provalo online!

//a: input matrix
a=>{
  // m: marker for used cells
  // n: result, initialized to a huge value
  int m=1<<31,n=~m;
  // recursive function
  // w: 1st dim coordinate
  // x: 2nd dim coordinate
  // y: current charge level
  // z: initial charge for current path
  void g(int w,int x,int y,int z){
    // i: loop variable
    // t: temp holds overwritten value
    // c: adjacent 1st dim coordinate
    // d: adjacent 2nd dim coordinate
    // e: delta charge needed
    for(int i=4,t,c,d,e;i-->0;)
      // avoid index out of range errors
      // by using try/catch
      try{
        // determine neighbor
        // coordinates and save value
        t=a[c=i<1?w-1:i<2?w+1:w,
            d=i>2?x-1:i>1?x+1:x];
        // if we have found a 0, check if
        // initial charge is lower than the
        // lowest so far. save it if it is.
        n=t==0&z<n?z:n;
        // mark current cell used
        a[c,d]=m;
        // determine if we need to
        // increase the initial charge
        e=y+t<2?2-y-t:0;
        // make recursive call if current
        // cell was not previously in use
        if(t!=m)g(c,d,y+t+e,z+e);
        // restore current cell value
        a[c,d]=t;
      }catch{}
  }
  // mark starting cell used
  a[0,0]=m;
  // start the recursive function
  g(0,0,2,2);
  // return the result to the caller
  return n;
}