无法在大小为1000000000的堆上初始化数组

Question

I am new to dynamic programming ,I was learning about recursion by solving this question

My Doubt

1) Since test case is very large How to decide the size of dp table , according to my knowledge we decide the size of table by the value of n; Please let me know what should correct table size ,because we don,t know how many sub problems going to repeat , i am little confused ;

2) As we know vector dynamically allocates memory on heap and declaring globally a vector mean only pointer variable dp will occupy space in global section , 1000000000* sizeof(int) will be occupied in heap.Then why it showing error std::bad alloc Because we can allocate memory as much as we want on heap

    #include<bits/stdc++.h>
    using namespace std;
    vector <int> dp(1000000001,-1);
    int exchange(int n){
        if(n<12)
            return n;
        if(dp[n]!=-1)
            return dp[n];
        return dp[n] = exchange(n/2)+exchange(n/3)+exchange(n/4);
    }
    int main(){
        int t;
        cin>>t;
        while(t--){
      //      memset(dp,-1,sizeof(dp));
            int n;
            cin>>n;
            cout<<exchange(n);
        }

    }

EDIT

Note-> count() The function returns the number of times the key K is present in the map container. It returns 1 if the key is present in the container as the map only contains a unique key. It returns 0 if the key is not present in the map container. It is passing nearly all the test cases but it is failing 1 000 000 000 according to long long int range value it should pass this one also but it giving some negative value as output ; I think this is the problem with container map

    #include<bits/stdc++.h>
    using namespace std;
    map <long long int,long long int> dp;
    int exchange(long long int n){
        if(n<12)
            return n;
        if(dp.count(n))
            return dp[n];
        return dp[n] = exchange(n/2)+exchange(n/3)+exchange(n/4);
    }
    int main(){
     //   int t;
       // cin>>t;
        while(1){
      //      memset(dp,-1,sizeof(dp));
            long long int n;
            cin>>n;
            cout<<exchange(n)<<endl;
        }

    }

Answer 1

You can avoid the immediate problem by doing:

vector <int> dp;

// ....

cin>>t;
dp = std::vector<int>(t, -1);

This will dynamically allocate the memory based on the entered t , and you can use exceptions to catch if the user enters too large a value.

Answer 2

While your input size may be very large, note that the vast majority of your table will not be inspected. For an input of 999,999,999 you will only ever touch 230 values of exchange(n) . Roughly speaking, you will descend log_2(n) times with a branching factor of 2 (since the n/4 case is covered by n/2 applied twice).

For this concrete example, you're thus better off using a map<int, int> or an unordered_map<int, int> .

Your concrete exchange function might look like the following:

std::map<int, int> dp;

int exchange(int n) {
    if (n < 12) return n;
    auto it = dp.find(n);
    if (it != dp.cend()) return it->second;

    int val = exchange(n/2) + exchange(n/3) + exchange(n/4);
    dp.insert({n, val});
    return val;
}

Answer 3

Vector allocates ONE block of memory, so it is possible that it doesn't found free memory block(read about memory fragmentation).

What's more , there is possibility of using max 2GB per one process on 32bit systems and 8TB on 64bit systems, of course if your machine has so much memory.