Nhiệm vụ của bạn là xác định chiều dài của ngọn dài nhất xuống một "ngọn núi" được biểu thị dưới dạng một lưới có độ cao nguyên. "Hậu duệ" là bất kỳ đường dẫn nào từ một ô bắt đầu đến các ô liền kề trực giao với chiều cao giảm nghiêm ngặt (nghĩa là không chéo và không cùng chiều cao). Chẳng hạn, bạn có thể di chuyển từ 5-4-3-1 nhưng không phải 5-5-4-3-3-2-1. Độ dài của đường dẫn này là có bao nhiêu chuyển động của ô từ ô bắt đầu đến ô kết thúc, do đó 5-4-3-1 là chiều dài 3.

Bạn sẽ nhận được một lưới hình chữ nhật làm đầu vào và bạn nên xuất một số nguyên biểu thị gốc dài nhất.

Ví dụ

1 2 3 2 2
3 4 5 5 5
3 4 6 7 4
3 3 5 6 2
1 1 2 3 1

Độ dài của con đường dài nhất xuống ngọn núi này là 5. Con đường dài nhất bắt đầu từ 7, di chuyển sang trái, lên, sang trái, lên, rồi sang trái (7-6-5-4-2-1). Vì có 5 chuyển động trong đường dẫn này, nên độ dài đường dẫn là 5.

Họ có thể là tất cả cùng một số.

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

Vì bản đồ chiều cao này là bằng phẳng, gốc dài nhất là 0. (không phải 19, vì trình tự đường dẫn phải được giảm dần)

Bản đồ chiều cao có thể được tạo thành từ số lớn hơn số có một chữ số.

10 12 13 14 15 15
17 14 15 15 15 16
18 20 21 15 15 15
21 14 10 11 11 15
15 15 15 15 15 15

Con đường dài nhất ở đây có chiều dài 6. (21, 20, 18, 17, 14, 12, 10)

... Và thậm chí số lượng lớn hơn cũng tốt.

949858 789874  57848  43758 387348
  5848 454115   4548 448545 216464
188452 484126 484216 786654 145451
189465 474566 156665 132645 456651
985464  94849 151654 151648 484364

Con cháu dài nhất ở đây có chiều dài 7. (786654, 484216, 484126, 474566, 156665, 151654, 151648, 132645)

Quy tắc và ghi chú

• Lưới có thể được thực hiện trong bất kỳ định dạng thuận tiện. Chỉ định định dạng của bạn trong câu trả lời của bạn.
• Bạn có thể giả sử bản đồ chiều cao là hình chữ nhật hoàn hảo, không trống và chỉ chứa các số nguyên dương trong phạm vi số nguyên 32 bit đã ký.
• Con đường đi xuống dài nhất có thể bắt đầu và kết thúc ở bất cứ đâu trên lưới.
• Bạn không cần phải mô tả con đường đi xuống dài nhất theo bất kỳ cách nào. Chỉ cần chiều dài của nó là cần thiết.
• Mã ngắn nhất sẽ thắng

JavaScript (ES7),  106 103 102  98 byte

f=(m,n=b=-1,x,y,p)=>m.map((r,Y)=>r.map((v,X)=>(x-X)**2+(y-Y)**2-1|v/p?b=n<b?b:n:f(m,n+1,X,Y,v)))|b

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

Đã bình luận

f = (                        // f = recursive function taking:
  m,                         //   m[]  = input matrix
  n = b = -1,                //   n    = length of the current path; b = best length so far
  x, y,                      //   x, y = coordinates of the previous cell
  p                          //   p    = value of the previous cell
) =>                         //
  m.map((r, Y) =>            // for each row r[] at position Y in m[]:
    r.map((v, X) =>          //   for each value v at position X in r[]:
      (x - X) ** 2 +         //     compute the squared Euclidean distance
      (y - Y) ** 2           //     between (x, y) and (X, Y)
      - 1                    //     if A) the above result is not equal to 1
      | v / p ?              //     or B) v is greater than or equal to p:
        b = n < b ? b : n    //       end of path: update b to n if n >= b
      :                      //     else:
        f(m, n + 1, X, Y, v) //       do a recursive call
    )                        //   end of inner map()
  ) | b                      // end of outer map(); return b

Làm sao?

Trong lần lặp đầu tiên, , và đều không xác định và cả hai bài kiểm tra ( A và B trong các bình luận) đều đánh giá NaN , điều này kích hoạt cuộc gọi đệ quy. Do đó, tất cả các ô được coi là điểm bắt đầu có thể của đường dẫn.$x$$y$$p$

Thạch ,  23 21  20 byte

-2 cảm ơn Erik the Outgolfer

ŒỤŒPạƝ§ỊẠƲƇœị⁸QƑƇṪL’

Hãy thử trực tuyến! (cách quá không hiệu quả cho các ví dụ - đường dẫn ở đâyđược mang lại95 94 93 83 77 40 10như vậy6)

Làm sao?

ŒỤŒPạƝ§ỊẠƲƇœị⁸QƑƇṪL’ - Link: list of lists of integers, M
ŒỤ                   - multi-dimensional indices sorted by values
  ŒP                 - power-set
          Ƈ          - filter, keep those for which:
         Ʋ           -   last four links as a monad:
     Ɲ               -     for each pair of neighbours:
    ạ                -       absolute difference
      §              -     sum each
       Ị             -     insignificant?
        Ạ            -     all?
           œị        - multi-dimensional index into:
             ⁸       -   chain's left argument, M
                Ƈ    - filter, keep only those:
               Ƒ     -   unaffected by?:
              Q      -     de-duplicate
                 Ṫ   - tail
                  L  - length
                   ’ - decrement

Python 2, 150 147 140 136 134 132 125 123 120 byte

l=lambda g,i,j:max(0<g.get(t)<g[i,j]and-~l(g,*t)for d in(-1,1)for t in((i+d,j),(i,j+d)))
lambda g:max(l(g,*t)for t in g)

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

Đưa đầu vào dưới dạng từ điển (x, y): value.

-7 byte nhờ wizzwizz4, -2 byte nhờ Jonathan Allen, -2 byte nhờ BMO

Thay thế, 123 121 byte

l=lambda i,j:max(0<g.get(t)<g[i,j]and-~l(*t)for d in(-1,1)for t in((i+d,j),(i,j+d)))
g=input();print max(l(*t)for t in g)

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

Về cơ bản là cùng một giải pháp, chỉ với lambda cuối cùng được thay thế bằng một chương trình thực tế. Cá nhân tôi thích cái đầu tiên tốt hơn, nhưng cái này đến gần bằng số byte bằng cách cho phép gđược sử dụng như một biến toàn cục.

Sạch , 211 207 byte

import StdEnv,Data.List
z=zipWith
$l=maximum[length k-1\\p<-permutations[(v,[x,y])\\y<-[0..]&u<-l,x<-[0..]&v<-u],(k,[m:n])<-map unzip(subsequences p)|and[all((>)2o sum o map abs)(z(z(-))n[m:n]):z(>)k(tl k)]]

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

Một giải pháp vũ phu lấy một danh sách các danh sách số nguyên ( [[Int]]).
Trình điều khiển TIO có định dạng giống như các ví dụ thông qua STDIN.

Quá chậm để chạy bất kỳ ví dụ nào trên TIO và có lẽ cũng cục bộ, nhưng hoạt động trên lý thuyết.

Cái này làm điều tương tự nhanh hơn, có thể thực hiện 3x3 hoặc 2x4 trên TIO và 4x4 và 3x5 cục bộ.

Thụt lề:

$ l
    = maximum
        [ length k-1
        \\p <- permutations
            [ (v, [x, y])
            \\y <- [0..] & u <- l
            , x <- [0..] & v <- u
            ]
        , (k, [m: n]) <- map unzip
            (subsequences p)
        | and
            [ all
                ((>) 2 o sum o map abs)
                (zipWith (zipWith (-)) n [m:n])
                :
                zipWith (>) k (tl k)
            ]
        ]

Python 3 , 219 byte

e,m=len,enumerate
b=lambda g,x,y:[b(g,i,j)for o in[-1,1]for i,j in[(x+o,y),(x,y+o)]if e(g)>i>=0<=j<e(g[x])and g[x][y]<g[i][j]]
l=lambda t:e(t)and 1+max(map(l,t))
d=lambda g:max(l(b(g,x,y))for x,r in m(g)for y,_ in m(r))

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

Lưới được thể hiện dưới dạng danh sách các danh sách:

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

Mã không mã gốc:

def potential_neighbours(x, y):
    return [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]

def neighbours(grid, x, y):
    result = []
    for i, j in potential_neighbours(x, y):
        if 0 <= i < len(grid) and 0 <= j < len(grid[x]) and grid[x][y] < grid[i][j]:
            result += [(i, j)]
    return result

def build_tree(grid, x, y):
    return [build_tree(grid, i, j) for i, j in neighbours(grid, x, y)]

def longest_path_in_tree(tree):
    if len(tree) == 0:
        return 0
    return 1 + max(map(longest_path_in_tree, tree))

def longest_descent(grid):
    trees = [build_tree(grid, x, y) for x, row in enumerate(grid) for y, _ in enumerate(row)]
    return max(map(longest_path_in_tree, trees))

Haskell , 188 186 byte

$\texttt{-XNoMonomorphismRestriction}$

f m|c<-[0..length(m!!0)-1],r<-[0..length m-1]=h[g[(x,y)]|x<-r,y<-c,let g((x,y):p)=h[1+g(k:p)|i<-[-1,1],k@(u,v)<-[(x+i,y),(x,y+i)],u#r,v#c,m!!u!!v<m!!x!!y,not$k#p]]
(#)=elem
h=foldl max 0

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

notElem(not.).(#)$+4$

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

Giải thích & Ungolfed

Chiến lược: Thử đệ quy tất cả các đường dẫn khả thi, theo dõi các mục đã truy cập và tối đa hóa chiều dài của chúng.

elemnotElem(#)elemmaximize$0$

safeMaximum = foldl max 0

Bây giờ chúng tôi đã sẵn sàng để xác định chức năng đệ quy của mình fun :: [[Integer]] -> Integer:

fun xs
  | c <- [0..length(m!!0)-1]             -- all possible indices of xs' columns
  , r <- [0..length m-1]                 -- all possible indices of xs' rows
  = safeMaximum                          -- maximize ..
      [ g [(x,y)]                        -- .. initially we haven't visited any others
      | x <- c, y<-r                     -- .. all possible entries
-- For the purpose of golfing we define g in the list-comprehension, it takes all visited entries (p) where (x,y) is the most recent
      , let g((x,y):p) = safeMaximum     -- maximize ..
          [ 1 + g(k:p)                   -- .. recurse, adding (x,y) to the visited nodes & increment (the next path will be 1 longer)
          | i <- [-1,1]                  -- offsets [left/up,right/down]
          , k@(u,v) <-[(x+i,y),(x,y+i)]  -- next entry-candidate
          , u#c, v#r                     -- make sure indices are in bound ..
          , m!!u!!v < m!!x!!y            -- .. , the the path is decreasing
          , not$(u,v)#p                  -- .. and we haven't already visited that element
          ]
      ]

Con trăn 3 263 227 byte

def f(m):
 p={(x,y):[c for i in[-1,1]for c in[(x,y+i),(x+i,y)]]for x,y in m};d={c:0 for c in p if not p[c]}
 while len(p)-len(d):
  for c in p:
   for b in p[c]:
    if b in d:d[c]=max(d[b]+1,d.get(c,0))
 return max(d.values())

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

-2 byte nhờ BMO

Có lưới trong định dạng {(0, 0): 1, (1, 0): 2, ...}. Định dạng này có thể được tạo từ định dạng ví dụ bằng cách sử dụng chức năng tiện ích sau:

lambda s,e=enumerate:{(x,y):int(n)for y,l in e(s.split('\n'))for x,n in e(l.split())}