京东2018秋招编程题

1.神奇数

将一个数n的各数位分成两部分，两部分之和相等，则称这个数为神奇数。比如242分成[2,2]、[4]。输入一个范围[l,
r]，输出这个范围内神奇数的个数。

• 第一种解法,使用回溯法

  采用回溯法进行递归搜索

#include <iostream>
#include <vector>
#include <algorithm>
#include<windows.h>
using namespace std;

long min_num=0,max_num=0;
long l;

bool opt(int a,int b){
    return a<b;
}

bool recall(vector<int> vec,int l,int pos,int sum){
    for(int i=pos;i<vec.size();i++){
        l+=vec[i];  
        if(l==sum){
            return true;
        }
        if( recall(vec,l,i+1,sum) ){
            return true;
        }
        if(l>sum){
            l-=vec[i];
            return false;
        }
        l-=vec[i];
    }
    return false;
} 

bool get_digits_recall(long i){
    vector<int> vec;
    long m=i;
    int sum=0;  
    int digit;
    while(m>0){
        if(m<10) {
            vec.push_back(m);
            sum+=m;
            break;
        }
        digit = m%10;
        sum+=digit;
        if(digit>0) 
            vec.push_back(digit);
        m/=10;
    }

    if(sum&1) return false; 
    l=0;
    sort(vec.begin(),vec.end(),opt);

    return recall(vec,l,0,sum>>1);
}

int strange_number(){
    if(max_num<11) return 0;
    int cnt=0;
    for(long i=min_num;i<max_num;i++){
        if(get_digits_recall(i)){
            cnt++;
        }
    } 
    return cnt;
}

int main(int argc, char const *argv[])
{
    cin>>min_num>>max_num;

    DWORD start_time=GetTickCount();

    cout<<strange_number(); 

    DWORD end_time=GetTickCount();
    cout<<"\nThe run time is:"<<(end_time-start_time)<<"ms!"<<endl;//输出运行时间

    return 0;
}

• 第二种解法,使用动态规划

判断一个数是否是神奇数，首先应该获取其各个数位{a1, a2, a3, a4,
…}，按照神奇数的定义，需要将数位分成两部分，且两部分元素和相等，因此所有数位的和sum{a1, a2, a3, a4,
…}必为偶数。如果不是偶数，则必然不是神奇数。 因此，这个问题就演变成，在{a1, a2, a3, a4,
…}中寻找一个子集，使得sum{子集} = sum/2。 显然，这是一个0-1背包问题。可以用回溯法、动态规划。
这里使用动态规划，用dp[i][j]表示子数组{a1, a2, a3, a4,…, ai}的元素和是否等于j。 初始dp[i][0] =
true （所有元素都不选，和为j） 如果不选择第i个元素，则dp[i][j] = dp[i-1][j]
如果选择第i个元素，则dp[i][j] = dp[i-1][j-num[i]] 因此，dp[i][j] = dp[i-1][j] ||
dp[i-1][j-num[i]]。 dp[n][newSum]即表示是否可以找到一个子集，其元素和为sum/2。

#include <iostream>
#include <vector>
#include<windows.h>
using namespace std;
int l=0,r=0;

//动态规划
bool canPartition(vector<int>&dicts,int n,int sum)  //n代表vector的非零位数 
{
    vector<vector<bool>> dp(n+1,vector<bool>(sum+1,false));
    for(int i=0; i<=n; i++)
        dp[i][0] = true;
    for(int j=1; j<=sum; j++){
        for(int i=1; i<=n; i++){
            dp[i][j] = dp[i-1][j]; //不选第i个元素
            if(j>=dicts[i-1])      //选第i个元素
                dp[i][j] = dp[i-1][j] || dp[i-1][j-dicts[i-1]];
        }
    }

    for(int i=0;i<n;i++)
        cout<<dicts[i]<<" ";
    cout<<endl;
    for(int j=0; j<=sum; j++){
        for(int i=0; i<=n; i++){
            cout<<"dp["<<i<<"]["<<j<<"]="<<dp[i][j]<<" ";
        }
        cout<<endl;
    }

    return dp[n][sum];
}

bool isSqs(int num) 
{
    vector<int> dicts(10,0);
    int k=0,sum=0;
    while(num!=0){
        dicts[k++] = num%10;
        num /= 10;
        sum += dicts[k-1];
    }
    if(sum & 1)
        return false;
    return canPartition(dicts,k,sum>>1);    //sum>>1表示除以2 
}

int sqs()
{
    if(r<11)
        return 0;
    int cnt = 0;
    for(int i=l; i<=r; i++){    //依次对每一个数进行测试 
        if(isSqs(i))
            cnt++;
    }
    return cnt;
}

int main()
{
    cin>>l>>r;

    DWORD start_time=GetTickCount();

    cout<<sqs();

    DWORD end_time=GetTickCount();
    cout<<"The run time is:"<<(end_time-start_time)<<"ms!"<<endl;//输出运行时间
    return 0;
}

2.疯狂的序列

有一个无限数列，{1，2，2，3，3，3，4，4，4，4，…}，数字n在数列中出现n次，且是连续的。输入一个整数x，输出序列的第x项的数字。x的范围为[1,10^18]。

可以看出是数字n的最后一个n的位置是序列中的第n*(n+1)/2项.

1. 使用for循环,但是会超时

2. 根据 (n+1)*n/2 = x , 得到n^2+n-2x=0 , 解得n=sqrt(1+8x)-1

#include <iostream>
#include <math.h>

using namespace std;

int main(){
    long i;
    cin>>i;
    double x = (sqrt((double)(1+8*i))-1)/2;
        cout<<ceil(x)<<endl;//向上取整
    return 0;
}