如何改进算法的运行时间？

Question

The aim is given a file, with the 1st line as the number of lines available, find how many pair of lines are permutations of each other. Example would be that AABA is a permutation of BAAA. The code is written in java. This is my current code:

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Arrays;

public class SpeedDemon {

    public class Data{
        byte[] dataValues;
        byte duplicate=1;
        int hashcode;
        public Data(byte[] input) {
            dataValues= new byte[128];
            for (byte x : input) {
                if (x==10){
                    break;
                }
                dataValues[x]++;
            }
            hashcode = Arrays.hashCode(dataValues);
        }
        public boolean equal(Data o){
            return this.hashcode==o.hashcode&&Arrays.equals(o.dataValues, this.dataValues);
        }
    }
    public int processData(String fileName){
        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));
            int size = Integer.parseInt(reader.readLine());
            int arr_size = 2;
            while (arr_size < size) {
                arr_size *= 2;
            }
            Data[] map = new Data[arr_size];
            int z = 0;
            Data data;
            int j;
            for (int i = 0; i < size; i++) {
                data = new Data(reader.readLine().getBytes());
                j = data.hashcode;
                j ^= (j >>> 16);
                j &= (arr_size - 1);
                while (true) {
                    if (map[j] == null) {
                        map[j] = data;
                        break;
                    } else {
                        if (map[j].equal(data)) {
                            z += map[j].duplicate++;
                            break;
                        } else {
                            j = j == arr_size - 1 ? 0 : j + 1;
                        }
                    }
                }
            }
            return z;
        }catch(Exception ex){ }
        return 0;
    }
    public static void main(String[] args) {
        System.out.println(new SpeedDemon().processData(args[0]));
    }
}

I would like to know if there is any way to improve the time efficiency of the program? It is part of my class contest and some people have managed runtimes of around 25% faster. I tried different array sizes and this seem to work the best.

Answer 1

Multiply arr_size by 4. You need a lot of free slots to make open addressing efficient, and depending on what size is you may not be getting very many right now.

Specify a larger buffer size on your buffered reader to reduce the I/O count. 32768 would be reasonable.

Then work on efficiency in Data Both the hashing and comparison operations need to iterate through all 128 possible byte values, which is unnecessary.

Answer 2

Are you sure your code even gets the correct answer? It doesn't seem likely.

The easiest way to determine if two strings are permutations of each other is to sort the strings and compare them. With that in mind, an easier and faster way to code this up would be to use a Map . Something like this:

Create a new Map where the key and value are both strings
for each line of the file
    s = read string from file
    sortedString = sort(s) // sort characters in the string
    if (map.contains(sortedString))
        you found a duplicate
    else
        map.insert(sortedString, string) // the key is the sorted string
end for

There are other ways to do this, but that's the easiest way I know of, and probably the fastest.