Как я могу изменить алгоритм, чтобы улучшить асимптотическую сложность?

Question 1

Ребята .

У меня есть алгоритм с хорошим выбором времени, я должен изменить его, чтобы получить лучшее время, но я понятия не имею.

Ты можешь мне помочь?

Вот время:

реальный 0m0.164s
пользователь 0m0.021s
sys 0m0.010s

Вот алгоритм:

def algo2(A, B):
    x=0
    y=0
    for a in A:
          m=0
          for b in B:
                if a == b:
                      m += 1
          if m>y:
                x = a
                y = m
    return x;

Вот массивы для алгоритма:
A = [1,2,3,4,5,6,7,8,9,0] B = [1,2,3,4,5,6,4,7,8,9,0]

arrays algorithm python-3.x

0

Gudron 25 Мар 2013 в 17:55

Есть ли ограничение на значения в массивах? Всегда ли массивы отсортированы?

–

beaker

25 Мар 2013 в 18:05

Что делает алгоритм?

–

SomeWittyUsername

25 Мар 2013 в 18:08

Я предполагаю, что элементы в A уникальны, но не в B. Вы хотите найти элемент в A, который чаще всего встречается в B. С n количеством элементов в A и m количеством элементов в B, ваш алгоритм находится в O (нм). Способ получить лучший большой O - это отсортировать A и B, а затем линейно просмотреть A и B, что приведет к O (n.log n + m.log m + n + m)

–

Kwariz

25 Мар 2013 в 18:11

Без границ, без сортировки.

–

Gudron

25 Мар 2013 в 18:12

Answer

Ваш алгоритм - O (n * m). Если массивы всегда сортируются, вы можете выполнить прямое слияние (O (n + m)), как показано ниже. (Обратите внимание, что код не на питоне ... Думаю, вы можете уловить идею и перевести ее)

ixA = 0
ixB = 0
maxVal = 0
maxCount = 0
workingVal = A[ixA]
workingCount = 0
while (ixA < A.length and ixB < B.length)
{
    if (workingVal == B[ixB])
    {
        workingCount += 1
    }
    else if (workingCount > maxCount)
    {
        maxCount = workingCount
        maxVal = workingVal
        workingCount = 0
        ixA += 1
        workingVal = A[ixA]
    }
    ixB += 1
}
// have to check the last one
if (workingCount > maxCount)
{
    maxCount = workingCount
    maxVal = workingVal
}

Если массивы не отсортированы, вы можете сначала отсортировать их, а затем выполнить слияние. Это будет O (m log m) + O (n log n) + O (m + n). Это все равно лучше, чем твой O (m * n).

0

Jim Mischel 25 Мар 2013 в 18:15

Question 2

Ваш алгоритм - O (n * m). Если массивы всегда сортируются, вы можете выполнить прямое слияние (O (n + m)), как показано ниже. (Обратите внимание, что код не на питоне ... Думаю, вы можете уловить идею и перевести ее)

ixA = 0
ixB = 0
maxVal = 0
maxCount = 0
workingVal = A[ixA]
workingCount = 0
while (ixA < A.length and ixB < B.length)
{
    if (workingVal == B[ixB])
    {
        workingCount += 1
    }
    else if (workingCount > maxCount)
    {
        maxCount = workingCount
        maxVal = workingVal
        workingCount = 0
        ixA += 1
        workingVal = A[ixA]
    }
    ixB += 1
}
// have to check the last one
if (workingCount > maxCount)
{
    maxCount = workingCount
    maxVal = workingVal
}

Если массивы не отсортированы, вы можете сначала отсортировать их, а затем выполнить слияние. Это будет O (m log m) + O (n log n) + O (m + n). Это все равно лучше, чем твой O (m * n).

0

Jim Mischel 25 Мар 2013 в 18:15

Как я могу изменить алгоритм, чтобы улучшить асимптотическую сложность?

1 ответ

Похожие вопросы

Новые вопросы

arrays