^{Tantangan Diambil dengan izin dari Kontes Tantangan Kode Universitas saya}

---

Ketergantungan yang kami miliki pada ponsel membuat kami mengisi ulang daya baterai setiap malam hingga tingkat maksimum baterai, sehingga kami tidak berisiko kehabisan daya pada pertengahan hari berikutnya. Bahkan ada orang yang, ketika mereka melihat outlet gratis di siang hari, menagih untuk apa yang mungkin terjadi.

Saya salah satunya.

Selama bertahun-tahun, saya telah menyempurnakan teknik saya untuk tidak mengisi baterai secara maksimal setiap malam. Dengan rutinitas berulang saya yang sangat dikenal, saya jelas pada jam berapa saya bisa melakukan pengisian ulang parsial (dan berapa unit level yang akan meningkat) dan apa yang menurunkan level baterai antara setiap pengisian. Dengan data ini, setiap malam saya menghitung tingkat baterai minimum yang harus saya tinggalkan di rumah pada hari berikutnya sehingga tidak pernah jatuh di bawah ambang batas yang saya tentukan sendiri dua unit.

Yang belum saya kuasai adalah perhitungan yang sama ketika saya meninggalkan rutinitas yang telah mapan dan saya memiliki beberapa alternatif untuk melakukan sesuatu. Itu terjadi, misalnya, pada hari-hari ketika saya sedang dalam perjalanan ke kota lain di mana saya dapat tiba dengan cara yang berbeda.

Dalam pendekatan pertama saya untuk masalah ini, saya berasumsi bahwa saya ingin bergerak di sekitar "papan catur", dari sudut kiri atas ke sudut kanan bawah. Di setiap "sel" saya dapat mengisi daya ponsel dalam jumlah tertentu, atau saya tidak bisa dan level bebannya turun.

Tantangan

Diberikan matriks bilangan bulat FxC, menampilkan jumlah level baterai minimal yang saya perlukan dari sudut kiri atas ke kanan bawah tanpa level beban turun di bawah 2 unit.

Dalam matriks, angka positif menunjukkan berapa banyak saya dapat mengisi daya ponsel saya sebelum saya harus melanjutkan mengikuti jalur saya, sementara angka negatif menunjukkan bahwa tidak ada outlet dan baterai ponsel menurunkan tingkat pengisiannya dengan jumlah itu. Dijamin bahwa jumlah di sel sumber dan tujuan (sudut kiri atas dan kanan bawah) selalu 0 dan bahwa sisa nilai (nilai absolut) tidak melebihi 100.

Contoh
Diberikan:

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

Jalur yang saya butuhkan lebih sedikit baterai adalah:

$$\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}$$

Dan jumlah level baterai minimal yang saya butuhkan adalah 4

Catatan

• Start akan selalu menjadi sudut kiri atas
• Akhir selalu menjadi sudut kanan bawah
• Anda tidak dapat pergi ke sel yang sudah Anda lewati. Contoh: Setelah berada di posisi (0,1), Anda tidak dapat pergi ke titik awal (0,0)
• Level baterai Anda tidak dapat (karena alasan apa pun) berada di bawah 2
• Anda bisa berasumsi akan selalu ada awal dan akhir
• Anda dapat menggunakan array 1 dimensi sebagai multidimensi jika perlu [1,2,3] == [[1,2,3]]
• Mungkin ada beberapa jalur yang benar (biaya minimal diperlukan)
• Tujuan Anda adalah hanya menghasilkan tingkat baterai awal terendah yang diperlukan, bukan rute
• Anda hanya dapat pergi secara vertikal dan horizontal (tidak diagonal)

Uji Kasus

[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

Cobalah online!

Berkomentar

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

Cobalah 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)

Cobalah 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}

Cobalah online!

C # (Visual C # Interactive Compiler) , 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;}

Cobalah 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;
}