Why does this give Segmentation fault? - c++

Question

So, I was solving a question which goes like this:
Given a list of n integers, A={a1,a2,…,an}, and another integer, k representing the expected sum. Select zero or more numbers from A such that the sum of these numbers is as near as possible, but not exceeding, to the expected sum (k).
Note
Each element of A can be selected multiple times.
If no element is selected then the sum is 0.
Input Format
The first line contains T the number of test cases.
Each test case comprises of two lines. First line contains two integers, n k, representing the length of list A and expected sum, respectively. Second line consists of n space separated integers, a1,a2,…,an, representing the elements of list A.
Constraints:
1 ≤ T ≤ 10
1 ≤ n ≤ 2000
1 ≤ k ≤ 2000
1 ≤ ai ≤ 2000, where i∈[1,n]
Output Format
Output T lines, the maximum sum for each test case which is as near as possible, but not exceeding, to the expected sum (k).
Here is the problem link: https://www.hackerrank.com/challenges/unbounded-knapsack
Now, I developed a top-down approach for this as follows:
int knapsack(int arr[],int n, int Sum, int dp[][1000])
{
if ( n < 0 || Sum < 0 )
return 0;
if(n==0||Sum==0)
{
dp[Sum][n] = 0;
return 0;
}
if (arr[n-1] == Sum)
{
dp[Sum][n-1] = arr[n-1];
return arr[n-1];
}
else if (dp[Sum][n] != -1)
return dp[Sum][n];
else if(arr[n-1] > Sum)
{
dp[Sum][n] = knapsack(arr,n-1,Sum,dp);
return dp[Sum][n];
}
else //gets selected or doesn't get selected
{
dp[Sum][n] = max( arr[n-1] + knapsack(arr,n,(Sum-arr[n-1]),dp) , knapsack(arr,n-1,Sum,dp) );
return dp[Sum][n];
}
}
However, the above gives a Seg fault when the input is given as:
1
5 9
3 4 4 4 8
I tried debugging it but it shows a Seg-fault at the beginning of the function after many recursive calls. Am I missing out any condition?

Answer 1

In your else:
dp[Sum][n] = max( arr[n-1] + knapsack(arr,n,(Sum-arr[n-1]),dp) , knapsack(arr,n-1,Sum,dp) );
It should be n - 1 as well, because you're done with the current element no matter what. Like it is now, it will do more recursive calls than necessary. With this fix, the segfault is gone on my PC and the function returns 0.
dp[Sum][n] = max( arr[n-1] + knapsack(arr,n-1,(Sum-arr[n-1]),dp) , knapsack(arr,n-1,Sum,dp) );
This program correctly returns 8 as the answer for your example:
int knapsack(int arr[],int n, int Sum, int dp[][1000]);
int main()
{
int t;
int n,k;
cin>>t;
int i,j;
int dp[1000][1000];
for(int i=0;i<t;i++)
{
for ( i = 0; i < 1000; i++ )
for ( j = 0; j < 1000; j++ )
dp[i][j] = -1;
int a[2000];
cin>>n>>k;
for(int j=0;j<n;j++)
cin>>a[j]; // you had i here
while (knapsack(a,n - 1,k,dp) == 0) // lower k until we can build it exactly
--k;
cout << k << endl;
}
return 0;
}
// knapsack(n, Sum) = true if we can use the first n elements to build Sum exactly
int knapsack(int arr[],int n, int Sum, int dp[][1000])
{
if (Sum < 0 )
return 0;
if(n < 0)
{
return Sum == 0;
}
else if (dp[Sum][n] != -1)
return dp[Sum][n];
else //gets selected or doesn't get selected
{
dp[Sum][n] = knapsack(arr,n-1,(Sum-arr[n]),dp) || knapsack(arr,n-1,Sum,dp);
}
return dp[Sum][n];
}
If you can use the same element more than once, I suggest the following iterative approach with a simple one dimensional array:
dp[0] = true
s = 0
for i = 0 to number of elements:
s += elements[i]
for j = elements[i] to s:
dp[j] = dp[j] || dp[j - elements[i]]
Where dp[x] = true if we can build sum x.

Answer 2

Your other bug is:
for(int j=0;j<n;j++)
cin>>a[i];
Notice the i where you meant j