通过使用指针/引用，在C ++中使用向量加快计算速度

Question

Currently, I am making a C++ program that solves a sudoku. In order to do this, I calculate the "energy" of the sudoku (the number of faults) frequently. This calculation unfortunately takes up a lot of computation time. I think that it can be sped up significantly by using pointers and references in the calculation, but have trouble figuring out how to implement this.

In my solver class, I have a vector<vector<int> data-member called _sudoku , that contains the values of each site. Currently, when calculating the energy I call a lot of functions with pass-by-value. I tried adding a & in the arguments of the functions and a * when making the variables, but this did not work. How can I make this program run faster by using pass-by-reference?

Calculating the energy should not change the vector anyway so that would be better.

I used the CPU usage to track down 80% of the calculation time to the function where vectors are called.

int SudokuSolver::calculateEnergy() {
    int energy = 243 - (rowUniques() + colUniques() + blockUniques());//count number as faults
    return energy;
}


int SudokuSolver::colUniques() {
    int count = 0;
    for (int col = 0; col < _dim; col++) {
        vector<int> colVec = _sudoku[col];
        for (int i = 1; i <= _dim; i++) {
            if (isUnique(colVec, i)) {
                count++;
            }
        }
    }
    return count;
}
int SudokuSolver::rowUniques() {
    int count = 0;
    for (int row = 0; row < _dim; row++) {

        vector<int> rowVec(_dim);
        for (int i = 0; i < _dim; i++) {
            rowVec[i] = _sudoku[i][row];
        }
        for (int i = 1; i <= _dim; i++) {
            if (isUnique(rowVec, i)) {
                count++;
            }
        }
    }
    return count;
}

int SudokuSolver::blockUniques() {
    int count = 0;
    for (int nBlock = 0; nBlock < _dim; nBlock++) {
        vector<int> blockVec = blockMaker(nBlock);
        for (int i = 1; i <= _dim; i++) {
            if (isUnique(blockVec, i)) {
                count++;
            }
        }
    }
    return count;
}

vector<int> SudokuSolver::blockMaker(int No) {
    vector<int> block(_dim);
    int xmin = 3 * (No % 3);
    int ymin = 3 * (No / 3);
    int col, row;
    for (int i = 0; i < _dim; i++) {
        col = xmin + (i % 3);
        row = ymin + (i / 3);
        block[i] = _sudoku[col][row];
    }
    return block;
}

bool SudokuSolver::isUnique(vector<int> v, int n) {
    int count = 0;
    for (int i = 0; i < _dim; i++) {
        if (v[i] == n) {
            count++;
        }
    }
    if (count == 1) {
        return true;
    } else {
        return false;
    }
}

The specific lines that use a lot of computatation time are the ones like: vector<int> colVec = _sudoku[col]; and every time isUnique() is called.

I expect that if I switch to using pass-by-reference, my code will speed up significantly. Could anyone help me in doing so, if that would indeed be the case?

Thanks in advance.

Answer 1

If you change your SudokuSolver::isUnique to take vector<int> &v , that is the only change you need to do pass-by-reference instead of pass-by-value. Passing with a pointer will be similar to passing by reference, with the difference that pointers could be re-assigned, or be NULL, while references can not.

I suspect you would see some performance increase if you are working on a sufficiently large-sized problem where you would be able to distinguish a large copy (if your problem is small, it will be difficult to see minor performance increases).

Hope this helps!

Answer 2

vector<int> colVec = _sudoku[col]; does copy/transfer all the elements, while const vector<int>& colVec = _sudoku[col]; would not (it only creates an alias for the right hand side).

Same with bool SudokuSolver::isUnique(vector<int> v, int n) { versus bool SudokuSolver::isUnique(const vector<int>& v, int n) {

Edited after Jesper Juhl's suggestion: The const addition makes sure that you don't change the reference contents by mistake.

Edit 2: Another thing to notice is that vector<int> rowVec(_dim); these vectors are continuously allocated and unallocated at each iteration, which might get costly. You could try something like

int SudokuSolver::rowUniques() {
    int count = 0;
    vector<int> rowVec(_maximumDim); // Specify maximum dimension       
    for (int row = 0; row < _dim; row++) {
        for (int i = 0; i < _dim; i++) {
            rowVec[i] = _sudoku[i][row];
        }
        for (int i = 1; i <= _dim; i++) {
            if (isUnique(rowVec, i)) {
                count++;
            }
        }
    }
    return count;
}

if that doesn't mess up with your implementation.