在 C++ 中初始化二维向量的问题

Question

I was implementing a solution for this problem to get a feel for the language. My reasoning is as follows:

1. Notice that the pattern on the diagonal is 2*n+1 .

2. The elements to the left and upwards are alternating arithmetic progressions or additions/subtractions of the elements from the diagonal to the boundary.

3. Create a 2D vector and instantiate all the diagonal elements. Then create a dummy variable to fill in the remaining parts by add/subtract the diagonal elements.

My code is as follows:

#include <vector>

using namespace std;

const long value = 1e9;

vector<vector<long>> spiral(value, vector<long> (value));
long temp;

void build(){
    spiral[0][0] = 1;
    for(int i = 1; i < 5e8; i++){
        spiral[i][i]= 2*i+1;
        temp = i;
        long counter = temp;
        while(counter){
            if(temp % 2 ==0){
                spiral[i][counter]++;
                spiral[counter][i]--;
                counter--;
                temp--;
            }else{
                spiral[i][counter]--;
                spiral[counter][i]++;
                counter--;
                temp--;
            }
        }
    }
}

int main(){
    spiral[0][0] = 1;
    build();
    int y, x;
    cin >> y >> x;
    cout << spiral[y][x] << endl;
}

The problem is that the programme doesn't output any thing. I can't figure out why my vector won't print any elements. I've tested it with spiral[1][1] and all I get is some obscure assembler message after waiting 5 or 10 minutes. What's wrong with my reasoning?

EDIT: Full output is:

and

Answer 1

A long is probably 4 or 8 bytes for you (eg commonly 4 bytes on Windows, 4 bytes on x86 Linux, and 8 bytes on x64 Linux), so lets assume 4. 1e9 * 4 is 4 gigabytes of continuous memory for each vector<long> (value) .

Then the outer vector creates another 1e9 copies of that, which is 4 exabytes (or 4 million terabytes) given a 32bit long or double for 64bit and ignoring the overhead size of each std::vector . It is highly unlikely that you have that much memory and swapfile, and being a global this is attempted before main() is called .

So you are not going to be able to store all this data directly, you will need to think about what data actually needs to be stored to get the result you desire.

---

If you run under a debugger set to stop on exceptions, you might see a std::bad_alloc getting thrown, with the call stack indicating the cause (eg Visual Studio will display something like "dynamic initializer for 'spiral'" in the call stack), but it is possible on Linux the OS will just kill it first, as Linux can over-commit memory (so new etc. succeeds), then when some program goes to use memory (an actual read or write) it fails (over committed, nothing free) and it SIGKILL's something to free memory (this doesn't seem entirely predictable, I copy-pasted your code onto Ubuntu 18 and on command line got "terminate called after throwing an instance of 'std::bad_alloc'").

Answer 2

Math is your friend, here, not std::vector . One of the constraints of this puzzle is a memory limit of 512MB, but a vector big enough for all the tests would require several GB of memory.

Consider how the square is filled. If you choose the maximum between the given x and y (call it w ), you have "delimited" a square of size w ² . Now you have to consider the outer edge of this square to find the actual index.

Eg Take x = 6 and y = 3. The maximum is 6 (even, remember the zig zag pattern), so the number is (6 - 1) ² + 3 = 28

*  *  *  *  *  26 
 *  *  *  *  *  27
 *  *  *  *  * [28] 
 *  *  *  *  *  29
 *  *  *  *  *  30
36 35 34 33 32  31

Here , a proof of concept.

Answer 3

The problem actually asks you to find an analytical formula for the solution, not to simulate the pattern. All you need to do is to carefully analyze the pattern:

unsigned int get_n(unsigned int row, unsigned int col) {
    assert(row >= 1 && col >= 1);

    const auto n = std::max(row, col);
    if (n % 2 == 0)
        std::swap(row, col);
    if (col == n)
        return n * n + 1 - row;
    else
        return (n - 1) * (n - 1) + col;
}