^{Üniversite Kod Yarışması Yarışmamın izniyle Alınan Zorluk}

---

Cep telefonlarına olan bağımlılığımız, onları her gece maksimum pil seviyesine kadar şarj etmemizi sağlar, bu nedenle ertesi günün ortasında gücün bitmesi riskiyle karşı karşıya kalmayız. Gün boyunca ücretsiz bir çıkış gördüklerinde, olabilecekleri ücretlendiren insanlar bile var.

Ben onlardan biriyim.

Yıllar boyunca, pili her gece maksimum şarj etmemek için tekniğimi geliştirdim. Mükemmel bilinen tekrarlayan rutinlerimle, günün hangi saatlerinde bu kısmi şarjları yapabileceğime (ve seviyenin kaç birim artacağına) ve her şarj arasındaki pil seviyesini neyin düşürdüğüne açıkım. Bu verilerle her gece, ertesi gün evden ayrılmak zorunda olduğum minimum pil seviyesini hesaplıyorum, böylece asla iki birimin kendi empoze ettiğim eşiğinin altına düşmüyor.

Henüz uzmanlaşmamış olduğum şey, yerleşik rutinden ayrıldığımda ve aynı şeyleri yapmak için birkaç alternatifim olduğunda aynı hesaplamadır. Örneğin, farklı yollarla gelebileceğim başka bir şehre giderken olduğum günlerde olur.

Soruna ilk yaklaşımımda, sol üst köşeden sağ alt köşeye bir "satranç tahtası" etrafında hareket etmek istediğimi varsayıyorum. Her bir "hücrede" cep telefonunu belirli bir miktarda şarj edebilirim veya yükleyemiyorum ve yük seviyesi düşüyor.

Meydan okuma

Bir FxC tamsayı matrisi göz önüne alındığında, yük seviyesi 2 birimin altına düşmeden sol üst köşeden sağ alt tarafa gitmem gereken minimum pil seviyesi miktarını çıktı.

Matriste, pozitif bir sayı yolumu izlemeye devam etmek zorunda kalmadan önce cep telefonumu ne kadar şarj edebileceğimi gösterirken, negatif bir sayı çıkış olmadığını ve cep telefonunun pilinin şarj seviyesini bu miktar kadar düşürdüğünü gösterir. Kaynak ve hedef hücrelerdeki (sol üst ve sağ alt köşe) miktarların her zaman 0 olması ve değerlerin geri kalanının (mutlak değer) 100'ü geçmemesi garanti edilir.

Verilen Örnek :

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

Daha az bataryaya ihtiyacım olan yol:

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

Ve ihtiyacım olan minimum pil seviyesi miktarı 4

notlar

• Başlangıç ​​her zaman sol üst köşe olacaktır
• Sonu daima sağ alt köşede olacak
• Daha önce geçmiş olduğunuz bir hücreye gidemezsiniz. Örnek: (0,1) konumuna geldiğinizde, başlangıç ​​noktasına (0,0) gidemezsiniz
• Pil seviyeniz (herhangi bir nedenle) 2 altına düşemez
• Her zaman bir başlangıç ​​ve bir son olacağını varsayabilirsiniz.
• Gerekirse 1 boyutlu dizileri çok boyutlu olarak alabilirsiniz [1,2,3] == [[1,2,3]]
• Birden fazla doğru (minimum gerekli şarj) yol olabilir
• Amacınız rotayı değil, yalnızca gereken en düşük başlangıç ​​pil seviyesini sağlamaktır
• Yalnızca dikey ve yatay olarak gidebilirsiniz (çapraz olarak değil)

Test Durumları

[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 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

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 , 208202 bayt

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

Çevrimiçi deneyin!

---

Python 2 , 217221 bayt

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)

Çevrimiçi deneyin!

R , 224 220 217 213 210 bayt

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}

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 242 bayt

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

Çevrimiçi deneyin!

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