741 Вишневый сбор

Название: N х N сетки (Grid) представляет собой вишню, каждая сетка представлена одним из трех чисел:
    0 указывает на то, что сетка пуст, так что вы можете пройти через него.
    1 указывает на то, что сетка заполнена с вишней, то вы можете выбрать вишню через него.
    -1 указывает на то, что сетка имеет шипы, блокирующие ваш путь.
Ваша задача в соответствии со следующими правилами, насколько это возможно подобрать Вишни:
    Начиная с позиции (0, 0), и , наконец , до (N-1, N-1 ), или может идти только вниз вправо, и только через активную сеть (то есть, решетка может проходить только через значение 0 или 1),
    при достижении (N-1, N-1 ) после того, как вы идете продолжать, пока он не вернется в (0, 0), только может пойти вверх или влево, и может быть эффективным только через решетку,
    когда вы идете через решетку и решетка содержит вишню, вы выбираете вишни и сетка становится пустым (значение становится равным 0),
    если не может пройти через путь не существует между (0, 0) и (N-1, N-1 ), то есть не выбрать , чтобы быть вишни.

Источник: https://leetcode-cn.com/problems/cherry-pickup/

Закон один: собственный код ошибки

Идея: полностью проанализировать смысл проблем, исходная задача не стремится по максимуму два пути следующего кода первым искать максимальный путь и направление каждой записи занимает максимальный путь опять же в зависимости от направления максимума записанного. удалить путь, а затем искать второй максимальный путь

от Typing Import List
 класса Solution:
     DEF cherryPickup (Self, Сетка: Список [Список [INT]]) -> INT:
         # требуется количество строк и столбцов 
        R & Л.Т., С = LEN (Сетка), Len (Grid [0])
         # второй номер присвоен. 1 
        Сетка [0] [0] = (Сетка [0] [0], Сетка [0] [0], 0)
         # обработки первой строки и первого столбца, если есть -1 решетки, то последние установлены на -1 
        # и запись пути, если он идет слева обозначаются как 1, от верхней части к Упомянутому -1 
        # каждому кортежу первого записывающего элементу и второму запись текущего исходного значения, третий путь записи 
        для ввода в диапазоне (1. , R & л):
             IF сетки [I] , [0] = -1! : 
                Сетка [I] , [0]= (Сетка [I] [0] + сетка [I-1] [0] [0], сетка [I] [0], -1 )
                 продолжают 
            еще :
                 для J в диапазоне (I, R): 
                    сетки [я ] [0] = (-1, -1, -1 )
             перерыв 
        для I в диапазоне (1 , в):
             если сетка [0] [I] = -1! : 
                сетки [0] [I] = (сетка [ 0] [I] + сетки [0] [I-1] [0], сетки [0] [I], 1 )
                 продолжают 
            еще :
                 для J в диапазоне (я, с): 
                    сетки [0] [I] = (-1, -1,1)
             BREAK 
        # найти максимальное значение первого пути, путь должен быть записан 
        для P в диапазоне (1. , R & Lt):
             для Q в диапазоне (1. , C):
                 ЕСЛИ Сетка [P] [Q] == -1 : 
                    Сетка [Р] [Q] = (-1, -1,1 )
                 # сначала определяет , является ли линия сетки внутри шипов 
                Элиф [Q] [0] <сетке [1-Р.] 0:
                     # если предыдущий также имеет шипы , и назначение поставил -1 
                    ПЧ сетки [P] [Q- 1.] [0] < 0: 
                        Сетка [P] [Q] = (-1, -1,1 )
                     остальное :
                        Сетка [P] [Q] = (Сетка [P] [Q-. 1] [0] + Сетка [P] [Q], Сетка [P] [Q] ,. 1 )
                 # на линии этот раз без сетки шипы 
                Элиф Сетка [P] [Q- 1.] [0] < 0:
                     # сверху и слева от решетки и имеет шипы и множество -1 
                    сетки [P] [Q] = (-1, -1,1 )
                 # это когда без шипов 
                Элиф сетки [P] [Q- 1.] [0]> = Сетка [Р- 1. ] [Q] [0]:
                     # влево большой 
                    сетки [P] [Q] = (сетка [р] [ . Q- 1] [0] + Сетка [P] [Q], Сетка [P] [Q] ,. 1 )
                 остальное :
                     # большой верхней части 
                    сетки [P] [Q] = (сетка [р-1] [Q] [0] + сетка [р] [Q], сетка [р] [Q], -1) 
        Ответ1 = Сетка [-1] [-. 1 ] [0]
         Печать ( ' KK ' , Ответ1)
         Печать (Сетка)
         # , чтобы удалить первый путь , пройденный маркировочный знак , производится максимум, то есть, вишня установить 0 
        м , 1-н-R & л = ,. 1-с. это время не сетки [0] [0] [2 ]: 
            Вход = Сетка [м] [н-] [2 ]
             # Описание больше 0 , если идет слева, колонка будет снижена . 1 ЕСЛИ Знак> 0: 
                n- - = 1. 
                Сетка [м] [п] = (0,0, Сетка [м] [н-] [2 ])
             # в противном случае от верхней стороны к ELIF Вход < 0: 
                м . - 1 =
         
            
            
                Сетка [м] [п] = (0,0, Сетка [м] [н-] [2 ])
             # в противном случае равен 0, что указывает верхний левый угол является 
            остальное : 
                Сетка [0] [0] = (0,0, 1 )
         # последний сетки устанавливается на 0 
        сетке [-1] [- 1] = (0,0,0)
         печати (Сетка)
         # затем перемещаться слева направо вниз снова 
        для P в диапазоне (1 , R & л) :
             для Q в диапазоне (1. , C):
                 если сетевой [P] [Q] [1.] == -1 :
                     Pass 
                # если предыдущее , как шипы, шипы на линии не будет, или если условие суждения время имеет пройти 
                ЭлифСетка [P] [Q- 1.] == -1 [1.] : 
                    Сетка [P] [Q] = (Сетка [. 1-Р] [Q] [0] + Сетка [P] [Q] [. 1], Сетка [P] [Q] [. 1], Сетка [P] [Q] [2 ])
                 Элиф сетки [. 1-Р] [Q] [1] . == -1 : 
                    Сетка [P] [Q] = (Сетка [Р] [Q- 1.] [0] + Сетка [P] [Q] [1.], Сетка [P] [Q] [1.], Сетка [P] [Q] [2 ])
                 остальное :
                     # Обратите внимание , что должно быть в квадратных скобках , чтобы обеспечить на самом внешнем является кортежем, в противном случае это INT, 
                    Сетка [P] [Q] = (макс (Сетка [Р-. 1] [Q] [0], Сетка [P] [Q-. 1] [0]) + Сетка [P] [Q] [. 1], Сетка [P] [Q] [. 1], Сетка [P] [Q] [2 ])
         возвращают Ответ1 сетки + [-1] [-. 1] [0]
Просмотр кода

Акт II: Официальный метод динамического программирования

Мышление: Типичный дп одномерные задачи, потому что есть три переменные, наиболее гениальная обработка место является граничным значением, возвращаемого значение конечного конца дерева только две ситуаций, одна -INF, достигая другие (N-1, после того, как N-1). в незавершенной обходе четыре ветви, и возвращает максимальную запись четыре ветви.

Класс Решение (Объект):
     DEF cherryPickup (Self, Сетка): 
        N = Len (Сетка)
         # . для записи входных и выходных значений функции резервной 
        памятки = [[[Ни] * N для _1 в диапазоне (N)] , для _2 в диапазоне (N)]
         , DEF DP (R1, C1, C2): 
            R2 = R1 + С1 - С2
             # если вы столкнулись ежевику, или выйти за пределы края, отрицательная бесконечность, возвращается, непосредственно соответствует концу этот путь 
            # здесь на самом деле круг вокруг края шипов 
            ЕСЛИ (R1 == N или N == R2 или Н == С1 или N == C2 или
                    Сетка [С1] [С1] == -1 или сетки [R2] [C2] == -1 ):
                 вернуть поплавок ( ' -INF ' )
             # Если точка сетки до конца, а другой конец должен также решетка, а возвращаемое значение. 
            # без этого условия, путь вернется , когда (N, N-1) или (N-1, N) возвращает «-inf», будет возвращать -inf окончательное дп , 
            # потому , что -INF номера добавления каких - либо -Inf, любое условие , которое имеет конец пути являются (N-1, N-1 ) в этой точке. 
            Элиф R1 == == N-C1 1. :
                 # здесь будет выходные четыре значения, из - за решетки и B в последние четыре методов 
                печати (Сетка [С1] [С1])
                 возвращает сетки [С1] [С1]
             # Если это значение пройденного до отката не похожи в lru_cache особенность 
            # когда возвраты функция встречает то же входное значение второго, возвращаемое значение непосредственно записано до экономии времени
            # Без этого условия также может выводить правильный ответ, но тайм - аут 
            Элиф Memo [r1] [c1] [c2] ЯВЛЯЕТСЯ  не None:
                 возвращение Memo [r1] [c1] [c2]
             еще :
                 # Если c1 равна с2, там r1 равен r2, две позиции совпадают, вишни можно вычислить только один раз, а затем c1! = c2 0, после того, как умножается на количество вишни только один раз 
                # в противном случае, если позиция не совпадает, c1! = c2 верно, который требует , чтобы эти два пути и 
                АНС = Сетка [С1] [С1] + (С1! = С2) * сетки [R2] [C2]
                 # минут четыре случая резервного 
                анс + = тах (дп (r1 , c1 + . 1, С2 +. 1), ДП (. 1 + R1, C1, C2 +. 1 ), 
                           DP (R1, C1 - Добавили +1, С2), ДП (. 1 + R1 , C1, C2))
             # каждая дерева квадрантов возвратами Конец вишни количество записей, и возвращает номер процесса пути 576 подобен этому вопросу границ,
            # Нормальное значение , учитывая тот же вход лицо удобно, прямое возвращаемое значение. 
            Напоминание [С1] [С1] [С2] = АНС
             возврата АНС 
        DP (0,0,0) 
        # возврата макс (0, DP (0, 0, 0)) 
ЕСЛИ  __name__ == ' __main__ ' : 
    duixiang = Решение () = duixiang.cherryPickup ([[1,1,1 ,], 
                                 [ 1,1,1 ,], 
                                 [ 1,1,1 , ], 
                                ]) 
    # А = duixiang.cherryPickup ([[1,1,1,1,0,0,0], 
    #                             [0,0,0,1,0,0,0] 
    #                              [0,0,0,1,0,0,1] 
    #                              [1,0,0,1,0,0,0] 
    #                              [0,0,0,1,0,0,0] 
    #                              [0,0,0,1,0,0,0] 
    #                              [0,0,0,1,1,1,1] ] 
    # ) 
    печать (а)
Просмотр кода

ТТТ

рекомендация

отwww.cnblogs.com/xxswkl/p/12123822.html