用一些S计数大小为k的唯一子集

七队面对一个可怕的敌人。他只有在特殊情况下才能被击败力量的四重组合攻击（1<=S<=10^9）。鸣人、佐助、小樱和卡卡西必须同时攻击执行组合。它们中的每一个可以从N（1<=N<=1000）个攻击中进行选择，每个攻击具有强度si（0<=i<N，1<=si<=10^9）。个人攻击的力量加起来形成组合的强度。

他们可以使用有效的组合吗？请注意所有人都可以使用攻击。

您需要编写一个函数，该函数接受如下输入——整数N作为攻击次数，整数向量s[]作为N攻击的强度和整数S作为所需强度组合的。将输出变量设置为不同的有效数量combo。

如果两种组合的强度相差至少使用了一次攻击。

输入：1 {1} 4

输出：1 ===>{1,1,1,1}

输入：2 {1,2} 5

输出：1 ===> {1,1,1,2}

下面是我的代码，它只通过了10个测试用例中的3个。我不知道测试用例，因为它是一些在线代码提交。

我的算法：1） 创建一个散列，其中索引是输入数组中成对的总和，值是对总和有贡献的单个元素2） 在散列上迭代，看看散列中的i是否有k-i3） 计数以上索引和返回计数/2，因为我们正在对H（i）和H（k-i）进行计数

请查看代码并告诉我你认为代码不会产生正确的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;
}