O (n) 시간에 5 개의 반복 된 값을 찾는 방법은 무엇입니까?

정확히 5를 반복하여 1 에서 n - 5 사이의 정수를 포함하는 n ≥ 6 크기의 배열이 있다고 가정합니다 . O ( n ) 시간 에 반복되는 숫자를 찾을 수있는 알고리즘을 제안해야합니다 . 나는 내 인생에서 아무것도 생각할 수 없다. 나는 정렬이 기껏해야 O ( n log n ) 일 것이라고 생각한다 . 그런 다음 배열을 순회하면 되고 됩니다. 그러나 링크 된 목록, 대기열, 스택 등으로 까다로운 항목을 보았으므로 정렬이 필요한지 확실하지 않습니다.$n \geq 6$$1$$n − 5$$O(n)$$O(n\log n)$$O(n)$$O(n^2\log n)$

크기가 n 인 추가 배열 B 를 만들 수 있습니다 . 처음에는 배열의 모든 요소를 0으로 설정하십시오 . 그런 다음 입력 배열 A를 반복 하고 각 i 에 대해 B [ A [ i ] ] 를 1 씩 증가시킵니다 . 그런 다음 단순히 배열 B : 루프 A 를 확인하고 B [ A [ i ] ] > 1 이면 A [ i ] 가 반복됩니다. 당신은 O ( n ) 에서 그것을 해결$B$$n$$0$$A$$B[A[i]]$$i$$B$$A$$B[A[i]] > 1$$A[i]$$O(n)$메모리 비용은 O ( n ) 이고 정수는 1 에서 n - 5 사이이므로 시간이 걸립니다 .$O(n)$$1$$n-5$

fade2black의 답변에 대한 솔루션이 표준 솔루션이지만 O ( n ) 공간을 사용합니다. 다음과 같이 이를 O ( 1 ) 공간으로 향상시킬 수 있습니다 .$O(n)$$O(1)$

1. 배열을 A [ 1 ] , … , A [ n ]으로 합니다. 들면 D = 1 , ... , 5 , 컴퓨팅 σ $A[1],\ldots,A[n]$$d=1,\ldots,5$ = Σ N 난 = 1 [ I ] D를 .$\sigma_d = \sum_{i=1}^n A[i]^d$
2. 계산 τ d = σ d − ∑ n − 5 i = 1 i d (잘 알려진 공식을 사용하여 후자의 합을 O ( 1 ) 로 계산할 수 있습니다 ). τ d = m d 1 + ⋯ + m d 5 (여기서 m 1 , … , m 5 는 반복되는 숫자 임)$\tau_d = \sigma_d - \sum_{i=1}^{n-5} i^d$$O(1)$$\tau_d = m_1^d + \cdots + m_5^d$$m_1,\ldots,m_5$
3. 다항식 계산 P ( t ) = ( t - m 1 ) ⋯ ( t - m 5 ) . 이 다항식의 계수의 대칭 함수이다 m 1 , ... , m 5 로부터 계산 될 수 τ 1 , ... , τ 5 에서 O ( 1 ) .$P(t) = (t-m_1)\cdots(t-m_5)$$m_1,\ldots,m_5$$\tau_1,\ldots,\tau_5$$O(1)$
4. 모든 n - 5 가능성 을 시도 하여 다항식 P ( t ) 의 근을 모두 찾으십시오 .$P(t)$$n-5$

이 알고리즘은 RAM 기계 모델을 가정하는데, 여기서 O ( log n ) 비트 워드 에 대한 기본 산술 연산에는 O ( 1 ) 시간이 걸립니다.$O(\log n)$$O(1)$

이 솔루션을 공식화하는 다른 방법은 다음과 같습니다.

1. Calculate $x_1 = \sum_{i=1}^n A[i]$, and deduce $y_1 = m_1 + \cdots + m_5$ using the formula $y_1 = x_1 - \sum_{i=1}^{n-5} i$.
2. Calculate $x_2 = \sum_{1 \leq i < j \leq} A[i] A[j]$ in $O(n)$ using the formula $$x_2 = (A[1]) A[2] + (A[1] + A[2]) A[3] + (A[1] + A[2] + A[3]) A[4] + \cdots + (A[1] + \cdots + A[n-1]) A[n].$$
3. Deduce $y_2 = \sum_{1 \leq i < j \leq 5} m_i m_j$ using the formula $$y_2 = x_2 - \sum_{1 \leq i < j \leq n-5} ij - \left(\sum_{i=1}^{n-5} i\right) y_1.$$
4. Calculate $x_3,x_4,x_5$ and deduce $y_3,y_4,y_5$ along similar lines.
5. The values of $y_1,\ldots,y_5$ are (up to sign) the coefficients of the polynomial $P(t)$ from the preceding solution.

This solution shows that if we replace 5 by $d$, then we get (I believe) a $O(d^2n)$ algorithm using $O(d^2)$ space, which performs $O(dn)$ arithmetic operations on integers of bit-length $O(d\log n)$, keeping at most $O(d)$ of these at any given time. (This requires careful analysis of the multiplications we perform, most of which involve one operand of length only $O(\log n)$.) It is conceivable that this can be improved to $O(dn)$ time and $O(d)$ space using modular arithmetic.

There's also a linear time and constant space algorithm based on partitioning, which may be more flexible if you're trying to apply this to variants of the problem that the mathematical approach doesn't work well on. This requires mutating the underlying array and has worse constant factors than the mathematical approach. More specifically, I believe the costs in terms of the total number of values $n$ and the number of duplicates $d$ are $\mathcal{O}(n \log d)$ and $\mathcal{O}(d)$ respectively, though proving it rigorously will take more time than I have at the moment.

Algorithm

Start with a list of pairs, where the first pair is the range over the whole array, or $[(1, n)]$ if 1-indexed.

Repeat the following steps until the list is empty:

1. Take and remove any pair $(i, j)$ from the list.
2. Find the minimum and maximum, $\text{min}$ and $\text{max}$, of the denoted subarray.
3. If $\text{min} = \text{max}$, the subarray consists only of equal elements. Yield its elements except one and skip steps 4 to 6.
4. If $\text{max} - \text{min} = j - i$, the subarray contains no duplicates. Skip steps 5 and 6.
5. Partition the subarray around $\frac{\text{min}+\text{max}}{2}$, such that elements up to some index $k$ are smaller than the separator and elements above that index are not.
6. Add $(i, k)$ and $(k + 1, j)$ to the list.

Cursory analysis of time complexity.

Steps 1 to 6 take $\mathcal{O}(j - i)$ time, since finding the minimum and maximum and partitioning can be done in linear time.

Every pair $(i, j)$ in the list is either the first pair, $(1, n)$, or a child of some pair for which the corresponding subarray contains a duplicate element. There are at most $d \lceil \log_2 n + 1\rceil$ such parents, since each traversal halves the range in which a duplicate can be, so there are at most $2d \lceil \log_2 n + 1\rceil$ total when including pairs over subarrays with no duplicates. At any one time, the size of the list is no more than $2d$.

하나의 사본을 찾는 작업을 고려하십시오. 이것은 기하 급수적으로 감소하는 범위에 걸쳐 일련의 쌍으로 구성되므로 총 작업량은 기하 시퀀스의 합 또는 O ( n ) 입니다. 이것은 d 개의 복제에 대한 총 작업 이 O ( n d ) 이어야하며 , n 에서 선형 이어야 한다는 명백한 결론을 만듭니다 .$\mathcal{O}(n)$$d$$\mathcal{O}(nd)$$n$

더 엄격한 경계를 찾으려면 최대 복제본을 최대한 분산시키는 최악의 시나리오를 고려하십시오. 직관적으로, 검색은 두 단계로 이루어집니다. 하나는 전체 배열이 매번 순회되고 점차적으로 작은 부분에서 하나는 부분이 n 보다 작은 부분입니다.$\frac{n}{d}$ so only parts of the array are traversed. The first phase can only be $\log d$ deep, so has cost $\mathcal{O}(n \log d)$, and the second phase has cost $\mathcal{O}(n)$ because the total area being searched is again exponentially decreasing.

Leaving this as an answer because it needs more space than a comment gives.

You make a mistake in the OP when you suggest a method. Sorting a list and then transversing it $O(n\log n)$ time, not $O(n^2\log n)$ time. When you do two things (that take $O(f)$ and $O(g)$ respectively) sequentially then the resulting time complexity is $O(f+g)=O(\max{f,g})$ (under most circumstances).

In order to multiply the time complexities, you need to be using a for loop. If you have a loop of length $f$ and for each value in the loop you do a function that takes $O(g)$, then you'll get $O(fg)$ time.

따라서 귀하의 경우 O ( n log n )로 정렬 한 다음 O ( n ) 으로 가로 로 O ( n log n + n ) = O ( n log n )가 됩니다. 정렬 알고리즘의 각 비교를 위해 당신이 걸리는 계산해야 할 일을했을 경우 O를 ( N ) , 다음 이 걸릴 것이라고 O ( n은 2 로그 N을 ) 있지만, 여기서는 그렇지 않다.$O(n\log n)$$O(n)$$O(n\log n+n)=O(n\log n)$$O(n)$$O(n^2\log n)$

O ( f + g ) = O ( max f , g ) 라는 내 주장에 대해 궁금한 점이 있다면 항상 사실이 아니라는 점에 유의하는 것이 중요합니다. 그러나 f ∈ O ( g ) 또는 g ∈ O ( f ) (모든 공통 기능을 보유 함)이면 유지됩니다. 가장 일반적인 시간은 추가 매개 변수가 관여하고 O ( 2 c n + n log n ) 와 같은 식을 얻는 경우 입니다.$O(f+g)=O(\max{f,g})$$f\in O(g)$$g\in O(f)$$O(2^cn+n\log n)$

There's an obvious in-place variant of the boolean array technique using the order of the elements as the store (where arr[x] == x for "found" elements). Unlike the partition variant that can be justified for being more general I'm unsure when you'd actually need something like this, but it is simple.

for idx from n-4 to n
    while arr[arr[idx]] != arr[idx]
        swap(arr[arr[idx]], arr[idx])

This just repeatedly puts arr[idx] at the location arr[idx] until you find that location already taken, at which point it must be a duplicate. Note that the total number of swaps is bounded by $n$ since each swap makes its exit condition correct.

Subtract the values you have from the sum $\sum_{i=1}^{n} i = \frac{(n-1) \cdot n}{2}$.

So, after $\Theta(n)$ time (assuming arithmetic is O(1), which it isn't really, but let's pretend) you have a sum $\sigma_1$ of 5 integers between 1 and n:

$x_1 + x_2 + x_3 + x_4 + x_5 = \sigma_1$

Supposedly, this is no good, right? You can't possibly figure out how to break this up into 5 distinct numbers.

아, 그러나 이것은 재미있을 곳입니다! 이제 이전과 동일한 작업을 수행하지만 ∑ n i = 1 i 2 에서 값 의 제곱 을 뺍니다 . 이제 당신은 :$\sum_{i=1}^{n} i^2$

${x_1}^2 + {x_2}^2 + {x_3}^2 + {x_4}^2 + {x_5}^2 = \sigma_2$

내가 어디로 가는지 보아? 거듭 제곱 3, 4 및 5에 대해 동일하게 수행하면 5 개의 변수에 5 개의 독립 방정식이 있습니다. 나는 당신이 → x를 풀 수 있다고 확신합니다.$\vec{x}$ .

주의 사항 : 산술은 실제로 O (1) 가 아닙니다 . 또한 합계를 나타내려면 약간의 공간이 필요합니다. 하지만 많은 당신이 상상하는 것처럼 - 만약 당신이, 오, 같은 당신이 가지고있는, 모듈 식으로 대부분의 모든 것을 할 수 ⌈ 로그 ( 5 N 6 ) ⌉ 비트; 그렇게해야합니다.$\lceil\log(5n^6)\rceil$

문제를 해결하는 가장 쉬운 방법은 원래 배열의 각 숫자에 대한 apperance를 계산 한 다음 1 에서 n - 5 까지의 모든 숫자를 탐색 하고 숫자가 두 번 이상 나타나는지 확인 하는 배열을 만드는 것입니다. 메모리와 시간 모두의 해가 선형이거나 O ( N $1$$n-5$$O(N)$

배열을 매핑 한 1 << A[i]다음 모든 것을 XOR합니다. 중복은 해당 비트가 꺼져있는 숫자입니다.

DATA=[1,2,2,2,2,2]

from collections import defaultdict

collated=defaultdict(list):
for item in DATA:
    collated[item].append(item)
    if len(collated) == 5:
        return item.

# n time