อนุญาตAจะเป็นmโดยnเมทริกซ์รูปสี่เหลี่ยมผืนผ้าบวกเลขที่mและnนอกจากนี้ยังมีในเชิงบวกจำนวนเต็ม

เราสนใจเส้นทาง RoD ('Right-or-Down') จากเซลล์ซ้ายบนของAไปยังเซลล์ล่างขวา; ในเส้นทาง RoD แต่ละเซลล์ที่ต่อเนื่องของเส้นทางจะเป็นเซลล์เดียวไปทางขวาหรือเซลล์เดียวลงจากเซลล์ก่อนหน้า

ด้วยเส้นทาง RoD ใด ๆ เราสามารถหาผลรวมของเซลล์ในAเส้นทางนั้น

ตัวอย่างเช่นพิจารณาเมทริกซ์ 4 คูณ 3:

[ [1, 2, 3, 4],
  [5, 1, 6, 7],
  [8, 2, 1, 1] ]

จากนั้นเราสามารถพิจารณาเส้นทาง RoD:

1 > 2   3   4
    v
5   1   6   7
    v
8   2 > 1 > 1

1+2+1+2+1+1=8ซึ่งมีผลรวมของ เป็นที่น่าสังเกตว่าเส้นทางนี้มีผลรวมน้อยที่สุดของเส้นทาง RoD ที่เป็นไปได้ทั้งหมดจากซ้ายไปขวาล่างในเมทริกซ์นั้น

ดังนั้นความท้าทายที่นำเสนอคือการให้ที่สั้นที่สุดฟังก์ชั่น / โปรแกรมในภาษาของคุณเลือกที่ผลรวมต่ำสุดเส้นทาง Rod Aจากบนซ้ายไปขวาล่างสามารถมีในเมทริกซ์ได้รับ

ช่องโหว่ที่ต้องห้ามตามปกติมีผลบังคับใช้ ข้อมูลที่คุณป้อนอาจอยู่ในรูปแบบที่สมเหตุสมผล ผลลัพธ์ของคุณจะต้องเป็นจำนวนเต็ม

นี่คือรหัสกอล์ฟ คำตอบจะได้คะแนนจากจำนวนไบต์

กรณีทดสอบ

[ [5] ] -> 5

[ [5, 2] ] -> 7

[ [5], 
  [2] ] -> 7

[ [ 9 , 1 , 12, 3 ],
  [ 12, 11, 6 , 11],
  [ 12, 9 , 2 , 11] ] -> 40

[ [ 6 , 8 , 11, 2 ],
  [ 3 , 6 , 7 , 6 ],
  [ 6 , 2 , 8 , 12] ] -> 37

[ [ 4 , 5 , 8 , 4 ],
  [ 6 , 5 , 9 , 4 ],
  [ 2 , 5 , 6 , 8 ] ] -> 31

[ [ 4 , 5 , 15, 18, 30],
  [ 26, 26, 3 , 4 , 5 ],
  [ 7 , 9 , 29, 25, 14],
  [ 16, 1 , 27, 13, 27],
  [ 23, 11, 25, 24, 12],
  [ 17, 23, 7 , 14, 5 ] ] -> 94

[ [ 10, 15, 7 , 2 , 9 ],
  [ 24, 5 , 2 , 1 , 25],
  [ 2 , 12, 14, 30, 18],
  [ 28, 4 , 12, 22, 14],
  [ 15, 21, 21, 11, 4 ],
  [ 21, 15, 21, 29, 9 ] ] -> 103

J , 42 ไบต์

v(+}.<.}:)&.>/@{.[:</.(2#v=._1+1#.$){.!._]

ลองออนไลน์!

มันทำงานอย่างไร

v(+}.<.}:)&.>/@{.[:</.(2#v=._1+1#.$){.!._]
                         v=._1+1#.$         Sum of two dimensions - 1; assign to v
                                            (v is a verb)
                      (2#          ){.!._]  Extend the given array in both dimensions
                 [:</.  Extract the antidiagonals as boxed arrays
v             @{.  Take the first `v` antidiagonals
 (       )&.>/     Reduce over unboxed items:
   }.<.}:            Given the right item R, take the minimum of R[1:] and R[:-1]
  +                  Add to the left item

ภาพประกอบ

1 2 3 4  Input array, dimensions = 3,4
5 1 6 7
8 2 1 1

1 2 3 4 _ _  Extended to 6,6 with filler _ (infinity)
5 1 6 7 _ _
8 2 1 1 _ _
_ _ _ _ _ _
_ _ _ _ _ _
_ _ _ _ _ _

1            Diagonalize and take first 6 rows
5 2
8 1 3
_ 2 6 4
_ _ 1 7 _
_ _ _ 1 _ _

Reduction: left+min(right[1:], right[:-1])
1                                          1  => 8
5 2                               5  2  => 10 7
8 1 3                   8 1 3  => 12 5 11
_ 2 6 4      _ 2 6 4 => _ 4 8 12
_ _ 1 7 _ => _ _ 2 8 _
_ _ _ 1 _ _

JavaScript (ES6), 78 77 76 ไบต์

m=>(M=g=s=>(v=(m[y]||0)[x])?g(s+=v,y++)|g(s,x++,y--)*x--|M<s?M:M=s:0)(x=y=0)

ลองออนไลน์!

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

m => (                      // m[] = input matrix
  M =                       // initialize the minimum M to a non-numeric value
  g = s =>                  // g = recursive function taking the current sum s
    (v = (m[y] || 0)[x]) ?  //   if the current cell v is defined:
      g(s += v, y++) |      //     do a recursive call at (x, y + 1)
      g(s, x++, y--) * x--  //     do a recursive call at (x + 1, y)
      |                     //     if at least one call did not return 0 (which means
                            //     that we haven't reached the bottom-right corner)
      M < s ?               //     or M is less than s (false if M is still non-numeric):
        M                   //       return M unchanged
      :                     //     else:
        M = s               //       update M to s, and return this new value
    :                       //   else (we're outside the bounds of the matrix):
      0                     //     return 0
)(x = y = 0)                // initial call to g with s = x = y = 0

Haskell, 63 57 ไบต์

f x@((a:_:_):c:d)=a+min(f$c:d)(f$tail<$>x)
f x=sum$id=<<x

ลองออนไลน์!

f x@((a:_:_):c:d)=           -- if it's at least a 2x2 matrix
   a+min                     -- add the top left element to the minimum of the
                             -- path costs of
        f$c:d                --   the matrix with the first row dropped and
        f$tail<$>x           --   the matrix with the first column dropped
f x=                         -- else, i.e. a 1xm or nx1 matrix, i.e. a vector
    sum$id=<<x               -- return the sum of this vector

MATL , 38 36 30 29 ไบต์

ขอบคุณ@Giuseppe ที่ชี้ให้เห็นข้อผิดพลาดตอนนี้แก้ไข

lyZyqsG&nghZ^Yc!tsGz=Z)Ys)sX<

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

l        % Push 1
y        % Input, implicit. Duplicate from below. Pushes the input below
         % the current 1, and a copy of the input on top
Zy       % Size of input. Gives [m, n]
qs       % Subtract 1 element-wise, sum. Gives m+n-2
G        % Push input again
&n       % Push size as two separate numbers. Gives m, n
gh       % Transform n into 1 and concatenate horizontally. Gives [m, 1]
Z^       % Cartesian power of [m, 1] raised to m+n-2. This produces the
         % Cartesian tuples as row of a matrix. A typical tuple may be
         % [1, m, 1, m, m]. This will define a path along the matrix in
         % linear, column-wise indexing (down, then across). So 1 means
         % move 1 step down, and m means move m steps "down", which is
         % actually 1 step to the right
Yc       % Concatenate strcat-like. This prepends the 1 that is at the
         % bottom of the stack to each row
!        % Transpose. Each tuple (extended with initial 1) is now a column
!ts      % Duplicate, sum of each column
Gz       % Number of nonzeros of input. Gives m*n-1
=Z)      % Keep only columns that sum m*n. That means that, starting from
Ys       % Cumulative sum of each column. This defines the path
)        % Index: pick entries specified by the path
s        % Sum of each column
X<       % Minimum
         % Display, implicit

R , 90 ไบต์

function(m){l=sum(m|1)
if(l>1)for(i in 2:l)m[i]=m[i]+min(m[i-1],m[max(0,i-nrow(m))])
m[l]}

ลองออนไลน์!

วิธีการแก้ปัญหาไร้เดียงสา: วนซ้ำผ่านอาร์เรย์ (ลงคอลัมน์) แทนที่แต่ละรายการด้วยผลรวมของตัวมันเองและค่าต่ำสุดของเพื่อนบ้านด้านบนและด้านซ้ายหากมีอยู่แล้วส่งคืนรายการสุดท้าย

Perl 6 , 57 54 ไบต์

my&f={|.flat&&.[0;0]+min (f(.[1..*]),f $_>>[1..*])||0}

ลองออนไลน์!

คำอธิบาย

my&f={                                               }  # Function f
      |.flat&&  # Return empty slip if matrix is empty
              .[0;0]+  # Value at (0,0) plus
                     min  # Minimum of
                          f(.[1..*])   # Rows 1..*
                                     f $_>>[1..*]  # Columns 1..*
                         (          ,            )||0  # Or 0 if empty

Röda , 100 89 bytes

f A{g={|x,y|{g(x-1,y)if[x>0];g(x,y-1)if[y>0];[0]if[x+y=0]}|min|[A[x][y]+_]}g#A-1,#A[0]-1}

ลองออนไลน์!

-9 ไบต์ขอบคุณCows นักต้มตุ๋น

Python 3 , 108 ไบต์

def f(A,m,n,i=0,j=0):r=i+1<m and f(A,m,n,i+1,j);d=j+1<n and f(A,m,n,i,j+1);return A[i][j]+min(r or d,d or r)

ลองออนไลน์!

Ungolfed

def f(A, m, n, i=0, j=0):
    right = i + 1 < m and f(A, m, n, i + 1, j)
    down  = j + 1 < n and f(A, m, n, i, j + 1)
    return A[i][j] + min(right or down, down or right)

เยลลี่ 21 ไบต์

ZI_.ỊȦ
ŒJŒPÇƇLÐṀœị⁸§Ṃ

ลองออนไลน์!

อย่างไร?

ZI_.ỊȦ - Link 1: isDownRight?: List of 2d indices (limited to having no repetitions)
Z      - transpose
 I     - deltas (vectorises)
  _.   - subtract 1/2 (vectorises)
    Ị  - insignificant? (effectively _.Ị here is like "v in {0,1}? 1 : 0")
     Ȧ - any & all (0 if a 0 is present when flattened, else 1)

ŒJŒPÇƇLÐṀœị⁸§Ṃ - Main Link: list of lists of integers, A
ŒJ             - multi-dimensional indices of A
  ŒP           - power-set
     Ƈ         - filter keep only those truthy by:
    Ç          -   last link as a monad
       ÐṀ      - filter keep only those maximal by:
      L        -   length
           ⁸   - chain's left argument, A
         œị    - multi-dimensional index into (vectorises)
            §  - sum each
             Ṃ - minimum

APL (Dyalog Classic) , 37 32 ไบต์

{⊃⌽,9e9(⊢⌊⍵+(2⊣⌿⍪)⌊2⊣/,)⍣≡+⍀+\⍵}

ลองออนไลน์!

+⍀+\ ผลรวมบางส่วนในแนวนอนและแนวตั้ง - ให้ค่าเริ่มต้นประเมินค่าสูงไปสำหรับเส้นทางไปยังแต่ละตาราง

9e9(... )⍣≡ใช้ "... " จนกว่าการบรรจบกันในแต่ละขั้นตอนจะมีจำนวนมาก (9 × 10 ⁹⁾ ) เป็นอาร์กิวเมนต์ที่เหลือ

, เพิ่ม 9e9 -s ทางด้านซ้ายของประมาณการปัจจุบัน

2⊣/ ใช้เซลล์แรกจากเซลล์คู่ที่ต่อเนื่องกันโดยปล่อยคอลัมน์สุดท้ายอย่างมีประสิทธิภาพ

2⊣⌿⍪ สิ่งเดียวกันในแนวตั้ง - ใส่ 9e9บนและวางแถวสุดท้าย

(2⊣⌿⍪) ⌊ 2⊣/, น้อย

⍵+ เพิ่มเมทริกซ์ดั้งเดิม

⊢⌊ พยายามปรับปรุงประมาณการปัจจุบันด้วยวิธีนั้น

⊃⌽, เซลล์ล่างขวา

ถ่าน 46 ไบต์

≔Ｅ§θ⁰∧κΣ§θ⁰ηＦθ«≔§η⁰ζＦＬι«≔⁺⌊⟦§ηκζ⟧§ικζ§≔ηκζ»»Ｉζ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย: นี่อาจจะสั้นกว่านี้หากมีข้อโต้แย้งสามข้อreduceใน Charcoal

≔Ｅ§θ⁰∧κΣ§θ⁰η

เติมอาร์เรย์การทำงานไว้ล่วงหน้าด้วยค่าขนาดใหญ่ยกเว้นค่าแรกซึ่งเป็นศูนย์

Ｆθ«

วนซ้ำแถวของอินพุต

≔§η⁰ζ

เริ่มต้นผลรวมปัจจุบันกับองค์ประกอบแรกของอาร์เรย์ทำงาน

ＦＬι«

วนซ้ำไปตามคอลัมน์ของอินพุต

≔⁺⌊⟦§ηκζ⟧§ικζ

ใช้ค่าต่ำสุดของผลรวมปัจจุบันและองค์ประกอบปัจจุบันของอาร์เรย์ทำงานและเพิ่มองค์ประกอบปัจจุบันของอินพุตเพื่อให้ผลรวมปัจจุบันใหม่

§≔ηκζ

และเก็บข้อมูลนั้นไว้ในอาร์เรย์การทำงานพร้อมสำหรับแถวถัดไป

»»Ｉζ

พิมพ์ผลรวมเมื่อดำเนินการอินพุตเสร็จสมบูรณ์

เยลลี่ขนาด 17 ไบต์

XL,1ẋLḊŒ!1;ⱮÄịẎ§Ṃ

ลองออนไลน์!

Java 8, 197 193 ไบต์

m->{int r=m.length-1,c=m[0].length-1,i=r,a;for(;i-->0;m[i][c]+=m[i+1][c]);for(i=c;i-->0;m[r][i]+=m[r][i+1]);for(i=r*c;i-->0;r=m[i/c][i%c+1],m[i/c][i%c]+=a<r?a:r)a=m[i/c+1][i%c];return m[0][0];}

-4 ไบต์ขอบคุณ@ceilingcat @ceilingcat

ลองออนไลน์

คำอธิบายทั่วไป:

จริง ๆ แล้วฉันทำความท้าทายนี้ประมาณหนึ่งปีที่ผ่านมากับProject Euler # 81ยกเว้นว่าถูก จำกัด เฉพาะเมทริกซ์จตุรัสแทนที่จะเป็นNโดยMเมทริกซ์ ดังนั้นฉันจึงปรับเปลี่ยนรหัสของฉันเล็กน้อยจากหลังไปยังบัญชีสำหรับสิ่งนั้น

ฉันรวมผลรวมแถวล่างและคอลัมน์ขวาสุดจากเซลล์สุดท้ายย้อนหลัง ดังนั้นลองใช้ตัวอย่างเมทริกซ์ของความท้าทาย:

1, 2, 3, 4
5, 1, 6, 7
8, 2, 1, 1

เซลล์สุดท้ายยังคงเหมือนเดิม เซลล์สุดท้ายที่สองของแถวด้านล่างจะกลายเป็นผลรวม: และเช่นเดียวกันสำหรับเซลล์สุดท้ายที่สองของคอลัมน์ขวาสุด:1+1 = 2 1+7 = 8เราทำต่อไปดังนั้นตอนนี้เมทริกซ์จะเป็นดังนี้:

 1,  2,  3, 12
 5,  1,  6,  8
12,  4,  2,  1

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

ดังนั้นเซลล์ที่มีจำนวน6จะกลายเป็น8เพราะ2ด้านล่างมันมีขนาดเล็กกว่า8ด้านขวาของมัน จากนั้นเราดูที่1ถัดไปของมัน (ทางซ้าย) และทำเช่นเดียวกัน นั่น1กลายเป็น5เพราะ4ด้านล่างมันเล็กกว่า8ด้านขวาของมัน

ดังนั้นหลังจากเราทำกับแถวที่สองถึงแถวสุดท้ายแล้วเมทริกซ์จะเป็นดังนี้:

 1,  2,  3, 12
10,  5,  8,  8
12,  4,  2,  1

และเรายังคงทำเช่นนี้กับเมทริกซ์ทั้งหมด:

 8,  7, 11, 12
10,  5,  8,  8
12,  4,  2,  1

ตอนนี้เซลล์แรกสุดจะมีผลลัพธ์ของเราซึ่งก็คือ 8ในกรณีนี้

คำอธิบายรหัส:

m->{                    // Method with integer-matrix input and integer return-type
  int r=m.length-1,     //  Amount of rows minus 1
      c=m[0].length-1,  //  Amount of columns minus 1
      i=r,              //  Index integer
      a;                //  Temp integer
  for(;i-->0;m[i][c]+=m[i+1][c]);
                        //  Calculate the suffix-sums for the rightmost column
  for(i=c;i-->0;m[r][i]+=m[r][i+1]);
                        //  Calculate the suffix-sums for the bottom row
  for(i=r*c;i-->0       //  Loop over the rows and columns backwards
      ;                 //     After every iteration:
       r=m[i/c][i%c+1], //      Set `r` to the value left of the current cell
       m[i/c][i%c]+=a<r?//      If `a` is smaller than `r`:
                 a      //       Add `a` to the current cell
                :       //      Else:
                 r)     //       Add `r` to the current cell
      a=m[i/c+1][i%c];  //    Set `a` to the value below the current cell
  return m[0][0];}      //  Return the value in the cell at index {0,0} as result

Brachylog , 26 25 ไบต์

∧≜.&{~g~g|hhX&{b|bᵐ}↰+↙X}

ลองออนไลน์!

-1 ไบต์เนื่องจากการตัดไม่จำเป็น - คุณไม่สามารถนำส่วนหัวของรายการที่ว่างเปล่า

อาจมีห้องมากมายสำหรับเล่นกอล์ฟ แต่ฉันต้องนอน

วิธีการนี้จะพยายามทดลองทุกค่าสำหรับผลลัพธ์ให้น้อยที่สุดก่อน ( ∧≜.) จนสามารถพบพา ธ ( b|bᵐ) ที่มุมล่างขวา ( ~g~g) ซึ่งสร้างผลรวมนั้น ( hhX&...↰+↙X)

Java (JDK) , 223 ไบต์

รับอินพุตเป็นรายการ 2D ของ ints

เพิ่มเติม 19 ไบต์สำหรับการimport java.util.*;รวม

import java.util.*;m->{var l=m.get(0);int s=m.size(),c=l.size(),x=-1>>>1,a=l.get(0);return s*c<2?a:Math.min(s>1?n.n(new Vector(m.subList(1,s))):x,c>1?n.n(new Vector<>(m){{replaceAll(l->new Vector(l.subList(1,c)));}}):x)+a;}

ลองออนไลน์!

มันทำงานอย่างไร

import java.util.*;                                     // Import needed for Vector class
m->{                                                    // Lambda that takes a 2D list of integers
    var r=m.get(0);                                     // Store first row in variable
    int h=m.size(),                                     // Store number of rows
        w=r.size(),                                     // Store number of columns
        x=-1>>>1,                                       // Store int max
        a=r.get(0);                                     // Store the current cell value
    return h*w<2?a:                                     // If matrix is single cell return value
        Math.min(                                       // Otherwise return the minimum of...

            h>1?                                        // If height is more than 1
                n.n(                                    // Recursively call this function with 
                    new Vector(m.subList(1,h))):        // a new matrix, without the top row
                x,                                      // Otherwise use int max as there is no row below this

            w>1?                                        // If width is more than 1
                n.n(new Vector<>(m){{                   // Recursively call this function with a new matrix             
                    replaceAll(                         // where all columns have been replaced with 
                        l->new Vector(l.subList(1,w))   // cloned lists without the leftmost column
                    );
                }}):                                    // Otherwise use int max as there is
                x                                       // no column to the right of this
        )+a;                                            // Add the current cell value to the result before returning
}

Python 2 , 86 ไบต์

f=lambda A:len(A)>1<len(A[0])and A[0][0]+min(f(zip(*A)[1:]),f(A[1:]))or sum(sum(A,()))

ลองออนไลน์!

ถ้าBเป็น transpose ของแล้วนิยามปัญหาก็หมายความว่าAf(A)==f(B)

A[1:]อาร์เรย์Aหายไปแถวบนหรือไม่ zip(*A[1:])เป็นอาร์เรย์ที่Aขาดหายไปคอลัมน์ซ้ายสุดและย้าย คือผลรวมขององค์ประกอบทั้งหมดในsum(sum(A,()))A

หากAมีเพียงคอลัมน์เดียวหรือแถวเดียวมีเพียงเส้นทางเดียวเพื่อให้fผลตอบแทนรวมขององค์ประกอบทั้งหมดในA; มิฉะนั้นเรา recurse และกลับผลรวมของA[0][0]+ ขนาดเล็กของfการAขาดหายไปแถวด้านบนและfของAที่หายไปช่องด้านซ้ายมือ