如何在时间复杂度方面改进算法？

Question

I'm trying to measure time complexity of my algorithm:

public boolean rotateAndCompare(int[] fst, int[] snd) {
    int len = fst.length;
    for (int k = 0; k < len; k++) {
        for (int j = 0; j < len; j++) {
            if (fst[(k + j) % len] != snd[j]) {
                break;
            }
            if (j == len - 1) {
                return true;
            }
        }
    }
    return false;
}

My assumption that it has O(n*n) complexity because we iterate through an array and then through another one array. Am I right? And If so then how can I improve it?

Answer 1

If I understand it correctly, your algorithm decides if the first fst.length integers of snd are equal to fst , possibly rotated. It assumes that snd.length >= fst.length . If that isn't what you meant, please specify in the question.

But assuming that's what you really meant, you can solve this problem in O(n) using a string matching algorithm like KMP . You need, in other words, see if you can find snd as a subarray of fst + fst , and that's a classic problem.

Here's an example implementation in Java:

import java.util.Arrays;

public class Main {
    public static class KMP {
        private final int F[];
        private final int[] needle;

        public KMP(int[] needle) {
            this.needle = needle;
            this.F = new int[needle.length + 1];

            F[0] = 0;
            F[1] = 0;
            int i = 1, j = 0;
            while (i < needle.length) {
                if (needle[i] == needle[j])
                    F[++i] = ++j;
                else if (j == 0)
                    F[++i] = 0;
                else
                    j = F[j];
            }
        }

        public int find(int[] haystack) {
            int i = 0, j = 0;
            int n = haystack.length, m = needle.length;

            while (i - j <= n - m) {
                while (j < m) {
                    if (needle[j] == haystack[i]) {
                        i++;
                        j++;
                    } else break;
                }
                if (j == m) return i;
                else if (j == 0) i++;
                j = F[j];
            }
            return -1;
        }
    }

    public static boolean rotateAndCompare(int[] fst, int[] snd) {
        int[] fst2 = new int[fst.length * 2];
        System.arraycopy(fst, 0, fst2, 0, fst.length);
        System.arraycopy(fst, 0, fst2, fst.length, fst.length);

        int[] snd2 = Arrays.copyOf(snd, fst.length);
        return new KMP(snd2).find(fst2) >= 0;
    }

    public static void main(String[] args) {
        System.out.println(rotateAndCompare(new int[]{1, 2, 3}, new int[]{3, 1, 2, 4}));
        System.out.println(rotateAndCompare(new int[]{1, 2, 2}, new int[]{3, 1, 2, 4}));
    }
}

Answer 2

O(n*n) is usually expressed as "order n-squared", O(n^2), which your algorithm is. However, since you do absolutely no length checking it could break altogether, which is more serious than algorithmic complexity. 'snd' (what does that stand for? Why so terse?) might not even have 'len' elements. Also, you can get a little improvement by making your terminal condition part of the loop control instead of checking it twice.

The risk of a crash is far more serious than algorithmic complexity. Once you solve that, you might be able to refactor the indexes to make it more linear, but I suspect that's not possible. If there are symmetries in your problem you might be able to exploit them.