拼多多内推编程题

1\给定一个无序数组，包含正数、负数和0，要求从中找出3个数的乘积，使得乘积最大，要求时间复杂度：O(n)，空间复杂度：O(1) 

输入描述:

无序整数数组A[n]

输出描述:

满足条件的最大乘积

输入例子1:

3 4 1 2

输出例子1:

24

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int main()
{
  // int x=807120253114;
    int n=0;
    int_least64_t top1,top2,top3,least1,least2;
    int_least64_t a[10000]={0};
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
  //  printf("%d\n",n);
  top1=least1=a[0];
   for(int i=0;i<n;i++)
   {
       if(a[i]>top1)
       {
           top1=a[i];
       }
       if(a[i]<least1)
       {
           least1=a[i];
       }
   }
   int64_t max2=1000000;
   int64_t min2=1000000;
   for(int i=0;i<n;i++)
   {
       if(abs(top1-a[i])<max2&&top1>a[i])
       {
           top2=a[i];
           max2=abs(a[i]-top1);
       }
       if(abs(least1-a[i])<min2&&least1<a[i])
       {
           least2=a[i];
           min2=abs(a[i]-least1);
       }
   }
   int64_t max3=1000000;
   for(int i=0;i<n;i++)
   {
       if(abs(a[i]-top2)<max3&&a[i]<top2)
            {top3=a[i];
            max3=abs(a[i]-top2);
            }
   }
  // cout<<top1<<" "<<top2<<" "<<top3<<endl;
 // cout<<least1<<" "<<least2<<endl;
   int64_t x=top1*top2*top3;
   int64_t y=top1*least1*least2;
   cout<< (x>y?x:y);
    return 0;
}

2\有两个用字符串表示的非常大的大整数,算出他们的乘积，也是用字符串表示。不能用系统自带的大整数类型。 

输入描述:

空格分隔的两个字符串，代表输入的两个大整数

输出描述:

输入的乘积，用字符串表示

输入例子1:

72106547548473106236 982161082972751393

输出例子1:

70820244829634538040848656466105986748

#include <iostream>
#include <string>
#include <vector>
#include <stdlib.h>
#include <assert.h>
using namespace std;
void reverse_data( string &data);//字符串反转
void compute_value( string lhs,string rhs,string &result );
void reverse_data( string &data)
{
    char temp = '0';
    int start=0;
    int end=data.size()-1;
    assert( data.size()&& start <= end );
    while ( start < end )
    {
        temp = data[start];
        data[start++] = data[end];
        data[end--] = temp;
    }
}
void compute_value( string lhs,string rhs,string &result )
{
    reverse_data(lhs);
    reverse_data(rhs);
    int i = 0, j = 0, res_i = 0;
    int tmp_i = 0;
    int carry = 0;

    for ( i = 0; i!=lhs.size(); ++i, ++tmp_i )
    {
        res_i = tmp_i;  //在每次计算时，结果存储的位需要增加
        for ( j = 0; j!= rhs.size(); ++j )
        {
            carry += ( result[res_i] - '0' )+(lhs[i] - '0') * (rhs[j] - '0');//此处注意，每次计算并不能保证以前计算结果的进位都消除， 并且以前的计算结果也需考虑。
            result[res_i++] = ( carry % 10 + '0' );
            carry /= 10;
        }
        while (carry)//乘数的一次计算完成，可能存在有的进位没有处理
        {
            result[res_i++] = (carry % 10 + '0');
            carry /= 10;
        }
    }
    for (int i=result.size()-1;i>=0;i--)
    {
        if (result[i]!='0')
            break;
        else
            result.pop_back();
    }
        reverse_data(result);
}
int main()
{
    string a,b;
    cin>>a>>b;
    string result(a.size()+b.size(),'0');
    compute_value(a,b,result);
    cout<<result<<endl;
 //   system("pause");
    return 0;
}

3六一儿童节，老师带了很多好吃的巧克力到幼儿园。每块巧克力j的重量为w[j]，对于每个小朋友i，当他分到的巧克力大小达到h[i] (即w[j]>=h[i])，他才会上去表演节目。老师的目标是将巧克力分发给孩子们，使得最多的小孩上台表演。可以保证每个w[i]> 0且不能将多块巧克力分给一个孩子或将一块分给多个孩子。 

输入描述:

第一行：n，表示h数组元素个数
 第二行：n个h数组元素
 第三行：m，表示w数组元素个数
 第四行：m个w数组元素

输出描述:

上台表演学生人数

输入例子1:

3 
 2 2 3
 2
 3 1 

输出例子1:

1

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool cop(int a,int b)
{
    return a>b;
}
int main()
{
    int n,m,count=0;
    vector<int> vn,vm;
    cin>>n;
    while(n>0)
    {
        int temp;
        cin>>temp;
        vn.push_back(temp);
        n--;
    }
    cin>>m;
    while(m>0)
    {
        int temp;
        cin>>temp;
        vm.push_back(temp);
        m--;
    }
    sort(vn.begin(),vn.end(),cop);
    sort(vm.begin(),vm.end(),cop);
    for(int i=0;i<vm.size();i++)
    {
        for(int j=0;j<vn.size();j++){
        if(vm[i]>=vn[j])
        {
            count++;
            vn[j]=1000000;
            break;
        }
        }
    }
    cout<<count;
    return 0;
}

4假设一个探险家被困在了地底的迷宫之中，要从当前位置开始找到一条通往迷宫出口的路径。迷宫可以用一个二维矩阵组成，有的部分是墙，有的部分是路。迷宫之中有的路上还有门，每扇门都在迷宫的某个地方有与之匹配的钥匙，只有先拿到钥匙才能打开门。请设计一个算法，帮助探险家找到脱困的最短路径。如前所述，迷宫是通过一个二维矩阵表示的，每个元素的值的含义如下 0-墙，1-路，2-探险家的起始位置，3-迷宫的出口，大写字母-门，小写字母-对应大写字母所代表的门的钥匙 

输入描述:

迷宫的地图，用二维矩阵表示。第一行是表示矩阵的行数和列数M和N
后面的M行是矩阵的数据，每一行对应与矩阵的一行（中间没有空格）。M和N都不超过100, 门不超过10扇。

输出描述:

路径的长度，是一个整数

输入例子1:

5 5
02111
01a0A
01003
01001
01111

输出例子1:

7

#include<stdio.h>
#include<queue>
#include<string.h>
#include<vector>
using namespace std;
char G[105][105];
int book[105][105][1200],N,M;
int Next[4][2]={0,1,0,-1,1,0,-1,0};
int bfs(int,int);
struct node{
    int x,y,k,step;
    node(int x,int y,int k,int step):x(x),y(y),k(k),step(step){}
};
int main(){
    int i,j;
    //freopen("input.txt","r",stdin);
    while(scanf("%d%d",&N,&M)!=EOF){
        for(i=0;i<N;i++) scanf("%s",G[i]);
        memset(book,0,sizeof(book));
        int flag=0;
        for(i=0;i<N;i++){
            if(flag==1) break;
            for(j=0;j<M;j++)
                if(G[i][j]=='2'){
                    flag=1;
                    book[i][j][0]=1;
                    printf("%d\n",bfs(i,j));
                    break;
                }
        }
    }
}

//BFS遍历，增加钥匙状态，由二维变成三维
int bfs(int startX,int startY){
    queue<node> Q;
    Q.push(node(startX,startY,0,0));
    while(!Q.empty()){
        node head=Q.front();Q.pop();
        if(G[head.x][head.y]=='3') return head.step;
        for(int i=0;i<4;i++){
            int nx=head.x+Next[i][0],ny=head.y+Next[i][1];
            if(nx>=N||nx<0||ny>=M||ny<0||G[nx][ny]=='0') continue;
            int key=head.k;
            if('a'<=G[nx][ny]&&G[nx][ny]<='z') key=key|(1<<(G[nx][ny]-'a'));             //记录钥匙状态(0左移变成1）
            if('A'<=G[nx][ny]&&G[nx][ny]<='Z'&&(key&(1<<(G[nx][ny]-'A')))==0) continue; //钥匙和门不匹配
            if(!book[nx][ny][key]){
                book[nx][ny][key]=1;
                Q.push(node(nx,ny,key,head.step+1));
            }
        }
    }
    return 0;
}//这题就是普通的bfs多了‘钥匙’这个状态
 //所以book[x][y][key]的意义就是 横坐标为x,纵坐标为y,钥匙状态为key的点是否访问过
 //钥匙的状态 就用二进制数表示 最多10 把钥匙 那就是1024