Count unique subsets of size k with some S [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 8 years ago.
Improve this question
Team 7 faces a horrible foe. He can only be defeated with a special
quadruple combination attack of strength ( 1 <=S <= 10^9 ).
Naruto, Sasuke, Sakura and Kakashi must attack simultaneously to
perform the combo. Each of them can choose from N ( 1 <= N <=1000 ) attacks, having strengths si each ( 0 <= i < N, 1 <= si <=10^9). The strengths of individual attacks add up to form the
strength of the combo.
Is there a valid combination that they can use? Note that the same
attacks are available to all of them.
You are required to write a function which takes input as follows – An
integer N as number of attacks, an integer vector s[] as the
strengths of N attacks and an integer S as the required strength
of the combo. Set the output variable to the number of distinct valid
combos.
Two combinations are different if they differ in strength of at least
one attack used.
Input: 1 {1} 4
Output: 1 ===>{1,1,1,1}
Input: 2 {1,2} 5
Output: 1 ===> {1,1,1,2}
Below is my code its only passes 3 test cases out of 10. I don't know the test cases as it was some online code submission.
My Algorithm:
1) Create a hash with indexes as sum of pairs from input array and value as individual elements contributing to sum
2) Iterate over the hash and look if for i in hash there is k-i
3) Count above indexes and return count/2 as we are counting for both H(i) and H(k-i)
Please review the code and tell me what scenarios you think code will not produce right o/p.
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<vector>
#include<map>
#include<set>
const int noOfPalyers = 4;
int validCombo(int input1,int input2[],int input3)
{
//Write code here
int count = 0;
std::vector<int> vec;
int size =input1*noOfPalyers;
for(int i = 0; i < input1; i++)
{
for(int j = 0; j < noOfPalyers;j++)
{
vec.push_back(input2[i]);
}
}
std::vector< std::set< std::pair<int, int> > > vecHash;
//vecHash.reserve(size*size);
for(int i =0; i < (size*size); i++)
{
vecHash.push_back(std::set< std::pair<int, int> >());
}
for(int i =0; i < size; i++)
{
for(int j =1; j < size; j++)
{
int key = vec[i] + vec[j];
if(vec[i]<= vec[j])
vecHash[key].insert(std::make_pair(vec[i], vec[j]));
else
vecHash[key].insert(std::make_pair(vec[j], vec[i]));
}
}
for(int i = 0; i < input3; i++)
{
if(vecHash[i].size() > 0 && i < input3)
{
if(vecHash[input3-i].size() > 0)
{
std::set< std::pair<int, int> >::iterator iter, iter2;
for(iter=vecHash[i].begin(); iter!=vecHash[i].end();++iter)
{
for(iter2=vecHash[input3-i].begin(); iter2!=vecHash[input3-i].end();++iter2)
{
std::cout<<(*iter).first<<","<< (*iter).second<<",";
std::cout<<(*iter2).first<<","<< (*iter2).second;
std::cout<<"\n";
count++;
}
}
}
}
}
return (count ==1 ? count: count/2);
}
int main()
{
int i = 3;
int arr[] = {1,2,3};
int j = 7;
int arr1[] ={1};
std::cout <<"o/p == " << validCombo(i, arr, j)<< "\n";
std::cout <<"o/p == " << validCombo(1, arr1, 4);
//getch();
return 0;
}

Answer 1

UPD. My God, now I've understood your comment :) and see that you tried to solve it the same way I wrote. Anyway, I hope you'll find some pieces of my explanation useful. First of all, you don't use hash functions (I know identity function is a hash func, but not the good one in our case). Also I didn't understand your count logic... I think you need to read Two combinations are different if they differ in strength of at least one attack used. part again and check your count logic.
There're just my first thoughts. Hope it could be helpful.
==================================
You know, this problem is about having particular sum of 4 numbers from the set. Let's imagine we have just 2 heroes (so 2 terms in our sum):
a + b = S,
where a, b are attack's strengths from set of N numbers (let's name it T). The number of different a + b sums is N^2. Simple calculating all of these sums and then searching those ones equal to S doesn't give us good solution. This problem can be solved with better complexity.
If we could find a fast function such that:
F(a) = F(S - b)
we would precalculate all F(S - b), then looped over all a's and found which ones satisfy equality above. You mentioned hash. Hash functions can do this. We need such hash func to map all numbers from set T to range [0, N]. Because we just have no more than N different a's.
But we have a little problem here:
F(a) = F(S - b) just means a can be equal to S - b. Fortunately, it's not a big problem,
because the main power is: F(a) != F(S - b) means a != S - b.
Ok, as you see we have algorithm to solve a + b = S problem with amortized O(N) complexity. Sounds good and promising, right? :)
==================================
Now come back to your problem:
a + b + c + d = S
My idea to precalculate all f(a + b) with O(N^2) and store them like this (warning! just pseudocode):
vector<int> hash = new vector<int>(with size N)
foreach (a in T)
foreach (b in T)
{
int x = OurHashFunc(a + b); // a + b <= 2 * 10^9 so it never overflows int
if (hash[x] == null)
hash[x] = new vector<pair<int,int>>
hash[x].push_back(new pair<int, int>(a, b));
}
We keep pairs (a,b) to be able to restore terms of initial sum. Then if our OurHashFunc is additive then transform our initial problem like this:
a + b + c + d = S // apply hash func =>
f(a + b) + f(c + d) = f(S) // rename =>
x + y = Z // wow, I bet I've already seen this equation ;)
Now 4-terms sum problem had reduced to 2-terms sum problem with an O(N^2) overhead.
I think this reduction can be continued: 2^k-terms sum problem should have avg O(N^k) solution.