^{ความท้าทายได้รับอนุญาตจากการประกวดรหัสมหาวิทยาลัยของฉัน}

---

การพึ่งพาเราบนโทรศัพท์มือถือทำให้เราชาร์จแบตเตอรี่ทุกคืนจนถึงระดับสูงสุดของแบตเตอรี่ดังนั้นเราจึงไม่เสี่ยงต่อการเกิดไฟฟ้าดับในช่วงกลางของวันถัดไป มีแม้กระทั่งคนที่เมื่อพวกเขาเห็นร้านขายของฟรีในระหว่างวันให้นำไปเก็บค่าใช้จ่ายสำหรับสิ่งที่อาจเกิดขึ้น

ฉันเป็นหนึ่งในพวกเขา

หลายปีที่ผ่านมาฉันได้ปรับปรุงเทคนิคของฉันเพื่อไม่ให้ชาร์จแบตเตอรี่ให้สูงสุดทุกคืน ด้วยกิจวัตรซ้ำ ๆ ที่รู้จักกันอย่างสมบูรณ์แบบของฉันฉันชัดเจนในเวลาของวันที่ฉันจะสามารถทำการชาร์จบางส่วนเหล่านั้น (และจำนวนหน่วยที่จะเพิ่มระดับ) และสิ่งที่ลดระดับแบตเตอรี่ระหว่างการชาร์จแต่ละครั้ง ด้วยข้อมูลเหล่านี้ทุกคืนฉันคำนวณระดับแบตเตอรี่ขั้นต่ำที่ฉันต้องออกจากบ้านในวันถัดไปด้วยเพื่อที่ว่ามันจะไม่ต่ำกว่าเกณฑ์ที่กำหนดด้วยตนเองของฉันสองหน่วย

สิ่งที่ฉันยังไม่ได้จัดการเพื่อหลักคือการคำนวณเดียวกันเมื่อฉันออกจากรูทีนที่กำหนดและฉันมีทางเลือกมากมายที่จะทำ ตัวอย่างเช่นมันเกิดขึ้นในวันที่ฉันกำลังเดินทางไปยังเมืองอื่นที่ฉันสามารถไปถึงได้ในหลาย ๆ ทาง

ในแนวทางแรกของปัญหาฉันคาดว่าฉันต้องการย้าย "กระดานหมากรุก" จากมุมบนซ้ายไปยังมุมขวาล่าง ใน "เซลล์" แต่ละรายการฉันสามารถเรียกเก็บเงินตามจำนวนที่ระบุได้หรือไม่สามารถทำได้และระดับการโหลดลดลง

ท้าทาย

รับเมทริกซ์ FxC ของจำนวนเต็มเอาท์พุทจำนวนแบตเตอรี่ระดับต่ำสุดที่ฉันต้องไปจากมุมบนซ้ายไปที่มุมล่างขวาโดยไม่ต้องระดับโหลดเคยต่ำกว่า 2 หน่วย

ในเมทริกซ์จำนวนบวกแสดงว่าฉันสามารถชาร์จโทรศัพท์มือถือได้มากน้อยเพียงใดก่อนที่ฉันจะกลับมาทำงานต่อในเส้นทางของฉันในขณะที่ตัวเลขติดลบระบุว่าไม่มีช่องเสียบและแบตเตอรี่ของโทรศัพท์มือถือจะลดลงตามระดับนั้น มีการรับประกันว่าปริมาณในเซลล์ต้นทางและปลายทาง (มุมบนซ้ายและมุมขวาล่าง) เป็น 0 เสมอและค่าที่เหลือ (ค่าสัมบูรณ์) ไม่เกิน 100

ตัวอย่างที่
ให้ไว้:

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

เส้นทางที่ฉันต้องการแบตเตอรี่น้อยกว่าคือ:

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

และระดับแบตเตอรี่ขั้นต่ำที่ฉันต้องการคือ 4

หมายเหตุ

• จุดเริ่มต้นจะเป็นมุมบนซ้ายเสมอ
• จุดจบจะเป็นมุมล่างขวาเสมอ
• คุณไม่สามารถไปที่เซลล์ที่คุณผ่านไปแล้ว ตัวอย่าง: เมื่ออยู่ในตำแหน่ง (0,1) คุณไม่สามารถไปที่จุดเริ่มต้น (0,0)
• ระดับแบตเตอรี่ของคุณไม่สามารถ (ต่ำกว่า 2) ไม่ว่าจะด้วยเหตุผลใดก็ตาม
• คุณสามารถสมมติได้ว่าจะมีจุดเริ่มต้นและจุดสิ้นสุดเสมอ
• คุณสามารถใช้อาร์เรย์ 1 มิติเป็นหลายมิติได้หากต้องการ [1,2,3] == [[1,2,3]]
• อาจมีเส้นทางที่ถูกต้องหลายรายการ
• เป้าหมายของคุณคือส่งออกเฉพาะระดับแบตเตอรี่เริ่มต้นต่ำสุดที่ต้องการไม่ใช่เส้นทาง
• คุณสามารถไปได้ทั้งแนวตั้งและแนวนอน (ไม่ใช่แนวทแยงมุม)

กรณีทดสอบ

[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 ไบต์

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

ลองออนไลน์!

แสดงความคิดเห็น

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 ไบต์

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

ลองออนไลน์!

---

Python 2 , 217 211 ไบต์

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)

ลองออนไลน์!

R , 224 220 217 213 210 ไบต์

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}

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 242 ไบต์

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

ลองออนไลน์!

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