网易游戏20180908题目

小A在一个程序的输出中犯了错误，由于忘记输出空格，他把一个正整数N的X进制和Y进制表示连在了一起输出，得到了一个无法识别的数字。
请你帮他恢复这个正整数N；

输入描述：

输入的第一行是一个正整数T(0<T<=100),表示有T个测试节点，对于每个样例，输入为X,YZ,其中X和Y为进制（2<=x,y<=16）,z是一个字符串，长度不超过62，表示正整数N（0<N<2^31-1）的X进制和Y进制连在一起的形式，10到15分别用大写A到F表示。数据保证一定有一解。

 

输入：
3
5 2 113221101000101
13 7 1016
4 12 2222248A
输出：
837
13
682

暴力破解：

#include<iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

int main(){
    int T;
    cin>>T;
    vector<int>result;
    while(T){
        T--;
       int jinzhi1,jinzhi2; string s;
       cin>>jinzhi1>>jinzhi2;{
           cin>>s;
       }
       int len =s.length();
        for(int i=1;i<len;i++){
            string s1=s.substr(0,i);
            string s2 =s.substr(i,len-i);
            int sum1=0,sum2=0;
            for(int j=0;j<s1.length();j++){
                sum1*=jinzhi1;
                if(isdigit(s1[j])){
                    sum1+=s1[j]-'0';
                }
                if(isalpha(s1[j])){
                    sum1+=s1[j]-'A'+10;
                }
            }
            for(int j=0;j<s2.length();j++){
                sum2*=jinzhi2;
                if(isdigit(s2[j])){
                    sum2+=s2[j]-'0';
                }
                if(isalpha(s2[j])){
                    sum2+=s2[j]-'A'+10;
                }
            }
            if(sum1==sum2){
                result.push_back(sum1);
                break;
            }
        }
    }
    for(int i:result){
        cout<<i<<endl;
    }
    return 0;
}

 

马上又到了一年一度的网易校招了，HR找到了小Y，告诉他要开始准备今年的机考题目了。小Y和小伙伴们日以继夜，废寝忘食地处好了N道题目，并给每道题目打了难度1-5，同时给每道题目标记了相应的tag（一道题可以有多个tag），表示这道题目所考察的知识点。

由于机考时间有限，小Y需要从N道题目中挑选M道题目组成最终的考卷，为了挑选合适的同学，并且使得题目具有一定的区分度，同时考察的知识面尽量广，这M道题目还需要满足下列条件：

1.所有M道题目的总难度不超过指定的值L。

2.所有M道题目的考察点没有重复，即Tag没有重复。

3.为了具备区分度，难度最低的题目相比难度最高的题目的难度差不低于S。

小Y想知道满足上述条件的总方案数有多少种，你能告诉他吗？

 

输入：
2
5 2 5 1
1 2 string dfs
1 1 heap
2 1 dfs
3 2 math search
4 1 dp
5 2 5 0
1 2 string dfs
1 1 heap
2 1 dfs
3 2 math search
4 1 dp
输出：
6
7

还是暴力破解，但是样例能过 提交通过0%很奇怪希望大家给点建议。

#include<iostream>
#include <vector>
#include <string>
#include <set>
using namespace std;
int max(int a,int b){
    return a>b?a:b;
};
int min(int a,int b){
    return a<b?a:b;
};
int main(){
    int T;

    while(cin>>T){vector<int>result_v;
    while(T)
    {
        int N,M,L,S,temp,result=0;
        cin>>N>>M>>L>>S;
        string temps;
        vector<pair<int,int>> timu=vector<pair<int,int>>(N);
        vector<vector<string>> shuxin=vector<vector<string>>(N);
        for(int i  =0;i<N;i++){
            cin>>temp;
            timu[i].first=temp;
            cin>>temp;
            timu[i].second=temp;
            for(int j=0;j<temp;j++){
                cin>>temps;
                shuxin[i].push_back(temps);
            }
        }
        set<string>settemp;
        int sum=0,Min,Max;
        result=0;


        for(int i = 0; i <N*N; ++i){
            bool flag=true;
            settemp.clear();
            sum=0,Min=L,Max=0;
            int tempi=i;
            int count=0;
            for (int j =0;j<N;j++){
                int index;
                index=tempi%2;
                tempi/=2;
                if(index)
                    count++;
            }
            if(count!=M)
                continue;
            tempi=i;
            for (int j =0;j<N;j++) {
                int qianyigesize=settemp.size();
                int houyigesize;
                int index;
                index=tempi%2;
                tempi/=2;
                if (index){
                    Max=max(Max,timu[j].first);
                    Min=min(Min,timu[j].first);
                    for (int k = 0; k < shuxin[j].size(); k++) {
                        settemp.insert(shuxin[j][k]);
                    }
                    houyigesize=settemp.size();
                    if(qianyigesize+shuxin[j].size()!=houyigesize){
                        flag= false;
                        break;
                    }

                    sum+=timu[j].first;
                    if (sum>L)
                    {
                        flag= false;
                        break;
                    }
                }

            }
            if(flag){
                if(Max-Min>=S)
                {
                    result++;}
            }
        }
        result_v.push_back(result);
        T--;
        }
        for(int i:result_v)
        {
        cout<<i<<endl;
        }
    }
    return 0;
}