Как найти длину самой длинной последовательности

Текстовый файл состоит не более чем из 10^6 символов L, D и R. Определите длину самой длинной последовательности, состоящей из символов R.

Сразу скажу, я в пайтоне новичок, поэтому всё, что смог написать так это:

f = open("zadanie24_2.txt")
s = f.readlines()
m = 0
for i in s:
    if s(i) == "R" and s(i + 1) == "RR":
        m+=1
print(m)

Прилетела вот такая ошибка

Traceback (most recent call last):
  File "c:UsersstasoOneDriveРабочий СтолPyExamOption 124.py", line 5, in <module>
    if s(i) == "R" and s(i + 1) == "RR":
TypeError: 'list' object is not callable

Где-то в инете нашёл этот код, в него подставлял свои значения, но опять же ничего не вышло

# откроем файл на чтение
F = open ('zadanie24_2.txt', 'rt')

# T - список файла F
T = F.read ().split ()

K = 1 # K - число одинаковых чисел
A = [] # список длин цепочек одинаковых чисел
for i in range (0, len (T) - 1) :
  #print (T [i], end = '')
  if T [i] == T [i + 1] :
    K += 1
  else :
    A += [K]
    K = 1

A += [K]

F.close ()

R = open ('result.txt', 'wt')
R.write (str (max (A)))

R.close ()
print ('Файл result.txt записан')

Помогите, кто может

Это была проблема, которая поставила меня в тупик и не позволила вовремя завершить соревнование по программированию. Предысторию можно найти здесь. Решение публикуется в последующем посте.

Проблема

(Объяснение на простом английском языке см. в следующем разделе.)

Вам дан двумерный массив A из N строк и M столбцов. Существует два массива I и J, элементы которых представляют индексы строк и индексы столбцов A соответственно. Должны быть соблюдены следующие условия:

I и J имеют длину L

I не уменьшается. То есть I[p] ≤ I[p+1] для всех o ≤ p ‹ L-1

J не убывает. То есть J[p] ≤ J[p+1] для всех o ≤ p ‹ L-1

Каждый элемент I[p] представляет индекс строки A, а каждый элемент J[p] представляет индекс столбца A . Другими словами:

Для всех 0 ≤ p ‹ L:

0 ≤ I[p] < N

0 ≤ J[p] < M

Индексы строк и столбцов в I и J используются для формирования подпоследовательности A. По сути, это массив длины L с индексами 0 ≤ p ‹ L, где каждый элемент равен A [I[p]] [J[p] ].

Подпоследовательность увеличивается.

Таким образом, для всех o ≤ p ‹ L-1:

A [I[p]] [J[p]] < A [I[p+1]] [J[p+1]]

Какова длина самой длинной возможной подпоследовательности A?

Мой мыслительный процесс

Что они просят простым английским языком?

Понимание проблемы

Всякий раз, когда я вижу проблему такого рода, я понятия не имею, о чем она просит, поэтому, конечно, первое, что я делаю, — это визуализирую ее.

Итак, давайте нарисуем двумерный массив A с N строками и M столбцами.

А как насчет массивов I и J? А эта беспорядочно выглядящая куча символов, A [I[p]] [J[p]]? Давайте попробуем упростить это, взглянув сначала на I и J.

I и J – это массивы индексов строк и столбцов двумерного массива A. Так что же такое I[p]и J[p]? Это будут p-й индекс строки и p-й индекс столбца.

Предположим, что I[p] равно 3, а J[p] равно 3. Таким образом, A [I[p]] [J[p]] просто относится к элементу в A, в строке 3 и >колонка 3!

Итак, как это связано с тем, что мы делаем? Напомним, что мы пытаемся найти подпоследовательность A. (Проще говоря, мы выбираем набор различных элементов из A.) Подпоследовательность упорядочена, поэтому A [I[p]] [J[p]] — это еще один способ обозначить элемент pth в этой подпоследовательности!

Но очевидно, что мы не можем просто взять кучу случайных элементов и на этом остановиться. Итак, каковы условия?

1. Подпоследовательность должна быть возрастающей, поэтому каждый член должен быть больше предыдущего.
2. Индексы строк и индексы столбцов должны быть неубывающими. Ключевое отличие состоит в том, что каждый термин может быть больше или равен предыдущему.

Как описать это более простыми словами? Оказывается, это довольно легко понять, когда вы визуализируете это.

Здесь мы видим, что выбираем элементы из A, и есть очевидная закономерность — мы можем двигаться только слева направо и сверху вниз< /сильный>.

Suppose we have an unsorted array of numbers, we have to find the length of the longest
sequence of consecutive elements.

So, if the input is like nums = [70, 7, 50, 4, 6, 5], then the output will be 4, as the longest
sequence of consecutive elements is [4, 5, 6, 7]. so we return its length: 4.

To solve this, we will follow these steps −

• nums := all unique elements of nums

• max_cnt := 0

• for each num in nums, do

  • if num — 1 not in nums, then

    • cnt := 0

    • while num is present in nums, do

      • num := num + 1

      • cnt := cnt + 1

    • max_cnt := maximum of max_cnt and cnt

• return max_cnt

Let us see the following implementation to get better understanding −

Example

 Live Demo

class Solution:
   def solve(self, nums):
      nums = set(nums)
      max_cnt = 0
      for num in nums:
         if num - 1 not in nums:
            cnt = 0
            while num in nums:
               num += 1
               cnt += 1
            max_cnt = max(max_cnt, cnt)
      return max_cnt
ob = Solution()
nums = [70, 7, 50, 4, 6, 5]
print(ob.solve(nums))

Input

[70, 7, 50, 4, 6, 5]

Output

4