^{Thử thách được thực hiện với sự cho phép từ Cuộc thi Thử thách Mã trường Đại học của tôi}

---

Sự phụ thuộc của chúng ta vào điện thoại di động khiến chúng ta sạc pin mỗi đêm cho đến mức tối đa của pin, vì vậy chúng ta không có nguy cơ hết điện vào giữa ngày hôm sau. Thậm chí có những người, khi họ nhìn thấy một cửa hàng miễn phí trong ngày, đã đặt nó để tính phí cho những gì có thể xảy ra.

Tôi là một trong số họ.

Trong những năm qua, tôi đã tinh chỉnh kỹ thuật của mình để không sạc pin tối đa mỗi đêm. Với các thói quen lặp đi lặp lại hoàn toàn được biết đến của tôi, tôi rõ ràng vào thời gian nào trong ngày tôi sẽ có thể thực hiện các lần sạc một phần đó (và mức độ sẽ tăng lên bao nhiêu đơn vị) và mức nào làm giảm mức pin giữa mỗi lần sạc. Với những dữ liệu này, mỗi đêm tôi tính mức pin tối thiểu tôi phải rời khỏi nhà vào ngày hôm sau để nó không bao giờ rơi xuống dưới ngưỡng tự áp đặt của tôi là hai đơn vị.

Những gì tôi chưa quản lý để thành thạo là tính toán tương tự khi tôi rời khỏi thói quen đã thiết lập và tôi có một vài lựa chọn thay thế để làm việc. Nó xảy ra, ví dụ, vào những ngày tôi đang trên đường đến một thành phố khác mà tôi có thể đến theo những cách khác nhau.

Trong cách tiếp cận vấn đề đầu tiên của tôi, tôi giả định rằng tôi muốn di chuyển xung quanh một "bàn cờ", từ góc trên bên trái sang góc dưới bên phải. Trong mỗi "ô", tôi có thể sạc cho điện thoại di động một số tiền cụ thể hoặc tôi không thể và mức tải của nó giảm xuống.

Thử thách

Đưa ra một ma trận số nguyên FxC, xuất ra mức pin tối thiểu tôi cần để đi từ góc trên bên trái sang góc dưới bên phải mà không có mức tải nào giảm xuống dưới 2 đơn vị.

Trong ma trận, một số dương cho biết tôi có thể sạc điện thoại di động bao nhiêu trước khi tôi phải tiếp tục theo đường dẫn của mình, trong khi số âm cho biết không có ổ cắm nào và pin của điện thoại di động giảm mức sạc đó. Đảm bảo rằng số lượng trong các ô nguồn và ô đích (góc trên bên trái và góc dưới bên phải) luôn bằng 0 và phần còn lại của các giá trị (giá trị tuyệt đối) không vượt quá 100.

Ví dụ đã
cho:

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

Con đường tôi cần ít pin hơn là:

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

Và mức pin tối thiểu tôi cần là 4

Ghi chú

• Bắt đầu luôn luôn là góc trên cùng bên trái
• Kết thúc luôn luôn là góc dưới bên phải
• Bạn không thể đi đến một tế bào bạn đã vượt qua. Ví dụ: Khi ở vị trí (0,1), bạn không thể đi đến điểm ban đầu (0,0)
• Mức pin của bạn không thể (vì bất kỳ lý do nào) dưới 2
• Bạn có thể cho rằng sẽ luôn có một khởi đầu và kết thúc
• Bạn có thể lấy mảng 1 chiều dưới dạng đa chiều nếu bạn cần [1,2,3] == [[1,2,3]]
• Có thể có nhiều đường dẫn chính xác (phí tối thiểu cần thiết)
• Mục tiêu của bạn là chỉ xuất mức pin ban đầu thấp nhất cần thiết chứ không phải tuyến đường
• Bạn chỉ có thể đi theo chiều dọc và chiều ngang (không theo đường chéo)

Các trường hợp thử nghiệm

[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

Hãy thử trực tuyến!

Đã bình luận

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

Hãy thử trực tuyến!

---

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)

Hãy thử trực tuyến!

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}

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác 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;}

Hãy thử trực tuyến!

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