다음 문제에 대해 서브 큐빅 알고리즘이 있습니까?

$n \times n$$A=(a_{ij})$

시간에 작동하는 실질적인 접근 방식이 있습니다. 여기서 는 프로세서 워드의 비트 수입니다. 주요 아이디어는 증가하는 순서 (임의로 연결 해제)로 매트릭스의 요소를 하나씩 반복하여 "전환"하는 것입니다. 트리플 의 가장 큰 요소 가 켜진 순간을 고려하십시오 . 간단히하기 위해, 상기 요소가 라고 가정 해 봅시다 . 마지막 요소가 켜졌을 때 트리플 값을 답에 추가하는 것이 당연합니다. 우리가 할 수의 수를 계산해야한다 그래서 '등이야 그 및$O(n^3 / w)$$w$I , J , I (K)은 , j는 k는 I J의 K를 나 케이 J의 K를 I J O ( N )$a_{ij}, a_{ik}, a_{jk}$$a_{ij}$$k$$a_{ik}$$a_{jk}$이미 켜져 있습니다 (즉, 트리플의 수입니다. 여기에서 가 가장 큰 요소이므로 지금은 완전히 켜져 있습니다). 여기서 비트 최적화를 사용하여 순진한 구현 속도를 높일 수 있습니다 .$a_{ij}$$O(n)$

자세한 내용은 , 작동해야하는 C ++ 11의 다음 구현을 참조 할 수 있습니다. (매우 최적화되지는 않았지만 적어도 내 컴퓨터 에서는 여전히 에 대한 순진 합계 보다 큰 마진을 능가 합니다).$n \leqslant 5000$$|a_{ij}| \leqslant 10^9$$n = 5000$

// code is not very elegant, 
// but should be understandable
// here the matrix a has dimensions n x n
// a has to be symmetric!
int64_t solve (int n, const vector<vector<int32_t>> &a)
{
        std::vector<boost::dynamic_bitset<int64_t>> mat
        (n, boost::dynamic_bitset<int64_t>(n));

        vector<pair<int, int>> order;
        for (int j = 1; j < n; j++)
        for (int i = 0; i < j; i++)
            order.emplace_back(i, j);
        sort(order.begin(), order.end(),
            [&] (const pair<int, int> &l, const pair<int, int> &r) 
            {return a[l.first][l.second] < a[r.first][r.second];});

        int64_t ans = 0;
        for (const auto &position : order)
        {
            int i, j;
            tie (i, j) = position;
            mat[i][j] = mat[j][i] = 1;
            // here it is important that conditions 
            // mat[i][i] = 0 and mat[j][j] = 0 always hold
            ans += (mat[i] & mat[j]).count() * int64_t(a[i][j]);
        }

        return ans;
}

당신이 비트 최적화가 부정 사용을 고려하는 경우, 당신은 항복, 여기에 같은 결과에 네 러시아 방법을 사용할 수 있습니다 (때문에 실용성해야 알고리즘, 가장 현대적인 하드웨어에 꽤 큰) 이론적으로 더 좋습니다. 실제로 선택 하고 행렬의 각 행을 정수를 에서 의 배열로 유지합니다 . 여기서 번째 숫자는 이르기까지 열의 비트 배열에 대응 포함하는 단독으로$O(n^3 / \log n)$$w$$b \approx \log_2 n$$\lceil \frac{n}{b} \rceil$$0$$2^b - 1$$i$$ib$$\min(n, (i + 1)b)$$0$색인. 시간에 이러한 두 블록의 스칼라 곱을 미리 계산할 수 있습니다 . 하나의 정수만 변경하기 때문에 행렬에서 위치를 업데이트하는 것이 빠릅니다. 행 및 의 스칼라 곱을 찾으려면 해당 행에 해당하는 배열을 반복하고 테이블에서 해당 블록의 스칼라 곱을 찾아서 얻은 곱을 요약하십시오.$O(2^{2b} b)$$i$$j$

위의 단락은 정수 을 갖는 연산 이 시간이 가정합니다 . 그것은 일반적으로 알고리즘의 비교 속도를 실제로 변경하지 않기 때문에 매우 일반적인 가정입니다 (예를 들어, 우리가 그 가정을 사용하지 않으면 무차별 강제 방법은 실제로 시간에 작동합니다 (여기서 가 상수 대해 적어도 까지의 절대 값을 갖는 정수 값을 사용하는 경우 비트 연산으로 시간을 측정합니다 (그렇지 않으면 행렬 곱셈)); 그러나 위에서 제안한 네 가지 러시아 방법은$\leqslant n$$O(1)$$O(n^3 \log n)$$a_{ij}$$n^{\varepsilon}$$\varepsilon > 0$$O(n^{\varepsilon})$$O(n^3 / \log n)$이 경우 크기 숫자를 가진 연산 ; 따라서 비트 연산을 수행하므로 모델 변경에도 불구하고 무차별 대입보다 여전히 우수합니다.$O(\log n)$$O(n^3)$

그러나 접근법의 존재에 대한 질문 은 여전히 ​​흥미 롭습니다.$O(n^{3 - \varepsilon})$

이 답변에 제시된 기법 (비트 최적화 및 4 명의 러시아인 방법)은 결코 독창적이지 않으며 박람회의 완성을 위해 여기에 제시됩니다. 그러나 그것들을 적용하는 방법을 찾는 것은 사소한 것이 아닙니다.